Generuj losową tablicę boggle

Wygeneruj siatkę 4x12 liter / spacji:

Każda kość powinna pojawić się dokładnie raz, losowo wybrana lokalizacja. Lokalizacje powinny być zbliżone do jednolitej przypadkowej permutacji kości. Wyświetl losową (ponownie, w przybliżeniu jednolitą) twarz każdej kości. Wyjustuj lewą twarz w oknie 3-znakowym. Na przykład,

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

Jest to nierandomizowana tablica w formacie, który chcę. Końcowe miejsce jest dozwolone.

Kostka do gry:

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

Zabawny fakt: w zestawie jest tylko 1 K. Jaki inny list dotyczy wyłącznie tych, którzy umierają?

To jest golf golfowy, więc wygrywa program z najkrótszą liczbą bajtów!

GolfScript, 116 bajtów

Ponieważ ocenianie jest w bajtach, myślę, że oznacza to, że możemy użyć wszystkich bajtów w rozwiązaniu. Wyjście poza zestaw ASCII do wydruku pozwala na nieco krótsze rozwiązanie niż w przypadku Petera Taylora , kosztem utrudnienia wyświetlenia kodu tutaj. Bez danych niedrukowalnych mój kod wygląda następująco:

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

Jest dość podobny do rozwiązania Petera Taylora i przyznam się do bezwstydnego pożyczania jego fragmentów (takich jak .81=' u '2/=sztuczka), chociaż myślę, że udało mi się nieco skrócić jego losowanie, nawet po spędzeniu dodatkowego bajtu char dla większej przypadkowości.

Ciąg binarny na początku skryptu zawiera znaki niedrukowalne, więc nie można go tutaj wkleić bezpośrednio. Zamiast tego dostarczę skrypt jako zrzut heksowy:

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*

W systemie Linux lub dowolnym systemie z xxdzainstalowanym narzędziem ten zrzut szesnastkowy można przekształcić z powrotem w działający 116-bajtowy program GolfScript, przepuszczając go xxd -r.

Edit: Zastępuje 999randsię 9.?randza dużo lepszej losowości. Losowanie powinno być teraz tak blisko ideału, jak pozwala na to podstawowa RNG.

Python 2.7, 253 229 215 znaków

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

Większość postaci to same kości. Nie chciałem spędzać zbyt wiele czasu, próbując to zbyt mocno zmniejszyć

drobna edycja: usunięto 2 niepotrzebne bajty (dodatkowe spacje)

edit2: do 229

edycja3: do 215

GolfScript ( 141 139 137 znaków bajtów)

Z czego 94 rozwija się do ciągu zawierającego kostki. Na rysunku nie uwzględniono niepotrzebnego znaku nowej linii wstawionego w celu zawinięcia, dzięki czemu kod można zobaczyć bez przewijania:

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

Ruby, 201 197 znaków

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

(i jest to jedna linijka)

Edycja 1: Użyto% W (), aby uniknąć .split i pary cudzysłowów.

Edycja 2: Dostosowano do specyfikacji (dwie spacje między każdą kolumną wyjściową)

PowerShell, 234 znaki

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

Oto ten sam kod z dodatkową białą spacją, próbując poprawić czytelność :-)

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

Nie znam wbudowanej shufflefunkcji PowerShell, więc zamieniłem każdy wynik w parę klucz-wartość - klucz równy wynikowi kości i wartość równa liczbie losowej. Potem wystarczyło posortować te pary według wartości, a następnie wyprowadzić klucze.

Perl, 179 znaków

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

Oto pełna wersja programu:

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