Votre objectif est de créer une chanson de l’alphabet sous forme de texte de la manière suivante (dans l’ordre):

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>

Exemple de sortie:

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

Règles:

• Chaque "lettre" de la chanson a sa propre ligne, il y a donc 26 lignes et un saut de ligne possible.

• La sortie est sensible à la casse:

  • La lettre au début de chaque ligne doit être en majuscule.
  • is for est en minuscule.
  • Le mot choisi n'a pas besoin d'être mis en majuscule, mais peut l'être. Toutes les lignes doivent être cohérentes.

• Le mot choisi pour chaque ligne appartient à vous, mais doit être un mot anglais valide avec au moins 3 lettres et ne peut pas être une conjonction (comme andou but), une interjection / exclamation (comme heyou yay), une abréviation (comme XLS) ou un nom (comme Jon).

• Bien que je doute que quiconque le trouverait plus court, je trouverais acceptable d’utiliser une phrase au lieu d’un seul mot. Donc, si pour une raison quelconque S is for Something smells fishy...est plus courte, foncez.

• Mettez la sortie de votre programme dans votre réponse, ou au moins la liste des mots que vous avez utilisés (s'il existe un lien pour exécuter votre code en ligne, nous n'avons pas besoin de voir la sortie complète).

• Le code le plus court gagne

_{Ce défi a été inspiré par cette vidéo .}

SOGL 0.8.1 , 60 32 octets

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

Explication:

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

C'est à peu près la réponse de Jonathan Allan , mais adaptée à cette langue.

Ancienne version: (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)

sortie:

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

Ce n'est pas le plus court que cette langue puisse faire, mais devrait être le meilleur avec les mots codés en dur.

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

Utilise la page de manuel de X comme source de mots.

Golfé

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

EDITS

• Utilisation d'une page de manuel 'xyst' non existante + |&pour économiser 5 octets;
• Sauvegardé 4 autres octets, en échangeant sed et sort .

Tester

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

-11 octets grâce à xnor (évitez le zip en parcourant la chaîne et en comptant cà partir de 65)

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

Essayez-le en ligne!

(Un port de ma réponse de gelée, quand il était 56 octets.)

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

Frapper, 78, 69 octets

Aardvarks, Babushkas et Kamikazes!

Golfé

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

EDITS

• Je me suis débarrassé de grep, -9 octets

Tester

%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

Utilise / usr / share / dict / words :

words est un fichier standard sur tous les systèmes d'exploitation Unix et de type Unix. Il s'agit simplement d'une liste de mots du dictionnaire délimitée par des lignes. Il est utilisé, par exemple, par les programmes de vérification orthographique.

PowerShell , 150 141 117 75 octets

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

Essayez-le en ligne!

Boucles de 65à 90(ASCII Aà Z). À chaque itération, nous transformons l'entier en valeur appropriée char(c'est-à-dire, ASCII 65pour A), sauvegardons celui-ci en $ivue d'une utilisation ultérieure, concaténons les chaînes avec is for $i, puis cliquetons au milieu du mot approprié. Cela se fait en indexant dans une longue chaîne (empruntée à la réponse de Jonathan Allan ). Termine avec la lettre tpour faire le mot de trois lettres.

Les chaînes résultantes sont toutes laissées sur le pipeline et une Write-Outputfin implicite les imprime avec des nouvelles lignes entre les deux.

J'ai sauvé un tas d'octets grâce à la liste de mots de Rod
Borrowed de la réponse de Jonathan Allan

Gelée , 39 octets

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

TryItOnline!

Sur la base de la version 56 octets (deux ci - dessous), mais les mots a changé pour enlever toute lettre du milieu "u"de sorte qu'il peut indexer dans le dictionnaire de mot "anisole"*, qui a l'avantage d'avoir les lettres que nous avons tous besoin à des index moins de six: 1:a, 2:n 3:i, 4:s, 5:o (6:l), 0:e(notez le "e"à droite est à l'index zéro [également 7 et -7 et tout autre nombre congruent à 0 mod 7]). Il est également au début du dictionnaire, il n’a donc qu’un indice de recherche sur trois octets beaucoup plus courant ( "anisogamete"qui fonctionnerait également pour 2).

* Ancien nom de l'éther aromatique méthoxybenzène, souvent utilisé dans les parfums.

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

Comment?

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

Précédent, 46

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

Les mots ont tous une deuxième lettre "s" ou "a" et la dernière lettre "p" ou "t" en utilisant une recherche de base quatre dans un produit cartésien de "sa" et "pt". Sauf le mot "U", que le code change en "Utiliser" (en utilisant le relativement encombrant F”e272¦à la fin) - si je pouvais trouver une liste de mots comme celle-ci qui ne comporte pas une telle exception, nous examinerions 39 octets .

Liste de mots:

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

essaye celui-là

56 octets précédents

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

Liste de mots:

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

Il est formaté, essayez-le

Précédent, 83 octets

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

... jouons "Trouve quelle lettre n'a pas d'animal!" il y en a un, et un seul - surveillez le hareng rouge (un mensonge, le hareng rouge était du xénon, qui est un élément, évidemment pas un animal) , sont deux mots de cinq lettres qui ne sont pas des animaux (le xénon en est un) :

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

(bien sûr, le formatage est correct, essayez-le - je pensais juste économiser de la place)

Retina , 89 87 octets

2 octets sauvés grâce à Martin Ender

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

m`$
t

Essayez-le en ligne!

J'ai choisi un mot pour chaque lettre qui se termine par t(certaines sont assez obscures).

Explication

ApBaCaDoEaFaGeHaIkaJeKiLeMeNeOpPeQaRaSaTiUniVaWeXysYurZi

Remplacez l’entrée inexistante (vide) par le texte ci-dessus.

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

Remplacez chaque lettre majuscule par (newline)(itself) is for (itself). Le texte ci-dessus est alors divisé en lignes séparées, comme

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

... etc

^¶
​

Cependant, puisque la nouvelle ligne a été placée avant chaque capitale, il existe une nouvelle ligne principale qui doit être supprimée. Il est supprimé à cette étape.

m`$
t

Mettez un tà la fin de chaque ligne, car chaque mot utilisé dans la chanson se termine par t.

Retina , 92 88 octets

Vous avez économisé 4 octets en empruntant une idée de la réponse de Business Cat .

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne!

Basé sur la liste de mots d'AdmBorkBork , mais j'ai changé quelques mots de plus en ceux qui se terminent par adéconomiser davantage d'octets sur le suffixe commun.

Explication

AddBCDEelFGHItsJetKitLMNetOilPQatRSTUrnVatWXisYesZit

Tournez l'entrée vide (inexistante) dans cette chaîne. Il contient toutes les lettres ainsi que le reste de ces mots qui ne finissent pas par ad.

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

Insérez un saut de ligne devant chaque lettre majuscule, puis transformez-le en X is for X.

m` .$
$&ad

Faites correspondre les lettres qui sont maintenant par elles-mêmes et ajoutez-les adpour compléter les mots abrégés.

G`.

Supprimez la ligne vide créée en insérant un saut de ligne auparavant A.

PHP, 122 124 127 120 115 101 octets

Suit la <letter><filler>tstructure "standard" .
J'ai essayé de trouver des mots qui n'avaient jamais été utilisés auparavant.
Si vous voyez un mot que vous voulez que je remplace, dites-le moi.

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

La nouvelle ligne est représentée comme \nmais compte pour 1 octet.

Sortie:

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

Mots étranges:

• ikat :

  Ikat, ou ikkat, est une technique de teinture utilisée pour créer des motifs sur des textiles. Elle consiste à appliquer une teinture résistante sur les fils avant de teindre et de tisser le tissu.

• xat :

  Un poteau sculpté érigé en mémorial aux morts par quelques Indiens de l'ouest de l'Amérique du Nord

• zit :

  un bouton; tache de peau.

• qat :

  Catha edulis (khat, qat) est une plante à fleurs originaire de la Corne de l'Afrique et de la péninsule arabique.

Pyke, 55 51 48 octets

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

Essayez-le ici!

Le lien est pour 3 longueur et ne qualifie pas comme mots incluent conjonctives.

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

Les sorties:

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

Vous pouvez tester cela en dehors de Pyke en utilisant le même algorithme. Nécessite 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 octets

Collaboré avec @ETHproductions

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

Contient beaucoup de non imprimables. Testez-le en ligne!

La liste de mots est:

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 utilise la bibliothèque de compression de chaîne shoco , qui réduit les octets courants des lettres minuscules. Voici une liste complète de toutes les exécutions de deux lettres condensées dans un octet:

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

L'idée est donc de former un mot avec une de ces paires pour chaque lettre de l'alphabet.

;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

Une chose intéressante à noter est que, bien que Japt puisse implicitement décompresser une chaîne encapsulée dans des backticks, il s'agit en fait d'un octet plus long ici, car vous auriez à saisir deux caractères dans la chaîne décompressée, au lieu d'un.

05AB1E , 45 42 39 38 37 36 octets

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

Essayez-le en ligne!

Explication

Aupousse l'alphabet majuscule.
'Æåpousse le mot scenario.
•à¡P°€kš¦zᮕpousse le nombre base-10 36774474076746444766322426.
Sèutilise ces chiffres pour indexer scenario.
)øzips ces chaînes ensemble dans la liste[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

Mots utilisés: ['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']

Version de 33 octets en utilisant des mots dont je ne suis pas sûr

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

Mots: ['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 octets

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

Sortie:

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

Tous les mots de 3 lettres finissant par 't', la plupart d’entre eux avec 'at'.

Utilisation de mots controversés (iat, dat, amp. Ump) - 55 octets:

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

En essayant toujours de trouver un motif, je pense qu'il est possible d'utiliser seulement 2 fins différentes et de tout simplifier.

Merci @Value Ink et @Business Cat pour votre aide.

///, 163 octets

/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

Essayez-le en ligne

Yob - n. - Un homme cruel et brutal

Hm, a appris quelque chose aujourd'hui ...

05AB1E , 72 68 octets

Code:

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

Utilise le codage CP-1252 . Essayez-le en ligne!

Explication

Le code suivant:

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

pousse ce tableau:

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

Et est traité en utilisant le code suivant:

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 octets

Eh bien, maintenant c'est certainement une solution non concurrente car il serait beaucoup plus facile de coder en dur les mots utilisés. Publiez-le simplement pour avoir la bonne réponse (et ne pas utiliser la liste de mots des autres).

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

Fondamentalement, toutes les fonctions définies dans l’ clojure.coreespace de noms sont toujours récupérées , mais après cela l’évalue doc <function name>et les place dans une chaîne. Après cela, le concatène en une chaîne énorme (avec le mot xyst) et trouve les mots appropriés à partir de là. Devrait être exécuté dans Clojure REPL.

Sortie:

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

Ancienne solution:

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

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

Une fonction anonyme renvoyant une chaîne. Contient des non imprimables; voici une version qui ne le fait pas:

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

Ceci utilise la technique de @ JonathanAllen, en n'utilisant que des mots de trois lettres finissant par t. La chaîne décompresse pour AnBiCoDoEaFaGOHuIsJoKiLoMaNiOuPaQaRoSiTiUnVeWeXaYeZi.

J'ai essayé d'enchaîner des paires de deux lettres comme suit:

Ace
 Bee
  Cee
   Dew
    Ewe
     ...

J'ai maintenant fait tout ce chemin pour Xrester bloqué Y; pour autant que je sache, le seul Xmot accessible de trois lettres est Xis, et il n'y a pas de mot de trois lettres commençant par Ys.

Pour mémoire, la chaîne complète était ceeeweeereueaebiueeiziais...

Mathematica, 97 octets

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

Recherche dans Mathematica WordListle troisième mot commençant par chaque lettre; cela évite les mots d'une lettre et les interjections. A une nouvelle ligne de piste.

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 octets

(édité de 76 à 73 octets, merci chat)

Inspiré par la solution de rubis:

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

nous utilisons anyau lieu de chacun car il est plus court et toutes les instructions println renvoient false. Pour les cas particuliers de la chaîne, nous utilisons String.find qui, dans groovy, renvoie la correspondance ou null. Sur null, nous utilisons l'opérateur elvis ?:pour renvoyer un mot se terminant par 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, récursivité, 74 octets

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

imprime le texte de la première réponse puis lève une exception PatternFormatException. Nous appelons la fermeture récursivement en commençant par 'A' et en augmentant ++charjusqu'à ce que le caractère suivant Zlève l'erreur.

Groovy, en trompant, 77 octets

Avec le risque d'être lynché:

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

C'est-à-dire, lisez les données de cette page et imprimez la définition d'une réponse valide au début. Pour ma défense ... il imprime la réponse demandée ... maintenant personne ne modifie la page ...

Groovy, utilisation de 'times', 81 octets

Construire sur la réponse en python avec le motif de mot à trois lettres:

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

impressions:

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, en récursant sur main (...), 83 octets

En supposant que nous comptions les nouvelles lignes comme un seul caractère.

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

imprime le texte de la première réponse puis lève une exception PatternSyntaxException.

Groovy, using eachWithIndex, 88 octets

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

Groovy, en utilisant transpose, 102 octets

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

05AB1E , 77 octets

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

Essayez-le en ligne!

Utilise la chaîne suivante compressée:

ASSBINCATDOTEATFATGOTHATILLJOTKITLOTMETNOTOATPATQUEROTSETTITUSEVATWETXISYIPZAP

Converti en base 214:

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

A utilisé une liste de mots au scrabble de 3 lettres: http://wordfinder.yourdictionary.com/letter-words/3

La sortie est la suivante:

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

Avait une version de 70 octets, mais les mots de 2 lettres ne sont pas autorisés.

A expliqué:

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

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

Maintenant, en utilisant des mots qui dans t

Lithp , 136 125 117 octets

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

(Split pour la lisibilité)

Essayez-le en ligne!

C’est quasiment un portage de la réponse Python

• 11 octets enregistrés en utilisant eachl'index de
• Sauvegardé 8 octets en supprimant les appels inutiles à (scope #)

Sortie:

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

Lot, 250 octets

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

Comme je n'allais jamais obtenir un score décent, j'ai choisi les mots humoristiques les plus courts possibles:

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

empilés , 72 octets

Il y en a deux pour 72 octets!

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

Essayez-le en ligne! En utilisant ce modèle génial. (Avant de vous demander, ++serait un simple jeton, donc + +est utilisé à la place.)

Ils travaillent tous deux par itérer de 65la 90et d' obtenir la séquence de caractères correcte. Remarques:

• #: est un alias pour chr
• # est un alias pour get
• {!...}est le même que { n : ... }(lambda avec ncomme paramètre)

Pour 73 octets:

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

Mathematica 93 octets

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

les rendements

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 octets

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

Sortie

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 octets

J'ai sacrifié quelques octets pour pseudo-randomiser la sortie à chaque exécution. L'idée est de rechercher des mots minuscules d'au moins 3 caractères /usr/share/dict/words, puis d'en choisir un dans cette liste à l'aide de 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])

Édite

• Supprimé title()car les mots ne doivent pas nécessairement être mis en majuscule.
• Changement de l'expression rationnelle en "\n(%c.{3,})"(+ 3 octets) pour permettre la suppression de ,re.M(- 5 octets).

Exemple de sortie:

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 (indicateur r) = 82 octets

Ceci est une implémentation sérieuse de la liste de mots de la réponse de Jonathan Allan .

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

Les mots, à l'exception de la lettre de fin partagée t, sont donnés sous forme concaténée à la ligne 1, puis imprimés dans le format demandé par la ligne 2. Une nouvelle ligne est présente.

Courir :

sed -rf alphabet_song.sed <<< ""

Java 7, 124 121 octets

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

Basé sur la réponse de @JonathanAllen , Java ne disposant pas de dictionnaire intégré sophistiqué. ;) J'ai essayé de trouver une autre lettre de fin pour tout l'alphabet (comme sou nou y), ou une lettre du milieu (comme aou e), mais la plupart manquaient d'un ou deux mots. J'ai donc fini par utilisert . Les mots sont choisis manuellement parmi wordhippo.com .

Ungolfed:

Essayez ici.

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

Sortie:

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 octets

Basé sur la liste de mots de Jonathan Allan :

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

anciennes versions, 86 octets:

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

Courez avec -nr.

sortie

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

Pour les mots étranges, voir la réponse d’Ismael