Probabilità dei dadi: simulare un gioco di Craps

Question

Mio fratello compie 21 anni in un paio di settimane ei miei genitori e io lo portiamo a Las Vegas. Per il mio 21, ho portato $ 200 a giocare a Vegas e sono tornato a casa con circa $ 450, principalmente giocando a craps. Ho intenzione di portare ancora $ 200 per questo viaggio e prima di andare ho pensato di eseguire alcune simulazioni di craps per vedere se posso raddoppiare i miei soldi di nuovo.

Ho letto da diverse fonti che la casa ha il più piccolo vantaggio nel craps quando piazza una scommessa passline con quote massime. Dalla mia memoria, e come rilevato dallo Wizard of Odds, la maggior parte dei casinò sulla Strip ha 3-4-5 probabilità con un minimo di $ 5. Tenendo conto di questo, qui è una simulazione di una sessione di craps (dadi di 100 rotoli) in 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/>'; 

} 

?> 

C'è qualcosa di sbagliato con la mia matematica qui? Mentre ci sono picchi e depressioni in ogni sessione, questa simulazione più spesso raddoppia i suoi soldi prima di andare in rovina. Considerando che la casa ha sempre il vantaggio nel craps, anche se è solo una frazione del percento, sono perplesso di questo risultato.

Answer 1

Bene, subito, posso vedere che hai un errore nel semplice caso di vittoria 7 o 11: dovresti vincere la tua scommessa, non il doppio della tua scommessa.

Modifica: Credo che il pagamento per la scommessa delle quote sia commisurato alla probabilità effettiva. Hai il doppio delle probabilità di ottenere 7 (perde le tue probabilità) di 10, quindi dovresti essere pagato 2: 1 quando vinci 4 o 10; e pago 6: 5 solo quando vinci 6 o 8.

Answer 2

Sarei attento con qualsiasi pezzo di codice scritto per "dimostrare" che è più probabile raddoppiare i tuoi soldi con il craps (o con qualsiasi altro gioco di possibilità) prima di andare in bancarotta. Las Vegas è una città tentacolare nel deserto del Nevada come un testamento a due cose:

1. Alla fine, la casa vince sempre
2. Le persone sono male in matematica

Non v'è alcun gioco qualsiasi casinò metterebbe sul loro piano che non ha influenzato entrambe le regole. Se il tuo codice non è d'accordo con Vegas, sto mettendo i miei soldi su Las Vegas.

Aggiornamento:

Ecco alcune C++ ho scritto in base al codice originale. Il problema originale che hai postato è stato se si potesse raddoppiare i propri soldi prima che si rompesse il più delle volte. Ho seguito il codice che ho scritto con alcuni risultati.

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

Risultati:

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

Non sei il controllo per vedere se avete abbastanza a sinistra in scorta per posizionare le vostre probabilità desiderati scommessa. In effetti, non stai controllando affatto la dimensione della tua scorta. Non sorprende che questa simulazione sarà in grado di battere la casa più spesso se si è in grado di scommettere anche se la dimensione dello stash è negativa.

A proposito, mi sono imbattuto 50.000 iterazioni della vostra simulazione di 100 lanci di dadi (con la mia modifica della puntata massima di scorta rimanente) e si avvicinò con le seguenti:

vittorie: 23807

perdite: 25465

push (si lascia con $ 200): 728

avg. vincite: $ 109,07