Generar tablero de Boggle aleatorio

Genere una cuadrícula de 4x12 de letras / espacios:

Cada dado debe aparecer precisamente una vez, ubicación elegida al azar. Las ubicaciones deben ser aproximadas, una permutación aleatoria uniforme de los dados. Muestre una cara aleatoria (de nuevo, aproximadamente uniforme) de cada dado. Izquierda-justifique la cara en la ventana de 3 caracteres. Por ejemplo,

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

Es un tablero no aleatorio en el formato que quiero. Se permite espacio final.

El 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

Dato divertido: solo hay 1 K en el set. ¿Qué otra carta comparte exclusivamente los que mueren?

Este es el código de golf, por lo que gana el programa con el bytecount más corto.

GolfScript, 116 bytes

Como la puntuación está en bytes, supongo que eso significa que podemos usar todos los bytes en la solución. Salir del conjunto ASCII imprimible permite una solución algo más corta que la de Peter Taylor , a costa de hacer que el código sea más difícil de mostrar aquí. Sin los datos no imprimibles, mi código se ve así:

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

Es bastante similar a la solución de Peter Taylor, y admito que tomé prestados descaradamente fragmentos (como el .81=' u '2/=truco), aunque creo que logré acortar un poco su barajadura, incluso después de gastar un extra carbón de bytes para una mejor aleatoriedad.

La cadena binaria al comienzo del script contiene caracteres no imprimibles, por lo que no se puede pegar directamente aquí. En cambio, proporcionaré el script como un volcado hexadecimal:

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*

En Linux, o cualquier sistema con el xxd utilidad instalada, este volcado hexadecimal se puede volver a convertir en un programa GolfScript de 116 bytes funcionando al pasarlo xxd -r.

Editar: Sustituido 999randcon 9.?randpor tanto una mejor aleatoriedad. El shuffle ahora debería ser casi tan perfecto como lo permita el RNG subyacente.

Python 2.7, 253 229 215 caracteres

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 mayoría de los personajes son solo los dados. No quería pasar demasiado tiempo tratando de reducirlo demasiado

edición menor: eliminó 2 bytes innecesarios (espacios adicionales)

edit2: hasta 229

edit3: hasta 215

GolfScript ( 141 139 137 caracteres bytes)

De los cuales 94 se expanden a la cadena que contiene los dados. La figura no incluye la nueva línea innecesaria insertada para que quede ajustada para que el código se pueda ver sin desplazarse:

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

Ruby, 201 197 caracteres

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

(y es de una sola línea)

Edición 1: se usó% W () para evitar el .split y un par de comillas.

Edición 2: Hecho a la especificación (dos espacios entre cada columna de salida)

Powershell, 234 caracteres

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

Aquí está el mismo código con espacios en blanco adicionales, en un intento de mejorar la legibilidad :-)

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

No conozco una shufflefunción incorporada en powershell, por lo que convertí cada resultado en un par clave-valor: la clave equivale a un resultado de dados y el valor equivale a un número aleatorio. Entonces fue solo un caso de ordenar estos pares por el valor y luego emitir las claves.

Perl, 179 caracteres

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

Aquí hay una versión detallada del programa:

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