Dados: Simulando un juego de Dados

Question

Mi hermano cumple 21 años en un par de semanas y mis padres y yo lo llevamos a Las Vegas. Para mi día 21, traje $ 200 para apostar en Las Vegas y volví a casa con alrededor de $ 450, principalmente jugando dados. Planeo traer $ 200 de nuevo para este viaje y antes de irme pensé en realizar algunas simulaciones de dados para ver si puedo duplicar mi dinero nuevamente.

He leído de varias fuentes que la casa tiene la ventaja más pequeña en los dados al hacer una apuesta de línea de pase con cuotas máximas. De mi memoria, y según lo encuestado por Wizard of Odds, la mayoría de los casinos en la Franja tienen una probabilidad 3-4-5 con un mínimo de $ 5. Teniendo esto en cuenta, que aquí hay una simulación de una sesión de juego de dados (dados de 100 rollos) en PHP:

<?php 

$stash = 200; 
$bet = 5; 

for($i=100; $i--;) { 

    $dice1 = mt_rand(1, 6); 
    $dice2 = mt_rand(1, 6); 
    $total = $dice1 + $dice2; 

    if(!$button) { 
     if($total===7 || $total===11) { 
      $stash += $bet; 
     } 
     elseif($total===2 || $total===3 || $total===12) { 
      $stash -= $bet; 
     } 
     else { 
      $button = $total; 
      if($total===4 || $total===10) { 
       $odds = $bet*3; 
      } 
      elseif($total===5 || $total===9) { 
       $odds = $bet*4; 
      } 
      elseif($total===6 || $total===8) { 
       $odds = $bet*5; 
      } 
     } 
    } 
    else { 
     if($total===7) { 
      $button = 0; 
      $stash -= ($bet + $odds); 
     } 
     elseif($total===$button) { 
      $button = 0; 
      $stash += $bet; 
      if($total===4 || $total===10) { 
       $stash += $odds*2/1; 
      } 
      elseif($total===5 || $total===9) { 
       $stash += $odds*3/2; 
      } 
      elseif($total===6 || $total===8) { 
       $stash += $odds*6/5; 
      } 
     } 
    } 

    echo 'Stash: $'.$stash.'<br/>'; 

} 

?> 

¿hay algo malo con mi matemáticas aquí? Si bien hay picos y valles a lo largo de cada sesión, esta simulación duplica con mayor frecuencia su dinero antes de ir a la quiebra. Considerando que la casa siempre tiene ventaja en el juego de dados, incluso si solo es una fracción de un porcentaje, estoy perplejo por este resultado.

Answer 1

Bueno, desde el principio, puedo ver que tienes un error en el simple caso de victoria 7 u 11: se supone que debes ganar tu apuesta, no el doble de tu apuesta.

Edit: Creo que el pago de la apuesta de probabilidades es proporcional a la probabilidad real. Tienes dos veces más probabilidades de tirar 7 (perder tus probabilidades) que 10, por lo que debes recibir un pago de 2: 1 cuando ganas con un 4 o 10; y solo pagaste 6: 5 cuando ganas en un 6 o 8.

Answer 2

Tendría cuidado con cualquier código escrito para "probar" que es más probable que dupliques tu dinero en dados (o cualquier otro juego) de oportunidad) antes de ir a la quiebra. Las Vegas es una ciudad en expansión en el desierto de Nevada como un testimonio de dos cosas:

1. Finalmente, la casa siempre gana
2. La gente es malo para las matemáticas

No hay juego de cualquier casino pondría en su piso que no aprovechó ambas reglas. Si su código no está de acuerdo con Vegas, pondré mi dinero en Vegas.

Actualización:

Aquí es un poco de C++ que escribí sobre la base de su código original. El problema original que publicó fue si podía doblar su dinero antes de quebrar la mayoría de las veces. Seguí el código que escribí con algunos resultados.

#include <iostream> 

int die_roll() 
{ 
    return std::rand() % 6 + 1; 
} 

int win_count_g(0); 
int loss_count_g(0); 

// return true when double our money. 
// return false when we can't bet anymore. 
bool test_loop(int cash) 
{ 
    static const int bet_k(5); 

    int goal(cash * 2); 
    int button(0); 

    while (true) 
    { 
     if (cash >= goal) 
      return true; 
     else if (cash < bet_k) 
      return false; 

     int roll(die_roll() + die_roll()); 
     int odds(0); // additional odds bet 

     if (button == 0) 
     { 
      if (roll == 7 || roll == 11) 
      { 
       ++win_count_g; 
       cash += bet_k; 
      } 
      else if (roll == 2 || roll == 3 || roll == 12) 
      { 
       ++loss_count_g; 
       cash -= bet_k; 
      } 
      else 
      { 
       button = roll; 

       if (roll == 4 || roll == 10) 
       { 
        odds = std::min(cash - bet_k, bet_k * 3); 
       } 
       else if (roll == 5 || roll == 9) 
       { 
        odds = std::min(cash - bet_k, bet_k * 4); 
       } 
       else // if (roll == 6 || roll == 8) 
       { 
        odds = std::min(cash - bet_k, bet_k * 5); 
       } 
      } 
     } 
     else 
     { 
      if (roll == 7) 
      { 
       ++loss_count_g; 
       button = 0; 
       cash -= bet_k + odds; 
      } 
      else if (roll == button) 
      { 
       ++win_count_g; 
       button = 0; 
       cash += bet_k; 

       if (roll == 4 || roll == 10) 
       { 
        cash += odds * 2; 
       } 
       else if (roll == 5 || roll == 9) 
       { 
        cash += odds * 3/2; 
       } 
       else // if (roll == 6 || roll == 8) 
       { 
        cash += odds * 6/5; 
       } 
      } 
     } 
    } 
} 

void test(int cash) 
{ 
    win_count_g = 0; 
    loss_count_g = 0; 

    int doubled(0); 
    int broke(0); 

    for (int i(0); i < 10000; ++i) 
     if (test_loop(cash)) 
      ++doubled; 
     else 
      ++broke; 

    float win_percentage(static_cast<float>(doubled)/(doubled + broke) * 100.0); 

    std::cout << "starting cash: $" << cash 
       << "; doubled: " << doubled 
       << "; broke: " << broke 
       << " (" << win_percentage << "% win)" 
       << "; loop wins: " << win_count_g 
       << "; loop losses: " << loss_count_g 
       << std::endl; 
} 

int main() 
{ 
    static const int cash_set_k[] = 
    { 
     5, 
     10, 
     20, 
     50, 
     100, 
     200, 
     400, 
     800, 
     1000 
    }; 
    static const int cash_set_size_k(sizeof(cash_set_k)/sizeof(cash_set_k[0])); 

    std::for_each(&cash_set_k[0], &cash_set_k[cash_set_size_k], &test); 

    return 0; 
} 

Resultados:

starting cash: $5; doubled: 4944; broke: 5056 (49.44% win); loop wins: 4944; loop losses: 5056 
starting cash: $10; doubled: 4862; broke: 5138 (48.62% win); loop wins: 19706; loop losses: 20258 
starting cash: $20; doubled: 4755; broke: 5245 (47.55% win); loop wins: 78360; loop losses: 80320 
starting cash: $50; doubled: 4345; broke: 5655 (43.45% win); loop wins: 489406; loop losses: 502506 
starting cash: $100; doubled: 3553; broke: 6447 (35.53% win); loop wins: 1914393; loop losses: 1972273 
starting cash: $200; doubled: 2468; broke: 7532 (24.68% win); loop wins: 7172464; loop losses: 7375024 
starting cash: $400; doubled: 861; broke: 9139 (8.61% win); loop wins: 22615369; loop losses: 23277609 
starting cash: $800; doubled: 112; broke: 9888 (1.12% win); loop wins: 54556881; loop losses: 56121041 
starting cash: $1000; doubled: 31; broke: 9969 (0.31% win); loop wins: 69308617; loop losses: 71296217 

Answer 3

No está comprobando para ver si tiene suficiente en el alijo para colocar sus probabilidades deseadas apuesta. De hecho, no estás verificando el tamaño de tu escondite en absoluto. No es de extrañar que esta simulación sea capaz de ganarle a la casa más a menudo si puede apostar incluso si su tamaño de escondite es negativo.

Por cierto, me encontré con 50.000 iteraciones de la simulación de 100 tiradas de dados (con mi modificación de la apuesta máxima de alijo restante) y se acercó con los siguientes:

victorias: 23807

pérdidas: 25465

empuje (salir con $ 200): 728

promedio. winnings: $ 109.07