Ribaltamento casuale dei dadi


14

In un dado standard (dado) i numeri sono disposti in modo tale che le facce opposte si sommino a sette. Scrivi il programma più breve possibile nella tua lingua preferita che genera un lancio casuale seguito da 9 suggerimenti casuali. Una mancia è un quarto di giro del dado, ad esempio se il dado è rivolto verso 5, tutti i possibili ribaltamenti sono 1,3,4 e 6.

Esempio di output desiderato:

1532131356

Risposte:


5

GolfScript, 26 caratteri

0{(.6,5@--\-.,rand=).}10*;

Una versione leggermente più compressa di Joey , che sostanzialmente risolve il problema con l'indicizzazione zero.


9

Ruby, 44

c=0;10.times{$><<c=([*1..6]-[c,7-c]).sample}

Ho trovato il trucco [* 1..6] sperimentando fortunatamente.


1
Alcuni bei trucchi qui, grandi cose. Colpendomi sulla testa per aver perso il metodo di esempio Array #.
Lars Haugseth,

4

JavaScript (71 caratteri)

Potrebbe essere necessario sostituire printcon alerto qualcos'altro, a seconda dell'ambiente JavaScript.

for(C=L=T=0;C++<10;print(L=T))while(!(T-L&&T+L-7))T=Math.random()*6+1|0

unire i loop incrementando in modo condizionale quello esterno quando viene trovato un valore: for (b = n = 10; n; ab && a + b-7 && print (b = a, n -)) a = Math.random () * 6 + 1 | 0
imma,

4

GolfScript, 28

0:|;{7,[0|7|-]-.,rand=:|}10*

3

bash

#/!bin/bash
f=`expr $RANDOM % 6` 
f=`expr $f + 1`
printf "$f"
for ((i=0; i<9; i++))
do
   ((bad=7-$f))
   next=`expr $RANDOM % 6`
   next=`expr $next + 1`
   while [ $next -eq $bad ] || [ $next -eq $f ]
   do
      next=`expr $RANDOM % 6`
      next=`expr $next + 1`
   done
printf "$next"
f=$next
done

codice di esempio: http://ideone.com/CCfro


L'uso di ((var=expression))è molto bello - ho pensato che il modo più breve fosse var=$((expression))Ma perché lo usi una volta sola e sprechi tonnellate di personaggi in expr in backtick?
Peter Taylor,

Non eseguo gran parte degli script di shell, ma per qualche motivo ((var = expr)) in alcuni punti non sono riusciti (sì strano: P) Da quando ho iniziato questo script, ho in qualche modo completato. :)
Aman ZeeK Verma,


2

Bash con un solo loop: 100 99 98 96

per ((i = 10, f = RANDOM% 6 + 1; i -;)) do
printf $ f
((N = RANDOM% 4 + 1, m = f <4 f: 7-f, f = n <m || ++ n <7-m n: n + 1))
fatto

http://ideone.com/XrZO7

L'idea chiave è che per scegliere un numero casuale in [1, x] che non è uguale a y è possibile scegliere un numero casuale in [1, x-1] e quindi incrementare se è> = y. Per questo problema vogliamo un numero casuale in [1,6] che non sia uguale a f o 7-f. Dobbiamo fare i due test in ordine min (f, 7-f), max (f, 7-f).

Supponendo che un ambiente inizialmente vuoto possa salvare 2 caratteri non inizializzando i e cambiando la condizione del loop in i++<10


2

Bash: 97 94 92 90 89 87

Molto colpito dalla risposta di Aman ZeeK Verma:

per ((i = 10, f = 0; i -;)) fare
per ((n = f; n == f || n + f == 7; f = RANDOM% 6 + 1)):
fatto
printf $ f
fatto

http://ideone.com/QiuTx

NB probabilmente può essere ridotto di 5 caratteri modificando la prima riga in for((;i++<10;))ma ciò rende ipotesi che non sono sempre valide. Funzionerebbe bene in ideone ma qualcuno che lo esegue da una shell potrebbe avere io fesportato in qualcosa di diverso da zero.


Mi piacerebbe fare una versione senza il ciclo interno, ma temo che sarà più lungo.
Peter Taylor,

Questo è estremamente fantastico, sono troppo crudo per bash immagino :)
Aman ZeeK Verma,

@Aman, la maggior parte non è specifica per bash. Sono solo alcune decine di perfezionamenti con test dopo ognuno e inversioni quando ho rotto qualcosa. L'unico pezzo che è davvero un trucco bash è il noop, che ho dovuto cercare. Se hai tempo di leggere man bash, però, lo consiglio. Una volta l'ho letto dall'inizio alla fine, e solo avere una vaga idea di ciò che è possibile e vale la pena guardare in alto mi è servito bene.
Peter Taylor,

2

Windows PowerShell, 45

-join(0..9|%{($d=1..6-ne(7-$d)-ne$d|random)})

Abbastanza banale, in realtà. Genero un elenco di possibili tiri di dado1..6 e quindi seleziono solo quelli non uguali a sette meno l'ultimo lancio e quindi solo quelli non uguali all'ultimo lancio. Dall'elenco rimanente seleziono quindi un elemento casuale e lo assegno a$d . Poiché $dinizialmente viene trattato quando 0lancia un dado normale la prima volta.

Script di prova:

for($i=0;$i-lt20;$i++){
    $o=@(./tipping.ps1)
    if ($i-gt0-and$o-eq$o2) { throw "Must have random output" }
    if ($o.count-ne1) { throw "Must only have one line of output" }
    if ($o[0]-match'[^1-6]'){ throw "Invalid characters" }
    if($o[0].length-ne10){ throw "Wrong length: $($o[0].length)" }
    $r=[char[]]($o[0])|%{$_-48}
    for ($x=1;$x-lt$r.count;$x++){
        if ($r[$x-1]+$r[$x]-eq7) { throw "Not a tipping: $($r[$x-1]) and $($r[$x])" }
    }
    $o2=$o
}

Storia:

  • 18/02/2011 11:57 (61) Primo tentativo.
  • 18/02/2011 11:58 (45) Non ho bisogno di generare il primo numero separatamente.

RicevoThe term 'random' is not recognized as a cmdlet, function, operable program, or script file. Verify the term and try again.
Peter Taylor, il

@Peter: PowerShell v2, per favore. Il Get-Randomcmdlet non esisteva in v1.
Joey,

2

J

Questo dovrebbe funzionare ma sfortunatamente il generatore casuale di J si blocca dopo la terza iterazione:

a=:>:i.6
f=:a#~1-(+&(a=])7&-)
((,(?4)&{@f@(_1&{))^:9)>:?6

6 4 5 4 5 4 5 4 5 4


Non sono affatto un esperto di J, ma mi sembra da quello che ho sofferto componendo la mia risposta J a questo thread che (?4)tende a essere arrotolato una volta e trattato come una costante per le successive iterazioni se non stai attento. Ci ho lavorato usando un (?@4:)costrutto simile.
JB,

2

Rubino

66 caratteri

(0..9).reduce([]){|m|m<<((1..6).to_a-[d=m[-1]||0,7-d]).shuffle[0]}

2

J, 30 caratteri

>:(?@4:{(i.6)-.],5&-)^:(<10)?6

6 2 3 5 4 2 4 1 3 6

Spiegazioni (leggi da destra a sinistra):

  • ?6 restituisce un numero casuale compreso tra 0 e 5
  • ^:(<10)applica una funzione 9 volte, accumulando i risultati lungo il percorso. La funzione è:
  • ?@4:{(i.6)-.],5&-
    • ] , 5&- restituisce un array del numero di input e il suo complemento a 5 (attualmente stiamo gestendo numeri basati su 0, quindi la somma delle facce opposte è 5)
    • (i. 6) -. li rimuove dal set completo di numeri interi da 0 a 5. Siamo rimasti con tutte le posizioni valide dopo una singola operazione di ribaltamento dalla posizione di input.
    • ?@4: { ne sceglie uno a caso.
  • >: incrementa l'intera sequenza per riportare le cifre nell'intervallo da 1 a 6.

Bel pensiero di ">:" alla fine.
Eelvex,

1
@Eelvex Non ho idea del perché i dadi del mondo reale siano da 1 a 6 quando tutti i ragionamenti sensibili su di loro usano da 0 a 5.: D
JB

2

GS2, 16 byte

16 2f 25 08 41 20 17 30 16 2f 31 31 25 09 19 32

Ecco come funziona

16 2f 25     # make range from 1 to 6 and push random element
08           # start block
    41       # duplicate top of stack twice
    20 17 30 # negate top of stack and add 7
    16 2f    # push range from 1 to 6
    31 31    # do set-wise difference with each of the two previous numbers
    25       # push a random element from the list
09           # end block
19 32        # repeat block 9 times

Penso che gs2 sia più recente di questa sfida.
lirtosiast,

1

QBasic (71 caratteri)

Le due nuove linee sono necessarie e incluse nel conteggio dei personaggi come un personaggio ciascuno.

RANDOMIZE:FOR I=0TO 9
1N=INT(RND*6)+1:IF L=N OR L+N=7THEN 1
?N:L=N:NEXT

1

TI-BASIC, 38 34

For(I,1,9
Ans→X
Repeat Ans≠X and Ans≠7-X
randInt(1,6
End
Disp Ans
End

Soluzione noiosa, ma è più breve della revisione precedente. Approfitto del fatto che su un nuovo calcolatore Ansviene inizializzato a zero.


Non so se sia possibile, ma darò 50 rappresentanti a chiunque riesca a trovare una soluzione più breve.
lirtosiast,

Come stai calcolando 34?
ricorsivo

Ogni token qui è un byte in memoria ; è standard per TI-BASIC essere segnato in questo modo. Se hai una calcolatrice, digita il programma, guarda la schermata di gestione della memoria, quindi sottrai 9 e sottrai la lunghezza del nome del programma per ottenere la dimensione del codice.
lirtosiast,

1

Java 8, 130 byte

v->{int d=(int)(Math.random()*6+1),i=10,p;String r=""+d;for(;i-->0;r+=d)for(p=d;p==d|p+d==7;d=(int)(Math.random()*6+1));return r;}

Provalo qui.

Come programma completo con metodo principale dettagliato, invece, sarebbero 178 byte :

interface M{static void main(String[]a){int d=(int)(Math.random()*6+1),i=10,p;String r=""+d;for(;i-->0;r+=d)for(p=d;p==d|p+d==7;d=(int)(Math.random()*6+1));System.out.print(r);}}

Provalo qui.

Semi-port della risposta Bash di @AmanZeeKVerma .

Spiegazione:

 v->{              // Method with empty unused parameter and String return-type
   int d=(int)(Math.random()*6+1),
                   //  Random dice-roll 1-6
       i=10,       //  Counter-integer, starting at 10
       p;          //  Temp integer to store new side
   String r=""+d;  //  Result-String, starting at the first dice-roll
   for(;i-->0;     //  Loop (1) 10 times:
       r+=d)       //    After every iteration, append the result with a random side
     for(p=d;      //   Set the new side to the current side
         p==d      //   Loop (2) as long as the new side and current side are the same
         |p+d==7;  //   or as long as both combined are exactly 7:
       d=(int)(Math.random()*6+1)
                   //    Set the new side to a random side 1-6
     );            //   End of loop (2)
                   //  End of loop (1) (implicit / single-line body)
  return r;        //  Return the result-String
}                  // End of method


0

> <> , 71 byte

Sono contento di poter mostrare la xrandomizzazione del puntatore di codice di <> quando non ricordo di averlo visto qui.

a&0 v
 /2v
1x3v 
>x< <<
6x4v
 \5v ~
:{:/ ^?=}
:{:/ ^?=7+}
:~$<^&;!?:-1&n

Puoi provarlo su questo interprete online (incolla il codice, invia, avvia).


Otterrai il mio voto una volta risolta la soluzione.
lirtosiast,

@ThomasKwa Fatto, potrei essere in grado di giocarci un po ', ma almeno ora è funzionale.
Aaron,

0

R , 67 byte

c(3,5,1,4,2,6)[(sample(1:6,1)+cumsum(sample((-2:2)[-3],9,T)))%%6+1]

Provalo online!

C'è una risposta da golfista R ma questo penso che sia un approccio diverso dalle risposte presentate finora.

c(3,5,1,4,2,6)                                                     #A dice and its facets
               (sample(1:6,1)                                      #Initial dice roll
                             +cumsum(sample((-2:2)[-3],9,T)))      #9 tippings in c(-2,-1,1,2)
                                                             %%6+1 #converts to values in [0,6]
              [                                                   ]#

0

05AB1E , 23 byte

6LΩUTFX?6LʒDXÊsX+7Ê*}ΩU

Può sicuramente essere giocato a golf, ma al momento non lo vedo ..

Provalo online.

Spiegazione:

6LΩ              # Pick a random value from the range [1,6]
                 #  i.e. [1,2,3,4,5,6] → 3
   U             # Save this random value in variable `X`
TF               # Loop 10 times:
  X?             #  Print `X` without newline to STDOUT
  6Lʒ     }      #  Create a range [1,6] again, and filter it by:
     DXÊ         #   Check if the current value is not equal to `X`
                 #    i.e. 1 and 3 → 1 (truthy)
                 #    i.e. 3 and 3 → 0 (falsey)
     sX+         #   Sum the current value with `X`
                 #    i.e. 1 and 3 → 4
                 #    i.e. 3 and 3 → 6
        7Ê       #   And check if it's not equal to 7
                 #    i.e. 4 and 7 → 1 (truthy)
                 #    i.e. 6 and 7 → 1 (truthy)
     *           #   If both checks are truthy, keep it in the filtered list
                 #    i.e. 1 and 1 → 1 (truthy)
                 #    i.e. 0 and 1 → 0 (falsey)
           Ω     #  Pick a random value from the filtered list
                 #   i.e. [1,2,5,6] → 1
            U    #  And save it in variable `X` for the next iteration of the loop
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.