Imprimer les 2 lettres du Scrabble Words

40

Le défi:

Imprimez tous les mots de 2 lettres acceptables dans Scrabble en utilisant le moins d'octets possible. J'ai créé une liste de fichiers texte ici . Voir aussi ci-dessous. Il y a 101 mots. Aucun mot ne commence par C ou V. Creative, même non optimales, les solutions sont encouragées.

AA
AB
AD
...
ZA

Règles:

  • Les mots sortis doivent être séparés d'une manière ou d'une autre.
  • Le cas n'a pas d'importance, mais devrait être cohérent.
  • Les espaces de fin et les nouvelles lignes sont autorisés. Aucun autre caractère ne doit être sorti.
  • Le programme ne doit prendre aucune entrée. Les ressources externes (dictionnaires) ne peuvent pas être utilisées.
  • Aucune échappatoire standard.

Liste de mots:

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
la source
8
Les mots doivent-ils être sortis dans le même ordre?
Sp3000
2
@ Sp3000 Je dirai non, si quelque chose d'intéressant peut être imaginé
qwr
2
S'il vous plaît clarifier ce qui compte exactement comme séparé en quelque sorte . Est-ce que cela doit être un espace? Dans l'affirmative, des espaces insécables seraient-ils autorisés?
Dennis
5
Ok, a trouvé une traduction
Mikey Mouse
3
Vi n'est pas un mot? Nouvelles à moi ...
jmoreno

Réponses:

39

Python 3, 194 188 octets

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

Ce n’est certainement pas la méthode la plus courte, mais j’ai pensé que ce serait un bon début. Essayez de compresser chaque paire dans des chemins en superposant autant que possible (par exemple "ODEX..."= ["OD", "DE", "EX", ...]). Les espaces sont utilisés pour séparer les chemins et toutes les paires contenant un espace sont supprimées (l'espace de fin est d'empêcher qu'un seul Esoit imprimé à la fin).

J'ai aussi essayé le regex, mais c'était plus long.

Sp3000
la source
1
+1 belle approche! J'ai emprunté votre chaîne pour une réponse Ruby
daniero
J'ai également fait une réponse basée sur votre idée en utilisant bash et regex
sergioFC
2
+1 pour AYAHOYOWOMUNUHAID!
Level River St
28

CJam, 96 94 octets

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+

Ce qui précède est un hexdump, qui peut être inversé avec xxd -r -c 16 -g 1.

Essayez-le en ligne dans l' interprète CJam .

En fonction de ce qui compte exactement comme séparé d'une manière ou d'une autre , le nombre d'octets pourrait être abaissé à 93 ou même à 92 :

  • Si nous remplaçons -55par 59, les mots seront séparés par des espaces insécables (0xA0).

  • Si nous remplaçons -55par W, les mots seront séparés par des signes at (0x40).

Idée

Nous pouvons coder chaque paire de lettres xy sous la forme (ord (x) - 65) × 25 + (ord (y) - 65) . 1

Au lieu de stocker les entiers résultants, nous stockons les différences de toutes les paires qui correspondent à deux mots adjacents (triés par ordre alphabétique).

La différence la plus élevée est de 35 ; nous les considérons donc comme les chiffres d'un entier de base 36 et convertissons cet entier en une chaîne d'octets.

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 La seconde lettre n'étant jamais un Z , utiliser 25 au lieu de 26 suffit.

Dennis
la source
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 

Pas vraiment un bon score, mais j'ai aimé le défi.

Je crée un tableau des options, créé un système au niveau du bit pour indiquer quelles options sont valides.

enter image description here

Ensuite, j'ai codé ces options en base 36 pour obtenir la chaîne:

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

Notez que la 3ème entrée de ce tableau de chaînes n'a pas de valeur, car C n'a pas d'options.

Pour imprimer les valeurs, je viens de convertir les options valides en caractères.

Je pourrais peut-être faire quelque chose pour éviter de reconnaître qu'il n'y a pas de mots qui se terminent par C, J, K, Q, V ou Z, mais je ne peux pas penser à une méthode pour le réduire en atm.


En transposant la table, il y a plus d'éléments vides et les données codent un peu plus compactement, ce qui permet de supprimer quelques octets. Le tableau est maintenant imprimé dans un ordre différent:

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

Merci à Ismael pour l'explosion et les astuces de boucle.

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

Avec une mise à jour de php5.6, pow(,)peut être remplacé en **sauvegardant 4 octets supplémentaires .

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
la source
Au lieu d'exploser ",", vous pouvez utiliserexplode(0,UB1YB0100CUP[...])
Ismael Miguel
Est-ce que ça ne casse pas puisqu'il y a des 0 dans l'encodage?
James Webster
Cependant .. il n'y a pas de 3je peux utiliser ça! Merci
James Webster
En outre, vous pouvez remplacer $e++;for($f=0;$f<26;$f++)par for($e++,$f=0;$f<26;$f++), et maintenant vous pouvez supprimer ces embêtants {}. Et si vous voulez convertir les caractères en minuscules, utilisez $e^' '.
Ismael Miguel
Bonne prise! Je n'aurais pas eu celui-là.
James Webster
8

Perl, 167 164 157 octets

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

A écrit un script séparé pour regrouper les lettres aussi compactes que possible dans une chaîne contenant tous les mots valides de 2 lettres. Ceci parcourt ensuite tous les mots de la lettre et affiche ceux valides, un par ligne. Courez avec perl -M5.10.1 script.pl.

AKHolland
la source
Je ne peux pas obtenir que cela fonctionne dans un compilateur en ligne.
mbomb007
@ mbomb007 Selon la version, vous avez besoin de l'indicateur de ligne de commande -M5.10.1pour utiliser le saymot clé ajouté à cette version ou ajoutez use feature 'say';le corps du script.
AKHolland
7

C, 155 octets

Version golfée

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

Sortie

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

Version non-golfée

La chaîne magique de 51 octets de la version golfée contient de nombreux caractères autres que ASCII 126, qui ont presque certainement été mutilés en équivalents Unicode. La version non-golfée utilise hex à la place et comme constante plutôt que littérale. De plus, la version non golfée sépare les mots avec une nouvelle ligne, ce qui facilite la copie et le collage dans Excel, la commande de la liste et la comparaison avec celle requise.

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

Explication

Si nous élargissons la définition de voyelle pour inclure les 8 lettres AHMEIOUY, nous observons que tous les mots sont constitués d’une voyelle et d’une autre lettre (qui peut ou non être une voyelle.) Par conséquent, pour tous les mots se terminant par besoin d’un tableau de 26 octets, un pour chaque première lettre, avec les bits correspondant à la voyelle. Nous avons besoin d'une table similaire pour les mots commençant par une voyelle, sauf que cette fois, nous n'avons besoin que de 25 octets, car il n'y a pas de mot se terminant par Z. Les deux tables sont combinées pour créer la table finale.

Afin d'éviter tout code ASCII dans la région 0..31, les deux voyelles les moins communes M et H sont attribuées aux 6ème et 7ème bits, et le codage considère 1 pour un mot non valide et 0 pour un mot valide. Puisqu'il n'y a pas de consonne qui se couple à la fois avec M et H, il est possible de s'assurer qu'au moins un de ces bits est un 1.

Le 8ème bit est attribué à A, qui est la voyelle la plus courante, pour tenter de limiter les caractères non-ASCII (il en existe encore beaucoup).

Les tableaux utilisés sont ci-dessous. Pour les mots contenant 2 voyelles, j'ai donné la priorité à la première lettre en tant que "voyelle" et la deuxième lettre en tant que "lettre". Les mots commençant par M constituent une exception à cette règle, car cela évite les conflits entre MM et HM.

Codage Hex de mots commençant par une voyelle

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 

Codage hexadécimal de mots se terminant par une voyelle

 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
la source
Peut-être que vous ferez un saut dans la version avec golf afin que le jeu puisse être retourné facilement
masterX244
7

Java, 484 448 407 391 389 octets

Mon premier essai

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

Formaté:

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

Essayez-le en ligne

griFlo
la source
Bon travail! Quelques suggestions: java.lang.Exception peut simplement s'appeler Exception. "args" peut être juste "un". String.format () peut être "" .format (). Il y a aussi un petit espacement supplémentaire dans la déclaration main (). Belle approche dans l'ensemble cependant, +1 de moi :)
jrich
Je viens de jouer avec la déclaration imprimée, mais vous m'avez battu! Vous pouvez enregistrer un autre octet en ne le remplaçant que \npar un espace. Ils ne doivent pas être séparés par de nouvelles lignes.
James Webster
Vous avez également manqué quelques espaces que vous pouvez supprimer.
James Webster
@ JamesWebster Thx pour les conseils.
griFlo
4
"".formatest douloureux à regarder, mais hilarant.
Codebreaker
6

Ruby, 166 octets

Emprunter la méthode soignée de sp3000 pour encoder les mots dans une chaîne compacte. Le kicker est ici la méthode courte pour le décoder en mots de deux lettres: Utiliser un lookahead dans la regex passé à la méthode de scan de String afin d’extraire les correspondances qui se chevauchent, ne contenant pas d’espace:

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

Ruby, 179 octets

Ma propre approche: générer tous les mots de deux lettres entre AAet ZA, puis sélectionner ceux qui sont valides à l'aide d'un masque binaire codé en base 36:

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

Matlab, 177 octets

Générez une matrice binaire définissant toutes les paires de lettres autorisées, remodelez-la et codez-la en base 64. La chaîne codée en base 64 ( 'CR+ ... % ') est utilisée comme donnée dans le programme. Le programme inverse les opérations pour décompresser la matrice, puis lit les paires autorisées:

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
la source
2
Un gentil Luis! Le golf est en fait assez amusant ... = P
Stewie Griffin
1
Agréable! Il n'y a pas d'alphabet!
Brain Guider
1
chapeau bas. C’est le code matlab le plus crypté que j’ai vu depuis longtemps ...
Hoki
Merci les gars! C'est seulement cryptique à cause du codage en base 64. Cette chaîne contient en fait la matrice binaire 26x25 des paires de lettres autorisées
Luis Mendo
6

Malbolge , 2118 octets

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~

Essayez-le en ligne!

Krzysztof Szewczyk
la source
5

Bash, 179 octets

echo U`sed -r 's/./& &/g'<<<HAABADEDOEFAEHELAGOFEMAHINAISHMENERESITALOHOMMONOPAMUMYAWETOSOWOYOXUNUPEXI`F `grep -o ..<<<ANARASATAXAYBEBIBOBYJOKAKILIMIOIDOIDORPIQITIUSUTYEZA`
  • Enregistré 7 octets grâce à Adam Katz commentaire

Il utilise sedpour faire le remplacement de regex. La première entrée de regex est basée sur l' idée de Sp3000 alors que la seconde regex utilise une entrée commune sans espaces.

Explication:

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
la source
1
Vous pouvez réduire cela de sept octets en utilisant un espace puis `grep -o ..à la place de `sed -r 's/ / &/g', une astuce de ma réponse ci-dessous.
Adam Katz
5

Attention, cette réponse n’est pas intéressante d’un point de vue programmatique.

Comme tous les mots ont deux caractères, nous pouvons les écraser tous ensemble, puis les déchirer à nouveau à l'aide d'une simple expression régulière.

Tout langage adapté aux expressions rationnelles peut le faire, certains plus efficacement que d’autres:

Grep (via Bash), 215 octets

grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

Javascript, 224 octets

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

Perl, 225 octets

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

Python, 245 octets

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

 


Comme note, certaines des réponses ici sont plus longues que echo ce que je considérerais comme une base:

Shell POSIX, 307 octets

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
la source
3
+1 pour être pratique. En réalité, fournir l’écho de base est le point de départ idéal pour tous.
metalim
+1 sur la réponse facile, mais vous devriez le marquer comme non compétitif, n'est-ce pas?
Matthew Roh
@ MatthewRoh - S'il y avait un analyseur de classement, il ne pourrait probablement rien trouver car je n'avais pas intentionnellement commencé avec un titre. Je ne suis pas inquiet, d'autant plus qu'il y a des réponses plus courtes pour chaque langue que j'ai postée.
Adam Katz
3

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

Mettra à jour si je peux le réduire, compilez simplement avec gcc -w, les sorties ./a.out parfaitement. S'il y a un intérêt pour un non-golf, faites le moi savoir.

Je ne vois aucun moyen de le réduire rapidement (vous pouvez techniquement supprimer les guillemets dans les options de vente et vous obtiendrez toujours une réponse correcte, le résultat ressemblant à une poubelle), merci de me le faire savoir. de toute façon pour le raccourcir

Jake
la source
Voici quelques suggestions, cela fonctionne très bien pour moi (ne vous contentez pas de copier-coller, l'échange de piles insère des caractères de contrôle étranges dans les commentaires) _;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));}. J'ai remplacé le délimiteur de sortie d'une nouvelle ligne par un espace extra octet) changez la chaîne de format printf en"%c%c\n"
Level River St
3

C #, 348 octets

J'ai eu un essai:

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));
            }
        }
    }
}
Jodrell
la source
4
Ceci est un défi codegolf, vous devriez donc poster votre nombre d'octets (longueur de votre code). Essayez également de le raccourcir un peu, par exemple en supprimant les espaces.
Jakube
@ Jakube, est-ce mieux?
Jodrell
Oui, ça a l'air correct
Jakube
3

Pyth , 140 octets

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

Essayez-le en ligne!

Méthode de compression: comme il n’existe Zaucun mot dans la deuxième position, utilisez l’alphabet réordonné bcdfghjklmnpqrstvwxyaeioupour coder la validité de chacune de ces lettres en tant que deuxième lettre pour chaque première lettre (les premières lettres sont dans l’ordre alphabétique).
Cela correspond à 25 bits par lettre, soit exactement 5 chiffres de la base 32. Comme la plupart des consonnes ne prennent que des voyelles comme deuxième lettre, je mets des voyelles à la fin pour obtenir des nombres à un chiffre. Je suis certain que, dans l’ensemble, il pourrait être amélioré par une analyse plus poussée et une réorganisation de l’alphabet, bien que la définition de l’alphabet réorganisé occuperait davantage d’octets.

Explication

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
la source
2

PHP: 211 209 204

Vous devez désactiver les avertissements, sinon on va imprimer en ce qui concerne la création implicite de $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++;

Très drôle. Les premières tentatives étaient de l’ordre de 250, mais c’est ma plus mince encore.

NickW
la source
2
Essayez ce compteur d'octets . Notez que désactiver le comptage des espaces est incorrect, car il réduit également les espaces que vous avez dans les chaînes. Votre score doit donc être supérieur à 186.
Sp3000
Bonne prise. J'ai mis à jour ma soumission en conséquence
NickW
Je ne vois pas pourquoi ... mais cela ne fait qu'imprimer "AAAA A ..."
James Webster
Vous avez éliminé le !si… vous en aviez besoin.
James Webster
Droite. Je viens de remarquer ça. J'utilisais! plus tôt et j’ai fait une rapide recherche-remplacement sans tenir compte de ce qui se passerait en premier.
NickW
2

CJam (99 bytes)

Cela inclut quelques caractères spéciaux, il est donc plus sûr de donner un vidage hexadécimal. (En particulier, le caractère avec valeur 0xa0, correspondant à un espace insécable, m'a causé pas mal de problèmes lors de la configuration de la démonstration en ligne).

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

Démo en ligne .

L'approche consiste à coder la différence en base 26.

Peter Taylor
la source
Ajouter un caractère à un entier donne un caractère, vous pouvez donc le remplacer 65f+:cpar 'Af+.
Dennis
Vrai. Et mdc'est une amélioration brillante, mais je n'avais pas réalisé à quel point ma réponse était proche de la vôtre.
Peter Taylor
2

CJam, 100 98 octets

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

(permalien)

  • Enregistré deux octets via des variables pré-initialisées (merci Dennis!)

Ceci est ma première entrée en CJam, donc il y a probablement un potentiel pour un peu plus de golf. Cependant, j'ai trouvé un moyen de réduire la liste de caractères à 63 octets, ce qui, espérons-le, sera utile à quelqu'un d'autre.

Méthode de compression

Jusqu'ici, la plupart des méthodes que j'ai vues encodaient les deux lettres de chaque mot. Cependant, lorsque nous plaçons les mots dans l'ordre alphabétique, la première lettre ne change pas très souvent, il est donc inutile de l'encoder explicitement.

Je ne code que le dernier caractère de chaque mot et j'inclus un élément spécial chaque fois que le premier caractère doit être incrémenté. Les caractères sont codés en tant que premier caractère, puis une liste de différences. Comme il n'y a pas de mots en double, les différences doivent être au moins 1. Ainsi, je peux utiliser 0comme élément de séparation. (Notez que je dois alors stocker la première lettre de chaque sous-séquence sous la forme d'un index, sinon il y aurait une confusion entre 'survol du premier caractère 0' et 'commencer par A0 '.)

Comme les différences dans ce cas ne sont jamais supérieures à 15, nous pouvons utiliser des bases 16 et intégrer deux éléments (4 bits) dans chaque octet (8 bits). (Dans le code actuel, j'ai converti à partir de la base 260 au lieu de la base 256 pour éviter les problèmes de caractères non imprimables.)

2012rcampion
la source
Vous pouvez économiser quelques octets en utilisant Get N, qui pousse 16 et un saut de ligne.
Dennis
@Dennis Merci, je n'ai pas réalisé que les variables avaient été pré-initialisées!
2012rcampion
1
Les 26 lettres majuscules sont des variables pré-initialisées. Vous pouvez voir la liste complète ici .
Dennis
Vous pouvez économiser plus d'octets en remplaçant %-3<par /;;ou même /&. (La deuxième option générera un message d'erreur. Le consensus sur les méta est qu'il est acceptable de le faire.)
Dennis
2

brainfuck , 1371 octets

Tout à fait golfable, mais je n'y ai pas mis beaucoup d'effort.

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

Essayez-le en ligne!

Krzysztof Szewczyk
la source
Pour commencer, vous pouvez vous débarrasser des nouvelles lignes
Jo King
@JoKing il n'y a pas vraiment de moyen que je puisse sur-golfer quelqu'un, je ne pense pas qu'il y ait beaucoup de sens à réduire de quelques octets à cette échelle.
Krzysztof Szewczyk
2

Zsh, 175 octets

Cette solution utilise une chaîne de 125 caractères, où les lettres minuscules servent de délimiteurs et la première lettre de la séquence de lettres majuscules suivante.

Nous parcourons les lettres de $L. Si la lettre en cours $Xest en minuscule par comparaison ascii, définissez-la $Wsur $X. Sinon, imprimez $Wconcaténé avec $Xpour créer le mot actuel.

Essayez-le en ligne!

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

Éditer: ajouté :lpour définir les minuscules de manière cohérente, selon les besoins
Éditer2: -4 octets à l'aide de la $Xvariable et simplifié si la [[..]]condition
Éditer3: -4 octets en supprimant les guillemets ( ")
Éditer5: -5 octets à l'aide de la conversion de tableau au lieu de l'itération Lci-dessous
Éditer4: Autre approche pour 182 octets , exploitant des chaînes réversibles dans les 33 premières lettres, $Ln’est que 107 lettres

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

Stax , 91 octets

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

Exécuter et déboguer

La seule astuce intéressante utilisée par cette réponse consiste à utiliser le jeton "," pour indiquer un changement dans la première lettre, plutôt que de le stocker pour chaque mot.

Merci à récursif pour l'idée d'utiliser l'opérateur m

utilisateur89655
la source
Bien fait. Je peux voir quelques petites optimisations. Utilisez Mau lieu de 1/, et utilisez une carte abrégée mau lieu de explicite poureach et print { ... PF. Celui-ci emballe à 89.
récursive
1

Python 3, 224 octets

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

Utilise des masques de bits de longueur variable pour coder les secondes lettres existantes pour chaque première lettre possible. Les masques de bits peuvent avoir une longueur de 0,1,3,7,15 ou 31 bits. Les bits sont mappés sur les lettres for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':, les bits précédents sont utilisés pour les lettres plus courantes, de sorte que les masques de bits peuvent être courts dans la plupart des cas (généralement 3 ou 7 bits, car la plupart des consonnes sont uniquement suivies de l'une des 5 voyelles ou YM ou H). Malheureusement, le code à décoder annule les économies réalisées par rapport à des méthodes plus simples (la liste initiale ne contient que 303 octets).

samgak
la source
1
J'ai découvert qu'il était préférable de coder la première lettre qui existe pour chaque deuxième lettre possible dans ma solution. Ça vaut peut-être la peine d'essayer chez vous.
James Webster
1

Haskell, 192 octets

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"

Pour chaque mot séparé par un espace dans la chaîne, placez la première lettre devant toutes les autres lettres et ajoutez un espace, par exemple SHIO-> SH SI SO.

nimi
la source
1

Java, 334 octets

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

Formaté:

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

Séparément, j'ai codé la liste de mots en un bitSet de longueur 26x26 = 676, puis l'a convertie en tableau d'octets, puis en Base 64. Cette chaîne est codée en dur dans ce programme et la procédure inverse est utilisée pour reproduire le BitSet. et finalement imprimer la liste des mots

Kevin K
la source
1

Java, 356 octets

Utilise le générateur de nombres aléatoires pour obtenir les mots:

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

Vous pouvez l'essayer ici: http://ideone.com/Qni32q

Arnaud
la source
1

Perl, 248 octets

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

Première utilisation de perl (et première utilisation de golf), il y a donc matière à amélioration. Désactivez les voyelles et regroupez les lettres restantes en fonction de la manière dont le mot résultant a été créé - ajouter la voyelle en premier, en dernier ou les deux voyelles en premier et dernier crée un mot sur la liste.

VoiceOfFolly
la source
Je ne connais pas Perl, mais je suppose que vous séparez la sortie par des espaces. Il semble "MM "."MY "."BY "."HM "."SH "pouvoir être raccourci à "MM MY BY HM SH".
Level River St
@steveverrill Merci! J'ai été tellement pris dans le reste du code que j'ai oublié à quel point c'était redondant.
VoiceOfFolly
1

Javascript (ES6), 214

Peut-être pas le moyen le plus court de le faire, mais certainement intéressant.

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

Parcourt chaque lettre de la première chaîne en l'ajoutant à chaque lettre de la ligne correspondante de la seconde. Ceci retourne les mots dans l'ordre de leur dernière lettre, comme suit:

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

Suggestions bienvenues!

ETHproductions
la source
1

Java, 255 254 octets

J'ai trouvé un moyen d'en extraire un octet de plus.

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

Ou (mais pas beaucoup plus clair):

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
la source
Vous pouvez enregistrer deux octets en modifiant les deux occurrences de 'A'en 65.
ProgramFOX
1

Haskell, 333 308 298 octets

Juste pour le fun!

L'évaluation simprimera tous les mots dans un ordre étrange - j'ai utilisé le fait que la plupart des combinaisons sont voyelles-consonne ou vice-versa, pourrait probablement optimiser encore plus avec des "classes" de caractères personnalisés, raccourcissant la matrice codée (ici, wet k).

Est-ce que quelqu'un connaît un moyen plus court d'imprimer des chaînes sans guillemets et crochets que celui monadique? Les classes de types sont encore plus longues, autant que je sache.

En outre, il pourrait également y avoir une façon plus courte de faire ple travail ...

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
la source
N'est-ce pas sequence_la même chose void$sequence? Ensuite, vous pouvez également omettre le import.
nimi
C'est étrangement emballé, mais oui. Merci!
Leif Willerts
N'est-ce pas, voiddevait être importé. Quoi qu'il en soit, je vais / je dois m'en souvenir.
Leif Willerts
1
Ah et sequence_$map putStrLnest mapM_ putStrLn. Remplacez le (, )autour concat$...d' une autre $.
nimi
1

05AB1E , 143 octets (non-concurrence)

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

Essayez-le en ligne!

Urne Magique De Pieuvre
la source
1
@KevinCruijssen 91 (et je suis sûr que cette méthode peut baisser, mais j'ai choisi les mots du dictionnaire pour humour).
Grimmy
1

PHP, 170 octets

approche la plus courte que j'ai pu trouver jusqu'à présent ...

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

panne

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
    ;

Remarque La version de mappage binaire la plus courte avec l'ASCI imprimable coûte 190 octets (113 octets de données + 77 octets de décodage) avec 6 bits = base 64, 174 octets (97 données, 77 décodage) avec 7 bits (base 128); peut-être un peu plus pour s'échapper.

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 (en utilisant ascii 32..255) prend 87 octets de données (+ d'échappement); mais je suppose que le décodage coûtera plus de 10 octets supplémentaires.
Exclure C et V de la carte permettrait d’économiser 16/14/13 octets sur les données mais coûterait beaucoup en décodage.

Titus
la source