text:
Create an Alphabet Song
Your goal is to create an alphabet song as text in the following form (in order):
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>

Example 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

Rules:

Each "letter" of the song has its own line, so there are 26 lines, and a possible trailing linefeed.
The output is case-sensitive:

The letter at the start of each line must be capitalized.
is for is lowercase.
The chosen word does not need to be capitalized, but may be. All lines should be consistent.

The chosen word for each line is up to you, but must be a valid English word with at least 3 letters, and it cannot be a conjunction (like and or but), interjection/exclamation (like hey or yay), abbreviation (like XLS), or a name (like Jon).
Though I doubt anyone would find it shorter, I'd find it acceptable to use a phrase instead of a single word. So if for some reason S is for Something smells fishy... is shorter, go for it.
Put your program's output in your answer, or at least the list of words you used (if there's a link to run your code online, we don't need to see the entire output).
Shortest code wins

This challenge was inspired by this video.

I am guessing slang is not allowed, even if listed in proper dictionaries? (e.g. "When she realised she was headed towards the outback again she just pulled a uey!")

Given some of the answers, this song by Barenaked Ladies seems relevant.

@JonathanAllan No slang. Dictionaries contain a lot of things that aren't technically words. Abbreviations is one, slang is another.

@AdmBorkBork This challenge was inspired by this video.

It's too bad that this devolved into finding 3 letter words that end in the same letter.

@12Me21 how is that devolution, is this not code-golf?! If you can find a way to access longer words with fewer bytes just do it! Edit - Find a list of 3-letter words using a set of two middle letters and a set of two end letters and you can beat the single enders (which use a set of seven middles).

@12Me21 Just because other people are copying each other's methods doesn't mean that there isn't a better one yet to be found.

There's a couple of answers using an external dictionary. Shouldn't they have to add the size of that file to their code?

@pipe Like which? The ones using the Linux words file? I'm not sure. What's the meta consensus? Idk, because if you think about Python modules, each one is really a different file, but the Linux file is OS dependent, so that might be an external source, not part of the language.

If X is for X-ray is allowed (where X is not a word, but just represents the common letter for an unknown in algebra) and S is for Something smells fishy... is also allowed, would X is for X is a letter be allowed?

No. X-ray is a single word, just like twenty-two is a word. Learn your English.

Relevant?

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

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

This is pretty much Jonathan Allan's answer, but ported to this language.
Old 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)

output:
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

This is not the shortest this language can do, but should be the best with the words hard coded.

Bash (+coreutils), 81, 87, 82, 78 bytes
Uses the man page for X, as the source of words.
Golfed
man xyst\  x|&grep -Po '\b[a-z]{4,} '|sed 's/\(.\)/\u\1 is for &/'|sort -uk1,1

EDITS

Used a non-existing 'xyst' man page + |& to save 5 bytes;
Saved 4 more bytes, by swapping sed and sort.

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

Does the name thing apply to any names (i.e. Cities, Continents e.t.c.) or only human names ?

Yeah. An alphabet song is typically for kids, and they don't use proper nouns.

Are lsof and xregs words? :)

@OldBunny2800 should be fixed now

I looked it up, and yes, xyst is a real word. :)

Looks like kids are gonna be learning some big words. :D

"What is a man?!"

Have you an online interpreter link? I don't know bash or sed - is the word "xyst" going through the grep somewhere, or would using a 3 letter non-existent page work to save a byte? (Xis and Xat are options).

@JonathanAllan
Unfortunately, man page for "x" is not available on TIO, but here is a link
https://tio.run/nexus/bash#@5@bmKdQUVlcEqOgAGTWqKUXpRYo6AbkK6jHJEUn6lbFVpvo1Cqo1xSnpiioF@vHaOjFaOrHlMYYKmQWK6TlFymo6QMl84tKFHRLsw11DP//BwA, which uses "man man" instead.
The trick with xyst is that man xyst will complain that there is "No manual entry for xyst" to the stderr, which is then merged into stdout with |&, so it can be grepped.

I've considered using a 3-letter "x"-word instead, but that won't work, as the regexp looks for the 4-letter words (as otherwise the rest of the dictionary would not be correct).

Yeah, I saw the "4" in the grep and realised there must be invalid strings in there you needed to ignore. Thanks for the link!

The challenge says "at least 3 letters" though...

Python 2, 88 77 bytes
-11 bytes thanks to xnor (avoid the zip by traversing the string and counting c up from 65)
c=65
for x in'niooaauusoioaiuaaoiineeaei':print'%c is for %c%st'%(c,c,x);c+=1

Try it online!
(A port of my Jelly answer, when it was 56 bytes.)
A is for Ant
B is for Bit
C is for Cot
D is for Dot
E is for Eat
F is for Fat
G is for Gut
H is for Hut
I is for Ist
J is for Jot
K is for Kit
L is for Lot
M is for Mat
N is for Nit
O is for Out
P is for Pat
Q is for Qat
R is for Rot
S is for Sit
T is for Tit
U is for Unt
V is for Vet
W is for Wet
X is for Xat
Y is for Yet
Z is for Zit

I like the method of words that end in t. The iteration can be shortened by updating x in parallel.

Very smart, as ever; thanks!

What's Unt? Can't find that one anywhere

I don't think Unt is a word, but Ut is so you can replace the n in your literal with \0 to make this valid and only add on one more byte. Edit nevermind rules say it has to be 3 letters long... hmmm

@AlbertRenshaw An unt is a European Mole according to Merriam-Webster. An alternative would be ult according to Wiktionary it is not just an abbreviation (which are listed with periods, such as ult.).

@JonathanAllan Oh I gotcha, it didn't return any results for me because I don't have access to M-W's unabridged section of their site.

Bash, 78, 69 bytes
Aardvarks, Babushkas and Kamikazes !
Golfed
sed -nr '/^[a-z]{9}$/s/(.)/\u\1 is for &/p'</u*/*/*/words|sort -uk1,1

EDITS

Got rid of grep, -9 bytes

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

Makes use of /usr/share/dict/words:

words is a standard file on all Unix and Unix-like operating systems, and is simply a newline-delimited list of dictionary words. It is used, for instance, by spell-checking programs.

PowerShell, 150 141 117 75 bytes
65..90|%{$i=[char]$_;"$i is for $i$('niooaauusoioaiuaaoiineeaei'[$_-65])t"}

Try it online!
Loops from 65 to 90 (i.e., ASCII A to Z). Each iteration, we turn the integer into the appropriate char (i.e., ASCII 65 for A), save that into $i for use later, string-concatenate that with is for $i, and then tack on the middle of the appropriate word. That's done by indexing into a lengthy string (borrowed from Jonathan Allan's answer). Finishes off with the letter t to make the three letter word.
The resulting strings are all left on the pipeline, and an implicit Write-Output at the end prints them with newlines in between.
Saved a bunch of bytes thanks to Rod
Borrowed wordlist from Jonathan Allan's answer

you can remove the first letter of each word (the capital one) and print with [char]$ example

@Rod Thanks. I coupled that with what I was just working on to change how the loop is calculated and how the indexing is calculated and saved some more yet.

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

TryItOnline!
Based on the 56 byte version (two below), but changed words to remove all middle letter "u"s so it can index into the dictionary word "anisole"*, which has the convenience of having the letters we need all at indexes less than six: 1:a, 2:n 3:i, 4:s, 5:o (6:l), 0:e (note the "e" on the right is at index zero [also 7 and -7 and any other number congruent to 0  mod 7]). It's also early in the dictionary so has only a two rather than the much more common three byte lookup index ("anisogamete" would also work for 2).
* The old-school name for the aromatic ether methoxybenzene, often used in perfumes.
A is for Ant
B is for Bit
C is for Cot
D is for Dot
E is for Eat
F is for Fat
G is for Got
H is for Hat
I is for Ist
J is for Jot
K is for Kit
L is for Lot
M is for Mat
N is for Nit
O is for Oat
P is for Pat
Q is for Qat
R is for Rot
S is for Sit
T is for Tit
U is for Unt
V is for Vet
W is for Wet
X is for Xat
Y is for Yet
Z is for Zit

###How?
“¤ṁ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
                          -> [          "A" ,          "B" ,          "C" ,          "D" ,          "E" ,          "F" ,          "G" ,          "H" ,          "I" ,          "J" ,          "K" ,          "L" ,          "M" ,          "N" ,          "O" ,          "P" ,          "Q" ,          "R" ,          "S" ,          "T" ,          "U" ,          "V" ,          "W" ,          "X" ,          "Y" ,          "Z"]
                    ç"  - zip with last Link (1) as a dyad (i.e. get [f("A", "n"), f("B", "i"), ...]
                          -> ["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"]
                      Y - join with line feeds
                        - implicit print

;“ẉbẊWS»,⁸K;;”t - Link 1, make a song line: character X; character Y
 “ẉbẊWS»        - compressed string = " is for"
;               - X (e.g. "A") concatenate that ->  "A is for"
        ,       - pair that with
         ⁸      - the left argument (X) ---------> ["A is for","A"]
          K     - join with spaces -------------->  "A is for A"
           ;    - concatenate with Y (e.g. "n") ->  "A is for An"
             ”t - literal character = "t"
            ;   - concatenate ------------------->  "A is for Ant"

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

Words all have second letter "s" or "a" and last letter "p" or "t" using a base four lookup in a Cartesian product of "sa" and "pt". Except the "U" word, which the code changes to "Use" (using the relatively bulky F”e272¦ on the end) - if I could find a word list like this that does not have such an exception we'd be looking at 39 bytes.
Word list:
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

try this one

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

Word list:
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

It is formatted, give it a go

###Previous, 83 bytes
“ẉbẊWS»WṁØA⁺żż“¦ịfe$ɲVPġþ¹Øt@ƑƊŀqṁŒƑOɦ⁴ḍẊḤṁr}Ƭ¢b⁻?q&øIụNẎ9eƲi⁸'ıB.;%V,¦İ⁷ẓk½»s5¤K€Y
...let's play "Spot which letter does not have an animal!" there is one, and only one - watch out for the red herring (a lie, the red herring was xenon, which is an element, obviously not an animal), are two five letter words here that are not animals (xenon being one):
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

(of course this is formatted correctly, try it - I just thought I'd save space)

Xenon is not an animal. I was sure you were making a joke by having H is for Herring, but I guess not.

Heh, it was a lie. Xenon was the obvious one :)

I think they are thinking of xenop, which is not in Jelly's dictionary.

Wonderful idea! But Uut?

@GregMartin I agree, I think you started devolving your words into syllabic grunts.

@GregMartin Oh, too quick with Google - I saw "Atomic Number 113" but failed to spot it is the symbol not the name... luckily an unt is a European Mole

What's a Xat?

@AdmBorkBork Apparently it's a type of carved totem pole

I couldn't wait for an explanation so I picked apart the code myself with TIO. That's a genius idea, but I don't think it'll work in many other languages. We'll see...

You can probably improve the 56-byte version to less than 52 via using base conversion and a lookup table to encode the string of letters.

@ais523 yes I think I can do 51, working on shortening

@ais523 actually, nope I can't do 51 due to the chain having multiple nilads. I've done 53.

@ais523 ...but I've got the newer version down to 50 :D

Aha, a jabot is "an ornamental frill or ruffle on the front of a shirt or blouse, typically made of lace". Obviously not an animal :-)

@ETHproductions congratulations!

@ais523 - turns out you were spot on - that version is now standing at 44 bytes using a base 8 (even though 7 letters) compression and indexing into the Cartesian product of the compressed string of the words "noise" plus "aura" and the letter "t".

@boboquack thanks, looks like I wasn't quite on the ball. fixed.

Retina, 89 87 bytes
Saved 2 bytes thanks to Martin Ender

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

m`$
t

Try it online!
I picked a word for each letter that ends in t (some are pretty obscure).
Explanation

ApBaCaDoEaFaGeHaIkaJeKiLeMeNeOpPeQaRaSaTiUniVaWeXysYurZi
Replace the non-existent (empty) input with the text above.
[A-Z]
¶$& is for $&

Replace each capital letter with (newline)(itself) is for (itself). This results in the text above being split into separate lines like
A is for Ap
B is for Ba
C is for Ca

... and so on
^¶

However, since the newline was placed before each capital, there is a leading newline that must be removed. It is removed in this stage.
m`$
t

Put a t at the end of every line, since every word used in the song ends in t.

You don't need to capture the upper case letter. Just use $& or $0 instead of $1. Actually that might also save bytes over my split stage.

@MartinEnder Thanks. What does $& do exactly? I didn't see it on the GitHub wiki.

It's an alias for $0 (and it's just part of the .NET flavour, as well as most other flavours).

Using some shorter words to get it down to 83, try it online

Retina, 92 88 bytes
Saved 4 bytes by borrowing an idea from Business Cat's answer.
Byte count assumes ISO 8859-1 encoding.

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

Try it online!
Based on AdmBorkBork's word list, but I've changed a few more words into ones that end in ad to save more bytes on the common suffix.
Explanation

AddBCDEelFGHItsJetKitLMNetOilPQatRSTUrnVatWXisYesZit

Turn the empty (non-existent) input into this string. It contains all the letters as well as the rest of those words which don't end in ad.
[A-Z]
¶$& is for $&

Insert a linefeed before each upper case letter and then turn it into X is for X.
m` .$
$&ad

Match the letters which are now by themselves and append ad to complete the shortened words.
G`.

Discard the empty line that was created by inserting a linefeed before A.

PHP, 122 124 127 120 115 101 bytes
Follows the "standard" <letter><filler>t structure.
I tried to come up with words that weren't used before by anyone.
If you see a word that you want me to replace, tell me.
foreach(range(A,Z)as$k=>$c)echo"$c is for $c",ceaoaaei0eieeouoaaei0eeaei[$k]?:[I=>ka,U=>ni][$c],"t\n";

The newline is represented as \n but counted as 1 byte.

Output:
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

Weird words:

ikat:

Ikat, or ikkat, is a dyeing technique used to pattern textiles that employs resist dyeing on the yarns prior to dyeing and weaving the fabric.

xat:

A carved pole erected as a memorial to the dead by some Indians of western North America

zit:

a pimple; skin blemish.

qat:

Catha edulis (khat, qat) is a flowering plant native to the Horn of Africa and the Arabian Peninsula.

Clever solution I was going to do something similar, glad to see this! +1

These aren't english words....

@ConorO'Brien Are you sure? PHP is all written in English, as far as I know.

@IsmaelMiguel things like vprintf and zend_version are most certainly not english words. Very few of these entities are actually words.

I think those are in english...

@ConorO'Brien Since you didn't like my list of English words in English, I made a new list of English words with words that are definetivelly written in English!

@IsmaelMiguel It's not that I didn't like it, it's just that it was breaking the rules stated by the OP. I removed my downvote..

The words are at least 3 letters

@MatthewRoh Sorry, fixing it

@MatthewRoh Thanks for pointing that out. I've fixed it now. If you see anything needing a fix, tell me.

I wouldn't call zit a weird word, at least, I think everyone should already know what it means.

I honestly didn't. But English isnt my first language. I can remove the definition if you think it doesn't belong there.

I dunno about T here...

@matt https://codegolf.stackexchange.com/a/109530/
https://codegolf.stackexchange.com/a/109519/
https://codegolf.stackexchange.com/a/109509/ <-- Posted before mine - https://codegolf.stackexchange.com/a/109579/
https://codegolf.stackexchange.com/a/109588/
https://codegolf.stackexchange.com/a/109595/
https://codegolf.stackexchange.com/a/109656/
https://codegolf.stackexchange.com/a/109581/
https://codegolf.stackexchange.com/a/109678/ <-- Posted after mine.
So far, nobody said anything about those. (Also, tit is a bird: https://en.wikipedia.org/wiki/Tit_(bird))

@IsmaelMiguel hmm ok

05AB1E, 45 42 39 38 37 36 bytes
Au'Æå•à¡P°€kš¦zá®•Sè)øvy¬“ÿ€ˆ€‡ ÿt“,

Try it online!
Explanation
Au pushes the uppercase alphabet.
'Æå pushes the word scenario.
•à¡P°€kš¦zá®• pushes the base-10 number 36774474076746444766322426.
Sè uses those digits to index into scenario.
)ø zips those strings together into the list [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

Words used: ['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']
33 byte version using some words I'm unsure about
Au'†Ž•4Ãðzòç•3BSè)øvy¬“ÿ€ˆ€‡ ÿt“,

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

-1 byte by changing the vy to for example ʒ (since we print, we can use the filter as a foreach). Since this answer is pretty old, the )ø should now be øJ and the •à¡P°€kš¦zá®• should be •V¢~U∊›v‚FγÞ•: try it online.

Japt, 52 50 bytes
Collaborated with @ETHproductions
;B£[R`  f `Od"¥¥º"gY]qXÃx

Contains many unprintables. Test it online!
The word list is:
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 uses the shoco string compression library, which reduces common runs of lowercase letters into by a byte. Here is a full list of all two-letter runs that are condensed into one 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

So the idea is to form a word with one of these pairs for each letter of the 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

One interesting thing to note is that while Japt can implicitly decompress a string wrapped in backticks, that's actually a byte longer here because you'd have to grab two chars in the decompressed string, rather than one.

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

Try it here!
Link is for 3 length and doesn't qualify as words include conjunctives.
    [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()

Outputs:
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

You can test this outside of Pyke using same algorithm. Requires 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))

No. Also, I get an error running your code.

Timeout running code. BAD EVAL Make sure you update your "Try it online" link.

Z is for zoofilia I would seriously consider before letting my kids sing this.

@zeppelin http://chat.stackexchange.com/transcript/message/35306609#35306609

For anyone doing a double-take like I did: english is not always capitalized. ;)

Ruby, 93 84 69 63 58 62 bytes
?A.upto(?Z){|l|puts l+" is for #{"AnDoIsUn"[/#{l}./]||l+?a}t"}

Output:
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

All 3-letter words ending with 't', most of them with 'at'.
Using controversial words (iat, dat, amp. ump) - 55 bytes:
?A.upto(?Z){|l|puts l+" is for "+l+("AU"[l]?"mp":"at")}

Still trying to find a pattern, I think it's possible to use just 2 different endings, and simplify everything.
Thanks @Value Ink and @Business cat for helping.

Qat and Xis (plural of Xi) are words, so you can use them and also reduce your lookup regex to /#{l}../

Thanks, I was thinking about something similar but I am away from my PC now, I will definitely check that.

Actually I was trying to find some 5 letter words for the missing letters: array, essay, inlay... But I am stuck on that. :-(

Kat is a valid word, so you can remove the special case for kit.

Very nice. Using some of your words could save me 3 bytes, but I can't find valid definitions for all of them. Words like dat and zat. Where did you find them?

Originally from wordhippo, double-checked with other sources. Zat is a village in Iran (Wikipedia), Dat is a common abbreviation for "digital audio tape" (Thefreedictionary). "aat" and "uat" seem to be impossible.

I thought of "dat" and "zat" but they are both the same conjunction (that) and slang, both of which types of words are barred. "amp" and "ump" seem to be abbreviations of "ampere"/"amplify" and "umpire". "IAT" is an acronym, so that's no good either.

Iat is indeed controversial, I am using "imp" instead. I will check the rest.

Would using ikat instead of imp help?

I don't know, I have to find a pattern, or go back to the first idea.

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

Try it online

Yob - n. - A cruel and brutal fellow

Hm, learned something today...

In the UK a yob is a lout, a thug, or a boor; more uncouth and rowdy than cruel and brutal.

In Russian "Yob" is a shortened past form of obscene verb, which, basically, is an equivalent of "f*ck" in English. The more you know...

05AB1E, 72 68 bytes
Code:
”–³æéÁéî¹àæÑåêÂ§µ™Ä‚æ†Í„Î¢×†™ƒÛÌ´ŸÄ«©‡¯†‚Ä²‚Ò„©É€ŠÛì„”#vy¬…ÿ€ˆ€‡ð«ì,

Uses the CP-1252 encoding. Try it online!
Explanation
The following code:
”–³æéÁéî¹àæÑåêÂ§µ™Ä‚æ†Í„Î¢×†™ƒÛÌ´ŸÄ«©‡¯†‚Ä²‚Ò„©É€ŠÛì„”#

pushes this 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']

And is processed using the following code:
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

Can you explain why that pushes that array?

I think 05AB1E has some built in words that can be represented by 2 bytes in a string.

@12Me21 that's cool! ”–³”=Apple and int(–³,214)=23891 but I still don't see the correlation here.

I believe this is the list: https://github.com/Adriandmen/05AB1E/blob/master/dictionary.py

@carusocomputing Here is a more detailed description of how the compression and decompression works.

@Adnan ahh... Odd way to index, but it works!

January, Xanax, and Zoloft are proper names, aren't they?

Clojure, 159 232 bytes
Well, now it's certainly non-competing solution as it would be far easier to hardcode the words used. Putting it out there just for the sake of having correct answer (and not using others' list of words).
(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))

Basically still gets all the functions defined in clojure.core namespace, but after that evaluates doc <function name> and puts it into string. After that concatenates it into one huge string (with the word xyst) and finds appropriate words from there. Should be run in Clojure REPL.
Output:
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

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

or, not orb, for 1 byte.

The minimum length is 3 letters

@mbomb007 updated.

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

An anonymous function returning a string. Contains unprintables; here's a version that doesn't:
_=>btoa`\x02pb
\x80è\x11¡Z\x18áî"Âh*"è1£b:ãÚA¤hJ$âRu^YåÚaæb`.replace(/(.)./g,`$1 is for $&t
`)

This uses @JonathanAllen's technique, using only three-letter words that end in t. The string decompresses to AnBiCoDoEaFaGOHuIsJoKiLoMaNiOuPaQaRoSiTiUnVeWeXaYeZi.
I tried chaining two-letter pairs like so:
Ace
 Bee
  Cee
   Dew
    Ewe
     ...

I've now made it all the way to X but got stuck on Y; as far as I can tell, the only attainable three-letter X word is Xis, and there's no three-letter word starting with Ys.
For the record, the full string was ceeeweeereueaebiueeiziais...

According to Wiktionary, you could use uzi and tiz...

@DLosc Great idea. Then you'd have to do sei, ski, or sri, which leaves you with ree, roe, rue, rye, which leaves you with... the only three letter q-words I can find are qat, qis, and qua. Is there a Wiktionary page with more three-letter words?

There's a category for three-letter words, but it isn't a complete list. For instance, it doesn't contain que (which I only know about because another answer here used it). (Not sure there's a p-word that ends with u, though.)

@DLosc I was already using piu, so that's not a problem at all :P Thanks!

Hm. piu seems pretty borderline--wiktionary doesn't have it as English, and dictionary.com has it as più (dunno how we're considering accents for this challenge). But yeah, ys_ would be a problem.

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

Looks in Mathematica's WordList for the third word beginning with each letter; this avoids one-letter words and interjections. Has a trailng newline.
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, totally forgot, thanks

Groovy, 76 73 bytes
(edited from 76 to 73 bytes, thank you cat)
Inspired by the ruby solution:
('A'..'Z').any{i->println"$i is for ${'AntIvyUse'.find(/$i../)?:i+'at'}"}

we use any instead of each as it is shorter and all the println statements return false. For the special cases in the string, we use String.find which in groovy returns the match or null. On null we use the elvis operator ?: to return a word ending in at instead.
Prints out:
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, recursion, 74 bytes
{i->println"$i is for ${'AntIvyUse'.find(/$i../)?:i+'at'}";call(++i)}('A')

prints out the text from the first answer and then throws a PatternFormatException. We call the closure recursively starting with 'A' and incrementing ++char until the character after Z throws the error.
Groovy, by cheating, 77 bytes
With the risk of being lynched:
print 'http://codegolf.stackexchange.com/q/109502'.toURL().text[21796..22189]

i.e. read the data in this page and print out the definition of a valid answer at the beginning. In my defense...it does print out the requested answer...now nobody edit the page...
Groovy, using 'times', 81 bytes
Building on the python answer with the three letter word pattern:
26.times{i,c=i+65->printf"%c is for %c${'niooaauusoioaiuaaoiineeaei'[i]}t\n",c,c}

prints:
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, by recursing on main(...), 83 bytes
Assuming we count newlines as one character.
i=args?args[0]:'A'
println"$i is for ${'AntIvyUse'.find(/$i../)?:i+'at'}"
main(++i)

prints out the text from the first answer and then throws a PatternSyntaxException.
Groovy, using eachWithIndex, 88 bytes
'niooaauusoioaiuaaoiineeaei'.eachWithIndex{c,i->char x=i+65;println "$x is for $x${c}t"}

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

Kat is a valid word, so you can remove the special case for kit.

edited, thank you. Saved me 3 bytes : )

SmileBASIC, 131 113 82 81 bytes
FOR I=1TO 26L$=CHR$(I+64)?L$;" is for ";L$;@niooaauusoioaiuaaoiineeaei[I];"t
NEXT

Now using words that in t

Example output?

It's the same as this one: http://codegolf.stackexchange.com/questions/109502/create-an-alphabet-song/109530#109530

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

Try it online!
Uses the following string compressed:
ASSBINCATDOTEATFATGOTHATILLJOTKITLOTMETNOTOATPATQUEROTSETTITUSEVATWETXISYIPZAP
Converted to Base-214:
‹T1qA‹rËöf#ùqÈ$>M©ÈñM£r°§°Ü]€¡3¸/©#bÍ'ò7DÉø½D—¹û©˜Ò×

Used a list of 3-letter scrabble words: http://wordfinder.yourdictionary.com/letter-words/3
Output is as follows:
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

Had a 70 byte version, but 2-letter words aren't allowed.

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

qui is not an English word. Looking this up reveals only a Latin word.

@mbomb007 was supposed to be Que I knew there was a 3 letter legal scrabble word, misspelled it.

Nice words :) }» could be replaced with ,.

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

(Split for readability)
Try it online!
This is pretty much a port of the Python answer

Saved 11 bytes by using each's index
Saved 8 bytes by removing useless call to (scope #)

Output:
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

Great name! (I don't, thuffer from a lithp, doethe the language have thuch a thpeech ithue though?)

Thank you! Nope, the language is fine with pronunciation. It's more that it's a bastardized version of Lisp. I just found Lisp far too difficult to wrap my head around, Lithp is my take on it in a way that makes sense to me. It should be much more readable than most Lisp code.

Perl 5, 72 bytes
say"$_ is for $_",(niooaaoasoioaiaaaoiineeaei=~/./g)[-65+ord],t for A..Z

Try it online!

Nice can't think of an alternative approach. You can save a few bytes using $-++ instead of the trick with ord though: Try it online!

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

Output
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

GNU sed, 81 + 1(r flag) = 82 bytes
This is a sed implementation of the word list from Jonathan Allan's answer.
s:$:AnBiCoDoEaFaGuHuIsJoKiLoMaNiOuPaQaRoSiTiUnVeWeXaYeZi:
s:(.).:\1 is for &t\n:g

The words, except the shared ending letter t, are given in concatenated form on line 1, and then printed in the requested format by line 2. A trailing newline is present.
Run:
sed -rf alphabet_song.sed <<< ""

PHP, 91 87 86 76 bytes
based on Jonathan Allan´s word list:
for($a=A;$i<26;)echo"$a is for ",$a++,neaoaaeiseioeuuoaaiineiaei[$i++],"t
";

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

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

Run with -nr.
output
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

For the weird words, see Ismael´s answer

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

Since I was never going to get a decent score, I went for the shortest humorous words that I could find:
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

stacked, 72 bytes
There are two for 72 bytes!
65@i$'niooaauusoioaiuaaoiineeaei'{!i#::' is for '+\n+'t'+ +out i 1+@i}"!
{!n#::' is for '+\'niooaauusoioaiuaaoiineeaei'n 65-#+'t'+ +out}65 90 for

Try it online! Using that awesome pattern. (Before you ask, ++ would be a single token, so + + is used instead.)
Both work by iterating from 65 to 90 and getting the correct character sequence. Notes:

#: is an alias for chr
# is an alias for get
{!...} is the same as { n : ... } (lambda with n as an parameter)

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

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

Based on @JonathanAllen's answer, since Java has no fancy built-in dictionary. ;) I tried to find another ending letter for the entire alphabet (like s or n or y), or a middle letter (like a or e), but most were missing just one or two words, so I ended up using t as well. Words are manually chosen from wordhippo.com.
Ungolfed:
Try it here.
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());
  }
}

Output:
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 for +a+++. I like writing those :P

Python 3, 145 137 135 bytes
I sacrificed some bytes to pseudo-randomise the output with each run. The idea is to look for lowercase words of at least 3 characters in /usr/share/dict/words and then pick one from that list using 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])

Edits

Removed title() as words don't have to be capitalised.
Changed the regex to "\n(%c.{3,})" (+ 3 bytes) to allow removal of ,re.M (- 5 bytes).

Example 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

Not sure they're all valid. For instance, I can't find a definition for Qohele,  though a search reveals that it is a book or volume of sacred text.

Just noticed that my regex doesn't match until the end of each word -- will fix.

Fixed it. Now only looking for lowercase, complete words to not have names in there.

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

yields
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

Vyxal j, 38 bytes
»hrZ⌈∪≠ẏ¡ɽ»`…„ṙµ`τkAZƛ÷:ðJ«⁼Ė⁼|«Jpp\tJ

Try it Online!
Port of Jelly answer.
How?
»hrZ⌈∪≠ẏ¡ɽ»`…„ṙµ`τkAZƛ÷:ðJ«⁼Ė⁼|«Jpp\tJ
»hrZ⌈∪≠ẏ¡ɽ»                             # Push compressed number 1849391794619481940361
           `…„ṙµ`                       # Push dictionary compressed string "anisole"
                 τ                      # Convert to custom base (this will result in "niooaaoasoioaiaaaoiineeaei")
                  kAZ                   # Zip with the uppercase alphabet
                     ƛ÷:                # For each item, push both to the stack and duplicate the top item (e.g. stack: "n", "A", "A")
                        ðJ              # Add a space to the end of the alphabet letter
                          «⁼Ė⁼|«J       # Concatenate compressed string "is for " to it
                                 pp     # Concatenate the alphabet letter and the other letter to the end (e.g. stack: "A is for An")
                                   \tJ  # Append the letter "t" to the end
                                        # j flag joins the top of the stack on newlines

Python 2, 112 bytes
for x in range(26):y=chr(x+65);print y+' is for '+y+'naaoaaeaneieaiaaaaairaeeei'[x:x+1]+('t','n')[x in(8,20,23)]

Try it online!
All of the words end with 't' except for 3 which end with 'n' so we just store the middle letters of the three letter words and indexes of the 3 'n' words and sort out the 'misfits' at the end.

Python 2.X, 147 bytes
Yet another try in python using nltk -
from nltk.corpus import*;k=lambda y:filter(lambda x:y in x[0],words.words());print'\n'.join([chr(i)+' is for '+k(chr(i))[64]for i in range(65,91)])

Output -
A is for Abranchiata
B is for Baconic
C is for Cahokia
D is for Damara
E is for Echium
F is for Fascista
G is for Galenic
H is for Halawi
I is for Ichthyornithidae
J is for Jamaica
K is for Kanauji
L is for Lahontan
M is for Macropodinae
N is for Nankingese
O is for Odelsthing
P is for Palaeeudyptes
Q is for Quintius
R is for Rambo
S is for Sac
T is for Tagula
U is for Ulyssean
V is for Vanguardist
W is for Wallon
X is for Xiphodontidae
Y is for Yazoo
Z is for Zea

Ungolfed
from nltk.corpus import*
k=lambda y:filter(lambda x:y in x[0],words.words())
print'\n'.join([chr(i)+' is for '+k(chr(i))[27]for i in range(65,91)])

@mbomb007 I used words corpus but brown corpus can also be used and it is quite better for this problem (but its really yuge). Btw Rambo is actually a word haha - http://dictionary.cambridge.org/dictionary/english/rambo

Befunge-93, 73 bytes
This just uses three-letter words, where the last letter is always t.
naaoaauanoioaefeauoosaeaei:0\55+\"t"\:0g\"A"+:," rof si ">:#,_$1+:55*`#@_

Try it online!
But with an additional two bytes, we can vary the last letter between t and e and get a more interesting selection.
teuowaeocoaooudouaeosaoaei:"A"+:,0" rof si ">:#,_$,:0g,1+:2%0g,55+,:55*`#@_

Try it online!

Jelly, 153 bytes (hardcoded words)
“¢r£ẒẸv⁽Ẋ⁷ƥḷṢ⁴kṣe]Ȧ½ṇZṅẸȥɓ!ṗẒ/¿`-¤ḅṘẠṗıBṖ²}çSṘ¦qḤAi\Ḃɲ=T¿?İ®ʋÇIZ(ṅ/ß+oŻ#⁽ƙ©Ḷ!&ẋṡU7FocĊ¶€¢¦ḥLØṀ¿;ȥż!Ọerṫ÷1Ẹjẏ8Ƙ&£ṃṾḊ¿Ṅ⁾ị°ÑBḅQ²€œðḤDẊj£ṅĠsṿBsƤȤ»ṣ”%j“ẉbẊWS»

Try it online!
A is for Apple
B is for Bald
C is for Cabin
D is for Dairy
E is for Eagle
F is for Fact
G is for Gauge
H is for Humid
I is for Iamb
J is for Jar
K is for Keg
L is for Lad
M is for Music
N is for Nose
O is for Oak
P is for Page
Q is for Quart
R is for Rag
S is for Sock
T is for Taco
U is for Udon
V is for Vault
W is for Week
X is for Xylophone
Y is for Yard
Z is for Zoo

Scala, 85 bytes
Based on @JonathanAllen's answer

Golfed version. Try it online!
var c=65
for(x<-"niooaauusoioaiuaaoiineeaei"){println(f"$c%c is for $c%c$x%st");c+=1}

Ungolfed version. Try it online!
object Main {
  def main(args: Array[String]): Unit = {
    var c = 65
    val input = "niooaauusoioaiuaaoiineeaei"
    for (x <- input) {
      val output = f"$c%c is for $c%c$x%st"
      println(output)
      c += 1
    }
  }
}


text:
Prime Divisor Table
Intro
Something I've played around with in recreational mathematics has been construction of a divisor table to visually compare/contrast the prime divisors of a set of numbers. The set of input numbers are across the top as column labels, the prime divisors are on the left as row labels, and a mark indicates where the two line up.
For example, for input 6, 9, 14, 22 a table similar to the following would be constructed:
    6  9 14 22
 2  *     *  *
 3  *  *
 7        *
11           *

This is because 6 has prime divisors of 2 and 3, 9 has prime divisors of 3, and so on.
Construction

The table is constructed such that the input numbers form column labels that are separated by spaces and in ascending order (you can assume they are pre-sorted), and the prime divisors are listed on the left in ascending order one per line forming the row labels.
Note that leading spaces on the prime divisors and input numbers may be required if the numbers are different lengths, so that all columns are the same width and line up appropriately.
Each divisor is represented by a single * (or other suitable ASCII character of your choosing, so long as the same character is used for all occurrences).
Multiple divisors are ignored (e.g., 3 x 3 = 9 but there's only one * for that intersection).
The * can be placed anywhere horizontally in the column, so long as it's unambiguous (I have all my examples with the * right-aligned).

Input

A list of positive integers in any convenient format, each >1.
You can assume that the input is pre-sorted.
The input is guaranteed to have only unique values.

Output
The resulting ASCII art representation of the prime divisor table.
Rules

Leading or trailing newlines or whitespace are all optional, so long as the characters themselves line up correctly.
If it's shorter to have a divider line separating the column/row headings from the tabular data, that's allowed, too.
Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
If possible, please include a link to an online testing environment so people can try out your code!
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Examples
6,9,14,22

    6  9 14 22
 2  *     *  *
 3  *  *
 7        *
11           *

2,3,5,7

  2 3 5 7
2 *
3   *
5     *
7       *

2,4,8,16,32

   2  4  8 16 32
2  *  *  *  *  *

75,99,151,153

     75  99 151 153
  3   *   *       *
  5   *
 11       *
 17               *
151           *

Can we have divider lines after the top row and the left column?

@ngenisis Sure, I'll allow that. The exact formulation of the table is pretty open, since that's not the exact thrust of this challenge.

Mathematica, 101 90 bytes
Thanks to ngenisis for saving 11 bytes!
TableForm[Outer[If[#∣#2,Y,""]&,f=#&@@@FactorInteger[1##],g={##}],TableHeadings->{f,g}]&

The ∣ character about a third of the way through is U+2223 (3 bytes). Unnamed function of a variable number of arguments, each of which is a nonzero integer, which returns a TableForm object (formatted output) like so:

f=#&@@@FactorInteger[1##] defines f to be the set of all primes dividing any of the inputs (equivalently, dividing their product 1##), while g is the list consisting of the inputs. Outer[If[#∣#2,Y,""]&,f,g] makes a table of Ys and empty strings corresponding to divisibility (we use the undefined token Y instead of a string "Y" or "*" to save two bytes). Then we use TableForm[...,TableHeadings->{f,g}] to format the resulting array with appropriate row and column headings.
Previous submission:
Grid[p=Prepend;Thread[q[Outer[If[#∣#2,Y,""]&,f=#&@@@FactorInteger[1##],g={##}]~p~g,f~p~""]]/.q->p]&

You can leave out the first "".

TableForm[Outer[If[#∣#2,Y,""]&,f=#&@@@FactorInteger[1##],g={##}],TableHeadings->{f,g}]& if dividers are allowed

And the second as well if you change it to p[f,].

Grid lines to separate the headers is allowed.

That's cool that Grid ignores Null, I didn't know that.

TableForm is cool, hopefully that will stay in my toolbox!

Jelly, 18 bytes
PÆfQ0;ðḍ€+W}⁸;"o⁶G

Uses 1 instead of *, as allowed by the rules.
Try it online!
How it works
PÆfQ0;ðḍ€+W}⁸;"o⁶G  Main link. Argument: A (array of integers greater than 1)

P                   Take the product of the integers in A.
 Æf                 Compute all prime factors (with multiplicity) of the product.
   Q                Unique; deduplicate the prime factors.
    0;              Prepend a 0. Let's call the result P.
      ð             Begin a new, dyadic chain. Left argument: P. Right argument: A
       ḍ€           Divisible each; for each p in P, test all integers in A for
                    divisibility by P. Yields one row of the shape of A for each p.
                    Note that the first element of P is 0, so the first row of the
                    resulting matrix contains only zeroes.
          W}        Wrap right; yield [A].
         +          Add the results to both sides. Because of how Jelly's auto-
                    vectorization works, this adds the first row of [A] (just A) to
                    the first row of the divisibility matrix (all zeroes) and
                    leaves the other rows untouched.
            ⁸;"     Prepend the elements of P to the corresponding rows of the
                    previous result.
               o⁶   OR space; replace all zeroes with spaces.
                 G  Grid; format the matrix as requested in the challenge spec.

JavaScript (ES6), 264 260 ... 179 173 bytes
a=>[for(c of s=' '.repeat(w=a.slice(-1),i=0))if(!+(r=[i++?i:s,...i<2?a:a.map(x=>x%i&&c)].map(y=>(s+y).slice(-(w+1).length),a=a.map(d=x=>i<2|x%i?x:d(x/i))).join``))r].join`
`

I think this approach has now permanently exceeded the recursive one (currently 178 bytes):
f=(a,i=0,w=a.slice(-1))=>i++-w?(+(r=[i<2?'':i,...i<2?a:a.map(x=>x%i&&' ')].map(y=>(' '.repeat(w)+y).slice(-(w+1).length)).join``)?'':r+`
`)+f(a.map(d=x=>i<2|x%i?x:d(x/i)),i,w):''

Uses 0 in place of *, which is allowed by the challenge.
Test snippet

let g =

a=>[for(c of s=' '.repeat(w=a.slice(-1),i=0))if(!+(r=[i++?i:s,...i<2?a:a.map(x=>x%i&&c)].map(y=>(s+y).slice(-(w+1).length),a=a.map(d=x=>i<2|x%i?x:d(x/i))).join``))r].join`
`

console.log(g([6,9,14,22]))
console.log(g([2,3,5,7]))
console.log(g([2,4,8,16,32]))
console.log(g([75,99,151,153]))

If I'm not mistaken, you can use the | operator in the if statement, since you're comparing 2 booleans...

@Luke Hey, you're right. Not sure how I missed that

Isn't it shorter to move the i<2 check inside the .map function?

@Luke If you mean change ...i<2?a:a.map(x=>x%i&&c) to ...a.map(x=>i<2?x:x%i&&c), that's no shorter. If you mean move it into the other .map, perhaps...

Jelly, 25 23 bytes
PÆfQ©ḍþµị⁾* ³;"Z⁶;®¤;"G

Try it online!
How?
It may well be shorter to use ÆE and filter out empty rows.
PÆfQ©ḍþµị⁾* ³;"Z⁶;®¤;"G - Main link: list of numbers, L
       µ                - monadic chain separation
P                       - product of L - multiply them all together
 Æf                     - prime factors (with repetitions, in ascending order)
   Q                    - unique items, maintaining order
                              - note that the product was performed to keep order
    ©                   - place in the register for later use, and yield
      þ                   - form the outer product of that and L using the dyad:
     ḍ                  -     isDivisor - 1 if divides, 0 if not
        ị⁾* <space      - index into "* " (1s to "*", 0s to " ")
            ³           - program's first input, L
             ;"         - zip with concatenation (column headers to the left)
               Z        - transpose (get it around the right way)
                   ¤    - nilad followed by link(s) as a nilad
                ⁶;®     - space (⁶) concatenated with (;) the register value (®)
                    ;"  - zip with concatenation (row labels to the left)
                      G - format the result as a grid (join items with spaces and
                                               rows with line feeds so they align)
                        - implicit print

Python 2 - 197 bytes
Switched to Python 2 for easier input handling and allowing `` for string conversion. Uses gmpy2 for generating the next prime. Output format still based on previous Python 3 submission (see below), namely filling a list g with symbols and formatting it.
import gmpy2
i=input()
n=len(i)+1
p=1;g=[' ']+i
while p<i[-1]:
 p=gmpy2.next_prime(p)
 t=['*'[m%p:]for m in i]
 if'*' in t:g+=[p]+t
print((('{:>%d}'%(len(`i[-1]`)+1)*n+'\n')*(len(g)/n)).format(*g))

Try it online!
Explanation
For those who don't want to decode it themselves.
import gmpy2                    # arithmetic library
i=input()
n=len(i)+1                      # saves bytes by not needing ()
                                # afterwards
p=1                             # starting number
g=[' ']+i                       # initialsing header row
while p<i[-1]:                  # looping until last character
  p=gmpy2.next_prime(p)         # get the next prime
  t=['*'[m%p:] for m in i]      # verify whether p is a
                                # divisor of each number
  if'*'in t:g+=[p]+t            # if any divisor found, append
                                # p + divisors to g.
print(
    (('{:>%d}'%(len(`i[-1]`)+1) # compute right formatting element
                                # for length of last character + 1
        *n+'\n'                 # repeat for each input + once
                                # for the prime and add newline
     )*(len(g)/n)               # repeat row format until g
                                # can be inserted
    ).format(*g)                # format using g
)

Previous
Python 3 - 251 bytes
Pretty sure someone can do better. Based on this answer for generating the primes < k.
i=list(map(int,input().split(',')))
l=len(str(i[-1]))+1
n=len(i)+1
g=[0]+i+sum([l for l in [[k]+[j%k==0for j in i]for k in range(2,i[-1])if all(k%f for f in range(2,k))]if 1in l],[])
print((('{:>%d}'%l*n+'\n')*(len(g)//n)).format(*g).replace('0',' '))

Ungolfed version and explanation will follow.

Welcome to PPCG!

Instead of i=list(map(int,input().split(','))), you could just do i=input(), and take input in the form [1, 2, 3, 4].

Thanks, I didn't know that. But I'm going to rework it later anyway :).

You can save 2 bytes with p=gmpy2.next_prime(p);t=['*'[m%p:]for m in i], and removing the space in if"*" in.

Python 2, 181 179 bytes
 -2 bytes thanks to FlipTack

n=input()
p=[]
t="%%%ss "%len(`n[-1]`)*-~len(n)
print t%(('',)+n)
i=2
while n[-1]/i:
 if all(i%j for j in p):
	p+=[i];s=['*'[m%i:]for m in n]
	if'*'in s:print t%tuple([i]+s)
 i+=1

The input must be a tuple.
Try it online!

Does all(i%j for j in p) work instead of using map?

@FlipTack yes, It was better, but I changed some thing and forgot the update this

Batch, 451 bytes
@echo off
set/am=0,w=2,p=1
for %%n in (%*)do set/a"n=m-%%n,m+=(n>>31)*n
for /l %%i in (0,1,9)do set/am/=10,w+=!!m
set s=
for %%n in ("" %*)do set t=%%~n&call:t
set v=%*
:g
if not %s: =%==%p% echo%s%
if %m%==1 exit/b
set/at=p+=1,m=0
set s=
call:t
set v=&for %%n in (%v%)do set n=%%n&set t=&call:c
goto g
:c
set/ar=n%%p
if %r%==0 set/an/=p&set t=*&goto c
set/a"m|=n
set v=%v% %n%
:t
set t=           %t%
call set s=%%s%%%%t:~-%w%%%

Explanation: Starts by calculating the field width w via the maximum of the input values m. Generates the first line of output by padding an empty string and the input numbers to the width w using the subroutine t. Then loops through the integers starting at 2, generating the line of output by padding the integer and then calling the subroutine c to pad an empty string or an asterisk as appropriate for each value, however the generated line is then skipped if it contains no asterisks. As the output is generated, each value is divided by the integer until it would leave a remainder, so the loop terminates when no value is greater than 1.
Note that the set v= gets executed after the %v% is substituted into the for loop on the same line.

Python 2, 157 148 146 145 143 bytes
def p(*t):print'%%%ds '%len(`x[-1]`)*len(t)%t
def f(x):k=m=1;p(' ',*x);exec"r=[n%k and' 'for n in x]\nif 0in m%k*r:p(k,*r)\nm*=k*k;k+=1;"*x[-1]

Uses 0 instead of *, as allowed by the rules.
Try it online!
Background
To identify primes, we use a corollary of Wilson's theorem:

How it works
The first line defines a helper function.
def p(*t):print'%%%ds '%len(`x[-1]`)*len(t)%t

p takes a variable number of arguments which it stores in the tuple t.
The '%%%ds '%len(`x[-1]`) uses a format string to construct a format string; %% is a literal percent sign, %d is a placeholder for the integer that len(`x[-1]`) returns, i.e., the number of digits of the last element in x (the input, not yet defined), and s  is literal.
If, e.g., the last element of x has three digits, this yields %3s , which *len(t) repeats once for every element of x. Finally, %t applies that format string to the tuple t, constructing a string of t's elements, space-separated and all right-justified to a certain length.
The second line defines the actual submission: a function f that takes a list x as input. After replacing the exec statement, which executes the string it precedes x[-1] times, with a for loop, we get the following code.
def f(x):
    k=m=1;p(' ',*x)
    for _ in range(x[-1]):
        r=[n%k and' 'for n in x]
        if 0in m%k*r:p(k,*r)
        m*=k*k;k+=1

First, f initializes k and m to 1. Note that (k - 1)! = 0! = 1 = m.
Then, p(' ',*x) prints a space and the integers in x, using the function p.
Now, we enter the loop to print the remaining output.
First, r=[n%k and' 'for n in x] constructs the list of the remainders of each integer n in x divided by k. Positive remainders, i.e, remainders that do not correspond to multiples of k, are truthy and get replaced with a space by and' '.
Next, we construct m%k*r. Since m = (k - 1)!, by the corollary of Wilson's theorem, this will be simply r if k is prime, but an empty list if not. If there is at least one 0 in the result, i.e., if k is prime and at least one integer in x is divisible by k, 0in m%k*r will return True and p(k,*r) get called, printing k and the divisibility indicators: 0 if divisible, a space if not.
Finally, we multiply m by k² and increment k, so the quality m = (k - 1)! continues to hold.

Mathematica, 165 bytes
Rather verbose - maybe someone can do something with it:
(j=Join;a=#[[All,1]]&/@FactorInteger@#;b=Sort@DeleteDuplicates@Flatten@a;Grid[j[{j[{""},#]},Transpose@j[{b},Table[If[MemberQ[a[[t]],#],"*",""]&/@b,{t,Length@a}]]]])&

Bash + GNU utilities, 134 133 132 125 123 bytes
q=printf\ ;u=$q%9s
$u
$q%9d $@
echo
for p in $($u\\n `factor $@`|bc|sort -un)
{
$q%9d $p
for x;{ ((x%p))&&$u||$u X;}
echo
}

Try it online!

MATL, 31 bytes
pYfu!Gy\~h0GhwvVZ{'(?<!\d)0'0YX

This uses 1 instead of *, as allowed by the challenge.
Try it online! Or verify all test cases.
Explanation (outdated)
p           % Implictly input array of numbers. Push product of array
Yf          % Prime factors as a row vector
u           % Keep only unique values
!           % Transpose into column vector
G           % Push input again
y           % Duplicate column vector of unique prime factors onto top
\           % Modulo, element-wise with broadcast
~           % Negate
h           % Concatenate horizontally
0           % Push 0
G           % Push input again
h           % Concatenate horizontally
w           % Swap
v           % Concatenate vertically
V           % Char array representation
Z{          % Convert to cell array of strings. Each row gives a string
'(?<!\d)0'  % Push this string: match '0' not preceded by a digit
0           % Push this string: '0' will be replaced by char 0
YX          % Regexp replace
            % Implicit inoput. Char 0 is displayed as space

Racket 176 bytes
(let((p printf))(display"   ")(for((x nl))(p" ~a " x))(displayln"")(for((i '(2 3 7 11)))
(p"~a  " i)(for((j nl))(if(member i(prime-divisors j))(p" * ")(p"   ")))(displayln"")))

Ungolfed:
(define (f nl)
  (let ((p printf))

    (display "   ")
    (for ((x nl))
      (p " ~a " x))
    (displayln "")

    (for ((i '(2 3 7 11)))
      (p "~a  " i)
      (for ((j nl))
        (if (member i (prime-divisors j))
            (p " * ")
            (p "   ")))
      (displayln ""))))

Testing:
(f '(6 9 14 22))

Output:
    6  9  14  22
2   *     *  *
3   *  *
7         *
11            *

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Dynamic programming - decreasing number
The challenge
You are given an integer n, and you have to use these operations to make it 1.

Divide it by 3.

Divide by 2.

Subtract 1.

Examples:
Input    Output
  1        0 (Its already 1, guys)
  5        3 (3->2->2 or 3->3->1)
 10        3 (3->1->1)
255        10(3->3->3->1->1->2->2->3->1->2)

Please expand on allowed input, expected output, and what the winning criterion is. Is the division floored to an integer? Consider using the Sandbox for Proposed Challenges to receive feedback for a challenge idea.

What if my language of choice only supports integer arithmetics ? Can I still apply ?

@zeppelin sure you can

@mbomb007 is 3 enough? Yes it is floored

What is the winning criterion? As I said before, try reading the guide in the Sandbox and visit our FAQ, where there is a template for challenges and things to consider when creating a challenge and What makes winning criteria “objective”?.

Personally, I'd recommend answering challenges before asking. That way, you'll see plenty of examples of great questions. Feel free to look at other questions to see how specific and detailed they are.

Also, you say it's floor division, but then 5 -> 1 because 5/3 = 1, so your example is wrong. Also, subtraction is never needed, the minimal number of moves can be reached with only division by 2 or 3.

Going by the three examples it looks like one may only divide when it gives an integer result (thus from ten one could start with a divide by two, but then it takes 3 steps from five, whereas if one starts by subtracting one, one may then divide by three twice from nine to get to one in a total of three operations).

@JonathanAllan "Yes it is floored" http://codegolf.stackexchange.com/questions/109602/dynamic-programming-decreasing-number#comment266880_109602

@mbomb007 I know, I saw that, but it does not fit with the examples! 5 divided by three floored is one.

Does the result need to reach 1 in fewest operations possible, or is any solution finding 1 acceptable?

@JonathanAllan And hence why it is closed. Anyway, I found a 54-byte solution for the one with floored division. Related OEIS

I think I might be able to fix it.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Smallest n-digit prime containing only these digits
You will need to generate the smallest prime with n digits, and it will only contain digits specified in the list k.
Examples:
Input:
4
1 2

For this, you must generate the smallest prime with 4 digits, and that prime must only contain the digits 1 and 2.
Output:
2111

Input:
10
0 4 7

Output:
4000000007

Input:
6
5 5 5 5 5 5 5 5 5 5 1 5 5 5 5 5 5 5 5 5 5

Output:
115151

You can guarantee that the input will always be in the format you specify, and you can do anything if you get invalid input (such as the input being a single digit n, without k.)
If no such solution to an input exists, your program is allowed to do any of the following:

Print banana
Throw an error
Run forever
Anything else

Since this is code-golf, try to aim for the shortest code.
The input can be in any format you specify. For example, if you want your input to be like any of the following, that is fine.
4
[1, 2]

[1,2]4

1,2
4

4 12

You can either write a program or a function, and it must either return the correct value or print it.
Whitespace is allowed anywhere.
This challenge inspired by A036229.

Mandatory question: Can we use any base? (The challenge is much easier in unary.)

Can the solution have leading zeros if zero is one of the input digits?

@flawr of course not, i think it may come under standard loopholes (if not, it needs to be added)

@LuisMendo i wouldn't count that as 'proper' number, so no.

Can the list be a set literal? And characters instead of integers? (@xnor's Python answer is using those)

@mbomb007 Yes, as the input is flexible.

Yeah, you said that, but taking input as a set removes duplicates from the list automatically, so I didn't know if it was allowed.

@mbomb007 That's allowed

Based on the second test case with output 4000000007 I assume we need to support numbers larger than 32-bit?

@KevinCruijssen Yes.

@Okx Ok, edited my answer.

Brachylog (2), 8 bytes
j₍oᵐ∋ᵐcṗ

Try it online!
Very slow on problems which have a lot of possible digits, or which contain a 0 in the set of possible digits (it does work in this case; it's just that it's so much slower that TIO times out unless the problem's very simple). As usual for Brachylog, this is a function, not a full program.
Input is taken in the format [ndigits,[list of digits]], e.g. [10,[[0,4,7]]].
Explanation
j₍oᵐ∋ᵐcṗ
j₍        Make a number of copies of the second element equal to the first element
  oᵐ      Sort each (ᵐ) of those copies (evaluation order hint)
    ∋ᵐ    Take one element from each of those copies
      c   Concatenate those elements to form an integer (asserts no leading 0)
       ṗ  producing a prime number

Seen from the purely declarative point of view, this says "find a prime number, with the given number of digits, where all digits are one of the given digits". In order to find the smallest such number, we use evaluation order hints in order to ensure the order in which we test the numbers is smallest to largest; in this case, ᵐ makes decisions near the start of the list less prone to changing than decisions near the end (this is its natural order, which happens to be the same as lexicographic and thus numerical order on integers), and thus {o∋}ᵐ has two evaluation order hints, "vary the last few digits first" (from the ᵐ's natural order) as the more important hint, and "check smaller digits before larger digits" (from the o before the ∋, which acts as a hint in this context) as the tiebreak. {o∋}ᵐ can be written as the equivalent oᵐ∋ᵐ to save a byte.

Bash + bsd-games package, 28 bytes

18 bytes saved thanks to @Dennis.

primes 1|egrep -wm1 [$2]{$1}

Input given at the command-line as n followed by k as a non-delimited list of digits.
Try it online.

Nice use of egrep.

Python 2, 66 bytes
f=lambda n,s,k=1,p=1:10**~-n<p%k*k<s>=set(`k`)or-~f(n,s,k+1,p*k*k)

Try it online!
Takes input like f(3,{'9','3','8'}).
Python has no built-ins for primes, so the function generates them using Wilson's Theorem to check each potential value for k in turn for being prime.
The chained inequality 10**~-n<p%k*k<s>=set(`k`) combines three conditions on k:

10**~-n<k: k contains at least n digits. We don't need to check exactly since if we reach more digits, there must have been no solution
p%k>0: k is prime, via the Wilson's Theorem condition with p=(n-1)!^2. Since p%k is 0 or 1, this can be combined with the previous condition as 10**~-n<p%k*k
s>=set(`k`): All digits in k are in the set s. This can be spliced in because Python 2 considers sets as bigger than numbers.

If the current k doesn't satisfy all of these, the function recurses onto k+1, adding 1 to the resulting output. Since the output terminates with True which equals 1, and k starts at 1, the output is k. This parallel tracking of k beats outputting k directly on success.

Wow -- awesome use of Wilson's Theorem!

JavaScript (ES7), 100 bytes
Takes input as number of digits n and string of allowed digits s in currying syntax (n)(s). Returns undefined if no solution is found.
Works rather quickly for up to 6 digits, might work for 7 and definitely too slow -- and memory hungry -- beyond that.
n=>s=>(a=[...Array(10**n).keys()]).find(i=>eval(`/[${s}]{${n}}/`).test(i)&&a.every(j=>j<2|j==i|i%j))

Test

let f =

n=>s=>(a=[...Array(10**n).keys()]).find(i=>eval(`/[${s}]{${n}}/`).test(i)&&a.every(j=>j<2|j==i|i%j))

console.log(f(5)("247")) // 22247

Exactly what I would have done, except maybe with a different primality test. I'll see how my way compares to yours...

@ETHproductions I started with a recursive primality test but it would have limited it to 4 digits (or maybe a bit more on some browsers?)

My first thought for a recursive solution is four bytes shorter, but it does throw an error for large numbers. I had n=>s=>[...Array(10**n).keys()].find(i=>eval(`/[${s}]{${n}}/`).test(i)&(p=j=>i%--j?p(j):j==1)(i))

@ETHproductions I too was tempted to use & instead of &&. But performance wise, this is a very costly byte.

The current version of Chrome supports TCO if you enable the "enable-javascript-harmony" flag (just go to chrome://flags and find that option)

Jelly, 12 bytes
DL×ÆP
ṗḌÇÐṀṂ

Takes a set and an integer as command-line arguments. Prints 0 if no solution exists.
Try it online!
How it works
ṗḌÇÐṀṂ  Main link. Left argument: A (digit set/array). Right argument: n (integer)

ṗ       Cartesian power; yield all arrays of length n that consist only of elements
        of the array A.
 Ḍ      Undecimal; convert all generated digit arrays to integers.
  ÇÐṀ   Keep only elements for which the helper link returns a maximal result.
     Ṃ  Take the minimum.

DL×ÆP   Helper link. Argument: k (integer)

D       Decimal; convert k into the array of its base 10 digits.
 L      Take the length.
   ÆP   Test if k is a prime number. Yields 1 or 0.
  ×     Multiply the length and the Boolean.

Pyke, 18 16 bytes
j;~p#`ljqi`Q-!)h

Try it here!
Runs forever if no values found

@Okx should now be fast enough to run most if not all of the test cases now

@Okx you know that you can download Pyke and run it offline if you want to test it fully without a time limit?

Oh, sorry. I thought it was the code. Turns out the timeout is about four seconds which is not very much.

Mathematica, 64 bytes
FirstCase[Tuples@##,x:{f_,___}/;f>0&&PrimeQ[y=FromDigits@x]:>y]&

Pure function where the first argument is the (sorted) list of allowed digits and the second argument is the allowed length. Tuples@## computes all lists of the allowed digits of the allowed length, then we find the FirstCase which matches x:{f_,___} such that the first digit f is not 0 and the integer y=FromDigits@x is prime and replaces it with y.

That's cool how you use the /; test to select a tuple but also :> convert to the desired output format. (I see in the documentation that that's allowed, but only after reading this answer!) You should specify that your function requires the allowed digits to be sorted: it gives the wrong answer 3331 instead of 3313 if called with [{3,1},4].

@ngenisis how about Select[FromDigits/@Tuples[Sort@#,#2],PrimeQ][[1]]&@@#& ?

@martin That doesn't account for tuples starting with 0 and the @@#& seems redundant.

@ngenisis sorry - didn't account for that

Brachylog, 15 bytes
tL∧?h~lṗ.dẹp⊆L∧

Try it online!
This is fairly slow.
Explanation
tL                Input = [H, L]
  ∧
   ?h~l .         The Output is a variable of length H
       ṗ.         The Output is a prime number
          ẹ       The Output's digits...
        .d        ...when removing duplicate digits...
           p      ...is a permutation...
            ⊆L    ...of an ordered subset of L
              ∧

JavaScript (ES6), 86 bytes
Takes input via the currying syntax, e.g., (4)('12')
n=>(d,F=(i,P=j=>i%--j?P(j):1==j)=>P(i)&&`${i}`.match(`^[${d}]{${n}}$`)?i:F(i+1))=>F(2)

'use strict';

const G=n=>(d,F=(i,P=j=>i%--j?P(j):1==j)=>P(i)&&`${i}`.match(`^[${d}]{${n}}$`)?i:F(i+1))=>F(2)

const submit = () => {
  console.clear();
  console.log(G(+n.value)(d.value));
}

button.onclick = submit;
submit();
<input id="n" type="number" min="1" value="4" />
<input id="d" type="text" value="12" />
<button id="button">Submit</button>

To be run in strict mode (for tail call optimisation [TCO]). If your environment doesn't support TCO it will result in a stack overflow error for primes larger than the environments stack.
For invalid inputs it will run forever.
Note:

Chrome (>= 51) users can go to chrome://flags/#enable-javascript-harmony and enable this flag to run the above snippet with TCO support.
Safari (>= 10) supports TCO

I think you can save two bytes with F=i=>(P=j=>i%--j?P(j):1==j)(i)&&...

@ETHproductions Can't because it has to be run in strict mode (to avoid stack overflow) and that creates a global variable P.

Oh, I didn't realize TCO only applied in strict mode.

@ETHproductions Aye neither did I until I read the spec I posted XD my first variation of the answer did use that shortcut until I realised it was invalid.

MATL, 17 bytes
wlwX"1GXNUStZp)l)

This function accepts two inputs, an integer specifying the number of digits and a character array indicating the possible values. In the case of no primes, an error is shown.
Try it Online!
Explanation
        % Implicitly grab two inputs. First as an integer (N), second as a string (OPTS)
w       % Reverse the order of the inputs
l       % Push the literal 1 to the stack
w       % Pull N back to the top of the stack
X"      % Repeat OPTS N times
1G      % Explicitly grab N again
XN      % Get all N-character combinations of the repeated version of OPTS
U       % Convert each row from a string to a number
S       % Sort them in ascending order
tZp)    % Grab only those that are primes
l)      % Retrieve the first prime
        % Implicitly print the result

Pyth - 13 12 bytes
f&P_T!-Tz^Tt

Test Suite.

Sage, 62 bytes
lambda l,d:[p for p in primes(10^(l-1),10^l)if set(`p`)<=d][0]

Takes input of the form: f( 4 , {'1','2'} )

Perl 6, 43 bytes
->\n,@k {first *.is-prime&/^@k**{n}$/,^∞}

Runs forever if no solution exists.

what is the input format?

@Okx: It's a lambda that takes two argument: A number n, and a list k.

Ruby, 77 76 bytes
->n,l{(10**~-n..10**n).find{|n|(2...n).none?{|x|n%x<1}&&!n.to_s[/[^#{l}]/]}}

Input format: a number and a string.
Example:
->n,l{...see above...} [6,"555555555515555555555"]
=> 115151

.all?{|x|n%x>0 and /[^#{l}]/!~n.to_s are two other 1-byte changes you can make

05AB1E, 22 19 18 bytes (-1 @Riley)
[NØ©S¹Kg0Q®g²Q&i®q

Try it online!
[                   # infinite loop.
 NØ©                # push nth prime.
    S¹Kg0Q          # see if, without banned digits, it's 0 length.
          ®g²Q&     # see if, it is originally also the length specified.
               i®q  # if true, print result and exit.

I don't think you need the , at the end.

@Riley nice call!

05AB1E, 17 bytes
[¾ØÐ¼g¹QiS²Kg0Qiq

Try it online!
[¾Ø ¼             # Infinite loop over all primes
   Ð              # Push two extra copies on the stack
     g¹Qi         # If the length of this prime == the first input...
         S²K      # Push this prime without any of the digits in the second input
            g0Qi  # If the length of what remains is 0...
                q # quit
                  # implicitly print this prime

R, 88 bytes
Note: as a special 'Language of the month' treat for anyone contemplating starting to golf in R (and I hope there are many of you...), I've written a short commentary of the various iterations that led to this answer in the R golfing chatroom.
function(n,k)for(x in 1:10^n)if(sum(x%/%10^(1:n-1)%%10%in%k)==n&(sum(!x%%1:x)<3))stop(x)

Try it online!
Outputs as an error message.  No output when there is no solution.
Checks all numbers in the range 1:10^n (obviously 10^n is not a prime, so we don't need to worry about the end case):

x%/%10^(1:n-1)%%10 extracts the digits, and %in% k checks whether each digit is in the list.  If the sum is ==n then we know that all the digits are Ok.
(sum(!x%%1:x)<3) checks for primality (a prime should have only 2 factors including 1 and itself).

When we find the first solution, we exit with stop(x) to output the answer as an error message.  return(x) would be the friendlier solution to output to STDOUT, but it costs +2 bytes.

APL (NARS2000 0.5.14), 31 characters:
{A←⍺⋄((1∘π)⍣{∧/A∊⍨⍎¨⍕⍺})10*⍵-1}

Example:
      1 2 {A←⍺⋄((1∘π)⍣{∧/A∊⍨⍎¨⍕⍺})10*⍵-1} 4
2111

      5 5 5 5 5 5 5 5 5 5 1 5 5 5 5 5 5 5 5 5 5 {A←⍺⋄((1∘π)⍣{∧/A∊⍨⍎¨⍕⍺})10*⍵-1} 6
115151

How it works:
A←⍺ captures left argument, that is, the required digits composing target prime.
10*⍵-1 generates the least number have ⍵ digits e.g. 10*(4-1) = 1000
1∘π finds next prime number of right argument; So on first iteration, (1∘π)1000 yields 1009
⍣ operator recursively applies (1∘π) to result from above, unless the inner function {∧/A∊⍨⍎¨⍕⍺}, when applied to 1009, evaluates to 1 i.e. boolean true, where it does not; Thus recurse.
The inner function {∧/A∊⍨⍎¨⍕⍺} takes ⍺, result of current iteration, as argument and test if every digit of it is an element of vector A.
Limitations:
Non-termination if no such prime of n digit exist.
Runs very slowly using the n = 10 example, not able to return even after 30 seconds.

Perl5, 77 bytes
($n,$d)=@ARGV;/^[$d]{$n}$/&&("x"x$_)!~/^(..+?)\1+$/&&print&&die for 2..10**$n

Run like this:
perl -le '($n,$d)=@ARGV;/^[$d]{$n}$/&&("x"x$_)!~/^(..+?)\1+$/&&print&&die for 2..10**$n' 4 12

Perl 6, 68 bytes
->\n,\k{first {.is-prime&&/.**{n}/},+«[X~] 0,|(k.unique.sort xx n)}

Try it
Returns Nil if no such prime can be found.
Expanded:
->
  \n, # number of digits
  \k  # list of digits
{

  first

    {
        .is-prime
      &&
        / . ** {n} / # exactly ｢n｣ digits ( in case ｢k｣ has a 0 )
    },

    +«\          # turn the following into a list of numbers

    [X[~]]       # cross the following with &infix:<~>

    0,           # append a 0 in case ｢n｣ was 1
    |(           # slip this list in (flatten)

        k        # the input list of possible digits
        .unique  # only one of each to reduce the search space (optional)
        .sort    # sort it so that the cross meta op returns them sorted

      xx         # list repeat

        n        # ｢n｣ times
    )
}

Python 2 + primefac, 91 85 bytes
import primefac as P
n,k=input()
p=10**~-n
while set(`p`)!=k:p=P.nextprime(p)
print p

Try it online
Input is like 4,{'1','2'}.

1,{'1'} isn't a valid input (because 1 isn't prime), so you can do whatever you like there.

Java 7, 139 141 bytes
long c(int a,String b){for(long n=2,i,x;;n++){for(x=n,i=2;i<x;x=x%i++<1?0:x);if(x>1&(n+"").length()==a&(n+"").matches("["+b+"]+"))return n;}}

+2 bytes by supporting numbers above 32-bit (changed int to long)
Input format: An integer (i.e. 4) and a String (i.e. "12")
Explanation:
long c(int a, String b){                  // Method with the two input parameters specified above
  for(long n = 2, i, x; ; n++){           // Loop from 2 going upwards
    for(x = n, i = 2; i < x; x = x % i++ < 1 ? 0 : x);  // Prime check for `n`
    if (x > 1                             // if `n` is a prime (if `x` > 1 after the loop above it means `n` is a prime)
         & (n+"").length() == a           // AND if `n` has a length equal to the input integer
         & (n+"").matches("["+b+"]+")){   // AND if `n` only contains the specified digits of the input String (using a regex)
      return n;                           // Then we have our answer
    }
  }                                       // If no answer is available for the given input, it continues looping
}

Test code:
Try it here.
NOTE: The second test case is disabled because it loops for a very long time..
class M{
  static long c(int a,String b){for(long n=2,i,x;;n++){for(x=n,i=2;i<x;x=x%i++<1?0:x);if(x>1&(n+"").length()==a&(n+"").matches("["+b+"]+"))return n;}}

  public static void main(String[] a){
    System.out.println(c(4, "12"));
    //System.out.println(c(10, "047"));
    System.out.println(c(6, "555555555515555555555"));
  }
}

Output:
2111
115151

PHP, 82 bytes
for($n=10**--$argv[1];$i-1||a&trim($n,$argv[2]);)for($i=++$n;--$i&&$n%$i;);echo$n;

Takes a number and a string of digits from command line arguments. Run with -nr.
breakdown
for($n=10**--$argv[1];  // $n = smallest number with (argument1) digits
    $i-1||                  // loop while $n is not prime or
    a&trim($n,$argv[2]);    // $n without all digits from (argument2) is not empty
)
    for($i=++$n;--$i&&$n%$i;);  // $i=largest divisor of $n smaller than $n (1 for primes)
echo$n;                 // print

Whispers v2, 245 bytes
> Input
> Input
> 10
> 0
>> ≺1
>> 3*1
>> 3*5
>> 7…6
>> L’
>> Select∧ 9 8
>> L⊥3
>> L∖2
>> Each 11 10
>> Each 12 13
>> #L
>> L=4
>> Each 15 14
>> Each 16 17
>> L⋅R
>> Each 19 13 18
>> Select∧ 15 20
>> 21ⁿ4
>> 22⊤3
>> Output 23

Try it online!
How it works
Assuming the two inputs are \$n\$ (the number of digits) and \$S\$ (the set of digits), the program works as follows:
First we generate the range \$A = \{10^{n-1}\dots10^n\}\$ and remove all composite numbers in this range. Next, we take the set difference of each value and the input set \$S\$, which gives \$\{\}\$ for all numbers which have the same digits as \$S\$ and a non-empty set for those that don't. We then take the length of each set, and if it is \$0\$, we keep the values in the set. Finally, of the filtered values, we select the first value i.e. the lowest value. This outputs the lowest value in the set of prime numbers between \$10^{n-1}\$ and \$10^n\$, where the digits are in \$S\$.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Tips for golfing in Underload
Underload is a stack-based semi-functional tarpit created by ais523. I've recently been trying to golf in it, as it's a surprisingly elegant language.
What tips do you have for golfing in Underload? (One tip per answer)

I like that the only form of control flow is an eval command, I've never seen a language like that before.

Use * for output
Because you can output by leaving a string on the stack, it might be useful to accumulate the string by using * rather than outputting with S. Say your challenge was "take a string and append a space", the way to do it with output would be:
S( )S

The way to do it with *, on the other hand is one byte shorter:
( )*

The problem is that if your output has a lot of accumulation, it might cost bytes to deal with the output element on the stack.

What does it mean for the output to have a lot of accumulation?

"Dirty" Decrement
The functionally-pure way to decrement a Church numeral is to use the lambda calculus predecessor function:
\n.n(\p.\z.z($(pT))(pT))(\z.z0[whatever you define the predecessor of 0 to be])

Where 0 = \x.\y.y, T = \x.\y.x, and $ is the successor.
Rewritten in Underload, this is 28 bytes:
(!())~(!())~(!:(:)~*(*)*~)~^!

This is alright, but we can exploit some of Underload's useful properties, namely that :! and ()* do are no-ops. This means that, for a number n, :ⁿ!!()()*ⁿ (where cⁿ is c repeated n times) yields n-1. For example doing this for the Church numeral 3 yields this:
:::!!()()***

Removing no-op pairs, we get:
:*

Which is 2.
So this is the new and shorter predecessor operation:
:(:)~^(!!()())*~(*)~^*

This is 7 bytes shorter.

That breaks on n=0 though. If you need that to work, (()~(:))~:(^!!())*~(*)~^**  is still 3 bytes shorter.

@ØrjanJohansen Generally, you'd have a special case for n=0, because with Underload's numbers decrementing 0 makes no sense anyway.

Use a dictionary of repeatedly reused functions
If you need to use a piece of code a lot, it makes sense to store that code on the stack and duplicate-and-eval it every now and then. So far, that's just normal Underload programming. Unfortunately, keeping a value around on the stack for a long time is difficult and tends to cause your code to become verbose, and that's true even if the value is a function rather than data. This gets a lot worse if you have multiple functions that need to be reused repeatedly.
In the sort of larger program that might benefit from several reused functions, a solution you can use is to instead make one large function that can fulfil any of their purposes depending on the way it's called (either based on what's underneath it on the stack, or via using longer calling sequences than just ^; a carefully written function can distinguish ^^ from ^:^ from ^*^ from ^~^, giving you four distinct, fairly short sequences). You can also store other useful things, such as strings that you use multiple times, in this "dictionary". Note that if you use the dictionary heavily, it may make sense to make it a kind of quine, pushing a copy of itself back onto the stack, so that you don't need to manually copy it with : to be able to use it without losing the ability to use it in the future.

I would go mad long before I got any program big enough in Underload that this became an issue :P

I once wrote some examples on the esolangs page of how to do dictionaries with my preferred ^!!!!^ style lookup (which I've also used in several other examples on the page, especially in the minimization section.) Although that might not give the shortest lookup.

Choose data formats specialized to the operations the problem needs
As a simple example, the most commonly seen implementation of booleans are !() for false (i.e. integer 0), and the null string for true (i.e. integer 1), but if you have a problem that's heavily based around logical XOR, it might make more sense to use the null string for false, and ~ for true (this data format can be converted into any other boolean format using (false)~(true)~^!, and allows the very terse implementation * for XOR.
It's possible to take this general principle even further and use functions that your program will need later as part of your data values; that saves having to store the functions and data separately on the stack. This can make the control flow rather more confusing, but when golfing, maintainability often has to take a back seat, and it's not like Underload is all that usable anyway.

I used to use (!) and (~!) for booleans, but your way seems better.

Put Unneeded Stack Values into the Program Space
Underload actually has two stacks—the stack of strings, and the stack of commands that make up the source code. Underload's ^ instruction lets us move strings from the former stack to the latter. By doing this, we can save a lot of unnecessary stack manipulation.
For example, say we have (a)(b)(c) on the main stack and we'd like to concatenate the bottom two elements, ignoring (c), to get (ab)(c). The naïve way to do this is to rotate the stack to get (c)(a)(b) and then concantenate and swap back:
a~a~*~a*^*~

This is bad. Using a~a~*~a*^ to rotate the stack like this is extremely costly, and should be avoided when possible. By putting (c) into the program space instead, this can be made four bytes shorter:
a(*)~*^

The idea is to take the instructions you'd like to execute and then add an instruction to push (c) back at the end, and then evaluate the result. This means that we don't have to worry about (c) until it's pushed back after we've finished.

You can also write it as (*)~a*^, which I think is a bit more composable. Essentially ~a*^ is the dip command from Joy.