Drucken Sie alle 2 Buchstaben Scrabble-Wörter


40

Die Herausforderung:

Drucken Sie jedes in Scrabble akzeptierte 2-Buchstaben-Wort mit möglichst wenigen Bytes. Ich habe eine Textdatei Liste erstellt hier . Siehe auch unten. Es gibt 101 Wörter. Kein Wort beginnt mit C oder V. Kreative Lösungen werden empfohlen, auch wenn sie nicht optimal sind.

AA
AB
AD
...
ZA

Regeln:

  • Die ausgegebenen Wörter müssen irgendwie getrennt werden.
  • Der Fall spielt keine Rolle, sollte aber konsistent sein.
  • Leerzeichen und Zeilenumbrüche sind erlaubt. Es sollten keine anderen Zeichen ausgegeben werden.
  • Das Programm sollte keine Eingaben machen. Externe Ressourcen (Wörterbücher) können nicht verwendet werden.
  • Keine Standardlücken.

Wortliste:

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

8
Müssen die Wörter in der gleichen Reihenfolge ausgegeben werden?
Sp3000,

2
@ Sp3000 ich sag nein, wenn sich was interessantes
einfallen

2
Bitte klären Sie, was genau irgendwie als getrennt gilt . Muss es ein Leerzeichen sein? Wenn ja, wären nicht unterbrechende Leerzeichen zulässig?
Dennis


3
Vi ist kein Wort? Neuigkeiten für mich ...
jmoreno

Antworten:


39

Python 3, 194 188 Bytes

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

Auf keinen Fall die kürzeste Methode, aber ich dachte, das wäre ein guter Anfang. Versuchen Sie, jedes Paar in Pfade zu packen, indem Sie so viel wie möglich überlappen (zB "ODEX..."= ["OD", "DE", "EX", ...]). Leerzeichen werden zum Trennen von Pfaden verwendet, und Paare mit Leerzeichen werden entfernt (das nachfolgende Leerzeichen soll verhindern, Edass am Ende ein einzelnes Zeichen gedruckt wird).

Ich habe auch versucht, Regex Golf zu spielen, aber es war länger.


1
+1 schöner Ansatz! Ich habe deine Saite für eine Ruby-Antwort ausgeliehen
daniero

Ich habe auch eine Antwort basierend auf Ihrer Idee mit Bash und Regex gemacht
sergioFC

2
+1 für AYAHOYOWOMUNUHAID!
Level River St

28

CJam, 96 94 Bytes

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+

Das obige ist ein Hexdump, der mit umgekehrt werden kann xxd -r -c 16 -g 1.

Probieren Sie es online im CJam-Interpreter aus .

Abhängig davon, was genau als getrennt gilt , könnte die Byteanzahl auf 93 oder sogar 92 gesenkt werden :

  • Wenn wir ersetzen -55mit 59, werden die Wörter durch geschützte Leerzeichen (0xA0) getrennt werden.

  • Wenn wir ersetzen -55mit W, werden die Worte von at-Zeichen getrennt werden (0x40).

Idee

Wir können jedes Buchstabenpaar xy als (ord (x) - 65) × 25 + (ord (y) - 65) kodieren . 1

Anstatt die resultierenden Ganzzahlen zu speichern, speichern wir die Differenzen aller Paare, die zwei benachbarten Wörtern entsprechen (alphabetisch sortiert).

Die höchste Differenz ist 35 , also betrachten wir sie als Ziffern einer Ganzzahl zur Basis 36 und wandeln diese Ganzzahl in eine Bytefolge um.

Code

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 Da der zweite Buchstabe niemals ein Z ist , ist die Verwendung von 25 anstelle von 26 ausreichend.


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 

Auf jeden Fall keine gute Punktzahl, aber ich mochte die Herausforderung.

Ich erstelle eine Tabelle der Optionen, erstelle ein bitweises System, um zu kennzeichnen, welche Optionen gültig sind.

Bildbeschreibung hier eingeben

Dann habe ich base-36 diese Optionen codiert, um die Zeichenfolge zu erhalten:

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

Beachten Sie, dass der dritte Eintrag in diesem String-Array keinen Wert hat, da C keine Optionen hat.

Um die Werte auszudrucken, konvertiere ich einfach die gültigen Optionen in Zeichen.

Es könnte etwas geben, das ich tun könnte, um das Erkennen zu reduzieren, dass es keine Wörter gibt, die auf C, J, K, Q, V oder Z enden, aber ich kann mir keine Methode vorstellen, um es atm zu reduzieren.


Durch das Transponieren der Tabelle entstehen mehr leere Elemente, und die Daten werden etwas kompakter codiert, wodurch einige Bytes eingespart werden. Das Array wird jetzt in einer anderen Reihenfolge gedruckt:

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

Danke an Ismael für die Explosion und die Loop-Hinweise.

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

Mit einem Update auf php5.6 pow(,)können durch **Speichern weiterer 4 Bytes ersetzt werden.

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

Anstatt durch zu explodieren ",", können Sieexplode(0,UB1YB0100CUP[...])
Ismael Miguel

Würde das nicht brechen, da die Kodierung Nullen enthält?
James Webster

Allerdings gibt es keinen, den 3ich benutzen kann! Vielen Dank
James Webster

Außerdem können Sie ersetzen $e++;for($f=0;$f<26;$f++)mit for($e++,$f=0;$f<26;$f++), und jetzt können Sie die lästigen entfernen {}. Und wenn Sie Zeichen in Kleinbuchstaben umwandeln möchten, verwenden Sie $e^' '.
Ismael Miguel

Guter Fang! Ich hätte das nicht bekommen.
James Webster

8

Perl, 167 164 157 Bytes

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

Schrieb ein separates Skript, um die Buchstaben so kompakt wie möglich zu einer Zeichenfolge zusammenzufassen, die alle gültigen 2-Buchstaben-Wörter enthält. Dies iteriert dann über alle zwei Buchstabenwörter und gibt die gültigen aus, eines pro Zeile. Laufen Sie mit perl -M5.10.1 script.pl.


In einem Online-Compiler funktioniert das nicht.
mbomb007

@ mbomb007 Abhängig von der Version benötigen Sie entweder das Befehlszeilenflag -M5.10.1, um das sayin dieser Version hinzugefügte Schlüsselwort zu verwenden , oder fügen Sie es use feature 'say';im Hauptteil des Skripts hinzu.
AKHolland,

7

C 155 Bytes

Golf Version

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

Ausgabe

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

Ungolfed-Version

Die 51-Byte-Magic-Zeichenfolge in der Golfversion enthält viele Zeichen jenseits von ASCII 126, die mit ziemlicher Sicherheit in Unicode-Entsprechungen umgewandelt wurden. Die ungolfed-Version verwendet stattdessen hexadezimal und nicht als Literal, sondern als Konstante. Die ungolfed-Version trennt die Wörter außerdem mit einem Zeilenumbruch, was das Kopieren und Einfügen in Excel, das Ordnen der Liste und das Vergleichen mit der gewünschten erleichtert.

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

Erläuterung

Wenn wir die Definition des Vokals um die 8 Buchstaben AHMEIOUY erweitern, stellen wir fest, dass alle Wörter aus einem Vokal und einem anderen Buchstaben bestehen (der ein Vokal sein kann oder nicht). Daher gilt für alle Wörter, die mit einem Vokal enden, Folgendes: brauchen eine Tabelle von 26 Bytes, eines für jeden ersten Buchstaben, wobei die einzelnen Bits dem Vokal entsprechen. Wir benötigen eine ähnliche Tabelle für die Wörter, die mit einem Vokal beginnen, mit der Ausnahme, dass wir diesmal nur 25 Bytes benötigen, da es kein Wort gibt, das auf Z endet. Die beiden Tabellen werden zusammengefasst, um die endgültige Tabelle zu erstellen.

Um ASCII-Codes in der Region 0..31 zu vermeiden, werden die zwei am wenigsten gemeinsamen "Vokale" M und H dem 6. und 7. Bit zugewiesen, und die Codierung berücksichtigt 1 für ein ungültiges Wort und 0 für ein gültiges Wort. Da es keinen Konsonanten gibt, der sich mit M und H paart, kann sichergestellt werden, dass mindestens eines dieser Bits eine 1 ist.

Das achte Bit wird A zugewiesen, dem am häufigsten verwendeten Vokal, um die Nicht-ASCII-Zeichen einzugrenzen (es gibt immer noch ziemlich viele davon).

Die verwendeten Tabellen sind unten. Bei Wörtern, die 2 Vokale enthalten, wurde der erste Buchstabe als "Vokal" und der zweite Buchstabe als "Buchstabe" eingestuft. Eine Ausnahme bilden Wörter, die mit M beginnen, da hierdurch ein Konflikt zwischen MM und HM vermieden wird.

Hexadezimale Kodierung von Wörtern, die mit einem Vokal beginnen

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 

Hexadezimale Kodierung von Wörtern, die mit einem Vokal enden

 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

Machen Sie vielleicht einen Hexdump der Golf-Version, damit das Mangeln leicht
rückgängig

7

Java, 484 448 407 391 389 Bytes

Mein erster Versuch

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

Formatiert:

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

Probieren Sie es online aus


Gute Arbeit! Einige Vorschläge: java.lang.Exception kann einfach als Exception bezeichnet werden. "args" kann nur "a" sein. String.format () kann "" .format () sein. In der main () -Deklaration gibt es auch einen kleinen zusätzlichen Abstand. Insgesamt aber
netter

Ich habe gerade mit der Print-Anweisung gespielt, aber Sie haben mich geschlagen! Sie können ein weiteres Byte speichern, indem Sie es durch \nein Leerzeichen ersetzen . Sie müssen nicht durch neue Zeilen getrennt werden.
James Webster

Sie haben auch einige Leerzeichen verpasst, die Sie entfernen können.
James Webster

@ JamesWebster thx für die Hinweise.
Griflo

4
"".formatist schmerzhaft anzusehen, aber lustig.
Codebreaker

6

Ruby, 166 Bytes

Leihen Sie sich die saubere Methode von sp3000 aus , um die Wörter in eine kompakte Zeichenfolge zu kodieren. Der Kicker hier ist die kurze Methode zum Zurückdecodieren in die aus zwei Buchstaben bestehenden Wörter: Verwenden eines Vorgriffs in der Regex, die an die Scanmethode von String übergeben wurde, um überlappende Übereinstimmungen zu extrahieren, ohne Leerzeichen zu enthalten:

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

Rubin, 179 Bytes

Mein eigener Ansatz: Generiere alle aus zwei Buchstaben bestehenden Wörter zwischen AAund ZAund wähle die gültigen aus, indem du eine Base-36-codierte Bitmaske verwendest:

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

6

Matlab, 177 Bytes

Generieren Sie eine binäre Matrix, die alle zulässigen Buchstabenpaare definiert, formen Sie sie um und codieren Sie sie mit Base-64. Die Base-64-codierte Zeichenfolge ( 'CR+ ... % ') wird als Daten im Programm verwendet. Das Programm kehrt die Operationen um, um die Matrix zu entpacken, und liest dann die zulässigen Paare:

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)

2
Schön, Luis! Golfen macht eigentlich Spaß ... = P
Stewie Griffin

1
Nett! Es gibt kein Alphabet!
Brain Guider

1
Hut ab. Dies ist der kryptischste Matlab-Code, den ich seit Ewigkeiten gesehen habe ...
Hoki

Danke Leute! Es ist nur wegen der Base-64-Codierung kryptisch. Diese Zeichenfolge packt tatsächlich die 26x25-Binärmatrix der zulässigen Buchstabenpaare
Luis Mendo

6

Malbolge , 2118 Bytes

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~

Probieren Sie es online!


5

Bash, 179 Bytes

echo U`sed -r 's/./& &/g'<<<HAABADEDOEFAEHELAGOFEMAHINAISHMENERESITALOHOMMONOPAMUMYAWETOSOWOYOXUNUPEXI`F `grep -o ..<<<ANARASATAXAYBEBIBOBYJOKAKILIMIOIDOIDORPIQITIUSUTYEZA`
  • 7 Bytes dank Adam Katz Kommentar gespeichert

Es wird sedzum Ersetzen von Regex verwendet. Die erste Regex-Eingabe basiert auf der Idee von Sp3000, während die zweite Regex die allgemeine Eingabe ohne Leerzeichen verwendet.

Erläuterung:

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

1
Sie können das durch ein Leerzeichen und dann `grep -o ..anstelle `sed -r 's/ / &/g'eines Tricks aus meiner Antwort unten um sieben Bytes verkleinern .
Adam Katz

5

Achtung, diese Antwort ist programmatisch nicht interessant.

Da alle Wörter zwei Zeichen lang sind, können wir sie alle zusammenschlagen und sie dann mit einem einfachen regulären Ausdruck wieder auseinander reißen.

Jede regex-freundliche Sprache kann dies tun, manche effizienter als andere:

Grep (via Bash), 215 Bytes

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

Javascript, 224 Bytes

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

Perl, 225 Bytes

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

Python, 245 Bytes

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

 


Einige der Antworten hier sind länger als echo, was ich als Grundlinie betrachten würde:

POSIX-Shell, 307 Byte

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

3
+1 für das Praktische. In der Tat ist das Bereitstellen des Basisechos der Punkt, an dem jeder beginnen sollte.
Metalim

+1 auf einfache Antwort, aber Sie sollten das als nicht konkurrierend markieren, nicht wahr?
Matthew Roh

@MatthewRoh - Wenn es einen Parser für die Rangliste gäbe, würde er wahrscheinlich nichts finden, da ich absichtlich nicht mit einer Überschrift begonnen habe. Ich mache mir keine Sorgen, zumal es für jede Sprache, die ich gepostet habe, kürzere Antworten gibt.
Adam Katz

3

C - 228 217 Bytes - 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(""));}

Wird aktualisiert, wenn ich es kleiner bekommen kann, kompiliere es einfach mit gcc -w, ./a.out gibt es perfekt aus. Wenn Sie Interesse an einem ungolfed haben, lassen Sie es mich wissen.

Ich kann mir keine Möglichkeit vorstellen, es aus meinem Kopf heraus zu verkürzen (Sie können die Anführungszeichen in Puts technisch entfernen und Sie erhalten trotzdem eine korrekte Antwort, die Ausgabe sieht nur wie Müll aus), also lassen Sie es mich bitte wissen sowieso zu verkürzen


Hier sind ein paar Vorschläge, die für mich in Ordnung sind (nicht nur Kopieren und Einfügen, Stapeltausch fügt seltsame Steuerzeichen in Kommentare ein). _;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));}Ich habe das Trennzeichen für die Ausgabe von einer neuen Zeile in ein Leerzeichen geändert, aber wenn Sie eine neue Zeile bevorzugen (eine) extra byte) ändere das printf Format "%c%c\n"
Level River St

3

C #, 348 Bytes

Ich hatte einen Versuch:

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

4
Dies ist eine Codegolf-Herausforderung, daher solltest du deine Byteanzahl (Länge deines Codes) posten. Versuchen Sie auch, es ein wenig zu verkürzen, indem Sie beispielsweise Leerzeichen entfernen.
Jakube,

@ Jakube, ist das besser?
Jodrell

Ja, sieht in
Ordnung

3

Pyth , 140 Bytes

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

Probieren Sie es online!

Komprimierungsmethode: Da Zkein Wort an der zweiten Position steht, verwenden Sie das neu geordnete Alphabet bcdfghjklmnpqrstvwxyaeiou, um die Gültigkeit jedes dieser Buchstaben als zweiten Buchstaben für jeden ersten Buchstaben zu kodieren (die ersten Buchstaben sind alphabetisch sortiert).
Dies sind 25 Bits pro Buchstabe oder genau 5 Basis-32-Stellen. Da die meisten Konsonanten nur Vokale als zweiten Buchstaben verwenden, setze ich Vokale an das Ende, um meistens einstellige Zahlen für sie zu erhalten. Ich bin sicher, dass es insgesamt durch weitere Analyse und Neuordnung des Alphabets verbessert werden könnte, obwohl dann die Definition des neu geordneten Alphabets mehr Bytes in Anspruch nehmen würde.

Erläuterung

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)

2

PHP: 211 209 204

Sie müssen Warnungen ausschalten, sonst wird bezüglich der impliziten Erstellung von gedruckt $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++;

Sehr lustig. Frühe Versuche lagen im 250er-Bereich, aber das ist mein bisher schlankster.


2
Probieren Sie diesen Bytezähler aus . Beachten Sie, dass das Deaktivieren der Leerzeichenzählung nicht korrekt ist, da dadurch auch alle Leerzeichen in Zeichenfolgen
berücksichtigt werden.

Guter Fang. Ich habe meinen
Beitrag

Ich kann nicht verstehen, warum ... aber dies druckt jetzt nur "AAAA A ..."
James Webster

Sie haben das !auf dem If herausgenommen. Sie brauchten das.
James Webster

Richtig. Das ist mir gerade aufgefallen. Ich habe benutzt! Begrenzer früher und ich habe eine schnelle Suche-Ersetzung durchgeführt, ohne zu überlegen, was zuerst passieren würde.
NickW

2

CJam (99 Bytes)

Dies beinhaltet einige Sonderzeichen, daher ist es am sichersten, einen Hexdump zu erstellen. (Insbesondere das Zeichen mit dem Wert 0xa0, das einem nicht unterbrechenden Leerzeichen entspricht, verursachte mir einige Probleme beim Einrichten der Online-Demo.)

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

Online-Demo .

Der Ansatz ist die Differenzcodierung in Base-26.


Hinzufügen eines Zeichens zu einer ganzen Zahl ergibt sich ein Zeichen, so dass Sie ersetzen können , 65f+:cmit 'Af+.
Dennis

Wahr. Es mdist eine großartige Verbesserung, aber ich hatte nicht bemerkt, wie nah meine Antwort an Ihrer ist.
Peter Taylor

2

CJam, 100 98 Bytes

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

(Permalink)

  • Zwei Bytes über vorinitialisierte Variablen gespeichert (danke Dennis!)

Dies ist mein erster CJam-Eintrag, daher besteht wahrscheinlich das Potenzial für mehr Golf. Ich habe mir jedoch eine Möglichkeit ausgedacht, die Liste der Zeichen auf 63 Bytes zu komprimieren, was hoffentlich jemand anderes hilfreich finden wird.

Kompressionsverfahren

Bisher haben die meisten Methoden, die ich gesehen habe, beide Buchstaben jedes Wortes codiert. Wenn wir jedoch die Wörter in alphabetischer Reihenfolge eingeben, ändert sich der erste Buchstabe nicht sehr oft, sodass es verschwenderisch erscheint, ihn explizit zu codieren.

Ich codiere nur das letzte Zeichen jedes Wortes und füge ein spezielles Element ein, wenn das erste Zeichen erhöht werden soll. Die Zeichen werden als erstes Zeichen codiert, dann wird eine Liste mit Unterschieden angezeigt. Da es keine doppelten Wörter gibt, müssen die Unterschiede mindestens alle sein 1. Somit kann ich 0als Trennelement verwenden. (Beachten Sie, dass ich dann den ersten Buchstaben jeder Untersequenz als einen Index speichern muss, da es sonst zu Verwechslungen zwischen 'Rollover First Character 0' und 'Start with A 0' kommen würde.)

Da die Unterschiede in diesem Fall niemals größer als 15 sind, können wir base-16 verwenden und zwei (4-Bit-) Elemente in jedes (8-Bit-) Byte packen. (Im aktuellen Code habe ich von Base-260 anstatt Base-256 konvertiert, um Probleme mit nicht druckbaren Zeichen zu vermeiden.)


Sie können ein paar Bytes speichern, indem Sie Gund verwenden und N16 und einen Zeilenvorschub drücken.
Dennis

@Dennis Danke, habe nicht erkannt, dass Variablen vorinitialisiert wurden!
2012rcampion

1
Alle 26 Großbuchstaben sind vorinitialisierte Variablen. Die vollständige Liste sehen Sie hier .
Dennis

Sie können mehr Bytes speichern durch Ersetzen %-3<mit /;;oder sogar /&. (Die zweite Option generiert eine Fehlermeldung. Konsens über Meta ist, dass es in Ordnung ist, dies zu tun.)
Dennis

2

Brainfuck , 1371 Bytes

Ziemlich golfen, aber ich habe nicht zu viel Mühe darauf verwendet.

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

Probieren Sie es online!


Zum einen können Sie die Zeilenumbrüche loswerden
Jo King,

@JoKing es gibt keine wirkliche Möglichkeit, jemanden zu übertreiben, ich glaube nicht, dass es viel Sinn macht, ein paar Bytes in diesem großen Maßstab zu entfernen.
Krzysztof Szewczyk

2

Zsh, 175 Bytes

Diese Lösung verwendet eine Zeichenfolge mit 125 Zeichen, wobei die Kleinbuchstaben als Begrenzer und der erste Buchstabe der folgenden Folge von Großbuchstaben dienen.

Wir durchlaufen die Buchstaben von $L. Wenn der aktuelle Buchstabe $Xim ASCII-Vergleich in Kleinbuchstaben geschrieben ist, setzen Sie ihn $Wauf $X. Andernfalls drucken Sie $Wverkettet mit $X, um das aktuelle Wort zu erstellen.

Probieren Sie es online!

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

Edit: hängten :lzu Satz Kleinbuchstaben durchgängig, pro Anforderung
EDIT2: -4 Bytes , die mit $Xvariablen und vereinfacht , wenn [[..]]Bedingung
Edit3: -4 Bytes , die durch das Entfernen Anführungszeichen ( ")
Edit5: -5 - Bytes anstelle Array Umwandlung von iterieren Lpro unten
Edit4: alternativer Ansatz für 182 Bytes , die umkehrbare Zeichenfolgen in den ersten 33 Buchstaben ausnutzen, $Lsind nur 107 Buchstaben

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

2

Stax , 91 Bytes

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

Führen Sie es aus und debuggen Sie es

Der einzige nette Trick, den diese Antwort verwendet, ist die Verwendung des Tokens ",", um eine Änderung im ersten Buchstaben anzuzeigen, anstatt sie für jedes Wort zu speichern.

Vielen Dank an recursive für die Idee, den Operator m zu verwenden


Schön gemacht. Es gibt ein paar kleine Optimierungen, die ich sehen kann. Verwenden Sie Manstelle von 1/und eine Kurzübersicht manstelle von foreach und print { ... PF. Dieser packt bis 89.
rekursiv

1

Python 3, 224 Bytes

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

Verwendet Bitmasken variabler Länge, um zu kodieren, welche zweiten Buchstaben für jeden möglichen ersten Buchstaben existieren. Die Bitmasken können 0,1,3,7,15 oder 31 Bits lang sein. Bits werden Buchstaben mit zugeordnet for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':, frühere Bits werden für häufigere Buchstaben verwendet, so dass die Bitmasken in den meisten Fällen kurz sein können (normalerweise 3 oder 7 Bits, da auf die meisten Konsonanten nur einer von 5 Vokalen oder YM oder H folgt). Leider macht der Code zum Dekodieren die Einsparungen im Vergleich zu einfacheren Methoden zunichte (die ursprüngliche Liste enthält nur 303 Bytes).


1
Ich habe festgestellt, dass es in meiner Lösung besser ist, für jeden möglichen zweiten Buchstaben den ersten Buchstaben zu codieren . Könnte einen Versuch wert sein.
James Webster

1

Haskell, 192 Bytes

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"

Für jedes durch Leerzeichen getrennte Wort in der Zeichenfolge setzen Sie den ersten Buchstaben vor alle anderen Buchstaben und fügen Sie ein Leerzeichen ein, z . B. SHIO-> SH SI SO.


1

Java, 334 Bytes

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

Formatiert:

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

Separat habe ich die Wortliste in eine Länge von 26 x 26 = 676 BitSet codiert, sie in ein Byte-Array konvertiert und schließlich in Base 64. Diese Zeichenfolge ist in diesem Programm fest codiert, und die umgekehrte Prozedur wird verwendet, um das BitSet zu reproduzieren. und schließlich die Liste der Wörter ausdrucken


1

Java, 356 Bytes

Verwendet den Zufallszahlengenerator, um die folgenden Wörter zu erhalten:

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

Sie können es hier ausprobieren: http://ideone.com/Qni32q


1

Perl, 248 Bytes

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

Das erste Mal mit Perl (und das erste Mal mit Golfspielen), also gibt es definitiv Raum für Verbesserungen. Berücksichtigen Sie die Vokale und gruppieren Sie die verbleibenden Buchstaben basierend auf der Erstellung des resultierenden Wortes. Fügen Sie den Vokal zuerst, den letzten oder beide Vokale zuerst und den letzten hinzu, und erstellen Sie ein Wort in der Liste.


Ich kenne Perl nicht, aber ich gehe davon aus, dass Sie die Ausgabe durch Leerzeichen trennen. Es scheint, "MM "."MY "."BY "."HM "."SH "könnte zu verkürzt werden "MM MY BY HM SH".
Level River St

@steveverrill Danke! Ich war so in den Rest des Codes verstrickt, dass ich übersah, wie überflüssig das war.
VoiceOfFolly

1

Javascript (ES6), 214

Vielleicht nicht der kürzeste Weg, aber auf jeden Fall interessant.

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

Durchläuft jeden Buchstaben in der ersten Zeichenfolge und fügt ihn jedem Buchstaben in der entsprechenden Zeile der zweiten hinzu. Dies gibt die Wörter in der Reihenfolge ihres letzten Buchstabens wie folgt zurück:

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

Vorschläge willkommen!


1

Java, 255 254 Bytes

Es wurde ein Weg gefunden, ein weiteres Byte daraus zu quetschen.

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

Oder (wenn auch nicht viel klarer):

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

Sie können zwei Bytes sparen, indem Sie beide Vorkommen von 'A'in ändern 65.
ProgramFOX

1

Haskell, 333 308 298 Bytes

Nur zum Spaß!

Das Auswerten sgibt alle Wörter in einer seltsamen Reihenfolge aus - ich habe die Tatsache ausgenutzt, dass die meisten Kombinationen Vokalkonsonanten sind oder umgekehrt. Mit benutzerdefinierten Zeichen "Klassen" könnte wahrscheinlich eine noch stärkere Optimierung erzielt werden, wodurch die codierte Matrix (hier wund hier) verkürzt wirdk ) .

Kennt jemand eine kürzere Methode zum Drucken von Zeichenfolgen ohne Anführungszeichen und Klammern als meine monadische? Typenklassen sind, soweit ich das beurteilen kann, noch länger.

Es könnte auch einen kürzeren Weg geben p, seine Arbeit zu erledigen ...

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

Ist das nicht sequence_dasselbe wie void$sequence? Dann können Sie auch das weglassen import.
nimi

Das ist komisch verpackt, aber ja. Vielen Dank!
Leif Willerts

Ist nicht, voidmusste importiert werden. Wie auch immer, ich werde / muss mich daran erinnern.
Leif Willerts

1
Ah und sequence_$map putStrLnist mapM_ putStrLn. Ersetzen Sie die (, )um concat$...mit einem anderen $.
nimi

1

05AB1E , 143 Bytes (nicht konkurrierend)

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

Probieren Sie es online!



1
@ KevinCruijssen 91 (und ich bin sicher, dass diese Methode niedriger werden kann, aber ich habe die Wörter des Wörterbuchs für Humor von Hand ausgewählt).
Grimmy

1

PHP, 170 Bytes

kürzester Ansatz, den ich bisher finden konnte ...

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

Nervenzusammenbruch

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
    ;

Hinweis Die kürzeste Bit-Mapping-Version mit druckbarem ASCII kostet 190 Byte (113 Byte Daten + 77 Byte Dekodierung) bei 6 Bit = Basis 64, 174 Byte (97 Daten, 77 Bit Dekodierung) bei 7 Bit (Basis 128); möglicherweise noch etwas mehr für die Flucht.

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

Die Basis 224 (unter Verwendung von ASCII 32..255) benötigt 87 Bytes Daten (+ Escaping); aber ich vermute, die dekodierung kostet mehr als 10 bytes extra.
Das Ausschließen von C und V von der Karte würde 16/14/13 Bytes an Daten einsparen, aber viel bei der Decodierung kosten.

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.