Imprima o alfabeto quatro vezes

37

O programa deve imprimir o alfabeto quatro vezes: primeiro na ordem alfabética normal, segundo na ordem de um teclado qwerty, terceiro na ordem de um teclado dvorak e, finalmente, na ordem alfabética inversa. A saída deve se parecer com isso:

abcdefghijklmnopqrstuvwxyz
qwertyuiopasdfghjklzxcvbnm
pyfgcrlaoeuidhtnsqjkxbmwvz
zyxwvutsrqponmlkjihgfedcba

A saída não diferencia maiúsculas de minúsculas e você pode adicionar ou omitir novas linhas ou espaços onde desejar.

O problema : o programa deve ter menos de 104 caracteres ou, em outras palavras, menor que o comprimento do alfabeto multiplicado por quatro.

Aceitarei a resposta com o código mais curto, a menos que veja algo realmente inteligente ou interessante com o qual estou mais impressionado.

EDIT: Aceitarei a resposta mais curta na quarta-feira, 27/04/2011.

EDIT2: E o vencedor é (como sempre) Golfscript em 64 caracteres! O segundo lugar , atrás apenas de três caracteres, também está em Golfscript, com 67 caracteres, seguido por Bash em terceiro lugar com 72 caracteres.

Mas havia alguns outros que eu queria mencionar, como este , que, dependendo da sua definição, usava apenas 52 "caracteres", e este onde ele o escreveu em um idioma criado por ele.

Havia algumas pessoas que quebrou uma regra não escrita e não se qualificam, mas vou mencioná-los apenas para a sua maneira de pensar sem a caixa.

Peter Olson
fonte
11
Considere usar uma recompensa para uma resposta que o impressionou. Eu acho que aceitar uma resposta em um código-golfe sempre deve ser o critério natural (ou seja, comprimento).
Joey
Eu perdi usando Tcl: tio.run/…
sergiol

Respostas:

16

Python 2, 97 caracteres

q="qwertyuiopasdfghjklzxcvbnm"
a="".join(sorted(q))
print a,q,"pyfgcrlaoeuidhtnsqjkxbmwvz",a[::-1]

Classificar QWERTY e converter de volta da lista em string é mais curto que o próprio alfabeto! *

Outra opção para gerar o alfabeto em menos caracteres que o próprio alfabeto:

print map(chr,range(65,91))

Embora isso imprima uma lista de caracteres Python.

Não há muito a ser feito aqui no caminho da compactação de dados; encravar as letras em 5 bits salva apenas 39 caracteres, o que não é muito se você precisar desimpedi-las (e ainda precisar representar os bytes literalmente); parece que o zlib (apenas como exemplo) salva menos de 20 bytes; codificar a sequência como uma lista de deltas para a próxima letra ainda leva 5 bits para cada delta, porque o maior nessa sequência é -22:

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
 1, 1, 1, 1, 1, 1, 1, -9, 6, -18, 13, 2, 5, -4, -12, 6, 
 1, -15, 18, -15, 2, 1, 2, 1, 14, -2, -21, 19, -20, 12, 
 -1, 3, 9, -19, 1, -4, 15, -6, -11, 14, -10, 16, -12, -5, 
 4, 12, -6, 5, -2, -7, 1, 13, -22, 11, 10, -1, 4, 0, -1, 
 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]

* Embora apenas um pouco.

Josh Caswell
fonte
11
Python 3.5:q="qwertyuiopasdfghjklzxcvbnm";a=sorted(q);print(*a,q,"pyfgcrlaoeuidhtnsqjkxbmwvz",*a[::-1])
Veedrac 23/03
15

PHP, 100 bytes

Conforme ISO 8859-1:

<?=base64_encode("i·yø!9%z)ª»-ºü1Ë:°z»rº*)jÇ_ä<\½¹æ§'àr¹Z¡ë¢vg²¨äŹ°¿<òÇî¶Êê¦æHâÞuÆÚ");

Para reproduzir de forma confiável,

printf '<?=base64_encode("' > 4times.php
printf abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba | base64 -d >> 4times.php
printf '");' > 4times.php
Ry-
fonte
5
Essa é uma maneira interessante de fazer isso. Todos os outros são variações da mesma idéia, mas essa é um pouco diferente.
31811 Peter Olson
Eu não acho que isso deve contar; a pergunta está marcada como "complexidade de Kolmogorov" e especifica "104 caracteres", o que significa que devemos discriminar o que consideramos um personagem. Caso contrário, definirei minha própria codificação de caracteres com um único caractere que mapeia para o ASCII um programa inteiro que resolve o problema e, em seguida, decodificá-lo.
Adrian Petrescu
2
@Adrian Petrescu: isso é facilmente resolvido exigindo que a codificação já exista no momento em que o desafio é colocado.
precisa saber é o seguinte
@ Lowjacker Claro, mas isso parece ser uma maneira bastante arbitrária de resolver isso.
Adrian Petrescu
5
@ Adrian, A vantagem do unicode ao usar caracteres vs bytes é reconhecida há muito tempo. Na minha opinião, não faz sentido que a pergunta seja marcada como Kolmogorov enquanto solicita caracteres. Deve estar contando bytes. Cabe à pessoa que faz a pergunta ter cuidado com esses termos.
gnibbler
10

Rubi 1.9, 88 87 84 80

puts b=[*?a..?z],:qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz,b.reverse
Lowjacker
fonte
10

Bash, 82

echo {a..z}
echo qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz
echo {z..a}
Roger Spencer
fonte
9

Python, 97 96 "caracteres"

Usando o uso da palavra "caracteres" liberalmente, aqui está um python que usa caracteres unicode de 16 bits para codificar 3 caracteres normais cada. O programa tem um total de 96 caracteres, 35 dos quais são os caracteres unicode mais estranhos que eu já vi.

for i in range(104):print chr((ord(u'ࠠᒃ⃦ⵉ��割廕��匓�เ᳅ⵉૹ�懬ࣅű傎ᱨ�⤰〷�弙劶��ⶍKᓇࡤ^A'[i/3])>>i%3*5&31)+97),

Não tenho certeza se o lixo unicode virá corretamente, então aqui está um programa python para gerar o programa python acima:

#!/usr/bin/python                                                                                                                                                                 
import codecs
f=codecs.open('alpha.py','w','utf-8')
f.write('#!/usr/bin/python\n')
f.write('# coding=utf-8\n')
f.write('for i in range(104):print chr((ord(u\"')
S='''abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcbaa'''
for i in xrange(0,104,3):
 n=32*32*(ord(S[i+2])-97)+32*(ord(S[i+1])-97)+ord(S[i+0])-97
 f.write(u'%c'%n)
f.write('"[i/3])>>i%3*5&31)+97),\n')
Keith Randall
fonte
9

Bash, 72

echo {a..z} qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz {z..a}

EDIT: removido tr -d.

Créditos: Alexander, Roger.

asoundmove
fonte
2
Regras permitem que você omitir |tr -d ' ', economizando 10 caracteres e fazer esta versão um líder no momento da escrita :-)
Alexander Gladysh
@ Alexander, Cool ;-) não sabia disso. Graças a @Roger, por me apontar na direção certa.
asoundmove
Eu estava tentando encontrar uma solução mais elegante com algum tipo de polinômio com poderes de números primos e módulos (ou, em outras palavras, encontrar uma função de permutação bastante simples que funcione nessa sequência) ... mas não posso passar o tempo necessário para essa solução, então deixarei assim. Além disso, seria muito difícil expressar de forma concisa.
asoundmove
9

Golfscript, 64 caracteres

"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz".$2%\1$-1%

Nota: também 64 bytes. Na verdade, jogar com as mudanças de base e Unicode parece contraproducente, porque baseé uma palavra-chave muito longa.

Peter Taylor
fonte
6

Windows PowerShell, 89

Não é particularmente bom, mas pelo menos mais curto que a sequência de saída:

[char[]](65..90)
'qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz'
[char[]](90..65))

Muito menor agora que vi que há um relaxamento no espaço em branco. E um pouco mais baixo ainda, se eu ignorar o caso que me é permitido.

Joey
fonte
2
Você tem um extra )lá. Deve ser 88.
Iszi
5

Golfscript, 76 , 67 caracteres

123,97>+."qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"\-1%
VOCÊS
fonte
Use 123,97>+para gerar o alfabeto inicial.
Ventero
Obrigado Ventero, eu realmente vi isso no seu outro post no outro dia.
VOCÊ
4

CI - 92 caracteres

'a(1p'z((,0(4d)(.$)<)$)(0c0c.1+2p$.)>)$)qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz

O CI ("Compilador / Intérprete") é uma linguagem simples baseada em pilha que criei para o desafio "Autointerpretação de intérpretes" ( link para resposta ). Publiquei essa resposta cerca de duas horas antes do lançamento deste desafio. Não é um GolfScript (que ainda não aprendi a aprender), pois meu objetivo era tornar o intérprete curto.

Este programa deve ser passado para o ci intérprete através da entrada padrão. O intérprete trata os caracteres após o término )como entrada para o programa. Meu idioma não suporta literais de string, então o stdin está tomando seu lugar.

Joey Adams
fonte
3

Python 2.7.X - 103 caracteres ironicamente ...

a='abcdefghijklmnopqrstuvwxyz'
print a,'qwertyuiopasdfghjklzxcvbnm pyfgcrlaoeuidhtnsqjkxbmwvz',a[::-1]

Como se vê, gerar o alfabeto em python requer mais caracteres do que codificá-lo. Assim como a importação do alfabeto. Às vezes é preciso amar uma linguagem centrada na legibilidade.

arrdem
fonte
11
Você não precisa do espaço entre as seqüências QWERTY e DVORAK, seria 1 caractere a menos.
Lowjacker
true, mas o python anexa automaticamente um espaço entre cada item da lista de impressão separada por vírgula, portanto, o espaço é meu sacrifício pessoal para alterar a saída legível.
arrdem
Você pode usar o em +vez de ,e economizar esse espaço.
Martin Ueding
3

C - 133 caracteres

Versão abreviada de Casey:

main(i){char a[105];strcpy(a+26,"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz");for(i=0;i<26;)a[i]=a[103-i]=i+++65;puts(a);}

Espaços em branco:

main(i) {
    char a[105];
    strcpy(a+26, "qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz");
    for(i=0;i<26;)
        a[i]=a[103-i]=i+++65;
    puts(a);
}

Saída transposta

Aqui está uma versão que transpõe a saída, por diversão. 134 caracteres.

main(i){char*a="qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz";for(i=0;i<26;i++,a++)printf("%c%c%c%c\n",i+65,*a,*(a+25),90-i);}

Espaços em branco:

main(i){
  char*a="qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz";
  for(i=0;i<26;i++,a++)
    printf("%c%c%c%c\n",i+65,*a,*(a+25),90-i);
}

Impressões:

AqmZ
BwpY
CeyX
DrfW
EtgV
FycU
GurT
HilS
IoaR
JpoQ
KaeP
LsuO
MdiN
NfdM
OghL
PhtK
QjnJ
RksI
SlqH
TzjG
UxkF
VcxE
WvbD
XbmC
YnwB
ZmvA
Alexander Gladysh
fonte
Ainda não se encaixa, é claro.
Alexander Gladysh
11
declarando icomo global e colocando strcpy(...)no primeiro bloco do loop for, você recebe 129. ainda demais.
bebe
3

J

x=:(97+/i.26){a.
x
261329910883437428257896643x A.x
247073478763191548160234722x A.x
(_1+/-i.26){x

Minha primeira experiência com J. A idéia é simplesmente usar o número canônico (lexicográfico) da permutação necessária; infelizmente, isso requer mais caracteres do que codificá-lo. Mas se alguém pudesse encontrar alguma expressão aritmética (usando poderes e outros enfeites) produzindo os números mágicos, ela poderia ser reduzida.

Villemoes
fonte
261329910883437428257896643 possui a fatoração primária 7 * 601 * 991 * 213987797 * 292923318887, portanto, não há poderes neste.
Jerry Jeremiah
3

Python, 90 caracteres unicode

#coding:u8
print u"扡摣晥桧橩汫湭灯牱瑳癵硷穹睱牥祴極灯獡晤桧歪穬捸扶浮祰杦牣慬敯極桤湴煳歪扸睭究祺睸當獴煲潰浮歬楪杨敦捤慢".encode("u16")[2:]

execute em ideone - http://ideone.com/R2dlI ou codepad - http://codepad.org/lp77NL9w

VOCÊS
fonte
2
Na verdade, ele possui apenas 52 "caracteres".
31811 Peter Olson
3

Javascript 139 121

Novo:

q='qwertyuiopasdfghjklzxcvbnm'
a=q.split('').sort()
alert(a.join('')+q+'pyfgcrlaoeuidhtnsqjkxbmwvz'+a.reverse().join(''))

velho:

a=[]
a[26]='qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz'
for(i=0;i<26;i++)a[i]=a[52-i]=String.fromCharCode(i+65)
alert(a.join(''))
Neil McGuigan
fonte
Você também pode ter 121 com:alert((a=(q='qwertyuiopasdfghjklzxcvbnm').split('').sort()).join('')+q+'pyfgcrlaoeuidhtnsqjkxbmwvz'+a.reverse().join(''))
WallyWest
2

Lua - 111 caracteres

Bate C e C ++! :-)

print'abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba'

Versão "inteligente" em Lua

129 caracteres

q='qwertyuiopasdfghjklzxcvbnm'a={q:byte(1,-1)}table.sort(a)a=q.char(unpack(a))print(a,q,'pyfgcrlaoeuidhtnsqjkxbmwvz',a:reverse())

Espaços em branco:

q='qwertyuiopasdfghjklzxcvbnm'
a={q:byte(1,-1)}
table.sort(a)
a=q.char(unpack(a))
print(a,q,'pyfgcrlaoeuidhtnsqjkxbmwvz',a:reverse())
Alexander Gladysh
fonte
2

C - 163 135 caracteres

Isso não atende aos requisitos, pois possui mais de 104 caracteres, mas foi divertido de fazer. Talvez alguém tenha algumas sugestões.

main(i){char a[105];strcpy(&a[26],"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz");for(i=0;i<26;)a[i]=a[103-i]=i+++65;puts(a);}

Isso é compilado no GCC 4.5.1 (outros não testados). Yay por omitir #includes, tipos de retorno e declarações de variáveis! A codificação física resultaria em um programa mais curto, mas isso não é divertido.

Versão em espaço em branco:

main(i) {                                                                                   
    char a[105];                                                                        
    strcpy(&a[26], "qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz");                 
    for(i=0;i<26;)                                                                          
        a[i]=a[103-i]=i+++65;                                                               
    puts(a);                                                                                
}

C - 124 122 coxo

Aqui está a versão codificada lame, e ainda não faz o corte.

main(){puts("abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba");}
Casey
fonte
Em puts()vez disso, use printf no segundo caso - 2 caracteres a menos.
precisa saber é o seguinte
E substitua whilepor puts(a);no primeiro caso, deixando cair *p=a; - 138 caracteres em vez de 163.
Alexander Gladysh 23/04
Sugestões impressionantes! Eu tinha esquecido totalmente puts. Changed.
Casey #
2

PHP 88 bytes

<?=$a=join(range(a,z)),~Žˆš‹†Š–žŒ›™˜—•”“…‡œ‰‘’†™˜œ“žšŠ–›—‹‘ŒŽ•”‡’ˆ‰…,strrev($a);
echofish
fonte
2

J - 69 char

'pyfgcrlaoeuidhtnsqjkxbmwvz'(,~|.)&(,\:~)'mnbvcxzlkjhgfdsapoiuytrewq'

Explicação:

  • (,\:~) y- Classifique yem ordem decrescente ( \:~) e acrescente ( ,) isso a y.

  • x (,~|.) y- Inverta ( |.) ye anexe-o à frente de x.

  • x F&G y- Executar (G y) F (G y), ou seja, executar Fos resultados da aplicação Gaos argumentos.

Então, todos juntos, anexamos o alfabeto, ao contrário, às cordas Dvorak e QWERTY reversa, depois invertemos a QWERTY / alfabeto e colocamos na frente da Dvorak / alfabeto.

algoritmshark
fonte
2

Bash, 64

Estou muito atrasado para a festa, mas tenho uma solução de 64 caracteres. O programa precisa ser salvo no disco para funcionar

echo {a..z} $(sed 1d $0|base64) {z..a};exit
««·+¢¢–¬uø!ŽIsÅËÛžjr~+•ªº'a¶{*ŽL[›ó

Como funciona:

{a..z}e {z..a}são bastante auto-explicativos, mas basicamente isso apenas imprime todos os caracteres desse intervalo.

$(sed 1d $0|base64) gera o programa, ignora a primeira linha e passa-o através de um codificador base64 (como outros exemplos fizeram).

O motivo é mais curto que outros exemplos semelhantes ...

... é porque os {a..z}intervalos são mais curtos que as codificações base64, então eu só preciso codificar base64 metade da string. E como estou lendo os dados binários do arquivo, em vez de armazená-los em uma string, não preciso escapar de nenhum caractere no código.

Como recriar este script:

Se o código não copiar / colar corretamente do Stack Exchange para o seu editor de texto, execute o seguinte na linha de comando (independente de shell):

echo 'echo {a..z} $(sed 1d $0|base64) {z..a};exit' > alphabetgolf
echo 'qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz' | base64 -d >> alphabetgolf

Então, para executar:

bash alphabetgolf
Laurence
fonte
2

05AB1E , 25 bytes

AžW.•8t”a$äJÚ₁вƒüu¯Cê•AR»

Experimente online!

Explicação

A                          # Push alphabet                    
 žW                        # Push qwerty string
   .•8t”a$äJÚ₁вƒüu¯Cê•     # Push compressed dvorak string
                      AR   # Push reversed alphabet
                         » # Join entire stack with newlines
Wisław
fonte
1

C ++

É meio triste quando a maneira mais curta de fazer algo em um idioma é codificá-lo.

#include <iostream>

int main()
{
 std::cout<<"abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba";
}
John
fonte
Você não precisa emitir os feeds de linha.
Lowjacker
@ Low: Doh! Esqueci de removê-las quando fiz as quebras de linha e percebi que não precisava. Obrigado por apontar isso.
John
Essa é uma solução muito óbvia e supera o requisito de comprimento máximo.
Peter Olson
std::couté mais curto using namespace stde você pode pular void.
Alexander Gladysh
@ Alex: Obrigado por apontar isso.
John
1

J (77)

(,|.@(26&{.))(,~/:~@(26&{.))'qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz'

Raspou 3 caracteres usando uma variável:

(,|.@a)(,~/:~@(a=.26&{.))'qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz'

Raspou mais 2 caracteres usando uma abordagem de nível de valor:

(|.a),~t,~a=./:~26{.t=.'qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz'
Gregory Higley
fonte
1

Haskell (95)

main=putStr$['a'..'z']++"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"++['z','y'..'a']

Perl (51)

Não existe uma regra que diga que não posso.

use LWP::Simple;print get("http://bit.ly/fGkflf");
marinus
fonte
11
Veja a lista de brechas padrão .
boboquack
1

Q (68)

.Q.a,"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz",(|:).Q.a

Saídas:

"abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfg     
crlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba"

Tentou encontrar uma melhoria na codificação embutida nos dois do meio, mas não apresentou um.

sinedcm
fonte
1

K - 69 char

b,a,|b:a@<26#a:"qwertyuiopasdfghjklzxcvbnmpyfgcrlaeouidhtnsqjkxbmwvz"

Explicação:

  • 26#a:- Atribua os dois layouts de teclado ae, em seguida, pegue os 26 primeiros caracteres.

  • b:a@<- Classificar ae atribuir isso a b: <fornece a permutação para uma classificação crescente e @permite indexar apara classificá-la.

  • b,a,|- Anexe em uma linha e b, em seguida a, inverta ( |) de b.

algoritmshark
fonte
1

Pyth, 57

G"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"VG

Alfabeto, string, alfabeto invertido. G é o alfabeto. A impressão está implícita.

isaacg
fonte
1

Dyalog APL , 60 bytes

⎕A'QWERTYUIOPASDFGHJKLZXCVBNMPYFGCRLAOEUIDHTNSQJKXBMWVZ',⌽⎕A

Impressões:

  ABCDEFGHIJKLMNOPQRSTUVWXYZ  QWERTYUIOPASDFGHJKLZXCVBNMPYFGCRLAOEUIDHTNSQJKXBMWVZ ZYXWVUTSRQPONMLKJIHGFEDCBA

O que é permitido de acordo com o OP:

A saída não diferencia maiúsculas de minúsculas e você pode adicionar ou omitir novas linhas ou espaços onde desejar.

Adão
fonte
1

Gelatina, 36 bytes (não concorrente)

Øa;Øq;“pyfgcrlaoeuidhtnsqjkxbmwvz”;U

Experimente online!

Explicação:

Øa;Øq;“pyfgcrlaoeuidhtnsqjkxbmwvz”;U    |
Øa;                                     | alphabet
   Øq;                                  | list with all rows of the qwerty keyboard
      “pyfgcrlaoeuidhtnsqjkxbmwvz”;     | string
                                   U    | reverse
acrólito
fonte
1

05AB1E , 60 59 bytes

AÂ"qwertyuiopasdfghjklzxcvbnm""pyfgcrlaoeuidhtnsqjkxbmwvz"»

Experimente online!

- empurra o alfabeto bifurcado.

"qwertyuiopasdfghjklzxcvbnm""pyfgcrlaoeuidhtnsqjkxbmwvz" - Empurra qwerty e drovak.

» - Imprime a pilha.

05AB1E , 57 bytes (se você não se importa com aleatório \ n)

AÂ"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"»

Experimente online!

Urna de polvo mágico
fonte
No primeiro exemplo, você pode salvar um byte, substituindo-o ""por uma nova linha.
Neil A.