Crear una canción del alfabeto

55

Su objetivo es crear una canción del alfabeto como texto en la siguiente forma (en orden):

A is for <word starting with A>
B is for <word starting with B>
C is for <word starting with C>
...
Z is for <word starting with Z>

Salida de ejemplo:

A is for Apple
B is for Banana
C is for Carrot
D is for Door
E is for Elephant
F is for Frog
G is for Goat
H is for Hat
I is for Icicle
J is for Jelly
K is for Kangaroo
L is for Lovely
M is for Mom
N is for Never
O is for Open
P is for Paste
Q is for Queen
R is for Rice
S is for Star
T is for Test
U is for Underneath
V is for Very
W is for Water
X is for X-ray
Y is for Yellow
Z is for Zipper

Reglas:

  • Cada "letra" de la canción tiene su propia línea, por lo que hay 26 líneas y un posible avance de línea final.

  • La salida distingue entre mayúsculas y minúsculas:

    • La letra al comienzo de cada línea debe estar en mayúscula.
    • is for es minúscula
    • La palabra elegida no necesita ser mayúscula, pero puede ser. Todas las líneas deben ser consistentes.
  • La palabra elegida para cada línea depende de usted, pero debe ser una palabra inglesa válida con al menos 3 letras, y no puede ser una conjunción (like ando but), interjección / exclamación (like heyo yay), abreviatura (like XLS) o un nombre (como Jon)

  • Aunque dudo que alguien lo encuentre más corto, me parece aceptable usar una frase en lugar de una sola palabra. Entonces, si por alguna razón S is for Something smells fishy...es más corta, hazlo.

  • Ponga el resultado de su programa en su respuesta, o al menos la lista de palabras que utilizó (si hay un enlace para ejecutar su código en línea, no necesitamos ver el resultado completo).

  • El código más corto gana


Este desafío fue inspirado por este video .

mbomb007
fuente
Supongo que la jerga no está permitida, incluso si aparece en los diccionarios adecuados. (por ejemplo, "Cuando se dio cuenta de que se dirigía hacia el interior de nuevo, ¡simplemente se quitó un uey !")
Jonathan Allan
1
Dadas algunas de las respuestas, esta canción de Barenaked Ladies parece relevante.
AdmBorkBork
1
@JonathanAllan Sin jerga. Los diccionarios contienen muchas cosas que técnicamente no son palabras. Las abreviaturas son una, la jerga es otra.
mbomb007
44
Es una pena que esto se haya traducido en encontrar palabras de 3 letras que terminen en la misma letra.
12Me21
1
Hay un par de respuestas usando un diccionario externo. ¿No deberían tener que agregar el tamaño de ese archivo a su código?
tubería

Respuestas:

3

SOGL 0.8.1 , 60 32 bytes

χ3½⌠↓-ζ⁄∞Nη6′⁵‘Z{t",t5~r‘ooKo to

Explicación:

χ3½⌠↓-ζ⁄∞Nη6′⁵‘                   push "niooaaoasoioaiaaaoiineeaei"
               Z{                 for each letter of the uppercase alphabet
                 t                output the letter in a newline (and disable implicit output)
                  ",t5~r‘o        append " is for "
                          o       append the letter
                           Ko     append the 1st letter of the 1st string (the 2nd letters) and remove it
                              to  append "t"

Esta es la respuesta de Jonathan Allan , pero portada a este idioma.

Versión anterior: (SOGL 0.8.2)

Z"sηΒ…@Ν┘$JP6*š∙╬F▓÷Σ⁷4⌠    ⁹{Tīο⁾α⅝½Χ<▼½Ξμ‚‘θ’»∫wGKO",t5~r‘P≥o


Z                                                             push the uppercase alphabet
 "sηΒ…@Ν┘$JP6*š∙╬F▓÷Σ⁷4⌠    ⁹{Tīο⁾α⅝½Χ<▼½Ξμ‚‘                  push the 27 words separated by spaces using the languages english compression (BCD...XYZA)
                                          θ                   split on spaces
                                           ’»∫                repeat 27 times (push 0-based pointer)
                                              w               get the 1-indexed item of the array (so 0 = last, 1 = first, 2 = 2nd,...)
                                               G              put the 1st thing on stack ontop (the alphabet)
                                                K             get the 1st letter and remove it
                                                 O            output it
                                                  ",t5~r‘     push compressed " is for "
                                                         P    append that (and disable last auto-output)
                                                          ≥   put the 1st thing on the stack below everything
                                                           o  append the last thing (the word from the word list)

salida:

A is for against
B is for being
C is for could
D is for down
E is for even
F is for first
G is for good
H is for had
I is for into
J is for just
K is for know
L is for little
M is for much
N is for nothing
O is for other
P is for project
Q is for quite
R is for right
S is for said
T is for their
U is for under
V is for very
W is for with
X is for xavier
Y is for you
Z is for zoo

Este no es el más corto que este lenguaje puede hacer, pero debería ser el mejor con las palabras codificadas.

dzaima
fuente
57

Bash (+ coreutils), 81, 87, 8278 bytes

Utiliza la página de manual para X , como fuente de palabras.

Golfed

man xyst\  x|&grep -Po '\b[a-z]{4,} '|sed 's/\(.\)/\u\1 is for &/'|sort -uk1,1

EDICIONES

  • Se utilizó una página de manual 'xyst' no existente + |&para guardar 5 bytes;
  • Se guardaron 4 bytes más, intercambiando sed y sort .

Prueba

%man xyst\  x|&grep -Po '\b[a-z]{4,} '|sed 's/\(.\)/\u\1 is for &/'|sort -uk1,1

A is for also 
B is for build 
C is for computing 
D is for distribution 
E is for entry 
F is for following 
G is for graphics 
H is for hierarchical 
I is for implementations 
J is for just 
K is for keyboard 
L is for listing 
M is for manual 
N is for network 
O is for output 
P is for programs 
Q is for quite 
R is for runs 
S is for system 
T is for transparent 
U is for used 
V is for various 
W is for window 
X is for xyst 
Y is for your 
Z is for zeros 
zepelín
fuente
3
¿Son lsof y xregs palabras? :)
OldBunny2800
1
@ OldBunny2800 debería arreglarse ahora
zepelín
2
Lo busqué, y sí, xyst es una palabra real. :)
OldBunny2800
3
Parece que los niños aprenderán algunas palabras grandes. : D
mbomb007
1
@JonathanAllan Desafortunadamente, la página de manual para "x" no está disponible en TIO, pero aquí hay un enlace tio.run/nexus/… , que usa "man man" en su lugar. El truco con xyst es que man xyst se quejará de que "No hay entrada manual para xyst" en el stderr, que luego se fusionó en stdout con |&, por lo que puede ser codificado.
zepelín
33

Python 2 , 88 77 bytes

-11 bytes gracias a xnor (evite el zip atravesando la cadena y contando cdesde 65)

c=65
for x in'niooaauusoioaiuaaoiineeaei':print'%c is for %c%st'%(c,c,x);c+=1

Pruébalo en línea!

(Un puerto de mi respuesta Jelly, cuando era 56 bytes).

A is for Ant
B is for Bit
C is for Cot
D is for Dot
E is for Eat
F is for Fat
G is for Gut
H is for Hut
I is for Ist
J is for Jot
K is for Kit
L is for Lot
M is for Mat
N is for Nit
O is for Out
P is for Pat
Q is for Qat
R is for Rot
S is for Sit
T is for Tit
U is for Unt
V is for Vet
W is for Wet
X is for Xat
Y is for Yet
Z is for Zit
Jonathan Allan
fuente
44
Me gusta el método de palabras que terminan en t. La iteración se puede acortar actualizando xen paralelo .
xnor
Muy inteligente, como siempre; ¡Gracias!
Jonathan Allan
1
¿Qué es Unt? No puedo encontrar esa en ninguna parte
Albert Renshaw
No creo que Untsea ​​una palabra, pero Utes para que pueda reemplazar el nen su literal con \0para hacer esto válido y solo agregar un byte más. Editar reglas de olvido dicen que tiene que tener 3 letras de largo ... hmmm
Albert Renshaw
44
@AlbertRenshaw Unt es un topo europeo según Merriam-Webster . Una alternativa sería ult según Wiktionary, no es solo una abreviatura (que se enumeran con puntos, como ult. ).
Jonathan Allan
31

Golpetazo, 78, 69 bytes

¡Aardvarks, Babushkas y Kamikazes!

Golfed

sed -nr '/^[a-z]{9}$/s/(.)/\u\1 is for &/p'</u*/*/*/words|sort -uk1,1

EDICIONES

  • Se deshizo de grep, -9 bytes

Prueba

%sed -nr '/^[a-z]{9}$/s/(.)/\u\1 is for &/p'</u*/*/*/words|sort -uk1,1

A is for aardvarks
B is for babushkas
C is for cablecast
D is for dachshund
E is for eagerness
F is for fabricate
G is for gabardine
H is for habitable
I is for ibuprofen
J is for jabberers
K is for kamikazes
L is for labelling
M is for macaronis
N is for nailbrush
O is for obedience
P is for pacemaker
Q is for quadrants
R is for rabbinate
S is for sabotaged
T is for tableland
U is for ulcerated
V is for vacancies
W is for wackiness
X is for xylophone
Y is for yachtsman
Z is for zealously

Hace uso de / usr / share / dict / words :

words es un archivo estándar en todos los sistemas operativos Unix y similares a Unix, y es simplemente una lista de palabras del diccionario delimitada por una nueva línea. Se usa, por ejemplo, en programas de corrección ortográfica.

zepelín
fuente
14

PowerShell , 150 141 117 75 bytes

65..90|%{$i=[char]$_;"$i is for $i$('niooaauusoioaiuaaoiineeaei'[$_-65])t"}

Pruébalo en línea!

Bucles de 65a 90(es decir, ASCII Aa Z). En cada iteración, convertimos el entero en el apropiado char(es decir, ASCII 65para A) , lo guardamos $ipara usarlo más tarde, concatenamos eso con is for $i, y luego añadimos en el medio de la palabra apropiada. Eso se hace indexando en una cadena larga (tomada de la respuesta de Jonathan Allan ). Termina con la letra tpara hacer la palabra de tres letras.

Las cadenas resultantes se dejan en la tubería, y un implícito Write-Outputal final las imprime con nuevas líneas en el medio.

Ahorré un montón de bytes gracias a la lista de palabras de Rod
Borrowed de la respuesta de Jonathan Allan

AdmBorkBork
fuente
puede quitar la primera letra de cada palabra (la mayúscula) e imprimir con un [char]$ ejemplo
Rod
@ Rod Gracias. Combiné eso con lo que estaba trabajando para cambiar la forma en que se calcula el ciclo y cómo se calcula la indexación y se guarda aún más.
AdmBorkBork
13

Jalea , 39 bytes

;“ẉbẊWS»,⁸K;;”t
“¤ṁp}œḊṄæ®’b6ị“ʠȷ»ØAç"Y

TryItOnline!

Basado en la versión de 56 bytes (dos a continuación), pero cambió las palabras para eliminar todas las letras del medio "u"para que pueda indexarse ​​en la palabra del diccionario "anisole"*, que tiene la conveniencia de tener todas las letras que necesitamos en índices menores a seis: 1:a, 2:n 3:i, 4:s, 5:o (6:l), 0:e(observe el "e"a la derecha está en el índice cero [también 7 y -7 y cualquier otro número congruente con 0 mod 7]). También es temprano en el diccionario, por lo que solo tiene un índice de búsqueda de dos bytes en lugar del mucho más común ( "anisogamete"también funcionaría para 2).

* El nombre de la vieja escuela para el éter aromático metoxibenceno, usado a menudo en perfumes.

A is for Ant
B is for Bit
C is for Cot
D is for Dot
E is for Eat
F is for Fat
G is for Got
H is for Hat
I is for Ist
J is for Jot
K is for Kit
L is for Lot
M is for Mat
N is for Nit
O is for Oat
P is for Pat
Q is for Qat
R is for Rot
S is for Sit
T is for Tit
U is for Unt
V is for Vet
W is for Wet
X is for Xat
Y is for Yet
Z is for Zit

¿Cómo?

“¤ṁp}œḊṄæ®’b6ị“ʠȷ»ØAç"Y - Main link: no arguments
“¤ṁp}œḊṄæ®’             - base 250 compressed number -> 75711304811637630759
           b6           - convert to base 6 list -----------> [   2,    3,    5,    5,    1,    1,    5,    1,    4,    5,    3,    5,    1,    3,    1,    1,    1,    5,    3,    3,    2,    0,    0,    1,    0,    3]
              “ʠȷ»      -     word from Jelly's dictionary, "anisole" 
             ị          - index into that ------------------> [ "n" , "i" , "o" , "o" , "a" , "a" , "o" , "a" , "s" , "o" , "i" , "o" , "a" , "i" , "a" , "a" , "a" , "o" , "i" , "i" , "n" , "e" , "e" , "a" , "e" , "i"]
                  ØA    - get the uppercase alphabet
                    ç"  - zip with last link (1) as a dyad -> ["Ant","Bit","Cot","Dot","Eat","Fat","Got","Hat","Ist","Jot","Kit","Lot","Mat","Nit","Oat","Pat","Qat","Rot","Sit","Tit","Unt","Vet","Wet","Xat","Yet","Zit"]
                      Y - join with line feeds
                        - implicit print

;“ẉbẊWS»,⁸K;;”t - Link 1, join up the parts: Character, Two-Character-Word-Ending
;               - concatenate Character (e.g. "A") with
 “ẉbẊWS»        - the compressed string " is for" --->  "A is for"
        ,       - pair that with
         ⁸      - the left argument (Character) -----> ["A is for","A"]
          K     - join with spaces ------------------>  "A is for A"
           ;    - concatenate with right argument --->  "A is for An"
            ;   - concatenate with
             ”t -     "t" --------------------------->  "A is for Ant"

Anterior, 46

“¤ṪŻIð^ƥ’b4ị⁾sap⁾pt¤ØAż,@K¥€“ẉbẊWS»ØAżYF”e272¦

Todas las palabras tienen la segunda letra "s" o "a" y la última letra "p" o "t" usando una búsqueda de base cuatro en un producto cartesiano de "sa" y "pt". Excepto la palabra "U", que el código cambia a "Usar" (usando el relativamente voluminoso F”e272¦al final). Si pudiera encontrar una lista de palabras como esta que no tenga esa excepción, estaríamos buscando 39 bytes .

Lista de palabras:

Asp, Bat, Cat, Dap, Eat, Fat, Gap, Hat, Ist, Jat, Kat, Lap, Mat, Nap, Oat, Pat, Qat, Rat, Sat, Tap, Use, Vat, Wat, Xat, Yap, Zap

prueba este


56 bytes anteriores

”tṁØA⁺,j“niooaauusoioaiuaaoiineeaei”œs3Z,@K¥€“ẉbẊWS»ØAżY

Lista de palabras:

Ant, Bit, Cot, Dot, Eat, Fat, Gut, Hut, Ist, Jot, Kit, Lot, Mat, Nit, Out, Pat, Qat, Rot, Sit, Tit, Unt, Vet, Wet, Xat, Yet, Zit

Se le da formato, darle una oportunidad


Anterior, 83 bytes

“ẉbẊWS»WṁØA⁺żż“¦ịfe$ɲVPġþ¹Øt@ƑƊŀqṁŒƑOɦ⁴ḍẊḤṁr}Ƭ¢b⁻?q&øIụNẎ9eƲi⁸'ıB.;%V,¦İ⁷ẓk½»s5¤K€Y

... juguemos "¡Encuentra qué letra no tiene un animal!" hay uno, y solo uno: cuidado con el arenque rojo (una mentira, el arenque rojo era xenón, que es un elemento, obviamente no un animal) , aquí hay dos palabras de cinco letras que no son animales (el xenón es uno) :

Aphid, Bison, Camel, Dingo, Eagle, Finch, Gecko, Heron, Indri, Jabot, Koala, Lemur, Mouse, Nyala, Otter, Panda, Quail, Raven, Sloth, Tapir, Urial, Viper, Whale, Xenon, Yapok, Zebra

(por supuesto, esto está formateado correctamente, pruébalo, solo pensé que ahorraría espacio)

Jonathan Allan
fuente
XenonNo es un animal. Estaba seguro de que estabas bromeando H is for Herring, pero supongo que no.
mbomb007
Je, fue una mentira. Xenon era el obvio :)
Jonathan Allan
Creo que están pensando en xenop , que no está en el diccionario de Jelly.
Jonathan Allan
¡Maravillosa idea! Pero Uut?
Greg Martin
@ GregMartin Estoy de acuerdo, creo que comenzaste a convertir tus palabras en gruñidos silábicos.
Urna mágica del pulpo
10

Retina , 89 87 bytes

Guardado 2 bytes gracias a Martin Ender


ApBaCaDoEaFaGeHaIkaJeKiLeMeNeOpPeQaRaSaTiUniVaWeXysYurZi
[A-Z]
¶$& is for $&
^¶

m`$
t

Pruébalo en línea!

Escogí una palabra para cada letra que termina en t(algunas son bastante oscuras).

Explicación


ApBaCaDoEaFaGeHaIkaJeKiLeMeNeOpPeQaRaSaTiUniVaWeXysYurZi

Reemplace la entrada inexistente (vacía) con el texto anterior.

[A-Z]
¶$& is for $&

Reemplace cada letra mayúscula con (newline)(itself) is for (itself). Esto hace que el texto anterior se divida en líneas separadas como

A is for Ap
B is for Ba
C is for Ca

... y así

^¶
​

Sin embargo, dado que la nueva línea se colocó antes de cada capital, hay una nueva línea principal que debe eliminarse. Se elimina en esta etapa.

m`$
t

Ponga un tal final de cada línea, ya que cada palabra utilizada en la canción termina en t.

Gato de negocios
fuente
No necesita capturar la letra mayúscula. Solo use $&o en $0lugar de $1. En realidad, eso también podría ahorrar bytes en mi etapa dividida.
Martin Ender
@MartinEnder Gracias. ¿Qué hace $&exactamente? No lo vi en el wiki de GitHub.
Business Cat
Es un alias para $0(y es solo parte del sabor .NET, así como la mayoría de los otros sabores).
Martin Ender
Usando algunas palabras más cortas para bajarlo a 83, pruébalo en línea
Jonathan Allan
8

Retina , 92 88 bytes

Ahorró 4 bytes al tomar prestada una idea de la respuesta de Business Cat .

El recuento de bytes asume la codificación ISO 8859-1.


AddBCDEelFGHItsJetKitLMNetOilPQatRSTUrnVatWXisYesZit
[A-Z]
¶$& is for $&
m` .$
$&ad
G`.

Pruébalo en línea!

Basado en la lista de palabras de AdmBorkBork , pero he cambiado algunas palabras más en unas que terminan adpara guardar más bytes en el sufijo común.

Explicación


AddBCDEelFGHItsJetKitLMNetOilPQatRSTUrnVatWXisYesZit

Convierta la entrada vacía (inexistente) en esta cadena. Contiene todas las letras, así como el resto de esas palabras que no terminan en ad.

[A-Z]
¶$& is for $&

Inserte un salto de línea antes de cada letra mayúscula y luego conviértalo X is for X.

m` .$
$&ad

Une las letras que ahora están solas y agrega adpara completar las palabras acortadas.

G`.

Deseche la línea vacía que se creó insertando un salto de línea antes A.

Martin Ender
fuente
8

PHP, 122 124 127 120 115 101 bytes

Sigue la <letter><filler>testructura "estándar" .
Traté de encontrar palabras que antes nadie usara.
Si ve una palabra que quiere que reemplace, dígame.

foreach(range(A,Z)as$k=>$c)echo"$c is for $c",ceaoaaei0eieeouoaaei0eeaei[$k]?:[I=>ka,U=>ni][$c],"t\n";

La nueva línea se representa \npero se cuenta como 1 byte.


Salida:

A is for Act
B is for Bet
C is for Cat
D is for Dot
E is for Eat
F is for Fat
G is for Get
H is for Hit
I is for Ikat
J is for Jet
K is for Kit
L is for Let
M is for Met
N is for Not
O is for Out
P is for Pot
Q is for Qat
R is for Rat
S is for Set
T is for Tit
U is for Unit
V is for Vet
W is for Wet
X is for Xat
Y is for Yet
Z is for Zit

Palabras raras:

  • ikat :

    Ikat, o ikkat, es una técnica de teñido utilizada para estampar textiles que emplea teñido resistente en los hilos antes de teñir y tejer la tela.

  • xat :

    Un poste tallado erigido como un monumento a los muertos por algunos indios del oeste de América del Norte

  • zit :

    un grano Mancha en la piel.

  • qat :

    Catha edulis (khat, qat) es una planta con flores nativa del Cuerno de África y la Península Arábiga.

Ismael Miguel
fuente
Solución inteligente Iba a hacer algo similar, ¡me alegra ver esto! +1
Albert Renshaw
1
Estas no son palabras en inglés ...
Conor O'Brien
@ ConorO'Brien ¿Estás seguro? PHP está escrito en inglés, hasta donde yo sé.
Ismael Miguel
55
@IsmaelMiguel cosas como vprintfy zend_versionciertamente no son palabras en inglés. Muy pocas de estas entidades son en realidad palabras.
Conor O'Brien
1
No diría zituna palabra extraña, al menos, creo que todos ya deberían saber lo que significa.
mbomb007
6

Pyke, 55 51 48 bytes

26.f[1R].C".d"R+E)DGjt@.^.Il 6>( F['h .dRdJl5

Pruébalo aquí!

El enlace tiene una longitud de 3 y no califica ya que las palabras incluyen conjuntivas.

    [1R].C".d"R+E)                            - def function [i):
     1R]                                      -     [1, i]
        .C                                    -    chr(^)
          ".d"R+                              -   ".d"+ ^
                E                             -  eval(^) (dictionary lookup of length 1)
                                              -    gets the `i`th word in the dictionary

26.f[             DGjt@.^.Il 6>(              -  first_26():
    [                                         -     function(i)
                       .^                     -    ^.startswith(v)
                   Gjt@                       -     alphabet[current_iter-1]
                         .Il 6>               -   if ^:
                           l 6>               -    len(function(i)) > 6
                                 F['h .dRdJl5 - for i in ^:
                                  ['h         -     function(i)[0], function(i)
                                      .d      -    "is for" (unprintables 0x02, 0x07, 0x06)
                                        R     -    rotate(^, ^^)
                                         dJ   -   " ".join(^)
                                           l5 -  ^.capitalize()

Salidas:

A is for available
B is for because
C is for community
D is for download
E is for english
F is for features
G is for getting
H is for hardware
I is for increase
J is for jewelry
K is for kitchen
L is for locations
M is for manufacturer
N is for northern
O is for outdoor
P is for protein
Q is for quickly
R is for religion
S is for surgery
T is for thousands
U is for universal
V is for vehicles
W is for weekend
X is for xenical
Y is for youngest
Z is for zoofilia

Puede probar esto fuera de Pyke usando el mismo algoritmo. Requiere dictionary.json .

import json, string

with open("dictionary.json") as f_obj:
    words=json.load(f_obj)

rtn=[]
i=0
while len(rtn) != 26:
    cur_word=words[i]
    if cur_word[0]==string.lowercase[len(rtn)]:
        if len(cur_word) > 6:
            rtn.append(cur_word)
    i += 1

for i in rtn:
    print("{} is for {}".format(i[0].upper(), i))
Azul
fuente
No. Además, recibo un error al ejecutar su código.
mbomb007
Timeout running code. BAD EVALAsegúrese de actualizar su enlace "Pruébelo en línea".
mbomb007
2
Z is for zoofiliaConsideraría seriamente antes de dejar que mis hijos canten esto.
zepelín
Para cualquiera que haga una doble toma como lo hice yo: el inglés no siempre está en mayúscula. ;)
DLosc
6

Japt , 52 50 bytes

Colaborado con @ETHproductions

;B£[R`  f `Od"¥¥º"gY]qXÃx

Contiene muchos no imprimibles. ¡Pruébalo en línea!

La lista de palabras es:

All Bar Can Dan Ear Fan Gas Has Ill Jar Kit Led Man Nit Oar Pan Qat Rat Sat Tan Udo Vat War Xis Yes Zit

Japt usa la biblioteca de compresión de cadenas shoco , que reduce las ejecuciones comunes de letras minúsculas en un byte. Aquí hay una lista completa de todas las ejecuciones de dos letras que se condensan en un byte:

an,ar,as,at,be,bl,bo,bu,ca,ce,ch,co,da,de,di,do,ed,en,er,es,ha,he,hi,ho,im,in,is,it,le,li,ll,ly,ma,me,mi,mo,nd,ne,ng,nt,of,on,or,ou,ra,re,ri,ro,se,sh,si,st,te,th,ti,to,ul,ur,us,ut,wa,we,wh,wi

Entonces, la idea es formar una palabra con uno de estos pares para cada letra del alfabeto.

;B£   [R`  f `    Od"string"gY]qXÃ x
;BmXY{[R" is for "Od"string"gY]qX} x

;                                      // Among other things, set B to "ABC...XYZ".
 B                                     // Split B into chars.
    mXY{                           }   // Map each item X and index Y to the following:
                      "string"gY       //   Take the char at index Y in the compressed str.
                    Od                 //   Decompress.
        [R" is for "            ]      //   Put this in an array with a newline and " is for ".
                                 qX    //   Join on X, giving "\n{X} is for {word}".
                                    x  // Trim. This removes the leading newline.
                                       // Implicit: output result of last expression

Una cosa interesante a tener en cuenta es que, si bien Japt puede descomprimir implícitamente una cadena envuelta en backticks, en realidad es un byte más largo porque tendría que tomar dos caracteres en la cadena descomprimida, en lugar de uno.

Oliver
fuente
6

05AB1E , 45 42 39 38 37 36 bytes

Au'Æå•à¡P°€kš¦zᮕSè)øvy¬“ÿ€ˆ€‡ ÿt“,

Pruébalo en línea!

Explicación

Auempuja el alfabeto en mayúscula.
'Æåempuja la palabra scenario.
•à¡P°€kš¦zᮕempuja el número de base 10 36774474076746444766322426.
usa esos dígitos para indexar scenario.
comprime esas cadenas juntas en la lista[An, Bi, Co, ..., Zi]

v                  # for each element in the list
 y                 # push it
  ¬                # push it's first letter
   “ÿ€ˆ€‡ ÿt“      # push the string "ÿ is for ÿt" 
                   # replacing ÿ with with the top element of the stack
             ,     # print with newline

Palabras usadas: ['Ant', 'Bit', 'Cot', 'Dot', 'Eat', 'Fat', 'Got', 'Hat', 'Ist', 'Jot', 'Kit', 'Lot', 'Mat', 'Nit', 'Oat', 'Pat', 'Qat', 'Rot', 'Sit', 'Tit', 'Unt', 'Vet', 'Wet', 'Xat', 'Yet', 'Zit']

Versión de 33 bytes con algunas palabras de las que no estoy seguro

Au'†Ž•4Ãðzòç•3BSè)øvy¬“ÿ€ˆ€‡ ÿt“,

Palabras: ['Ant', 'Bat', 'Cat', 'Dat', 'Eat', 'Fat', 'Gat', 'Hat', 'Ist', 'Jat', 'Kat', 'Lat', 'Mat', 'Nat', 'Oat', 'Pat', 'Qat', 'Rat', 'Sat', 'Tat', 'Ust', 'Vat', 'Wat', 'Xat', 'Yat', 'Zat']

Emigna
fuente
6

Ruby, 93 84 69 63 58 62 bytes

?A.upto(?Z){|l|puts l+" is for #{"AnDoIsUn"[/#{l}./]||l+?a}t"}

Salida:

A is for Ant
B is for Bat
C is for Cat
D is for Dot
E is for Eat
F is for Fat
G is for Gat
H is for Hat
I is for Ist
J is for Jat
K is for Kat
L is for Lat
M is for Mat
N is for Nat
O is for Oat
P is for Pat
Q is for Qat
R is for Rat
S is for Sat
T is for Tat
U is for Unt
V is for Vat
W is for Wat
X is for Xat
Y is for Yat
Z is for Zat

Todas las palabras de 3 letras que terminan con 't', la mayoría de ellas con 'at'.

Uso de palabras controvertidas (iat, dat, amp. Ump) - 55 bytes:

?A.upto(?Z){|l|puts l+" is for "+l+("AU"[l]?"mp":"at")}

Aún tratando de encontrar un patrón, creo que es posible usar solo 2 terminaciones diferentes y simplificar todo.

Gracias @Value Ink y @Business cat por ayudar.

GB
fuente
1
Qat y Xis (plural de Xi ) son palabras, por lo que puede usarlas y también reducir su expresión regular de búsqueda a/#{l}../
Value Ink
Gracias, estaba pensando en algo similar, pero ahora estoy lejos de mi PC, definitivamente lo comprobaré.
GB
En realidad, estaba tratando de encontrar algunas palabras de 5 letras para las letras que faltaban: matriz, ensayo, incrustación ... Pero estoy atascado en eso. :-(
GB
1
Kat es una palabra válida, por lo que puede eliminar el caso especial para kit.
Business Cat
1
Pensé en "dat" y "zat", pero ambos son la misma conjunción (eso) y argot, ambos tipos de palabras están prohibidas. "amp" y "ump" parecen ser abreviaturas de "ampere" / "amplify" y "umpire". "IAT" es un acrónimo, por lo que tampoco es bueno.
Jonathan Allan
6

///, 163 bytes

/2/ad//1/ is for /A1Add
B1B2
C1C2
D1D2
E1Eat
F1F2
G1Goo
H1H2
I1Irk
J1Job
K1Kob
L1L2
M1M2
N1Nob
O1Owl
P1P2
Q1Qat
R1R2
S1S2
T1T2
U1Use
V1Vat
W1W2
X1X-ray
Y1Yob
Z1Zoo

Pruébalo en línea

Yob - n. - Un tipo cruel y brutal

Hm, aprendí algo hoy ...

Steenbergh
fuente
2
En el Reino Unido, un yob es un patán, un matón o un boor; más grosero y ruidoso que cruel y brutal.
Jonathan Allan
1
En ruso, "Yob" es una forma pasada abreviada de verbo obsceno, que, básicamente, es equivalente a "f * ck" en inglés. Cuanto más sepas ...
Mr Scapegrace
5

05AB1E , 72 68 bytes

Código:

”–³æéÁéî¹àæÑå꧵™Ä‚æ†Í„΢׆™ƒÛÌ´ŸÄ«©‡¯†‚IJ‚Ò„©É€ŠÛì„”#vy¬…ÿ€ˆ€‡ð«ì,

Utiliza la codificación CP-1252 . Pruébalo en línea!

Explicación

El siguiente código:

”–³æéÁéî¹àæÑå꧵™Ä‚æ†Í„΢׆™ƒÛÌ´ŸÄ«©‡¯†‚IJ‚Ò„©É€ŠÛì„”#

empuja esta matriz:

['Apple', 'Banana', 'Carol', 'Door', 'Elephant', 'Frog', 'Goat', 'Hat', 'Ice', 'January', 'Key', 'Love', 'Mom', 'Never', 'Open', 'Paste', 'Queen', 'Rice', 'Star', 'Test', 'Underwear', 'Very', 'Water', 'Xanax', 'Yellow', 'Zoloft']

Y se procesa utilizando el siguiente código:

vy¬…ÿ€ˆ€‡ð«ì,

vy              # For each string in the array
  ¬             # Get the first letter of that string
   …ÿ€ˆ€‡       # Push the string "ÿ is for" where 'ÿ' is the first letter of the string
         ð«     # Append a space character
           ì    # Prepend this string to the current string from the array
            ,   # Print with a newline
Adnan
fuente
¿Puedes explicar por qué eso empuja esa matriz?
Urna mágica del pulpo
Creo que 05AB1E tiene algunas palabras integradas que se pueden representar con 2 bytes en una cadena.
12Me21
@ 12Me21 eso es genial! ”–³”=Appley int(–³,214)=23891todavía no veo la correlación aquí.
Urna mágica del pulpo
Creo que esta es la lista: github.com/Adriandmen/05AB1E/blob/master/dictionary.py
12Me21
2
@carusocomputing Aquí hay una descripción más detallada de cómo funciona la compresión y descompresión.
Adnan
5

Clojure, 159 232 bytes

Bueno, ahora es una solución que no compite, ya que sería mucho más fácil codificar las palabras utilizadas. Exponerlo solo por el simple hecho de tener la respuesta correcta (y no usar la lista de palabras de otros).

(mapv #(println(str(char %)" is for"(first(re-seq(re-pattern(str" "(char(+ % 32))"+\\w{3,} "))
    (reduce(fn[a b](str a(with-out-str(load-string(str "(doc "b")")))))" xyst "(map str(keys(ns-publics 'clojure.core))))))))(range 65 91))

Básicamente, todavía obtiene todas las funciones definidas en el clojure.coreespacio de nombres, pero después de eso lo evalúa doc <function name>y lo pone en cadena. Después de eso lo concatena en una gran cadena (con la palabra xyst) y encuentra las palabras apropiadas a partir de ahí. Debe ejecutarse en Clojure REPL.

Salida:

A is for arbitrary
B is for being
C is for changes
D is for determined
E is for exception
F is for failed
G is for given
H is for held
I is for items
J is for java
K is for keys
L is for lazy
M is for must
N is for notified
O is for option
P is for performed
Q is for queued
R is for returns
S is for state
T is for true
U is for uses
V is for validator
W is for were
X is for xyst
Y is for yields
Z is for zero

Vieja solución:

(mapv #(println(str(char %)" is for "(some(fn[a](and(=(.charAt a 0)(char(+ % 32)))a))(conj(map str(keys(ns-publics 'clojure.core)))"orb""yes"))))(range 65 91))
acantilado
fuente
or, no orb, por 1 byte.
wizzwizz4
1
La longitud mínima es de 3 letras
12Me21
@ mbomb007 actualizado.
Cliffroot
4

JavaScript (ES6), 82 bytes

_=>btoa`pb
è¡Záî"Âh*"è1£b:ãÚA¤hJ$âRu^YåÚaæb`.replace(/(.)./g,`$1 is for $&t
`)

Una función anónima que devuelve una cadena. Contiene no imprimibles; Aquí hay una versión que no:

_=>btoa`\x02pb
\x80è\x11¡Z\x18áî"Âh*"è1£b:ãÚA¤hJ$âRu^YåÚaæb`.replace(/(.)./g,`$1 is for $&t
`)

Esto usa la técnica de @ JonathanAllen, usando solo palabras de tres letras que terminan en t. La cadena se descomprime en AnBiCoDoEaFaGOHuIsJoKiLoMaNiOuPaQaRoSiTiUnVeWeXaYeZi.

Intenté encadenar pares de dos letras así:

Ace
 Bee
  Cee
   Dew
    Ewe
     ...

Ahora he llegado hasta el final Xpero me quedé atascado Y; Por lo que puedo decir, la única Xpalabra alcanzable de tres letras es Xis, y no hay una palabra de tres letras que empiece Ys.

Para el registro, la cadena completa era ceeeweeereueaebiueeiziais...

ETHproducciones
fuente
Según Wiktionary, podría usar uziy tiz...
DLosc
@DLosc Gran idea. Entonces tendría que hacer sei, skio sri, que te deja con ree, roe, rue, rye, que te deja con la única ... tres letras q-palabras que puedo encontrar son qat, qisy qua. ¿Hay una página de Wiktionary con más palabras de tres letras?
ETHproductions
Hay una categoría para palabras de tres letras, pero no es una lista completa. Por ejemplo, no contiene que (que solo conozco porque otra respuesta aquí lo usó). (Sin embargo, no estoy seguro de que haya una ppalabra que termine en u).
DLosc
@DLosc ya estaba usando piu, así que eso no es un problema en absoluto: P ¡Gracias!
ETHproductions
Hm. piuparece bastante límite: wiktionary no lo tiene como inglés, y dictionary.com lo tiene como più(no sé cómo estamos considerando los acentos para este desafío). Pero sí, ys_sería un problema.
DLosc
3

Mathematica, 97 bytes

a@c_:={ToUpperCase@c," is for ",Select[WordList[],#~StringTake~1==c&][[3]],"
"};a/@Alphabet[]<>""

Busca en Mathematica WordListla tercera palabra que comienza con cada letra; esto evita palabras de una letra e interjecciones. Tiene una nueva línea trailng.

A is for aardvark
B is for babble
C is for cabala
D is for dabbled
E is for eagerly
F is for fable
G is for gabble
H is for haberdashery
I is for iambus
J is for jabberer
K is for kaleidoscope
L is for label
M is for mac
N is for nacelle
O is for oak
P is for pabulum
Q is for quackery
R is for rabbinate
S is for sable
T is for tabbouleh
U is for udder
V is for vacant
W is for wad
X is for xenophobic
Y is for yachting
Z is for zapper
Greg Martin
fuente
sí, totalmente olvidado, gracias
Greg Martin
3

Groovy, 76 73 bytes

(editado de 76 a 73 bytes, gracias gato)

Inspirado en la solución de rubí:

('A'..'Z').any{i->println"$i is for ${'AntIvyUse'.find(/$i../)?:i+'at'}"}

usamos en anylugar de cada uno, ya que es más corto y todas las declaraciones println devuelven falso. Para los casos especiales en la cadena, usamos String.find que en groovy devuelve la coincidencia o nulo. En nulo usamos el operador elvis ?:para devolver una palabra que termina en su atlugar.

Imprime:

A is for Ant
B is for Bat
C is for Cat
D is for Dat
E is for Eat
F is for Fat
G is for Gat
H is for Hat
I is for Ivy
J is for Jat
K is for Kat
L is for Lat
M is for Mat
N is for Nat
O is for Oat
P is for Pat
Q is for Qat
R is for Rat
S is for Sat
T is for Tat
U is for Use
V is for Vat
W is for Wat
X is for Xat
Y is for Yat
Z is for Zat

Groovy, recursividad, 74 bytes

{i->println"$i is for ${'AntIvyUse'.find(/$i../)?:i+'at'}";call(++i)}('A')

imprime el texto de la primera respuesta y luego lanza una PatternFormatException. Llamamos al cierre de forma recursiva comenzando con 'A' e incrementándolo ++charhasta que el personaje luego de Zlanzar el error.

Groovy, por trampa, 77 bytes

Con el riesgo de ser linchado:

print 'http://codegolf.stackexchange.com/q/109502'.toURL().text[21796..22189]

es decir, lea los datos en esta página e imprima la definición de una respuesta válida al principio. En mi defensa ... imprime la respuesta solicitada ... ahora nadie edita la página ...

Groovy, usando 'tiempos', 81 bytes

Sobre la base de la respuesta de Python con el patrón de palabras de tres letras:

26.times{i,c=i+65->printf"%c is for %c${'niooaauusoioaiuaaoiineeaei'[i]}t\n",c,c}

huellas dactilares:

A is for Ant
B is for Bit
C is for Cot
D is for Dot
E is for Eat
F is for Fat
G is for Gut
H is for Hut
I is for Ist
J is for Jot
K is for Kit
L is for Lot
M is for Mat
N is for Nit
O is for Out
P is for Pat
Q is for Qat
R is for Rot
S is for Sit
T is for Tit
U is for Unt
V is for Vet
W is for Wet
X is for Xat
Y is for Yet
Z is for Zit

Groovy, recurriendo en main (...), 83 bytes

Suponiendo que contamos las nuevas líneas como un personaje.

i=args?args[0]:'A'
println"$i is for ${'AntIvyUse'.find(/$i../)?:i+'at'}"
main(++i)

imprime el texto de la primera respuesta y luego lanza una PatternSyntaxException.

Groovy, usando eachWithIndex, 88 bytes

'niooaauusoioaiuaaoiineeaei'.eachWithIndex{c,i->char x=i+65;println "$x is for $x${c}t"}

Groovy, usando transposición, 102 bytes

['A'..'Z','niooaauusoioaiuaaoiineeaei'as List].transpose().each{println it[0]+" is for ${it.join()}t"}
Matias Bjarland
fuente
Kat es una palabra válida, por lo que puede eliminar el caso especial para kit.
Business Cat
editado, gracias. Me salvó 3 bytes
:)
2

05AB1E , 77 bytes

•‹T1qA‹rËöf#ùqÈ$>M©ÈñM£r°§°Ü]€¡3¸/©#bÍ'ò7DÉø½D—¹û©˜Òו36B3ôvy™¬"ÿ is for ÿ"}»

Pruébalo en línea!

Utiliza la siguiente cadena comprimida:

ASSBINCATDOTEATFATGOTHATILLJOTKITLOTMETNOTOATPATQUEROTSETTITUSEVATWETXISYIPZAP

Convertido a Base-214:

‹T1qA‹rËöf#ùqÈ$>M©ÈñM£r°§°Ü]€¡3¸/©#bÍ'ò7DÉø½D—¹û©˜Ò×

Usó una lista de palabras de scrabble de 3 letras: http://wordfinder.yourdictionary.com/letter-words/3

La salida es la siguiente:

A is for Ass
B is for Bin
C is for Cat
D is for Dot
E is for Eat
F is for Fat
G is for Got
H is for Hat
I is for Ill
J is for Jot
K is for Kit
L is for Lot
M is for Met
N is for Not
O is for Oat
P is for Pat
Q is for Que
R is for Rot
S is for Set
T is for Tit
U is for Use
V is for Vat
W is for Wet
X is for Xis
Y is for Yip
Z is for Zap

Tenía una versión de 70 bytes, pero no se permiten palabras de 2 letras.


Explicado:

•‹T1qA‹rËöf#ùqÈ$>M©ÈñM£r°§°Ü]€¡3¸/©#bÍ'ò7DÉø½D—¹û©˜Òו # Compressed String

36B3ô                   # Decompress, split into 3s.
     v               }  # For each word...
      y™¬"ÿ is for ÿ"   # Take first letter of word, interpolate.
                      » # Print with newlines.
Urna de pulpo mágico
fuente
quiNo es una palabra inglesa. Buscar esto revela solo una palabra latina.
mbomb007
Se suponía que @ mbomb007 era Que. Sabía que había una palabra de scrabble legal de 3 letras, la escribí mal.
Urna mágica del pulpo
Bonitas palabras :) podrían ser reemplazadas por ,.
Emigna
2

SmileBASIC, 131 113 82 81 bytes

FOR I=1TO 26L$=CHR$(I+64)?L$;" is for ";L$;@niooaauusoioaiuaaoiineeaei[I];"t
NEXT

Ahora usando palabras que en t

12Me21
fuente
Ejemplo de salida?
caracol_
2

Lithp , 136 125 117 bytes

((import lists)(each(split "niooaauusoioaiuaaoiineeaei" "")
#X,C::((print(chr(+ 65 C))"is for"(+(chr(+ 65 C))X "t"))))

(División para facilitar la lectura)

Pruébalo en línea!

Esto es más o menos un puerto de la respuesta de Python

  • Guardado 11 bytes usando each el índice de
  • Ahorró 8 bytes al eliminar llamadas inútiles a (scope #)

Salida:

A is for Ant
B is for Bit
C is for Cot
D is for Dot
E is for Eat
F is for Fat
G is for Gut
H is for Hut
I is for Ist
J is for Jot
K is for Kit
L is for Lot
M is for Mat
N is for Nit
O is for Out
P is for Pat
Q is for Qat
R is for Rot
S is for Sit
T is for Tit
U is for Unt
V is for Vet
W is for Wet
X is for Xat
Y is for Yet
Z is for Zit
Andrakis
fuente
2
¡Gran nombre! (No, por un litp, ¿no me parece que el idioma tiene esa voz?)
Jonathan Allan
1
¡Gracias! No, el idioma está bien con la pronunciación. Es más que una versión bastarda de Lisp. Acabo de encontrar a Lisp demasiado difícil de entender, Lithp es mi opinión de una manera que tiene sentido para mí. Debería ser mucho más legible que la mayoría de los códigos Lisp.
Andrakis
1

Lote, 250 bytes

@set s=ABCDEFGHIJKLMNOPQRSTUVWXYZ
@for %%w in (eon dellium zar jinn lbow hon nat our rk unta not lama nemonic domo uija sycho uay ye ee sunami rn ex rap enophobe ou ugzwang)do @call:c %%w
@exit/b
:c
@echo %s:~0,1% is for %s:~0,1%%1
@set s=%s:~1%

Como nunca iba a obtener una puntuación decente, busqué las palabras humorísticas más cortas que pude encontrar:

A is for Aeon
B is for Bdellium
C is for Czar
D is for Djinn
E is for Elbow
F is for Fhon
G is for Gnat
H is for Hour
I is for Irk
J is for Junta
K is for Knot
L is for Llama
M is for Mnemonic
N is for Ndomo
O is for Ouija
P is for Psycho
Q is for Quay
R is for Rye
S is for See
T is for Tsunami
U is for Urn
V is for Vex
W is for Wrap
X is for Xenophobe
Y is for You
Z is for Zugzwang
Neil
fuente
1

apilado , 72 bytes

¡Hay dos para 72 bytes!

65@i$'niooaauusoioaiuaaoiineeaei'{!i#::' is for '+\n+'t'+ +out i 1+@i}"!
{!n#::' is for '+\'niooaauusoioaiuaaoiineeaei'n 65-#+'t'+ +out}65 90 for

Pruébalo en línea! Usando ese patrón impresionante. (Antes de preguntar, ++sería un solo token, por lo que + +se usa en su lugar).

Ambos funcionan iterando de 65a 90y obteniendo la secuencia de caracteres correcta. Notas:

  • #: es un alias para chr
  • # es un alias para get
  • {!...}es lo mismo que { n : ... }(lambda con ncomo parámetro)

Para 73 bytes:

'niooaauusoioaiuaaoiineeaei'toarr{e i:65 i+#::' is for '+\e+'t'+ +out}map
Conor O'Brien
fuente
1

Mathematica 93 Bytes

ToUpperCase@#<>" is for "<>Cases[WordList[],s_/; s~StringPart~1==#][[9]]&/@Alphabet[]//Column

rendimientos

A is for abandoned
B is for babushka
C is for cabin
D is for dactylic
E is for eardrum
F is for fabricator
G is for gadabout
H is for habitation
I is for ice
J is for jackal
K is for kappa
L is for laboratory
M is for macaroni
N is for nagger
O is for oarsman
P is for pachysandra
Q is for quadratic
R is for rabidness
S is for saccharin
T is for tableland
U is for ulcer
V is for vacationist
W is for wadi
X is for xylene
Y is for yammer
Z is for zebra
Kelly Lowder
fuente
1

Groovy, 72 bytes

c=65;"niooaauusoioaiuaaoiineeaei".any{printf"%c is for %<c%st\n",c++,it}

Salida

A is for Ant
B is for Bit
C is for Cot
D is for Dot
E is for Eat
F is for Fat
G is for Gut
H is for Hut
I is for Ist
J is for Jot
K is for Kit
L is for Lot
M is for Mat
N is for Nit
O is for Out
P is for Pat
Q is for Qat
R is for Rot
S is for Sit
T is for Tit
U is for Unt
V is for Vet
W is for Wet
X is for Xat
Y is for Yet
Z is for Zit
Peter De Bruycker
fuente
1

Python 3, 145 137 135 bytes

Sacrifiqué algunos bytes para seudoaleatorizar la salida con cada ejecución. La idea es buscar palabras en minúscula de al menos 3 caracteres /usr/share/dict/wordsy luego elegir una de esa lista usando id([x])%99.

import re
for x in range(65,91):print("%c is for "%x+re.findall("\n(%c.{3,})"%(x+32),open('/usr/share/dict/words').read())[id([x])%99])

Ediciones

  • Eliminado title()ya que las palabras no tienen que ser mayúsculas
  • Cambió la expresión regular a "\n(%c.{3,})"(+ 3 bytes) para permitir la eliminación de ,re.M(- 5 bytes).

Salida de ejemplo:

A is for abacinate
B is for bacchantic
C is for caback
D is for dactylosternal
E is for eagless
F is for factful
G is for gabbroic
H is for hackneyed
I is for iambize
J is for jacutinga
K is for kadaya
L is for labra
M is for macaco
N is for nailwort
O is for oakenshaw
P is for pachysomia
Q is for quachil
R is for racer
S is for sabbath
T is for tabulable
U is for ubication
V is for vagabondism
W is for wabe
X is for xenobiosis
Y is for yacca
Z is for zeed
PidgeyUsedGust
fuente
No estoy seguro de que todos sean válidos. Por ejemplo, no puedo encontrar una definición para Qohele, aunque una búsqueda revela que es un libro o un volumen de texto sagrado.
Andrakis
1
Acabo de notar que mi expresión regular no coincide hasta el final de cada palabra, se solucionará.
PidgeyUsedGust
Arreglado. Ahora solo busca palabras en minúsculas y completas para no tener nombres allí.
PidgeyUsedGust
1

GNU sed, 81 + 1 (r flag) = 82 bytes

Esta es una implementación sed de la lista de palabras de la respuesta de Jonathan Allan .

s:$:AnBiCoDoEaFaGuHuIsJoKiLoMaNiOuPaQaRoSiTiUnVeWeXaYeZi:
s:(.).:\1 is for &t\n:g

Las palabras, excepto la letra final compartida t , se dan en forma concatenada en la línea 1, y luego se imprimen en el formato solicitado por la línea 2. Una nueva línea final está presente.

Ejecutar :

sed -rf alphabet_song.sed <<< ""
seshoumara
fuente
1

Java 7, 124 121 bytes

String c(){String r="";for(char c=65;c<91;r+=c+" is for "+c+"baaonaiineioaeaoaaeileeaoi".charAt(c++-65)+"t\n");return r;}

Basado en la respuesta de @JonathanAllen , ya que Java no tiene un elegante diccionario incorporado. ;) Traté de encontrar otra letra final para todo el alfabeto (like so nor y), o una letra del medio (like ao e), pero a la mayoría le faltaban solo una o dos palabras, así que terminé usando ttambién. Las palabras se eligen manualmente de wordhippo.com .

Sin golf:

Pruébalo aquí

class M{
  static String c(){String r="";for(char c=65;c<91;r+=c+" is for "+c+"baaonaiineioaeaoaaeileeaoi".charAt(c++-65)+"t\n");return r;}

  public static void main(String[] a){
    System.out.println(c());
  }
}

Salida:

A is for Abt
B is for Bat
C is for Cat
D is for Dot
E is for Ent
F is for Fat
G is for Git
H is for Hit
I is for Int
J is for Jet
K is for Kit
L is for Lot
M is for Mat
N is for Net
O is for Oat
P is for Pot
Q is for Qat
R is for Rat
S is for Set
T is for Tit
U is for Ult
V is for Vet
W is for Wet
X is for Xat
Y is for Yot
Z is for Zit
Kevin Cruijssen
fuente
1
+1 para +a+++. Me gusta escribir esos: P
Poke
1

PHP, 91 87 86 76 bytes

basado en la lista de palabras de Jonathan Allan :

for($a=A;$i<26;)echo"$a is for ",$a++,neaoaaeiseioeuuoaaiineiaei[$i++],"t
";

versiones anteriores, 86 bytes:

for($a=A;a&$c=reaoaaei0eioeuuoaaii0eiaei[$i++];)echo"$a is for ",$a++,$c?$c.t:nto,"
";

o

for($a=A;$c=reaoaaeiHeioeuuoaaiiHeiaei[$i++];)echo"$a is for ",$a++,$c^x?$c.t:nto,"
";

Corre con -nr.

salida

A is for Art
B is for Bet
C is for Cat
D is for Dot
E is for Eat
F is for Fat
G is for Get
H is for Hit
I is for Into
J is for Jet
K is for Kit
L is for Lot
M is for Met
N is for Nut
O is for Out
P is for Pot
Q is for Qat
R is for Rat
S is for Sit
T is for Tit
U is for Unto
V is for Vet
W is for Wit
X is for Xat
Y is for Yet
Z is for Zit

Para las palabras raras, vea la respuesta de Ismael

Titus
fuente