ความท้าทาย:

พิมพ์ทุก ๆ 2 ตัวอักษรคำที่ยอมรับได้ใน Scrabbleโดยใช้น้อยที่สุด ผมได้สร้างรายการแฟ้มข้อความที่นี่ ดูด้านล่าง มี 101 คำ ไม่มีคำใดขึ้นต้นด้วย C หรือ V. Creative แม้ว่าจะไม่ได้รับการสนับสนุนก็ตาม

AA
AB
AD
...
ZA

กฎ:

• คำที่ส่งออกจะต้องแยกจากกันอย่างใด
• กรณีไม่สำคัญ แต่ควรสอดคล้องกัน
• อนุญาตให้เว้นวรรคต่อท้ายและขึ้นบรรทัดใหม่ ไม่ควรแสดงอักขระอื่น
• โปรแกรมไม่ควรรับอินพุตใด ๆ ไม่สามารถใช้ทรัพยากรภายนอก (พจนานุกรม)
• ไม่มีช่องโหว่มาตรฐาน

wordlist:

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 ไบต์

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

เกือบจะไม่ใช่วิธีที่สั้นที่สุด แต่ฉันคิดว่านี่เป็นการเริ่มต้นที่ดี พยายามที่จะแพ็คแต่ละคู่เข้าไปในเส้นทางโดยการทับซ้อนให้มากที่สุด (เช่น"ODEX..."= ["OD", "DE", "EX", ...]) ช่องว่างถูกใช้เพื่อแยกพา ธ และคู่ใด ๆ ที่มีช่องว่างในนั้นจะถูกลบออก (พื้นที่ต่อท้ายคือเพื่อป้องกันไม่ให้Eพิมพ์เดี่ยวในตอนท้าย)

ฉันพยายามเล่นกอล์ฟ regex นี้ แต่มันก็นานกว่า

CJam, 96 94 ไบต์

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+

ดังกล่าวข้างต้นเป็น hexdump xxd -r -c 16 -g 1ซึ่งสามารถกลับด้วย

ลองใช้ออนไลน์ในล่าม CJam

ทั้งนี้ขึ้นอยู่กับสิ่งที่นับว่าแยกออกจากกันอย่างใดอย่างหนึ่งนับไบต์อาจลดลงถึง93หรือแม้กระทั่ง92 :

• หากเราแทนที่-55ด้วย59คำจะถูกคั่นด้วยช่องว่างที่ไม่ทำลาย (0xA0)

• หากเราแทนที่-55ด้วยWคำนั้นจะถูกคั่นด้วยเครื่องหมาย at (0x40)

ความคิด

เราสามารถเข้ารหัสคู่ของตัวอักษรแต่ละxyเป็น(อ๊อด (x) - 65) × 25 + (อ๊อด (y) - 65) ¹

แทนที่จะเก็บจำนวนเต็มผลลัพธ์เราจะเก็บความแตกต่างของคู่ทั้งหมดที่ตรงกับคำที่อยู่ติดกันสองคำ (เรียงตามตัวอักษร)

ความแตกต่างสูงสุดคือ35ดังนั้นเราจึงพิจารณาว่ามันเป็นจำนวนเต็มฐาน36และแปลงจำนวนเต็มนั้นเป็นสตริงไบต์

รหัส

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.

¹ _{เนื่องจากตัวอักษรตัวที่สองไม่เคยเป็นZ การใช้25แทน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 

ไม่ใช่คะแนนที่ยอดเยี่ยม แต่ฉันชอบความท้าทาย

ฉันสร้างตารางตัวเลือกสร้างระบบ bitwise เพื่อตั้งค่าสถานะตัวเลือกที่ถูกต้อง

จากนั้นฉันฐาน -36 เข้ารหัสตัวเลือกเหล่านั้นเพื่อรับสตริง:

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

โปรดสังเกตว่ารายการที่ 3 ในอาร์เรย์สตริงนั้นไม่มีค่าเนื่องจาก C ไม่มีตัวเลือก

เพื่อพิมพ์ค่าฉันแค่แปลงตัวเลือกที่ถูกต้องให้เป็นตัวอักษร

อาจมีบางสิ่งที่ฉันสามารถทำได้เพื่อลดการรับรู้ว่าไม่มีคำที่ลงท้ายด้วย C, J, K, Q, V หรือ Z แต่ฉันไม่สามารถคิดวิธีที่จะลดมันได้

โดยการแปลงตารางมีองค์ประกอบที่ว่างเปล่ามากขึ้นและข้อมูลจะเข้ารหัสเพิ่มขึ้นอีกเล็กน้อยซึ่งย่อมาจากไม่กี่ไบต์ ตอนนี้อาร์เรย์จะถูกพิมพ์ตามลำดับอื่น:

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

ขอบคุณ Ismael สำหรับการระเบิดและคำแนะนำการวนซ้ำ

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 คุณpow(,)สามารถแทนที่ได้ด้วย**การบันทึกอีก 4 ไบต์

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 ไบต์

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

เขียนสคริปต์แยกต่างหากเพื่อจัดกลุ่มตัวอักษรให้มีขนาดกะทัดรัดที่สุดเท่าที่จะเป็นไปได้ในสตริงที่มีคำทั้งหมด 2 ตัวอักษรที่ถูกต้อง จากนั้นจะทำซ้ำคำทั้งหมดของคำสองตัวอักษรและพิมพ์คำที่ถูกต้องหนึ่งคำต่อบรรทัด perl -M5.10.1 script.plทำงานด้วย

C, 155 ไบต์

รุ่น Golfed

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

เอาท์พุต

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

เวอร์ชันที่ไม่ดี

สายเวทย์มนตร์ขนาด 51 ไบต์ในเวอร์ชั่นกอล์ฟประกอบด้วยอักขระจำนวนมากเกิน ASCII 126 ซึ่งมีอยู่ในรูปแบบที่เทียบเท่ากับ Unicode รุ่นที่ไม่ได้ใช้งานใช้ hex แทนและเป็นค่าคงที่มากกว่าตัวอักษร นอกจากนี้เวอร์ชันที่ไม่ได้แต่งแต้มแยกคำด้วยการขึ้นบรรทัดใหม่ซึ่งทำให้ง่ายต่อการคัดลอกและวางลงใน Excel เรียงลำดับรายการและเปรียบเทียบกับคำที่ต้องการ

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

คำอธิบาย

หากเราขยายคำจำกัดความของเสียงสระเพื่อรวม 8 ตัวอักษร AHMEIOUY เราสังเกตว่าคำทั้งหมดประกอบด้วยสระหนึ่งตัวและตัวอักษรอีกหนึ่งตัว (ซึ่งอาจเป็นหรืออาจไม่ใช่สระ) ดังนั้นสำหรับคำทั้งหมดที่ลงท้ายด้วยเสียงสระเรา ต้องการตารางขนาด 26 ไบต์หนึ่งตัวสำหรับแต่ละตัวอักษรตัวแรกโดยแต่ละบิตสอดคล้องกับสระ เราต้องการตารางที่คล้ายกันสำหรับคำที่ขึ้นต้นด้วยเสียงสระยกเว้นเวลานี้เราต้องการเพียง 25 ไบต์เนื่องจากไม่มีคำที่ลงท้ายด้วย Z ทั้งสองตารางจะรวมกันเพื่อสร้างตารางสุดท้าย

เพื่อหลีกเลี่ยงรหัส ASCII ใด ๆ ในภูมิภาค 0..31 จะมีการกำหนด "เสียงสระ" M และ H อย่างน้อยสองตัวให้กับบิตที่ 6 และ 7 และการเข้ารหัสจะพิจารณา 1 สำหรับคำที่ไม่ถูกต้องและ 0 สำหรับคำที่ถูกต้อง เนื่องจากไม่มีพยัญชนะที่จับคู่กับทั้ง M และ H จึงเป็นไปได้ที่จะมั่นใจได้ว่าอย่างน้อยหนึ่งในบิตเหล่านี้คือ 1

บิตที่ 8 ถูกกำหนดให้กับ A ซึ่งเป็นเสียงสระที่พบบ่อยที่สุดเพื่อพยายาม จำกัด อักขระที่ไม่ใช่ ASCII (ยังคงมีอยู่ค่อนข้างมาก)

ตารางที่ใช้อยู่ด้านล่าง สำหรับคำที่ประกอบด้วยเสียงสระ 2 ตัวฉันให้ความสำคัญกับตัวอักษรตัวแรกว่าเป็น "เสียงสระ" และตัวอักษรตัวที่สองเป็น "ตัวอักษร" ข้อยกเว้นสำหรับคำนี้คือคำที่ขึ้นต้นด้วย M เนื่องจากเป็นการหลีกเลี่ยงการปะทะกันระหว่าง MM และ HM

การเข้ารหัส Hex ของคำที่ขึ้นต้นด้วยสระ

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 

การเข้ารหัส Hex ของคำลงท้ายด้วยสระ

 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 ไบต์

ความพยายามครั้งแรกของฉัน

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

จัดรูปแบบ:

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

ลองออนไลน์

Ruby, 166 ไบต์

การยืมวิธีที่ประณีตของ sp3000สำหรับการเข้ารหัสคำลงในสตริงขนาดกะทัดรัด kicker ที่นี่เป็นวิธีสั้น ๆ ในการถอดรหัสกลับไปเป็นคำสองตัวอักษร: การใช้ lookahead ใน regex ส่งผ่านไปยังวิธีการสแกนของ String เพื่อแยกการจับคู่ที่ซ้อนทับกันไม่ใช่ containg space:

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

ทับทิม 179 ไบต์

แนวทางของฉัน: สร้างคำสองตัวอักษรทั้งหมดระหว่างAAและZAและเลือกคำที่ถูกต้องโดยใช้ bitmask ที่เข้ารหัส 36 ฐาน:

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

Matlab, 177 ไบต์

สร้างไบนารีเมทริกซ์ที่กำหนดคู่ของตัวอักษรที่ได้รับอนุญาตปรับรูปร่างและเข้ารหัส -64 ฐาน สตริงเข้ารหัส 64 ฐาน ( 'CR+ ... % ') ถูกใช้เป็นข้อมูลในโปรแกรม โปรแกรมย้อนกลับการดำเนินการเพื่อคลายเมทริกซ์จากนั้นอ่านคู่ที่อนุญาต:

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 ไบต์

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~

ลองออนไลน์!

Bash, 179 ไบต์

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

• บันทึกแล้ว 7 ไบต์ขอบคุณ Adam Katz comment

มันใช้sedในการทำทดแทน regex อินพุต regex แรกขึ้นอยู่กับแนวคิด Sp3000ในขณะที่ regex ที่สองใช้อินพุตทั่วไปโดยไม่มีช่องว่าง

คำอธิบาย:

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

คำเตือนคำตอบนี้ไม่น่าสนใจทางโปรแกรม

เนื่องจากคำทั้งหมดมีความยาวสองตัวเราจึงสามารถชนกันทั้งหมดแล้วแยกออกมาอีกครั้งโดยใช้นิพจน์ทั่วไปที่เรียบง่าย

ภาษาที่เป็นมิตรกับ regex สามารถทำได้บางอย่างมีประสิทธิภาพมากกว่าภาษาอื่น:

Grep (ผ่าน Bash), 215 ไบต์

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

Javascript, 224 ไบต์

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

Perl, 225 ไบต์

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

Python ขนาด 245 ไบต์

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

ตามที่ทราบคำตอบบางส่วนของที่นี่ยาวกว่าechoซึ่งฉันจะพิจารณาพื้นฐาน:

POSIX เชลล์ขนาด 307 ไบต์

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 ไบต์ - 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(""));}

จะอัปเดตหากฉันสามารถทำให้เล็กลงได้เพียงรวบรวม gcc -w, ./a.out เอาท์พุทอย่างสมบูรณ์ หากมีความสนใจใน ungolfed แจ้งให้เราทราบ

ฉันไม่สามารถคิดวิธีใดที่จะย่อให้สั้นลงด้านบนของหัวของฉัน (คุณสามารถลบเครื่องหมายคำพูดในการใส่และคุณจะยังได้รับคำตอบที่ถูกต้องผลลัพธ์ที่ออกมาดูเหมือนขยะ) ดังนั้นโปรดแจ้งให้เราทราบ เพื่อย่อให้สั้นลง

C #, 348 ไบต์

ฉันไปแล้ว:

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 ไบต์

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

ลองออนไลน์!

วิธีการบีบอัด: เนื่องจากไม่มีZตำแหน่งที่สองของคำใด ๆ ให้ใช้ตัวอักษรที่เรียงลำดับใหม่bcdfghjklmnpqrstvwxyaeiouเพื่อเข้ารหัสความถูกต้องของตัวอักษรแต่ละตัวเป็นตัวอักษรตัวที่สองสำหรับตัวอักษรตัวแรกแต่ละตัว (ตัวอักษรตัวแรกอยู่ในลำดับตัวอักษร)
นี่คือ 25 บิตต่อตัวอักษรหรือ 5 หลัก -32 หลัก เนื่องจากเสียงพยัญชนะส่วนใหญ่ใช้เสียงสระเป็นตัวอักษรตัวที่สองเท่านั้นฉันจึงวางเสียงสระท้ายเพื่อให้ได้ตัวเลข 1 หลักส่วนใหญ่ ฉันแน่ใจว่ามันสามารถปรับปรุงได้โดยรวมโดยการวิเคราะห์เพิ่มเติมและการเรียงลำดับตัวอักษรใหม่แม้ว่าความหมายของตัวอักษรที่เรียงลำดับใหม่จะใช้เวลามากขึ้นเป็นไบต์

คำอธิบาย

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

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++;

สนุกมาก. ความพยายามครั้งแรกอยู่ในช่วง 250 แต่นี่คือบางที่สุดของฉัน

CJam (99 ไบต์)

รวมถึงอักขระพิเศษบางตัวดังนั้นจึงปลอดภัยที่สุดที่จะให้ hexdump (โดยเฉพาะอย่างยิ่งตัวละครที่มีค่า0xa0ซึ่งสอดคล้องกับพื้นที่ไม่แตกทำให้ฉันค่อนข้างลำบากในการตั้งค่าการสาธิตออนไลน์)

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

สาธิตออนไลน์

วิธีการคือการเข้ารหัสความแตกต่างในฐาน -26

CJam, 100 98 ไบต์

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

(ความคิดเห็น)

• บันทึกสองไบต์ผ่านตัวแปร preinitialized (ขอบคุณเดนนิส!)

นี่เป็นรายการ CJam แรกของฉันดังนั้นอาจมีความเป็นไปได้ที่จะตีกอล์ฟเพิ่มขึ้น อย่างไรก็ตามฉันคิดวิธีบีบอัดรายการอักขระลงไปที่ 63 ไบต์ซึ่งหวังว่าคนอื่นจะมีประโยชน์

วิธีการบีบอัด

จนถึงที่สุดวิธีการที่ฉันเห็นเข้ารหัสตัวอักษรทั้งสองของแต่ละคำ อย่างไรก็ตามเมื่อเราใส่คำตามลำดับตัวอักษรตัวอักษรตัวแรกจะไม่เปลี่ยนบ่อยนักดังนั้นจึงเป็นการสิ้นเปลืองที่จะเข้ารหัสอย่างชัดเจน

ฉันเข้ารหัสเฉพาะอักขระสุดท้ายของแต่ละคำและรวมรายการพิเศษทุกครั้งที่อักขระแรกควรเพิ่มขึ้น อักขระถูกเข้ารหัสเป็นอักขระตัวแรกจากนั้นรายการของความแตกต่าง 1เนื่องจากไม่มีคำที่ซ้ำกันความแตกต่างทุกคนจะต้องมีอย่างน้อย ดังนั้นฉันสามารถใช้0เป็นรายการคั่น (โปรดทราบว่าฉันต้องเก็บตัวอักษรตัวแรกของแต่ละตัวเรียงตามลำดับเดียวมิฉะนั้นจะมีความสับสนระหว่าง 'ตัวอักษรตัวแรกของโรลโอเวอร์0' และ 'เริ่มต้นด้วย A 0')

เนื่องจากความแตกต่างในกรณีนี้จะไม่มากกว่า 15 เราจึงสามารถใช้เบส -16 และแพ็คสองรายการ (4 บิต) ลงในแต่ละไบต์ (8 บิต) (ในรหัสจริงที่ฉันแปลงจาก base-260 แทน base-256 เพื่อหลีกเลี่ยงปัญหาเกี่ยวกับอักขระที่ไม่สามารถพิมพ์ได้)

brainfuck , 1371 ไบต์

ค่อนข้างตีกอล์ฟได้ แต่ฉันไม่ได้ใช้ความพยายามมากเกินไป

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

ลองออนไลน์!

Zsh, 175 ไบต์

โซลูชันนี้ใช้สายอักขระ 125 อักขระซึ่งตัวอักษรตัวเล็กทำหน้าที่เป็นตัวคั่นและอักษรตัวแรกของตัวอักษรพิมพ์ใหญ่ต่อไปนี้

$Lเราย้ำผ่านตัวอักษรของ หากตัวอักษรในปัจจุบัน$Xเป็นตัวพิมพ์เล็กโดยเปรียบเทียบ ASCII ตั้งไป$W $Xมิฉะนั้นให้พิมพ์$Wตัดแบ่งด้วย$Xเพื่อสร้างคำปัจจุบัน

ลองออนไลน์!

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

_{แก้ไข: ท้าย:lชุดพิมพ์เล็กอย่างต่อเนื่องตามความต้องการ
Edit2: -4 ไบต์โดยใช้$Xตัวแปรและง่ายถ้า[[..]]สภาพ
Edit3: -4 ไบต์โดยการเอาคำพูด ( ")
Edit5: -5 ไบต์ใช้การแปลงอาร์เรย์แทนการทำซ้ำในช่วงLต่อด้านล่าง
Edit4: วิธีการสำรองสำหรับ 182 ไบต์ใช้ประโยชน์จากสตริงที่ย้อนกลับได้ใน 33 ตัวอักษรแรก$Lมีเพียง 107 ตัวอักษร}

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

Stax , 91 ไบต์

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

เรียกใช้และแก้ไขข้อบกพร่อง

เคล็ดลับเพียงอย่างเดียวที่คำตอบนี้ใช้คือใช้โทเค็น "," เพื่อแสดงการเปลี่ยนแปลงในจดหมายฉบับแรกแทนที่จะเก็บไว้สำหรับทุกคำ

ขอบคุณสำหรับแนวคิดการใช้โอเปอเรเตอร์แบบเรียกซ้ำ

Python 3, 224 ไบต์

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

ใช้บิตมาสก์ที่มีความยาวผันแปรได้เพื่อเข้ารหัสตัวอักษรตัวที่สองที่มีอยู่สำหรับตัวอักษรตัวแรกที่เป็นไปได้แต่ละตัว รูปแบบบิตสามารถมีความยาว 0,1,3,7,15 หรือ 31 บิต บิตถูกแมปกับตัวอักษรfor d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':บิตก่อนหน้านี้ถูกใช้สำหรับตัวอักษรทั่วไปเพื่อให้บิตมาสก์สามารถสั้นในกรณีส่วนใหญ่ (ปกติ 3 หรือ 7 บิตเนื่องจากตัวอักษรส่วนใหญ่จะตามด้วยหนึ่งใน 5 สระหรือ YM หรือ H) น่าเสียดายที่โค้ดที่ใช้ในการถอดรหัสจะทำให้การออมของคุณลดลงเมื่อเทียบกับวิธีการที่ง่ายกว่า (รายการเดิมมีขนาดเพียง 303 ไบต์)

Haskell ขนาด 192 ไบต์

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"

ทุกพื้นที่แยกคำในสตริงใส่ตัวอักษรตัวแรกในด้านหน้าของตัวอักษรอื่น ๆ ทั้งหมดและเพิ่มพื้นที่เช่น->SHIOSH SI SO

Java, 334 ไบต์

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

จัดรูปแบบ:

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

แยกกันฉันเข้ารหัสรายการคำลงในความยาว 26x26 = 676 บิตเซ็ตแปลงเป็นอาร์เรย์ไบต์และจากนั้นก็เป็นเบส 64 ในที่สุดสตริงนั้นมีการเข้ารหัสยากในโปรแกรมนี้และกระบวนการย้อนกลับใช้ในการสร้างบิตเซ็ตอีกครั้ง และพิมพ์รายการคำศัพท์ในท้ายที่สุด

Java, 356 ไบต์

ใช้ตัวสร้างตัวเลขสุ่มเพื่อให้ได้คำ:

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

คุณสามารถลองได้ที่นี่: http://ideone.com/Qni32q

Perl, 248 ไบต์

@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 (และเล่นกอล์ฟเป็นครั้งแรก) ดังนั้นจึงมีที่ว่างสำหรับการปรับปรุงอย่างแน่นอน แยกเสียงสระและจัดกลุ่มตัวอักษรที่เหลือตามวิธีการสร้างคำที่เกิดขึ้น - เพิ่มเสียงสระก่อน, สุดท้ายหรือทั้งสองเสียงสระแรกและสุดท้ายสร้างคำในรายการ

Javascript (ES6), 214

อาจไม่ใช่วิธีที่สั้นที่สุดที่จะทำ แต่น่าสนใจอย่างแน่นอน

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

วนตัวอักษรแต่ละตัวในสตริงแรกเพิ่มเข้าไปในตัวอักษรแต่ละตัวในบรรทัดที่สอดคล้องกันของตัวที่สอง ส่งคืนคำตามลำดับตัวอักษรสุดท้ายของพวกเขาเช่น:

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

ยินดีต้อนรับข้อเสนอแนะ!

Java, 255 254 ไบต์

ค้นพบวิธีที่จะบีบอัดอีกหนึ่งไบต์จากมัน

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

หรือ (แต่ไม่ค่อยชัดเจน):

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 ไบต์

แค่เล่น ๆ!

การประเมินsจะพิมพ์คำทั้งหมดในลำดับที่แปลก - ฉันใช้ความจริงที่ว่ารวมกันมากที่สุดคือสระ-พยัญชนะหรือในทางกลับกันอาจจะได้เพิ่มประสิทธิภาพมากยิ่งขึ้นด้วยตัวอักษรที่กำหนดเอง "เรียน" การตัดทอนเมทริกซ์เข้ารหัส (ที่นี่wและk)

ไม่มีใครรู้วิธีที่สั้นกว่าในการพิมพ์สตริงโดยไม่ต้องใส่เครื่องหมายคำพูดและวงเล็บปีกกามากกว่าของฉัน คลาสของประเภทนั้นจะยาวกว่าที่ฉันบอกได้

นอกจากนี้อาจมีวิธีที่สั้นกว่าในการทำงานpของ ...

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 ไบต์ (ไม่แข่งขัน)

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

ลองออนไลน์!

PHP, 170 ไบต์

วิธีที่สั้นที่สุดที่ฉันสามารถหาได้ ...

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

ชำรุด

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
    ;

หมายเหตุเวอร์ชันการแมปบิตที่สั้นที่สุดพร้อม ASCII ที่พิมพ์ได้มีราคา 190 ไบต์ (113 ข้อมูลไบต์ + การถอดรหัส 77 ไบต์) โดยใช้ 6 บิต = ฐาน 64, 174 ไบต์ (97 ข้อมูล, 77 ถอดรหัส) โดยใช้ 7 บิต (ฐาน 128) อาจมีอีกมากสำหรับการหลบหนี

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

ฐาน 224 (โดยใช้ ascii 32..255) ใช้ข้อมูล 87 ไบต์ (+ กำลังหลบหนี) แต่ฉันเดาว่าการถอดรหัสจะมีราคาเพิ่มเกินกว่า 10 ไบต์
การไม่รวม C และ V จากแผนที่จะช่วยประหยัดข้อมูลได้ 16/14/13 ไบต์ แต่มีค่าใช้จ่ายสูงในการถอดรหัส