Genera boggle board casuale

Genera una griglia 4x12 di lettere / spazi:

Ogni dado dovrebbe apparire esattamente una volta, posizione scelta casualmente. Le posizioni dovrebbero essere approssimative una permutazione casuale uniforme dei dadi. Mostra una faccia casuale (di nuovo, approssimativamente uniforme) di ogni dado. Giustifica a sinistra la faccia nella finestra di 3 caratteri. Per esempio,

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

È una scheda non randomizzata nel formato che desidero. È consentito lo spazio di trascinamento.

Il dado:

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

Fatto divertente: nel set c'è solo 1 K. Quale altra lettera condivide esclusivamente quelli che muoiono?

Si tratta di code-golf, quindi vince il programma con il byte più breve!

GolfScript, 116 byte

Dato che il punteggio è in byte, immagino che ciò significhi che possiamo usare tutti i byte nella soluzione. Uscire dal set ASCII stampabile consente una soluzione leggermente più breve di quella di Peter Taylor , al costo di rendere il codice più difficile da visualizzare qui. Senza i dati non stampabili, il mio codice è simile al seguente:

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

È abbastanza simile alla soluzione di Peter Taylor, e ammetto di averne preso spudoratamente in prestito frammenti (come il .81=' u '2/=trucco), anche se penso di essere riuscito ad accorciare leggermente il suo shuffle, anche dopo aver speso un byte di caratteri aggiuntivo per una migliore casualità.

La stringa binaria all'inizio dello script contiene caratteri non stampabili, quindi non può essere incollata direttamente qui. Invece, fornirò lo script come un dump esadecimale:

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*

Su Linux o su qualsiasi sistema con l' xxdutilità installata, questo dump esadecimale può essere convertito in un programma GolfScript da 116 byte funzionante passandolo attraverso xxd -r.

Modifica: sostituito 999randcon 9.?randper una casualità molto migliore. Lo shuffle dovrebbe ora essere quasi vicino alla perfezione come consente l'RNG sottostante.

Python 2.7, 253 229 215 caratteri

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 maggior parte dei personaggi sono solo i dadi stessi. Non volevo passare troppo tempo a cercare di ridurlo troppo

modifica minore: rimossi 2 byte non necessari (spazi extra)

edit2: fino a 229

edit3: fino a 215

GolfScript ( 141 139 137 caratteri byte)

Di cui 94 espandersi nella stringa contenente i dadi. La figura non include la newline non necessaria inserita per farla avvolgere in modo che il codice possa essere visto senza scorrere:

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

Rubino, 201 197 caratteri

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

(ed è un one-liner)

Modifica 1: usato% W () per evitare .split e un paio di virgolette.

Modifica 2: reso conforme alle specifiche (due spazi tra ciascuna colonna di output)

Powershell, 234 caratteri

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

Ecco lo stesso codice con spazi extra, nel tentativo di migliorare la leggibilità :-)

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

Non sono a conoscenza di una shufflefunzionalità integrata in PowerShell, quindi ho trasformato ogni risultato in una coppia chiave-valore: la chiave equivale a un risultato di dadi e il valore uguale a un numero casuale. Quindi si è trattato solo di ordinare queste coppie in base al valore, quindi di emettere le chiavi.

Perl, 179 caratteri

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

Ecco una versione dettagliata del programma:

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