Wydrukuj wszystkie 2-literowe słowa Scrabble

40

Wyzwanie:

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

AA
AB
AD
...
ZA

Zasady:

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

Lista słów:

AA AB AD AE AG AH AI AL AM AN AR AS AT AW AX AY 
BA BE BI BO BY 
DE DO 
ED EF EH EL EM EN ER ES ET EX 
FA FE 
GO 
HA HE HI HM HO 
ID IF IN IS IT 
JO 
KA KI 
LA LI LO 
MA ME MI MM MO MU MY 
NA NE NO NU 
OD OE OF OH OI OM ON OP OR OS OW OX OY 
PA PE PI 
QI 
RE 
SH SI SO 
TA TI TO 
UH UM UN UP US UT 
WE WO 
XI XU 
YA YE YO 
ZA
qwr
źródło
8
Czy słowa muszą być wypisywane w tej samej kolejności?
Sp3000,
2
@ Sp3000 Powiem „nie”, jeśli można wymyślić coś interesującego
qwr 13.15
2
Wyjaśnij, co dokładnie liczy się jako oddzielone . Czy to musi być biały znak? Jeśli tak, czy dozwolone byłyby spacje nierozdzielające?
Dennis
5
Ok, znalazłem tłumaczenie
Mikey Mouse
3
Vi nie jest słowem? Wiadomości dla mnie ...
jmoreno,

Odpowiedzi:

39

Python 3, 194 188 bajtów

s="BI ODEXIF BAAX ASOHER LOXUMOPAGOR KI US AMY BOITONOSI MMEMINANEHI UPI AYAHOYOWOMUNUHAID PEFARED QIS BEN JOFETAE KAT ABYESHMALI UTI ZADOELAWE "
while s:" "in s[:2]or print(s[:2]);s=s[1:]

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

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

Sp3000
źródło
1
+1 fajne podejście! Pożyczyłem twój sznurek, aby uzyskać odpowiedź Ruby
daniero,
Odpowiedziałem również na podstawie twojego pomysłu, używając bash i regex
sergioFC
2
+1 za AYAHOYOWOMUNUHAID!
Level River St
28

CJam, 96 94 bajtów

0000000: 31 30 31 2c 22 5a 0a d0 fd 64 f6 07 a3 81 30 f2  101,"Z...d....0.
0000010: c2 a5 60 0c 59 0f 14 3c 01 dd d1 69 7d 66 47 6e  ..`.Y..<...i}fGn
0000020: db 54 e5 8f 85 97 de b9 79 11 35 34 21 cb 26 c3  .T......y.54!.&.
0000030: f0 36 41 2b b4 51 fb 98 48 fc cb 52 75 1f 1d b1  .6A+.Q..H..Ru...
0000040: 6b c3 0c d9 0f 22 32 36 30 62 33 36 62 66 7b 3c  k...."260b36bf{<
0000050: 31 62 32 35 6d 64 2d 35 35 7d 27 41 66 2b        1b25md-55}'Af+

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

Wypróbuj online w interpretatorze CJam .

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

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

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

Pomysł

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

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

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

Kod

101,   e# Push [0 ... 100].
"…"    e# Push the string that encodes the differences/increments.
260b   e# Convert from base 260 to integer.
36b    e# Convert from integer to base 36 (array).
f{     e# For each I in [0 ... 100]:
       e#   Push the base 36 array.
  <    e#   Keep it's first I elements.
  1b   e#   Compute their sum.
  25md e#   Push quotient and residue of the sum's division by 25.
  -55  e#   Push -55 = '\n' - 'A'.
}      e#
'Af+   e# Add 'A' to all resulting integers. This casts to Character.

1 Ponieważ druga litera nigdy nie jest literą Z , wystarczy użyć 25 zamiast 26 .

Dennis
źródło
14

PHP 224, 218, 210 206

foreach(explode(",","I19SR,9ZY8H,,CNK,5JRU0,H,CN4,G0H,H160,CN4,75,CU9,AMIHD,MTQP,HQOXK,7L,74,G,CXS,CU9,HTOG,,CNK,MHA8,CNL,1")as$a){$b++;for($c=0;$c<26;$c++)echo base_convert($a,36,10)&pow(2,$c)?chr(96+$b).chr(97+$c)." ":"";}
aa ab ad ae ag ah ai al am an ar as at aw ax ay ba be bi bo by de do ed ef eh el em en er es et ex fa fe go ha he hi hm ho id if in is it jo ka ki la li lo ma me mi mm mo mu my na ne no nu od oe of oh oi om on op or os ow ox oy pa pe pi qi re sh si so ta ti to uh um un up us ut we wo xi xu ya ye yo za 

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

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

wprowadź opis zdjęcia tutaj

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

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

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

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

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


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

foreach(explode(",","UB1YB,1,,CUP,CLMEJ,CUO,1,SG0H,5J9MR,,,H,MX01,MTXT,CYO5M,MTQ8,,CNL,MTXT,MHAP,50268,,CN5,CNL,FSZ,,")as$a){$b++;for($c=0;$c<26;$c++)echo base_convert($a,36,10)&pow(2,$c)?chr(97+$c).chr(96+$b)." ":"";} 

aa ba fa ha ka la ma na pa ta ya za ab ad ed id od ae be de fe he me ne oe pe re we ye ef if of ag ah eh oh sh uh ai bi hi ki li mi oi pi qi si ti xi al el am em hm mm om um an en in on un bo do go ho jo lo mo no so to wo yo op up ar er or as es is os us at et it ut mu nu xu aw ow ax ex ox ay by my oy

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

foreach(explode(3,UB1YB3133CUP3CLMEJ3CUO313SG0H35J9MR333H3MX013MTXT3CYO5M3MTQ833CNL3MTXT3MHAP35026833CN53CNL3FSZ)as$d)for($e++,$f=0;$f<26;$f++)echo base_convert($d,36,10)&pow(2,$f)?chr(97+$f).chr(96+$e)." ":"";

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

foreach(explode(3,UB1YB3133CUP3CLMEJ3CUO313SG0H35J9MR333H3MX013MTXT3CYO5M3MTQ833CNL3MTXT3MHAP35026833CN53CNL3FSZ)as$d)for($e++,$f=0;$f<26;$f++)echo base_convert($d,36,10)&2**$f?chr(97+$f).chr(96+$e)." ":"";
James Webster
źródło
Zamiast eksplodować ",", możesz użyćexplode(0,UB1YB0100CUP[...])
Ismael Miguel
Czy to nie zepsuje się, ponieważ w kodowaniu są zera?
James Webster,
Jednak .. nie 3mogę tego użyć! Dzięki
James Webster,
Możesz także zastąpić $e++;for($f=0;$f<26;$f++)je for($e++,$f=0;$f<26;$f++), a teraz możesz usunąć te nieznośne {}. A jeśli chcesz przekonwertować znaki na małe litery, użyj $e^' '.
Ismael Miguel,
Dobry chwyt! Nie dostałbym tego.
James Webster,
8

Perl, 167 164 157 bajtów

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

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

AKHolland
źródło
Nie mogę tego uruchomić w kompilatorze online.
mbomb007,
@ mbomb007 W zależności od wersji potrzebujesz flagi wiersza polecenia, -M5.10.1aby użyć saysłowa kluczowego dodanego w tej wersji, lub dodaj treść use feature 'say';skryptu.
AKHolland
7

C, 155 bajtów

Wersja golfowa

i,v;main(){for(;++i-408;" >b  Ùc :oÒ¹ i ;¹ w so@)ia ¥g¨¸ ´k¦ase    Ù{§k {"[i/8]>>i%8&1||printf("%c%c%c ",i/8%2*v,i/16+65,!(i/8%2)*v))v="YUOIEMHA"[i%8];}

Wydajność

YA HA AA BY BO BI BE BA AB DO DE OD ID ED AD YE OE HE AE FE FA OF IF EF GO AG UH OH EH AH OI HI AI JO KI KA LO LI LA EL AL MY MU MO MI ME MM MA UM OM EM HM AM NU NO NE NA UN ON IN EN AN YO HO PI PE PA UP OP QI RE OR ER AR SO SI SH US OS IS ES AS TO TI TA UT IT ET AT WO WE OW AW XU XI OX EX AX OY AY ZA

Wersja bez golfa

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

char a[]=
{0xFF,0x3E ,0x62,0x7F ,0xFF,0xFF ,0xEB,0x63 ,0xFF,0x3A ,0x6F,0xE3 ,0xFB,0x7F ,0xFF,0x69 ,0xFF,0x3B
,0xFB,0xFF ,0x77,0xFF ,0x73,0x6F ,0x40,0x29 ,0x69,0x61 ,0xFF,0xBE ,0x67,0xF9 ,0xF7,0xFF ,0xEF,0x6B
,0xB3,0x61 ,0x73,0x65 ,0xFF,0xFF ,0xFF,0xFF ,0xEB,0x7B ,0xF5,0x6B ,0xFF,0x7B ,0x7F};

//iterate through i = 16*letter + 8*order + vowel
i,v;main(){for(;i++-408;a[i/8]>>i%8&1||printf("%c%c%c\n",i/8%2*v,i/16+65,!(i/8%2)*v))v="YUOIEMHA"[i%8];}

Wyjaśnienie

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

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

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

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

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

3E 7F FF 63 3A E3 7F 69 3B FF FF 6F 29 61 BE F9 FF 6B 61 65 FF FF 7B 6B 7B

AA AB    AD AE    AG AH AI       AL AM AN          AR AS AT       AW AX AY 
HA          HE          HI          HM    HO 

         ED    EF    EH          EL EM EN          ER ES ET          EX 
         ID    IF                      IN             IS IT 
         OD OE OF    OH OI          OM ON     OP   OR OS          OW OX OY 
                     UH             UM UN     UP       US UT 
YA          YE                            YO 

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

 A  H  M  E  I  O  U  Y
                         FF
BA       BE BI BO    BY  62
                         FF 
         DE    DO        EB
                         FF
FA       FE              6F
               GO        FB
                         FF
                         FF
               JO        FB
KA          KI           77
LA          LI LO        73
MA    MM ME MI MO MU MY  40
NA       NE    NO NU     69
                         FF
PA       PE PI           67
            QI           F7
         RE              EF
    SH      SI  SO       B3
TA          TI  TO       73
                         FF
                         FF
         WE     WO       EB
            XI     XU    F5
                         FF
ZA                       7F
Level River St
źródło
Może zrobić
zrzut heksowy wersji golfowej,
7

Java, 484 448 407 391 389 bajtów

Moja pierwsza próba

public static void main(String[]a){int[]x={57569742,35784706,0,2099200,5534148,35651584,2048,35792896,5247168,2048,33685504,33687552,35794978,35653664,7746958,35782656,131072,2097152,395264,33687552,551296,0,2099200,131104,35653632,33554432};for(Integer i=0;i<26;i++){for(int z=0;z<26;z++){if("".format("%26s",i.toString(x[i],2)).charAt(z)=='1'){System.out.format("%c%c ",'A'+i,'A'+z);}}}}

Sformatowany:

public static void main(String[] a) {
    int[] x = { 57569742, 35784706, 0, 2099200, 5534148, 35651584, 2048, 35792896, 5247168, 2048, 33685504, 33687552, 35794978, 35653664,
            7746958, 35782656, 131072, 2097152, 395264, 33687552, 551296, 0, 2099200, 131104, 35653632, 33554432 };
    for (Integer i = 0; i < 26; i++) {
        for (int z = 0; z < 26; z++) {
            if ("".format("%26s", i.toString(x[i], 2)).charAt(z) == '1') {
                System.out.format("%c%c ", 'A' + i, 'A' + z);
            }
        }
    }
}

Wypróbuj online

griFlo
źródło
Dobra robota! Niektóre sugestie: java.lang.Exception można po prostu nazwać Exception. „args” może być po prostu „a”. String.format () może być „” .format (). W deklaracji main () jest także trochę dodatkowych odstępów. Ogólnie
fajne
Właśnie bawiłem się drukowanym oświadczeniem, ale pobiłeś mnie! Możesz zapisać kolejny bajt, zastępując \ngo tylko spacją. Nie muszą być oddzielone nowymi wierszami.
James Webster,
Brakowało również kilku spacji, które można usunąć.
James Webster,
@JamesWebster thx za podpowiedzi.
griFlo,
4
"".formatjest bolesne, ale przezabawne.
codebreaker
6

Rubin, 166 bajtów

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

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

Rubinowy, 179 bajtów

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

i=-1
puts ("AA".."ZA").select{|w|"djmsjr5pfw2omzrfgydo01w2cykswsrjaiwj9f2moklc7okcn4u2uxyjenr7o3ub90fk7ipdq16dyttg8qdxajdthd6i0dk8zlmn5cmdkczrg0xxk6lzie1i45mod7".to_i(36)[i+=1]>0}
daniero
źródło
6

Matlab, 177 bajtów

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

x=de2bi('CR+"''        1$$ L*\"%$!! !   $!04P@<W(        0$   1"%$$100@RZP4  $$    0$ ! 1$$$$1 0  P (    $ 0 0$ ! # %  '-32)';[i,j]=find(reshape(x(1:650),26,[])');char([j i]+64)
Luis Mendo
źródło
2
Niezły Luis! Gra w golfa jest właściwie zabawą ... = P
Stewie Griffin
1
Miły! Nie ma alfabetu!
Brain Guider
1
czapki z głów. To najbardziej tajemniczy kod Matlab, jaki widziałem od wieków ...
Hoki
Dzięki chłopaki! Jest to tajemnicze tylko z powodu kodowania base-64. Ten ciąg faktycznie zawiera macierz binarną 26x25 dozwolonych par liter
Luis Mendo
6

Malbolge , 2118 bajtów

D'``_#>nI||38h6/vdtO*)_^mI7)"XWfB#z@Q=`<)\xwvuWm32ponmfN+ibJfe^$\[`Y}@VUySXQPUNSLpJINMLEiC+G@EDCB;_?>=}|492765.R210p(-,+*#G'&feB"baw=u]sxq7Xnsrkjoh.fNdchgf_%]\a`Y^W{>=YXWPOsSRQ3OHMLKJIBfF('C<`#"8=<;:3W1w5.R2+q/('&J$)"'~D$#"baw=utsxq7Xnsrkjoh.fNdchgf_%c\D`_X|\>=YXWPOsSRQ3OHMLKJIBfFEDC%$@9]=6|:32V6/.3210)M-m+$)"'&%|Bcb~w|u;yxwvuWm3kpinmfe+ihgfH%cb[ZY}]?UZYRWVOs65KPIHGkKJIH*)?c&BA@?8\6|:32V6/.3210)M-,lk)"F&feBzbxw=uzyrwpon4Ukpi/mfkdc)g`ed]#DZ_^]VzZ<;QPt7MLQPOHlFEJIHAe(>C<;_?>765:981Uv.32+*)Mnm%$)(!Efe{zy?}|{zyxqpo5mrkpoh.fNdihg`ed]#DZ_^]Vz=YRQuUTMqQ32NMLEDhHG@(>C<;_?>76;:3W76v43,+O/.nm+*)"Fgf${z@a}v{zyr8vo5Vrqj0nmfN+Lhg`_%cbDCY}@VUySRWPt76Lp3ONMLEDhHG@(>C<;_"8\6|:32V0v.Rs10/.'&+$H('&feB"!x>|^]srwvun4Ukpi/gfe+Lbaf_%cE[`Y}@?[TxRWPUNMLKo2NGFjD,BAeED&<A:^>=6|:32V6v.R21*/(L,+*#"!E}|{z@xw|{t:[qpotsrk1Rhmlkd*Kgfe^$bDZ_^]VzZ<;QuUTMqKJOHGkEJCBA@dD=<;:^>=6|:32V654t,+O).',+*#G'&feBzbx>|^]yr8vXnsrkjoh.fkdcbg`&^Fba`Y^WVzZ<XWPUTMqQ3INMFjD,BAe?>=B;_9>7<54X8765u-Q10)o'&J$)"!~%${A!x}v<]\xwpun4rTpoh.leMchgf_d]#DZ_^]VzZYR:Pt7SLKPOHlFEJIHAeED&<`@"87<5Y98165.3,P*/(-&+$H(!~}C#c!x}|u;\[wvun4lTjih.fN+Lbgfe^c\"CY}@VUyYXWPOsSRKJIHlLE-IBAeE'&<`@"87<5Y98165.3,Pq/.-,+*#G'&fe#"!x>|{zyr8Yotml2ponPlkdcb(fH%]\[`Y^W{zZ<XWPUTMq4JIHMLEi,BA@d>=B;:9]7};:3W7wv.3,+O)o'&J*)('g%${Ay~}v{zyrq7otmrqpoh.fejiha'eG]\[ZY}@VUy<;WVOsSRQPImM/KJIBAe(>=aA:^>=6|:32V65u-Qr0/.'K+$j"'~De#zy~wv<]yrqpo5srkjohg-kdib(feG]b[Z~^]\UTYRvP8TSRKJIHlLKD,BAe?>=B;_?>7<;:981U54t,+O)o'&Jkj('&}C#"bx>_{tyr8vuWVl2pihgle+ihgfH%cEDZ~XWVUy<XWPUTMqQP2NGLEiCBGF?>b%A@?87[;:zy1U54t210/.'K+$j"'~De#zy~wv<zyxwp6Wmlqpohg-kdib(feG]ba`Y^W{>=YXWPOs65KJIHl/KJIBA@dDCB;:9]=<;:zy1Uvu3,P0)o'&J$#(!~D|#"y?}v{zyr8vXnml2ponPledc)gfH%c\D`_^]VzZ<;QVOTSLpPIHGkKJCBG@dD=<;:^>=6|:32Vw543,+*N.nm+*)"F&feB"y~}|{ts9qvonsl2ponmfN+Lha`e^$\[Z_X|\UTYRQVOsM5KJOHGFjD,BA@d>=B;:9]=};4X81w5.R210)o'&J$j"'~%|{"y?w_u;y[wpun4Ukponmfe+Lha'eGc\[!B^WV[TxXQ9ONrRQ32NMLEDh+AeE'&<`#"8=<;:3W7wv.3,+O/.'m+*)(!EfeBcbx>_{tsxwvun4Ukpi/POkdcha'_d]#DZ_^]VzZ<RQPUNMqQ3ONGkE-IBAeED=BA:9]=<|43870/St,+O/.-ml*)(!Ef|Bcb~w|u;y[Zvun4rTpoh.fN+cKgf_%cE[!BXWV[ZSwWP8TSLpJIHMLEJIBf)d'=aA@">=<5Y98165.3,Pq)('K%*#"!EfeBcyxwvu;yxwvuWm3~

Wypróbuj online!

Krzysztof Szewczyk
źródło
5

Bash, 179 bajtów

echo U`sed -r 's/./& &/g'<<<HAABADEDOEFAEHELAGOFEMAHINAISHMENERESITALOHOMMONOPAMUMYAWETOSOWOYOXUNUPEXI`F `grep -o ..<<<ANARASATAXAYBEBIBOBYJOKAKILIMIOIDOIDORPIQITIUSUTYEZA`
  • Zaoszczędzono 7 bajtów dzięki komentarzowi Adama Katza

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

Wyjaśnienie:

echo              print to standard output the following
U                 boundary U character
sed -r [etc]      the result of replacing regex
    .             select a character
    & &           replace it for: matched char, space, matched char
    g             do it globaly for every character
    <<<HAAB[etc]  string input based on Sp3000 idea => HA AA AB ...
F                 boundary F character
sed -r [etc]      the result of replacing regex
    ..            every two characters
    <space>&      for space+matched character
    g             do it globally
    <<<ANAR       normal input => AN AR ...
sergioFC
źródło
1
Można kurczyć, że przez siedem bajtów używając przestrzeni a następnie `grep -o ..w miejscu `sed -r 's/ / &/g', trick z moją odpowiedź poniżej.
Adam Katz
5

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

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

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

Grep (via Bash), 215 bajtów

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

JavaScript, 224 bajty

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

Perl, 225 bajtów

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

Python, 245 bajtów

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

 


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

Powłoka POSIX, 307 bajtów

echo AA AB AD AE AG AH AI AL AM AN AR AS AT AW AX AY BA BE BI BO BY DE DO ED EF EH EL EM EN ER ES ET EX FA FE GO HA HE HI HM HO ID IF IN IS IT JO KA KI LA LI LO MA ME MI MM MO MU MY NA NE NO NU OD OE OF OH OI OM ON OP OR OS OW OX OY PA PE PI QI RE SH SI SO TA TI TO UH UM UN UP US UT WE WO XI XU YA YE YO ZA
Adam Katz
źródło
3
+1 za praktyczność. Naprawdę, zapewnienie podstawowego echa jest punktem, od którego każdy powinien zacząć.
metalim
+1 przy łatwej odpowiedzi, ale powinieneś zaznaczyć to jako niekonkurujące, prawda?
Matthew Roh
@MatthewRoh - Gdyby był parser tabeli liderów, prawdopodobnie nic by nie znalazł, ponieważ celowo nie zacząłem od nagłówka. Nie martwię się, zwłaszcza, że ​​dla każdego opublikowanego języka są krótsze odpowiedzi.
Adam Katz
3

C - 228 217 bajtów - GCC

 _;main(){char *z,*i="AABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EOU IEO A A ";for(z=i;_++^26;)for(;*++z^32;putchar(_+64),putchar(*z),puts(""));}

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

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

Jake
źródło
Oto kilka sugestii, działa dla mnie dobrze (nie tylko kopiuj i wklej, wymiana stosu wstawia dziwne znaki kontrolne do komentarzy) _;main(){char*z="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(;_++^26;)for(;*++z^32;printf("%c%c ",_+64,*z));}Zmieniłem separator wyjściowy z nowego wiersza na spację, ale jeśli wolisz nowy wiersz (jeden dodatkowy bajt) zmień ciąg formatu printf na"%c%c\n"
Level River St
3

C #, 348 bajtów

Miałem okazję:

using System;class A{static void Main(){var a=new System.Collections.BitArray(Convert.FromBase64String("tnOciwgCCAAAAAggAFBxHIkAAAAACICIKABQQBgAAAIgIACAgCAAIqIgigCCADfWuIgAAAACAIAAAAAwCICAIAAAYRkAAAAAAggAgAAIIoAACA=="));int c, d;for(var i=0;i<652;i++){if(a[i]){c=Math.DivRem(i,26,out d);Console.Write("{0}{1} ",(char)('A' + c),(char)('@' + d));}}}}

Nie golfowany:

using System;

class A
{
    static void Main()
    {
        var a = new System.Collections.BitArray(Convert.FromBase64String(
            "tnOciwgCCAAAAAggAFBxHIkAAAAACICIKABQQBgAAAIgIACAgCAAIqIgigCCADfWuIgAAAACAI" + 
            "AAAAAwCICAIAAAYRkAAAAAAggAgAAIIoAACA=="));
        int c, d; 
        for(var i = 0; i < 652; i++)
        {
            if(a[i])
            {
                c = Math.DivRem(i, 26, out d);
                Console.Write("{0}{1} ", (char)('A' + c), (char)('@' + d));
            }
        }
    }
}
Jodrell
źródło
4
Jest to wyzwanie dla codegolf, dlatego powinieneś opublikować swoją liczbę bajtów (długość kodu). Spróbuj także go nieco skrócić, na przykład usuwając spacje.
Jakube,
@Jakube, czy to jest lepsze?
Jodrell,
Tak, wygląda dobrze
Jakube,
3

Pyth , 140 bajtów

K"aeiou"=H+-G+K\zKL.[`Z25.Bib32jdSfTs.e.e?nZ`0+@Gk@HY""byMc"ljjns 1u  a 6jji0 o 2 100u 60hg0 2 k m 101v r 6hr7c s 4 8 g006 m hpg0  a 5 q g"d

Wypróbuj online!

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

Wyjaśnienie

K"aeiou"=H+-G+K\zK # Define the reordered alphabet
K"aeiou"           # K := "aeiou"
        =H         # H :=
           -G      #      G.removeAll(
             +K\z  #                   K + "z" 
          +      K #                           ) + K

L.[`Z25.Bib32      # Define a lambda function for decompression
L                  # y = lambda b:
         ib32      # convert b to int using Base 32
       .B          # convert to binary string
 .[`Z25            # pad to the left with "0" to the nearest multiple of 25 in length

                           c"..."d # split the compressed string on " "
                         yM        # Apply y (above lambda) to each element
                                   #   Intermediate result: List of binary strings
                                   #   with 1s for allowed combinations
      .e                           # map over ^ lambda b (current element), k (current index):
        .e              b          # map over b: lambda Z (cur. elem.), Y (cur. ind.):
               +@Gk@HY             # G[k] + H[Y] (G is the regular alphabet)
          ?nZ`0       ""           #     if Z != "0" else ""
     s                             # combine into one large list
   fT                              # remove all falsy values (empty strings)
  S                                # sort (if any order is possible, remove this)
jd                                 # join on spaces (if a normal list with the words is
                                   #   allowed, remove this)
ar4093
źródło
2

PHP: 211 209 204

Musisz wyłączyć ostrzeżenia, w przeciwnym razie wydrukuje się w odniesieniu do domniemanego utworzenia $b

for($a=65;$b<strlen($c="ABDEGHILMNRSTWXY!AEIOY!EO!DFHLMNRSTX!AE!O!AEIMO!DFNST!O!AI!AIO!AEIMOUY!AEOU!DEFHIMNPRSWXY!AEI!I!E!HIO!AIO!HMNPST!EO!IU!AEO!A");$b++)if($c[$b]!='!')echo chr($a).$c[$b].' ';else$a++;

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

NickW
źródło
2
Wypróbuj ten licznik bajtów . Pamiętaj, że wyłączenie liczenia białych znaków jest niepoprawne, ponieważ dyskontuje również wszelkie spacje w ciągach znaków, więc twój wynik powinien być większy niż 186.
Sp3000
Dobry chwyt Zaktualizowałem odpowiednio swoje zgłoszenie
NickW,
Nie rozumiem dlaczego ... ale teraz drukuje tylko „AAAA A ...”
James Webster,
Podjąłeś decyzję, !jeśli potrzebujesz tego.
James Webster,
Dobrze. Właśnie to zauważyłem. Używałem! ogranicznik wcześniej i zrobiłem szybkie wyszukiwanie-zamień, nie zastanawiając się, co stanie się najpierw.
NickW,
2

CJam (99 bajtów)

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

00000000  36 37 36 22 c4 b2 2d 51  3f 04 93 5c 64 6c 8d 6e  |676"..-Q?..\dl.n|
00000010  d7 f9 7d 97 29 aa 43 ef  04 41 12 e1 aa ce 12 4d  |..}.).C..A.....M|
00000020  05 f3 1c 2b 73 43 a0 f0  41 c0 a7 33 24 06 37 a3  |...+sC..A..3$.7.|
00000030  83 96 57 69 9b 91 c4 09  c3 93 e1 ed 05 3b 84 55  |..Wi.........;.U|
00000040  d9 26 fd 47 68 22 32 35  36 62 33 38 62 7b 31 24  |.&.Gh"256b38b{1$|
00000050  2b 7d 2f 5d 7b 32 36 62  28 3b 36 35 66 2b 3a 63  |+}/]{26b(;65f+:c|
00000060  4e 7d 2f                                          |N}/|
00000063

Demo online .

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

Peter Taylor
źródło
Dodawanie znaku do liczby całkowitej daje znak, dzięki czemu można zastąpić 65f+:cz 'Af+.
Dennis,
Prawdziwe. I mdjest genialnym poprawa, ale nie zdawał sobie sprawy, jak blisko jest moja odpowiedź na twoje.
Peter Taylor,
2

CJam, 100 98 bajtów

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

(bezpośredni link)

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

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

Metoda kompresji

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

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

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

2012 rcampion
źródło
Możesz zaoszczędzić kilka bajtów, używając Gi N, które wypychają 16 i przesuw linii.
Dennis,
@Dennis Dzięki, nie zdawałem sobie sprawy, że zmienne zostały wstępnie zainicjowane!
2012rcampion
1
Wszystkie 26 wielkich liter to zmienne wstępnie zainicjowane. Możesz zobaczyć pełną listę tutaj .
Dennis,
Możesz zaoszczędzić więcej bajtów, zastępując %-3<je /;;lub nawet /&. (Druga opcja spowoduje wygenerowanie komunikatu o błędzie. Konsensus w sprawie meta jest taki, że można to zrobić.)
Dennis
2

pieprzenie mózgu , 1371 bajtów

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

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

Wypróbuj online!

Krzysztof Szewczyk
źródło
Cóż, po pierwsze, możesz pozbyć się nowych linii
Jo King
@JoKing, nie ma prawdziwego sposobu na pokonanie kogoś, nie sądzę, aby golenie kilku bajtów na tak dużą skalę miało sens.
Krzysztof Szewczyk
2

Zsh, 175 bajtów

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

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

Wypróbuj online!

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

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

L=aBHLMNTYdEOeFHMNRhOiSTmOUnOUoSWYaADEGIRSWXbEIOYeLSTXfAgOhIMiDFNjOkAIlIOmIMYoEFIPRXpAEIqIsHtOuHPSTwExIUyEzA
for ((;i++<$#L;))X=$L[i]&&((#X>90))&&W=$X:u||<<<$W$X`((i<34))&&<<<\ $X$W`
roblogic
źródło
2

Stax , 91 bajtów

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

Uruchom i debuguj

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

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

użytkownik89655
źródło
Ładnie wykonane. Widzę kilka drobnych optymalizacji. Użyj Mzamiast 1/i użyj skróconej mapy mzamiast wyraźnego wymyślania i drukowania { ... PF. Ten pakuje do 89.
rekurencyjny
1

Python 3, 224 bajty

s='';i=int("AQHU9HU1X0313T1J9OMYMZZSRFWLCYT3POSE06UGHXDZN6H5SQSZIFCE6VEB",36)
for c in range(26):
 b=i%6;i//=6;k=(1<<b)-1;j=i%(1<<k);i>>=k
 for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':
  if j&1:s+=chr(c+65)+d+' '
  j>>=1
print s

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

samgak
źródło
1
Odkryłem, że lepiej zakodować, która pierwsza litera istnieje dla każdej możliwej drugiej litery w moim rozwiązaniu. Może warto spróbować w twoim.
James Webster,
1

Haskell, 192 bajty

putStr$(\(a:b)->((a:).(:" "))=<<b)=<<words"AABDEGHILMNRSTWXY BAEIOY DEO EDFHLMNRSTX FAE GO HAEIMO IDFNST JO KAI LAIO MAEIMOUY NAEOU ODEFHIMNPRSWXY PAEI QI RE SHIO TAIO UHMNPST WEO XIU YAEO ZA"

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

nimi
źródło
1

Java, 334 bajty

public class C{public static void main(String[]a){for(int i=0;i<26;i++){for(int j=0;j<26;j++){if(java.util.BitSet.valueOf(java.util.Base64.getDecoder().decode("2znORQQBBAAAAAQQAKg4jkQAAAAABEBEFAAoIAwAAAEQEABAQBAAEVEQRQBBgBtrXEQAAAABAEAAAAAYBEBAEACAsAwAAAAAAQQAQAAEEUAABA==")).get(i*26+j)){System.out.format("%c%c\n",'a'+i,'a'+j);}}}}}

Sformatowany:

public class Code {
    public static void main(String[] a) {
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < 26; j++) {
                if (java.util.BitSet.valueOf(
                        java.util.Base64.getDecoder()
                            .decode("2znORQQBBAAAAAQQAKg4jkQAAAAABEBEFAAoIAwAAAEQEABAQBAAEVEQRQBBgBtrXEQAAAABAEAAAAAYBEBAEACAsAwAAAAAAQQAQAAEEUAABA=="))
                        .get(i * 26 + j)) {
                    System.out.format("%c%c\n", 'a' + i, 'a' + j);
                }
            }
        }
    }
}

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

Kevin K.
źródło
1

Java, 356 bajtów

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

import java.util.Random;class X{public static void main(String[]a){int j,n,m=9,x;for(String u:"rgzza 2u2hh r2rxs qs5f fwiag 26i33y 2xqmje 5h94v 16ld2a 17buv 4zvdi 1elb3y 2t108q 5wne9 1mrbfe 1ih89 fh9ts r0gh".split(" ")){x=Integer.parseInt(u,36);Random r=new Random(x/2);j=m-=x%2;while(j-->0){n=r.nextInt(676);System.out.format(" %c%c",65+n/26,65+n%26);}}}}

Nie golfowany:

import java.util.Random;
class X{
    public static void main(String[]a){
        int j,n,m=9,x;
        for(String u:"rgzza 2u2hh r2rxs qs5f fwiag 26i33y 2xqmje 5h94v 16ld2a 17buv 4zvdi 1elb3y 2t108q 5wne9 1mrbfe 1ih89 fh9ts r0gh".split(" ")){
            x=Integer.parseInt(u,36);
            Random r=new Random(x/2);
            j=m-=x%2;
            while(j-->0){
                n=r.nextInt(676);
                System.out.format(" %c%c",65+n/26,65+n%26);
            }
        }
    }
}

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

Arnaud
źródło
1

Perl, 248 bajtów

@v=split(//,"AEIOU");@s=split(' ',"ADEGIRSWX LSTX DFN EFIPRX HPST BHLMNTY DFHMNR ST DHMNSWY MN ZFKP WYPB KQXLHPMB LGJTB X");for(0..14){foreach $c(split(//,@s[$_])){$_<10?print @v[$_%5].$c." ":a;$_>4?print $c.@v[$_%5]." ":a;}}print "MM MY BY HM SH";

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

VoiceOfFolly
źródło
Nie znam Perla, ale zakładam, że oddzielasz dane wyjściowe spacjami. Wydaje się, że "MM "."MY "."BY "."HM "."SH "można go skrócić "MM MY BY HM SH".
Level River St
@steveverrill Thanks! Byłem tak pochłonięty resztą kodu, że przeoczyłem, jak to było zbędne.
VoiceOfFolly,
1

JavaScript (ES6), 214

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

_=>(i=0,[...'ABDEFGHILMNOPRSTUWXY'].map(z=>[...`ABFHKLMNPTYZ
A
AEIO
ABDFHMNOPRWY
EIO
A
AEOSU
ABHKLMOPQSTX
AE
AEHMOU
AEIOU
BDGHJLMNSTWY
OU
AEO
AEIOU
AEIU
MNX
AO
AEO
ABMO`.split`
`[i++]].map(g=>g+z).join` `).join`
`)

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

AA BA FA HA KA LA MA NA PA TA YA ZA
AB
AD ED ID OD
AE BE DE FE HE ME NE OE PE RE WE YE
EF IF OF
AG
AH EH OH SH UH
AI BI HI KI LI MI OI PI QI SI TI XI
AL EL
AM EM HM MM OM UM
AN EN IN ON UN
BO DO GO HO JO LO MO NO SO TO WO YO
OP UP
AR ER OR
AS ES IS OS US
AT ET IT UT
MU NU XU
AW OW
AX EX OX
AY BY MY OY

Sugestie mile widziane!

ETHprodukcje
źródło
1

Java, 255 254 bajtów

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

class C{public static void main(String[]a){char c='A';for(char l:"ABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EO IU AEO A".toCharArray())if(l<'A')c++;else System.out.print(" "+c+l);}}

Lub (choć niewiele wyraźniej):

class C {
    public static void main(String[] a) {
        char c = 'A';
        for (char l : "ABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EO IU AEO A"
                .toCharArray())
            if (l < 'A')
                c++;
            else
                System.out.print(" " + c + l);
    }
}
Aofl
źródło
Możesz zapisać dwa bajty, zmieniając oba wystąpienia 'A'na 65.
ProgramFOX
1

Haskell, 333 308 298 bajtów

Dla żartu!

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

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

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

v="AEIOU"
c="BCDFGHJKLMNPQRSTVWXYZ"
w=[976693,321324,50188,945708,52768]
k=[15,0,10,3,8,15,8,5,13,31,27,7,4,2,12,13,0,10,20,11,1]
z a b x=[[c:[e]|(e,f)<-b#p d,f]|(c,d)<-a#x]
(#)=zip
p 0=[]
p n=((n`mod`2)>0):p(n`div`2)
s=mapM_ putStrLn$concat$z v c w++z c v k++[words"AA AE AI BY HM MM MY OE OI SH"]
Leif Willerts
źródło
Czy to nie sequence_to samo co void$sequence? Następnie możesz pominąć również import.
nimi
To dziwnie zapakowane, ale tak. Dzięki!
Leif Willerts,
Nie, voidmusiał zostać zaimportowany. W każdym razie, muszę to zapamiętać.
Leif Willerts,
1
Ach i sequence_$map putStrLnjest mapM_ putStrLn. Zamień (, )wokół na concat$...inny $.
nimi
1

05AB1E , 143 bajty ( zakaz konkurowania)

•ZÐFý8ù6„=4ÅœÿWì±7Ë5Œ¾`ó/îAnµ%Ñ¥Ëø±/ÀéNzքѧIJ¶D—ÙVEStvÖò…¸¾6F³#EXŠm¯Cĵ±ÓoÊ°}^€Ftå߀ðŒ=«j;F-Â1;xX3i&QZÒ'Ü”>lwìlOs>íÙVÇI)~î‰Hç²?Öd0È^ÝQ°•36B2ô»

Wypróbuj online!

Urna Magicznej Ośmiornicy
źródło
95 bajtów przez przeniesienie odpowiedzi @ Sp3000 na Python 3 .
Kevin Cruijssen
1
@KevinCruijssen 91 (i jestem pewien, że ta metoda może być niższa, ale ręcznie wybrałem słowa ze słownika dla humoru).
Grimmy
1

PHP, 170 bajtów

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

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

awaria

for(;$c=CHARACTERS[$i++];)  // loop $c through map
    $c<1                            // if $c is a letter (integer value < 1)
        ?print$c.chr($k+65)._           // print first letter, second letter, delimiter
        :$k+=$c                         // else increase second letter
    ;

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

for(;$p<676;)                   // loop through combinations
    ord("MAPPING"[$p/6])-32>>$p%6&1     // test bit
        ?                                       // if set, do nothing
        :print chr($p/26+65).chr($p++%26+65)._; // if not, print combination+delimiter

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

Tytus
źródło