도전 과제 :

가능한 한 적은 바이트를 사용하여 스크래블에서 허용되는 2 글자마다 인쇄 하십시오. 여기에 텍스트 파일 목록을 만들었습니다 . 아래도 참조하십시오. 101 개의 단어가 있습니다. C 나 V로 시작하는 단어는 없습니다. 최적이 아닌 솔루션이라도 권장됩니다.

AA
AB
AD
...
ZA

규칙 :

• 출력 된 단어는 어떻게 든 분리되어야합니다.
• 대소 문자는 중요하지 않지만 일관성이 있어야합니다.
• 후행 공백과 개행이 허용됩니다. 다른 문자는 출력하지 않아야합니다.
• 프로그램은 입력을받지 않아야합니다. 외부 리소스 (사전)를 사용할 수 없습니다.
• 표준 허점이 없습니다.

단어 목록:

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문자가 인쇄 되지 않도록하는 것입니다 ).

나는 또한 정규식 골프를 시도했지만 더 길었다.

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+

위의 16 진 덤프는로 바꿀 수 있습니다 xxd -r -c 16 -g 1.

CJam 통역사 에서 온라인으로 사용해보십시오 .

어떻게 든 분리 된 것으로 정확히 계산되는지에 따라 바이트 수를 93 또는 92 로 낮출 수 있습니다 .

• 우리가 바꿀 경우 -55에 59, 단어는 비 깨는 공간 (내지 0xA0)로 구분됩니다.

• 우리가 바꿀 경우 -55에 W, 단어는 (× 40) 징후에 의해 분리됩니다.

생각

각 문자 쌍 xy 를 (ord (x)-65) × 25 + (ord (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, 210206

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 

확실히 큰 점수는 아니지만 도전을 좋아했습니다.

옵션 테이블을 만들고 유효한 옵션을 표시하는 비트 단위 시스템을 만들었습니다.

그런 다음 문자열을 얻기 위해 해당 옵션을 base-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"

C에는 옵션이 없기 때문에 해당 문자열 배열의 세 번째 항목에는 값이 없습니다.

값을 인쇄하려면 유효한 옵션을 문자로 변환하면됩니다.

C, J, K, Q, V 또는 Z로 끝나는 단어가 없다는 것을 인식하지 못하게 할 수는 있지만 atm을 줄이는 방법은 생각할 수 없습니다.

테이블을 전치하면 더 많은 빈 요소가 있으며 데이터는 조금 더 압축되어 몇 바이트를 줄입니다. 어레이는 이제 다른 순서로 인쇄됩니다.

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으로 업데이트하면 4 바이트를 더 절약 pow(,)할 수 있습니다 **.

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

펄 167 164 157 바이트

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

별도의 스크립트를 작성하여 문자를 가능한 한 컴팩트하게 그룹화하여 유효한 두 글자 단어가 모두 포함 된 문자열로 묶습니다. 그런 다음 두 글자를 모두 반복하고 유효한 단어를 한 줄에 하나씩 인쇄합니다. 로 실행하십시오 perl -M5.10.1 script.pl.

C, 155 바이트

골프 버전

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 이후의 많은 문자가 포함되어 있으며 이는 거의 확실하게 유니 코드 문자로 엉망입니다. ungolfed 버전은 16 진수를 대신 리터럴 대신 상수로 사용합니다. 또한 ungolfed 버전은 단어를 줄 바꿈으로 구분하여 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 바이트의 테이블이 필요합니다. Z로 끝나는 단어가 없기 때문에 이번에는 25 바이트 만 필요하다는 점을 제외하고 모음으로 시작하는 단어에 대해 비슷한 테이블이 필요합니다. 두 테이블은 서로 묶여서 최종 테이블을 만듭니다.

0..31 영역에서 ASCII 코드를 피하기 위해 두 개의 최소 공통 "모음"M 및 H가 6 번째 및 7 번째 비트에 할당되며 인코딩은 유효하지 않은 단어로 1을, 유효 단어로 0을 고려합니다. M 및 H와 쌍을 이루는 자음이 없기 때문에 이러한 비트 중 하나 이상이 1임을 보장 할 수 있습니다.

8 번째 비트는 가장 일반적인 모음 인 A에 지정되어 비 ASCII 문자를 제한하려고 시도합니다 (아직 문자 수가 많음).

사용 된 표는 다음과 같습니다. 모음이 2 개 포함 된 단어의 경우 첫 번째 문자는 "모음"으로 간주되고 두 번째 문자는 "문자"로 우선 순위를 부여했습니다. MM과 HM 사이의 충돌을 피하기 때문에 M로 시작하는 단어는 예외입니다.

모음으로 시작하는 단어의 16 진 인코딩

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 

모음으로 끝나는 단어의 16 진 인코딩

 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

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

온라인으로 사용해보십시오

루비, 166 바이트

단어를 간결한 문자열로 인코딩하기위한 sp3000의 깔끔한 방법을 차용 했습니다 . 여기서 키커는 두 글자로 다시 디코딩하는 짧은 방법입니다. 정규 표현식에서 lookahead를 사용하여 공백을 포함하지 않고 겹치는 일치 항목을 추출하기 위해 String의 scan 방법으로 전달합니다.

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하고 기본 36 인코딩 비트 마스크를 사용하여 유효한 단어를 선택하십시오.

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

Matlab, 177 바이트

허용되는 모든 문자 쌍을 정의하는 이진 행렬을 생성하고 모양을 변경하고 base-64로 인코딩합니다. base-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~

온라인으로 사용해보십시오!

배쉬, 179 바이트

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

• Adam Katz의 의견으로 7 바이트 절약

sed정규식 교체를 수행 하는 데 사용 됩니다. 첫 번째 정규식 입력은 Sp3000 아이디어 를 기반으로 하며 두 번째 정규식은 공백없이 공통 입력을 사용합니다.

설명:

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

경고,이 답변은 프로그래밍 방식으로 흥미롭지 않습니다.

모든 단어의 길이는 두 자이므로 모두 정규식을 사용하여 다시 찢어 낼 수 있습니다.

정규 표현식 친화적 인 언어는 다른 언어보다 효율적으로 수행 할 수 있습니다.

Grep (Bash를 통해), 215 바이트

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

자바 스크립트, 224 바이트

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

펄, 225 바이트

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

파이썬, 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));}}}}

언 골프 드 :

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 개의 Base-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 바이트)

여기에는 몇 가지 특수 문자가 포함되어 있으므로 16 진 덤프를주는 것이 가장 안전합니다. (특히 0xa0비 공백 공간에 해당하는 value가있는 문자 는 온라인 데모를 설정하는 데 약간의 문제를 일으켰습니다).

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

온라인 데모 .

접근 방식은 base-26의 차분 인코딩입니다.

CJam, 100 98 바이트

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

(퍼머 링크)

• 사전 초기화 된 변수를 통해 2 바이트 절약 (Dennis 덕분에)

이것은 첫 번째 CJam 입장이므로 골프를 더 많이 할 가능성이 있습니다. 그러나 문자 목록을 63 바이트로 압축하여 다른 사람이 도움이 될 수있는 방법을 생각해 냈습니다.

압축 방법

지금까지 내가 본 대부분의 방법은 각 단어의 두 문자를 모두 인코딩했습니다. 그러나 알파벳 순서로 단어를 넣을 때 첫 글자는 자주 바뀌지 않으므로 명시 적으로 인코딩하는 것은 낭비적인 것 같습니다.

각 단어의 마지막 문자 만 인코딩하고 첫 문자가 증가 할 때마다 특수 항목을 포함시킵니다. 문자는 첫 번째 문자로 인코딩 된 다음 차이점 목록으로 인코딩됩니다. 중복 된 단어가 없으므로 차이는 모두 적어도이어야 1합니다. 따라서 0구분자 항목으로 사용할 수 있습니다 . (그런 다음 각 하위 시퀀스의 첫 문자를 하나의 색인으로 저장해야합니다. 그렇지 않으면 '롤오버 첫 문자 0'와 '시작으로 A 0' 가 혼동 될 수 있습니다 .)

이 경우의 차이는 15보다 크지 않으므로 base-16을 사용하여 두 개의 (4 비트) 항목을 각 (8 비트) 바이트로 묶을 수 있습니다. (실제 코드에서는 인쇄 할 수없는 문자 문제를 피하기 위해 base-256 대신 base-260에서 변환했습니다.)

brainfuck , 1371 바이트

골프는 가능하지만 너무 많은 노력을 기울이지 않았습니다.

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

온라인으로 사용해보십시오!

Zsh, 175 바이트

이 솔루션은 소문자 문자 구분 기호의 역할을 125 문자 문자열을 사용 하고 대문자 다음과 같은 일련의 첫 글자를.

의 글자를 반복합니다 $L. $XASCII 문자 비교로 현재 문자 가 소문자 인 경우로 설정 $W하십시오 $X. 그렇지 않으면 인쇄 $W와 연결 $X현재 단어를 만들기 위해.

온라인으로 사용해보십시오!

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

_{편집 : :l요구 사항에 따라 소문자를 일관되게 설정하도록 추가 되었습니다 .
Edit2 : $X변수를 사용하여 -4 바이트 및 [[..]]조건을 단순화 한 경우 조건
Edit3 : 따옴표를 제거하여 -4 바이트 ( ")
Edit5 : -5 바이트 L아래 의 반복을 반복하는 대신 배열 변환을 사용하여 -5 바이트
Edit4 : 대체 방법 처음 33 자의 가역 문자열을 이용하는 182 바이트$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;

실행 및 디버깅

이 답변이 사용하는 유일한 트릭은 ","토큰을 사용하여 모든 단어에 대해 저장하지 않고 첫 글자를 변경하는 것입니다.

m 연산자를 사용한다는 아이디어에 대한 재귀 덕분에

파이썬 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':, 이전 비트는보다 일반적인 문자에 사용되므로 대부분의 경우 비트 마스크가 짧아 질 수 있습니다 (대부분의 자음 뒤에 5 모음 또는 YM 또는 H 중 하나만 있기 때문에 일반적으로 3 또는 7 비트). 불행히도 그것을 해독하는 코드는보다 간단한 방법에 비해 비용을 절감합니다 (원본 목록은 303 바이트에 불과합니다).

하스켈, 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"

문자열에서 공백으로 구분 된 모든 단어에 대해 첫 번째 문자를 다른 모든 문자 앞에 놓고 공백을 추가하십시오 (예 : SHIO->) SH SI SO.

자바, 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 BitSet으로 인코딩하고 바이트 배열로 변환 한 다음 마지막으로 Base 64로 변환했습니다.이 문자열은이 프로그램에서 하드 코딩되어 있으며 역 절차는 BitSet을 재생산하는 데 사용됩니다. 궁극적으로 단어 목록을 인쇄

자바, 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);}}}}

언 골프 드 :

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

펄, 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";

펄 (처음 골프)을 처음 사용하기 때문에 개선의 여지가 분명히 있습니다. 모음을 제외하고 결과 단어가 생성 된 방법에 따라 나머지 문자를 그룹화합니다. 모음을 먼저 추가하거나 마지막으로 추가하거나 마지막으로 두 번 모두 추가하여 목록에 단어를 만듭니다.

자바 스크립트 (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

제안을 환영합니다!

자바, 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);
    }
}

하스켈, 333 (308) 298 바이트

재미로!

평가 s하면 모든 단어가 이상한 순서로 인쇄됩니다. 대부분의 조합이 모음 자음이거나 그 반대 인 사실을 사용하여 사용자 지정 문자 "클래스"로 훨씬 더 최적화하여 인코딩 된 행렬을 단축시킬 수 있습니다 (여기서 w및 k).

아무도 내 monadic보다 따옴표와 괄호없이 문자열을 인쇄하는 더 짧은 방법을 알고 있습니까? 내가 말할 수있는 한 타입 클래스는 더 길다.

또한 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가 포함 된 가장 짧은 비트 매핑 버전은 6 비트 = 기본 64를 사용하는 190 바이트 (113 바이트 데이터 + 77 바이트 디코딩), 7 비트 (기본 128)를 사용하는 174 바이트 (97 데이터, 77 디코딩); 탈출을 위해 더 많은 것.

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

Base 224 (ascii 32..255 사용)는 87 바이트 데이터 (+ 이스케이프 처리)를 사용합니다. 하지만 디코딩 비용이 10 바이트를 초과 할 것으로 생각합니다.
지도에서 C와 V를 제외하면 데이터에 16/14/13 바이트가 절약되지만 디코딩에 많은 비용이 듭니다.