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
Respuestas:
Python 3,
194188 bytesDefinitivamente 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 queE
se imprima una sola al final).También intenté regex golfing esto pero fue más largo.
fuente
AYAHOYOWOMUNUHAID
!CJam,
9694 bytesLo 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
-55
con59
, las palabras se separarán por espacios que no se rompen (0xA0).Si reemplazamos
-55
conW
, 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
1 Como la segunda letra nunca es una Z , usar 25 en lugar de 26 es suficiente.
fuente
PHP
224, 218,210206Definitivamente 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.
Luego, base 36 codificó esas opciones para obtener la cadena:
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:
Gracias a Ismael por la explosión y por las sugerencias de bucle.
Con una actualización a php5.6,
pow(,)
se puede reemplazar**
guardando otros 4 bytes.fuente
","
, puedes usarexplode(0,UB1YB0100CUP[...])
3
que pueda usar. Gracias$e++;for($f=0;$f<26;$f++)
confor($e++,$f=0;$f<26;$f++)
, y ahora puede eliminar esos molestos{}
. Y si desea convertir caracteres en minúsculas, use$e^' '
.Perl,
167164157 bytesEscribió 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
.fuente
-M5.10.1
para usar lasay
palabra clave agregada en esa versión o agregaruse feature 'say';
el cuerpo del script.C, 155 bytes
Versión de golf
Salida
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.
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
Codificación hexadecimal de palabras que terminan con una vocal
fuente
Java
484448407391389 bytesMi primer intento
Formateado:
Pruébalo en línea
fuente
\n
con solo un espacio. No tienen que estar separados por nuevas líneas."".format
Es doloroso de ver, pero divertido.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:
Rubí, 179 bytes
Mi propio enfoque: generar todas las palabras de dos letras entre
AA
yZA
, y seleccionar las válidas usando una máscara de bits codificada en base 36:fuente
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:fuente
Malbolge , 2118 bytes
Pruébalo en línea!
fuente
Bash, 179 bytes
Se utiliza
sed
para 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:
fuente
`grep -o ..
en lugar de`sed -r 's/ / &/g'
, un truco de mi respuesta a continuación.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
Javascript, 224 bytes
Perl, 225 bytes
Python, 245 bytes
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
fuente
C -
228217 Bytes - GCCSe 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
fuente
_;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"
C #, 348 bytes
Tuve una oportunidad:
Sin golf:
fuente
Pyth , 140 bytes
Pruébalo en línea!
Método de compresión: como no hay ninguna
Z
en 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
fuente
PHP:
211209204Debe desactivar las advertencias; de lo contrario, se imprimirá con respecto a la creación implícita de
$b
Muy divertido. Los primeros intentos estuvieron en el rango de 250, pero este es el más delgado hasta ahora.
fuente
!
sobre si ... lo necesitabas.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).Demostración en línea .
El enfoque es la codificación de diferencia en base-26.
fuente
65f+:c
por'Af+
.md
es una mejora brillante, pero no me había dado cuenta de cuán cercana está mi respuesta a la suya.CJam,
10098 bytes(enlace permanente)
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 usar0
como 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 rollover0
' 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).
fuente
G
yN
, que empuja 16 y un salto de línea.%-3<
con/;;
o incluso/&
. (La segunda opción generará un mensaje de error. El consenso sobre el meta es que está bien hacer esto.)brainfuck , 1371 bytes
Bastante golfable, pero no puse demasiado esfuerzo en ello.
Pruébalo en línea!
fuente
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$X
está en minúscula por comparación ascii, ajústela$W
en$X
. De lo contrario, imprimir$W
concatenado con$X
para hacer la palabra actual.Pruébalo en línea!
Edición: se adjunta
:l
para establecer minúsculas de forma coherente, según los requisitosEdición2: -4 bytes usando la
$X
variable y simplificada si la[[..]]
condiciónEdición3: -4 bytes eliminando comillas (
"
)Edición5: -5 bytes usando la conversión de matriz en lugar de iterar
L
por debajoEditar4: Enfoque alternativo para 182 bytes , explotando cadenas reversibles en las primeras 33 letras,
$L
son solo 107 letrasfuente
Stax , 91 bytes
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
fuente
M
lugar de1/
y use un mapa abreviado enm
lugar de foreach e print explícitos{ ... PF
. Este tiene un paquete de 89.Python 3, 224 bytes
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).fuente
Haskell, 192 bytes
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
.fuente
Java, 334 bytes
Formateado:
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
fuente
Java, 356 bytes
Utiliza el generador de números aleatorios para obtener las palabras:
Sin golf:
Puedes probarlo aquí: http://ideone.com/Qni32q
fuente
Perl, 248 bytes
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.
fuente
"MM "."MY "."BY "."HM "."SH "
podría acortarse"MM MY BY HM SH"
.Javascript (ES6), 214
Quizás no sea la forma más corta de hacerlo, pero definitivamente es interesante.
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í:
Sugerencias bienvenidas!
fuente
Java,
de 255254 bytesEncontré una manera de exprimir un byte más.
O (aunque no mucho más claro):
fuente
'A'
into65
.Haskell,
333308298 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íw
yk
).¿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
p
el trabajo ...fuente
sequence_
mismo quevoid$sequence
? Entonces puedes omitir también elimport
.void
tuvo que ser importado. De todos modos, voy a / tengo que recordar esto.sequence_$map putStrLn
esmapM_ putStrLn
. Reemplace el(
,)
alrededorconcat$...
con otro$
.05AB1E , 143 bytes (No competir)
Pruébalo en línea!
fuente
PHP, 170 bytes
enfoque más corto que pude encontrar hasta ahora ...
Descompostura
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.
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.
fuente