Crea una canzone Alphabet


55

Il tuo obiettivo è creare una canzone alfabetica come testo nella seguente forma (in ordine):

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>

Esempio di output:

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

Regole:

  • Ogni "lettera" della canzone ha una sua linea, quindi ci sono 26 linee e un possibile avanzamento riga finale.

  • L'output è sensibile al maiuscolo / minuscolo:

    • La lettera all'inizio di ogni riga deve essere in maiuscolo.
    • is for è in minuscolo.
    • La parola scelta non deve essere maiuscola, ma può esserlo. Tutte le linee dovrebbero essere coerenti.
  • La parola scelta per ciascuna riga dipende da te, ma deve essere una parola inglese valida con almeno 3 lettere e non può essere una congiunzione (come ando but), interiezione / esclamazione (come heyo yay), abbreviazione (come XLS) o un nome (come Jon).

  • Anche se dubito che qualcuno lo troverebbe più breve, troverei accettabile usare una frase invece di una sola parola. Quindi, se per qualche motivo S is for Something smells fishy...è più breve, provaci.

  • Inserisci l'output del tuo programma nella tua risposta, o almeno l'elenco delle parole che hai usato (se c'è un link per eseguire il tuo codice online, non abbiamo bisogno di vedere l'intero output).

  • Il codice più corto vince


Questa sfida è stata ispirata da questo video .


Immagino che lo slang non sia permesso, anche se elencato nei dizionari appropriati? (es. "Quando si è accorta di essere diretta di nuovo verso l'outback ha appena tirato fuori un uey !")
Jonathan Allan,

1
Date alcune delle risposte, questa canzone di Barenaked Ladies sembra rilevante.
AdmBorkBork,

1
@JonathanAllan No slang. I dizionari contengono molte cose che non sono tecnicamente parole. Le abbreviazioni sono una, il gergo è un'altra.
mbomb007,

4
È un peccato che questo sia andato nel trovare parole di 3 lettere che finiscono nella stessa lettera.
Mee

1
Ci sono un paio di risposte usando un dizionario esterno. Non dovrebbero aggiungere la dimensione di quel file al loro codice?
pipe

Risposte:


3

SOGL 0.8.1 , 60 32 byte

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

Spiegazione:

χ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"

Questa è praticamente la risposta di Jonathan Allan , ma convertita in questa lingua.

Vecchia versione: (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)

produzione:

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

Questo non è il più breve che questa lingua possa fare, ma dovrebbe essere il migliore con le parole hard coded.


57

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

Utilizza la pagina man per X , come fonte di parole.

golfed

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

EDITS

  • Utilizzato una pagina man 'xyst' inesistente + |&per salvare 5 byte;
  • Salvati altri 4 byte, scambiando sed e ordina .

Test

%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 

3
Le parole lsof e xregs sono? :)
OldBunny2800

1
@ OldBunny2800 dovrebbe essere risolto ora
zeppelin

2
Ho cercato, e sì, xyst è una parola vera. :)
OldBunny2800

3
Sembra che i bambini impareranno alcune grandi parole. : D
mbomb007

1
@JonathanAllan Sfortunatamente, la pagina man per "x" non è disponibile su TIO, ma qui c'è un link tio.run/nexus/… , che usa invece "man man". Il trucco con xyst è che man xyst si lamenterà che non c'è "nessuna registrazione manuale per xyst" per lo stderr, che viene poi unito in stdout con |&, quindi può essere grepped.
Zeppelin,

33

Python 2 , 88 77 byte

-11 byte grazie a xnor (evita lo zip attraversando la stringa e contando cda 65)

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

Provalo online!

(Una porta della mia risposta Jelly, quando era di 56 byte.)

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

4
Mi piace il metodo delle parole che termina in t. L'iterazione può essere abbreviata aggiornando xin parallelo .
xnor

Molto intelligente, come sempre; Grazie!
Jonathan Allan,

1
Cosa Unt? Non riesco a trovarlo da nessuna parte
Albert Renshaw,

Non credo Untsia una parola, ma Utè così che puoi sostituire il valore nletterale con \0per renderlo valido e aggiungere solo un altro byte. Modifica le regole di Nevermind dicono che deve essere lungo 3 lettere ... hmmm
Albert Renshaw,

4
@AlbertRenshaw Un unt è una talpa europea secondo Merriam-Webster . Un'alternativa sarebbe ult secondo Wikizionario non è solo un'abbreviazione (che sono elencati con punti, come ult. ).
Jonathan Allan,

31

bash, 78, 69 byte

Aardvarks, Babushkas e Kamikazes!

golfed

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

EDITS

  • Sbarazzato di grep, -9 byte

Test

%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

Utilizza / usr / share / dict / words :

parole è un file standard su tutti i sistemi operativi simili a Unix e Unix ed è semplicemente un elenco delimitato da nuove righe di parole del dizionario. Viene utilizzato, ad esempio, dai programmi di controllo ortografico.


14

PowerShell , 150 141 117 75 byte

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

Provalo online!

Passa da 65a 90(cioè da ASCII Aa Z). Ogni iterazione, trasformiamo il numero intero nell'appropriato char(cioè, ASCII 65per A), lo salviamo in $iper l'uso in seguito, concateniamo quello con stringa is for $ie quindi viriamo al centro della parola appropriata. Questo viene fatto indicizzando in una lunga stringa (presa in prestito dalla risposta di Jonathan Allan ). Termina con la lettera tper rendere la parola di tre lettere.

Le stringhe risultanti vengono lasciate tutte sulla pipeline e un implicito Write-Outputalla fine le stampa con una nuova linea di mezzo.

Ho salvato un sacco di byte grazie alla lista di parole di Rod
Borrowed dalla risposta di Jonathan Allan


puoi rimuovere la prima lettera di ogni parola (quella maiuscola) e stampare con l' [char]$ esempio
Rod

@Rod Grazie. L'ho combinato con quello su cui stavo lavorando per cambiare il modo in cui viene calcolato il loop e come viene calcolato e salvato ancora un po 'l'indicizzazione.
AdmBorkBork,

13

Gelatina , 39 byte

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

TryItOnline!

Basato sulla versione a 56 byte (due sotto), ma ha cambiato le parole per rimuovere tutte le lettere di mezzo in "u"modo che possa indicizzarsi nella parola del dizionario "anisole"*, che ha la comodità di avere le lettere di cui abbiamo bisogno in tutti gli indici inferiori a sei: 1:a, 2:n 3:i, 4:s, 5:o (6:l), 0:e(nota il "e"a destra è all'indice zero [anche 7 e -7 e qualsiasi altro numero congruente a 0 mod 7]). È anche all'inizio del dizionario, quindi ha solo un indice di ricerca a tre byte piuttosto che molto più comune ( "anisogamete"funzionerebbe anche per 2).

* Il nome di vecchia scuola per l'etere aromatico metossibenzene, spesso usato nei profumi.

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

Come?

“¤ṁ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"

Precedente, 46

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

Le parole hanno tutte la seconda lettera "s" o "a" e l'ultima lettera "p" o "t" utilizzando una ricerca di base quattro in un prodotto cartesiano di "sa" e "pt". Tranne la parola "U", che il codice cambia in "Usa" (usando il relativamente voluminoso F”e272¦alla fine) - se potessi trovare un elenco di parole come questo che non ha una tale eccezione, vedremmo 39 byte .

Lista di parole:

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

prova questo


56 byte precedenti

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

Lista di parole:

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

È formattato, provalo


Precedente, 83 byte

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

... giochiamo a "Individua quale lettera non ha un animale!" ce n'è uno, e solo uno - fai attenzione alle aringhe rosse (una bugia, l'aringa rossa era lo xeno, che è un elemento, ovviamente non un animale) , qui ci sono due parole di cinque lettere che non sono animali (lo xeno è 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

(ovviamente questo è formattato correttamente, provalo - pensavo solo di risparmiare spazio)


Xenonnon è un animale. Ero sicuro che avresti fatto uno scherzo H is for Herring, ma credo di no.
mbomb007,

Heh, era una bugia. Xenon era quello ovvio :)
Jonathan Allan l'

Penso che stiano pensando allo xenop , che non è nel dizionario di Jelly.
Jonathan Allan,

Idea meravigliosa! Ma Uut?
Greg Martin,

@GregMartin Sono d'accordo, penso che tu abbia iniziato a devolvere le tue parole in grugniti sillabici.
Magic Octopus Urn

10

Retina , 89 87 byte

Salvato 2 byte grazie a Martin Ender


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

m`$
t

Provalo online!

Ho scelto una parola per ogni lettera che termina t(alcuni sono piuttosto oscuri).

Spiegazione


ApBaCaDoEaFaGeHaIkaJeKiLeMeNeOpPeQaRaSaTiUniVaWeXysYurZi

Sostituisci l'input inesistente (vuoto) con il testo sopra.

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

Sostituisci ogni lettera maiuscola con (newline)(itself) is for (itself) . Ciò comporta che il testo sopra sia diviso in righe separate come

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

... e così via

^¶
​

Tuttavia, poiché la nuova riga è stata inserita in precedenza ogni capitale, esiste una nuova riga principale che deve essere rimossa. Viene rimosso in questa fase.

m`$
t

Metti un talla fine di ogni riga, poiché ogni parola usata nella canzone finisce t.


Non è necessario acquisire la lettera maiuscola. Basta usare $&o $0invece di $1. In realtà ciò potrebbe anche salvare byte sul mio split stage.
Martin Ender,

@MartinEnder Grazie. Che cosa $&fa esattamente? Non l'ho visto sul wiki di GitHub.
Business Cat

È un alias per $0(ed è solo una parte del sapore .NET, così come la maggior parte degli altri sapori).
Martin Ender,

Usando alcune parole più brevi per arrivare a 83, provalo online
Jonathan Allan,

8

Retina , 92 88 byte

Salvato 4 byte prendendo in prestito un'idea da risposta di Business Cat .

Il conteggio dei byte presuppone la codifica ISO 8859-1.


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

Provalo online!

Basato sull'elenco di parole di AdmBorkBork , ma ho cambiato qualche altra parola in una di quelle che finisconoad per salvare più byte sul suffisso comune.

Spiegazione


AddBCDEelFGHItsJetKitLMNetOilPQatRSTUrnVatWXisYesZit

Trasforma l'input vuoto (inesistente) in questa stringa. Contiene tutte le lettere e il resto di quelle parole che non finiscono ad.

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

Inserisci un avanzamento riga prima di ogni lettera maiuscola e poi trasformalo in X is for X.

m` .$
$&ad

Abbina le lettere che sono ora da sole e aggiungi adper completare le parole abbreviate.

G`.

Eliminare la riga vuota che è stata creata inserendo un avanzamento riga in precedenza A.


8

PHP, 122 124 127 120 115 101 byte

Segue la struttura "standard" <letter><filler>t.
Ho provato a trovare parole che non erano mai state usate da nessuno prima.
Se vedi una parola che vuoi che sostituisca, dimmelo.

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

La nuova riga è rappresentata come \nma conteggiata come 1 byte.


Produzione:

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

Parole strane:

  • IKAT :

    Ikat, o ikkat, è una tecnica di tintura utilizzata per modellare tessuti che impiegano resistere alla tintura sui filati prima di tingere e tessere il tessuto.

  • xat :

    Un palo scolpito eretto in memoria dei morti da alcuni indiani del Nord America occidentale

  • zit :

    un brufolo; imperfezione della pelle.

  • qat :

    Catha edulis (khat, qat) è una pianta fiorita originaria del Corno d'Africa e della penisola arabica.


Soluzione intelligente Stavo per fare qualcosa di simile, felice di vederlo! +1
Albert Renshaw,

1
Queste non sono parole inglesi ....
Conor O'Brien,

@ ConorO'Brien Sei sicuro? PHP è tutto scritto in inglese, per quanto ne so.
Ismael Miguel,

5
@IsmaelMiguel cose come vprintfe zend_versioncertamente non sono parole inglesi. Pochissime di queste entità sono in realtà parole.
Conor O'Brien,

1
Non definirei zituna parola strana, almeno, penso che tutti dovrebbero già sapere cosa significa.
mbomb007,

6

Pyke, 55 51 48 byte

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

Provalo qui!

Il collegamento ha una lunghezza di 3 e non si qualifica poiché le parole includono congiuntive.

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

Uscite:

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

Puoi testarlo al di fuori di Pyke usando lo stesso algoritmo. Richiede dizionari.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))

No. Inoltre, viene visualizzato un errore durante l'esecuzione del codice.
mbomb007,

Timeout running code. BAD EVALAssicurati di aggiornare il link "Provalo online".
mbomb007,

2
Z is for zoofiliaPrenderei seriamente in considerazione prima di lasciare che i miei figli cantino questo.
Zeppelin,


Per chiunque faccia un doppio take come ho fatto io: l' inglese non è sempre in maiuscolo. ;)
DLosc

6

Japt , 52 50 byte

Collaborato con @ETHproductions

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

Contiene molti non stampabili. Provalo online!

L'elenco delle parole è:

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 utilizza la libreria di compressione delle stringhe shoco , che riduce le esecuzioni comuni di lettere minuscole in un byte. Ecco un elenco completo di tutte le esecuzioni di due lettere condensate in 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

Quindi l'idea è quella di formare una parola con una di queste coppie per ogni lettera dell'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 interessante da notare è che mentre Japt può decomprimere implicitamente una stringa avvolta in backtick, in realtà qui è un byte più lungo perché dovresti prendere due caratteri nella stringa decompressa, anziché uno.


6

05AB1E , 45 42 39 38 37 36 byte

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

Provalo online!

Spiegazione

Auspinge l'alfabeto maiuscolo.
'Æåspinge la parola scenario.
•à¡P°€kš¦zᮕspinge il numero base-10 36774474076746444766322426.
usa quelle cifre per indicizzare scenario.
comprime le stringhe insieme nell'elenco[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

Parole usate: ['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']

Versione a 33 byte usando alcune parole di cui non sono sicuro

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

Parole: ['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']


6

Rubino, 93 84 69 63 58 62 byte

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

Produzione:

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

Tutte le parole di 3 lettere che terminano con 't', la maggior parte delle quali con 'at'.

Usando parole controverse (iat, dat, amp. Ump) - 55 byte:

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

Sto ancora cercando di trovare uno schema, penso che sia possibile usare solo 2 finali diversi e semplificare tutto.

Grazie @Value Ink e @Business cat per l'aiuto.


1
Qat e X è (plurale di Xi ) sono parole, in modo da poterli usare e anche ridurre il regex ricerca di/#{l}../
Valore di inchiostro

Grazie, stavo pensando a qualcosa di simile ma ora sono lontano dal mio PC, lo controllerò sicuramente.
GB

In realtà stavo cercando di trovare alcune parole di 5 lettere per le lettere mancanti: matrice, saggio, intarsio ... Ma sono bloccato su quello. :-(
GB

1
Kat è una parola valida, quindi puoi rimuovere il caso speciale per kit.
Business Cat

1
Ho pensato a "dat" e "zat" ma sono entrambi la stessa congiunzione (quella) e slang, entrambi i quali tipi di parole sono esclusi. "amp" e "ump" sembrano essere abbreviazioni di "ampere" / "amplify" e "umpire". "IAT" è un acronimo, quindi neanche questo va bene.
Jonathan Allan,

6

///, 163 byte

/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

Provalo online

Yob - n. - Un tipo crudele e brutale

Hm, ho imparato qualcosa oggi ...


2
Nel Regno Unito un yob è un zoticone, un delinquente o un boor; più crudele e turbolento che crudele e brutale.
Jonathan Allan,

1
In russo "Yob" è una forma abbreviata del verbo osceno, che, fondamentalmente, è un equivalente di "f * ck" in inglese. Più sai ...
Mr Scapegrace,

5

05AB1E , 72 68 byte

Codice:

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

Utilizza la codifica CP-1252 . Provalo online!

Spiegazione

Il seguente codice:

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

spinge questo array:

['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 viene elaborato utilizzando il seguente codice:

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

Puoi spiegare perché questo spinge quell'array?
Magic Octopus Urn

Penso che 05AB1E abbia alcune parole incorporate che possono essere rappresentate da 2 byte in una stringa.
Mee,

@ 12Me21 è fantastico! ”–³”=Applee int(–³,214)=23891ma non vedo ancora la correlazione qui.
Magic Octopus Urn


2
@carusocomputing Ecco una descrizione più dettagliata di come funzionano la compressione e la decompressione.
Adnan,

5

Clojure, 159 232 byte

Bene, ora è sicuramente una soluzione non competitiva in quanto sarebbe molto più semplice codificare le parole usate. Mettendolo lì solo per il gusto di avere una risposta corretta (e non usare la lista di parole altrui).

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

Praticamente ottiene ancora tutte le funzioni definite nello clojure.corespazio dei nomi, ma successivamente lo valuta doc <function name>e lo mette in stringa. Dopodiché lo concatena in un'unica enorme stringa (con la parola xyst) e trova le parole appropriate da lì. Dovrebbe essere eseguito in Clojure REPL.

Produzione:

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

Vecchia soluzione:

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

or, non orb, per 1 byte.
wizzwizz4,

1
La lunghezza minima è di 3 lettere
12Me21

@ mbomb007 aggiornato.
cliffroot

4

JavaScript (ES6), 82 byte

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

Una funzione anonima che restituisce una stringa. Contiene non stampabili; ecco una versione che non:

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

Questo utilizza la tecnica di @ JonathanAllen, usando solo parole di tre lettere che finiscono t. La stringa si decomprime in AnBiCoDoEaFaGOHuIsJoKiLoMaNiOuPaQaRoSiTiUnVeWeXaYeZi.

Ho provato a concatenare coppie di due lettere in questo modo:

Ace
 Bee
  Cee
   Dew
    Ewe
     ...

Ora ci sono riuscito Xma mi sono bloccato Y; per quanto ne so, l'unica Xparola raggiungibile di tre lettere è Xis, e non c'è una parola di tre lettere che inizia con Ys.

Per la cronaca, l'intera stringa era ceeeweeereueaebiueeiziais...


Secondo Wikizionario, potresti usare uzietiz ...
DLosc

@DLosc Ottima idea. Allora dovreste fare sei, skio sriche ti lascia con ree, roe, rue, rye, che ti lascia con ... l'unico di tre lettere qPAROLE posso trovare sono qat, qisequa . Esiste una pagina Wikizionario con più parole di tre lettere?
ETHproductions

C'è una categoria per parole di tre lettere, ma non è un elenco completo. Ad esempio, non contiene que (che conosco solo perché qui è stata utilizzata da un'altra risposta). (Non sono sicuro che ci sia una pparola che termina u, però.)
DLosc

@DLosc che stavo già usando piu, quindi non è affatto un problema: P Grazie!
ETHproductions

Hm. piusembra piuttosto borderline - wiktionary non lo ha come l'inglese, e dizionario.com lo ha come più(non so come stiamo prendendo in considerazione gli accenti per questa sfida). Ma sì, ys_sarebbe un problema.
DLosc

3

Mathematica, 97 byte

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

Cerca in Mathematica WordListla terza parola che inizia con ogni lettera; questo evita parole e interiezioni di una lettera. Ha una nuova riga.

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

eep, totalmente dimenticato, grazie
Greg Martin

3

Groovy, 76 73 byte

(modificato da 76 a 73 byte, grazie gatto)

Ispirato alla soluzione di rubini:

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

noi usiamo any posto di ciascuno in quanto è più breve e tutte le istruzioni println restituiscono false. Per i casi speciali nella stringa, usiamo String.find che in groovy restituisce la corrispondenza o null. Su null usiamo l'operatore elvis ?:per restituire invece una parola che termina con at.

Stampa:

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, ricorsione, 74 byte

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

stampa il testo dalla prima risposta e quindi genera una PatternFormatException. Chiamiamo la chiusura ricorsivamente iniziando con 'A' e incrementando++char fino a quando il carattere dopo Zgenera l'errore.

Groovy, tradendo, 77 byte

Con il rischio di essere linciato:

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

cioè leggere i dati in questa pagina e stampare la definizione di una risposta valida all'inizio. A mia difesa ... stampa la risposta richiesta ... ora nessuno modifica la pagina ...

Groovy, usando 'times', 81 byte

Basandosi sulla risposta di Python con il modello di parole di tre lettere:

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

stampe:

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, ricorrendo sul principale (...), 83 byte

Supponendo che contiamo le nuove linee come un personaggio.

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

stampa il testo dalla prima risposta e quindi genera una PatternSyntaxException.

Groovy, usando eachWithIndex, 88 byte

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

Groovy, usando transpose, 102 byte

['A'..'Z','niooaauusoioaiuaaoiineeaei'as List].transpose().each{println it[0]+" is for ${it.join()}t"}

Kat è una parola valida, quindi puoi rimuovere il caso speciale per kit.
Business Cat,

a cura, grazie. Mi ha salvato 3 byte
:)

2

05AB1E , 77 byte

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

Provalo online!

Utilizza la seguente stringa compressa:

ASSBINCATDOTEATFATGOTHATILLJOTKITLOTMETNOTOATPATQUEROTSETTITUSEVATWETXISYIPZAP

Convertito in Base-214:

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

Utilizzato un elenco di parole scrabble di 3 lettere: http://wordfinder.yourdictionary.com/letter-words/3

L'output è il seguente:

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

Aveva una versione da 70 byte, ma non sono consentite parole di 2 lettere.


Ha spiegato:

•‹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.

quinon è una parola inglese. Cercare questo rivela solo una parola latina.
mbomb007,

@ mbomb007 doveva essere, Quesapevo che c'era una parola scrabble legale di 3 lettere, l'ho scritto male.
Magic Octopus Urn

Belle parole :) potrebbero essere sostituite con ,.
Emigna,


2

Lithp , 136 125 117 byte

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

(Dividi per leggibilità)

Provalo online!

Questa è praticamente una porta della risposta Python

  • Salvato 11 byte usando eachl'indice di
  • Salvato 8 byte rimuovendo la chiamata inutile a (scope #)

Produzione:

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

2
Ottimo nome! (Io no, tu lo so, ma la lingua ha ancora un tono così intenso?)
Jonathan Allan,

1
Grazie! No, la lingua va bene con la pronuncia. È più che una versione bastardata di Lisp. Ho appena trovato Lisp troppo difficile da avvolgere la testa, Lithp è la mia opinione in un modo che abbia senso per me. Dovrebbe essere molto più leggibile della maggior parte del codice Lisp.
Andrakis,

1

Lotto, 250 byte

@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%

Dal momento che non avrei mai ottenuto un punteggio decente, ho cercato le parole umoristiche più brevi che sono riuscito a trovare:

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

1

impilati , 72 byte

Ce ne sono due per 72 byte!

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

Provalo online!Usando quel modello fantastico. (Prima di chiedere, ++sarebbe un singolo token, quindi + +viene utilizzato invece.)

Entrambi funzionano ripetendo da 65 a 90e ottenendo la sequenza di caratteri corretta. Appunti:

  • #: è un alias per chr
  • # è un alias per get
  • {!...}è lo stesso di { n : ... }(lambda conn come parametro)

Per 73 byte:

'niooaauusoioaiuaaoiineeaei'toarr{e i:65 i+#::' is for '+\e+'t'+ +out}map

1

Mathematica 93 byte

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

i rendimenti

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

1

Groovy, 72 byte

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

Produzione

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

1

Python 3, 145 137 135 byte

Ho sacrificato alcuni byte per pseudo-randomizzare l'output ad ogni corsa. L'idea è quella di cercare parole minuscole di almeno 3 caratteri /usr/share/dict/wordse quindi sceglierne una dall'elenco 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])

Le modifiche

  • Rimosso title()perché le parole non devono essere maiuscole.
  • Modificato regex in "\n(%c.{3,})"(+ 3 byte) per consentire la rimozione di ,re.M(- 5 byte).

Esempio di output:

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

Non sono sicuro che siano tutti validi. Ad esempio, non riesco a trovare una definizione per Qohele, anche se una ricerca rivela che si tratta di un libro o di un volume di testo sacro.
Andrakis,

1
Ho appena notato che il mio regex non combacia fino alla fine di ogni parola - risolverà.
PidgeyUsedFust

Aggiustato. Ora cerco solo parole minuscole e complete per non avere nomi.
PidgeyUsedFust

1

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

Questa è un'implementazione sed della lista di parole dalla risposta di Jonathan Allan .

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

Le parole, ad eccezione della lettera finale condivisa t, sono riportate in forma concatenata alla riga 1 e quindi stampate nel formato richiesto dalla riga 2. È presente una riga finale trascinata.

Esegui :

sed -rf alphabet_song.sed <<< ""

1

Java 7, 124 121 byte

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

Basato sulla risposta di @JonathanAllen , poiché Java non ha un dizionario incorporato di fantasia. ;) Ho cercato di trovare un'altra lettera finale per l'intero alfabeto (come so no y), o una lettera centrale (come ao e), ma la maggior parte mancava solo una o due parole, quindi ho finito anche per usare t. Le parole vengono scelte manualmente da wordhippo.com .

Ungolfed:

Provalo qui.

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

Produzione:

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

1
+1 per +a+++. Mi piace scrivere quelli: P
Poke

1

PHP, 91 87 86 76 byte

basato sull'elenco di parole di Jonathan Allan :

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

versioni precedenti, 86 byte:

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,"
";

Corri con -nr.

produzione

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

Per le parole strane, vedi risposta di Ismael

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.