Die Herausforderung:

Drucken Sie jedes in Scrabble akzeptierte 2-Buchstaben-Wort mit möglichst wenigen Bytes. Ich habe eine Textdatei Liste erstellt hier . Siehe auch unten. Es gibt 101 Wörter. Kein Wort beginnt mit C oder V. Kreative Lösungen werden empfohlen, auch wenn sie nicht optimal sind.

AA
AB
AD
...
ZA

Regeln:

• Die ausgegebenen Wörter müssen irgendwie getrennt werden.
• Der Fall spielt keine Rolle, sollte aber konsistent sein.
• Leerzeichen und Zeilenumbrüche sind erlaubt. Es sollten keine anderen Zeichen ausgegeben werden.
• Das Programm sollte keine Eingaben machen. Externe Ressourcen (Wörterbücher) können nicht verwendet werden.
• Keine Standardlücken.

Wortliste:

AA AB AD AE AG AH AI AL AM AN AR AS AT AW AX AY 
BA BE BI BO BY 
DE DO 
ED EF EH EL EM EN ER ES ET EX 
FA FE 
GO 
HA HE HI HM HO 
ID IF IN IS IT 
JO 
KA KI 
LA LI LO 
MA ME MI MM MO MU MY 
NA NE NO NU 
OD OE OF OH OI OM ON OP OR OS OW OX OY 
PA PE PI 
QI 
RE 
SH SI SO 
TA TI TO 
UH UM UN UP US UT 
WE WO 
XI XU 
YA YE YO 
ZA

Python 3, 194 188 Bytes

s="BI ODEXIF BAAX ASOHER LOXUMOPAGOR KI US AMY BOITONOSI MMEMINANEHI UPI AYAHOYOWOMUNUHAID PEFARED QIS BEN JOFETAE KAT ABYESHMALI UTI ZADOELAWE "
while s:" "in s[:2]or print(s[:2]);s=s[1:]

Auf keinen Fall die kürzeste Methode, aber ich dachte, das wäre ein guter Anfang. Versuchen Sie, jedes Paar in Pfade zu packen, indem Sie so viel wie möglich überlappen (zB "ODEX..."= ["OD", "DE", "EX", ...]). Leerzeichen werden zum Trennen von Pfaden verwendet, und Paare mit Leerzeichen werden entfernt (das nachfolgende Leerzeichen soll verhindern, Edass am Ende ein einzelnes Zeichen gedruckt wird).

Ich habe auch versucht, Regex Golf zu spielen, aber es war länger.

CJam, 96 94 Bytes

0000000: 31 30 31 2c 22 5a 0a d0 fd 64 f6 07 a3 81 30 f2  101,"Z...d....0.
0000010: c2 a5 60 0c 59 0f 14 3c 01 dd d1 69 7d 66 47 6e  ..`.Y..<...i}fGn
0000020: db 54 e5 8f 85 97 de b9 79 11 35 34 21 cb 26 c3  .T......y.54!.&.
0000030: f0 36 41 2b b4 51 fb 98 48 fc cb 52 75 1f 1d b1  .6A+.Q..H..Ru...
0000040: 6b c3 0c d9 0f 22 32 36 30 62 33 36 62 66 7b 3c  k...."260b36bf{<
0000050: 31 62 32 35 6d 64 2d 35 35 7d 27 41 66 2b        1b25md-55}'Af+

Das obige ist ein Hexdump, der mit umgekehrt werden kann xxd -r -c 16 -g 1.

Probieren Sie es online im CJam-Interpreter aus .

Abhängig davon, was genau als getrennt gilt , könnte die Byteanzahl auf 93 oder sogar 92 gesenkt werden :

• Wenn wir ersetzen -55mit 59, werden die Wörter durch geschützte Leerzeichen (0xA0) getrennt werden.

• Wenn wir ersetzen -55mit W, werden die Worte von at-Zeichen getrennt werden (0x40).

Idee

Wir können jedes Buchstabenpaar xy als (ord (x) - 65) × 25 + (ord (y) - 65) kodieren . ¹

Anstatt die resultierenden Ganzzahlen zu speichern, speichern wir die Differenzen aller Paare, die zwei benachbarten Wörtern entsprechen (alphabetisch sortiert).

Die höchste Differenz ist 35 , also betrachten wir sie als Ziffern einer Ganzzahl zur Basis 36 und wandeln diese Ganzzahl in eine Bytefolge um.

Code

101,   e# Push [0 ... 100].
"…"    e# Push the string that encodes the differences/increments.
260b   e# Convert from base 260 to integer.
36b    e# Convert from integer to base 36 (array).
f{     e# For each I in [0 ... 100]:
       e#   Push the base 36 array.
  <    e#   Keep it's first I elements.
  1b   e#   Compute their sum.
  25md e#   Push quotient and residue of the sum's division by 25.
  -55  e#   Push -55 = '\n' - 'A'.
}      e#
'Af+   e# Add 'A' to all resulting integers. This casts to Character.

¹ _{Da der zweite Buchstabe niemals ein Z ist , ist die Verwendung von 25 anstelle von 26 ausreichend.}

PHP 224, 218, 210 206

foreach(explode(",","I19SR,9ZY8H,,CNK,5JRU0,H,CN4,G0H,H160,CN4,75,CU9,AMIHD,MTQP,HQOXK,7L,74,G,CXS,CU9,HTOG,,CNK,MHA8,CNL,1")as$a){$b++;for($c=0;$c<26;$c++)echo base_convert($a,36,10)&pow(2,$c)?chr(96+$b).chr(97+$c)." ":"";}

aa ab ad ae ag ah ai al am an ar as at aw ax ay ba be bi bo by de do ed ef eh el em en er es et ex fa fe go ha he hi hm ho id if in is it jo ka ki la li lo ma me mi mm mo mu my na ne no nu od oe of oh oi om on op or os ow ox oy pa pe pi qi re sh si so ta ti to uh um un up us ut we wo xi xu ya ye yo za 

Auf jeden Fall keine gute Punktzahl, aber ich mochte die Herausforderung.

Ich erstelle eine Tabelle der Optionen, erstelle ein bitweises System, um zu kennzeichnen, welche Optionen gültig sind.

Dann habe ich base-36 diese Optionen codiert, um die Zeichenfolge zu erhalten:

"I19SR,9ZY8H,,CNK,5JRU0,H,CN4,G0H,H160,CN4,75,CU9,AMIHD,MTQP,HQOXK,7L,74,G,CXS,CU9,HTOG,,CNK,MHA8,CNL,1"

Beachten Sie, dass der dritte Eintrag in diesem String-Array keinen Wert hat, da C keine Optionen hat.

Um die Werte auszudrucken, konvertiere ich einfach die gültigen Optionen in Zeichen.

Es könnte etwas geben, das ich tun könnte, um das Erkennen zu reduzieren, dass es keine Wörter gibt, die auf C, J, K, Q, V oder Z enden, aber ich kann mir keine Methode vorstellen, um es atm zu reduzieren.

Durch das Transponieren der Tabelle entstehen mehr leere Elemente, und die Daten werden etwas kompakter codiert, wodurch einige Bytes eingespart werden. Das Array wird jetzt in einer anderen Reihenfolge gedruckt:

foreach(explode(",","UB1YB,1,,CUP,CLMEJ,CUO,1,SG0H,5J9MR,,,H,MX01,MTXT,CYO5M,MTQ8,,CNL,MTXT,MHAP,50268,,CN5,CNL,FSZ,,")as$a){$b++;for($c=0;$c<26;$c++)echo base_convert($a,36,10)&pow(2,$c)?chr(97+$c).chr(96+$b)." ":"";} 

aa ba fa ha ka la ma na pa ta ya za ab ad ed id od ae be de fe he me ne oe pe re we ye ef if of ag ah eh oh sh uh ai bi hi ki li mi oi pi qi si ti xi al el am em hm mm om um an en in on un bo do go ho jo lo mo no so to wo yo op up ar er or as es is os us at et it ut mu nu xu aw ow ax ex ox ay by my oy

Danke an Ismael für die Explosion und die Loop-Hinweise.

foreach(explode(3,UB1YB3133CUP3CLMEJ3CUO313SG0H35J9MR333H3MX013MTXT3CYO5M3MTQ833CNL3MTXT3MHAP35026833CN53CNL3FSZ)as$d)for($e++,$f=0;$f<26;$f++)echo base_convert($d,36,10)&pow(2,$f)?chr(97+$f).chr(96+$e)." ":"";

Mit einem Update auf php5.6 pow(,)können durch **Speichern weiterer 4 Bytes ersetzt werden.

foreach(explode(3,UB1YB3133CUP3CLMEJ3CUO313SG0H35J9MR333H3MX013MTXT3CYO5M3MTQ833CNL3MTXT3MHAP35026833CN53CNL3FSZ)as$d)for($e++,$f=0;$f<26;$f++)echo base_convert($d,36,10)&2**$f?chr(97+$f).chr(96+$e)." ":"";

Perl, 167 164 157 Bytes

"AMAEDOXUHALAXISHENUNUPABEFAHIDEMYESOHOSITAAGOYAYAWOWETOINODOREX KIFEHMMER BYONELI BOEMUS PELOMI UMOFAD BATAR KANAS JOPI UTI ZAI BI QI"=~/$_/&&say for AA..ZZ

Schrieb ein separates Skript, um die Buchstaben so kompakt wie möglich zu einer Zeichenfolge zusammenzufassen, die alle gültigen 2-Buchstaben-Wörter enthält. Dies iteriert dann über alle zwei Buchstabenwörter und gibt die gültigen aus, eines pro Zeile. Laufen Sie mit perl -M5.10.1 script.pl.

C 155 Bytes

Golf Version

i,v;main(){for(;++i-408;" >b  Ùc :oÒ¹ i ;¹ w so@)ia ¥g¨¸ ´k¦ase    Ù{§k {"[i/8]>>i%8&1||printf("%c%c%c ",i/8%2*v,i/16+65,!(i/8%2)*v))v="YUOIEMHA"[i%8];}

Ausgabe

YA HA AA BY BO BI BE BA AB DO DE OD ID ED AD YE OE HE AE FE FA OF IF EF GO AG UH OH EH AH OI HI AI JO KI KA LO LI LA EL AL MY MU MO MI ME MM MA UM OM EM HM AM NU NO NE NA UN ON IN EN AN YO HO PI PE PA UP OP QI RE OR ER AR SO SI SH US OS IS ES AS TO TI TA UT IT ET AT WO WE OW AW XU XI OX EX AX OY AY ZA

Ungolfed-Version

Die 51-Byte-Magic-Zeichenfolge in der Golfversion enthält viele Zeichen jenseits von ASCII 126, die mit ziemlicher Sicherheit in Unicode-Entsprechungen umgewandelt wurden. Die ungolfed-Version verwendet stattdessen hexadezimal und nicht als Literal, sondern als Konstante. Die ungolfed-Version trennt die Wörter außerdem mit einem Zeilenumbruch, was das Kopieren und Einfügen in Excel, das Ordnen der Liste und das Vergleichen mit der gewünschten erleichtert.

char a[]=
{0xFF,0x3E ,0x62,0x7F ,0xFF,0xFF ,0xEB,0x63 ,0xFF,0x3A ,0x6F,0xE3 ,0xFB,0x7F ,0xFF,0x69 ,0xFF,0x3B
,0xFB,0xFF ,0x77,0xFF ,0x73,0x6F ,0x40,0x29 ,0x69,0x61 ,0xFF,0xBE ,0x67,0xF9 ,0xF7,0xFF ,0xEF,0x6B
,0xB3,0x61 ,0x73,0x65 ,0xFF,0xFF ,0xFF,0xFF ,0xEB,0x7B ,0xF5,0x6B ,0xFF,0x7B ,0x7F};

//iterate through i = 16*letter + 8*order + vowel
i,v;main(){for(;i++-408;a[i/8]>>i%8&1||printf("%c%c%c\n",i/8%2*v,i/16+65,!(i/8%2)*v))v="YUOIEMHA"[i%8];}

Erläuterung

Wenn wir die Definition des Vokals um die 8 Buchstaben AHMEIOUY erweitern, stellen wir fest, dass alle Wörter aus einem Vokal und einem anderen Buchstaben bestehen (der ein Vokal sein kann oder nicht). Daher gilt für alle Wörter, die mit einem Vokal enden, Folgendes: brauchen eine Tabelle von 26 Bytes, eines für jeden ersten Buchstaben, wobei die einzelnen Bits dem Vokal entsprechen. Wir benötigen eine ähnliche Tabelle für die Wörter, die mit einem Vokal beginnen, mit der Ausnahme, dass wir diesmal nur 25 Bytes benötigen, da es kein Wort gibt, das auf Z endet. Die beiden Tabellen werden zusammengefasst, um die endgültige Tabelle zu erstellen.

Um ASCII-Codes in der Region 0..31 zu vermeiden, werden die zwei am wenigsten gemeinsamen "Vokale" M und H dem 6. und 7. Bit zugewiesen, und die Codierung berücksichtigt 1 für ein ungültiges Wort und 0 für ein gültiges Wort. Da es keinen Konsonanten gibt, der sich mit M und H paart, kann sichergestellt werden, dass mindestens eines dieser Bits eine 1 ist.

Das achte Bit wird A zugewiesen, dem am häufigsten verwendeten Vokal, um die Nicht-ASCII-Zeichen einzugrenzen (es gibt immer noch ziemlich viele davon).

Die verwendeten Tabellen sind unten. Bei Wörtern, die 2 Vokale enthalten, wurde der erste Buchstabe als "Vokal" und der zweite Buchstabe als "Buchstabe" eingestuft. Eine Ausnahme bilden Wörter, die mit M beginnen, da hierdurch ein Konflikt zwischen MM und HM vermieden wird.

Hexadezimale Kodierung von Wörtern, die mit einem Vokal beginnen

3E 7F FF 63 3A E3 7F 69 3B FF FF 6F 29 61 BE F9 FF 6B 61 65 FF FF 7B 6B 7B

AA AB    AD AE    AG AH AI       AL AM AN          AR AS AT       AW AX AY 
HA          HE          HI          HM    HO 

         ED    EF    EH          EL EM EN          ER ES ET          EX 
         ID    IF                      IN             IS IT 
         OD OE OF    OH OI          OM ON     OP   OR OS          OW OX OY 
                     UH             UM UN     UP       US UT 
YA          YE                            YO 

Hexadezimale Kodierung von Wörtern, die mit einem Vokal enden

 A  H  M  E  I  O  U  Y
                         FF
BA       BE BI BO    BY  62
                         FF 
         DE    DO        EB
                         FF
FA       FE              6F
               GO        FB
                         FF
                         FF
               JO        FB
KA          KI           77
LA          LI LO        73
MA    MM ME MI MO MU MY  40
NA       NE    NO NU     69
                         FF
PA       PE PI           67
            QI           F7
         RE              EF
    SH      SI  SO       B3
TA          TI  TO       73
                         FF
                         FF
         WE     WO       EB
            XI     XU    F5
                         FF
ZA                       7F

Java, 484 448 407 391 389 Bytes

Mein erster Versuch

public static void main(String[]a){int[]x={57569742,35784706,0,2099200,5534148,35651584,2048,35792896,5247168,2048,33685504,33687552,35794978,35653664,7746958,35782656,131072,2097152,395264,33687552,551296,0,2099200,131104,35653632,33554432};for(Integer i=0;i<26;i++){for(int z=0;z<26;z++){if("".format("%26s",i.toString(x[i],2)).charAt(z)=='1'){System.out.format("%c%c ",'A'+i,'A'+z);}}}}

Formatiert:

public static void main(String[] a) {
    int[] x = { 57569742, 35784706, 0, 2099200, 5534148, 35651584, 2048, 35792896, 5247168, 2048, 33685504, 33687552, 35794978, 35653664,
            7746958, 35782656, 131072, 2097152, 395264, 33687552, 551296, 0, 2099200, 131104, 35653632, 33554432 };
    for (Integer i = 0; i < 26; i++) {
        for (int z = 0; z < 26; z++) {
            if ("".format("%26s", i.toString(x[i], 2)).charAt(z) == '1') {
                System.out.format("%c%c ", 'A' + i, 'A' + z);
            }
        }
    }
}

Probieren Sie es online aus

Ruby, 166 Bytes

Leihen Sie sich die saubere Methode von sp3000 aus , um die Wörter in eine kompakte Zeichenfolge zu kodieren. Der Kicker hier ist die kurze Methode zum Zurückdecodieren in die aus zwei Buchstaben bestehenden Wörter: Verwenden eines Vorgriffs in der Regex, die an die Scanmethode von String übergeben wurde, um überlappende Übereinstimmungen zu extrahieren, ohne Leerzeichen zu enthalten:

puts "BI ODEXIF BAAX ASOHER LOXUMOPAGOR KI US AMY BOITONOSI MMEMINANEHI UPI AYAHOYOWOMUNUHAID PEFARED QIS BEN JOFETAE KAT ABYESHMALI UTI ZADOELAWE".scan /(?=(\w\w))/

Rubin, 179 Bytes

Mein eigener Ansatz: Generiere alle aus zwei Buchstaben bestehenden Wörter zwischen AAund ZAund wähle die gültigen aus, indem du eine Base-36-codierte Bitmaske verwendest:

i=-1
puts ("AA".."ZA").select{|w|"djmsjr5pfw2omzrfgydo01w2cykswsrjaiwj9f2moklc7okcn4u2uxyjenr7o3ub90fk7ipdq16dyttg8qdxajdthd6i0dk8zlmn5cmdkczrg0xxk6lzie1i45mod7".to_i(36)[i+=1]>0}

Matlab, 177 Bytes

Generieren Sie eine binäre Matrix, die alle zulässigen Buchstabenpaare definiert, formen Sie sie um und codieren Sie sie mit Base-64. Die Base-64-codierte Zeichenfolge ( 'CR+ ... % ') wird als Daten im Programm verwendet. Das Programm kehrt die Operationen um, um die Matrix zu entpacken, und liest dann die zulässigen Paare:

x=de2bi('CR+"''        1$$ L*\"%$!! !   $!04P@<W(        0$   1"%$$100@RZP4  $$    0$ ! 1$$$$1 0  P (    $ 0 0$ ! # %  '-32)';[i,j]=find(reshape(x(1:650),26,[])');char([j i]+64)

Malbolge , 2118 Bytes

D'``_#>nI||38h6/vdtO*)_^mI7)"XWfB#z@Q=`<)\xwvuWm32ponmfN+ibJfe^$\[`Y}@VUySXQPUNSLpJINMLEiC+G@EDCB;_?>=}|492765.R210p(-,+*#G'&feB"baw=u]sxq7Xnsrkjoh.fNdchgf_%]\a`Y^W{>=YXWPOsSRQ3OHMLKJIBfF('C<`#"8=<;:3W1w5.R2+q/('&J$)"'~D$#"baw=utsxq7Xnsrkjoh.fNdchgf_%c\D`_X|\>=YXWPOsSRQ3OHMLKJIBfFEDC%$@9]=6|:32V6/.3210)M-m+$)"'&%|Bcb~w|u;yxwvuWm3kpinmfe+ihgfH%cb[ZY}]?UZYRWVOs65KPIHGkKJIH*)?c&BA@?8\6|:32V6/.3210)M-,lk)"F&feBzbxw=uzyrwpon4Ukpi/mfkdc)g`ed]#DZ_^]VzZ<;QPt7MLQPOHlFEJIHAe(>C<;_?>765:981Uv.32+*)Mnm%$)(!Efe{zy?}|{zyxqpo5mrkpoh.fNdihg`ed]#DZ_^]Vz=YRQuUTMqQ32NMLEDhHG@(>C<;_?>76;:3W76v43,+O/.nm+*)"Fgf${z@a}v{zyr8vo5Vrqj0nmfN+Lhg`_%cbDCY}@VUySRWPt76Lp3ONMLEDhHG@(>C<;_"8\6|:32V0v.Rs10/.'&+$H('&feB"!x>|^]srwvun4Ukpi/gfe+Lbaf_%cE[`Y}@?[TxRWPUNMLKo2NGFjD,BAeED&<A:^>=6|:32V6v.R21*/(L,+*#"!E}|{z@xw|{t:[qpotsrk1Rhmlkd*Kgfe^$bDZ_^]VzZ<;QuUTMqKJOHGkEJCBA@dD=<;:^>=6|:32V654t,+O).',+*#G'&feBzbx>|^]yr8vXnsrkjoh.fkdcbg`&^Fba`Y^WVzZ<XWPUTMqQ3INMFjD,BAe?>=B;_9>7<54X8765u-Q10)o'&J$)"!~%${A!x}v<]\xwpun4rTpoh.leMchgf_d]#DZ_^]VzZYR:Pt7SLKPOHlFEJIHAeED&<`@"87<5Y98165.3,P*/(-&+$H(!~}C#c!x}|u;\[wvun4lTjih.fN+Lbgfe^c\"CY}@VUyYXWPOsSRKJIHlLE-IBAeE'&<`@"87<5Y98165.3,Pq/.-,+*#G'&fe#"!x>|{zyr8Yotml2ponPlkdcb(fH%]\[`Y^W{zZ<XWPUTMq4JIHMLEi,BA@d>=B;:9]7};:3W7wv.3,+O)o'&J*)('g%${Ay~}v{zyrq7otmrqpoh.fejiha'eG]\[ZY}@VUy<;WVOsSRQPImM/KJIBAe(>=aA:^>=6|:32V65u-Qr0/.'K+$j"'~De#zy~wv<]yrqpo5srkjohg-kdib(feG]b[Z~^]\UTYRvP8TSRKJIHlLKD,BAe?>=B;_?>7<;:981U54t,+O)o'&Jkj('&}C#"bx>_{tyr8vuWVl2pihgle+ihgfH%cEDZ~XWVUy<XWPUTMqQP2NGLEiCBGF?>b%A@?87[;:zy1U54t210/.'K+$j"'~De#zy~wv<zyxwp6Wmlqpohg-kdib(feG]ba`Y^W{>=YXWPOs65KJIHl/KJIBA@dDCB;:9]=<;:zy1Uvu3,P0)o'&J$#(!~D|#"y?}v{zyr8vXnml2ponPledc)gfH%c\D`_^]VzZ<;QVOTSLpPIHGkKJCBG@dD=<;:^>=6|:32Vw543,+*N.nm+*)"F&feB"y~}|{ts9qvonsl2ponmfN+Lha`e^$\[Z_X|\UTYRQVOsM5KJOHGFjD,BA@d>=B;:9]=};4X81w5.R210)o'&J$j"'~%|{"y?w_u;y[wpun4Ukponmfe+Lha'eGc\[!B^WV[TxXQ9ONrRQ32NMLEDh+AeE'&<`#"8=<;:3W7wv.3,+O/.'m+*)(!EfeBcbx>_{tsxwvun4Ukpi/POkdcha'_d]#DZ_^]VzZ<RQPUNMqQ3ONGkE-IBAeED=BA:9]=<|43870/St,+O/.-ml*)(!Ef|Bcb~w|u;y[Zvun4rTpoh.fN+cKgf_%cE[!BXWV[ZSwWP8TSLpJIHMLEJIBf)d'=aA@">=<5Y98165.3,Pq)('K%*#"!EfeBcyxwvu;yxwvuWm3~

Probieren Sie es online!

Bash, 179 Bytes

echo U`sed -r 's/./& &/g'<<<HAABADEDOEFAEHELAGOFEMAHINAISHMENERESITALOHOMMONOPAMUMYAWETOSOWOYOXUNUPEXI`F `grep -o ..<<<ANARASATAXAYBEBIBOBYJOKAKILIMIOIDOIDORPIQITIUSUTYEZA`

• 7 Bytes dank Adam Katz Kommentar gespeichert

Es wird sedzum Ersetzen von Regex verwendet. Die erste Regex-Eingabe basiert auf der Idee von Sp3000, während die zweite Regex die allgemeine Eingabe ohne Leerzeichen verwendet.

Erläuterung:

echo              print to standard output the following
U                 boundary U character
sed -r [etc]      the result of replacing regex
    .             select a character
    & &           replace it for: matched char, space, matched char
    g             do it globaly for every character
    <<<HAAB[etc]  string input based on Sp3000 idea => HA AA AB ...
F                 boundary F character
sed -r [etc]      the result of replacing regex
    ..            every two characters
    <space>&      for space+matched character
    g             do it globally
    <<<ANAR       normal input => AN AR ...

Achtung, diese Antwort ist programmatisch nicht interessant.

Da alle Wörter zwei Zeichen lang sind, können wir sie alle zusammenschlagen und sie dann mit einem einfachen regulären Ausdruck wieder auseinander reißen.

Jede regex-freundliche Sprache kann dies tun, manche effizienter als andere:

Grep (via Bash), 215 Bytes

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

Javascript, 224 Bytes

alert("AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA".match(/../g))

Perl, 225 Bytes

 $_="AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA";s/../$&\n/g;print

Python, 245 Bytes

import re
print re.sub(r'..','\g<0>\n',"AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA")

Einige der Antworten hier sind länger als echo, was ich als Grundlinie betrachten würde:

POSIX-Shell, 307 Byte

echo AA AB AD AE AG AH AI AL AM AN AR AS AT AW AX AY BA BE BI BO BY DE DO ED EF EH EL EM EN ER ES ET EX FA FE GO HA HE HI HM HO ID IF IN IS IT JO KA KI LA LI LO MA ME MI MM MO MU MY NA NE NO NU OD OE OF OH OI OM ON OP OR OS OW OX OY PA PE PI QI RE SH SI SO TA TI TO UH UM UN UP US UT WE WO XI XU YA YE YO ZA

C - 228 217 Bytes - GCC

 _;main(){char *z,*i="AABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EOU IEO A A ";for(z=i;_++^26;)for(;*++z^32;putchar(_+64),putchar(*z),puts(""));}

Wird aktualisiert, wenn ich es kleiner bekommen kann, kompiliere es einfach mit gcc -w, ./a.out gibt es perfekt aus. Wenn Sie Interesse an einem ungolfed haben, lassen Sie es mich wissen.

Ich kann mir keine Möglichkeit vorstellen, es aus meinem Kopf heraus zu verkürzen (Sie können die Anführungszeichen in Puts technisch entfernen und Sie erhalten trotzdem eine korrekte Antwort, die Ausgabe sieht nur wie Müll aus), also lassen Sie es mich bitte wissen sowieso zu verkürzen

C #, 348 Bytes

Ich hatte einen Versuch:

using System;class A{static void Main(){var a=new System.Collections.BitArray(Convert.FromBase64String("tnOciwgCCAAAAAggAFBxHIkAAAAACICIKABQQBgAAAIgIACAgCAAIqIgigCCADfWuIgAAAACAIAAAAAwCICAIAAAYRkAAAAAAggAgAAIIoAACA=="));int c, d;for(var i=0;i<652;i++){if(a[i]){c=Math.DivRem(i,26,out d);Console.Write("{0}{1} ",(char)('A' + c),(char)('@' + d));}}}}

Ungolfed:

using System;

class A
{
    static void Main()
    {
        var a = new System.Collections.BitArray(Convert.FromBase64String(
            "tnOciwgCCAAAAAggAFBxHIkAAAAACICIKABQQBgAAAIgIACAgCAAIqIgigCCADfWuIgAAAACAI" + 
            "AAAAAwCICAIAAAYRkAAAAAAggAgAAIIoAACA=="));
        int c, d; 
        for(var i = 0; i < 652; i++)
        {
            if(a[i])
            {
                c = Math.DivRem(i, 26, out d);
                Console.Write("{0}{1} ", (char)('A' + c), (char)('@' + d));
            }
        }
    }
}

Pyth , 140 Bytes

K"aeiou"=H+-G+K\zKL.[`Z25.Bib32jdSfTs.e.e?nZ`0+@Gk@HY""byMc"ljjns 1u  a 6jji0 o 2 100u 60hg0 2 k m 101v r 6hr7c s 4 8 g006 m hpg0  a 5 q g"d

Probieren Sie es online!

Komprimierungsmethode: Da Zkein Wort an der zweiten Position steht, verwenden Sie das neu geordnete Alphabet bcdfghjklmnpqrstvwxyaeiou, um die Gültigkeit jedes dieser Buchstaben als zweiten Buchstaben für jeden ersten Buchstaben zu kodieren (die ersten Buchstaben sind alphabetisch sortiert).
Dies sind 25 Bits pro Buchstabe oder genau 5 Basis-32-Stellen. Da die meisten Konsonanten nur Vokale als zweiten Buchstaben verwenden, setze ich Vokale an das Ende, um meistens einstellige Zahlen für sie zu erhalten. Ich bin sicher, dass es insgesamt durch weitere Analyse und Neuordnung des Alphabets verbessert werden könnte, obwohl dann die Definition des neu geordneten Alphabets mehr Bytes in Anspruch nehmen würde.

Erläuterung

K"aeiou"=H+-G+K\zK # Define the reordered alphabet
K"aeiou"           # K := "aeiou"
        =H         # H :=
           -G      #      G.removeAll(
             +K\z  #                   K + "z" 
          +      K #                           ) + K

L.[`Z25.Bib32      # Define a lambda function for decompression
L                  # y = lambda b:
         ib32      # convert b to int using Base 32
       .B          # convert to binary string
 .[`Z25            # pad to the left with "0" to the nearest multiple of 25 in length

                           c"..."d # split the compressed string on " "
                         yM        # Apply y (above lambda) to each element
                                   #   Intermediate result: List of binary strings
                                   #   with 1s for allowed combinations
      .e                           # map over ^ lambda b (current element), k (current index):
        .e              b          # map over b: lambda Z (cur. elem.), Y (cur. ind.):
               +@Gk@HY             # G[k] + H[Y] (G is the regular alphabet)
          ?nZ`0       ""           #     if Z != "0" else ""
     s                             # combine into one large list
   fT                              # remove all falsy values (empty strings)
  S                                # sort (if any order is possible, remove this)
jd                                 # join on spaces (if a normal list with the words is
                                   #   allowed, remove this)

PHP: 211 209 204

Sie müssen Warnungen ausschalten, sonst wird bezüglich der impliziten Erstellung von gedruckt $b

for($a=65;$b<strlen($c="ABDEGHILMNRSTWXY!AEIOY!EO!DFHLMNRSTX!AE!O!AEIMO!DFNST!O!AI!AIO!AEIMOUY!AEOU!DEFHIMNPRSWXY!AEI!I!E!HIO!AIO!HMNPST!EO!IU!AEO!A");$b++)if($c[$b]!='!')echo chr($a).$c[$b].' ';else$a++;

Sehr lustig. Frühe Versuche lagen im 250er-Bereich, aber das ist mein bisher schlankster.

CJam (99 Bytes)

Dies beinhaltet einige Sonderzeichen, daher ist es am sichersten, einen Hexdump zu erstellen. (Insbesondere das Zeichen mit dem Wert 0xa0, das einem nicht unterbrechenden Leerzeichen entspricht, verursachte mir einige Probleme beim Einrichten der Online-Demo.)

00000000  36 37 36 22 c4 b2 2d 51  3f 04 93 5c 64 6c 8d 6e  |676"..-Q?..\dl.n|
00000010  d7 f9 7d 97 29 aa 43 ef  04 41 12 e1 aa ce 12 4d  |..}.).C..A.....M|
00000020  05 f3 1c 2b 73 43 a0 f0  41 c0 a7 33 24 06 37 a3  |...+sC..A..3$.7.|
00000030  83 96 57 69 9b 91 c4 09  c3 93 e1 ed 05 3b 84 55  |..Wi.........;.U|
00000040  d9 26 fd 47 68 22 32 35  36 62 33 38 62 7b 31 24  |.&.Gh"256b38b{1$|
00000050  2b 7d 2f 5d 7b 32 36 62  28 3b 36 35 66 2b 3a 63  |+}/]{26b(;65f+:c|
00000060  4e 7d 2f                                          |N}/|
00000063

Online-Demo .

Der Ansatz ist die Differenzcodierung in Base-26.

CJam, 100 98 Bytes

'A'@" ©Ô&ñ±ð¨9_AÚá¼thÁätÑû¨HÙH&J3p¼ÛèVçckùá%´}xà41"260bGb{_{+N2$2$}{;;)'@}?}%-3<

(Permalink)

• Zwei Bytes über vorinitialisierte Variablen gespeichert (danke Dennis!)

Dies ist mein erster CJam-Eintrag, daher besteht wahrscheinlich das Potenzial für mehr Golf. Ich habe mir jedoch eine Möglichkeit ausgedacht, die Liste der Zeichen auf 63 Bytes zu komprimieren, was hoffentlich jemand anderes hilfreich finden wird.

Kompressionsverfahren

Bisher haben die meisten Methoden, die ich gesehen habe, beide Buchstaben jedes Wortes codiert. Wenn wir jedoch die Wörter in alphabetischer Reihenfolge eingeben, ändert sich der erste Buchstabe nicht sehr oft, sodass es verschwenderisch erscheint, ihn explizit zu codieren.

Ich codiere nur das letzte Zeichen jedes Wortes und füge ein spezielles Element ein, wenn das erste Zeichen erhöht werden soll. Die Zeichen werden als erstes Zeichen codiert, dann wird eine Liste mit Unterschieden angezeigt. Da es keine doppelten Wörter gibt, müssen die Unterschiede mindestens alle sein 1. Somit kann ich 0als Trennelement verwenden. (Beachten Sie, dass ich dann den ersten Buchstaben jeder Untersequenz als einen Index speichern muss, da es sonst zu Verwechslungen zwischen 'Rollover First Character 0' und 'Start with A 0' kommen würde.)

Da die Unterschiede in diesem Fall niemals größer als 15 sind, können wir base-16 verwenden und zwei (4-Bit-) Elemente in jedes (8-Bit-) Byte packen. (Im aktuellen Code habe ich von Base-260 anstatt Base-256 konvertiert, um Probleme mit nicht druckbaren Zeichen zu vermeiden.)

Brainfuck , 1371 Bytes

Ziemlich golfen, aber ich habe nicht zu viel Mühe darauf verwendet.

>+[+[<]>>+<+]>[-<<+<+>>>]-[-[-<]>>+<]>-[-<<<<+>>>>]<<<<<<..>>.<<.>+.>.<<.>++.>.<
<.>+.>.<<.>++.>.<<.>+.>.<<.>+.>.<<.>+++.>.<<.>+.>.<<.>+.>.<<.>++++.>.<<.>+.>.<<.
>+.>.<<.>+++.>.<<.>+.>.<<.>+.>.<------------------------<+.>.>.<<.>++++.>.<<.>++
++.>.<<.>++++++.>.<<.>++++++++++.>.<--------------------<++.>.>.<<.>++++++++++.>
.<-----------<+.>.>.<<.>++.>.<<.>++.>.<<.>++++.>.<<.>+.>.<<.>+.>.<<.>++++.>.<<.>
+.>.<<.>+.>.<<.>++++.>.<-----------------------<+.>.>.<<.>++++.>.<<+.>++++++++++
.>.<--------------<+.>.>.<<.>++++.>.<<.>++++.>.<<.>++++.>.<<.>++.>.<-----------<
+.>.>.<<.>++.>.<<.>++++++++.>.<<.>+++++.>.<<.>+.>.<-----<+.>.>.<--------------<+
.>.>.<<.>++++++++.>.<--------<+.>.>.<<.>++++++++.>.<<.>+.>.<---------<+.>.>.<<.>
++++.>.<<.>++++.>.<<.>++++.>.<<.>++.>.<<.>++++++.>.<<.>++++.>.<-----------------
-------<+.>.>.<<.>++++.>.<<.>++++++++++.>.<<.>++++++.>.<-----------------<+.>.>.
<<.>+.>.<<.>+.>.<<.>++.>.<<.>+.>.<<.>++++.>.<<.>+.>.<<.>++.>.<<.>++.>.<<.>+.>.<<
.>++++.>.<<.>+.>.<<.>+.>.<------------------------<+.>.>.<<.>++++.>.<<.>++++.>.<
<+.>.>.<----<+.>.>.<<+.>+++.>.<<.>+.>.<<.>++++++.>.<--------------<+.>.>.<<.>+++
+++++.>.<<.>++++++.>.<-------<+.>.>.<<.>+++++.>.<<.>+.>.<<.>++.>.<<.>+++.>.<<.>+
.>.<---------------<++.>.>.<<.>++++++++++.>.<------<+.>.>.<<.>++++++++++++.>.<--
------------------<+.>.>.<<.>++++.>.<<.>++++++++++.>.<--------------<+.>.>.

Probieren Sie es online!

Zsh, 175 Bytes

Diese Lösung verwendet eine Zeichenfolge mit 125 Zeichen, wobei die Kleinbuchstaben als Begrenzer und der erste Buchstabe der folgenden Folge von Großbuchstaben dienen.

Wir durchlaufen die Buchstaben von $L. Wenn der aktuelle Buchstabe $Xim ASCII-Vergleich in Kleinbuchstaben geschrieben ist, setzen Sie ihn $Wauf $X. Andernfalls drucken Sie $Wverkettet mit $X, um das aktuelle Wort zu erstellen.

Probieren Sie es online!

L=aABDEGHILMNRSTWXYbAEIOYdEOeDFHLMNRSTXfAEgOhAEIMOiDFNSTjOkAIlAIOmAEIMOUYnAEOUoDEFHIMNPRSWXYpAEIqIrEsHIOtAIOuHMNPSTwEOxIUyAEOzA
for X in ${(s::)L};{((#X>90))&&W=$X||<<<$W$X:l}

_{Edit: hängten :lzu Satz Kleinbuchstaben durchgängig, pro Anforderung
EDIT2: -4 Bytes , die mit $Xvariablen und vereinfacht , wenn [[..]]Bedingung
Edit3: -4 Bytes , die durch das Entfernen Anführungszeichen ( ")
Edit5: -5 - Bytes anstelle Array Umwandlung von iterieren Lpro unten
Edit4: alternativer Ansatz für 182 Bytes , die umkehrbare Zeichenfolgen in den ersten 33 Buchstaben ausnutzen, $Lsind nur 107 Buchstaben}

L=aBHLMNTYdEOeFHMNRhOiSTmOUnOUoSWYaADEGIRSWXbEIOYeLSTXfAgOhIMiDFNjOkAIlIOmIMYoEFIPRXpAEIqIsHtOuHPSTwExIUyEzA
for ((;i++<$#L;))X=$L[i]&&((#X>90))&&W=$X:u||<<<$W$X`((i<34))&&<<<\ $X$W`

Stax , 91 Bytes

âG→æ£ilæα¿:√▒▓uøD¶[│█æä║¢v┼T↨σªΩ■&*φòb¡CÆ?ì▀┬6ù═╦±qBF!╘π╓╙'♣*ù&↕!£ä3±r⌡W-╓D╬☺╝ï╜²á5Æ÷§═ôφF;

Führen Sie es aus und debuggen Sie es

Der einzige nette Trick, den diese Antwort verwendet, ist die Verwendung des Tokens ",", um eine Änderung im ersten Buchstaben anzuzeigen, anstatt sie für jedes Wort zu speichern.

Vielen Dank an recursive für die Idee, den Operator m zu verwenden

Python 3, 224 Bytes

s='';i=int("AQHU9HU1X0313T1J9OMYMZZSRFWLCYT3POSE06UGHXDZN6H5SQSZIFCE6VEB",36)
for c in range(26):
 b=i%6;i//=6;k=(1<<b)-1;j=i%(1<<k);i>>=k
 for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':
  if j&1:s+=chr(c+65)+d+' '
  j>>=1
print s

Verwendet Bitmasken variabler Länge, um zu kodieren, welche zweiten Buchstaben für jeden möglichen ersten Buchstaben existieren. Die Bitmasken können 0,1,3,7,15 oder 31 Bits lang sein. Bits werden Buchstaben mit zugeordnet for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':, frühere Bits werden für häufigere Buchstaben verwendet, so dass die Bitmasken in den meisten Fällen kurz sein können (normalerweise 3 oder 7 Bits, da auf die meisten Konsonanten nur einer von 5 Vokalen oder YM oder H folgt). Leider macht der Code zum Dekodieren die Einsparungen im Vergleich zu einfacheren Methoden zunichte (die ursprüngliche Liste enthält nur 303 Bytes).

Haskell, 192 Bytes

putStr$(\(a:b)->((a:).(:" "))=<<b)=<<words"AABDEGHILMNRSTWXY BAEIOY DEO EDFHLMNRSTX FAE GO HAEIMO IDFNST JO KAI LAIO MAEIMOUY NAEOU ODEFHIMNPRSWXY PAEI QI RE SHIO TAIO UHMNPST WEO XIU YAEO ZA"

Für jedes durch Leerzeichen getrennte Wort in der Zeichenfolge setzen Sie den ersten Buchstaben vor alle anderen Buchstaben und fügen Sie ein Leerzeichen ein, z . B. SHIO-> SH SI SO.

Java, 334 Bytes

public class C{public static void main(String[]a){for(int i=0;i<26;i++){for(int j=0;j<26;j++){if(java.util.BitSet.valueOf(java.util.Base64.getDecoder().decode("2znORQQBBAAAAAQQAKg4jkQAAAAABEBEFAAoIAwAAAEQEABAQBAAEVEQRQBBgBtrXEQAAAABAEAAAAAYBEBAEACAsAwAAAAAAQQAQAAEEUAABA==")).get(i*26+j)){System.out.format("%c%c\n",'a'+i,'a'+j);}}}}}

Formatiert:

public class Code {
    public static void main(String[] a) {
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < 26; j++) {
                if (java.util.BitSet.valueOf(
                        java.util.Base64.getDecoder()
                            .decode("2znORQQBBAAAAAQQAKg4jkQAAAAABEBEFAAoIAwAAAEQEABAQBAAEVEQRQBBgBtrXEQAAAABAEAAAAAYBEBAEACAsAwAAAAAAQQAQAAEEUAABA=="))
                        .get(i * 26 + j)) {
                    System.out.format("%c%c\n", 'a' + i, 'a' + j);
                }
            }
        }
    }
}

Separat habe ich die Wortliste in eine Länge von 26 x 26 = 676 BitSet codiert, sie in ein Byte-Array konvertiert und schließlich in Base 64. Diese Zeichenfolge ist in diesem Programm fest codiert, und die umgekehrte Prozedur wird verwendet, um das BitSet zu reproduzieren. und schließlich die Liste der Wörter ausdrucken

Java, 356 Bytes

Verwendet den Zufallszahlengenerator, um die folgenden Wörter zu erhalten:

import java.util.Random;class X{public static void main(String[]a){int j,n,m=9,x;for(String u:"rgzza 2u2hh r2rxs qs5f fwiag 26i33y 2xqmje 5h94v 16ld2a 17buv 4zvdi 1elb3y 2t108q 5wne9 1mrbfe 1ih89 fh9ts r0gh".split(" ")){x=Integer.parseInt(u,36);Random r=new Random(x/2);j=m-=x%2;while(j-->0){n=r.nextInt(676);System.out.format(" %c%c",65+n/26,65+n%26);}}}}

Ungolfed:

import java.util.Random;
class X{
    public static void main(String[]a){
        int j,n,m=9,x;
        for(String u:"rgzza 2u2hh r2rxs qs5f fwiag 26i33y 2xqmje 5h94v 16ld2a 17buv 4zvdi 1elb3y 2t108q 5wne9 1mrbfe 1ih89 fh9ts r0gh".split(" ")){
            x=Integer.parseInt(u,36);
            Random r=new Random(x/2);
            j=m-=x%2;
            while(j-->0){
                n=r.nextInt(676);
                System.out.format(" %c%c",65+n/26,65+n%26);
            }
        }
    }
}

Sie können es hier ausprobieren: http://ideone.com/Qni32q

Perl, 248 Bytes

@v=split(//,"AEIOU");@s=split(' ',"ADEGIRSWX LSTX DFN EFIPRX HPST BHLMNTY DFHMNR ST DHMNSWY MN ZFKP WYPB KQXLHPMB LGJTB X");for(0..14){foreach $c(split(//,@s[$_])){$_<10?print @v[$_%5].$c." ":a;$_>4?print $c.@v[$_%5]." ":a;}}print "MM MY BY HM SH";

Das erste Mal mit Perl (und das erste Mal mit Golfspielen), also gibt es definitiv Raum für Verbesserungen. Berücksichtigen Sie die Vokale und gruppieren Sie die verbleibenden Buchstaben basierend auf der Erstellung des resultierenden Wortes. Fügen Sie den Vokal zuerst, den letzten oder beide Vokale zuerst und den letzten hinzu, und erstellen Sie ein Wort in der Liste.

Javascript (ES6), 214

Vielleicht nicht der kürzeste Weg, aber auf jeden Fall interessant.

_=>(i=0,[...'ABDEFGHILMNOPRSTUWXY'].map(z=>[...`ABFHKLMNPTYZ
A
AEIO
ABDFHMNOPRWY
EIO
A
AEOSU
ABHKLMOPQSTX
AE
AEHMOU
AEIOU
BDGHJLMNSTWY
OU
AEO
AEIOU
AEIU
MNX
AO
AEO
ABMO`.split`
`[i++]].map(g=>g+z).join` `).join`
`)

Durchläuft jeden Buchstaben in der ersten Zeichenfolge und fügt ihn jedem Buchstaben in der entsprechenden Zeile der zweiten hinzu. Dies gibt die Wörter in der Reihenfolge ihres letzten Buchstabens wie folgt zurück:

AA BA FA HA KA LA MA NA PA TA YA ZA
AB
AD ED ID OD
AE BE DE FE HE ME NE OE PE RE WE YE
EF IF OF
AG
AH EH OH SH UH
AI BI HI KI LI MI OI PI QI SI TI XI
AL EL
AM EM HM MM OM UM
AN EN IN ON UN
BO DO GO HO JO LO MO NO SO TO WO YO
OP UP
AR ER OR
AS ES IS OS US
AT ET IT UT
MU NU XU
AW OW
AX EX OX
AY BY MY OY

Vorschläge willkommen!

Java, 255 254 Bytes

Es wurde ein Weg gefunden, ein weiteres Byte daraus zu quetschen.

class C{public static void main(String[]a){char c='A';for(char l:"ABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EO IU AEO A".toCharArray())if(l<'A')c++;else System.out.print(" "+c+l);}}

Oder (wenn auch nicht viel klarer):

class C {
    public static void main(String[] a) {
        char c = 'A';
        for (char l : "ABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EO IU AEO A"
                .toCharArray())
            if (l < 'A')
                c++;
            else
                System.out.print(" " + c + l);
    }
}

Haskell, 333 308 298 Bytes

Nur zum Spaß!

Das Auswerten sgibt alle Wörter in einer seltsamen Reihenfolge aus - ich habe die Tatsache ausgenutzt, dass die meisten Kombinationen Vokalkonsonanten sind oder umgekehrt. Mit benutzerdefinierten Zeichen "Klassen" könnte wahrscheinlich eine noch stärkere Optimierung erzielt werden, wodurch die codierte Matrix (hier wund hier) verkürzt wirdk ) .

Kennt jemand eine kürzere Methode zum Drucken von Zeichenfolgen ohne Anführungszeichen und Klammern als meine monadische? Typenklassen sind, soweit ich das beurteilen kann, noch länger.

Es könnte auch einen kürzeren Weg geben p, seine Arbeit zu erledigen ...

v="AEIOU"
c="BCDFGHJKLMNPQRSTVWXYZ"
w=[976693,321324,50188,945708,52768]
k=[15,0,10,3,8,15,8,5,13,31,27,7,4,2,12,13,0,10,20,11,1]
z a b x=[[c:[e]|(e,f)<-b#p d,f]|(c,d)<-a#x]
(#)=zip
p 0=[]
p n=((n`mod`2)>0):p(n`div`2)
s=mapM_ putStrLn$concat$z v c w++z c v k++[words"AA AE AI BY HM MM MY OE OI SH"]

05AB1E , 143 Bytes (nicht konkurrierend)

•ZÐFý8ù6„=4ÅœÿWì±7Ë5Œ¾`ó/îAnµ%Ñ¥Ëø±/ÀéNzքѧIJ¶D—ÙVEStvÖò…¸¾6F³#EXŠm¯Cĵ±ÓoÊ°}^€Ftå߀ðŒ=«j;F-Â1;xX3i&QZÒ'Ü”>lwìlOs>íÙVÇI)~î‰Hç²?Öd0È^ÝQ°•36B2ô»

Probieren Sie es online!

PHP, 170 Bytes

kürzester Ansatz, den ich bisher finden konnte ...

for(;$c=ABFHKLMNPTYZ1A2AEIO1ABDFHMNOPRWY1EIO1A1AEOSU1ABHKJMOPQSTX3AE1AEHMOU1AEIOU1BDGHJLMNSTWY1OU11AEO1AEIOU1AEIU1MNX2AO1AEO1ABMO[$i++];)$c<1?print$c.chr($k+65)._:$k+=$c;

Nervenzusammenbruch

for(;$c=CHARACTERS[$i++];)  // loop $c through map
    $c<1                            // if $c is a letter (integer value < 1)
        ?print$c.chr($k+65)._           // print first letter, second letter, delimiter
        :$k+=$c                         // else increase second letter
    ;

Hinweis Die kürzeste Bit-Mapping-Version mit druckbarem ASCII kostet 190 Byte (113 Byte Daten + 77 Byte Dekodierung) bei 6 Bit = Basis 64, 174 Byte (97 Daten, 77 Bit Dekodierung) bei 7 Bit (Basis 128); möglicherweise noch etwas mehr für die Flucht.

for(;$p<676;)                   // loop through combinations
    ord("MAPPING"[$p/6])-32>>$p%6&1     // test bit
        ?                                       // if set, do nothing
        :print chr($p/26+65).chr($p++%26+65)._; // if not, print combination+delimiter

Die Basis 224 (unter Verwendung von ASCII 32..255) benötigt 87 Bytes Daten (+ Escaping); aber ich vermute, die dekodierung kostet mehr als 10 bytes extra.
Das Ausschließen von C und V von der Karte würde 16/14/13 Bytes an Daten einsparen, aber viel bei der Decodierung kosten.