Stampa tutte le 2 lettere di Scrabble


40

La sfida:

Stampa ogni 2 lettere accettabili in Scrabble usando il minor numero di byte possibile. Ho creato un elenco di file di testo qui . Vedi anche sotto. Ci sono 101 parole. Nessuna parola inizia con C o V. Le soluzioni creative, anche se non ottimali, sono incoraggiate.

AA
AB
AD
...
ZA

Regole:

  • Le parole emesse devono essere separate in qualche modo.
  • Il caso non ha importanza, ma dovrebbe essere coerente.
  • Sono consentiti spazi finali e newline. Nessun altro personaggio dovrebbe essere emesso.
  • Il programma non dovrebbe ricevere alcun input. Le risorse esterne (dizionari) non possono essere utilizzate.
  • Nessuna scappatoia standard.

Elenco di parole:

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
Le parole devono essere emesse nello stesso ordine?
Sp3000,

2
@ Sp3000 Dirò di no, se si può pensare a qualcosa di interessante
qwr

2
Si prega di chiarire ciò che conta esattamente come separato in qualche modo . Deve essere uno spazio bianco? In tal caso, sarebbero consentiti spazi non interrotti?
Dennis,

5
Ok, ho trovato una traduzione
Mikey Mouse,

3
Vi non è una parola? Notizie per me ...
jmoreno,

Risposte:


39

Python 3, 194 188 byte

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

Quasi sicuramente non è il metodo più breve, ma ho pensato che sarebbe stato un buon inizio. Cerca di impacchettare ogni coppia in percorsi sovrapponendoli il più possibile (ad es. "ODEX..."= ["OD", "DE", "EX", ...]). Gli spazi vengono utilizzati per separare i percorsi e tutte le coppie con uno spazio al suo interno vengono rimosse (lo spazio finale serve per impedire che un singolo Evenga stampato alla fine).

Ho anche provato il golf regex, ma è stato più lungo.


1
+1 bel approccio! Ho
preso in

Ho anche fatto una risposta in base alla tua idea usando bash e regex
sergioFC

2
+1 per AYAHOYOWOMUNUHAID!
Level River St

28

CJam, 96 94 byte

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

Quanto sopra è un dump esadecimale, che può essere invertito con xxd -r -c 16 -g 1.

Provalo online nell'interprete CJam .

A seconda di ciò che conta esattamente come separato in qualche modo , il conteggio dei byte potrebbe essere ridotto a 93 o addirittura 92 :

  • Se sostituiamo -55con 59, le parole saranno separate da spazi non interrotti (0xA0).

  • Se sostituiamo -55con W, le parole saranno separate da un segno (0x40).

Idea

Possiamo codificare ogni coppia di lettere xy come (ord (x) - 65) × 25 + (ord (y) - 65) . 1

Invece di memorizzare gli interi risultanti, memorizzeremo le differenze di tutte le coppie che corrispondono a due parole adiacenti (in ordine alfabetico).

La differenza più alta è 35 , quindi li consideriamo cifre di un intero 36 di base e convertiamo quel numero intero in una stringa di byte.

Codice

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 Poiché la seconda lettera non è mai una Z , è sufficiente usare 25 anziché 26 .


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 

Sicuramente non è un ottimo punteggio, ma la sfida mi è piaciuta.

Creo una tabella delle opzioni, ho creato un sistema bit per contrassegnare quali opzioni sono valide.

inserisci qui la descrizione dell'immagine

Quindi ho base-36 codificato quelle opzioni per ottenere la stringa:

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

Nota la terza voce in quella matrice di stringhe non ha un valore, perché C non ha opzioni.

Per stampare i valori, ho appena convertito le opzioni valide in caratteri.

Potrebbe esserci qualcosa che potrei fare per ridurre il riconoscimento del fatto che non ci sono parole che terminano in C, J, K, Q, V o Z, ma non riesco a pensare a un metodo per ridurlo.


Trasponendo la tabella, ci sono più elementi vuoti e i dati codificano un po 'più compatti che si sono rasati di pochi byte. L'array è ora stampato in un ordine diverso:

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

Grazie a Ismael per l'esplosione e per i suggerimenti sul loop.

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

Con un aggiornamento a php5.6, pow(,)può essere sostituito **salvando altri 4 byte.

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

Invece di esplodere ",", puoi usareexplode(0,UB1YB0100CUP[...])
Ismael Miguel il

Non si romperà dato che ci sono 0 nella codifica?
James Webster,

Tuttavia .. non c'è un 3che posso usare quello! Grazie
James Webster,

Inoltre, è possibile sostituire $e++;for($f=0;$f<26;$f++)con for($e++,$f=0;$f<26;$f++), e ora è possibile rimuovere quelli fastidiosi {}. E se vuoi convertire i caratteri in minuscolo, usa $e^' '.
Ismael Miguel,

Buona pesca! Non l'avrei preso.
James Webster,

8

Perl, 167 164 157 byte

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

Scritto uno script separato per raggruppare le lettere il più compatto possibile in una stringa che conteneva tutte le parole valide di 2 lettere. Questo quindi scorre su tutte le parole di due lettere e stampa quelle valide, una per riga. Corri con perl -M5.10.1 script.pl.


Non riesco a farlo funzionare in un compilatore online.
mbomb007,

@ mbomb007 A seconda della versione, è necessario il flag della riga di comando -M5.10.1per utilizzare la sayparola chiave aggiunta in quella versione o aggiungerla use feature 'say';nel corpo dello script.
AKHolland,

7

C, 155 byte

Versione golfizzata

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

Produzione

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

Versione Ungolfed

La stringa magica da 51 byte nella versione golfata contiene molti caratteri oltre ASCII 126, che sono stati quasi certamente trasformati in equivalenti Unicode. La versione ungolfed usa invece hex, e come costante anziché letterale. Inoltre, la versione ungolfed separa le parole con una nuova riga, il che rende più semplice copiare e incollare in Excel, ordinare l'elenco e confrontarlo con quello richiesto.

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

Spiegazione

Se espandiamo la definizione di vocale per includere le 8 lettere AHMEIOUY, osserviamo che tutte le parole sono costituite da una vocale e da un'altra lettera (che può essere o meno una vocale). Pertanto, per tutte le parole che terminano in una vocale, noi è necessaria una tabella di 26 byte, una per ogni prima lettera, con i singoli bit corrispondenti alla vocale. Abbiamo bisogno di una tabella simile per le parole che iniziano con una vocale, tranne per il fatto che questa volta abbiamo bisogno solo di 25 byte, poiché non c'è una parola che termina in Z. Le due tabelle sono sfogliate insieme per creare il tavolo finale.

Per evitare qualsiasi codice ASCII nella regione 0..31, le due "vocali" meno comuni M e H sono assegnate al 6 ° e 7 ° bit e la codifica considera 1 per una parola non valida e 0 per una parola valida. Poiché non esiste una consonante che si accoppia con M e H, è possibile assicurarsi che almeno uno di questi bit sia 1.

L'ottavo bit è assegnato ad A, che è la vocale più comune, per cercare di limitare i caratteri non ASCII (ancora ce ne sono molti.)

Le tabelle utilizzate sono di seguito. Per le parole contenenti 2 vocali, ho dato la priorità alla prima lettera come considerata "vocale" e la seconda lettera come "lettera". Un'eccezione a ciò sono le parole che iniziano con M, in quanto ciò evita uno scontro tra MM e HM.

Codifica esadecimale di parole che iniziano con una vocale

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 

Codifica esadecimale di parole che terminano con una vocale

 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

Magari crea una discarica esadecimale della versione golfata in modo tale da poter facilmente ripristinare la
manomissione

7

Java, 484 448 407 391 389 byte

Il mio primo tentativo

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

formattato:

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

Provalo online


Bel lavoro! Alcuni suggerimenti: java.lang.Exception può essere chiamato semplicemente eccezione. "args" può essere solo "a". String.format () può essere "" .format (). C'è anche un po 'di spazio in più nella dichiarazione main (). Bel approccio comunque, +1 da parte mia :)
jrich

Ho appena giocato con la dichiarazione stampata, ma mi hai battuto! È possibile salvare un altro byte sostituendolo \ncon solo uno spazio. Non devono essere separati da nuove linee.
James Webster,

Hai anche perso alcuni spazi che puoi rimuovere.
James Webster,

@JamesWebster thx per i suggerimenti.
griFlo,

4
"".formatè doloroso da guardare, ma divertente.
codebreaker

6

Rubino, 166 byte

Prendendo in prestito il metodo accurato di sp3000 per codificare le parole in una stringa compatta. Il kicker qui è il metodo breve per decodificarlo in parole di due lettere: usare un lookahead nella regex passato al metodo di scansione di String per estrarre le partite sovrapposte, senza contare lo spazio:

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

Rubino, 179 byte

Il mio approccio: genera tutte le parole di due lettere tra AAe ZAe seleziona quelle valide usando una maschera di bit codificata in base 36:

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

6

Matlab, 177 byte

Genera una matrice binaria che definisce tutte le coppie di lettere consentite, rimodellala e codifica in base 64. La stringa codificata in base 64 ( 'CR+ ... % ') viene utilizzata come dati nel programma. Il programma inverte le operazioni per decomprimere la matrice e quindi legge le coppie consentite:

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
Bello Luis! Il golf è in realtà un po 'divertente ... = P
Stewie Griffin

1
Bello! Non c'è alfabeto!
Brain Guider

1
giù i cappelli. Questo è il codice matlab più criptico che abbia mai visto in epoche ...
Hoki

Grazie ragazzi! È solo criptico a causa della codifica base-64. Quella stringa racchiude effettivamente la matrice binaria 26x25 delle coppie di lettere consentite
Luis Mendo,

6

Malbolge , 2118 byte

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

Provalo online!


5

Bash, 179 byte

echo U`sed -r 's/./& &/g'<<<HAABADEDOEFAEHELAGOFEMAHINAISHMENERESITALOHOMMONOPAMUMYAWETOSOWOYOXUNUPEXI`F `grep -o ..<<<ANARASATAXAYBEBIBOBYJOKAKILIMIOIDOIDORPIQITIUSUTYEZA`
  • Salvato 7 byte grazie al commento di Adam Katz

Usa sedper fare la sostituzione regex. Il primo input regex si basa sull'idea Sp3000 mentre il secondo regex utilizza input comuni senza spazi.

Spiegazione:

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
Puoi ridurlo di sette byte usando uno spazio e poi `grep -o ..al posto di `sed -r 's/ / &/g', un trucco dalla mia risposta qui sotto.
Adam Katz,

5

Attenzione, questa risposta non è interessante a livello di programmazione.

Dato che tutte le parole sono lunghe due caratteri, possiamo romperle tutte insieme e poi separarle di nuovo usando una semplice espressione regolare.

Qualsiasi linguaggio adatto alla regex può farlo, alcuni in modo più efficiente di altri:

Grep (via Bash), 215 byte

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

Javascript, 224 byte

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

Perl, 225 byte

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

Python, 245 byte

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

 


Come nota, alcune delle risposte qui sono più lunghe di echo , che considererei una base:

Shell POSIX, 307 byte

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

3
+1 per essere pratico. Davvero, fornire l'eco di base è il punto da cui tutti dovrebbero partire.
metalim,

+1 sulla risposta facile, ma dovresti contrassegnarlo come non competitivo, non è vero?
Matthew Roh,

@MatthewRoh - Se ci fosse un parser per la classifica, probabilmente non riuscirebbe a trovare nulla dal momento che intenzionalmente non ho iniziato con un'intestazione. Non sono preoccupato, soprattutto perché ci sono risposte più brevi per ogni lingua che ho pubblicato.
Adam Katz,

3

C - 228 217 byte - GCC

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

Si aggiorna se riesco a rimpicciolirlo, basta compilare perfettamente con gcc -w, ./a.out output. Se c'è qualche interesse per un non golfizzato, fammi sapere.

Non riesco a pensare ad alcun modo per accorciarlo dalla parte superiore della mia testa, (puoi rimuovere tecnicamente le virgolette in put e otterrai comunque una risposta corretta, l'output sembra solo spazzatura) quindi per favore fammi sapere di comunque per accorciarlo


Ecco alcuni suggerimenti, funziona bene per me (non solo copia e incolla, lo scambio di stack inserisce strani caratteri di controllo nei commenti) _;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));}Ho cambiato il delimitatore di output da una nuova riga a uno spazio, ma se preferisci una nuova riga (una byte extra) cambia la stringa del formato printf in"%c%c\n"
Level River St

3

C #, 348 byte

Ho provato:

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
Questa è una sfida di codegolf, quindi dovresti pubblicare il numero di byte (lunghezza del codice). Prova anche ad accorciarlo un po ', ad esempio rimuovendo gli spazi bianchi.
Jakube,

@Jakube, va meglio?
Jodrell,

Sì, sembra ok
Jakube

3

Pyth , 140 byte

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

Provalo online!

Metodo di compressione: poiché non è presente Znella seconda posizione di una parola, utilizzare l'alfabeto riordinato bcdfghjklmnpqrstvwxyaeiouper codificare la validità di ciascuna di quelle lettere come seconda lettera per ogni prima lettera (le prime lettere sono in ordine alfabetico).
Sono 25 bit per lettera, o esattamente 5 cifre Base-32. Poiché la maggior parte delle consonanti prende solo le vocali come seconda lettera, ho messo le vocali alla fine per ottenere principalmente numeri a 1 cifra. Sono sicuro che potrebbe essere complessivamente migliorato da ulteriori analisi e riordino dell'alfabeto, anche se la definizione dell'alfabeto riordinato richiederebbe più byte.

Spiegazione

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

È necessario disattivare gli avvisi, altrimenti si stamperà per quanto riguarda la creazione implicita di $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++;

Molto divertente. I primi tentativi furono nella gamma 250, ma questo è il mio più sottile.


2
Prova questo contatore di byte . Si noti che la disattivazione del conteggio degli spazi bianchi non è corretta, poiché sconta anche gli spazi presenti nelle stringhe, quindi il punteggio dovrebbe essere superiore a 186.
Sp3000

Buona pesca. Ho aggiornato la mia richiesta di conseguenza
NickW

Non riesco a capire perché .. ma questo ora stampa solo "AAAA A ..."
James Webster,

Hai eliminato !il se ... ne avevi bisogno.
James Webster,

Destra. L'ho appena notato. Stavo usando! delimitatore in precedenza e ho fatto una rapida ricerca di sostituzione senza considerare cosa sarebbe successo prima.
Nick

2

CJam (99 byte)

Questo include alcuni caratteri speciali, quindi è più sicuro dare una discarica. (In particolare, il personaggio con valore 0xa0, corrispondente a uno spazio non-break, mi ha causato un bel po 'di problemi nell'impostare la demo 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 .

L'approccio è la codifica delle differenze in base-26.


L'aggiunta di un carattere a un numero intero produce un carattere, quindi puoi sostituirlo 65f+:ccon 'Af+.
Dennis,

Vero. Ed mdè un miglioramento geniale, ma non mi ero reso conto di quanto la mia risposta fosse vicina alla tua.
Peter Taylor,

2

CJam, 100 98 byte

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

(Permalink)

  • Salvato due byte tramite variabili preinizializzate (grazie Dennis!)

Questa è la mia prima voce su CJam, quindi c'è probabilmente il potenziale per giocare a golf. Tuttavia, ho trovato un modo per comprimere l'elenco di caratteri fino a 63 byte che, si spera, qualcun altro troverà utile.

Metodo di compressione

Finora la maggior parte dei metodi che ho visto codificavano entrambe le lettere di ogni parola. Tuttavia, quando mettiamo le parole in ordine alfabetico, la prima lettera non cambia molto spesso, quindi sembra inutile codificarla esplicitamente.

Codifico solo l'ultimo carattere di ogni parola e includo un elemento speciale ogni volta che il primo carattere dovrebbe aumentare. I personaggi sono codificati come primo carattere, quindi un elenco di differenze. Poiché non ci sono parole duplicate, le differenze devono essere almeno tutte 1. Quindi posso usare 0come elemento separatore. (Nota che devo quindi memorizzare la prima lettera di ogni sottosequenza come indicizzata, altrimenti ci sarebbe confusione tra 'rollover primo carattere 0' e 'inizia con A 0'.)

Poiché le differenze in questo caso non sono mai superiori a 15, possiamo usare base-16 e impacchettare due elementi (a 4 bit) in ogni byte (a 8 bit). (Nel codice effettivo ho convertito da base-260 anziché base-256 per evitare problemi con caratteri non stampabili.)


È possibile salvare un paio di byte utilizzando Ge N, che invia 16 e un avanzamento riga.
Dennis,

@Dennis Grazie, non avevo capito che le variabili erano preinizializzate!
2012campo

1
Tutte le 26 lettere maiuscole sono variabili preinizializzate. Puoi vedere l'elenco completo qui .
Dennis,

È possibile salvare più byte sostituendo %-3<con /;;o anche /&. (La seconda opzione genererà un messaggio di errore. Il consenso sulla meta è che è OK farlo.)
Dennis

2

Brainfuck , 1371 byte

Abbastanza golfabile, ma non ci ho fatto troppi sforzi.

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

Provalo online!


Bene, per prima cosa, puoi sbarazzarti delle nuove linee
Jo King il

@JoKing non c'è modo reale di superare in astuzia qualcuno, non credo abbia molto senso radersi un paio di byte su questa grande scala.
Krzysztof Szewczyk,

2

Zsh, 175 byte

Questa soluzione utilizza una stringa di 125 caratteri, in cui le lettere minuscole fungono da delimitatori e la prima lettera della seguente sequenza di lettere maiuscole.

Esaminiamo le lettere di $L. Se la lettera corrente $Xè minuscola per confronto ASCII, impostare $Wsu $X. Altrimenti, stampa $Wconcatenata con $Xper rendere la parola corrente.

Provalo online!

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

Modifica: aggiunto :lper impostare le
lettere $X[[..]] minuscole in modo coerente, per requisito Modifica2: -4 byte usando variabile e semplificata se condizione
Modifica3: -4 byte rimuovendo le virgolette ( ")
Modifica 5: -5 byte usando la conversione di array invece di L ripetere per sotto
Modifica4: Approccio alternativo per 182 byte , sfruttando stringhe reversibili nelle prime 33 lettere, $Lsono solo 107 lettere

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

2

Stax , 91 byte

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

Esegui ed esegui il debug

L'unico trucco che questa risposta usa è usare il token "," per mostrare una modifica nella prima lettera, anziché memorizzarla per ogni parola.

Grazie a ricorsivo per l'idea di utilizzare l'operatore m


Ben fatto. Ci sono un paio di piccole ottimizzazioni che posso vedere. Utilizzare Minvece di 1/e utilizzare una mappa abbreviata manziché esplicita foreach e stampa { ... PF. Questo vale per 89.
ricorsivo il

1

Python 3, 224 byte

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

Utilizza maschere di bit di lunghezza variabile per codificare quali seconde lettere esistono per ogni possibile prima lettera. Le maschere di bit possono essere lunghe 0,1,3,7,15 o 31 bit. I bit vengono mappati su lettere con for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':, i bit precedenti vengono utilizzati per lettere più comuni in modo che le maschere di bit possano essere brevi nella maggior parte dei casi (di solito 3 o 7 bit poiché la maggior parte delle consonanti sono seguite solo da una delle 5 vocali o YM o H). Sfortunatamente il codice per decodificarlo nega i risparmi rispetto a metodi più semplici (l'elenco originale è di soli 303 byte).


1
Ho scoperto che è meglio codificare quale prima lettera esiste per ogni possibile seconda lettera nella mia soluzione. Potrebbe valere la pena provare nel tuo.
James Webster,

1

Haskell, 192 byte

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

Per ogni parola separata da spazio nella stringa metti la prima lettera davanti a tutte le altre lettere e aggiungi uno spazio, ad es. SHIO-> SH SI SO.


1

Java, 334 byte

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

formattato:

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

Separatamente, ho codificato l'elenco di parole in una lunghezza 26x26 = 676 BitSet, l'ho convertito in un array di byte e infine in Base 64. Quella stringa è codificata in questo programma e la procedura inversa viene utilizzata per riprodurre BitSet, e infine stampare l'elenco delle parole


1

Java, 356 byte

Utilizza il generatore di numeri casuali per ottenere le parole:

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

Puoi provarlo qui: http://ideone.com/Qni32q


1

Perl, 248 byte

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

La prima volta che usi il perl (e la prima volta a giocare a golf), quindi c'è sicuramente margine di miglioramento. Fattorizza le vocali e raggruppa le lettere rimanenti in base al modo in cui è stata creata la parola risultante - aggiungendo prima la vocale, l'ultima o entrambe le vocali prima e l'ultima crea una parola nell'elenco.


Non conosco Perl, ma suppongo che tu stia separando l'output per spazi. Sembra che "MM "."MY "."BY "."HM "."SH "potrebbe essere abbreviato "MM MY BY HM SH".
Level River St

@steveverrill Grazie! Sono stato così preso dal resto del codice che ho trascurato quanto fosse ridondante.
VoiceOfFolly

1

Javascript (ES6), 214

Forse non è il modo più breve per farlo, ma sicuramente interessante.

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

Passa attraverso ogni lettera della prima stringa, aggiungendola a ciascuna lettera nella riga corrispondente della seconda. Questo restituisce le parole in ordine dell'ultima lettera, in questo modo:

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

Suggerimenti benvenuti!


1

Java, 255 254 byte

Ho trovato un modo per comprimerne un altro byte.

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

O (anche se non molto più chiaro):

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

È possibile salvare due byte modificando entrambe le occorrenze di 'A'in 65.
Programma FOX

1

Haskell, 333 308 298 byte

Solo per divertimento!

La valutazione sstamperà tutte le parole in uno strano ordine - ho usato il fatto che la maggior parte delle combinazioni sono consonanti vocaliche o viceversa, probabilmente potrei ottimizzare ancora di più con le "classi" di caratteri personalizzati, accorciando la matrice codificata (qui we k).

Qualcuno conosce un modo più breve per stampare stringhe senza virgolette e parentesi rispetto a quello monadico? Le classi di tipo sono ancora più lunghe per quanto posso dire.

Inoltre, potrebbe esserci anche un modo più breve di fare pil lavoro ...

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

Non è sequence_lo stesso di void$sequence? Quindi puoi omettere anche il import.
nimi,

Stranamente confezionato, ma sì. Grazie!
Leif Willerts,

Non è necessario, è voidstato importato. Comunque, dovrò ricordare questo.
Leif Willerts,

1
Ah, e lo sequence_$map putStrLnè mapM_ putStrLn. Sostituisci il (, in )giro concat$...con un altro $.
nimi,

1

05AB1E , 143 byte (non competitivi)

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

Provalo online!



1
@KevinCruijssen 91 (e sono sicuro che questo metodo può abbassarsi, ma ho scelto a mano le parole del dizionario per umorismo).
Grimmy,

1

PHP, 170 byte

l'approccio più breve che ho trovato finora ...

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

abbattersi

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
    ;

Nota La versione di mappatura dei bit più breve con ASCII stampabile costa 190 byte (113 byte dati + 77 byte decodifica) utilizzando 6 bit = base 64, 174 byte (97 dati, 77 decodifica) utilizzando 7 bit (base 128); forse un po 'di più per fuggire.

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

La base 224 (usando ascii 32..255) prende 87 byte di dati (+ escape); ma immagino che la decodifica costerà più di 10 byte in più.
Escludere C e V dalla mappa risparmierebbe 16/14/13 byte sui dati ma costa molto nella decodifica.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.