Rotolamento dei dadi iterati

12

Dato un input in ncui 3 <= n <= 25, eseguire i seguenti passaggi, iniziando con un ndado a faccia singola (facce nel campo [1, n], incluso):

  1. Stampa il risultato del lancio dei ndadi sul lato corrente in gioco, nel modulo kdn: X(dove si Xtrova il risultato ed kè il numero di dadi in gioco).
  2. Se Xè maggiore o uguale a n/2volte il numero di dadi in gioco, aggiungi un dado. Altrimenti, rimuovi un dado.
  3. Se il numero di dadi in gioco è uguale a 0o n, fermati. Altrimenti, vai al passaggio 1.

L'esempio funziona (si noti che l'output tra parentesi è a scopo esplicativo e non è necessario):

6 lati:

1d6: 4 (avg: 3.0, add)
2d6: 6 (avg: 6.0, add)
3d6: 9 (avg: 9.0, add)
4d6: 16 (avg: 12.0, add)
5d6: 13 (avg: 15.0, remove)
4d6: 9 (avg: 12.0, remove)
3d6: 5 (avg: 9.0, remove)
2d6: 7 (avg: 6.0, add)
3d6: 11 (avg: 9.0, add)
4d6: 14 (avg: 12.0, add)
5d6: 17 (avg: 15.0, add)

9-sided:

1d9: 7 (avg: 4.5, add)
2d9: 14 (avg: 9.0, add)
3d9: 18 (avg: 13.5, add)
4d9: 18 (avg: 18.0, add)
5d9: 28 (avg: 22.5, add)
6d9: 26 (avg: 27.0, remove)
5d9: 28 (avg: 22.5, add)
6d9: 34 (avg: 27.0, add)
7d9: 33 (avg: 31.5, add)
8d9: 30 (avg: 36.0, remove)
7d9: 29 (avg: 31.5, remove)
6d9: 35 (avg: 27.0, add)
7d9: 32 (avg: 31.5, add)
8d9: 42 (avg: 36.0, add)

Regole

  • Gli output devono essere esattamente nel formato kdn: X, con le nuove righe che separano ciascun rotolo
  • In realtà devi simulare il lancio di più dadi; [1, n]non è consentito semplicemente restituire un numero intero casuale nell'intervallo (incluso) moltiplicato per il numero di dadi attualmente in gioco, poiché ciò non simula accuratamente il lancio di più dadi.
  • Sono vietate le scappatoie standard
  • Questo è code-golf , quindi vince la risposta più breve in byte

Classifica

Lo snippet di stack in fondo a questo post genera la classifica dalle risposte a) come un elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

## Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostra snippet di codice

code-golf  random 
— Mego
fonte
Lo trovo confuso. Esempio di risposta, per favore?
— Hipe99,
Risposta di esempio , poiché gli esempi sono concisi.
— Hipe99,
La tua modifica è stata chiarita. Grazie!
— Hipe99,
16
Sei sicuro della tua aritmetica? Un d6 convenzionale ha un rotolo medio di 3,5.
— Peter Taylor,
11
Tutte le medie nei tuoi esempi sembrano sbagliate
— edc65

Risposte:

3

Mathematica, 95 89 80 caratteri

For[k=1,0<k<#,If[Print[k,d,#,": ",x=Tr[{1,#}~RandomInteger~k]];x<k/2#,k--,k++]]&

Ungolfed

For[
  k = 1,
  0 < k < #,
  If[
    Print[k, d, #, ": ", x = Tr[{1, #}~RandomInteger~k]];
    x < k/2 #,
    k--,
    k++
  ]
] &
— shrx
fonte
1
@ MartinBüttner grazie per i tuoi suggerimenti. Echosfortunatamente non può prendere una sequenza di input come Printfa.
— Shrx
Oh, buon punto.
— Martin Ender,
3

PHP, 164 121 112 113 109 byte

Versione finale, lo prometto. Migliorato usando il suggerimento di Tito:

function d($x,$y){for($i=$y;$i--;)$r+=rand(1,$x);echo$y."d$x: $r\n";$y+=$r/$y>$x/2?:-1;$y<$x&&$y?d($x,$y):0;}

EDIT: aggiunto un byte extra per la formattazione. Ho dimenticato che c'è un IF che, grazie alla caduta del testo "Aggiungi / Sottotitoli", avrebbe potuto essere un operatore ternario:

function d($x,$y){for($i=$y;$i--;)$r+=rand(1,$x);echo$y."d$x: $r\n";$r/$y>$x/2?$y++:$y--;if($y<$x&&$y)d($x,$y);}

L'output ora assomiglia a:

1d6: 5
2d6: 11
3d6: 8
2d6: 11
3d6: 7
2d6: 4
1d6: 5

EDIT: Grazie a @Manatwork, mi hai salvato molto! Versione nuova e avanzata:

function d($x,$y){for($i=$y;$i--;)$r+=rand(1,$x);echo$y."d$x=$r\n";if($r/$y>$x/2)$y++;else$y--;if($y<$x&&$y){d($x,$y);}}

Voce precedente:

function d($x,$y){for($i=0;$i<$y;$i++)($r+=rand(1,$x));$s=$y."d$x=$r, ";if($r/$y>$x/2){$y++;$s.="add";}else{$y--;$s.="sub";}echo $s."\n";if($y<$x&&$y>0){d($x,$y);}}`

Lancia stampi separati, produce questo:

1d6=6, add
2d6=7, add
3d6=11, add
4d6=14, add
5d6=15, sub
4d6=15, add
5d6=18, add

E si chiama così: d(6, 1);

La visualizzazione del suffisso Adde è Subobbligatoria? Questo non è chiaro dalla tua domanda.

— steenbergh
fonte
Il requisito dice "notare che l'output tra parentesi è a scopo esplicativo e non è richiesto". In questo modo sembra più breve:function d($x,$y=1){for($i=$y;$i--;)$r+=rand(1,$x);echo$y."d$x, $r↵";$r/$y>$x/2?$y++:$y--;if($y<$x&&$y)d($x,$y);}
— arte il
@manatwork Grazie, mi hai davvero aiutato molto!
— Steenbergh,
L'if può essere ancora un ternario, salvando un byte. E rimodellare l'aumento / la diminuzione può salvare due byte:$y-=$r/$y>$x/2?:-1
— Tito
2

Python 3, 125

Salvato 3 byte grazie a DSM.

def x(d):
 import random;c=1
 while 0<c<d:r=sum(map(random.randint,[1]*c,[d]*c));print('%id%i: %i'%(c,d,r));c+=2*(r>=d*c/2)-1

Abbastanza semplice, lancia un mucchio di dadi e controlla la media. Niente di troppo fantasioso qui ancora.
Deve essere chiamato con un int. Quindi, x(6)produrrà qualcosa del genere:

1d6: 5
2d6: 10
3d6: 8
2d6: 7
3d6: 11
4d6: 8
3d6: 13
4d6: 19
5d6: 13
4d6: 15
5d6: 22

.

— Morgan Thrapp
fonte
2

JavaScript (ES6), 97 102 106 112 byte

Grazie @ user81655 e @Jupotter per avermi salvato qualche byte.

f=n=>{for(k=1;k%n;console.log(k+`d${n}: `+x),k+=x<k*n/2?-1:1)for(x=i=k;i--;)x+=Math.random()*n|0}

// 102 bytes:
f=n=>{for(k=1;k%n;console.log(k+`d${n}: `+x),k+=x<k*n/2?-1:1)for(x=i=0;++i<=k;)x+=1+Math.random()*n|0}

// Previous attempt, 112 bytes
f=n=>{k=1;while(k&&k!=n){for(x=i=0;i++<=k;)x+=1+~~(Math.random()*n);console.log(k+`d${n}: `+x);k+=x<k*n/2?-1:1}}

dimostrazione

Funziona solo con browser compatibili con ES6 (al momento include Firefox e Edge, possibilmente con Chrome e Opera con funzioni JavaScript sperimentali abilitate):

f=n=>{for(k=1;k%n;console.log(k+`d${n}: `+x),k+=x<k*n/2?-1:1)for(x=i=k;i--;)x+=Math.random()*n|0}

// Snippet stuff
console.log = x => {
  document.getElementById('O').innerHTML += x + `<br>`;
}

document.getElementById('F').addEventListener('submit', e => {
  document.getElementById('O').innerHTML = ``
  f(document.getElementById('I').valueAsNumber)
})
<form id=F action=# method=get>
  <label>
    Number of faces: 
    <input type=number min=3 max=25 value=9 required id=I>
  </label>
  <button>Play</button>
  
  <div>
    <output id=O></output>
  </div>
</form>
Espandi frammento

— rink.attendant.6
fonte
Si potrebbe cambiare il whilead un forciclo, verso il basso rotondo con |0al posto di ~~()e spostare alcune affermazioni in modo da poter rimuovere le staffe per risparmiare pochi byte. Inoltre ti è permesso di renderlo una funzione anonima (no f=). 103 byte:n=>{for(k=1;k&&k!=n;k+=x<k*n/2?-1:1)for(x=i=0;i++<=k;console.log(k+`d${n}: `+x))x+=1+Math.random()*n|0}
— user81655
@ user81655 Grazie. Per qualche motivo la tua versione ha creato molti output estranei, quindi ho spostato console.logl'altro forloop (mi è costato 1 carattere in più del tuo). Sono ancora arrivato a 106
— rink.attendant.6
L'ho appena scritto senza testarlo, quindi sono contento che abbia funzionato per lo più. :)
— user81655
Puoi ottenere un personaggio sostituendo la k&&k!=ncondizione con il confrontok%n!=0
— Giove
@Jupotter Grazie, k%nfunziona ancora meglio;)
— rink.attendant.6
1

CJam, 45 byte

ri:M;{X__{Mmr+}*[X'dM':S5$N]o_+XM*<_+(-:XM%}g

Provalo online.

Implementa le specifiche in modo piuttosto letterale (inclusa la formula "mean roll" matematicamente errata). Come previsto, il porting del programma GolfScript originale in basso su CJam ha salvato un sacco di byte a causa di nomi di comandi integrati più brevi ( mr, oe ginvece di rand, putse do).

GolfScript, 51 byte

~:&;{1..{&rand+}*[1"d"&": "4$]puts.+1&*<.+(-:1&%}do

Ecco la mia voce GolfScript originale. Notevoli trucchi per il golf includono l' uso del numero 1come variabile pre-inizializzata per memorizzare il numero attuale di dadi da lanciare. (La versione CJam invece utilizza X, che CJam inizializza al valore 1.)

Ps. Visto il titolo, inizialmente volevo rispondere a questo in AnyDice . Ma risulta essere una scelta orribile per questa sfida, e non penso che sia tecnicamente possibile usarlo per implementare queste specifiche come indicato.

Il problema è che AnyDice è un linguaggio specifico del dominio per la scrittura di programmi deterministici per il calcolo delle statistiche di lancio dei dadi. Mentre l'ispezione dei possibili risultati di un tiro e l'esecuzione di tiri condizionali basati su di essi è possibile tramite la ricorsione, non c'è modo di generare alcuna casualità effettiva. Quindi, mentre puoi simulare questa sequenza di tiri di dado in AnyDice, tutto ciò che puoi ottenere, dato che l'output sono statistiche su cose come, ad esempio, il numero di tiri fino al termine del processo o la distribuzione dei risultati in un determinato passaggio.

Detto questo, ecco il più vicino che potrei ottenere in AnyDice :

N: 6
K: 1
function: clip X:n { result: X * (X < N) }
function: adjust X:n { result: [clip X + ((XdN)*2 >= X*N)*2-1] * (X > 0) }
loop I over {1..20} {
  output K named "dice in roll [I]"
  output KdN named "outcome of roll [I]"
  K: [adjust K]
}

Questo non è un codice particolarmente golfistico, dal momento che sembrava un esercizio di futilità. I trucchi standard per giocare a golf con la lingua, come abbreviare i nomi delle funzioni ed eliminare gli spazi bianchi non necessari, dovrebbero esaurire la maggior parte del potenziale del golf.

Il trucco chiave usato qui è che, quando si chiama una funzione in attesa di un numero (come indicato dalla :ndefinizione della funzione) in AnyDice e si passa un dado (cioè una distribuzione di probabilità), AnyDice valuta automaticamente la funzione per tutto il possibile valori del dado e combina i risultati in un nuovo dado.

Ecco uno screenshot dell'output (in formato grafico a barre) per i primi tre tiri:

Screenshot di AnyDice

(Si noti che la colonna "0" in ciascun grafico indica la probabilità che l'iterazione fermato, a causa del numero di dadi che colpiscono sia 0 o N, prima del tiro corrente. Questo sembra essere un modo conveniente per rappresentare la condizione di arresto, poiché ovviamente rotolare 0dN produce sempre 0.)

— Ilmari Karonen
fonte
1

R, 103 byte

Un'attuazione abbastanza semplice. I tiri di dado vengono effettuati da sum(sample(n,i)).

i=1;n=scan();while(i&i<=n){cat(i,'d',n,': ',s<-sum(sample(n,i)),'\n',sep='');i=ifelse(s<i*n/2,i-1,i+1)}

Prova

> i=1;n=scan();while(i&i<=n){cat(i,'d',n,': ',s<-sum(sample(n,i)),'\n',sep='');i=ifelse(s<i*n/2,i-1,i+1)}
1: 9
2: 
Read 1 item
1d9: 9
2d9: 14
3d9: 10
2d9: 14
3d9: 9
2d9: 9
3d9: 12
2d9: 7
1d9: 9
2d9: 11
3d9: 17
4d9: 18
5d9: 25
6d9: 29
7d9: 33
8d9: 43
9d9: 45
>
— MickyT
fonte
1

CoffeeScript, 106 99 byte

f=(n,k=1)->(x=k;x+=Math.random()*n|0for[k..0];console.log k+"d#{n}: "+x;k+=x<k*n/2&&-1||1)while k%n

# Previous attempt, 106 bytes
f=(n,k=1)->(x=i=0;x+=1+Math.random()*n//1while++i<=k;console.log k+"d#{n}: "+x;k+=x<k*n/2&&-1||1)while k%n

Ungolfed

f = (n, k = 1) ->
 (x = k
 x += 1 + Math.random() * n | 0 for [k..0]
 console.log k + "d#{n}: " + x
 k += x < k * n / 2 && -1 || 1
 ) while k % n
— rink.attendant.6
fonte
1

Julia, 77 byte

n->(N=1;while 0<N<n k=sum(rand(1:n,N));print(N,"d$n: $k
");N+=1-2(2k<N*n)end)

La maggior parte di questo dovrebbe essere autoesplicativo: nella printstringa viene utilizzata una nuova riga anziché utilizzare printlnper salvare un byte. rand(1:n,N)produce Nnumeri interi casuali tra 1 e n.

— Glen O
fonte
1

Rubino, 93 90 82 caratteri

->n{d=s=2
puts"#{d}d#{n}: #{s=eval'+rand(n)+1'*d}"while(d+=s<d*n/2.0?-1:1)>0&&d<n}

Esecuzione di esempio:

2.1.5 :001 > -->n{d=s=2;puts"#{d}d#{n}: #{s=eval'+rand(n)+1'*d}"while(d+=s<d*n/2.0?-1:1)>0&&d<n}[6]
1d6: 5
2d6: 10
3d6: 6
2d6: 5
1d6: 5
2d6: 8
3d6: 15
4d6: 18
5d6: 22
— uomo al lavoro
fonte
0

QBIC , 83 byte (non concorrenti)

:c=a{e=0[1,q|e=e+_rq,a|]?!q$+@d|!+a$+@:|+!e$~e<c/2|q=q-1\q=q+1]c=q*a~q=a|_X]~q=0|_X

Spiegazione:

q                    Tracks the number of dice (is implicitly 1 at the start)
:                    Takes input from a CMD line parameter
[1,q|e=e+_rq,a|]     Rolls the dice separately
?!q$+@d|!+a$+@:|+!e$ Prints the roll result (requires an unfortunate amount of casting...)
~e<c/2|q=q-1\q=q+1]  Checks whether to increase or decrease
~q=a|_X]~q=0|_X      Tests the amount of dice and quits on either boundary.
— steenbergh
fonte
0

PHP, 104 byte

for($n=$argv[$k=1];$k&&$k<$n;print$k."d$n: $x\n",$k-=$x<$n*$k/2?:-1)for($x=$i=0;$i++<$k;)$x+=rand(1,$n);

Corri con php -r '<code>' <N>

abbattersi

for($n=$argv[$k=1];     // import input, init number of dice
    $k&&$k<$n;          // while 0<$k<$n
    print$k."d$n: $x\n",    // 2. print results
    $k-=$x<$n*$k/2?:-1      // 3. remove or add a die
)
    for($x=$i=0;$i++<$k;)   // 1. roll dice separately
        $x+=rand(1,$n);         // sum up results
— Titus
fonte
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.