Criar uma música do alfabeto

55

Seu objetivo é criar uma música do alfabeto como texto no seguinte formato (em ordem):

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>

Exemplo de saída:

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

Regras:

  • Cada "letra" da música tem sua própria linha, então há 26 linhas e um possível avanço de linha à direita.

  • A saída diferencia maiúsculas de minúsculas:

    • A letra no início de cada linha deve ser maiúscula.
    • is for é minúsculo.
    • A palavra escolhida não precisa ser maiúscula, mas pode ser. Todas as linhas devem ser consistentes.
  • A palavra escolhida para cada linha é com você, mas deve ser uma palavra em inglês válida com pelo menos três letras e não pode ser uma conjunção (como andou but), interjeição / exclamação (como heyou yay), abreviação (como XLS) ou uma nome (como Jon).

  • Embora eu duvide que alguém ache mais curto, acho aceitável usar uma frase em vez de uma única palavra. Portanto, se por algum motivo S is for Something smells fishy...for mais curto, vá em frente.

  • Coloque a saída do seu programa na sua resposta ou pelo menos na lista de palavras que você usou (se houver um link para executar seu código on-line, não precisamos ver a saída inteira).

  • O código mais curto vence


Este desafio foi inspirado neste vídeo .

mbomb007
fonte
Eu estou supondo que gírias não são permitidas, mesmo que listadas nos dicionários adequados? (por exemplo: "Quando ela percebeu que estava voltando para o interior novamente, apenas puxou um uey !")
Jonathan Allan Em
11
Dadas algumas das respostas, essa música de Barenaked Ladies parece relevante.
AdmBorkBork 8/17/17
11
@JonathanAllan Sem gírias. Os dicionários contêm muitas coisas que não são tecnicamente palavras. Abreviações é uma, gíria é outra.
Mbomb007
4
É uma pena que isso tenha acabado na busca de três palavras da letra que terminem na mesma letra.
12Me21
11
Existem algumas respostas usando um dicionário externo. Eles não deveriam adicionar o tamanho desse arquivo ao código?
pipe

Respostas:

3

SOGL 0.8.1 , 60 32 bytes

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

Explicação:

χ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 é praticamente a resposta de Jonathan Allan , mas portada para esse idioma.

Versão antiga: (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)

resultado:

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 não é o mais curto que esse idioma pode fazer, mas deve ser o melhor com as palavras codificadas.

dzaima
fonte
57

Bash (+ coreutils), 81, 87, 82, 78 bytes

Usa a página de manual do X , como a fonte das palavras.

Golfe

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

EDITAR% S

  • Usou uma página de manual 'xyst' não existente + |&para salvar 5 bytes;
  • Economizou mais 4 bytes, trocando sed e sort .

Teste

%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 
zepelim
fonte
3
São palavras lsof e xregs? :)
OldBunny2800
11
@ OldBunny2800 deve ser corrigido agora
zeppelin
2
Eu procurei, e sim, xyst é uma palavra real. :)
OldBunny2800
3
Parece que as crianças vão aprender algumas grandes palavras. : D
mbomb007
11
@JonathanAllan Infelizmente, a página de manual para "x" não está disponível no TIO, mas aqui está o link tio.run/nexus/… , que usa "man man". O truque do xyst é que o man xyst irá reclamar que não há "Entrada manual para o xyst" no stderr, que é então mesclado no stdout com |&, para que possa ser recebido.
Zeppelin
33

Python 2 , 88 77 bytes

-11 bytes graças ao xnor (evite o zip atravessando a string e contando caté 65)

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

Experimente online!

(Uma porta da minha resposta Jelly, quando tinha 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
fonte
4
Eu gosto do método das palavras que terminam em t. A iteração pode ser reduzida, atualizando xem paralelo .
xnor 8/17
Muito esperto, como sempre; obrigado!
Jonathan Allan
11
O que é Unt? Não pode achar que um em qualquer lugar
Albert Renshaw
Eu não acho que Unté uma palavra, mas Uté para que você possa substituir o nno seu literal por \0para tornar isso válido e adicionar apenas mais um byte. Editar Nevermind regras dizem que tem que ser 3 letras ... hmmm
Albert Renshaw
4
@AlbertRenshaw Um unt é uma toupeira europeia de acordo com a Merriam-Webster . Uma alternativa seria ult, de acordo com o Wikcionário , não é apenas uma abreviação (que é listada com períodos, como ult. ).
Jonathan Allan
31

Bater, 78, 69 bytes

Aardvarks, Babushkas e Kamikazes!

Golfe

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

EDITAR% S

  • Livre-se do grep, -9 bytes

Teste

%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

Utiliza / usr / share / dict / words :

words é um arquivo padrão em todos os sistemas operacionais Unix e Unix-like, e é simplesmente uma lista delimitada por nova linha de palavras do dicionário. É usado, por exemplo, por programas de verificação ortográfica.

zepelim
fonte
14

PowerShell , 150 141 117 75 bytes

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

Experimente online!

Loops de 65para 90(ou seja, ASCII Apara Z). A cada iteração, transformamos o número inteiro no apropriado char(ou seja, ASCII 65para A), salvamos isso $ipara uso posterior, concatenamos a string com is for $ie depois aderimos no meio da palavra apropriada. Isso é feito indexando em uma cadeia longa (emprestada da resposta de Jonathan Allan ). Termina com a letra tpara formar a palavra de três letras.

As seqüências resultantes são todas deixadas no pipeline e um implícito Write-Outputno final as imprime com novas linhas no meio.

Economizei um monte de bytes graças à lista de palavras com Rod
Borrowed da resposta de Jonathan Allan

AdmBorkBork
fonte
você pode remover a primeira letra de cada palavra (a maiúscula) e imprimir com [char]$ exemplo
Rod
@ Rod Obrigado. Eu juntei isso ao que eu estava trabalhando para mudar a maneira como o loop é calculado e como a indexação é calculada e salva ainda mais.
AdmBorkBork 8/17/17
13

Geléia , 39 bytes

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

TryItOnline!

Com base na versão de 56 bytes (dois abaixo), mas as palavras alteradas para remover todas as letras do meio "u"s, para que possam ser indexadas na palavra do dicionário "anisole"*, que tem a conveniência de ter as letras necessárias em índices inferiores a seis: 1:a, 2:n 3:i, 4:s, 5:o (6:l), 0:e(observe o "e"à direita está no índice zero [também 7 e -7 e qualquer outro número congruente a 0 mod 7]). Também é cedo no dicionário, portanto, possui apenas um índice de dois bytes, em vez do índice de pesquisa de três bytes, muito mais comum ( "anisogamete"também funcionaria para 2).

* O nome da velha escola para o éter aromático metoxibenzeno, frequentemente usado em 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

Quão?

“¤ṁ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 as palavras têm segunda letra "s" ou "a" e última letra "p" ou "t" usando uma pesquisa de base quatro em um produto cartesiano de "sa" e "pt". Exceto a palavra "U", que o código muda para "Use" (usando o relativamente volumoso F”e272¦no final) - se eu conseguisse encontrar uma lista de palavras como essa que não tenha uma exceção, estaríamos olhando para 39 bytes .

Lista de palavras:

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

tente este


56 bytes anteriores

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

Lista de palavras:

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

Está formatado, experimente


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

... jogamos "Mancha que letra não tem um animal!" existe um, e apenas um - cuidado com o arenque vermelho (uma mentira, o arenque vermelho era xenon, que é um elemento, obviamente não é um animal) , são duas palavras de cinco letras aqui que não são animais (o xenônio é um) :

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

(é claro que isso está formatado corretamente, tente - eu apenas pensei em economizar espaço)

Jonathan Allan
fonte
Xenonnão é um animal. Eu tinha certeza que você estava fazendo uma piada H is for Herring, mas acho que não.
mbomb007
Heh, era mentira. Xenon era o óbvio :)
Jonathan Allan
Eu acho que eles estão pensando em xenop , que não está no dicionário de Jelly.
Jonathan Allan
Ideia maravilhosa! Mas Uut?
Greg Martin
@ GregMartin Eu concordo, acho que você começou a devolver suas palavras em grunhidos silábicos.
Magic Octopus Urn
10

Retina , 89 87 bytes

Economizou 2 bytes graças a Martin Ender


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

m`$
t

Experimente online!

Eu escolhi uma palavra para cada letra que termina em t(algumas são bastante obscuras).

Explicação


ApBaCaDoEaFaGeHaIkaJeKiLeMeNeOpPeQaRaSaTiUniVaWeXysYurZi

Substitua a entrada inexistente (vazia) pelo texto acima.

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

Substitua cada letra maiúscula por (newline)(itself) is for (itself). Isso resulta no texto acima sendo dividido em linhas separadas, como

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

... e assim por diante

^¶
​

No entanto, como a nova linha foi colocada antes de cada capital, há uma nova linha principal que deve ser removida. É removido nesta fase.

m`$
t

Coloque a tno final de cada linha, pois todas as palavras usadas na música terminam em t.

Gato de negócios
fonte
Você não precisa capturar a letra maiúscula. Basta usar $&ou em $0vez de $1. Na verdade, isso também pode salvar bytes no meu estágio dividido.
Martin Ender
@MartinEnder Thanks. O que $&faz exatamente? Eu não o vi no wiki do GitHub.
Business Cat
É um alias para $0(e é apenas parte do sabor do .NET, assim como a maioria dos outros sabores).
Martin Ender
Usando algumas palavras mais curtas para obtê-lo para baixo para 83, experimentá-lo on-line
Jonathan Allan
8

Retina , 92 88 bytes

Economizou 4 bytes emprestando uma idéia da resposta do Business Cat .

A contagem de bytes assume a codificação ISO 8859-1.


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

Experimente online!

Com base na lista de palavras do AdmBorkBork , mas mudei mais algumas palavras para aquelas que terminam em adpara salvar mais bytes no sufixo comum.

Explicação


AddBCDEelFGHItsJetKitLMNetOilPQatRSTUrnVatWXisYesZit

Transforme a entrada vazia (inexistente) nessa string. Ele contém todas as letras e o restante das palavras que não terminam ad.

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

Insira um avanço de linha antes de cada letra maiúscula e depois transforme-o em X is for X.

m` .$
$&ad

Combine as letras que agora estão sozinhas e acrescente adpara completar as palavras abreviadas.

G`.

Descarte a linha vazia que foi criada inserindo um avanço de linha antes A.

Martin Ender
fonte
8

PHP, 122 124 127 120 115 101 bytes

Segue a <letter><filler>testrutura "padrão" .
Tentei inventar palavras que antes não eram usadas por ninguém.
Se você vir uma palavra que deseja que eu substitua, me diga.

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

A nova linha é representada como \ncontada como 1 byte.


Resultado:

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

Palavras estranhas:

  • ikat :

    Ikat, ou ikkat, é uma técnica de tingimento usada para modelar tecidos que emprega resistência ao tingimento nos fios antes de tingir e tecer o tecido.

  • xat :

    Um poste esculpido erguido como um memorial aos mortos por alguns índios do oeste da América do Norte

  • espinha :

    uma espinha; manchas na pele.

  • qat :

    Catha edulis (khat, qat) é uma planta nativa do Chifre da África e da Península Arábica.

Ismael Miguel
fonte
Solução inteligente, eu ia fazer algo semelhante, feliz em ver isso! 1
Albert Renshaw
11
Estas não são palavras inglesas ....
Conor O'Brien
@ ConorO'Brien Você tem certeza? O PHP é todo escrito em inglês, até onde eu sei.
Ismael Miguel
5
Coisas @IsmaelMiguel gostam vprintfe zend_versioncertamente não são palavras em inglês. Muito poucas dessas entidades são realmente palavras.
Conor O'Brien
11
Eu não chamaria zituma palavra estranha, pelo menos, acho que todo mundo já deveria saber o que isso significa.
mbomb007
6

Pyke, 55 51 48 bytes

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

Experimente aqui!

O link tem três dimensões e não se qualifica, pois as palavras incluem conjuntivos.

    [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()

Saídas:

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

Você pode testar isso fora do Pyke usando o mesmo algoritmo. Requer 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
fonte
Não. Além disso, recebo um erro ao executar seu código.
mbomb007
Timeout running code. BAD EVALAtualize o link "Experimente online".
Mbomb007
2
Z is for zoofiliaEu consideraria seriamente antes de deixar meus filhos cantarem isso.
Zeppelin
Para quem faz uma dupla olhada como eu: inglês nem sempre é maiúsculo. ;)
DLosc 8/17
6

Japt , 52 50 bytes

Colaborou com @ETHproductions

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

Contém muitos não imprimíveis. Teste online!

A lista de palavras é:

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 a biblioteca de compactação de string shoco , que reduz execuções comuns de letras minúsculas em um byte. Aqui está uma lista completa de todas as execuções de duas letras que são condensadas em um 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

Portanto, a idéia é formar uma palavra com um desses pares para cada letra do 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

Uma coisa interessante a ser observada é que, embora o Japt possa descomprimir implicitamente uma string envolvida em backticks, na verdade é um byte a mais aqui, porque você precisaria pegar dois caracteres na string descompactada, em vez de um.

Oliver
fonte
6

05AB1E , 45 42 39 38 37 36 bytes

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

Experimente online!

Explicação

Auempurra o alfabeto maiúsculo.
'Æåempurra a palavra scenario.
•à¡P°€kš¦zᮕempurra o número da base 10 36774474076746444766322426.
usa esses dígitos para indexar scenario.
fecha essas cadeias na 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

Palavras 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']

Versão de 33 bytes usando algumas palavras que não tenho certeza

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

Palavras: ['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
fonte
6

Ruby, 93 84 69 63 58 62 bytes

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

Resultado:

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 as palavras de três letras terminadas com 't', a maioria com 'at'.

Usando palavras controversas (iat, dat, amp. Ump) - 55 bytes:

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

Ainda tentando encontrar um padrão, acho que é possível usar apenas 2 finais diferentes e simplificar tudo.

Obrigado @Value Ink e @Business cat por ajudar.

GB
fonte
11
Qat e Xis (plural de Xi ) são palavras, portanto você pode usá-las e também reduzir sua regex de pesquisa para/#{l}../
Value Ink
Obrigado, eu estava pensando em algo semelhante, mas agora estou longe do meu PC, vou verificar isso definitivamente.
GB
Na verdade, eu estava tentando encontrar algumas palavras de cinco letras para as letras que faltavam: matriz, ensaio, embutimento ... Mas estou presa a isso. :-(
GB
11
Kat é uma palavra válida, para que você possa remover o caso especial de kit.
Business Cat
11
Pensei em "dat" e "zat", mas ambos são a mesma conjunção (isso) e gíria, cujos tipos de palavras são barrados. "amp" e "ump" parecem ser abreviações de "ampere" / "amplify" e "árbitro". "IAT" é um acrônimo, então também não é bom.
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

Experimente online

Yob - n. - Um sujeito cruel e brutal

Hm, aprendi alguma coisa hoje ...

steenbergh
fonte
2
No Reino Unido, um idiota é um grosseiro, um bandido ou um boor; mais rude e turbulento do que cruel e brutal.
Jonathan Allan
11
Em russo, "Yob" é uma forma abreviada de verbo obsceno, que basicamente é equivalente a "f * ck" em inglês. Quanto mais você sabe ...
Sr. Patife
5

05AB1E , 72 68 bytes

Código:

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

Usa a codificação CP-1252 . Experimente online!

Explicação

O código a seguir:

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

empurra 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']

E é processado usando o seguinte 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
fonte
Você pode explicar por que isso empurra essa matriz?
Magic Octopus Urn
Eu acho que 05AB1E tem algumas palavras construídas que podem ser representadas por 2 bytes em uma string.
12Me21
@ 12Me21 que legal! ”–³”=Applee int(–³,214)=23891ainda não vejo a correlação aqui.
Magic Octopus Urn
Eu acredito que esta é a lista: github.com/Adriandmen/05AB1E/blob/master/dictionary.py
12Me21
2
@carusocomputing Aqui está uma descrição mais detalhada de como a compactação e descompactação funciona.
Adnan
5

Clojure, 159 232 bytes

Bem, agora é certamente uma solução não concorrente, pois seria muito mais fácil codificar as palavras usadas. Colocá-lo lá fora apenas por uma questão de ter correto resposta (e não usar a lista de palavras de outras pessoas).

(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))

Basicamente, ainda obtém todas as funções definidas em clojure.core espaço nome, mas depois a avalia doc <function name>e a coloca em string. Depois disso, concatena-o em uma cadeia enorme (com a palavra xyst) e encontra as palavras apropriadas a partir daí. Deve ser executado no Clojure REPL.

Resultado:

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

Solução antiga:

(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))
cliffroot
fonte
or, não orb, por 1 byte.
Wizzwizz4
11
O comprimento mínimo é de 3 letras
12Me21
@ mbomb007 atualizado.
Cliffroot
4

JavaScript (ES6), 82 bytes

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

Uma função anônima que retorna uma string. Contém imprimíveis; aqui está uma versão que não:

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

Isso usa a técnica de @ JonathanAllen, usando apenas palavras de três letras que terminam em t. A cadeia descompacta paraAnBiCoDoEaFaGOHuIsJoKiLoMaNiOuPaQaRoSiTiUnVeWeXaYeZi .

Tentei encadear pares de duas letras da seguinte maneira:

Ace
 Bee
  Cee
   Dew
    Ewe
     ...

Eu já fiz todo o caminho, Xmas fiquei preso Y; até onde eu sei, a única Xpalavra possível de três letras é Xise não há nenhuma palavra de três letras começando com Ys.

Para o registro, a sequência completa era ceeeweeereueaebiueeiziais...

ETHproductions
fonte
De acordo com Wiktionary, você poderia usar uzie tiz...
DLosc
@DLosc Ótima idéia. Então você teria que fazer sei, skiou sri, que deixa você com ree, roe, rue, rye, que deixa você com ... a única de três letras q-words posso encontrar são qat, qise qua. Existe uma página do Wikcionário com mais palavras de três letras?
ETHproductions
Há uma categoria para palavras de três letras, mas não é uma lista completa. Por exemplo, ele não contém que (o que eu sei apenas porque outra resposta aqui o usou). (Não tenho certeza que há uma p-palavra que termina com u, no entanto.)
DLosc
@DLosc eu já estava usando piu, então isso não é um problema: P Obrigado!
ETHproductions
Hum. piuparece bastante limítrofe - o wikcionário não o tem como inglês e o dictionary.com o tem più(não sei como estamos considerando os acentos para esse desafio). Mas sim, ys_seria um problema.
DLosc 9/02
3

Mathematica, 97 bytes

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

Procura no Mathematica WordLista terceira palavra que começa com cada letra; isso evita palavras de uma letra e interjeições. Tem uma nova linha 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
fonte
eep, esqueci completamente, graças
Greg Martin
3

Groovy, 76 73 bytes

(editado de 76 a 73 bytes, obrigado gato)

Inspirado na solução ruby:

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

usamos em anyvez de cada um, pois é mais curto e todas as instruções println retornam falsas. Para os casos especiais da string, usamos String.find, que no groovy retorna a correspondência ou nulo. Em null, usamos o operador elvis ?:para retornar uma palavra que termina com at.

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, recursão, 74 bytes

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

imprime o texto da primeira resposta e lança uma PatternFormatException. Chamamos o fechamento recursivamente começando com 'A' e aumentando ++charaté o personagem depois Zlançar o erro.

Groovy, trapaceando, 77 bytes

Com o risco de ser linchado:

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

isto é, leia os dados nesta página e imprima a definição de uma resposta válida no início. Em minha defesa ... imprime a resposta solicitada ... agora ninguém edita a página ...

Groovy, usando 'times', 81 bytes

Com base na resposta python com o padrão de palavras de três letras:

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

impressões:

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, recorrendo no (...) principal, 83 bytes

Supondo que contamos novas linhas como um caractere.

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

imprime o texto da primeira resposta e lança uma PatternSyntaxException.

Groovy, usando eachWithIndex, 88 bytes

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

Groovy, usando transpose, 102 bytes

['A'..'Z','niooaauusoioaiuaaoiineeaei'as List].transpose().each{println it[0]+" is for ${it.join()}t"}
Matias Bjarland
fonte
Kat é uma palavra válida, para que você possa remover o caso especial de kit.
Business Cat
editado, obrigado. Salvei-me 3 bytes
:)
2

05AB1E , 77 bytes

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

Experimente online!

Usa a seguinte string compactada:

ASSBINCATDOTEATFATGOTHATILLJOTKITLOTMETNOTOATPATQUEROTSETTITUSEUSEVATWETXISYIPZAP

Convertido para Base-214:

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

Usou uma lista de palavras de três letras scrabble: http://wordfinder.yourdictionary.com/letter-words/3

A saída é a seguinte:

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

Tinha uma versão de 70 bytes, mas palavras de 2 letras não são permitidas.


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 polvo mágico
fonte
quinão é uma palavra em inglês. A pesquisa revela apenas uma palavra latina.
Mbomb007
@ mbomb007 deveria ser, Queeu sabia que havia uma palavra legal de três letras, com erros ortográficos.
Magic Octopus Urn
Palavras bonitas :) podem ser substituídas por ,.
Emigna
2

SmileBASIC, 131 113 82 81 bytes

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

Agora, usando palavras que em t

12Me21
fonte
Exemplo de saída?
snail_
2

Lithp , 136 125 117 bytes

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

(Dividir para facilitar a leitura)

Experimente online!

Esta é praticamente uma porta da resposta Python

  • 11 bytes salvos usando eacho índice de
  • Economizou 8 bytes removendo chamadas inúteis para (scope #)

Resultado:

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
fonte
2
Ótimo nome! (Eu não, thuffer de um lithp, doethe a linguagem têm thuch um thpeech ithue embora?)
Jonathan Allan
11
Obrigado! Não, o idioma é bom com a pronúncia. É mais que uma versão bastardo do Lisp. Achei Lisp muito difícil de entender, Lithp é a minha opinião de uma maneira que faz sentido para mim. Deve ser muito mais legível do que a maioria dos 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 eu nunca conseguiria uma pontuação decente, procurei as mais curtas palavras de humor que consegui 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
fonte
1

empilhados , 72 bytes

Existem dois por 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

Experimente online! Usando esse padrão incrível. (Antes de você perguntar, ++seria um único token, então + +é usado.)

Ambos trabalham por iteração a partir 65de 90e obter a sequência de caracteres correto. Notas:

  • #: é um apelido para chr
  • # é um apelido para get
  • {!...}é o mesmo que { n : ... }(lambda com ncomo parâmetro)

Para 73 bytes:

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

Mathematica 93 Bytes

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

rendimentos

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
fonte
1

Groovy, 72 bytes

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

Resultado

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
fonte
1

Python 3, 145 137 135 bytes

Eu sacrifiquei alguns bytes para pseudo-randomizar a saída a cada execução. A idéia é procurar palavras em minúsculas de pelo menos três caracteres /usr/share/dict/wordse escolher uma dessa 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])

Editar% s

  • Removido title() porque as palavras não precisam ser capitalizadas.
  • O regex foi alterado para "\n(%c.{3,})"(+ 3 bytes) para permitir a remoção de ,re.M(- 5 bytes).

Exemplo de saída:

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
fonte
Não tenho certeza de que todos são válidos. Por exemplo, não consigo encontrar uma definição para Qohele, embora uma pesquisa revele que é um livro ou volume de texto sagrado.
Andrakis
11
Só notei que meu regex não corresponde até o final de cada palavra - será corrigido.
usar o seguinte código
Corrigido. Agora, apenas procure palavras minúsculas e completas para não ter nomes.
usar o seguinte código
1

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

Esta é uma implementação sed da lista de palavras da resposta de Jonathan Allan .

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

As palavras, exceto a letra final compartilhada t, são fornecidas na forma concatenada na linha 1 e, em seguida, impressas no formato solicitado pela linha 2. Uma nova linha final está presente.

Execute :

sed -rf alphabet_song.sed <<< ""
seshoumara
fonte
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;}

Com base na resposta de JonathanAllen , já que o Java não possui um dicionário interno sofisticado. ;) Tentei encontrar outra letra final para o alfabeto inteiro (como sou nou y), ou uma letra do meio (como aou e), mas a maioria estava faltando apenas uma ou duas palavras, então acabei usando ttambém. As palavras são escolhidas manualmente em wordhippo.com .

Ungolfed:

Experimente aqui.

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

Resultado:

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
fonte
11
+1 para +a+++. Gosto de escrever: P
Poke
1

PHP, 91 87 86 76 bytes

com base na lista de palavras de Jonathan Allan :

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

versões anteriores, 86 bytes:

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

ou

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

Corra com -nr.

resultado

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 as palavras estranhas, veja a resposta de Ismael

Titus
fonte