8 votes

Quelle est la durée prévue d'un jeu de la guerre ?

Dans le jeu de cartes Guerre vous distribuez un jeu standard de 52 cartes entre deux joueurs. Les joueurs retournent ensuite les cartes, la carte la plus élevée gagnant. En cas d'égalité (guerre), chaque joueur joue N cartes supplémentaires et le joueur ayant la Nième carte la plus haute gagne toutes les cartes (les égalités suivantes suivent les mêmes règles). Le jeu peut durer très longtemps et semble ne jamais durer très longtemps.

Quel est le nombre prévu de "tours" jusqu'à ce que le jeu soit terminé ?

J'ai appris à jouer à la guerre avec N égal à 3 (c'est-à-dire qu'un total de 10 cartes sont jouées dans une guerre : l'égalité originale, 3 faces cachées et une carte de comparaison finale).

Pour être complet, supposons que la partie est terminée si un joueur a moins de 5 cartes et entre en guerre (c'est-à-dire s'il n'a pas de dernière carte à retourner).

Supposons qu'après avoir joué votre dernière carte de votre main, vous mélangez les cartes gagnantes dans un ordre aléatoire et reprenez.

Supposons que les cartes sont dans un ordre aléatoire pour commencer.

12voto

Cohensius Points 3357

En fait, la guerre n'est pas un jeu mais un Automates car les joueurs n'ont pas le choix.

Wimpy Programmer l'a déjà fait simulation il a découvert qu'en mélangeant les cartes gagnantes. le nombre moyen de tours est de 262 le mode est 84, et le maximum (sur un échantillon de 100 000 essais) est 2 702 tours. Il a également constaté que sans mélange des cartes gagnantes, le jeu pourrait être sans fin.

Il a utilisé N=2 alors que vous jouez avec N=3, un N plus élevé raccourcit la partie, cependant je ne pense pas que cela fera une grande différence.

turns of war untill someone wins (thousand)

4voto

Mike Breen Points 1434

En tant que problème mathématique, il s'agit d'un cas de marche aléatoire ("marche" de N cartes à la fois du jeu de l'adversaire vers le vôtre, où N est généralement égal à un, mais peut être égal à 4 ou 7 ou autre en fonction des égalités). Il est souvent présenté comme le problème de la "ruine des joueurs". En ignorant le problème des égalités et en traitant chaque jet de cartes comme un essai indépendant, le nombre moyen de tours est de 26*26 = 676 tours.

Le fait de prendre en compte les égalités réduirait considérablement le nombre de N, ce qui permettrait de faire des pas plus importants de temps en temps. Le nombre moyen de tours lorsque le pas est de 5 (c'est-à-dire que chaque tour est une guerre qui est résolue au premier bris d'égalité) équivaut à jouer avec 6 cartes chacun (26/5, arrondi au supérieur). Et 6*6 = 36 tours.

Il s'agit donc de déterminer la probabilité des grandes étapes. On peut s'attendre à des égalités dans environ 3/51 des cas (lorsque vous jouez une carte, il y a 3 cartes qui peuvent vous égaler parmi les 51 autres cartes). 48/51 = taille de pas 1, 3/51 * 46/49 = taille de pas 5, 3/51 * 3/49 * 44/47 = taille de pas 9, et ainsi de suite. Cela donne une taille de pas moyenne d'environ 1,25. Une partie jouée avec tous les pas égaux à 1,25 devrait durer environ 21*21 = 441 tours (26/1,25 = 21 cartes par équiv). Il faut ensuite réduire encore ce chiffre pour tenir compte de la possibilité de mort subite lorsque l'une des égalités survient alors qu'un joueur n'a plus de cartes. (Désolé, je n'ai pas les détails sur la façon de faire cela exactement).

EDIT : Je dois également souligner que cette approche suppose que les essais sont indépendants. C'est en fait la différence entre les dés et les cartes. Chaque lancer de dé est indépendant. Mais chaque tirage ne l'est pas -- il dépend de ce qui a été tiré / de ce qui reste. Et dans le cas de la guerre, gagner un essai améliore généralement vos chances au Kème tirage suivant (lorsque vous tirez à nouveau cette carte). C'est un très léger (IMO) effet de leader en fuite (atténué par le fait que l'on reçoit aussi la carte perdante, mais je pense quand même que le résultat net est un gain). Et cela multipliera l'avantage, s'il y en a un, accordé à un joueur par rapport à l'autre lors de la distribution initiale. En d'autres termes, toute légère déviation vers les cartes les plus élevées lors de la distribution initiale sera amplifiée à chaque tour de jeu successif.

Pour en savoir plus :

Marche aléatoire simple : http://www2.math.uu.se/~sea/kurser/stokprocmn1/slumpvandring_fra.pdf

Premier passage d'un marcheur aléatoire unidimensionnel https://www.math.ucdavis.edu/~tracy/courses/math135A/UsefullCourseMaterial/firstPassage.pdf

2voto

DarkCygnus Points 3350

Eh bien, à partir de ça même lien que vous avez partagé, sur le tableau récapitulatif à droite se lit :

Temps de jeu 10 à 40 minutes.

Ce qui dit directement la durée moyenne d'un jeu.

Maintenant, les tours sur ce jeu, selon mon expérience, sont assez rapides. Ils peuvent durer quelques secondes (révéler les cartes, quelqu'un gagne, les cartes sont prises, fin du tour), ou en cas d'égalité quelques secondes supplémentaires.

Ainsi, en supposant qu'un tour dure en moyenne 10 secondes, nous pouvons transformer cette durée moyenne d'unités de temps en tours. Dans le meilleur des cas (10 minutes), il faudra 60 tours pour terminer, dans le pire des cas (40 minutes), il faudra 240 tours.

-2voto

derekmc Points 1

Juste une réponse rapide ici, la guerre en fait es un jeu, car la façon dont les joueurs choisissent les cartes affecte le résultat. Vous pouvez choisir de ramasser les cartes dans un ordre différent après chaque tour. Mais il est très difficile de jouer de manière stratégique.

Pour ce qui est de la question à l'étude, j'ai construit ma propre simulation, et pour 5 essais, avec brassage, j'ai obtenu :

58, 144, 354, 428, 189

Cela représente une moyenne de 234 tirs. Évidemment, vous pouvez faire plus d'essais, pour obtenir un chiffre plus précis, mais c'est définitivement une longue partie à jouer !

Mon code source est

<html>
<head>
<script>

window.addEventListener("load", () => goto(WAR));

// player decks and discards
let D1, D2, TABLE, ROUND;

function rank(x){
  let r = (x%13) + 1;
  if(r == 1) r = 14;
  return r;
}
function card(x){
  let r = rank(x);
  let suit = Math.floor(x/13);
  if(r > 10){
    r = ["Jack", "Queen", "King", "Ace"][r - 11]; }
  suit = ["Clubs", "Spades", "Hearts", "Diamonds"][suit];
  return `${r} of ${suit}`;
}
function deck(){
  return [...Array(52).keys()];
}
function shuffle(d){
  if(!d) d=deck();
  for(let i=0; i<d.length; ++i){
    let j = i + Math.floor((d.length-i) * Math.random());
    [d[i], d[j]] = [d[j], d[i]];
  }
  return d;
}

function draw(d,n,result){
  if(!d) d=deck();
  if(!n) n = 1;
  if(!result) result = [];
  n = Math.min(n, d.length);
  for(let i=0; i<n; ++i){
    result.push(d.shift()); }
  return result;
}

function ShowCounts(next){
  return next;
} 

function WAR(){
  D1 = shuffle();
  D2 = draw(D1, 26);
  console.log(D1, D2);
  TABLE = [];
  ROUND = 1;
  disp(`Welcome to War`);
  return WAIT;
}
function WAIT(){
  let handlers = [];
  more(`Press [Enter] or click anywhere to continue.`);
  wait(handlers, document.body, 'mousedown', null, FIGHT);
  wait(handlers, document.body, 'keydown', (e)=>(e.keyCode == 13), FIGHT);
  return null;
}
function FIGHT(){
  disp(`Fight! (Round ${ROUND++})`);
  more(`Player 1: ${D1.length} cards.`);
  more(`Player 2: ${D2.length} cards.`);
  more();
  if(D1.length == 0 || D2.length == 0) return END;
  let a = D1.shift();
  let b = D2.shift();
  TABLE.push(a);
  TABLE.push(b);
  more(`${card(a)} vs ${card(b)}.`);
  let x = rank(a);
  let y = rank(b);
  if(x == y){
    return TIE; }
  let winner = (x > y)? D1 : D2;
  more(`Player ${x>y? 1 : 2} wins ${TABLE.length} cards.`);
  draw(shuffle(TABLE), TABLE.length, winner);
  more();
  return WAIT;
}
function TIE(){
  more("Round is tied.");
  more("Each player draws 3 more facedown cards.");
  draw(D1, 3, TABLE);
  draw(D2, 3, TABLE);
  if(D1.length == 0 || D2.length == 0){
    return END; }
  return sleep(0.0, FIGHT);
}
function END(){
  if(D1.length > D2.length){
    disp("Player 1 Wins!"); }
  else{
    disp("Player 2 Wins!"); }
  more(`After ${ROUND} rounds.`);
  return RESTART;
}

function RESTART(){
  return sleep(2.5, ()=>{
    more("Restarting ...");
    sleep(2.5, WAR)})
}

function goto(target){ // targets return the next function to run.
  while(target){
    target = target(); }
}

function wait(handlers, target, name, test, after){
  if(!handlers) handlers = [];
  let handler = function(evt){
    if(test && !test(evt)) return;
    for(let tuple of handlers){
      let [other_target, other_name, other_handler] = tuple;
      other_target.removeEventListener(other_name, other_handler);
    }
    goto(after);
  }
  handlers.push([target, name, handler]);
  target.addEventListener(name, handler);
  return null;
}

function sleep(n, after){
    setTimeout(()=>goto(after), n*1000);
    return null;
}

function disp(x){
  if(x == undefined) x = "";
  document.getElementById("disptext").innerHTML = x;
}
function more(x){
  if(x == undefined) x = "";
  document.getElementById("disptext").innerHTML += "\n" + x;
}

function randint(n){
  return Math.floor(Math.random() * n);
}

function Download(){
  var zip = new JSZip();

  // Generate a directory within the Zip file structure
  var guessgame = zip.folder("war");

  guessgame.file("index.html", document.documentElement.outerHTML);

  // Generate the zip file asynchronously
  zip.generateAsync({type:"blob"}).then(function(content){
      // Force down of the Zip file
      saveAs(content, "wargame.zip");
  });
}

</script>
<style>
 *{ font-size: 108%; font-family: monospace; }
 #editor{ height: 70%; width: 100%; overflow-x: scroll; }
</style>
</head>
<body>
  <p><pre id="disptext"></pre></p>
  <!--<input id='textinput' type='text'></input>
  <input id='okaybutton' type='button' value="ok"></input>-->
  <!-- <p style="position: fixed; bottom: 0px; right:8px; text-align: right;"> -->
  <p>
    <!-- <h3> Source Code </h3> -->
    <!--<button onclick="editor.innerHTML = document.documentElement.outerHTML; editor.style.display='block'"> View </button>-->
    <!--<button onclick="Download();"> Download Game</button>-->
  </p>
  <p>
    <textarea id='editor' wrap='off' style="display:none;" readonly="true"></textarea>
  </p>

</body>
</html>

AlleGamers.com

AlleGamers est une communauté de gamers qui cherche à élargir la connaissance des jeux vidéo.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X