Generuj losową tablicę boggle

16

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 więc wygrywa program z najkrótszą liczbą bajtów!

boothby
źródło
3
nie może być litery F, jeśli są litery K. oznacza to, że nie możesz przeliterować ... : P
Blazer
@ Blazer: Tak, a ty też nie możesz przeliterować. : P
Ry-

Odpowiedzi:

5

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.

Ilmari Karonen
źródło
Ach - zapomniałem, że można sortować według mapowania.
Peter Taylor,
4

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

marynarka
źródło
1
możesz ulepszyć kod dzięki indeksowaniu print a+' u'[a=='Q']orazprint'\n'[j%4:]
Keith Randall
@keith dzięki! Zrobiłem to jeszcze mocniej, łącząc te dwie sztuczki :)
Blazer
1
Udało mi się sprowadzić go do 218, nie zabijając go (tak myślę?): 1) Zmień instrukcję importu na from random import*i usuń wszystko r.. 2) Zmień separatory w ciągu na `` (spacja) i skorzystaj z str.splitdomyślnego argumentu. 3) Pozbądź się wszystkiego, co ma związek z jużytkowaniem '\n'[len(d)%4:]. 4) Użyj list.popdomyślnego argumentu. 5) ... 6) Zysk!
Dillon Cower
@DC ahh dzięki! Jestem zaskoczony, że ich przeoczyłem. ale chyba dostaję to za napisanie tego w ciągu kilku minut: P
Blazer
1
I zmniejszyłem go jeszcze bardziej o 3 znaki przy użyciu małej sztuczki z mapą, ale musiałem zachować j=0...+'\n'[j%4:], aby zadziałało
Blazer
3

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*
Peter Taylor
źródło
Jeśli moja (ręczna) analiza jest poprawna, nie ma żadnych innych ciągów, które byłyby zarówno wystarczająco długie, jak i wystarczająco częste, aby skompresować dane przez prostą zamianę, niezależnie od kolejności kości i wewnątrz kości.
Peter Taylor,
Udało mi się zmniejszyć tabelę z 96 do 84 znaków, przeplatając kości i stosując kodowanie długości przebiegu. Dekodowanie, które może nadrobić różnicę ... z pewnością ma znaczenie dla Pythona.
stoisko
Możesz zakodować 6 liter w 30 bitach, a następnie w 5 znakach do wydrukowania, oszczędzając 16 bajtów. Ale potrzebujesz trochę shift / mask, aby je wyodrębnić.
ugoren
@ugoren, Ilmari już to zrobił.
Peter Taylor,
@PeterTaylor, jeśli powiesz, że tak, wierzę ci (nigdy nie zadałem sobie trudu, aby nauczyć się gry w golfa). Ale wydaje się, że używa 57 znaków niedrukowalnych, podczas gdy ja sugerowałem 80 do druku.
ugoren
2

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ą)

Mark Thomas
źródło
Właśnie zatwierdziłem zmianę tej odpowiedzi przez „anonimowego użytkownika”; Zakładam, że to byłeś ty, Mark, i po prostu zapomniałeś się zalogować. (Ps. Wydajność nie wydaje się być zgodna ze specyfikacją; użycie x.join(" ").gsub(/Q ?/,"Qu")poprawiłoby to kosztem trzech dodatkowych znaków).
Ilmari Karonen
(To jedna dodatkowa spacja w joinłańcuchu oraz dodatkowa spacja i znak zapytania w wyrażeniu regularnym, na wypadek, gdyby oprogramowanie SE zmieniło spacje ...)
Ilmari Karonen
@IlmariKaronen Dzięki, nie zauważyłem dwóch spacji między kolumnami. Powinien być teraz sprecyzowany.
Mark Thomas
2

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.

Andrew Shepherd
źródło
może mógłbyś użyć ostatnich cyfr w bieżącym czasie w ms jako wartości sortującej?
Blazer
@ Blazer - prawdopodobnie, ale „losowy” wymaga tylko sześciu znaków :-)
Andrew Shepherd
0

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";
}
chlebak
źródło