Zufälliges Boggle Board generieren

Erzeugen Sie ein 4x12-Gitter aus Buchstaben / Leerzeichen:

Jeder Würfel sollte genau einmal erscheinen, wobei die Position zufällig gewählt wird. Die Positionen sollten ungefähr einer gleichmäßigen zufälligen Permutation der Würfel entsprechen. Zeigen Sie eine zufällige (wieder annähernd gleichmäßige) Fläche jedes Würfels an. Richten Sie das Gesicht im 3-Zeichen-Fenster linksbündig aus. Beispielsweise,

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

Ist ein nicht randomisiertes Board in dem von mir gewünschten Format. Leerzeichen sind erlaubt.

Der Würfel:

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

Amüsante Tatsache: Es gibt nur 1 K im Set. Welcher andere Brief teilt ausschließlich die, die sterben?

Das ist Code-Golf, also gewinnt das Programm mit dem kürzesten bytecount!

GolfScript, 116 Bytes

Da die Bewertung in Bytes erfolgt, bedeutet dies, dass wir alle Bytes in der Lösung verwenden können. Das Verlassen des druckbaren ASCII-Satzes ermöglicht eine etwas kürzere Lösung als die von Peter Taylor , was die Anzeige des Codes hier erschwert. Ohne die nicht druckbaren Daten sieht mein Code folgendermaßen aus:

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

Es ist Peter Taylors Lösung ziemlich ähnlich, und ich gebe zu, dass ich schamlos Teile davon ausgeliehen habe (wie den .81=' u '2/=Trick), obwohl ich glaube, dass ich es geschafft habe, sein Shuffle ein wenig zu verkürzen, selbst nachdem ich ein zusätzliches Zeichenbyte für eine bessere Zufälligkeit ausgegeben habe.

Die Binärzeichenfolge am Anfang des Skripts enthält nicht druckbare Zeichen und kann daher hier nicht direkt eingefügt werden. Stattdessen stelle ich das Skript als Hex-Dump bereit:

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*

Unter Linux oder auf jedem System, auf dem das xxdDienstprogramm installiert ist, kann dieser Hex-Speicherauszug durch Weitergabe in ein funktionsfähiges 116-Byte-GolfScript-Programm umgewandelt werden xxd -r.

Edit: Ersetzt 999randdurch 9.?randfür eine viel bessere Zufälligkeit. Das Shuffle sollte nun so gut wie perfekt sein, wie es der zugrunde liegende RNG zulässt.

Python 2.7, 253 229 215 Zeichen

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

Die meisten Charaktere sind nur die Würfel selbst. Ich wollte nicht zu viel Zeit damit verbringen, es zu reduzieren

Nebenbearbeitung: 2 unnötige Bytes entfernt (zusätzliche Leerzeichen)

edit2: runter auf 229

edit3: runter auf 215

GolfScript ( 141 139 137 Zeichen Bytes)

Davon entfallen 94 auf die Zeichenfolge mit den Würfeln. In der Abbildung ist der unnötige Zeilenumbruch nicht enthalten, damit der Code ohne Bildlauf angezeigt werden kann:

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

Ruby, 201 197 Zeichen

%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")}

(und es ist ein Einzeiler)

Bearbeiten 1:% W () verwendet, um die Teilung und ein Paar Anführungszeichen zu vermeiden.

Edit 2: Angepasst (zwei Leerzeichen zwischen jeder Ausgabespalte)

Powershell, 234 Zeichen

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

Hier ist derselbe Code mit zusätzlichen Leerzeichen, um die Lesbarkeit zu verbessern :-)

#########################################
# 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'
         }

Ich kenne keine eingebaute shuffleFunktion in Powershell und habe jedes Ergebnis in ein Schlüssel-Wert-Paar umgewandelt - den Schlüssel, der einem Würfelergebnis entspricht, und den Wert, der einer Zufallszahl entspricht. Dann war es nur ein Fall, diese Paare nach dem Wert zu sortieren und dann die Schlüssel auszugeben.

Perl, 179 Zeichen

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

Hier ist eine ausführliche Version des Programms:

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