Meydan okuma:

Scrabble'da kabul edilebilir her 2 harfli kelimeyi mümkün olduğunca az byte kullanarak yazdırın . Burada bir metin dosyası listesi oluşturdum . Ayrıca aşağıya bakınız. 101 kelime var. Hiçbir kelime C veya V ile başlamaz. Creative, en uygun olmasa bile çözümler teşvik edilir.

AA
AB
AD
...
ZA

Kurallar:

• Çıktılan kelimeler bir şekilde ayrılmalıdır.
• Davanın önemi yok ama tutarlı olmalı.
• Sondaki boşluklara ve yeni satırlara izin verilir. Başka hiçbir karakter çıkarılmamalıdır.
• Program herhangi bir giriş yapmamalıdır. Dış kaynaklar (sözlükler) kullanılamaz.
• Standart boşluklar yok.

Kelime listesi:

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 bayt

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

Neredeyse kesinlikle en kısa yöntem değil, ama bunun iyi bir başlangıç ​​olacağını düşündüm. Her çifti mümkün olduğunca üst üste bindirerek yollara paketlemeye çalışın (örn. "ODEX..."= ["OD", "DE", "EX", ...]). Boşluklar yolları ayırmak için kullanılır ve içinde boşluk olan herhangi bir çift kaldırılır (izleyen boşluk bir Ekişinin sonunda yazdırılmasını engellemektir ).

Ben de regex golf bu denedim ama daha uzun oldu.

CJam, 96 94 bayt

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+

Yukarıdakiler, tersine çevrilebilen bir hexdump'tır xxd -r -c 16 -g 1.

CJam tercümanında çevrimiçi olarak deneyin .

Bir şekilde tam olarak neyin ayrıldığına bağlı olarak , bayt sayısı 93'e veya hatta 92'ye düşürülebilir :

• Eğer -55ile yer değiştirirsek 59, kelimeler kesilmeyen boşluklarla (0xA0) ayrılır.

• Eğer -55ile yer değiştirirsek W, kelimeler işaretlerle ayrılacaktır (0x40).

Fikir

Xy harflerinin her çiftini (ord (x) - 65) × 25 + (ord (y) - 65) olarak kodlayabiliriz . ¹

Sonuçtaki tamsayıları saklamak yerine, iki bitişik kelimeye karşılık gelen (çift alfabetik olarak sıralanmış) tüm çiftlerin farklılıklarını saklayacağız.

En büyük fark 35'tir , bu yüzden onları bir baz 36 tamsayısının hanesi olarak değerlendiriyoruz ve bu tamsayıyı bir bayt dizgisine dönüştürüyoruz.

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.

¹ _{İkinci harf bir asla olduğundan Z kullanarak, 25 yerine 26 yeterlidir.}

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 

Kesinlikle harika bir skor değil ama mücadeleyi sevdim.

Hangi seçeneklerin geçerli olduğunu işaretlemek için bitsel bir sistem oluşturduğum bir seçenekler tablosu oluşturdum.

Sonra ben base-36 dizgeyi almak için şu seçenekleri kodladım:

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

Bu dize dizisindeki 3. girdi bir değere sahip değildir, çünkü C hiçbir seçeneğe sahip değildir.

Değerleri yazdırmak için geçerli seçenekleri sadece karaktere dönüştürürüm.

C, J, K, Q, V veya Z ile biten hiçbir kelime olmadığının farkına varmak için yapabileceğim bir şey olabilir, ancak bunu azaltmak için bir yöntem düşünemiyorum.

Masayı transpoze ederek, daha fazla boş eleman var ve veriler birkaç bayttan daha küçük, daha kompakt bir şekilde kodlanıyor. Dizi şimdi farklı bir sırada yazdırılıyor:

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

Patlama ve döngü ipuçları için Ismael'e teşekkürler.

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

Php5.6 güncellemesiyle, başka bir 4 bayt kaydedilerek pow(,)değiştirilebilir **.

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 bayt

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

Harfleri olabildiğince kompakt olarak tüm geçerli 2 harfli kelimeleri içeren bir dizgede gruplamak için ayrı bir komut dosyası yazdı. Bu daha sonra iki harfli kelimenin tümünü tekrar eder ve geçerli olanları, her satıra bir tane yazar. İle koş perl -M5.10.1 script.pl.

C, 155 bayt

Golf versiyonu

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

Çıktı

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 versiyonu

Golf sürümündeki 51 baytlık sihirli ip, ASCII 126'nın ötesinde, neredeyse Unicode eşdeğeri olarak belirlenmiş birçok karakter içeriyor. Ungolded versiyonu yerine hex ve değişmez yerine sabit kullanır. Ayrıca, sürümsiz sürüm, kelimeleri yeni bir satırla ayırır; bu da Excel'e kopyalanıp yapıştırılmasını, listeyi sipariş etmesini ve gerekli olanla karşılaştırılmasını kolaylaştırır.

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

açıklama

AHMEIOUY 8 harfini içerecek şekilde sesli harf tanımını genişletirsek, bütün kelimelerin bir ünlü ve diğer bir harften (sesli harf olabilir veya olmayabilir) oluştuğunu gözlemleriz. Bu nedenle, sesli harfle biten tüm kelimeler için Her bir ilk harf için bir tane olmak üzere 26 bitlik bir tabloya ihtiyaç duyunuz. Bir sesli harfle başlayan kelimeler için benzer bir tabloya ihtiyacımız var, ancak bu sefer Z ile biten hiçbir kelime olmadığından sadece 25 bayta ihtiyacımız var.

0..31 bölgesindeki herhangi bir ASCII kodundan kaçınmak için, en az iki "ünlü" M ve H, 6. ve 7. bitlere atanır ve kodlama geçersiz bir kelime için 1 ve geçerli bir kelime için 0 olarak kabul edilir. Hem M hem de H ile çiftleşen ünsüz olmadığından, bu bitlerden en az birinin 1 olmasını sağlamak mümkündür.

8. bit, ASCII olmayan karakterleri sınırlamaya çalışmak için en yaygın sesli harf olan A'ya atanır (yine de çoğu vardır).

Kullanılan tablolar aşağıdadır. 2 ünlü içeren sözcükler için, ilk harfine "ünlü" ve ikinci harfe "harf" olarak baktım. Bunun bir istisnası, M ile başlayan kelimelerdir, çünkü bu, MM ile HM arasındaki bir çatışmayı önler.

Bir sesli harfle başlayan kelimelerin hex kodlaması

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 

Bir sesli harfle biten kelimelerin hex kodlaması

 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 bayt

İlk denemem

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

biçimlendirilmiş:

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

Çevrimiçi deneyin

Ruby, 166 bayt

Kelimeleri kompakt bir dizgede kodlamak için sp3000'in düzenli yöntemi ödünç almak . Buradaki vurucu, iki harfli kelimelerin içine tekrar kodunu çözmek için kısa bir yöntemdir: Üst üste binen eşleşmeleri çıkarmak için String'in tarama yöntemine geçen regex'te bir bakış açısı kullanmak;

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

Ruby, 179 bayt

Kendi yaklaşımım: AAve arasındaki iki harfli kelimelerin tümünü oluşturun ve ZAbir baz 36 kodlu bit maskesi kullanarak geçerli olanları seçin:

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

Matlab, 177 bayt

İzin verilen tüm harf çiftlerini tanımlayan ikili bir matris oluşturun, yeniden şekillendirin ve base-64 kodlayın. Base-64 kodlanmış dizgisi ( 'CR+ ... % ') programda veri olarak kullanılır. Program matrisi açmak için işlemleri tersine çevirir ve ardından izin verilen çiftleri okur:

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 bayt

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~

Çevrimiçi deneyin!

Bash, 179 bayt

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

• Adam Katz yorumu ile 7 bayt kaydedildi

sedRegex değiştirme yapmak için kullanır . İlk regex girişi Sp3000 fikrine dayanırken, ikinci regex boşluksuz ortak girdi kullanıyor.

Açıklama:

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

Uyarı, bu cevap programlı olarak ilginç değil.

Tüm kelimeler iki karakter uzunluğunda olduklarından hepsini bir araya toplayabilir ve basit bir düzenli ifade kullanarak tekrar parçalayabiliriz.

Herhangi bir regex dostu dil bunu yapabilir, bazıları diğerlerinden daha verimli:

Grep (Bash üzerinden), 215 bayt

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

Javascript, 224 bayt

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

Perl, 225 bayt

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

Python, 245 bayt

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

Bir not olarak, buradaki bazı cevaplar, daha uzun echosürelidir;

POSIX kabuğu, 307 bayt

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

Eğer küçültebilirsem güncellenecek, sadece gcc -w, ./a.out çıktıları ile derleyeceğim. Ungolfed herhangi bir ilgi varsa, bana bildirin.

Kafamın üstünden kısaltmak için herhangi bir yol düşünemiyorum, (teknik olarak kozlardaki alıntıları kaldırabilir ve hala doğru bir cevap alırsınız, çıktı sadece çöp gibi görünür), lütfen bana bildirin kısaltmak için yine de

C #, 348 bayt

Gitmiştim:

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 bayt

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

Çevrimiçi deneyin!

Sıkıştırma yöntemi: ZHerhangi bir kelimenin ikinci konumunda olmadığından bcdfghjklmnpqrstvwxyaeiou, bu harflerin her birinin geçerliliğini her ilk harf için ikinci bir harf olarak kodlamak için yeniden sıralanan alfabeyi kullanın (ilk harfler alfabetik olarak sıralanmıştır).
Bu, harf başına 25 bit veya tam olarak 5 Base-32 hanedir. Çoğu ünsüz harfleri yalnızca ikinci harf olarak sesli harf aldığından dolayı, onlar için çoğunlukla 1 basamaklı sayıları almak için sesli harfler ekledim. Alfabenin daha fazla analiz edilmesi ve yeniden sıralanması ile genel olarak geliştirilebileceğinden eminim, ancak daha sonra yeniden sıralanan alfabenin tanımı daha fazla bayt alacaktır.

açıklama

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

Uyarıları kapatmanız gerekir, aksi takdirde bir kişi gizli kullanımına ilişkin olarak basılacaktır. $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++;

Çok eğlenceli. İlk denemeler 250 aralığındaydı, ama bu benim en zayıflarım.

CJam (99 bayt)

Bu birkaç özel karakter içeriyor, bu yüzden hexdump vermek en güvenli yol. (Özellikle, 0xa0bölünmeyen bir boşluğa karşılık gelen değere sahip karakter , çevrimiçi demoyu ayarlamakta oldukça sıkıntıya neden oldu).

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

Çevrimiçi demo .

Yaklaşım temel 26'da fark kodlamasıdır.

CJam, 100 98 bayt

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

(Kalıcı)

• Önceden başlatılmış değişkenlerle iki bayt kurtarıldı (teşekkürler Dennis!)

Bu benim ilk CJam girişim, bu yüzden muhtemelen biraz daha golf oynama potansiyeli var. Ancak, karakter listesini 63 bayt'a kadar sıkıştıracak bir yöntem buldum, umarım bir başkası yardımcı olur.

Sıkıştırma yöntemi

Şimdiye kadar gördüğüm yöntemlerin çoğu, her bir kelimenin iki harfini de kodladı. Ancak, kelimeleri alfabetik sıraya koyduğumuzda, ilk harf çok sık değişmez, bu yüzden açıkça kodlamak israf gibi görünmektedir.

Her kelimenin yalnızca son karakterini kodlarım ve ilk karakterin artması gerektiğinde özel bir öğe eklerim. Karakterler ilk karakter olarak kodlanır, sonra farklılıkların bir listesi. Yinelenen kelimeler olmadığından, farklılıkların tümü en azından olmalıdır 1. Böylece 0ayırıcı madde olarak kullanabilirim . (Daha sonra her bir alt dizinin ilk harfini tek indeksli olarak kaydetmem gerektiğine dikkat edin, aksi takdirde 'rollover first character 0' ile 'A ile başla' arasında bir karışıklık olur 0.)

Bu durumdaki farklar asla 15'ten büyük olmadığından, base-16'yı kullanabilir ve iki (4 bit) öğeyi her bir (8 bit) bayta paketleyebiliriz. (Gerçek kodda, yazdırılamayan karakterlerle ilgili sorunları önlemek için base-256 yerine base-260'dan dönüştürdüm.)

brainfuck , 1371 bayt

Oldukça golf oynayabilirim ama çok fazla çaba sarf etmedim.

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

Çevrimiçi deneyin!

Zsh, 175 bayt

Bu çözüm küçük harfler sınırlayıcı olarak hizmet 125 karakter dizesini kullanır ve büyük harflerle aşağıdaki dizinin ilk harfi.

Harflerini yineliyoruz $L. Geçerli mektup Eğer $XASCII kıyasla küçük harf olup, set $Wiçin $X. Aksi halde, geçerli sözcüğü yapmak için $Wbirleştirilmiş baskı $X.

Çevrimiçi Deneyin!

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

_{Düzenleme: ekteki :ldizi şartı başına, sürekli olarak küçük harfli
-4 kullanılarak bayt: EDIT2 $Xdeğişken ve eğer basitleştirilmiş [[..]]durumu
Edit3: -4 bayt tırnak (kaldırarak ")
Edit5: -5 yineleme yerine dizi dönüşüm kullanarak bayt Laşağıda başına
Edit4: Alternatif bir yaklaşım için İlk 33 harften geri dönüşümlü dizelerden yararlanan 182 bayt$L sadece 107 harftir.}

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

Stax , 91 bayt

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

Koş ve hata ayıkla

Bu cevabın kullandığı tek düzgün numara, her kelimede saklamak yerine, ilk harfinde bir değişiklik göstermek için "," işaretini kullanmaktır.

M operatörünü kullanma fikri için özyinelemeli

Python 3, 224 bayt

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

Her olası ilk harf için hangi ikinci harflerin bulunduğunu kodlamak için değişken uzunluktaki bit maskeleri kullanır. Bit maskeleri 0,1,3,7,15 veya 31 bit uzunluğunda olabilir. Bitler, harflerle eşleştirilir for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':, daha önceki bitler daha yaygın harfler için kullanılır; bu nedenle, çoğu durumda bit maskeleri kısa olabilir (çoğu ünsüzleri yalnızca 5 ünlü veya YM veya H ile takip ettiği için genellikle 3 veya 7 bit). Maalesef kod çözme kodu, daha basit yöntemlerle karşılaştırıldığında tasarrufları engelliyor (orijinal liste yalnızca 303 bayttır).

Haskell, 192 bayt

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"

Dizideki ayrılmış her kelime için, ilk harfi diğer tüm harflerin önüne koyun ve bir boşluk ekleyin, örneğin SHIO-> SH SI SO.

Java, 334 bayt

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

biçimlendirilmiş:

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

Ayrı olarak, kelime listesini 26x26 = 676 BitSet uzunluğuna kodladım, bir bayt dizisine dönüştürdüm ve sonra da Base 64'e dönüştürdüm. ve sonuçta sözcüklerin listesini yazdırın

Java, 356 bayt

Kelimeleri almak için rasgele sayı üretecini kullanır:

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

Burada deneyebilirsiniz: http://ideone.com/Qni32q

Perl, 248 bayt

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

Perl (ve ilk kez golf) kullanarak ilk kez, bu yüzden kesinlikle iyileştirilmesi için yer var. Ünlü harfleri ayırdı ve geri kalan harfleri sonuçta ortaya çıkan sözcüğün nasıl oluşturulduğuna göre gruplandırdı;

Javascript (ES6), 214

Belki de bunu yapmanın en kısa yolu değil, ama kesinlikle ilginç.

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

İlk dizgideki her harften dolaşır, ikincinin karşılık gelen satırındaki her harfe eklenir. Bu, sözcükleri son harf sırasına göre döndürür, şöyle:

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

Önerilerinizi bekliyoruz!

Java, 255 254 bayt

Bir baytı daha sıkmak için bir yol buldum.

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

Veya (çok net olmasa da):

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 bayt

Sadece eğlence için!

Değerlendirme s, bütün kelimeleri garip bir sıraya göre basacaktır - çoğu kombinasyonun ünlü ünsüz veya tam tersi olduğu gerçeğini kullandım, muhtemelen kodlanmış matrisi kısaltan (burada wve k) özel karakter "sınıfları" ile daha da optimize edebilirdi .

Telleri basmak için monadik olandan daha kısa bir yol bilen var mı? Tip sınıfları söyleyebileceğim kadar uzun.

Ayrıca, pişini yapmanın daha kısa bir yolu olabilir .

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 bayt ( Rekabet etmedi )

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

Çevrimiçi deneyin!

PHP, 170 bayt

şu ana kadar bulabildiğim en kısa yaklaşım ...

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

Yıkmak

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
    ;

Not Yazdırılabilir ascii içeren en kısa bit eşleme sürümü 6 bit = 190 taban (190 veri (113 bayt veri + 77 bayt kod çözme) kullanarak) 7 bit (taban 128); kaçmak için belki biraz daha.

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

Baz 224 (ascii 32.255'i kullanarak) 87 bayt veri alır (+ kaçış); ancak kod çözme işleminin fazladan 10 bayttan daha fazla olacağını düşünüyorum.
Haritadan C ve V hariç tutulduğunda, verilerde 16/14/13 bayt tasarruf sağlanır, ancak kod çözme işleminin maliyeti yüksek olur.