Imprimir todas as palavras de 2 letras Scrabble


40

O desafio:

Imprima cada palavra de duas letras aceitável no Scrabble usando o mínimo de bytes possível. Eu criei uma lista de arquivos de texto aqui . Veja também abaixo. Existem 101 palavras. Nenhuma palavra começa com C ou V. Soluções criativas, mesmo que não sejam ótimas, são incentivadas.

AA
AB
AD
...
ZA

Regras:

  • As palavras produzidas devem ser separadas de alguma forma.
  • O caso não importa, mas deve ser consistente.
  • Espaços à direita e novas linhas são permitidos. Nenhum outro caractere deve ser produzido.
  • O programa não deve receber nenhuma entrada. Recursos externos (dicionários) não podem ser usados.
  • Sem brechas padrão.

Lista de palavras:

AA AB AD AE AG AH AI AL AM AN AR AS AT AW AX AY 
BA BE BI BO BY 
DE DO 
ED EF EH EL EM EN ER ES ET EX 
FA FE 
GO 
HA HE HI HM HO 
ID IF IN IS IT 
JO 
KA KI 
LA LI LO 
MA ME MI MM MO MU MY 
NA NE NO NU 
OD OE OF OH OI OM ON OP OR OS OW OX OY 
PA PE PI 
QI 
RE 
SH SI SO 
TA TI TO 
UH UM UN UP US UT 
WE WO 
XI XU 
YA YE YO 
ZA

8
As palavras precisam ser exibidas na mesma ordem?
SP3000

2
@ SP3000 eu vou dizer não, se algo interessante pode ser pensado
QWR

2
Esclareça o que exatamente conta como separado de alguma forma . Tem que ser um espaço em branco? Em caso afirmativo, seriam permitidos espaços sem quebra?
Dennis

5
Ok, encontrou uma tradução
Mikey Mouse

3
Vi não é uma palavra? Notícias para mim ...
jmoreno

Respostas:


39

Python 3, 194 188 bytes

s="BI ODEXIF BAAX ASOHER LOXUMOPAGOR KI US AMY BOITONOSI MMEMINANEHI UPI AYAHOYOWOMUNUHAID PEFARED QIS BEN JOFETAE KAT ABYESHMALI UTI ZADOELAWE "
while s:" "in s[:2]or print(s[:2]);s=s[1:]

Definitivamente, não é o método mais curto, mas achei que seria um bom começo. Tente agrupar cada par em caminhos, sobrepondo o máximo possível (por exemplo, "ODEX..."= ["OD", "DE", "EX", ...]). Os espaços são usados ​​para separar caminhos e quaisquer pares com um espaço são removidos (o espaço à direita é para impedir que um único Eseja impresso no final).

Eu também tentei regex golf isso, mas foi mais longo.


11
+1 boa abordagem! Eu pedi seu string para uma resposta de Ruby
daniero

Fiz também uma resposta com base em sua idéia usando bash e regex
sergioFC

2
+1 para AYAHOYOWOMUNUHAID!
Level River St

28

CJam, 96 94 bytes

0000000: 31 30 31 2c 22 5a 0a d0 fd 64 f6 07 a3 81 30 f2  101,"Z...d....0.
0000010: c2 a5 60 0c 59 0f 14 3c 01 dd d1 69 7d 66 47 6e  ..`.Y..<...i}fGn
0000020: db 54 e5 8f 85 97 de b9 79 11 35 34 21 cb 26 c3  .T......y.54!.&.
0000030: f0 36 41 2b b4 51 fb 98 48 fc cb 52 75 1f 1d b1  .6A+.Q..H..Ru...
0000040: 6b c3 0c d9 0f 22 32 36 30 62 33 36 62 66 7b 3c  k...."260b36bf{<
0000050: 31 62 32 35 6d 64 2d 35 35 7d 27 41 66 2b        1b25md-55}'Af+

O acima é um hexdump, que pode ser revertido com xxd -r -c 16 -g 1.

Experimente online no intérprete CJam .

Dependendo do que exatamente conta como separado , a contagem de bytes pode ser reduzida para 93 ou mesmo 92 :

  • Se substituirmos -55por 59, as palavras serão separadas por espaços sem quebra (0xA0).

  • Se substituirmos -55por W, as palavras serão separadas por arroba (0x40).

Idéia

Podemos codificar cada par de letras xy como (ord (x) - 65) × 25 + (ord (y) - 65) . 1

Em vez de armazenar os números inteiros resultantes, armazenaremos as diferenças de todos os pares que correspondem a duas palavras adjacentes (classificadas em ordem alfabética).

A diferença mais alta é 35 , portanto, consideramos os dígitos do número inteiro base 36 e convertemos esse número inteiro em uma sequência de bytes.

Código

101,   e# Push [0 ... 100].
"…"    e# Push the string that encodes the differences/increments.
260b   e# Convert from base 260 to integer.
36b    e# Convert from integer to base 36 (array).
f{     e# For each I in [0 ... 100]:
       e#   Push the base 36 array.
  <    e#   Keep it's first I elements.
  1b   e#   Compute their sum.
  25md e#   Push quotient and residue of the sum's division by 25.
  -55  e#   Push -55 = '\n' - 'A'.
}      e#
'Af+   e# Add 'A' to all resulting integers. This casts to Character.

1 Como a segunda letra nunca é um Z , usar 25 em vez de 26 é suficiente.


14

PHP 224, 218, 210 206

foreach(explode(",","I19SR,9ZY8H,,CNK,5JRU0,H,CN4,G0H,H160,CN4,75,CU9,AMIHD,MTQP,HQOXK,7L,74,G,CXS,CU9,HTOG,,CNK,MHA8,CNL,1")as$a){$b++;for($c=0;$c<26;$c++)echo base_convert($a,36,10)&pow(2,$c)?chr(96+$b).chr(97+$c)." ":"";}
aa ab ad ae ag ah ai al am an ar as at aw ax ay ba be bi bo by de do ed ef eh el em en er es et ex fa fe go ha he hi hm ho id if in is it jo ka ki la li lo ma me mi mm mo mu my na ne no nu od oe of oh oi om on op or os ow ox oy pa pe pi qi re sh si so ta ti to uh um un up us ut we wo xi xu ya ye yo za 

Definitivamente não é uma ótima pontuação, mas gostei do desafio.

Eu crio uma tabela de opções, criei um sistema bit a bit para sinalizar quais opções são válidas.

insira a descrição da imagem aqui

Então eu codifiquei a base-36 para obter a string:

"I19SR,9ZY8H,,CNK,5JRU0,H,CN4,G0H,H160,CN4,75,CU9,AMIHD,MTQP,HQOXK,7L,74,G,CXS,CU9,HTOG,,CNK,MHA8,CNL,1"

Observe que a terceira entrada nessa matriz de cadeias não tem um valor, porque C não tem opções.

Para imprimir os valores, basta converter as opções válidas em caracteres.

Pode haver algo que eu possa fazer para reduzir o reconhecimento de que não há palavras terminadas em C, J, K, Q, V ou Z, mas não consigo pensar em um método para reduzi-lo em ATM.


Ao transpor a tabela, há mais elementos vazios e os dados codificam um pouco mais compactamente, o que reduz alguns bytes. A matriz agora é impressa em uma ordem diferente:

foreach(explode(",","UB1YB,1,,CUP,CLMEJ,CUO,1,SG0H,5J9MR,,,H,MX01,MTXT,CYO5M,MTQ8,,CNL,MTXT,MHAP,50268,,CN5,CNL,FSZ,,")as$a){$b++;for($c=0;$c<26;$c++)echo base_convert($a,36,10)&pow(2,$c)?chr(97+$c).chr(96+$b)." ":"";} 

aa ba fa ha ka la ma na pa ta ya za ab ad ed id od ae be de fe he me ne oe pe re we ye ef if of ag ah eh oh sh uh ai bi hi ki li mi oi pi qi si ti xi al el am em hm mm om um an en in on un bo do go ho jo lo mo no so to wo yo op up ar er or as es is os us at et it ut mu nu xu aw ow ax ex ox ay by my oy

Obrigado a Ismael pela explosão e pelas dicas de loop.

foreach(explode(3,UB1YB3133CUP3CLMEJ3CUO313SG0H35J9MR333H3MX013MTXT3CYO5M3MTQ833CNL3MTXT3MHAP35026833CN53CNL3FSZ)as$d)for($e++,$f=0;$f<26;$f++)echo base_convert($d,36,10)&pow(2,$f)?chr(97+$f).chr(96+$e)." ":"";

Com uma atualização para php5.6, pow(,)pode ser substituído **salvando outros 4 bytes.

foreach(explode(3,UB1YB3133CUP3CLMEJ3CUO313SG0H35J9MR333H3MX013MTXT3CYO5M3MTQ833CNL3MTXT3MHAP35026833CN53CNL3FSZ)as$d)for($e++,$f=0;$f<26;$f++)echo base_convert($d,36,10)&2**$f?chr(97+$f).chr(96+$e)." ":"";

Em vez de explodir por ",", você pode usarexplode(0,UB1YB0100CUP[...])
Ismael Miguel

Isso não seria interrompido, pois existem 0s na codificação?
James Webster

No entanto .. não há um que 3eu possa usar isso! Graças
James Webster

Além disso, você pode substituir $e++;for($f=0;$f<26;$f++)por for($e++,$f=0;$f<26;$f++), e agora você pode removê-los {}. E se você deseja converter caracteres em minúsculas, use $e^' '.
Ismael Miguel

Boa pegada! Eu não teria esse.
James Webster

8

Perl, 167 164 157 bytes

"AMAEDOXUHALAXISHENUNUPABEFAHIDEMYESOHOSITAAGOYAYAWOWETOINODOREX KIFEHMMER BYONELI BOEMUS PELOMI UMOFAD BATAR KANAS JOPI UTI ZAI BI QI"=~/$_/&&say for AA..ZZ

Escreva um script separado para agrupar as letras o mais compacto possível em uma sequência que contenha todas as palavras válidas de 2 letras. Isso então itera sobre todas as duas palavras da letra e imprime as válidas, uma por linha. Corra com perl -M5.10.1 script.pl.


Não consigo fazer isso funcionar em um compilador online.
Mbomb007

@ mbomb007 Dependendo da versão, você precisa do sinalizador da linha de comando -M5.10.1para usar a saypalavra - chave adicionada nessa versão ou adicionar use feature 'say';no corpo do script.
precisa saber é o seguinte

7

C, 155 bytes

Versão Golfed

i,v;main(){for(;++i-408;" >b  Ùc :oÒ¹ i ;¹ w so@)ia ¥g¨¸ ´k¦ase    Ù{§k {"[i/8]>>i%8&1||printf("%c%c%c ",i/8%2*v,i/16+65,!(i/8%2)*v))v="YUOIEMHA"[i%8];}

Saída

YA HA AA BY BO BI BE BA AB DO DE OD ID ED AD YE OE HE AE FE FA OF IF EF GO AG UH OH EH AH OI HI AI JO KI KA LO LI LA EL AL MY MU MO MI ME MM MA UM OM EM HM AM NU NO NE NA UN ON IN EN AN YO HO PI PE PA UP OP QI RE OR ER AR SO SI SH US OS IS ES AS TO TI TA UT IT ET AT WO WE OW AW XU XI OX EX AX OY AY ZA

Versão ungolfed

A seqüência mágica de 51 bytes na versão golfed contém muitos caracteres além do ASCII 126, que quase certamente foram transformados em equivalentes Unicode. A versão ungolfed usa hex em vez disso, e como uma constante e não como literal. Além disso, a versão ungolfed separa as palavras com uma nova linha, o que facilita copiar e colar no Excel, ordenar a lista e comparar com a necessária.

char a[]=
{0xFF,0x3E ,0x62,0x7F ,0xFF,0xFF ,0xEB,0x63 ,0xFF,0x3A ,0x6F,0xE3 ,0xFB,0x7F ,0xFF,0x69 ,0xFF,0x3B
,0xFB,0xFF ,0x77,0xFF ,0x73,0x6F ,0x40,0x29 ,0x69,0x61 ,0xFF,0xBE ,0x67,0xF9 ,0xF7,0xFF ,0xEF,0x6B
,0xB3,0x61 ,0x73,0x65 ,0xFF,0xFF ,0xFF,0xFF ,0xEB,0x7B ,0xF5,0x6B ,0xFF,0x7B ,0x7F};

//iterate through i = 16*letter + 8*order + vowel
i,v;main(){for(;i++-408;a[i/8]>>i%8&1||printf("%c%c%c\n",i/8%2*v,i/16+65,!(i/8%2)*v))v="YUOIEMHA"[i%8];}

Explicação

Se expandirmos a definição de vogal para incluir as 8 letras AHMEIOUY, observaremos que todas as palavras consistem em uma vogal e outra (que pode ou não ser uma vogal.) Portanto, para todas as palavras que terminam em vogal, precisa de uma tabela de 26 bytes, uma para cada primeira letra, com os bits individuais correspondentes à vogal. Precisamos de uma tabela semelhante para as palavras que começam com uma vogal, exceto que desta vez precisamos apenas de 25 bytes, pois não há palavras que terminem em Z. As duas tabelas são reunidas para criar a mesa final.

Para evitar códigos ASCII na região 0..31, as duas "vogais" M e H menos comuns são atribuídas ao 6º e 7º bits, e a codificação considera 1 para uma palavra inválida e 0 para uma palavra válida. Como não há consoante que emparelhe com M e H, é possível garantir que pelo menos um desses bits seja 1.

O oitavo bit é atribuído a A, que é a vogal mais comum, para tentar limitar os caracteres não-ASCII (ainda existem muitos deles).

As tabelas usadas estão abaixo. Para palavras contendo 2 vogais, priorizei a primeira letra como sendo considerada a "vogal" e a segunda letra como a "letra". Uma exceção a isso são as palavras que começam com M, pois evitam conflitos entre MM e HM.

Codificação hexadecimal de palavras que começam com uma vogal

3E 7F FF 63 3A E3 7F 69 3B FF FF 6F 29 61 BE F9 FF 6B 61 65 FF FF 7B 6B 7B

AA AB    AD AE    AG AH AI       AL AM AN          AR AS AT       AW AX AY 
HA          HE          HI          HM    HO 

         ED    EF    EH          EL EM EN          ER ES ET          EX 
         ID    IF                      IN             IS IT 
         OD OE OF    OH OI          OM ON     OP   OR OS          OW OX OY 
                     UH             UM UN     UP       US UT 
YA          YE                            YO 

Codificação hexadecimal de palavras que terminam com uma vogal

 A  H  M  E  I  O  U  Y
                         FF
BA       BE BI BO    BY  62
                         FF 
         DE    DO        EB
                         FF
FA       FE              6F
               GO        FB
                         FF
                         FF
               JO        FB
KA          KI           77
LA          LI LO        73
MA    MM ME MI MO MU MY  40
NA       NE    NO NU     69
                         FF
PA       PE PI           67
            QI           F7
         RE              EF
    SH      SI  SO       B3
TA          TI  TO       73
                         FF
                         FF
         WE     WO       EB
            XI     XU    F5
                         FF
ZA                       7F

Talvez fazer uma hexdump da versão golfed para que o mangling pode ser revertido facilmente
masterX244

7

Java, 484 448 407 391 389 bytes

Minha primeira tentativa

public static void main(String[]a){int[]x={57569742,35784706,0,2099200,5534148,35651584,2048,35792896,5247168,2048,33685504,33687552,35794978,35653664,7746958,35782656,131072,2097152,395264,33687552,551296,0,2099200,131104,35653632,33554432};for(Integer i=0;i<26;i++){for(int z=0;z<26;z++){if("".format("%26s",i.toString(x[i],2)).charAt(z)=='1'){System.out.format("%c%c ",'A'+i,'A'+z);}}}}

Formatado:

public static void main(String[] a) {
    int[] x = { 57569742, 35784706, 0, 2099200, 5534148, 35651584, 2048, 35792896, 5247168, 2048, 33685504, 33687552, 35794978, 35653664,
            7746958, 35782656, 131072, 2097152, 395264, 33687552, 551296, 0, 2099200, 131104, 35653632, 33554432 };
    for (Integer i = 0; i < 26; i++) {
        for (int z = 0; z < 26; z++) {
            if ("".format("%26s", i.toString(x[i], 2)).charAt(z) == '1') {
                System.out.format("%c%c ", 'A' + i, 'A' + z);
            }
        }
    }
}

Experimente online


Bom trabalho! Algumas sugestões: java.lang.Exception pode ser chamado apenas de exceção. "args" pode ser apenas "a". String.format () pode ser "" .format (). Há também um pouco de espaçamento extra na declaração main (). Abordagem agradável em geral, porém, +1 de mim :)
jrich

Acabei de brincar com a declaração impressa, mas você me venceu! Você pode salvar outro byte, substituindo-o \npor apenas um espaço. Eles não precisam ser separados por novas linhas.
James Webster

Você também perdeu alguns espaços que você pode remover.
James Webster

@JamesWebster thx para as dicas.
griFlo

4
"".formatÉ doloroso de se olhar, mas hilário.
Codebreaker

6

Ruby, 166 bytes

Emprestando o puro método do sp3000 para codificar as palavras em uma sequência compacta. O kicker aqui é o método curto para decodificá-lo de volta para as palavras de duas letras: Usar um lookahead no regex passado para o método de varredura de String para extrair correspondências sobrepostas, sem ocupar espaço:

puts "BI ODEXIF BAAX ASOHER LOXUMOPAGOR KI US AMY BOITONOSI MMEMINANEHI UPI AYAHOYOWOMUNUHAID PEFARED QIS BEN JOFETAE KAT ABYESHMALI UTI ZADOELAWE".scan /(?=(\w\w))/

Ruby, 179 bytes

Minha própria abordagem: gere todas as palavras de duas letras entre AAe ZAe selecione as válidas usando uma máscara de bits codificada em base 36:

i=-1
puts ("AA".."ZA").select{|w|"djmsjr5pfw2omzrfgydo01w2cykswsrjaiwj9f2moklc7okcn4u2uxyjenr7o3ub90fk7ipdq16dyttg8qdxajdthd6i0dk8zlmn5cmdkczrg0xxk6lzie1i45mod7".to_i(36)[i+=1]>0}

6

Matlab, 177 bytes

Gere uma matriz binária definindo todos os pares de letras permitidos, reformule-a e codifique-base-64. A string codificada na base 64 ( 'CR+ ... % ') é usada como dados no programa. O programa reverte as operações para descompactar a matriz e depois lê os pares permitidos:

x=de2bi('CR+"''        1$$ L*\"%$!! !   $!04P@<W(        0$   1"%$$100@RZP4  $$    0$ ! 1$$$$1 0  P (    $ 0 0$ ! # %  '-32)';[i,j]=find(reshape(x(1:650),26,[])');char([j i]+64)

2
Luis agradável! Golfe é realmente divertido ... = P
Stewie Griffin

11
Agradável! Não há alfabeto!
Cérebro Guider

11
Tiramos o chapéu. Este é o código Matlab enigmática mais tenho visto em idades ...
Hoki

Obrigado rapazes! É apenas enigmático por causa da codificação base-64. Essa seqüência realmente embala a matriz 26x25 binário de pares de letras permitidos
Luis Mendo

6

Malbolge , 2118 bytes

D'``_#>nI||38h6/vdtO*)_^mI7)"XWfB#z@Q=`<)\xwvuWm32ponmfN+ibJfe^$\[`Y}@VUySXQPUNSLpJINMLEiC+G@EDCB;_?>=}|492765.R210p(-,+*#G'&feB"baw=u]sxq7Xnsrkjoh.fNdchgf_%]\a`Y^W{>=YXWPOsSRQ3OHMLKJIBfF('C<`#"8=<;:3W1w5.R2+q/('&J$)"'~D$#"baw=utsxq7Xnsrkjoh.fNdchgf_%c\D`_X|\>=YXWPOsSRQ3OHMLKJIBfFEDC%$@9]=6|:32V6/.3210)M-m+$)"'&%|Bcb~w|u;yxwvuWm3kpinmfe+ihgfH%cb[ZY}]?UZYRWVOs65KPIHGkKJIH*)?c&BA@?8\6|:32V6/.3210)M-,lk)"F&feBzbxw=uzyrwpon4Ukpi/mfkdc)g`ed]#DZ_^]VzZ<;QPt7MLQPOHlFEJIHAe(>C<;_?>765:981Uv.32+*)Mnm%$)(!Efe{zy?}|{zyxqpo5mrkpoh.fNdihg`ed]#DZ_^]Vz=YRQuUTMqQ32NMLEDhHG@(>C<;_?>76;:3W76v43,+O/.nm+*)"Fgf${z@a}v{zyr8vo5Vrqj0nmfN+Lhg`_%cbDCY}@VUySRWPt76Lp3ONMLEDhHG@(>C<;_"8\6|:32V0v.Rs10/.'&+$H('&feB"!x>|^]srwvun4Ukpi/gfe+Lbaf_%cE[`Y}@?[TxRWPUNMLKo2NGFjD,BAeED&<A:^>=6|:32V6v.R21*/(L,+*#"!E}|{z@xw|{t:[qpotsrk1Rhmlkd*Kgfe^$bDZ_^]VzZ<;QuUTMqKJOHGkEJCBA@dD=<;:^>=6|:32V654t,+O).',+*#G'&feBzbx>|^]yr8vXnsrkjoh.fkdcbg`&^Fba`Y^WVzZ<XWPUTMqQ3INMFjD,BAe?>=B;_9>7<54X8765u-Q10)o'&J$)"!~%${A!x}v<]\xwpun4rTpoh.leMchgf_d]#DZ_^]VzZYR:Pt7SLKPOHlFEJIHAeED&<`@"87<5Y98165.3,P*/(-&+$H(!~}C#c!x}|u;\[wvun4lTjih.fN+Lbgfe^c\"CY}@VUyYXWPOsSRKJIHlLE-IBAeE'&<`@"87<5Y98165.3,Pq/.-,+*#G'&fe#"!x>|{zyr8Yotml2ponPlkdcb(fH%]\[`Y^W{zZ<XWPUTMq4JIHMLEi,BA@d>=B;:9]7};:3W7wv.3,+O)o'&J*)('g%${Ay~}v{zyrq7otmrqpoh.fejiha'eG]\[ZY}@VUy<;WVOsSRQPImM/KJIBAe(>=aA:^>=6|:32V65u-Qr0/.'K+$j"'~De#zy~wv<]yrqpo5srkjohg-kdib(feG]b[Z~^]\UTYRvP8TSRKJIHlLKD,BAe?>=B;_?>7<;:981U54t,+O)o'&Jkj('&}C#"bx>_{tyr8vuWVl2pihgle+ihgfH%cEDZ~XWVUy<XWPUTMqQP2NGLEiCBGF?>b%A@?87[;:zy1U54t210/.'K+$j"'~De#zy~wv<zyxwp6Wmlqpohg-kdib(feG]ba`Y^W{>=YXWPOs65KJIHl/KJIBA@dDCB;:9]=<;:zy1Uvu3,P0)o'&J$#(!~D|#"y?}v{zyr8vXnml2ponPledc)gfH%c\D`_^]VzZ<;QVOTSLpPIHGkKJCBG@dD=<;:^>=6|:32Vw543,+*N.nm+*)"F&feB"y~}|{ts9qvonsl2ponmfN+Lha`e^$\[Z_X|\UTYRQVOsM5KJOHGFjD,BA@d>=B;:9]=};4X81w5.R210)o'&J$j"'~%|{"y?w_u;y[wpun4Ukponmfe+Lha'eGc\[!B^WV[TxXQ9ONrRQ32NMLEDh+AeE'&<`#"8=<;:3W7wv.3,+O/.'m+*)(!EfeBcbx>_{tsxwvun4Ukpi/POkdcha'_d]#DZ_^]VzZ<RQPUNMqQ3ONGkE-IBAeED=BA:9]=<|43870/St,+O/.-ml*)(!Ef|Bcb~w|u;y[Zvun4rTpoh.fN+cKgf_%cE[!BXWV[ZSwWP8TSLpJIHMLEJIBf)d'=aA@">=<5Y98165.3,Pq)('K%*#"!EfeBcyxwvu;yxwvuWm3~

Experimente online!


5

Bash, 179 bytes

echo U`sed -r 's/./& &/g'<<<HAABADEDOEFAEHELAGOFEMAHINAISHMENERESITALOHOMMONOPAMUMYAWETOSOWOYOXUNUPEXI`F `grep -o ..<<<ANARASATAXAYBEBIBOBYJOKAKILIMIOIDOIDORPIQITIUSUTYEZA`
  • Guardado 7 bytes graças ao comentário de Adam Katz

Ele usa sedpara fazer a substituição do regex. A primeira entrada de regex é baseada na ideia do Sp3000, enquanto a segunda regex usa entrada comum sem espaços.

Explicação:

echo              print to standard output the following
U                 boundary U character
sed -r [etc]      the result of replacing regex
    .             select a character
    & &           replace it for: matched char, space, matched char
    g             do it globaly for every character
    <<<HAAB[etc]  string input based on Sp3000 idea => HA AA AB ...
F                 boundary F character
sed -r [etc]      the result of replacing regex
    ..            every two characters
    <space>&      for space+matched character
    g             do it globally
    <<<ANAR       normal input => AN AR ...

11
Você pode reduzir isso em sete bytes usando um espaço e, `grep -o ..em vez de `sed -r 's/ / &/g', um truque da minha resposta abaixo.
Adam Katz

5

Atenção, esta resposta não é programaticamente interessante.

Como todas as palavras têm dois caracteres, podemos agrupá-las e separá-las novamente usando uma expressão regular simples.

Qualquer idioma compatível com regex pode fazer isso, alguns com mais eficiência do que outros:

Grep (via Bash), 215 bytes

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

Javascript, 224 bytes

alert("AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA".match(/../g))

Perl, 225 bytes

 $_="AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA";s/../$&\n/g;print

Python, 245 bytes

import re
print re.sub(r'..','\g<0>\n',"AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA")

 


Como observação, algumas das respostas aqui são mais longas do echoque eu consideraria uma linha de base:

Shell POSIX, 307 bytes

echo AA AB AD AE AG AH AI AL AM AN AR AS AT AW AX AY BA BE BI BO BY DE DO ED EF EH EL EM EN ER ES ET EX FA FE GO HA HE HI HM HO ID IF IN IS IT JO KA KI LA LI LO MA ME MI MM MO MU MY NA NE NO NU OD OE OF OH OI OM ON OP OR OS OW OX OY PA PE PI QI RE SH SI SO TA TI TO UH UM UN UP US UT WE WO XI XU YA YE YO ZA

3
+1 por ser prático. Realmente, fornecer o eco base é o ponto em que todos devem começar.
metalim

+1 em resposta fácil, mas você deve marcar isso como não concorrente, não?
precisa saber é o seguinte

@ MatthewRoh - Se houvesse um analisador no quadro de líderes, provavelmente não conseguiria encontrar nada, pois eu intencionalmente não comecei com um cabeçalho. Não estou preocupado, principalmente porque há respostas mais curtas para todos os idiomas que publiquei.
Adam Katz

3

C - 228 217 bytes - CCG

 _;main(){char *z,*i="AABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EOU IEO A A ";for(z=i;_++^26;)for(;*++z^32;putchar(_+64),putchar(*z),puts(""));}

Será atualizado se eu puder diminuí-lo, basta compilar com as saídas gcc -w, ./a.out perfeitamente. Se houver algum interesse em um não-destruído, me avise.

Não consigo pensar em nenhuma maneira de reduzi-lo do topo da minha cabeça (você pode remover tecnicamente as aspas em put e você ainda obterá uma resposta correta, a saída se parece com lixo), por favor, avise-me de qualquer maneira para encurtá-lo


Aqui estão algumas sugestões: ele funciona bem para mim (não apenas copie e cole, a troca de pilhas insere caracteres de controle estranhos nos comentários) _;main(){char*z="AABDEGHILMNRSTWXY AEIOY EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST EOU IEO A A ";for(;_++^26;)for(;*++z^32;printf("%c%c ",_+64,*z));}Alterei o delimitador de saída de uma nova linha para um espaço, mas se você preferir uma nova linha (uma byte extra) altere a sequência de caracteres do formato printf para"%c%c\n"
Level River St

3

C #, 348 bytes

Eu tentei:

using System;class A{static void Main(){var a=new System.Collections.BitArray(Convert.FromBase64String("tnOciwgCCAAAAAggAFBxHIkAAAAACICIKABQQBgAAAIgIACAgCAAIqIgigCCADfWuIgAAAACAIAAAAAwCICAIAAAYRkAAAAAAggAgAAIIoAACA=="));int c, d;for(var i=0;i<652;i++){if(a[i]){c=Math.DivRem(i,26,out d);Console.Write("{0}{1} ",(char)('A' + c),(char)('@' + d));}}}}

Ungolfed:

using System;

class A
{
    static void Main()
    {
        var a = new System.Collections.BitArray(Convert.FromBase64String(
            "tnOciwgCCAAAAAggAFBxHIkAAAAACICIKABQQBgAAAIgIACAgCAAIqIgigCCADfWuIgAAAACAI" + 
            "AAAAAwCICAIAAAYRkAAAAAAggAgAAIIoAACA=="));
        int c, d; 
        for(var i = 0; i < 652; i++)
        {
            if(a[i])
            {
                c = Math.DivRem(i, 26, out d);
                Console.Write("{0}{1} ", (char)('A' + c), (char)('@' + d));
            }
        }
    }
}

4
Este é um desafio do codegolf, portanto, você deve postar sua contagem de bytes (comprimento do seu código). Também tente encurtar um pouco, por exemplo, removendo o espaço em branco.
Jakube

@Jakube, isso é melhor?
Jodrell

Sim, parece ok
Jakube 13/08/2015

3

Pitão , 140 bytes

K"aeiou"=H+-G+K\zKL.[`Z25.Bib32jdSfTs.e.e?nZ`0+@Gk@HY""byMc"ljjns 1u  a 6jji0 o 2 100u 60hg0 2 k m 101v r 6hr7c s 4 8 g006 m hpg0  a 5 q g"d

Experimente online!

Método de compressão: como não existe Zna segunda posição de nenhuma palavra, use o alfabeto reordenado bcdfghjklmnpqrstvwxyaeioupara codificar a validade de cada uma dessas letras como uma segunda letra para cada primeira letra (as primeiras letras estão em ordem alfabética).
São 25 bits por letra ou exatamente 5 dígitos da Base 32. Como a maioria das consoantes só usa vogais como segunda letra, coloquei vogais no final para obter principalmente números de um dígito para elas. Tenho certeza de que, em geral, poderia ser melhorado com mais análises e reordenações do alfabeto, embora a definição do alfabeto reordenado ocupasse mais bytes.

Explicação

K"aeiou"=H+-G+K\zK # Define the reordered alphabet
K"aeiou"           # K := "aeiou"
        =H         # H :=
           -G      #      G.removeAll(
             +K\z  #                   K + "z" 
          +      K #                           ) + K

L.[`Z25.Bib32      # Define a lambda function for decompression
L                  # y = lambda b:
         ib32      # convert b to int using Base 32
       .B          # convert to binary string
 .[`Z25            # pad to the left with "0" to the nearest multiple of 25 in length

                           c"..."d # split the compressed string on " "
                         yM        # Apply y (above lambda) to each element
                                   #   Intermediate result: List of binary strings
                                   #   with 1s for allowed combinations
      .e                           # map over ^ lambda b (current element), k (current index):
        .e              b          # map over b: lambda Z (cur. elem.), Y (cur. ind.):
               +@Gk@HY             # G[k] + H[Y] (G is the regular alphabet)
          ?nZ`0       ""           #     if Z != "0" else ""
     s                             # combine into one large list
   fT                              # remove all falsy values (empty strings)
  S                                # sort (if any order is possible, remove this)
jd                                 # join on spaces (if a normal list with the words is
                                   #   allowed, remove this)

2

PHP: 211 209 204

Você precisa desativar os avisos, caso contrário, um será impresso com relação à criação implícita de $b

for($a=65;$b<strlen($c="ABDEGHILMNRSTWXY!AEIOY!EO!DFHLMNRSTX!AE!O!AEIMO!DFNST!O!AI!AIO!AEIMOUY!AEOU!DEFHIMNPRSWXY!AEI!I!E!HIO!AIO!HMNPST!EO!IU!AEO!A");$b++)if($c[$b]!='!')echo chr($a).$c[$b].' ';else$a++;

Muito divertido. As primeiras tentativas foram na faixa de 250, mas este é o meu mais fino ainda.


2
Experimente este contador de bytes . Note que desligar contagem espaço em branco é incorreto, uma vez que também desconta nenhum espaço que você tem em cordas, para que a sua pontuação deve ser superior a 186.
SP3000

Boa pegada. Atualizei minha submissão de acordo.
NickW

Eu não posso ver porque .. mas isso agora só imprime "AAAA A ..."
James Webster

Você eliminou !o se ... você precisava disso.
James Webster

Direita. Eu só notei isso. Eu estava usando! delimitador anteriormente e eu fiz uma substituição rápida de localização sem considerar o que aconteceria primeiro.
NickW

2

CJam (99 bytes)

Isso inclui alguns caracteres especiais, portanto, é mais seguro fornecer um hexdump. (Em particular, o personagem com valor 0xa0, correspondente a um espaço ininterrupto, me causou alguns problemas na configuração da demonstração online).

00000000  36 37 36 22 c4 b2 2d 51  3f 04 93 5c 64 6c 8d 6e  |676"..-Q?..\dl.n|
00000010  d7 f9 7d 97 29 aa 43 ef  04 41 12 e1 aa ce 12 4d  |..}.).C..A.....M|
00000020  05 f3 1c 2b 73 43 a0 f0  41 c0 a7 33 24 06 37 a3  |...+sC..A..3$.7.|
00000030  83 96 57 69 9b 91 c4 09  c3 93 e1 ed 05 3b 84 55  |..Wi.........;.U|
00000040  d9 26 fd 47 68 22 32 35  36 62 33 38 62 7b 31 24  |.&.Gh"256b38b{1$|
00000050  2b 7d 2f 5d 7b 32 36 62  28 3b 36 35 66 2b 3a 63  |+}/]{26b(;65f+:c|
00000060  4e 7d 2f                                          |N}/|
00000063

Demonstração online .

A abordagem é codificação de diferenças na base-26.


Adicionar um caractere a um número inteiro gera um caractere, para que você possa substituir 65f+:cpor 'Af+.
Dennis

Verdade. E mdé uma melhoria brilhante, mas eu não tinha percebido o quão perto minha resposta está da sua.
Peter Taylor

2

CJam, 100 98 bytes

'A'@" ©Ô&ñ±ð¨9_AÚá¼thÁätÑû¨HÙH&J3p¼ÛèVçckùá%´}xà41"260bGb{_{+N2$2$}{;;)'@}?}%-3<

(link permanente)

  • Salva dois bytes via variáveis ​​pré-inicializadas (obrigado Dennis!)

Esta é a minha primeira entrada no CJam, então provavelmente existe o potencial para um pouco mais de golfe. No entanto, criei uma maneira de compactar a lista de caracteres para 63 bytes, o que, espero, alguém achará útil.

Método de compressão

Até agora, a maioria dos métodos que eu vi codificava as duas letras de cada palavra. No entanto, quando colocamos as palavras em ordem alfabética, a primeira letra não muda com muita frequência, por isso parece um desperdício codificá-la explicitamente.

Eu codifico apenas o último caractere de cada palavra e incluo um item especial sempre que o primeiro caractere deve aumentar. Os caracteres são codificados como o primeiro caractere e, em seguida, uma lista de diferenças. Como não há palavras duplicadas, todas as diferenças devem ser pelo menos 1. Assim, eu posso usar 0como um item separador. (Observe que devo armazenar a primeira letra de cada subsequência como um indexado, caso contrário haveria confusão entre 'primeiro caractere de substituição 0' e 'iniciar com A 0'.)

Como as diferenças nesse caso nunca são maiores que 15, podemos usar a base 16 e empacotar dois itens (4 bits) em cada byte (8 bits). (No código real, converti da base 260 em vez da base 256 para evitar problemas com caracteres não imprimíveis.)


Você pode salvar alguns bytes usando Ge N, que pressiona 16 e um avanço de linha.
Dennis

@ Dennis Obrigado, não percebeu que as variáveis ​​foram pré-inicializadas!
usar o seguinte código

11
Todas as 26 letras maiúsculas são variáveis ​​pré-inicializadas. Você pode ver a lista completa aqui .
Dennis

Você pode salvar mais bytes substituindo %-3<por /;;ou mesmo /&. (A segunda opção irá gerar uma mensagem de erro. Consenso sobre meta é que é OK para fazer isso.)
Dennis

2

brainfuck , 1371 bytes

Bastante jogável, mas não me esforcei muito.

>+[+[<]>>+<+]>[-<<+<+>>>]-[-[-<]>>+<]>-[-<<<<+>>>>]<<<<<<..>>.<<.>+.>.<<.>++.>.<
<.>+.>.<<.>++.>.<<.>+.>.<<.>+.>.<<.>+++.>.<<.>+.>.<<.>+.>.<<.>++++.>.<<.>+.>.<<.
>+.>.<<.>+++.>.<<.>+.>.<<.>+.>.<------------------------<+.>.>.<<.>++++.>.<<.>++
++.>.<<.>++++++.>.<<.>++++++++++.>.<--------------------<++.>.>.<<.>++++++++++.>
.<-----------<+.>.>.<<.>++.>.<<.>++.>.<<.>++++.>.<<.>+.>.<<.>+.>.<<.>++++.>.<<.>
+.>.<<.>+.>.<<.>++++.>.<-----------------------<+.>.>.<<.>++++.>.<<+.>++++++++++
.>.<--------------<+.>.>.<<.>++++.>.<<.>++++.>.<<.>++++.>.<<.>++.>.<-----------<
+.>.>.<<.>++.>.<<.>++++++++.>.<<.>+++++.>.<<.>+.>.<-----<+.>.>.<--------------<+
.>.>.<<.>++++++++.>.<--------<+.>.>.<<.>++++++++.>.<<.>+.>.<---------<+.>.>.<<.>
++++.>.<<.>++++.>.<<.>++++.>.<<.>++.>.<<.>++++++.>.<<.>++++.>.<-----------------
-------<+.>.>.<<.>++++.>.<<.>++++++++++.>.<<.>++++++.>.<-----------------<+.>.>.
<<.>+.>.<<.>+.>.<<.>++.>.<<.>+.>.<<.>++++.>.<<.>+.>.<<.>++.>.<<.>++.>.<<.>+.>.<<
.>++++.>.<<.>+.>.<<.>+.>.<------------------------<+.>.>.<<.>++++.>.<<.>++++.>.<
<+.>.>.<----<+.>.>.<<+.>+++.>.<<.>+.>.<<.>++++++.>.<--------------<+.>.>.<<.>+++
+++++.>.<<.>++++++.>.<-------<+.>.>.<<.>+++++.>.<<.>+.>.<<.>++.>.<<.>+++.>.<<.>+
.>.<---------------<++.>.>.<<.>++++++++++.>.<------<+.>.>.<<.>++++++++++++.>.<--
------------------<+.>.>.<<.>++++.>.<<.>++++++++++.>.<--------------<+.>.>.

Experimente online!


Bem, por um lado, você pode se livrar das novas linhas
Jo King

@ JoKing, não existe uma maneira real de derrotar alguém, acho que não há muito sentido em eliminar alguns bytes nessa grande escala.
Krzysztof Szewczyk

2

Zsh, 175 bytes

Essa solução usa uma seqüência de caracteres de 125 caracteres, em que as letras minúsculas servem como delimitadores e a primeira letra da seguinte seqüência de letras maiúsculas.

Nós iteramos sobre as letras de $L. Se a letra atual $Xestiver em minúscula por comparação ascii, defina $Wcomo $X. Caso contrário, imprima $Wconcatenado com $Xpara formar a palavra atual.

Experimente Online!

L=aABDEGHILMNRSTWXYbAEIOYdEOeDFHLMNRSTXfAEgOhAEIMOiDFNSTjOkAIlAIOmAEIMOUYnAEOUoDEFHIMNPRSWXYpAEIqIrEsHIOtAIOuHMNPSTwEOxIUyAEOzA
for X in ${(s::)L};{((#X>90))&&W=$X||<<<$W$X:l}

Edit: anexado :lpara definir minúsculas consistentemente, por requisito
Edit2: -4 bytes usando $Xvariável e simplificado se [[..]]condição
Edit3: -4 bytes removendo aspas ( ")
Edit5: -5 bytes usando conversão de matriz em vez de iterar Lconforme abaixo
Edit4: Abordagem alternativa para 182 bytes , explorando cadeias reversíveis nas primeiras 33 letras, $Lsão apenas 107 letras

L=aBHLMNTYdEOeFHMNRhOiSTmOUnOUoSWYaADEGIRSWXbEIOYeLSTXfAgOhIMiDFNjOkAIlIOmIMYoEFIPRXpAEIqIsHtOuHPSTwExIUyEzA
for ((;i++<$#L;))X=$L[i]&&((#X>90))&&W=$X:u||<<<$W$X`((i<34))&&<<<\ $X$W`

2

Stax , 91 bytes

âG→æ£ilæα¿:√▒▓uøD¶[│█æä║¢v┼T↨σªΩ■&*φòb¡CÆ?ì▀┬6ù═╦±qBF!╘π╓╙'♣*ù&↕!£ä3±r⌡W-╓D╬☺╝ï╜²á5Æ÷§═ôφF;

Execute e depure

O único truque que essa resposta usa é usar o token "," para mostrar uma alteração na primeira letra, em vez de armazená-la para cada palavra.

Obrigado ao recursivo pela ideia de usar o operador m


Bem feito. Existem algumas pequenas otimizações que posso ver. Use em Mvez de 1/e use um mapa abreviado em mvez de foreach e print explícitos { ... PF. Este empacota a 89.
recursivo em

1

Python 3, 224 bytes

s='';i=int("AQHU9HU1X0313T1J9OMYMZZSRFWLCYT3POSE06UGHXDZN6H5SQSZIFCE6VEB",36)
for c in range(26):
 b=i%6;i//=6;k=(1<<b)-1;j=i%(1<<k);i>>=k
 for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':
  if j&1:s+=chr(c+65)+d+' '
  j>>=1
print s

Usa máscaras de bits de comprimento variável para codificar quais segundas letras existem para cada primeira letra possível. As máscaras de bits podem ter 0,1,3,7,15 ou 31 bits. Os bits são mapeados para letras com for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':, os bits anteriores são usados ​​para letras mais comuns, de modo que as máscaras de bits podem ser curtas na maioria dos casos (geralmente 3 ou 7 bits, pois a maioria das consoantes é seguida apenas por uma das 5 vogais ou YM ou H). Infelizmente, o código para decodificar nega a economia em comparação com métodos mais simples (a lista original é de apenas 303 bytes).


11
Eu descobri que é melhor codificar qual primeira letra existe para cada segunda letra possível na minha solução. Pode valer a pena tentar no seu.
James Webster

1

Haskell, 192 bytes

putStr$(\(a:b)->((a:).(:" "))=<<b)=<<words"AABDEGHILMNRSTWXY BAEIOY DEO EDFHLMNRSTX FAE GO HAEIMO IDFNST JO KAI LAIO MAEIMOUY NAEOU ODEFHIMNPRSWXY PAEI QI RE SHIO TAIO UHMNPST WEO XIU YAEO ZA"

Para cada palavra separada por espaço na string, coloque a primeira letra na frente de todas as outras letras e adicione um espaço, por exemplo SHIO- -> SH SI SO.


1

Java, 334 bytes

public class C{public static void main(String[]a){for(int i=0;i<26;i++){for(int j=0;j<26;j++){if(java.util.BitSet.valueOf(java.util.Base64.getDecoder().decode("2znORQQBBAAAAAQQAKg4jkQAAAAABEBEFAAoIAwAAAEQEABAQBAAEVEQRQBBgBtrXEQAAAABAEAAAAAYBEBAEACAsAwAAAAAAQQAQAAEEUAABA==")).get(i*26+j)){System.out.format("%c%c\n",'a'+i,'a'+j);}}}}}

Formatado:

public class Code {
    public static void main(String[] a) {
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < 26; j++) {
                if (java.util.BitSet.valueOf(
                        java.util.Base64.getDecoder()
                            .decode("2znORQQBBAAAAAQQAKg4jkQAAAAABEBEFAAoIAwAAAEQEABAQBAAEVEQRQBBgBtrXEQAAAABAEAAAAAYBEBAEACAsAwAAAAAAQQAQAAEEUAABA=="))
                        .get(i * 26 + j)) {
                    System.out.format("%c%c\n", 'a' + i, 'a' + j);
                }
            }
        }
    }
}

Separadamente, codifiquei a lista de palavras em um comprimento 26x26 = 676 BitSet, converti-a em uma matriz de bytes e, finalmente, na Base 64. Essa cadeia é codificada nesse programa e o procedimento inverso é usado para reproduzir o BitSet, e, finalmente, imprimir a lista de palavras


1

Java, 356 bytes

Usa o gerador de números aleatórios para obter as palavras:

import java.util.Random;class X{public static void main(String[]a){int j,n,m=9,x;for(String u:"rgzza 2u2hh r2rxs qs5f fwiag 26i33y 2xqmje 5h94v 16ld2a 17buv 4zvdi 1elb3y 2t108q 5wne9 1mrbfe 1ih89 fh9ts r0gh".split(" ")){x=Integer.parseInt(u,36);Random r=new Random(x/2);j=m-=x%2;while(j-->0){n=r.nextInt(676);System.out.format(" %c%c",65+n/26,65+n%26);}}}}

Ungolfed:

import java.util.Random;
class X{
    public static void main(String[]a){
        int j,n,m=9,x;
        for(String u:"rgzza 2u2hh r2rxs qs5f fwiag 26i33y 2xqmje 5h94v 16ld2a 17buv 4zvdi 1elb3y 2t108q 5wne9 1mrbfe 1ih89 fh9ts r0gh".split(" ")){
            x=Integer.parseInt(u,36);
            Random r=new Random(x/2);
            j=m-=x%2;
            while(j-->0){
                n=r.nextInt(676);
                System.out.format(" %c%c",65+n/26,65+n%26);
            }
        }
    }
}

Você pode experimentá-lo aqui: http://ideone.com/Qni32q


1

Perl, 248 bytes

@v=split(//,"AEIOU");@s=split(' ',"ADEGIRSWX LSTX DFN EFIPRX HPST BHLMNTY DFHMNR ST DHMNSWY MN ZFKP WYPB KQXLHPMB LGJTB X");for(0..14){foreach $c(split(//,@s[$_])){$_<10?print @v[$_%5].$c." ":a;$_>4?print $c.@v[$_%5]." ":a;}}print "MM MY BY HM SH";

Primeira vez usando perl (e golfe pela primeira vez), então definitivamente há espaço para melhorias. Fatore as vogais e agrupe as letras restantes com base em como a palavra resultante foi criada - adicionando a vogal primeiro, último ou ambos, vogal primeiro e último, crie uma palavra na lista.


Não conheço Perl, mas presumo que você esteja separando a saída por espaços. Parece que "MM "."MY "."BY "."HM "."SH "poderia ser reduzido para "MM MY BY HM SH".
Level River St

@steveverrill Obrigado! Fiquei tão envolvido com o restante do código que esqueci o quanto isso era redundante.
precisa saber é o seguinte

1

Javascript (ES6), 214

Talvez não seja a maneira mais curta de fazer isso, mas definitivamente interessante.

_=>(i=0,[...'ABDEFGHILMNOPRSTUWXY'].map(z=>[...`ABFHKLMNPTYZ
A
AEIO
ABDFHMNOPRWY
EIO
A
AEOSU
ABHKLMOPQSTX
AE
AEHMOU
AEIOU
BDGHJLMNSTWY
OU
AEO
AEIOU
AEIU
MNX
AO
AEO
ABMO`.split`
`[i++]].map(g=>g+z).join` `).join`
`)

Faz um loop através de cada letra na primeira sequência, adicionando-a a cada letra na linha correspondente da segunda. Isso retorna as palavras na ordem da última letra, da seguinte forma:

AA BA FA HA KA LA MA NA PA TA YA ZA
AB
AD ED ID OD
AE BE DE FE HE ME NE OE PE RE WE YE
EF IF OF
AG
AH EH OH SH UH
AI BI HI KI LI MI OI PI QI SI TI XI
AL EL
AM EM HM MM OM UM
AN EN IN ON UN
BO DO GO HO JO LO MO NO SO TO WO YO
OP UP
AR ER OR
AS ES IS OS US
AT ET IT UT
MU NU XU
AW OW
AX EX OX
AY BY MY OY

Sugestões são bem-vindas!


1

Java, 255 254 bytes

Encontrei uma maneira de extrair mais um byte dele.

class C{public static void main(String[]a){char c='A';for(char l:"ABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EO IU AEO A".toCharArray())if(l<'A')c++;else System.out.print(" "+c+l);}}

Ou (embora não seja muito claro):

class C {
    public static void main(String[] a) {
        char c = 'A';
        for (char l : "ABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EO IU AEO A"
                .toCharArray())
            if (l < 'A')
                c++;
            else
                System.out.print(" " + c + l);
    }
}

Você pode salvar dois bytes alterando as duas ocorrências de 'A'em 65.
ProgramFOX

1

Haskell, 333 308 298 bytes

Apenas por diversão!

A avaliação simprimirá todas as palavras em uma ordem estranha - usei o fato de que a maioria das combinações é consoante de vogal ou vice-versa, provavelmente poderia otimizar ainda mais com "classes" de caracteres personalizados, encurtando a matriz codificada (aqui we k).

Alguém conhece uma maneira mais curta de imprimir seqüências de caracteres sem aspas e colchetes do que a minha monádica? As classes de tipo são ainda mais longas, até onde eu sei.

Além disso, também pode haver uma maneira mais curta de fazer po trabalho ...

v="AEIOU"
c="BCDFGHJKLMNPQRSTVWXYZ"
w=[976693,321324,50188,945708,52768]
k=[15,0,10,3,8,15,8,5,13,31,27,7,4,2,12,13,0,10,20,11,1]
z a b x=[[c:[e]|(e,f)<-b#p d,f]|(c,d)<-a#x]
(#)=zip
p 0=[]
p n=((n`mod`2)>0):p(n`div`2)
s=mapM_ putStrLn$concat$z v c w++z c v k++[words"AA AE AI BY HM MM MY OE OI SH"]

Não é sequence_o mesmo que void$sequence? Então você pode omitir também o import.
nimi

Isso é estranhamente empacotado, mas sim. Obrigado!
Leif Willerts

Não é, voidteve que ser importado. Enfim, vou ter que lembrar disso.
Leif Willerts

11
Ah, e sequence_$map putStrLné mapM_ putStrLn. Substitua o (, )em torno concat$...com outro $.
nimi

1

05AB1E , 143 bytes (Não concorrência)

•ZÐFý8ù6„=4ÅœÿWì±7Ë5Œ¾`ó/îAnµ%Ñ¥Ëø±/ÀéNzքѧIJ¶D—ÙVEStvÖò…¸¾6F³#EXŠm¯Cĵ±ÓoÊ°}^€Ftå߀ðŒ=«j;F-Â1;xX3i&QZÒ'Ü”>lwìlOs>íÙVÇI)~î‰Hç²?Öd0È^ÝQ°•36B2ô»

Experimente online!



11
@KevinCruijssen 91 (e tenho certeza de que esse método pode ficar mais baixo, mas escolhi as palavras do dicionário para humor).
Grimmy 30/08

1

PHP, 170 bytes

abordagem mais curta que pude encontrar até agora ...

for(;$c=ABFHKLMNPTYZ1A2AEIO1ABDFHMNOPRWY1EIO1A1AEOSU1ABHKJMOPQSTX3AE1AEHMOU1AEIOU1BDGHJLMNSTWY1OU11AEO1AEIOU1AEIU1MNX2AO1AEO1ABMO[$i++];)$c<1?print$c.chr($k+65)._:$k+=$c;

demolir

for(;$c=CHARACTERS[$i++];)  // loop $c through map
    $c<1                            // if $c is a letter (integer value < 1)
        ?print$c.chr($k+65)._           // print first letter, second letter, delimiter
        :$k+=$c                         // else increase second letter
    ;

Nota A versão mais curta de mapeamento de bits com ascii imprimível custa 190 bytes (dados de 113 bytes + decodificação de 77 bytes) usando 6 bits = base 64, 174 bytes (97 dados, decodificação 77) usando 7 bits (base 128); possivelmente um pouco mais para escapar.

for(;$p<676;)                   // loop through combinations
    ord("MAPPING"[$p/6])-32>>$p%6&1     // test bit
        ?                                       // if set, do nothing
        :print chr($p/26+65).chr($p++%26+65)._; // if not, print combination+delimiter

A base 224 (usando ascii 32..255) recebe dados de 87 bytes (+ escape); mas acho que a decodificação custará mais de 10 bytes extras.
A exclusão de C e V do mapa economizaria 16/14/13 bytes nos dados, mas custaria muito em decodificação.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.