Generar tablero de Boggle aleatorio

16

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 por lo que gana el programa con el bytecount más corto.

boothby
fuente
3
no puede haber F si hay K. esto significa que no puedes deletrear f ... iretruck! : P
Blazer
@Blazer: Sí, y tampoco puedes deletrear f ... olk. : P
Ry-

Respuestas:

5

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.

Ilmari Karonen
fuente
Ah, me había olvidado de que puedes ordenar por mapeo.
Peter Taylor
4

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

Chaqueta de sport
fuente
1
puede hacer que su código sea más estricto con la indexación, print a+' u'[a=='Q']yprint'\n'[j%4:]
Keith Randall
@keith gracias! Lo hice aún más estricto combinando esos dos trucos :)
Blazer
1
Logré bajarlo a 218 sin matarlo (¿creo?): 1) Cambie la declaración de importación from random import*y elimine todo r.. 2) Cambie los separadores en cadena a `` (espacio) y aproveche str.splitel argumento predeterminado de '. 3) Deshágase de todo lo que tenga que ver jy use '\n'[len(d)%4:]. 4) Use list.popel argumento por defecto. 5) ... 6) Beneficio!
Dillon Cower
@DC ahh gracias! Me sorprende que los haya pasado por alto. pero supongo que eso es lo que obtengo por escribirlo en unos minutos: P
Blazer
1
Y lo reduje aún más en 3 caracteres usando un pequeño truco de mapa, pero tuve que mantenerlo j=0...+'\n'[j%4:]para que funcione
Blazer
3

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*
Peter Taylor
fuente
Si mi análisis (a mano) es correcto, no hay otras cadenas que sean lo suficientemente largas y frecuentes como para comprimir los datos mediante un simple reemplazo, independientemente del orden de los dados y dentro de los dados.
Peter Taylor
Pude bajar la tabla de 96 a 84 caracteres intercalando los dados y usando la codificación de longitud de ejecución. Decodificación que podría marcar la diferencia ... seguro que lo hace para Python.
stand
Puede codificar 6 letras en 30 bits, luego en 5 caracteres imprimibles, ahorrando 16 bytes. Pero necesitarás un cambio / máscara para extraerlos.
ugoren
@ugoren, Ilmari ya lo hizo.
Peter Taylor
@PeterTaylor, si dices que lo hizo, te creo (nunca me molesté en aprender Golfscript). Pero parece estar usando 57 caracteres no imprimibles, mientras que yo sugerí 80 imprimibles.
ugoren
2

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)

Mark Thomas
fuente
Acabo de aprobar una edición de "un usuario anónimo" a esta respuesta; Supongo que fue usted, Mark, y simplemente olvidó iniciar sesión. (Ps. Su salida no parece ser exactamente la especificada; el uso x.join(" ").gsub(/Q ?/,"Qu")lo arreglaría al costo de tres caracteres adicionales).
Ilmari Karonen
(Eso es un espacio adicional en la joincadena y un espacio adicional y un signo de interrogación en la expresión regular, en caso de que el software SE destruya los espacios ...)
Ilmari Karonen
@IlmariKaronen Gracias, no noté los dos espacios entre columnas. Debería ser para especificar ahora.
Mark Thomas
2

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.

Andrew Shepherd
fuente
¿tal vez podría usar los últimos dígitos de la hora actual en ms como valor de clasificación?
Blazer
@Blazer - posiblemente, pero "aleatorio" solo toma seis caracteres :-)
Andrew Shepherd
0

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";
}
caja de pan
fuente