Các thách thức:

In mỗi 2 chữ cái có thể chấp nhận được trong Scrabble bằng cách sử dụng càng ít byte càng tốt. Tôi đã tạo một danh sách tập tin văn bản ở đây . Xem thêm bên dưới. Có 101 từ. Không có từ nào bắt đầu bằng C hoặc V. Creative, ngay cả khi không tối ưu, các giải pháp được khuyến khích.

AA
AB
AD
...
ZA

Quy tắc:

• Các từ xuất ra phải được tách ra bằng cách nào đó.
• Trường hợp không quan trọng, nhưng nên nhất quán.
• Không gian lưu trữ và dòng mới được cho phép. Không có nhân vật khác nên được xuất ra.
• Chương trình không nên có bất kỳ đầu vào. Tài nguyên bên ngoài (từ điển) không thể được sử dụng.
• Không có sơ hở tiêu chuẩn.

Danh sách các từ:

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 byte

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

Hầu như chắc chắn không phải là phương pháp ngắn nhất, nhưng tôi nghĩ đây sẽ là một khởi đầu tốt. Cố gắng đóng gói mỗi cặp thành các đường dẫn bằng cách chồng chéo càng nhiều càng tốt (ví dụ "ODEX..."= ["OD", "DE", "EX", ...]). Dấu cách được sử dụng để phân tách các đường dẫn và bất kỳ cặp nào có khoảng trắng trong đó sẽ bị xóa (khoảng trắng ở cuối là để ngăn một dấu Ein được in ở cuối).

Tôi cũng đã thử chơi golf regex nhưng nó lâu hơn.

CJam, 96 94 byte

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+

Trên đây là một hexdump, có thể được đảo ngược với xxd -r -c 16 -g 1.

Hãy thử trực tuyến trong trình thông dịch CJam .

Tùy thuộc vào số chính xác được phân tách bằng cách nào đó , số byte có thể được hạ xuống còn 93 hoặc thậm chí 92 :

• Nếu chúng ta thay thế -55bằng 59, các từ sẽ được phân tách bằng khoảng trắng không ngắt (0xA0).

• Nếu chúng ta thay thế -55bằng W, các từ sẽ được phân tách bằng dấu hiệu (0x40).

Ý kiến

Chúng ta có thể mã hóa từng cặp chữ xy là (ord (x) - 65) × 25 + (ord (y) - 65) . ¹

Thay vì lưu trữ các số nguyên kết quả, chúng tôi sẽ lưu trữ sự khác biệt của tất cả các cặp tương ứng với hai từ liền kề (được sắp xếp theo thứ tự abc).

Sự khác biệt cao nhất là 35 , vì vậy chúng tôi coi chúng là các chữ số của một số nguyên 36 cơ bản và chuyển đổi số nguyên đó thành chuỗi aa byte.

Mã

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.

¹ _{Vì chữ cái thứ hai không bao giờ là chữ Z , sử dụng 25 thay vì 26 là đủ.}

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 

Chắc chắn không phải là một điểm số tuyệt vời, nhưng tôi thích thử thách.

Tôi tạo một bảng các tùy chọn, tạo một hệ thống bitwise để đánh dấu các tùy chọn nào là hợp lệ.

Sau đó, tôi cơ sở-36 đã mã hóa các tùy chọn đó để có được chuỗi:

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

Lưu ý mục nhập thứ 3 trong mảng chuỗi đó không có giá trị, vì C không có tùy chọn.

Để in các giá trị, tôi chỉ cần chuyển đổi các tùy chọn hợp lệ thành ký tự.

Có thể có một vài điều tôi có thể làm để giảm nhận ra rằng không có từ nào kết thúc bằng C, J, K, Q, V hoặc Z, nhưng tôi không thể nghĩ ra một phương pháp để giảm atm.

Bằng cách hoán chuyển bảng, có nhiều phần tử trống hơn và dữ liệu mã hóa gọn hơn một chút, loại bỏ một vài byte. Mảng hiện được in theo thứ tự khác:

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

Cảm ơn Ismael cho sự bùng nổ và gợi ý vòng lặp.

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

Với bản cập nhật cho php5.6, pow(,)có thể được thay thế bằng cách **lưu thêm 4 byte.

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 byte

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

Đã viết một tập lệnh riêng để nhóm các chữ cái lại với nhau càng nhỏ càng tốt thành một chuỗi chứa tất cả các từ 2 chữ cái hợp lệ. Điều này sau đó lặp đi lặp lại trên tất cả hai từ chữ cái và in những từ hợp lệ, mỗi từ một dòng. Chạy với perl -M5.10.1 script.pl.

C, 155 byte

Phiên bản chơi gôn

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

Đầu ra

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

Phiên bản ung dung

Chuỗi ma thuật 51 byte trong phiên bản chơi gôn chứa nhiều ký tự ngoài ASCII 126, gần như chắc chắn đã được đưa vào tương đương Unicode. Phiên bản không sử dụng thay vì sử dụng hex, và như một hằng số thay vì theo nghĩa đen. Ngoài ra, phiên bản không được phân tách các từ bằng một dòng mới, giúp sao chép và dán vào Excel dễ dàng hơn, sắp xếp danh sách và so sánh với từ được yêu cầu.

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

Giải trình

Nếu chúng tôi mở rộng định nghĩa nguyên âm để bao gồm 8 chữ cái AHMEIOUY, chúng tôi quan sát thấy rằng tất cả các từ bao gồm một nguyên âm và một chữ cái khác (có thể hoặc không phải là nguyên âm.) Do đó, đối với tất cả các từ kết thúc bằng nguyên âm, chúng tôi cần một bảng gồm 26 byte, mỗi byte cho một chữ cái đầu tiên, với các bit riêng lẻ tương ứng với nguyên âm. Chúng ta cần một bảng tương tự cho các từ bắt đầu bằng nguyên âm, ngoại trừ lần này chúng ta chỉ cần 25 byte, vì không có từ nào kết thúc bằng Z. Hai bảng được riff với nhau để tạo bảng cuối cùng.

Để tránh mọi mã ASCII trong vùng 0..31, hai "nguyên âm" M và H ít phổ biến nhất được gán cho bit thứ 6 và thứ 7 và mã hóa xem xét 1 cho một từ không hợp lệ và 0 cho một từ hợp lệ. Vì không có phụ âm nào ghép với cả M và H nên có thể đảm bảo ít nhất một trong các bit này là 1.

Bit thứ 8 được gán cho A, đây là nguyên âm phổ biến nhất, để cố gắng giới hạn các ký tự không phải ASCII (vẫn còn khá nhiều trong số chúng.)

Các bảng được sử dụng dưới đây. Đối với các từ có chứa 2 nguyên âm, tôi ưu tiên cho chữ cái đầu tiên được coi là "nguyên âm" và chữ cái thứ hai là "chữ cái". Một ngoại lệ cho điều này là các từ bắt đầu bằng M, vì điều này tránh được sự xung đột giữa MM và HM.

Mã hóa hex các từ bắt đầu bằng một nguyên âm

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 

Mã hóa hex của các từ kết thúc bằng một nguyên âm

 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 byte

Lần thử đầu tiên của tôi

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

Định dạng:

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

Dùng thử trực tuyến

Ruby, 166 byte

Mượn phương pháp gọn gàng của sp3000 để mã hóa các từ thành một chuỗi nhỏ gọn. Công cụ khởi động ở đây là phương pháp ngắn để giải mã nó thành các từ có hai chữ cái: Sử dụng một cái nhìn trong biểu thức chính thức được truyền cho phương thức quét của String để trích xuất các kết quả trùng lặp, không tạo khoảng trống:

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 byte

Cách tiếp cận của riêng tôi: Tạo tất cả các từ hai chữ cái giữa AAvà ZA, và chọn những cái có giá trị sử dụng một cơ sở 36 bitmask mã hóa:

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

Matlab, 177 byte

Tạo một ma trận nhị phân xác định tất cả các cặp chữ cái được phép, định hình lại nó và mã hóa cơ sở 64. Chuỗi mã hóa cơ sở-64 ( 'CR+ ... % ') được sử dụng làm dữ liệu trong chương trình. Chương trình đảo ngược các hoạt động để giải nén ma trận và sau đó đọc các cặp được phép:

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 byte

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~

Hãy thử trực tuyến!

Bash, 179 byte

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

• Đã lưu 7 byte nhờ bình luận của Adam Katz

Nó sử dụng sedđể làm thay thế regex. Đầu vào regex đầu tiên dựa trên ý tưởng Sp3000 trong khi regex thứ hai sử dụng đầu vào chung không có khoảng trắng.

Giải trình:

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

Cảnh báo, câu trả lời này không thú vị về mặt lập trình.

Vì tất cả các từ đều dài hai ký tự, chúng ta có thể đập chúng lại với nhau và sau đó tách chúng ra một lần nữa bằng cách sử dụng một biểu thức chính quy đơn giản.

Bất kỳ ngôn ngữ thân thiện với regex nào cũng có thể làm điều này, một số hiệu quả hơn những ngôn ngữ khác:

Grep (thông qua Bash), 215 byte

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

Javascript, 224 byte

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

Perl, 225 byte

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

Python, 245 byte

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

Lưu ý, một số câu trả lời ở đây dài hơn echo, mà tôi xem là đường cơ sở:

Vỏ POSIX, 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 byte - 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(""));}

Sẽ cập nhật nếu tôi có thể làm cho nó nhỏ hơn, chỉ cần biên dịch với các đầu ra gcc -w, ./a.out một cách hoàn hảo. Nếu có bất kỳ quan tâm đến một kẻ vô lương tâm, hãy cho tôi biết.

Tôi không thể nghĩ ra bất kỳ cách nào để rút ngắn nó khỏi đỉnh đầu của tôi, (về mặt kỹ thuật bạn có thể loại bỏ các trích dẫn trong các vị trí và bạn vẫn sẽ nhận được câu trả lời chính xác, đầu ra trông giống như rác), vì vậy hãy cho tôi biết dù sao để rút ngắn nó

C #, 348 byte

Tôi đã đi:

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

Ung dung:

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

Bình thường , 140 byte

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

Hãy thử trực tuyến!

Phương pháp nén: Vì không có Zvị trí thứ hai của bất kỳ từ nào, hãy sử dụng bảng chữ cái được sắp xếp lại bcdfghjklmnpqrstvwxyaeiouđể mã hóa tính hợp lệ của mỗi chữ cái đó như một chữ cái thứ hai cho mỗi chữ cái đầu tiên (các chữ cái đầu tiên theo thứ tự bảng chữ cái).
Đây là 25 bit cho mỗi chữ cái, hoặc chính xác là 5 chữ số Base-32. Vì hầu hết các phụ âm chỉ lấy nguyên âm làm chữ cái thứ hai, tôi đặt nguyên âm ở cuối để có được các số chủ yếu là 1 chữ số cho chúng. Tôi chắc chắn rằng nó có thể được cải thiện tổng thể bằng cách phân tích và sắp xếp lại bảng chữ cái, mặc dù sau đó định nghĩa của bảng chữ cái được sắp xếp lại sẽ chiếm nhiều byte hơn.

Giải trình

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

Bạn phải tắt cảnh báo, nếu không, người ta sẽ in liên quan đến việc tạo ngầm $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++;

Rất vui. Những nỗ lực ban đầu nằm trong phạm vi 250, nhưng đây là lần tôi gầy nhất.

CJam (99 byte)

Điều này bao gồm một vài ký tự đặc biệt, vì vậy an toàn nhất để cung cấp một hexdump. (Đặc biệt, nhân vật có giá trị 0xa0, tương ứng với một không gian không phá vỡ, gây cho tôi khá nhiều rắc rối trong việc thiết lập bản demo trực tuyến).

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

Bản demo trực tuyến .

Cách tiếp cận là mã hóa khác biệt trong cơ sở 26.

CJam, 100 98 byte

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

(permalink)

• Đã lưu hai byte thông qua các biến được khởi tạo trước (cảm ơn Dennis!)

Đây là mục nhập đầu tiên của tôi, vì vậy có thể có nhiều khả năng chơi gôn hơn. Tuy nhiên, tôi đã nghĩ ra cách nén danh sách các ký tự xuống còn 63 byte, hy vọng ai đó sẽ thấy hữu ích.

Phương pháp nén

Cho đến nay hầu hết các phương pháp mà tôi thấy được mã hóa cả hai chữ cái của mỗi từ. Tuy nhiên, khi chúng ta đặt các từ theo thứ tự bảng chữ cái, chữ cái đầu tiên không thay đổi rất thường xuyên, vì vậy có vẻ lãng phí khi mã hóa nó một cách rõ ràng.

Tôi chỉ mã hóa ký tự cuối cùng của mỗi từ và bao gồm một mục đặc biệt mỗi khi ký tự đầu tiên tăng. Các ký tự được mã hóa thành ký tự đầu tiên, sau đó là danh sách các khác biệt. Vì không có từ trùng lặp, ít nhất tất cả các khác biệt 1. Do đó tôi có thể sử dụng 0như một mục phân cách. (Lưu ý rằng sau đó tôi phải lưu trữ chữ cái đầu tiên của mỗi chuỗi sau dưới dạng một chỉ mục, nếu không sẽ có sự nhầm lẫn giữa 'cuộn qua ký tự đầu tiên 0' và 'bắt đầu bằng A 0'.)

Vì sự khác biệt trong trường hợp này không bao giờ lớn hơn 15, nên chúng ta có thể sử dụng cơ sở 16 và gói hai mục (4 bit) vào mỗi byte (8 bit). (Trong mã thực tế tôi đã chuyển đổi từ cơ sở-260 thay vì cơ sở-256 để tránh các vấn đề với các ký tự không thể in được.)

Brainfuck , 1371 byte

Khá golf, nhưng tôi đã không nỗ lực quá nhiều vào nó.

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

Hãy thử trực tuyến!

Zsh, 175 byte

Giải pháp này sử dụng chuỗi 125 ký tự, trong đó các chữ cái viết thường đóng vai trò là dấu phân cách và chữ cái đầu tiên của chuỗi chữ in hoa sau đây.

Chúng tôi lặp đi lặp lại qua các chữ cái của $L. Nếu chữ hiện tại $Xlà chữ thường bằng cách so sánh ascii, đặt $Wthành $X. Nếu không, in $Wnối với $Xđể tạo từ hiện tại.

Hãy thử trực tuyến!

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

_{Chỉnh sửa: được thêm vào :lđể đặt chữ thường, theo yêu cầu
Edit2: -4 byte sử dụng $Xbiến và được đơn giản hóa nếu [[..]]điều kiện
Edit3: -4 byte bằng cách xóa dấu ngoặc kép ( ")
Edit5: -5 byte bằng cách sử dụng chuyển đổi mảng thay vì lặp lại Ltheo bên dưới
Edit4: Cách tiếp cận thay thế cho 182 byte , khai thác các chuỗi có thể đảo ngược trong 33 chữ cái đầu tiên, $Lchỉ có 107 chữ cái}

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

Stax , 91 byte

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

Chạy và gỡ lỗi nó

Thủ thuật gọn gàng duy nhất mà câu trả lời này sử dụng là sử dụng mã thông báo "," để hiển thị thay đổi trong chữ cái đầu tiên, thay vì lưu trữ nó cho mỗi từ.

Cảm ơn đệ quy cho ý tưởng sử dụng toán tử m

Python 3, 224 byte

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

Sử dụng mặt nạ bit có độ dài thay đổi để mã hóa chữ cái thứ hai tồn tại cho mỗi chữ cái đầu tiên có thể. Các mặt nạ bit có thể dài 0,1,3,7,15 hoặc 31 bit. Các bit được ánh xạ tới các chữ cái for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':, các bit trước đó được sử dụng cho các chữ cái phổ biến hơn để mặt nạ bit có thể ngắn trong hầu hết các trường hợp (thường là 3 hoặc 7 bit do hầu hết các phụ âm chỉ được theo sau bởi một trong 5 nguyên âm hoặc YM hoặc H). Thật không may, mã để giải mã nó phủ nhận sự tiết kiệm so với các phương thức đơn giản hơn (danh sách ban đầu chỉ có 303 byte).

Haskell, 192 byte

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"

Đối với mỗi không gian được phân tách từ trong chuỗi, đặt chữ cái đầu tiên trước tất cả các chữ cái khác và thêm khoảng trắng, ví dụ: SHIO> SH SI SO.

Java, 334 byte

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

Định dạng:

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

Một cách riêng biệt, tôi đã mã hóa danh sách từ thành độ dài 26x26 = 676 Bitset, chuyển đổi nó thành một mảng byte và cuối cùng thành Base 64. Chuỗi đó được mã hóa cứng trong chương trình này và quy trình ngược được sử dụng để tái tạo Bitset, và cuối cùng in ra danh sách các từ

Java, 356 byte

Sử dụng trình tạo số ngẫu nhiên để có được các từ:

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

Ung dung:

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

Bạn có thể dùng thử tại đây: http://ideone.com/Qni32q

Perl, 248 byte

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

Lần đầu tiên sử dụng perl (và lần đầu tiên chơi golf), vì vậy chắc chắn có chỗ để cải thiện. Xác định nguyên âm và nhóm các chữ cái còn lại dựa trên cách tạo từ kết quả - thêm nguyên âm trước, cuối hoặc cả hai nguyên âm trước và cuối cùng tạo một từ trong danh sách.

Javascript (ES6), 214

Có lẽ không phải là cách ngắn nhất để làm điều đó, nhưng chắc chắn thú vị.

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

Vòng lặp qua từng chữ cái trong chuỗi đầu tiên, thêm nó vào từng chữ cái trong dòng tương ứng của chuỗi thứ hai. Điều này trả về các từ theo thứ tự của chữ cái cuối cùng của họ, như vậy:

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

Gợi ý chào mừng!

Java, 255 254 byte

Tìm thấy một cách để vắt thêm một byte ra khỏi nó.

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

Hoặc (mặc dù không rõ ràng hơn nhiều):

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 byte

Chỉ để cho vui thôi!

Đánh giá ssẽ in tất cả các từ theo thứ tự kỳ lạ - Tôi đã sử dụng thực tế là hầu hết các kết hợp là phụ âm nguyên âm hoặc ngược lại, có thể có thể tối ưu hóa nhiều hơn với các "lớp" ký tự tùy chỉnh, rút ​​ngắn ma trận được mã hóa (ở đây, wvà k).

Có ai biết một cách ngắn hơn để in chuỗi mà không có dấu ngoặc kép và dấu ngoặc đơn hơn so với đơn âm của tôi không? Loại lớp thậm chí còn dài hơn như tôi có thể nói.

Ngoài ra, cũng có thể có một cách làm pcông việc ngắn hơn ...

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 byte (Không cạnh tranh)

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

Hãy thử trực tuyến!

PHP, 170 byte

Cách tiếp cận ngắn nhất tôi có thể tìm thấy cho đến nay ...

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

phá vỡ

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
    ;

chú thích Phiên bản ánh xạ bit ngắn nhất có thể in ascii có giá 190 byte (giải mã 113 byte + giải mã 77 byte) sử dụng 6 bit = cơ sở 64, 174 byte (dữ liệu 97, giải mã 77) bằng 7 bit (cơ sở 128); có thể một số nữa để trốn thoát.

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

Cơ sở 224 (sử dụng ascii 32..255) lấy 87 byte dữ liệu (+ thoát); nhưng tôi đoán việc giải mã sẽ tốn thêm hơn 10 byte.
Loại trừ C và V khỏi bản đồ sẽ tiết kiệm 16/14/13 byte trên dữ liệu nhưng tốn rất nhiều chi phí khi giải mã.