Gerar placa aleatória Boggle

16

Gere uma grade 4x12 de letras / espaços:

Cada dado deve aparecer precisamente uma vez, local escolhido aleatoriamente. Os locais devem ser aproximados a uma permutação aleatória uniforme dos dados. Mostre uma face aleatória (novamente, aproximadamente uniforme) de cada dado. Justifique à esquerda o rosto na janela de 3 caracteres. Por exemplo,

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

É uma placa não aleatória no formato que eu quero. Espaço à direita é permitido.

O 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

Fato divertido: há apenas 1 K no conjunto. Que outra carta compartilha exclusivamente os que morrem?

Isso é e o programa com o menor número de vitórias ganha!

boothby
fonte
3
não pode haver F se houver K. isso significa que você não pode soletrar f ... iretruck! : P
Blazer
@Blazer: Sim, e você também não pode soletrar f ... olk. : P
Ry-

Respostas:

5

GolfScript, 116 bytes

Como a pontuação é em bytes, acho que significa que podemos usar todos os bytes na solução. Sair do conjunto ASCII imprimível permite uma solução um pouco mais curta que a de Peter Taylor , com o custo de dificultar a exibição do código aqui. Sem os dados não imprimíveis, meu código fica assim:

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

É bem parecido com a solução de Peter Taylor, e admito ter emprestado vergonhosamente partes dela (como o .81=' u '2/=truque), embora eu ache que tenha conseguido encurtar um pouco o shuffle dele, mesmo depois de gastar um byte de char extra para obter uma melhor aleatoriedade.

A cadeia binária no início do script contém caracteres não imprimíveis e, portanto, não pode ser colada diretamente aqui. Em vez disso, fornecerei o script como um dump 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*

No Linux ou em qualquer sistema com o xxdutilitário instalado, esse dump hexadecimal pode ser transformado novamente em um programa GolfScript de 116 bytes em funcionamento, passando-o xxd -r.

Edit: Substituído 999randpor 9.?randpara uma aleatoriedade muito melhor. O shuffle agora deve estar o mais próximo possível da perfeição que o RNG subjacente permitir.

Ilmari Karonen
fonte
Ah - eu tinha esquecido que você pode classificar por um mapeamento.
31412 Peter 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:],

A maioria dos personagens são apenas os dados. Eu não queria gastar muito tempo tentando reduzi-lo muito

edição menor: removido 2 bytes desnecessários (espaços extras)

edit2: até 229

edit3: até 215

Blazer
fonte
11
você pode fazer seu código mais apertado com a indexação, print a+' u'[a=='Q']eprint'\n'[j%4:]
Keith Randall
@keith thanks! I tornou ainda mais apertado, combinando esses dois truques :)
Blazer
11
Consegui reduzi-lo para 218 sem matá-lo (acho?): 1) Altere a declaração de importação para from random import*e remova tudo r.. 2) Altere os separadores na string para `` (espaço) e tire vantagem do str.splitargumento padrão. 3) Livre-se de qualquer coisa relacionada com je use '\n'[len(d)%4:]. 4) Use list.popo argumento padrão. 5) ... 6) Lucro!
Dillon Cower
@DC ahh obrigado! Estou surpreso por ter esquecido deles. mas eu acho que é o que eu recebo para escrevê-lo em poucos minutos: P
Blazer
11
E eu reduzi-lo ainda mais por 3 caracteres usando um truque pequeno mapa, mas eu tive que manter o j=0...+'\n'[j%4:]para que ele funcione
Blazer
3

GolfScript ( 141 139 137 bytes de caracteres )

Dos quais, 94 expandem para a sequência que contém os dados. A figura não inclui a nova linha desnecessária inserida para torná-la quebrada, para que o código possa ser visto sem rolar:

'Y
ISY
XIAOOW
VYAAEEGNABBJOOEHRTVWCIMOTUEIOSSTACHOPSHIMNQUEEINSUEEGHNWAFFKPSHLNNRZ'n/'TTELRD'*
6/{[6rand=99rand\]}%${1=.81='  u '2/=}%8/n*
Peter Taylor
fonte
Se minha análise (manual) estiver correta, não há outras seqüências de caracteres que sejam longas o suficiente e freqüentes o suficiente para compactar os dados por simples substituição, independentemente da ordem dos dados e dos dados.
Peter Taylor
Consegui reduzir a tabela de 96 para 84 caracteres, intercalando os dados e usando a codificação de execução. Decodificação que pode fazer a diferença ... certamente faz para python.
usar o seguinte comando
Você pode codificar 6 letras em 30 bits e depois em 5 caracteres imprimíveis, economizando 16 bytes. Mas você precisará de alguma mudança / máscara para extraí-los.
ugoren
@ugoren, Ilmari já fez isso.
22413 Peter Peter
@ Peter Taylor, se você diz que sim, eu acredito em você (nunca me preocupei em aprender Golfscript). Mas ele parece estar usando 57 caracteres não imprimíveis, enquanto eu sugeri 80 imprimíveis.
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")}

(e é uma linha)

Editar 1: Utilizou% W () para evitar o .split e um par de aspas.

Editar 2: Feito para especificar (dois espaços entre cada coluna de saída)

Mark Thomas
fonte
Acabei de aprovar uma edição por "um usuário anônimo" nesta resposta; Eu suponho que era você, Mark, e você simplesmente esqueceu de fazer o login. (Ps. Você parece não estar exatamente dentro das especificações; o uso x.join(" ").gsub(/Q ?/,"Qu")consertaria isso ao custo de três caracteres extras.)
Ilmari Karonen
(Esse é um espaço extra na joincorda e uma marca de espaço e pergunta extra no regex, no caso dos mangles software SE os espaços ...)
Ilmari Karonen
@IlmariKaronen Obrigado, eu não notei os dois espaços entre as colunas. Deve ser a especificação agora.
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'}

Aqui está o mesmo código com espaço em branco extra, na tentativa de melhorar a legibilidade :-)

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

Como não conheço um shufflerecurso interno do PowerShell, transformei cada resultado em um par de valores-chave - a chave igual a um resultado de dados e o valor igual a um número aleatório. Depois, foi apenas um caso de classificar esses pares pelo valor e depois emitir as chaves.

Andrew Shepherd
fonte
talvez você possa usar os últimos dígitos no tempo atual em ms como um valor de classificação?
Blazer
@Blazer - possivelmente, mas "aleatório" leva apenas 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

Aqui está uma versão detalhada do 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";
}
caixa de pão
fonte