Générer une carte Boggle aléatoire


16

Générez une grille 4x12 de lettres / espaces:

Chaque dé doit apparaître précisément une fois, l'emplacement choisi au hasard. Les emplacements doivent correspondre approximativement à une permutation aléatoire uniforme des dés. Affichez une face aléatoire (à nouveau, approximativement uniforme) de chaque dé. Justifiez à gauche le visage dans la fenêtre à 3 caractères. Par exemple,

A  E  A  A
E  C  D  E
D  A  Qu E
E  A  H  D

Est une carte non randomisée dans le format que je veux. L'espace de fuite est autorisé.

Les dés:

A  A  E  E  G  N
E  L  R  T  T  Y
A  O  O  T  T  W
A  B  B  J  O  O
E  H  R  T  V  W
C  I  M  O  T  U
D  I  S  T  T  Y
E  I  O  S  S  T
D  E  L  R  V  Y
A  C  H  O  P  S
H  I  M  N  Qu U
E  E  I  N  S  U
E  E  G  H  N  W
A  F  F  K  P  S
H  L  N  N  R  Z
D  E  I  L  R  X

Fait amusant: il n'y a que 1 K dans l'ensemble. Quelle autre lettre partage exclusivement qui meurent?

Il s'agit de donc le programme avec le plus petit nombre de victoires gagne!


3
il ne peut pas y avoir de F s'il y a des K. cela signifie que vous ne pouvez pas épeler f ... iretruck! : P
Blazer

@Blazer: Ouais, et tu ne peux pas épeler f ... olk non plus. : P
Ry-

Réponses:


5

GolfScript, 116 octets

Étant donné que le score est en octets, je pense que cela signifie que nous pouvons utiliser tous les octets de la solution. Sortir de l'ensemble ASCII imprimable permet une solution un peu plus courte que celle de Peter Taylor , au prix de rendre le code plus difficile à afficher ici. Sans les données non imprimables, mon code ressemble à ceci:

'57 BYTES OF BINARY DATA HERE'256base 26base 6/{;9.?rand}${6rand=65+.81='  u '2/=}%8/n*

Il est assez similaire à la solution de Peter Taylor, et je dois admettre aux bits d' emprunt sans vergogne de celui - ci (comme le .81=' u '2/=truc), même si je pense que je réussi à réduire son remaniement légèrement, même après avoir passé un supplément ombles octet pour une meilleure aléatoire.

La chaîne binaire au début du script contient des caractères non imprimables et ne peut donc pas être collée directement ici. Au lieu de cela, je fournirai le script sous forme de vidage hexadécimal:

0000000: 2701 8302 7c56 97d5 ec9c 52e3 462e 44d7  '...|V....R.F.D.
0000010: a8d2 81c9 6115 fc80 4da4 6cd3 b06f a6d8  ....a...M.l..o..
0000020: 4e7e 2029 12a9 f331 0b83 3481 de36 81e2  N~ )...1..4..6..
0000030: 41b4 534d dee8 13f7 ccfd 2732 3536 6261  A.SM......'256ba
0000040: 7365 2032 3662 6173 6520 362f 7b3b 392e  se 26base 6/{;9.
0000050: 3f72 616e 647d 247b 3672 616e 643d 3635  ?rand}${6rand=65
0000060: 2b2e 3831 3d27 2020 7520 2732 2f3d 7d25  +.81='  u '2/=}%
0000070: 382f 6e2a                                8/n*

Sous Linux, ou tout système avec l' xxdutilitaire installé, ce vidage hexadécimal peut être reconverti en un programme GolfScript de 116 octets en le passant xxd -r.

Edit: Remplacé 999randpar 9.?randpour un bien meilleur caractère aléatoire. Le shuffle devrait maintenant être aussi proche de la perfection que le permet le RNG sous-jacent.


Ah - j'avais oublié que vous pouvez trier par une cartographie.
Peter Taylor

4

Python 2.7, 253 229 215 caractères

from random import*
j=0
for x in map(choice,sample("AAEEGN ELRTTY AOOTTW ABBJOO EHRTVW CIMOTU DISTTY EIOSST DELRVY ACHOPS HIMNQU EEINSU EEGHNW AFFKPS HLNNRZ DEILRX".split(),16)):j+=1;print x+' u'[x=='Q']+'\n'[j%4:],

La plupart des personnages ne sont que les dés eux-mêmes. Je ne voulais pas passer trop de temps à essayer de le réduire trop

modification mineure: suppression de 2 octets inutiles (espaces supplémentaires)

edit2: jusqu'à 229

edit3: jusqu'à 215


1
vous pouvez rendre votre code plus serré avec l'indexation, print a+' u'[a=='Q']etprint'\n'[j%4:]
Keith Randall

@keith merci! Je l'ai rendu encore plus serré en combinant ces deux astuces :)
Blazer

1
J'ai réussi à le réduire à 218 sans le tuer (je pense?): 1) Modifiez l'instruction d'importation from random import*et supprimez tout r.. 2) Remplacez les séparateurs de la chaîne par `` (espace) et profitez de str.splitl'argument par défaut de. 3) Débarrassez-vous de tout ce qui a à voir jet à utiliser '\n'[len(d)%4:]. 4) Utilisez list.popl'argument par défaut de. 5) ... 6) Profit!
Dillon Cower

@DC ahh merci! Je suis surpris de les avoir oubliés. mais je suppose que c'est ce que j'obtiens en l'écrivant en quelques minutes: P
Blazer

1
Et je l'ai encore réduit de 3 caractères en utilisant un petit truc de carte, mais j'ai dû garder le j=0...+'\n'[j%4:]pour que ça marche
Blazer

3

GolfScript ( 141 139 137 octets de caractères )

Dont 94 s'étendent jusqu'à la chaîne contenant les dés. La figure n'inclut pas le saut de ligne inutile inséré pour le boucler afin que le code puisse être vu sans défilement:

'Y
ISY
XIAOOW
VYAAEEGNABBJOOEHRTVWCIMOTUEIOSSTACHOPSHIMNQUEEINSUEEGHNWAFFKPSHLNNRZ'n/'TTELRD'*
6/{[6rand=99rand\]}%${1=.81='  u '2/=}%8/n*

Si mon analyse (à la main) est correcte, il n'y a pas d'autres chaînes à la fois assez longues et assez fréquentes pour compresser les données par simple remplacement, indépendamment de l'ordre des dés et à l'intérieur des dés.
Peter Taylor

J'ai pu faire passer le tableau de 96 à 84 caractères en entrelaçant les dés et en utilisant un encodage de longueur. Un décodage qui pourrait faire la différence ... c'est certainement le cas pour python.
boothby

Vous pouvez encoder 6 lettres en 30 bits, puis en 5 caractères imprimables, économisant 16 octets. Mais vous aurez besoin d'un décalage / masque pour les extraire.
ugoren

@ugoren, Ilmari l'a déjà fait.
Peter Taylor

@PeterTaylor, si vous dites qu'il l'a fait, je vous crois (je n'ai jamais pris la peine d'apprendre Golfscript). Mais il semble utiliser 57 caractères non imprimables, alors que j'ai suggéré 80 caractères imprimables.
ugoren

2

Ruby, 201 197 caractères

%W(AAEEGN ELRTTY AOOTTW ABBJOO EHRTVW CIMOTU DISTTY EIOSST DELRVY ACHOPS HIMNQU EEINSU EEGHNW AFFKPS HLNNRZ DEILRX).sample(16).map{|c|c[rand 6]}.each_slice(4){|x|puts x.join("  ").gsub(/Q ?/,"Qu")}

(et c'est une ligne)

Édition 1: utilisé% W () pour éviter le .split et une paire de guillemets.

Edit 2: Made to spec (deux espaces entre chaque colonne de sortie)


Je viens d'approuver une modification par "un utilisateur anonyme" de cette réponse; Je suppose que vous étais, Mark, et vous avez juste oublié de vous connecter (sortie Ps Vous ne semble pas être exactement les spécifications;. Utiliser. x.join(" ").gsub(/Q ?/,"Qu"). Fixerait que , au prix de trois caractères supplémentaires)
Ilmari Karonen

(C'est un espace supplémentaire dans la joinchaîne et un espace supplémentaire et un point d'interrogation dans l'expression régulière, au cas où le logiciel SE gâcherait les espaces ...)
Ilmari Karonen

@IlmariKaronen Merci, je n'ai pas remarqué les deux espaces entre les colonnes. Ce devrait être aux spécifications maintenant.
Mark Thomas

2

Powershell, 234 caractères

$d=(0..15|%{@{'AAEEGNELRTTYAOOTTWABBJOOEHRTVWCIMOTUDISTTYEIOSSTDELRVYACHOPSHIMNQUEEINSUEEGHNWAFFKPSHLNNRZDEILRX'[6*$_+(random)%6]=random}.GetEnumerator()}|sort Value|%{$_.Key})
0..3|%{($d[($_*4)..($_*4+3)])-join"   "-replace'Q ','Qu'}

Voici le même code avec des espaces supplémentaires, dans une tentative d'améliorer la lisibilité :-)

#########################################
# roll the 16 dice and shuffle them     #
#########################################

$d=(
        0..15 | % {
                    @{
                       'AAEEGNELRTTYAOOTTWABBJOOEHRTVWCIMOTUDISTTYEIOSSTDELRVYACHOPSHIMNQUEEINSUEEGHNWAFFKPSHLNNRZDEILRX'[6*$_+(random)%6]=random
                     }.GetEnumerator() 
                  } | sort Value | % {
                                        $_.Key
                                     }
    )

############################################
# add the 16 results to the 4 by 4 grid    #
############################################

0..3 | % {
            ($d[($_*4)..($_*4+3)]) -join "   " -replace 'Q ','Qu'
         }

Je ne suis pas au courant d'une shufflefonctionnalité intégrée dans PowerShell, j'ai donc transformé chaque résultat en une paire clé-valeur - la clé égalant un résultat de dés et la valeur égalant un nombre aléatoire. Ensuite, il s'agissait simplement de trier ces paires par valeur, puis de sortir les clés.


peut-être pourriez-vous utiliser les derniers chiffres de l'heure actuelle en ms comme valeur de tri?
Blazer

@Blazer - peut-être, mais "aléatoire" ne prend que six caractères :-)
Andrew Shepherd

0

Perl, 179 caractères

@d=(Qu,map"$_ ",HIMNUAAEEGNELRTTYAOOTTWABBJOOEHRTVWCIMOTUDISTTYEIOSSTDELRVYACHOPSEEINSUEEGHNWAFFKPSHLNNRZDEILRX
=~/./g);print+(splice@d,6*int rand@d/6,6)[rand 6],@d%24?$":$/while@d

Voici une version détaillée du programme:

my $fullset = "HIMNUAAEEGNELRTTYAOOTTWABBJOOEHRTVWCIMOTUDISTTY"
           . "EIOSSTDELRVYACHOPSEEINSUEEGHNWAFFKPSHLNNRZDEILRX";
my @dice = ("Qu");
push @dice, "$_ " for split //, $fullset;
while (@dice) {
    my @die = splice @dice, 6 * (int rand @dice / 6), 6;
    print $die[rand 6];
    print @dice % 24 ? " " : "\n";
}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.