Wyzwanie:

Drukuj każde 2-literowe słowo dopuszczalne w języku Scrabble, używając jak najmniej bajtów. Utworzyłem tutaj listę plików tekstowych . Zobacz także poniżej. Jest 101 słów. Żadne słowo nie zaczyna się od C lub V. Kreatywne, nawet jeśli nieoptymalne rozwiązania są zachęcane.

AA
AB
AD
...
ZA

Zasady:

• Wyprowadzane słowa należy jakoś rozdzielić.
• Sprawa nie ma znaczenia, ale powinna być spójna.
• Końcowe spacje i znaki nowej linii są dozwolone. Żadne inne znaki nie powinny być wyprowadzane.
• Program nie powinien pobierać żadnych danych wejściowych. Nie można używać zasobów zewnętrznych (słowników).
• Brak standardowych luk.

Lista słów:

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 bajtów

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

Zdecydowanie nie jest to najkrótsza metoda, ale pomyślałem, że to dobry początek. Spróbuj spakować każdą parę w ścieżki, nakładając się jak najwięcej (np. "ODEX..."= ["OD", "DE", "EX", ...]). Spacje służą do oddzielania ścieżek, a wszelkie pary ze spacją są usuwane (spacja końcowa ma zapobiegać Edrukowaniu pojedynczej na końcu).

Próbowałem też gry w golfa regularnego, ale było to dłuższe.

CJam, 96 94 bajtów

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+

Powyżej jest zrzut heksowy, który można odwrócić za pomocą xxd -r -c 16 -g 1.

Wypróbuj online w interpretatorze CJam .

W zależności od tego, co dokładnie liczy się jako rozdzielone , liczbę bajtów można obniżyć do 93, a nawet 92 :

• Jeśli zastąpić -55ze 59słowa będą oddzielone przez nie miejscach łamania (0xa0).

• Jeśli zastąpimy -55z Wwyrazy zostaną rozdzielone na znaki (0x40).

Pomysł

Możemy zakodować każdą parę liter xy jako (ord (x) - 65) × 25 + (ord (y) - 65) . ¹

Zamiast przechowywać wynikowe liczby całkowite, będziemy przechowywać różnice wszystkich par, które odpowiadają dwóm sąsiednim słowom (posortowanym alfabetycznie).

Największa różnica wynosi 35 , więc uważamy je za cyfry liczby całkowitej 36 i przekształcamy tę liczbę całkowitą na ciąg bajtów.

Kod

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.

¹ _{Ponieważ druga litera nigdy nie jest literą Z , wystarczy użyć 25 zamiast 26 .}

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 

Zdecydowanie niezbyt dobry wynik, ale podobało mi się wyzwanie.

Tworzę tabelę opcji, utworzyłem system bitowy, aby oznaczyć, które opcje są prawidłowe.

Następnie I-36 zakodowałem te opcje, aby uzyskać ciąg:

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

Zwróć uwagę, że trzeci wpis w tej tablicy łańcuchów nie ma wartości, ponieważ C nie ma opcji.

Aby wydrukować wartości, wystarczy przekonwertować prawidłowe opcje na znaki.

Może być coś, co mogę zrobić, aby zmniejszyć rozpoznawanie, że nie ma słów kończących się na C, J, K, Q, V lub Z, ale nie mogę wymyślić metody zmniejszenia tego atm.

Po transponowaniu tabeli jest więcej pustych elementów, a dane kodują się nieco bardziej zwięźle, co zmniejszyło liczbę bajtów. Tablica jest teraz drukowana w innej kolejności:

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

Dzięki Ismael za wybuch i wskazówki dla pętli.

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)." ":"";

Z aktualizacją do php5.6 pow(,)można zastąpić **zapisując kolejne 4 bajty.

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 bajtów

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

Napisałem osobny skrypt, aby pogrupować litery tak zwarte, jak to możliwe, w ciąg zawierający wszystkie prawidłowe 2-literowe słowa. Następnie iteruje wszystkie dwa słowa z literami i wypisuje prawidłowe, po jednym w wierszu. Uruchom z perl -M5.10.1 script.pl.

C, 155 bajtów

Wersja golfowa

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];}

Wydajność

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

Wersja bez golfa

51-bajtowy ciąg znaków w wersji golfowej zawiera wiele znaków poza ASCII 126, które prawie na pewno zostały zamienione w odpowiedniki Unicode. Wersja bez golfa używa zamiast tego hexa i jako stała zamiast literału. Ponadto wersja bez golfa oddziela słowa znakiem nowej linii, co ułatwia kopiowanie i wklejanie do programu Excel, porządkowanie listy i porównywanie z wymaganym.

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];}

Wyjaśnienie

Jeśli rozszerzymy definicję samogłoski o 8 liter AHMEIOUY, zauważymy, że wszystkie słowa składają się z jednej samogłoski i jednej innej litery (która może, ale nie musi być samogłoską). Dlatego też, dla wszystkich słów kończących się samogłoską, potrzebuję tabeli 26 bajtów, po jednej na każdą pierwszą literę, z poszczególnymi bitami odpowiadającymi samogłosce. Potrzebujemy podobnej tabeli dla słów zaczynających się od samogłoski, z tym wyjątkiem, że tym razem potrzebujemy tylko 25 bajtów, ponieważ nie ma słowa kończącego się na Z. Dwie tabele są ze sobą połączone, aby utworzyć końcową tabelę.

Aby uniknąć jakichkolwiek kodów ASCII w regionie 0..31, dwie najmniej wspólne „samogłoski” M i H są przypisane do 6. i 7. bitu, a kodowanie uwzględnia 1 dla niepoprawnego słowa i 0 dla prawidłowego słowa. Ponieważ nie ma spółgłoski, która łączy się zarówno z M, jak i H, można zapewnić, że co najmniej jeden z tych bitów ma wartość 1.

8-ty bit jest przypisany do A, która jest najczęstszą samogłoską, aby spróbować ograniczyć znaki spoza ASCII (wciąż jest ich dość dużo).

Stosowane tabele znajdują się poniżej. W przypadku słów zawierających 2 samogłoski pierwszą literę uznałem za „samogłoskę”, a drugą literę jako „literę”. Wyjątkiem są słowa zaczynające się na M, ponieważ pozwala to uniknąć starcia między MM a HM.

Kodowanie szesnastkowe słów zaczynających się od samogłoski

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 

Kodowanie szesnastkowe słów kończących się samogłoską

 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 bajtów

Moja pierwsza próba

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

Sformatowany:

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

Wypróbuj online

Rubin, 166 bajtów

Pożyczanie zgrabnej metody sp3000 do kodowania słów w zwarty ciąg. Kickerem jest tutaj krótka metoda dekodowania go z powrotem na dwuliterowe słowa: użycie lookahead w wyrażeniu regularnym przekazanym do metody skanowania String w celu wyodrębnienia nakładających się dopasowań, nie zajmując miejsca:

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

Rubinowy, 179 bajtów

Moje własne podejście: Wygeneruj wszystkie dwuliterowe słowa pomiędzy AAi ZA, i wybierz poprawne, używając zakodowanej w bazie 36 maski bitowej:

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

Matlab, 177 bajtów

Wygeneruj macierz binarną definiującą wszystkie dozwolone pary liter, przekształć ją i zakoduj w base-64. Łańcuch (64) zakodowany w standardzie base-64 'CR+ ... % 'jest używany jako dane w programie. Program odwraca operacje w celu rozpakowania macierzy, a następnie odczytuje dozwolone pary:

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 bajtów

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~

Wypróbuj online!

Bash, 179 bajtów

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

• Zaoszczędzono 7 bajtów dzięki komentarzowi Adama Katza

Wykorzystuje sedsię do wymiany wyrażeń regularnych. Pierwsze wyrażenie regularne oparte jest na pomyśle Sp3000, podczas gdy drugie wyrażenie regularne używa wspólnego wprowadzania bez spacji.

Wyjaśnienie:

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

Uwaga, ta odpowiedź nie jest interesująca programowo.

Ponieważ wszystkie słowa składają się z dwóch znaków, możemy je wszystkie zmiażdżyć, a następnie rozerwać na części za pomocą prostego wyrażenia regularnego.

Każdy język przyjazny wyrażeniom regularnym może to zrobić, niektóre bardziej efektywnie niż inne:

Grep (via Bash), 215 bajtów

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

JavaScript, 224 bajty

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

Perl, 225 bajtów

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

Python, 245 bajtów

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

Uwaga: niektóre odpowiedzi tutaj są dłuższe niż echo, co uważam za punkt odniesienia:

Powłoka POSIX, 307 bajtów

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 bajtów - 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(""));}

Zaktualizuje się, jeśli uda mi się go zmniejszyć, po prostu skompiluj z wyjściami gcc -w, ./a.out. Daj mi znać, jeśli zainteresuje Cię nie golfista.

Nie mogę wymyślić żadnego sposobu, aby skrócić go z czubka głowy (możesz technicznie usunąć cytaty w putach i nadal otrzymasz poprawną odpowiedź, wynik wygląda jak śmieci), więc daj mi znać o tak czy inaczej, aby go skrócić

C #, 348 bajtów

Miałem okazję:

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

Nie golfowany:

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 bajtów

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

Wypróbuj online!

Metoda kompresji: Ponieważ nie ma Zdrugiej pozycji żadnego słowa, użyj zmienionego alfabetu, bcdfghjklmnpqrstvwxyaeiouaby zakodować ważność każdej z tych liter jako drugiej litery dla każdej pierwszej litery (pierwsze litery są w kolejności alfabetycznej).
To 25 bitów na literę lub dokładnie 5 cyfr Base-32. Ponieważ większość spółgłosek bierze samogłoski tylko jako drugą literę, wstawiam samogłoski na końcu, aby uzyskać dla nich głównie liczby 1-cyfrowe. Jestem pewien, że ogólnie można by to ulepszyć poprzez dalszą analizę i zmianę kolejności alfabetu, chociaż wtedy definicja zmienionego alfabetu zajęłaby więcej bajtów.

Wyjaśnienie

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

Musisz wyłączyć ostrzeżenia, w przeciwnym razie wydrukuje się w odniesieniu do domniemanego utworzenia $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++;

Bardzo zabawne. Wczesne próby były w zakresie 250, ale to moja najcieńsza jak dotąd.

CJam (99 bajtów)

Obejmuje to kilka znaków specjalnych, więc najbezpieczniej jest dać zrzut heksowy. (W szczególności postać z wartością 0xa0odpowiadającą niełamliwej spacji sprawiła mi sporo kłopotów z konfiguracją demonstracji online).

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

Demo online .

Podejście polega na kodowaniu różnic w bazie 26.

CJam, 100 98 bajtów

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

(bezpośredni link)

• Zapisano dwa bajty za pomocą wstępnie zainicjowanych zmiennych (dzięki Dennis!)

To mój pierwszy wpis do CJam, więc prawdopodobnie istnieje potencjał do gry w golfa. Wymyśliłem jednak sposób na skompresowanie listy znaków do 63 bajtów, co, mam nadzieję, pomoże komuś innemu.

Metoda kompresji

Jak dotąd większość metod, które widziałem, kodowała obie litery każdego słowa. Kiedy jednak umieszczamy słowa w kolejności alfabetycznej, pierwsza litera nie zmienia się bardzo często, więc jawne kodowanie wydaje się marnotrawstwem.

Koduję tylko ostatni znak każdego słowa i dołączam specjalny element za każdym razem, gdy pierwszy znak powinien zwiększać. Znaki są kodowane jako pierwszy znak, a następnie lista różnic. Ponieważ nie ma zduplikowanych słów, wszystkie różnice muszą być przynajmniej 1. W ten sposób mogę użyć 0jako elementu separatora. (Należy pamiętać, że muszę najpierw zapisać pierwszą literę każdego podsekwencji jako jeden indeks, w przeciwnym razie powstałoby zamieszanie między „pierwszym znakiem najazdu 0” a „zacznij od A 0”).

Ponieważ różnice w tym przypadku nigdy nie są większe niż 15, możemy użyć base-16 i spakować dwa (4-bitowe) elementy do każdego (8-bitowego) bajtu. (W rzeczywistym kodzie przekonwertowałem z base-260 zamiast base-256, aby uniknąć problemów ze znakami niedrukowalnymi).

pieprzenie mózgu , 1371 bajtów

Całkiem golfowy, ale nie włożyłem w to zbyt wiele wysiłku.

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

Wypróbuj online!

Zsh, 175 bajtów

W tym rozwiązaniu zastosowano ciąg znaków o długości 125 znaków, w którym małe litery służą jako ograniczniki i pierwsza litera poniższej sekwencji wielkich liter.

Iterujemy literami $L. Jeśli bieżąca litera $Xjest porównywana małymi literami, ustaw $Wna $X. W przeciwnym razie drukuj $Wpołączony z, $Xaby utworzyć bieżące słowo.

Wypróbuj online!

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

_{Edycja: dołączana, :laby konsekwentnie ustawiać małe litery, zgodnie z wymaganiami
Edycja2: -4 bajty przy użyciu $Xzmiennej i uproszczona, jeśli [[..]]warunek
Edytuj3: -4 bajty poprzez usunięcie cudzysłowów ( ")
Edycja5: -5 bajtów przy użyciu konwersji tablic zamiast iteracji Lna niżej
Edycja4: Alternatywne podejście dla 182 bajty , wykorzystujące odwracalne ciągi w pierwszych 33 literach, $Lto tylko 107 liter}

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

Stax , 91 bajtów

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

Uruchom i debuguj

Jedyną ciekawą sztuczką, jakiej używa ta odpowiedź, jest użycie tokena „,”, aby pokazać zmianę w pierwszej literze, zamiast zapisywania jej dla każdego słowa.

Dzięki rekursywnemu za pomysł użycia operatora m

Python 3, 224 bajty

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

Wykorzystuje maski bitów o zmiennej długości do kodowania, które drugie litery istnieją dla każdej możliwej pierwszej litery. Maski bitów mogą mieć długość 0,1,3,7,15 lub 31 bitów. Bity są odwzorowywane na litery za pomocą for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':, wcześniejsze bity są używane do bardziej powszechnych liter, dzięki czemu maski bitów mogą być krótkie w większości przypadków (zwykle 3 lub 7 bitów, ponieważ po większości spółgłosek występuje tylko jedna z 5 samogłosek lub YM lub H). Niestety kod do jego dekodowania neguje oszczędności w porównaniu z prostszymi metodami (oryginalna lista ma tylko 303 bajty).

Haskell, 192 bajty

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"

Dla każdego oddzielonego spacją słowa w ciągu umieść pierwszą literę przed wszystkimi innymi literami i dodaj spację, np. SHIO-> SH SI SO.

Java, 334 bajty

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

Sformatowany:

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

Oddzielnie zakodowałem listę słów na długość 26 x 26 = 676 BitSet, przekonwertowałem ją na tablicę bajtów, a następnie ostatecznie na Bazę 64. Ten ciąg jest zakodowany na stałe w tym programie, a do odtworzenia BitSet używana jest procedura odwrotna, i ostatecznie wydrukuj listę słów

Java, 356 bajtów

Używa generatora liczb losowych, aby uzyskać słowa:

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

Nie golfowany:

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

Możesz spróbować tutaj: http://ideone.com/Qni32q

Perl, 248 bajtów

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

Pierwszy raz korzystam z Perla (i po raz pierwszy w golfa), więc zdecydowanie jest miejsce na ulepszenia. Dokonano podziału samogłosek i pogrupowano pozostałe litery na podstawie tego, w jaki sposób powstało słowo wynikowe - dodając samogłoskę jako pierwszą, ostatnią lub obie samogłoski jako pierwszą i ostatnią, tworząc słowo na liście.

JavaScript (ES6), 214

Być może nie jest to najkrótszy sposób, ale zdecydowanie interesujący.

_=>(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`
`)

Pętle przechodzą przez każdą literę w pierwszym ciągu, dodając ją do każdej litery w odpowiednim wierszu drugiego. Zwraca słowa w kolejności od ostatniej litery, tak jak poniżej:

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

Sugestie mile widziane!

Java, 255 254 bajtów

Znalazłem sposób na wyciśnięcie z niego jeszcze jednego bajtu.

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

Lub (choć niewiele wyraźniej):

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 bajtów

Dla żartu!

Ewaluacja swydrukuje wszystkie słowa w dziwnej kolejności - wykorzystałem fakt, że większość kombinacji to samogłoska-spółgłoska lub odwrotnie, prawdopodobnie mogłaby jeszcze bardziej zoptymalizować za pomocą „klas” znaków niestandardowych, skracając zakodowaną macierz (tutaj wi k).

Czy ktoś zna krótszy sposób drukowania ciągów bez cudzysłowów i nawiasów niż mój monadyczny? O ile wiem, klasy typów są jeszcze dłuższe.

Ponadto może istnieć krótszy sposób wykonywania ppracy ...

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 bajty ( zakaz konkurowania)

•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ô»

Wypróbuj online!

PHP, 170 bajtów

najkrótsze podejście, jakie udało mi się znaleźć ...

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

awaria

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
    ;

Uwaga Najkrótsza wersja z mapowaniem bitów z drukowanym ascii kosztuje 190 bajtów (113 bajtów danych + 77 bajtów dekodowania) przy użyciu 6 bitów = podstawa 64, 174 bajtów (97 danych, 77 dekodowania) przy użyciu 7 bitów (podstawa 128); być może trochę więcej za ucieczkę.

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

Baza 224 (używając ascii 32..255) zajmuje 87 bajtów danych (+ ucieczka); ale myślę, że dekodowanie będzie kosztowało więcej niż 10 bajtów dodatkowych.
Wykluczenie C i V z mapy pozwoliłoby zaoszczędzić 16/14/13 bajtów na danych, ale kosztowało dużo w dekodowaniu.