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:
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
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
((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?
for(i in 0:9)cat(F<-sample(setdiff(1:6,c(F,7-F)),1))
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
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
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
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.
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.
-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:
The term 'random' is not recognized as a cmdlet, function, operable program, or script file. Verify the term and try again.
Get-Randomcmdlet non esisteva in v1.
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
(?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.
(0..9).reduce([]){|m|m<<((1..6).to_a-[d=m[-1]||0,7-d]).shuffle[0]}
>:(?@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.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
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
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.
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;}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);}}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 methoda=randi(6)
for i=1:9;b=1:6;b([a,7-a])=[];a=b(randi(4))
end
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).
c(3,5,1,4,2,6)[(sample(1:6,1)+cumsum(sample((-2:2)[-3],9,T)))%%6+1]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]
[ ]#6LΩUTFX?6LʒDXÊsX+7Ê*}ΩU
Può sicuramente essere giocato a golf, ma al momento non lo vedo ..
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