¿Cuál es la duración esperada de un juego de Guerra?

La guerra en realidad no es un juego sino un autómata , ya que los jugadores no tienen opciones.

Wimpy Programmer ya hizo esta simulación , descubrió que al barajar las cartas ganadoras, el número medio de vueltas es 262 , la moda es 84 y el máximo (en una muestra de 100.000 intentos) es 2.702 vueltas. También descubrió que sin barajar las cartas ganadoras, el juego podría ser interminable.

Usó N=2 mientras juegas con N=3, más alto N acorta el juego, sin embargo, no creo que haga una gran diferencia.

Como problema matemático, este es un caso de un paseo aleatorio ("pasear" N cartas a un paso del mazo de tu oponente al tuyo, donde N suele ser uno, pero puede ser 4 o 7 o lo que sea dependiendo de los empates). a menudo se enmarca como el problema de "la ruina de los jugadores". Ignorando el tema de los empates y tratando cada tirada de cartas como una prueba independiente, el promedio de turnos es 26*26 = 676 turnos.

Tener en cuenta los empates lo reduciría bastante en función de N, lo que permitiría pasos más grandes ocasionalmente. El número medio de turnos cuando el tamaño del paso es 5 (es decir, cada turno es una guerra que se resuelve en su primer desempate) es equivalente a jugar con 6 cartas cada uno (26/5, redondeado). Y 6*6 = 36 vueltas.

Entonces solo es cuestión de calcular la probabilidad de dar grandes pasos. Se pueden esperar empates alrededor de 3/51 de las veces (cuando juegas una carta, hay 3 cartas que pueden empatar de las otras 51 cartas). 48/51 = tamaño de paso 1, 3/51 * 46/49 = tamaño de paso 5, 3/51 * 3/49 * 44/47 = tamaño de paso 9, y así sucesivamente. Esto hace un tamaño de paso promedio de alrededor de 1,25. Se espera que un juego jugado con todos los pasos iguales a 1,25 dure alrededor de 21*21 = 441 turnos (26/1,25 = 21 cartas cada equivalente). Y luego reduzca eso un poco más para tener en cuenta la posibilidad de muerte súbita cuando uno de los empates ocurre cuando un jugador tiene pocas cartas. (Lo siento, no tengo los detalles sobre cómo hacer eso exactamente).

EDITAR: También debo enfatizar que este enfoque asume que los ensayos son ensayos independientes. Esa es básicamente la diferencia entre dados y cartas. Cada lanzamiento de un dado es independiente. Pero cada sorteo no lo es, depende de qué más se haya sorteado / qué más quede. Y en el caso de la Guerra, ganar una prueba en general mejora tus probabilidades en el K-ésimo sorteo siguiente (cuando vuelves a sacar esa carta). Es un efecto de líder fugitivo muy leve (OMI) (mitigado al recibir también la carta perdedora, pero sigo pensando que la red es una ganancia). Y multiplicará la ventaja, si la hay, otorgada a un jugador sobre el otro en el trato inicial. Es decir, cualquier ligera desviación hacia las cartas con números más altos en el reparto inicial se amplificará en cada recorrido sucesivo por la baraja.

Otras lecturas:

Paseo aleatorio simple: http://www2.math.uu.se/~sea/kurser/stokprocmn1/slumpvandring_eng.pdf

Primer pasaje de un caminante aleatorio unidimensional https://www.math.ucdavis.edu/~tracy/courses/math135A/UsefullCourseMaterial/firstPassage.pdf

Bueno, desde ese mismo enlace que compartiste, en la tabla de resumen a la derecha se lee:

Tiempo de juego 10–40 min.

Lo que dice directamente la duración media de un juego.

Ahora, los encendidos de este juego, según mi experiencia, son bastante rápidos. Pueden durar unos segundos (revelar cartas, alguien gana, se toman cartas, final del turno), o en caso de empate unos segundos más.

Entonces, suponiendo que un turno dura en promedio 10 segundos, podemos transformar esa duración promedio de unidades de tiempo a turnos. En el mejor de los casos (10 minutos) tardará 60 turnos en completarse, en el peor de los casos (40 minutos) tardará 240 turnos.

Solo una respuesta rápida aquí, la guerra en realidad es un juego, porque la forma en que los jugadores recogen las cartas afecta el resultado. Puedes elegir recoger las cartas en diferentes órdenes después de cada ronda. Pero es muy difícil jugar estratégicamente.

En cuanto a la pregunta en cuestión, construí mi propia simulación y durante 5 intentos, con barajar, obtuve:

58, 144, 354, 428, 189

Esto llega a un promedio de 234 rondas. Obviamente, puedes hacer más intentos para obtener un número más preciso, ¡pero definitivamente es un juego largo para jugar!

mi código fuente es

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