Imprimir todas las palabras de Scrabble de 2 letras

40

El reto:

Imprima cada palabra de 2 letras aceptable en Scrabble usando la menor cantidad de bytes posible. He creado una lista de archivos de texto aquí . Ver también a continuación. Hay 101 palabras. Ninguna palabra comienza con C o V. Creativo, incluso si no es óptimo, se recomiendan soluciones.

AA
AB
AD
...
ZA

Reglas:

  • Las palabras de salida deben separarse de alguna manera.
  • El caso no importa, pero debe ser consistente.
  • Se permiten espacios finales y líneas nuevas. No se deben generar otros caracteres.
  • El programa no debe tomar ninguna entrada. No se pueden usar recursos externos (diccionarios).
  • No hay lagunas estándar.

Lista de palabras:

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
qwr
fuente
8
¿Las palabras tienen que salir en el mismo orden?
Sp3000
2
@ Sp3000 Diré que no, si se puede pensar en algo interesante
qwr
2
Por favor aclare lo que cuenta exactamente como separado de alguna manera . ¿Tiene que ser un espacio en blanco? Si es así, ¿se permitirían espacios que no se rompan?
Dennis
55
Ok, encontré una traducción
Mikey Mouse
3
Vi no es una palabra? Noticias para mí ...
jmoreno

Respuestas:

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 no es el método más corto, pero pensé que sería un buen comienzo. Intente empaquetar cada par en rutas solapando tanto como sea posible (por ejemplo, "ODEX..."= ["OD", "DE", "EX", ...]). Los espacios se utilizan para separar las rutas y se eliminan los pares con un espacio (el espacio final es para evitar que Ese imprima una sola al final).

También intenté regex golfing esto pero fue más largo.

Sp3000
fuente
1
+1 buen enfoque! Pedí prestada su cadena para una respuesta de Ruby
daniero
También hice una respuesta basada en su idea usando bash y 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+

Lo anterior es un hexdump, que se puede revertir con xxd -r -c 16 -g 1.

Pruébelo en línea en el intérprete de CJam .

Dependiendo de lo que cuente exactamente como separado de alguna manera , el recuento de bytes podría reducirse a 93 o incluso 92 :

  • Si reemplazamos -55con 59, las palabras se separarán por espacios que no se rompen (0xA0).

  • Si reemplazamos -55con W, las palabras se separarán por signos at (0x40).

Idea

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

En lugar de almacenar los enteros resultantes, almacenaremos las diferencias de todos los pares que corresponden a dos palabras adyacentes (ordenadas alfabéticamente).

La diferencia más alta es 35 , por lo que los consideramos dígitos de un entero base 36 y convertimos ese entero en una cadena 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 la segunda letra nunca es una Z , usar 25 en lugar de 26 es suficiente.

Dennis
fuente
14

PHP 224, 218, 210206

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 no es una gran puntuación, pero me gustó el desafío.

Creo una tabla de opciones, creé un sistema bit a bit para marcar qué opciones son válidas.

ingrese la descripción de la imagen aquí

Luego, base 36 codificó esas opciones para obtener la cadena:

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

Tenga en cuenta que la tercera entrada en esa matriz de cadenas no tiene un valor, porque C no tiene opciones.

Para imprimir los valores, acabo de convertir las opciones válidas a caracteres.

Podría haber algo que podría hacer para reducir el reconocimiento de que no hay palabras que terminen en C, J, K, Q, V o Z, pero no puedo pensar en un método para reducirlo.


Al transponer la tabla, hay más elementos vacíos y los datos se codifican de forma un poco más compacta, lo que reduce unos pocos bytes. La matriz ahora se imprime en un orden 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

Gracias a Ismael por la explosión y por las sugerencias de bucle.

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)." ":"";

Con una actualización a php5.6, pow(,)se puede reemplazar **guardando otros 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)." ":"";
James Webster
fuente
En lugar de explotar ",", puedes usarexplode(0,UB1YB0100CUP[...])
Ismael Miguel
¿No se rompería eso ya que hay 0s en la codificación?
James Webster
Sin embargo ... no hay una 3que pueda usar. Gracias
James Webster
Además, puede reemplazar $e++;for($f=0;$f<26;$f++)con for($e++,$f=0;$f<26;$f++), y ahora puede eliminar esos molestos {}. Y si desea convertir caracteres en minúsculas, use $e^' '.
Ismael Miguel
¡Buena atrapada! Yo no habría conseguido ese.
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

Escribió una secuencia de comandos separada para agrupar las letras lo más compactas posible en una cadena que contuviera todas las palabras válidas de 2 letras. Esto luego itera sobre todas las palabras de dos letras e imprime las válidas, una por línea. Corre con perl -M5.10.1 script.pl.

AKHolland
fuente
No puedo hacer que esto funcione en un compilador en línea.
mbomb007
@ mbomb007 Dependiendo de la versión, necesita el indicador de línea de comando -M5.10.1para usar la saypalabra clave agregada en esa versión o agregar use feature 'say';el cuerpo del script.
AKHolland
7

C, 155 bytes

Versión de golf

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];}

Salida

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

Versión sin golf

La cadena mágica de 51 bytes en la versión de golf contiene muchos caracteres más allá de ASCII 126, que casi con seguridad han sido destrozados en equivalentes Unicode. La versión sin golf utiliza hexadecimal en su lugar, y como una constante en lugar de un literal. Además, la versión no escrita separa las palabras con una nueva línea, lo que hace que sea más fácil copiar y pegar en Excel, ordenar la lista y compararla con la requerida.

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];}

Explicación

Si ampliamos la definición de vocal para incluir las 8 letras AHMEIOUY, observamos que todas las palabras consisten en una vocal y otra letra (que puede o no ser vocal). Por lo tanto, para todas las palabras que terminan en vocal, necesita una tabla de 26 bytes, uno para cada primera letra, con los bits individuales correspondientes a la vocal. Necesitamos una tabla similar para las palabras que comienzan con una vocal, excepto que esta vez solo necesitamos 25 bytes, ya que no hay una palabra que termine en Z. Las dos tablas se agrupan para crear la tabla final.

Para evitar cualquier código ASCII en la región 0..31, las dos "vocales" menos comunes M y H se asignan al 6 ° y 7 ° bit, y la codificación considera 1 para una palabra no válida y 0 para una palabra válida. Como no hay una consonante que se empareje con M y H, es posible asegurar que al menos uno de estos bits sea un 1.

El octavo bit se asigna a A, que es la vocal más común, para tratar de limitar los caracteres no ASCII (todavía hay muchos de ellos).

Las tablas utilizadas están a continuación. Para las palabras que contienen 2 vocales, le di prioridad a la primera letra como la "vocal" y a la segunda como "letra". Una excepción a esto son las palabras que comienzan con M, ya que esto evita un choque entre MM y HM.

Codificación hexadecimal de palabras que comienzan con una vocal

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 

Codificación hexadecimal de palabras que terminan con una vocal

 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
Level River St
fuente
Tal vez haga un volcado hexagonal de la versión de golf para que la destrucción se pueda revertir fácilmente
masterX244
7

Java 484 448 407 391 389 bytes

Mi primer intento

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);}}}}

Formateado:

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);
            }
        }
    }
}

Pruébalo en línea

griFlo
fuente
¡Buen trabajo! Algunas sugerencias: java.lang.Exception solo se puede llamar Excepción. "args" puede ser solo "a". String.format () puede ser "" .format (). También hay un pequeño espacio extra en la declaración main (). Buen enfoque en general, +1 de mi parte :)
jrich
Acabo de jugar con la declaración impresa, ¡pero me ganaste! Puede guardar otro byte reemplazando\n con solo un espacio. No tienen que estar separados por nuevas líneas.
James Webster
También te has perdido algunos espacios que puedes eliminar.
James Webster
@JamesWebster gracias por las sugerencias.
griFlo
44
"".format Es doloroso de ver, pero divertido.
Codebreaker
6

Rubí, 166 bytes

Pedir prestado el método ordenado de sp3000 para codificar las palabras en una cadena compacta. El truco aquí es el método corto para decodificarlo de nuevo en las palabras de dos letras: usando una búsqueda anticipada en la expresión regular pasada al método de escaneo de String para extraer coincidencias superpuestas, sin contaminar el espacio:

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

Rubí, 179 bytes

Mi propio enfoque: generar todas las palabras de dos letras entre AAy ZA, y seleccionar las válidas usando una máscara de bits codificada en base 36:

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

Matlab, 177 bytes

Genere una matriz binaria que defina todos los pares de letras permitidos, modifíquela y codifíquela en base 64. La cadena codificada en base 64 ( 'CR+ ... % ') se usa como datos en el programa. El programa invierte las operaciones para desempaquetar la matriz y luego lee los 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)
Luis Mendo
fuente
2
Buen Luis! Jugar al golf es realmente divertido ... = P
Stewie Griffin
1
¡Agradable! ¡No hay alfabeto!
Brain Guider
1
felicitaciones. Este es el código matlab más críptico que he visto en mucho tiempo ...
Hoki
¡Gracias chicos! Solo es críptico debido a la codificación de base 64. Esa cadena en realidad contiene la matriz binaria de 26x25 de pares de letras permitidas
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~

Pruébalo en línea!

Krzysztof Szewczyk
fuente
5

Bash, 179 bytes

echo U`sed -r 's/./& &/g'<<<HAABADEDOEFAEHELAGOFEMAHINAISHMENERESITALOHOMMONOPAMUMYAWETOSOWOYOXUNUPEXI`F `grep -o ..<<<ANARASATAXAYBEBIBOBYJOKAKILIMIOIDOIDORPIQITIUSUTYEZA`
  • Guardado 7 bytes gracias al comentario de Adam Katz

Se utiliza sedpara hacer regex reemplazo. La primera entrada de expresiones regulares se basa en la idea de Sp3000, mientras que la segunda expresión regular utiliza entradas comunes sin espacios.

Explicación:

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 ...
sergioFC
fuente
1
Puede reducir eso en siete bytes usando un espacio y luego `grep -o ..en lugar de `sed -r 's/ / &/g', un truco de mi respuesta a continuación.
Adam Katz el
5

Advertencia, esta respuesta no es programáticamente interesante.

Como todas las palabras tienen dos caracteres, podemos juntarlas todas y luego separarlas nuevamente usando una expresión regular simple.

Cualquier lenguaje amigable con expresiones regulares puede hacer esto, algunos de manera más eficiente que otros:

Grep (a través de 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 nota, algunas de las respuestas aquí son más largas que echo , lo que consideraría una línea 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
Adam Katz
fuente
3
+1 por ser práctico. Realmente, proporcionar el eco base es el punto desde el que todos deberían comenzar.
metalim
+1 en respuesta fácil, pero deberías marcar eso como no competidor, ¿no?
Matthew Roh
@MatthewRoh: si hubiera un analizador de la tabla de líderes, probablemente no encontraría nada ya que intencionalmente no comencé con un encabezado. No estoy preocupado, especialmente porque hay respuestas más cortas para cada idioma que he publicado.
Adam Katz
3

C - 228 217 Bytes - GCC

 _;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(""));}

Se actualizará si puedo hacerlo más pequeño, solo compile con gcc -w, ./a.out salidas perfectamente. Si hay algún interés en un no golfista, avíseme.

No se me ocurre ninguna forma de acortarlo en la parte superior de mi cabeza (técnicamente puedes eliminar las comillas en puestos y aún obtendrás una respuesta correcta, la salida solo parece basura), así que avísame de todos modos para acortarlo

Jake
fuente
Aquí hay algunas sugerencias, funciona bien para mí (no solo copie y pegue, el intercambio de pila inserta caracteres de control extraños en comentarios) _;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));}He cambiado el delimitador de salida de una nueva línea a un espacio, pero si prefiere una nueva línea (una byte adicional) cambie la cadena de formato printf a"%c%c\n"
Level River St
3

C #, 348 bytes

Tuve una oportunidad:

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));}}}}

Sin golf:

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));
            }
        }
    }
}
Jodrell
fuente
44
Este es un desafío de codegolf, por lo que debe publicar su conteo de bytes (longitud de su código). También intente acortarlo un poco, por ejemplo, eliminando espacios en blanco.
Jakube
@Jakube, ¿eso es mejor?
Jodrell
Sí, se ve bien
Jakube
3

Pyth , 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

Pruébalo en línea!

Método de compresión: como no hay ninguna Zen la segunda posición de ninguna palabra, use el alfabeto reordenadobcdfghjklmnpqrstvwxyaeiou para codificar la validez de cada una de esas letras como una segunda letra para cada primera letra (las primeras letras están en orden alfabético).
Esto es 25 bits por letra, o exactamente 5 dígitos Base-32. Como la mayoría de las consonantes solo toman vocales como segunda letra, pongo vocales al final para obtener mayormente números de 1 dígito para ellas. Estoy seguro de que en general podría mejorarse mediante un mayor análisis y reordenamiento del alfabeto, aunque la definición del alfabeto reordenado ocuparía más bytes.

Explicación

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)
ar4093
fuente
2

PHP: 211 209 204

Debe desactivar las advertencias; de lo contrario, se imprimirá con respecto a la creación 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++;

Muy divertido. Los primeros intentos estuvieron en el rango de 250, pero este es el más delgado hasta ahora.

NickW
fuente
2
Prueba este contador de bytes . Tenga en cuenta que desactivar el recuento de espacios en blanco es incorrecto, ya que también descuenta cualquier espacio que tenga en cadenas, por lo que su puntaje debe ser superior a 186.
Sp3000
Buena atrapada. He actualizado mi presentación en consecuencia
NickW
No puedo ver por qué ... pero esto ahora solo imprime "AAAA A ..."
James Webster
Has sacado el !sobre si ... lo necesitabas.
James Webster
Correcto. Acabo de notar eso. Estaba usando! delimitador anterior e hice una búsqueda rápida de reemplazo sin considerar lo que sucedería primero.
NickW
2

CJam (99 bytes)

Esto incluye algunos caracteres especiales, por lo que es más seguro dar un hexdump. (En particular, el personaje con valor 0xa0, correspondiente a un espacio sin interrupciones, me causó muchos problemas para configurar la demostración en línea).

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

Demostración en línea .

El enfoque es la codificación de diferencia en base-26.

Peter Taylor
fuente
Agregar un carácter a un entero produce un carácter, por lo que puede reemplazarlo 65f+:cpor 'Af+.
Dennis
Cierto. Y mdes una mejora brillante, pero no me había dado cuenta de cuán cercana está mi respuesta a la suya.
Peter Taylor
2

CJam, 100 98 bytes

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

(enlace permanente)

  • Guardado dos bytes a través de variables preinicializadas (¡gracias Dennis!)

Esta es mi primera entrada en CJam, por lo que es probable que exista un poco más de golf. Sin embargo, se me ocurrió una forma de comprimir la lista de caracteres hasta 63 bytes que, con suerte, alguien más encontrará útil.

Método de compresión

Hasta ahora, la mayoría de los métodos que vi codificaron ambas letras de cada palabra. Sin embargo, cuando ponemos las palabras en orden alfabético, la primera letra no cambia muy a menudo, por lo que parece un desperdicio codificarla explícitamente.

Codifico solo el último carácter de cada palabra e incluyo un elemento especial siempre que el primer carácter se incremente. Los caracteres se codifican como el primer carácter, luego una lista de diferencias. Como no hay palabras duplicadas, todas las diferencias deben ser al menos 1. Por lo tanto, puedo usar 0como elemento separador. (Tenga en cuenta que luego debo almacenar la primera letra de cada subsecuencia como un índice, de lo contrario, habría confusión entre el 'primer carácter de rollover 0' y 'comenzar con A0 ').

Dado que las diferencias en este caso nunca son mayores que 15, podemos usar base 16 y empacar dos elementos (4 bits) en cada byte (8 bits). (En el código real, convertí de base 260 en lugar de base 256 para evitar problemas con los caracteres no imprimibles).

Campeonato 2012
fuente
Puede guardar un par de bytes usando Gy N, que empuja 16 y un salto de línea.
Dennis
@ Dennis Gracias, ¡no me di cuenta de que las variables estaban preinicializadas!
2012rcampion
1
Las 26 letras mayúsculas son variables preinicializadas. Puedes ver la lista completa aquí .
Dennis
Puede guardar más bytes reemplazando %-3<con /;;o incluso /&. (La segunda opción generará un mensaje de error. El consenso sobre el meta es que está bien hacer esto.)
Dennis
2

brainfuck , 1371 bytes

Bastante golfable, pero no puse demasiado esfuerzo en ello.

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

Pruébalo en línea!

Krzysztof Szewczyk
fuente
Bueno, por un lado, puedes deshacerte de las nuevas líneas
Jo King,
@JoKing no hay una forma real de superar a alguien, no creo que tenga mucho sentido recortar un par de bytes en esta gran escala.
Krzysztof Szewczyk
2

Zsh, 175 bytes

Esta solución utiliza una cadena de 125 caracteres, donde las letras minúsculas sirven como delimitadores y la primera letra de la siguiente secuencia de letras mayúsculas.

Repetimos las letras de $L. Si la letra actual $Xestá en minúscula por comparación ascii, ajústela $Wen $X. De lo contrario, imprimir $Wconcatenado con $Xpara hacer la palabra actual.

Pruébalo en línea!

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

Edición: se adjunta :lpara establecer minúsculas de forma coherente, según los requisitos
Edición2: -4 bytes usando la $Xvariable y simplificada si la [[..]]condición
Edición3: -4 bytes eliminando comillas ( ")
Edición5: -5 bytes usando la conversión de matriz en lugar de iterar Lpor debajo
Editar4: Enfoque alternativo para 182 bytes , explotando cadenas reversibles en las primeras 33 letras, $Lson solo 107 letras

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

Stax , 91 bytes

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

Ejecutar y depurarlo

El único truco que usa esta respuesta es usar el token "," para mostrar un cambio en la primera letra, en lugar de almacenarlo para cada palabra.

Gracias a recursive por la idea de usar el operador m

usuario89655
fuente
Bien hecho. Hay un par de pequeñas optimizaciones que puedo ver. Use en Mlugar de 1/y use un mapa abreviado en mlugar de foreach e print explícitos { ... PF. Este tiene un paquete de 89.
recursivo
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

Utiliza máscaras de bits de longitud variable para codificar qué segundas letras existen para cada posible primera letra. Las máscaras de bits pueden tener una longitud de 0,1,3,7,15 o 31 bits. Los bits se asignan a letras con for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':, los bits anteriores se usan para letras más comunes, de modo que las máscaras de bits pueden ser cortas en la mayoría de los casos (generalmente 3 o 7 bits ya que la mayoría de las consonantes solo son seguidas por una de las 5 vocales o YM o H). Desafortunadamente, el código para decodificarlo niega los ahorros en comparación con métodos más simples (la lista original es de solo 303 bytes).

samgak
fuente
1
Descubrí que es mejor codificar qué primera letra existe para cada posible segunda letra en mi solución. Puede valer la pena probar en el tuyo.
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 palabra separada por espacios en la cadena, coloque la primera letra delante de todas las demás letras y agregue un espacio, por ejemplo, SHIO-> SH SI SO.

nimi
fuente
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);}}}}}

Formateado:

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);
                }
            }
        }
    }
}

Por separado, codifiqué la lista de palabras en una longitud 26x26 = 676 BitSet, la convertí en una matriz de bytes, y finalmente en Base 64. Esa cadena está codificada en este programa, y ​​el procedimiento inverso se utiliza para reproducir el BitSet, y finalmente imprimir la lista de palabras

Kevin K
fuente
1

Java, 356 bytes

Utiliza el generador de números aleatorios para obtener las palabras:

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);}}}}

Sin golf:

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);
            }
        }
    }
}

Puedes probarlo aquí: http://ideone.com/Qni32q

Arnaud
fuente
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";

La primera vez que usa Perl (y el golf por primera vez), por lo que definitivamente hay margen de mejora. Se factorizaron las vocales y se agruparon las letras restantes en función de cómo se creó la palabra resultante; al agregar la vocal primero, la última o ambas, primero y última, se crea una palabra en la lista.

VoiceOfFolly
fuente
No sé Perl, pero supongo que está separando la salida por espacios. Parece que "MM "."MY "."BY "."HM "."SH "podría acortarse "MM MY BY HM SH".
Level River St
@steveverrill ¡Gracias! Me quedé tan atrapado en el resto del código que pasé por alto lo redundante que era.
VoiceOfFolly
1

Javascript (ES6), 214

Quizás no sea la forma más corta de hacerlo, pero definitivamente es interesante.

_=>(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`
`)

Recorre cada letra en la primera cadena y la agrega a cada letra en la línea correspondiente de la segunda. Esto devuelve las palabras en orden de su última letra, así:

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

Sugerencias bienvenidas!

ETHproducciones
fuente
1

Java, de 255 254 bytes

Encontré una manera de exprimir un byte más.

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);}}

O (aunque no mucho más 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);
    }
}
Aofl
fuente
Puede guardar dos bytes cambiando ambas ocurrencias de 'A'into 65.
ProgramFOX
1

Haskell, 333 308 298 bytes

¡Solo por diversión!

Evaluando s imprimirá todas las palabras en un orden extraño: utilicé el hecho de que la mayoría de las combinaciones son vocales-consonantes o viceversa, probablemente podría optimizar aún más con las "clases" de caracteres personalizados, acortando la matriz codificada (aquí wy k).

¿Alguien sabe una forma más corta de imprimir cadenas sin comillas y corchetes que mi monádico? Las clases de tipos son incluso más largas por lo que puedo ver.

Además, también podría haber una forma más corta de hacer pel trabajo ...

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"]
Leif Willerts
fuente
¿No es lo sequence_mismo que void$sequence? Entonces puedes omitir también el import.
nimi
Eso está extrañamente empaquetado, pero sí. ¡Gracias!
Leif Willerts
No, voidtuvo que ser importado. De todos modos, voy a / tengo que recordar esto.
Leif Willerts
1
Ah, y lo sequence_$map putStrLnes mapM_ putStrLn. Reemplace el (, )alrededor concat$...con otro $.
nimi
1

05AB1E , 143 bytes (No competir)

•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ô»

Pruébalo en línea!

Urna de pulpo mágico
fuente
95 bytes portando la respuesta de Python 3 de @ Sp3000 .
Kevin Cruijssen
1
@KevinCruijssen 91 (y estoy seguro de que este método puede ser más bajo, pero elegí las palabras del diccionario por humor).
Grimmy
1

PHP, 170 bytes

enfoque más corto que pude encontrar hasta ahora ...

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

Descompostura

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 La versión de mapeo de bits más corta con ascii imprimible cuesta 190 bytes (113 bytes de datos + 77 bytes de decodificación) usando 6 bits = base 64, 174 bytes (97 datos, 77 decodificación) usando 7 bits (base 128); posiblemente un poco más por 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

Base 224 (usando ascii 32..255) toma 87 bytes de datos (+ escape); pero supongo que la decodificación costará más de 10 bytes adicionales.
Excluir C y V del mapa ahorraría 16/14/13 bytes en los datos, pero cuesta mucho decodificar.

Titus
fuente