Twoim celem jest utworzenie piosenki alfabetu jako tekstu w następującej formie (w kolejności):

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>

Przykładowe dane wyjściowe:

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

Zasady:

• Każda „litera” utworu ma swoją własną linię, więc jest 26 linii i możliwy ciągły wiersz.

• W danych wyjściowych rozróżniana jest wielkość liter:

  • Litera na początku każdej linii musi być wielka.
  • is for jest małymi literami.
  • Wybrane słowo nie musi być pisane dużymi literami, ale może być. Wszystkie linie powinny być spójne.

• Wybrane słowo dla każdej linii należy do Ciebie, ale musi być poprawnym słowem angielskim z co najmniej 3 literami i nie może być łącznikiem (jak andlub but), wykrzyknikiem / wykrzyknikiem (jak heylub yay), skrótem (jak XLS) lub nazwa (jak Jon).

• Chociaż wątpię, aby ktokolwiek uznałby go za krótszy, uznałbym za dopuszczalne użycie frazy zamiast jednego słowa. Więc jeśli z jakiegoś powodu S is for Something smells fishy...jest krótszy, idź do niego.

• Wpisz wynik swojego programu w swojej odpowiedzi lub przynajmniej listę użytych słów (jeśli istnieje link do uruchomienia kodu online, nie musimy widzieć całego wyniku).

• Najkrótszy kod wygrywa

_{To wyzwanie zostało zainspirowane tym filmem .}

SOGL 0.8.1 , 60 32 bajtów

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

Wyjaśnienie:

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

To właściwie odpowiedź Jonathana Allana , ale przeniesiona na ten język.

Stara wersja: (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)

wynik:

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

To nie jest najkrótszy język, jaki potrafi ten język, ale powinien być najlepszy ze słowami zakodowanymi na stałe.

Bash (+ coreutils), 81, 87, 82, 78 bajtów

Używa strony man dla X , jako źródła słów.

Grał w golfa

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

EDYCJE

• Użyłem nieistniejącej strony podręcznika „xyst” +, |&aby zapisać 5 bajtów;
• Zaoszczędziłem jeszcze 4 bajty, zamieniając sed i sortuj .

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 

Python 2 , 88 77 bajtów

-11 bajtów dzięki xnor (unikaj zipu, przechodząc przez łańcuch i licząc cod 65)

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

Wypróbuj online!

(Port mojej odpowiedzi Jelly, gdy miał 56 bajtów.)

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

Grzmotnąć, 78, 69 bajtów

Aardvarki, Babushkas i Kamikazes!

Grał w golfa

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

EDYCJE

• Pozbyłem się grep, -9 bajtów

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

Wykorzystuje / usr / share / dict / words :

words jest standardowym plikiem we wszystkich systemach operacyjnych Unix i podobnych do Unixa i jest po prostu listą słów słownikowych rozdzielanych znakami nowej linii. Jest używany na przykład przez programy sprawdzające pisownię.

PowerShell , 150 141 117 75 bajtów

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

Wypróbuj online!

Pętle od 65do 90(tj. ASCII Ado Z). W każdej iteracji zamieniamy liczbę całkowitą na odpowiednią char(tj. ASCII 65dla A), zachowując ją do $ipóźniejszego użycia, łącząc łańcuch z tym is for $i, a następnie zaznaczając środek odpowiedniego słowa. Dokonuje się tego poprzez indeksowanie w długi ciąg (zapożyczony z odpowiedzi Jonathana Allana ). Kończy literą, ttworząc trzyliterowe słowo.

Powstałe ciągi są pozostawione w potoku, a domniemane Write-Outputna końcu drukuje je z nowymi liniami pomiędzy nimi.

Zaoszczędził sporo bajtów dzięki liście słów Rod
Borrowed z odpowiedzi Jonathana Allana

Galaretka , 39 bajtów

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

TryItOnline!

Oparty na 56-bajtowej wersji (dwa poniżej), ale zmienił słowa, aby usunąć wszystkie środkowe litery, "u"aby mógł indeksować do słowa słownika "anisole"*, co zapewnia wygodę posiadania potrzebnych liter o indeksach mniejszych niż sześć: 1:a, 2:n 3:i, 4:s, 5:o (6:l), 0:e(zwróć uwagę na "e"po prawej jest na indeksie zerowym [także 7 i -7 oraz dowolna inna liczba zgodna z 0 mod 7]). Jest także wcześnie w słowniku, więc ma tylko dwa, a nie o wiele bardziej powszechny trzy bajtowy indeks wyszukiwania ( "anisogamete"działałby również dla 2).

* Oldschoolowa nazwa aromatycznego eteru metoksybenzenu, często używanego w perfumach.

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

W jaki sposób?

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

Poprzedni, 46

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

Wszystkie słowa mają drugą literę „s” lub „a” i ostatnią literę „p” lub „t” przy użyciu podstawowego wyszukiwania czwartego w iloczynie kartezjańskim „sa” i „pt”. Z wyjątkiem słowa „U”, które kod zmienia na „Użyj” (używając stosunkowo nieporęcznego F”e272¦na końcu) - gdybym mógł znaleźć taką listę słów, która nie ma takiego wyjątku, patrzylibyśmy na 39 bajtów .

Lista słów:

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

Spróbuj tego

Poprzednie 56 bajtów

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

Lista słów:

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

Jest sformatowany, spróbuj

Poprzednio 83 bajty

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

... zagrajmy „Odszukaj, która litera nie ma zwierzęcia!” tam jest jeden i tylko jeden - uważaj na czerwonego śledzia (kłamstwo czerwony śledź był ksenon, który jest elementem, oczywiście nie zwierzę) , dwa pięć list słów tutaj, że nie są to zwierzęta (ksenonowe będąc jednym) :

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

(oczywiście jest to poprawnie sformatowane, spróbuj - po prostu pomyślałem, że zaoszczędzę miejsce)

Retina , 89 87 bajtów

Zaoszczędzono 2 bajty dzięki Martinowi Enderowi

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

m`$
t

Wypróbuj online!

Wybrałem słowo dla każdej litery, która kończy się na t(niektóre są dość niejasne).

Wyjaśnienie

ApBaCaDoEaFaGeHaIkaJeKiLeMeNeOpPeQaRaSaTiUniVaWeXysYurZi

Zastąp nieistniejące (puste) wejście powyższym tekstem.

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

Zamień każdą wielką literę na (newline)(itself) is for (itself). Powoduje to, że powyższy tekst jest podzielony na osobne linie, takie jak

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

... i tak dalej

^¶
​

Ponieważ jednak nowa linia została umieszczona przed każdą stolicą, istnieje nowa linia wiodąca, którą należy usunąć. Jest usuwany na tym etapie.

m`$
t

Umieść tna końcu każdej linii, ponieważ każde słowo użyte w piosence kończy się na t.

Siatkówka , 92 88 bajtów

Zaoszczędzono 4 bajty, pożyczając pomysł od Business Cat .

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Wypróbuj online!

Na podstawie listy słów AdmBorkBork , ale zmieniłem kilka słów na te, które kończą się naad aby zaoszczędzić więcej bajtów na wspólnym sufiksie.

Wyjaśnienie

AddBCDEelFGHItsJetKitLMNetOilPQatRSTUrnVatWXisYesZit

Zamień puste (nieistniejące) wejście w ten ciąg. Zawiera wszystkie litery, a także resztę słów, które się nie kończą ad.

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

Wstaw linijkę przed każdą wielką literą, a następnie zamień na X is for X.

m` .$
$&ad

Dopasuj litery, które są teraz same i dołącz, adaby uzupełnić skrócone słowa.

G`.

Odrzuć pustą linię, która została utworzona przez wstawienie wcześniej linii A.

PHP, 122 124 127 120 115 101 bajtów

Podąża za „standardową” <letter><filler>tstrukturą.
Próbowałem wymyślić słowa, których nikt wcześniej nie używał.
Jeśli zobaczysz słowo, które chcesz, żebym zastąpił, powiedz mi.

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

Nowa linia jest reprezentowana jako, \nale liczona jako 1 bajt.

Wynik:

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

Dziwne słowa:

• ikat :

  Ikat, lub ikkat, jest techniką barwienia stosowaną do modelowania tekstyliów, która wykorzystuje odporność na barwienie przędzy przed barwieniem i tkaniem tkaniny.

• xat :

  Rzeźbiony słup wzniesiony jako pomnik zmarłych przez niektórych Indian z zachodniej Ameryki Północnej

• zit :

  pryszcz; skazy skórne.

• qat :

  Catha edulis (khat, qat) to roślina kwiatowa pochodząca z Rogu Afryki i Półwyspu Arabskiego.

Pyke, 55 51 48 bajtów

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

Wypróbuj tutaj!

Link ma długość 3 i nie kwalifikuje się, ponieważ słowa zawierają łączniki.

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

Wyjścia:

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

Możesz to przetestować poza Pyke przy użyciu tego samego algorytmu. Wymaga 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))

Japt , 52 50 bajtów

Współpracował z @ETHproductions

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

Zawiera wiele niedrukowalnych materiałów. Przetestuj online!

Lista słów to:

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 korzysta z biblioteki kompresji ciągów shoco , która redukuje typowe przebiegi małych liter o bajty. Oto pełna lista wszystkich dwuliterowych przebiegów skondensowanych w jeden bajt:

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

Pomysł polega więc na utworzeniu słowa z jedną z tych par dla każdej litery alfabetu.

;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

Jedną interesującą rzeczą do odnotowania jest to, że chociaż Japt może pośrednio dekompresować ciąg zawinięty w backticks, tak naprawdę jest to bajt już tutaj, ponieważ trzeba będzie złapać dwa znaki w zdekompresowanym ciągu zamiast jednego.

05AB1E , 45 42 39 38 37 36 bajtów

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

Wypróbuj online!

Wyjaśnienie

Auwypycha wielkie litery alfabetu.
'Æåwypycha słowo scenario.
•à¡P°€kš¦zᮕwypycha liczbę base-10 36774474076746444766322426.
Sèużywa tych cyfr do indeksowania scenario.
)øzamyka te ciągi razem na liście[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

Użyte słowa: ['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']

Wersja 33-bajtowa z użyciem słów, których nie jestem pewien

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

Słowa: ['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']

Ruby, 93 84 69 63 58 62 bajtów

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

Wynik:

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

Wszystkie trzyliterowe słowa kończące się na „t”, większość z nich na „at”.

Używając kontrowersyjnych słów (iat, dat, amp. Ump) - 55 bajtów:

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

Wciąż próbuję znaleźć wzór, myślę, że można użyć tylko 2 różnych zakończeń i wszystko uprościć.

Dzięki @Value Ink i @Business cat za pomoc.

///, 163 bajty

/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

Wypróbuj online

Yob - n. - Okrutny i brutalny facet

Hm, nauczyłem się dzisiaj ...

05AB1E , 72 68 bajtów

Kod:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Wyjaśnienie

Poniższy kod:

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

wypycha tę tablicę:

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

I jest przetwarzany przy użyciu następującego kodu:

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

Clojure, 159 232 bajty

Cóż, teraz jest to z pewnością niekonkurencyjne rozwiązanie, ponieważ o wiele łatwiej byłoby na stałe zakodować użyte słowa. Umieszczenie go tam tylko po to, aby uzyskać poprawną odpowiedź (i nie używać listy słów innych osób).

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

Zasadniczo nadal pobiera wszystkie funkcje zdefiniowane w clojure.coreprzestrzeni nazw, ale potem ocenia doc <function name>i umieszcza je w ciągu. Następnie łączy go w jeden wielki ciąg (ze słowem xyst) i stamtąd znajduje odpowiednie słowa. Należy uruchomić w Clojure REPL.

Wynik:

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

Stare rozwiązanie:

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

JavaScript (ES6), 82 bajty

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

Anonimowa funkcja zwracająca ciąg znaków. Zawiera niedrukowalne; oto wersja, która nie:

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

Wykorzystuje to technikę @ JonathanAllen, używając tylko trzyliterowych słów, które kończą się na t. Ciąg dekompresuje się do AnBiCoDoEaFaGOHuIsJoKiLoMaNiOuPaQaRoSiTiUnVeWeXaYeZi.

Próbowałem połączyć łańcuchowe dwuliterowe pary w ten sposób:

Ace
 Bee
  Cee
   Dew
    Ewe
     ...

XDotarłem już do końca, ale utknąłem Y; o ile wiem, jedynym możliwym do uzyskania trzyliterowym Xsłowem jest Xisi nie ma trzyliterowego słowa zaczynającego się od Ys.

Dla przypomnienia, pełny ciąg to ceeeweeereueaebiueeiziais...

Mathematica, 97 bajtów

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

Wygląda na Mathematica WordList trzeciego słowa rozpoczynającego się od każdej litery; pozwala to uniknąć liter i wykrzykników. Ma nową linię.

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

Groovy, 76 73 bajtów

(edytowany z 76 do 73 bajtów, dziękuję kotu)

Zainspirowany rozwiązaniem rubinowym:

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

używamy anyzamiast każdego, ponieważ jest on krótszy, a wszystkie instrukcje println zwracają wartość false. Dla specjalnych przypadków w ciągu używamy String.find, który w groovy zwraca dopasowanie lub null. W przypadku wartości null używamy operatora elvis, ?:aby atzamiast tego zwracać słowo kończące się na .

Wydruki:

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, rekurencja, 74 bajty

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

drukuje tekst z pierwszej odpowiedzi, a następnie zgłasza wyjątek PatternFormatException. Zamykanie nazywamy rekurencyjnie, zaczynając od „A” i zwiększając, ++charaż postać po tym Zzgłosi błąd.

Groovy, oszukując, 77 bajtów

Z ryzykiem zlinczowania:

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

tzn. przeczytaj dane na tej stronie i wydrukuj definicję poprawnej odpowiedzi na początku. W mojej obronie ... drukuje żądaną odpowiedź ... teraz nikt nie edytuje strony ...

Groovy, używając „razy”, 81 bajtów

Opierając się na pythonowej odpowiedzi, składającej się z trzech liter:

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

drukuje:

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, rekurencyjnie na głównej (...), 83 bajtach

Zakładając, że nowe znaki liczymy jako jeden znak.

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

drukuje tekst z pierwszej odpowiedzi, a następnie zgłasza wyjątek PatternSyntaxException.

Groovy, używając eachWithIndex, 88 bajtów

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

Groovy, przy użyciu transpozycji, 102 bajty

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

05AB1E , 77 bajtów

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

Wypróbuj online!

Używa skompresowanego następującego ciągu:

ASSBINCATDOTEATFATGOTHATILLJOTKITLOTMETNOTOATPATQUEROTSETTITUSEVATWETXISYIPZAP

Przekształcony w Base-214:

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

Użyto listy 3-literowych scrabble słów: http://wordfinder.yourdictionary.com/letter-words/3

Dane wyjściowe są następujące:

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

Miał wersję 70-bajtową, ale słowa dwuliterowe nie są dozwolone.

Wyjaśniono:

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

SmileBASIC, 131 113 82 81 bajtów

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

Teraz używam słów, które w t

Lithp , 136 125 117 bajtów

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

(Podziel dla czytelności)

Wypróbuj online!

To właściwie port odpowiedzi Pythona

• Zapisano 11 bajtów za pomocą eachindeksu
• Zaoszczędzono 8 bajtów, usuwając bezużyteczne połączenie z (scope #)

Wynik:

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

Partia, 250 bajtów

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

Ponieważ nigdy nie zamierzałem uzyskać przyzwoitego wyniku, wybrałem najkrótsze humorystyczne słowa, jakie udało mi się znaleźć:

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

ułożone , 72 bajty

Są dwa na 72 bajty!

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

Wypróbuj online! Używając tego niesamowitego wzoru. (Zanim zapytasz, ++będzie to pojedynczy token, więc + +jest używany zamiast tego).

Zarówno praca przez powtarzanie od 65celu 90i coraz prawidłową sekwencję znaków. Uwagi:

• #: jest pseudonimem dla chr
• # jest pseudonimem dla get
• {!...}jest taki sam jak { n : ... }(lambda z njako parametr)

Dla 73 bajtów:

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

Mathematica 93 bajty

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

plony

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

Groovy, 72 bajty

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

Wynik

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

Python 3, 145 137 135 bajtów

Poświęciłem kilka bajtów, aby pseudolosowo wygenerować dane wyjściowe przy każdym uruchomieniu. Chodzi o to, aby wyszukać małe litery o długości co najmniej 3 znaków, /usr/share/dict/wordsa następnie wybrać jeden z tej listy za pomocą 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])

Edycje

• Usunięte, title()ponieważ słowa nie muszą być pisane dużymi literami.
• Zmieniono wyrażenie regularne na "\n(%c.{3,})"(+ 3 bajty), aby umożliwić usunięcie ,re.M(- 5 bajtów).

Przykładowe dane wyjściowe:

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

GNU sed, 81 + 1 (flaga r) = 82 bajty

Jest to realizacja sed listy słów Jonathan Allana odpowiedź .

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

Słowa, z wyjątkiem wspólnej litery końcowej t, są podawane w formie konkatenowanej w linii 1, a następnie drukowane w żądanym formacie w linii 2. Obecna jest nowa linia końcowa.

Uruchom :

sed -rf alphabet_song.sed <<< ""

Java 7, 124 121 bajtów

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

Na podstawie @JonathanAllen odpowiedź „s , ponieważ Java ma ochotę wbudowanego słownika. ;) Próbowałem znaleźć kolejną literę końcową dla całego alfabetu (jak slub nlub y) lub środkową literę (jak alube ), ale w większości brakowało tylko jednego lub dwóch słów, więc skończyłem również z użyciem t. Słowa są wybierane ręcznie z wordhippo.com .

Nie golfowany:

Wypróbuj tutaj.

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

Wynik:

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

PHP, 91 87 86 76 bajtów

na podstawie listy słów Jonathana Allana :

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

starsze wersje, 86 bajtów:

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

lub

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

Uruchom z -nr.

wynik

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

Dziwne słowa, patrz odpowiedź Ismaela