Lancement de dés itérés

12

Étant donné une entrée noù 3 <= n <= 25, effectuez les étapes suivantes, en commençant par un ndé simple face (faces dans la plage [1, n], inclus):

  1. Imprime le résultat du lancer des ndés en cours, sous la forme kdn: X(où Xest le résultat et kle nombre de dés en jeu).
  2. Si Xest supérieur ou égal au n/2nombre de fois en jeu, ajoutez un dé. Sinon, retirez un dé.
  3. Si le nombre de dés en jeu est égal à 0ou n, arrêtez. Sinon, passez à l'étape 1.

L'exemple s'exécute (notez que la sortie entre parenthèses est pour explication et n'est pas requise):

6 faces:

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 faces:

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)

Règles

  • Les sorties doivent être exactement au format kdn: X, avec des retours à la ligne séparant chaque rouleau
  • Vous devez simuler le fait de lancer plusieurs dés; renvoyer simplement un entier aléatoire dans la plage [1, n](incluse) multiplié par le nombre de dés actuellement en jeu n'est pas autorisé, car cela ne simule pas avec précision le lancement de plusieurs dés.
  • Les failles standard sont interdites
  • Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte

Classement

L'extrait de pile au bas de cet article génère le classement à partir des réponses a) en tant que liste des solutions les plus courtes par langue et b) en tant que classement général.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle de démarque suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

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

Afficher l'extrait de code

code-golf  random 
— Mego
source
Je trouve cela déroutant. Exemple de réponse, s'il vous plaît?
— Hipe99
Exemple de réponse , car les exemples sont laconiques.
— Hipe99
Votre modification a été clarifiée. Merci!
— Hipe99
16
Êtes-vous sûr de votre arithmétique? Un d6 conventionnel a un roulis moyen de 3,5.
— Peter Taylor
11
Toutes les moyennes dans vos exemples semblent fausses
— edc65

Réponses:

3

Mathematica, 95 89 80 caractères

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

Non golfé

For[
  k = 1,
  0 < k < #,
  If[
    Print[k, d, #, ": ", x = Tr[{1, #}~RandomInteger~k]];
    x < k/2 #,
    k--,
    k++
  ]
] &
— shrx
source
1
@ MartinBüttner merci pour vos suggestions. Echone peut malheureusement pas prendre une séquence d'entrées comme le Printfait.
— shrx
Oh, bon point.
— Martin Ender
3

PHP, 164 121 112 113 109 octets

Version finale, je le promets. Amélioré en utilisant la suggestion de Titus:

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: ajout d'un octet supplémentaire pour le formatage. J'ai oublié qu'il y a un IF dedans qui, grâce à la suppression du texte "add / sub", aurait pu être un opérateur ternaire:

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

La sortie ressemble maintenant à:

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

EDIT: Merci à @Manatwork, ça m'a sauvé beaucoup! Version nouvelle et améliorée:

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

Entrée précédente:

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);}}`

Lance des matrices séparées, produit ceci:

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

Et cela s'appelle ainsi: d(6, 1);

L'affichage du suffixe Addet Subest-il obligatoire? Cela ne ressort pas clairement de votre question.

— steenbergh
source
L'exigence indique «notez que la sortie entre parenthèses est pour explication et n'est pas requise». Cette façon semble plus courte: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);}
— manatwork
@manatwork Merci, vous avez vraiment beaucoup aidé!
— steenbergh
Le if peut toujours être un ternaire, économisant un octet. Et le remodelage de l'augmentation / diminution peut économiser deux octets:$y-=$r/$y>$x/2?:-1
— Titus
2

Python 3, 125

Enregistré 3 octets grâce à 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

Assez simple, lance un tas de dés et vérifie la moyenne. Rien d'extraordinaire ici encore.
Il doit être appelé avec un int. Donc, x(6)cela produira quelque chose comme ceci:

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

.

— Morgan Thrapp
source
2

JavaScript (ES6), 97 102 106 112 octets

Merci @ user81655 et @Jupotter de m'avoir sauvé quelques octets.

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

Démo

Cela ne fonctionne que dans les navigateurs compatibles ES6 (pour le moment qui incluent Firefox et Edge, éventuellement avec Chrome et Opera avec les fonctionnalités expérimentales JavaScript activées):

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>
Développer l'extrait

— rink.attendant.6
source
Vous pouvez changer la whileen forboucle, arrondir à la |0place de ~~()et déplacer quelques instructions afin de pouvoir supprimer les crochets pour économiser quelques octets. Vous pouvez également en faire une fonction anonyme (non f=). 103 octets: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 Merci. Pour une raison quelconque, votre version a créé beaucoup de sortie étrangère, j'ai donc déplacé la console.logvers l'autre forboucle (m'a coûté 1 char de plus que la vôtre). Toujours à 106
— rink.attendant.6
Je viens d'écrire ceci sans le tester, donc je suis content que cela ait surtout fonctionné. :)
— user81655
Vous pouvez gagner un personnage en remplaçant la k&&k!=ncondition par la comparaisonk%n!=0
— Jupotter
@Jupotter Merci, ça k%nmarche encore mieux;)
— rink.attendant.6
1

CJam, 45 octets

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

Essayez-le en ligne.

Implémente la spécification de façon assez littérale (y compris la formule mathématique incorrecte du "rouleau moyen"). Comme prévu, le portage du programme GolfScript d'origine ci-dessous vers CJam a enregistré un tas d'octets en raison de noms de commandes intégrés plus courts ( mr, oet gau lieu de rand, putset do).

GolfScript, 51 octets

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

Voici mon entrée GolfScript originale. Les astuces de golf notables incluent l' utilisation du nombre 1comme variable commodément pré-initialisée pour stocker le nombre actuel de dés à lancer. (La version CJam utilise à la place X, que CJam initialise à la valeur 1.)

Ps. En voyant le titre, je voulais à l'origine répondre à cela dans AnyDice . Mais cela s'avère être un choix horrible pour ce défi, et je ne pense pas qu'il soit même techniquement possible de l'utiliser pour implémenter cette spécification comme indiqué.

Le problème est que AnyDice est un langage spécifique au domaine pour écrire des programmes déterministes pour calculer les statistiques de roulement des dés. Bien qu'il soit possible d'inspecter les résultats possibles d'un rouleau et d'effectuer des rouleaux conditionnels en fonction de ceux -ci via la récursivité, il n'y a aucun moyen de générer un caractère aléatoire réel. Ainsi, bien que vous puissiez simuler cette séquence de lancers de dés dans AnyDice, tout ce que vous pouvez obtenir en sortie est des statistiques sur, par exemple, le nombre de lancers jusqu'à la fin du processus ou la distribution des résultats à une étape donnée.

Cela dit, voici le plus proche que je pouvais obtenir dans 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]
}

Ce n'est pas un code particulièrement golfé, car cela semblait être un exercice futile. Les astuces de golf standard en accolade, comme raccourcir les noms de fonction et éliminer les espaces inutiles, devraient de toute façon épuiser la plupart du potentiel de golf.

L'astuce clé utilisée ici est que, lorsque vous appelez une fonction qui attend un nombre (comme indiqué :ndans la définition de fonction) dans AnyDice, et lui passez un dé (c'est-à-dire une distribution de probabilité) à la place, AnyDice évalue automatiquement la fonction pour tous les possibles valeurs du dé, et combine les résultats dans un nouveau dé.

Voici une capture d'écran de la sortie (au format graphique à barres) pour les trois premiers rouleaux:

Capture d'écran d'AnyDice

(Notez que le « 0 » colonne dans chaque graphique indique la probabilité que l'itération est arrêté, en raison du nombre de dés frapper soit 0 ou N, avant que le rouleau actuel. Cela arrive à être un moyen commode de représenter la condition d' arrêt, depuis bien sûr, rouler 0dN donne toujours 0.)

— Ilmari Karonen
source
1

R, 103 octets

Une implémentation assez simple. Les jets de dés sont effectués par 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)}

Essai

> 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
source
1

CoffeeScript, 106 99 octets

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

Non golfé

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
source
1

Julia, 77 octets

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 plupart de ces informations devraient être explicites - une nouvelle ligne réelle est utilisée dans la printchaîne plutôt que printlnpour enregistrer un octet. rand(1:n,N)produit Ndes entiers aléatoires entre 1 et n.

— Glen O
source
1

Rubis, 93 90 82 caractères

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

Exemple d'exécution:

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
— homme au travail
source
0

QBIC , 83 octets (non concurrents)

: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

Explication:

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
source
0

PHP, 104 octets

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

Courir avec php -r '<code>' <N>

panne

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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.