Ho cercato di codificare un algoritmo per suggerire scommesse in giochi 1X2 (ponderati).
Fondamentalmente, ogni partita ha una serie di partite (squadre in casa vs squadre in trasferta):
1: vince la casaX: disegnare2: vince via
Per ogni partita e simbolo ( 1, Xe 2), assegnerò una percentuale che rappresenta le probabilità / probabilità che quel simbolo sia il risultato corretto della partita. Ecco un array che rappresenta la struttura:
$game = array
(
'match #1' => array // stdev = 0.0471
(
'1' => 0.3, // 30% home wins
'X' => 0.4, // 40% draw
'2' => 0.3, // 30% away wins
),
'match #2' => array // stdev = 0.4714
(
'1' => 0.0, // 0% home wins
'X' => 0.0, // 0% draw
'2' => 1.0, // 100% away wins
),
'match #3' => array // stdev = 0.4027
(
'1' => 0.1, // 10% home wins
'X' => 0.0, // 0% draw
'2' => 0.9, // 90% away wins
),
);
Calcolo anche la deviazione standard per ogni scommessa (commentata nello snippet sopra); deviazioni standard più elevate rappresentano una certezza più elevata, mentre le partite con le deviazioni standard più basse si traducono in un livello di incertezza più elevato e, idealmente, dovrebbero essere coperte con una scommessa doppia o tripla, se possibile.
Il seguente pseudo-algoritmo dovrebbe descrivere il flusso di lavoro complessivo:
for each match, sorted by std. dev // "uncertain" matches first
if still can make triple bets
mark top 3 symbols of match // mark 3 (all) symbols
else if still can make double bets
mark top 2 symbols of match // mark 2 (highest) symbols
else if can only make single bets // always does
mark top symbol of match // mark 1 (highest) symbol
Fin qui tutto bene, ma devo dire all'algoritmo quanto voglio spendere. Diciamo che una singola scommessa costa 1in qualunque valuta, la formula per calcolare quanto costa una scommessa multipla:
2^double_bets * 3^triple_bets * cost_per_bet (= 1)
Ovviamente, l'algoritmo dovrebbe cercare di allocare quanti più soldi possibile nel suggerimento della scommessa (altrimenti non avrebbe molto senso), e ora è qui che diventa più complicato ...
Diciamo che voglio pagare un massimo di 4, elencando tutti i possibili multipli in PHP ( @ IDEOne ):
$cost = 1; // cost per single bet
$result = array();
$max_cost = 4; // maximum amount to bet
foreach (range(0, 3) as $double)
{
foreach (range(0, 3) as $triple)
{
if (($double + $triple) <= 3) // game only has 3 matches
{
$bets = pow(2, $double) * pow(3, $triple); // # of bets
$result[$bets] = array
(
'cost' => $bets * $cost, // total cost of this bet
'double' => $double,
'triple' => $triple,
);
if ($result[$bets]['cost'] > $max_cost)
{
unset($result[$bets]);
}
}
}
}
ksort($result);
Produce il seguente output:
Array
(
[1] => Array
(
[cost] => 1
[double] => 0
[triple] => 0
)
[2] => Array
(
[cost] => 2
[double] => 1
[triple] => 0
)
[3] => Array
(
[cost] => 3
[double] => 0
[triple] => 1
)
[4] => Array
(
[cost] => 4
[double] => 2
[triple] => 0
)
)
Il problema
Se scelgo di giocare la massima quantità di denaro disponibile ( 4) dovrei scommettere con due doppie, se uso lo pseudo-algoritmo sopra descritto finirei con il seguente suggerimento di scommessa:
match #1=>X1match #2=>2match #3=>12
Che sembra subottimale rispetto a una tripla scommessa che costa 3e copre più incertezza:
match #1=>X12match #2=>2match #3=>2
L'esempio sopra ottiene ancora più rilevanza se si considera che le match #3probabilità potrebbero essere:
$game['match #3'] = array // stdev = 0.4714
(
'1' => 0.0, // 0% home wins
'X' => 0.0, // 0% draw
'2' => 1.0, // 100% away wins
);
In questo caso sprecherei un doppio senza una buona ragione.
Fondamentalmente, posso solo scegliere la scommessa più grande (forse stupida) e non la più grande e intelligente .
Ho sbattuto la testa contro il muro per alcuni giorni, sperando di ottenere una sorta di epifania, ma finora sono stato in grado di trovare solo due mezze [cattive] soluzioni:
1) Disegna una "Linea"
Fondamentalmente direi che le partite con uno stdev inferiore a un valore specifico sarebbero triple, le partite con uno stdev molto più alto sarebbero le scommesse doppie e le altre scommesse singole.
Il problema con questo, ovviamente, è scoprire i limiti specifici appropriati - e anche se trovo i valori perfetti per la scommessa "più intelligente", non so ancora se ho abbastanza soldi per giocare la scommessa suggerita o se Potrei fare una scommessa ancora più grande (anche intelligente) ...
2) Bruteforce
Ho avuto questa idea mentre scrivevo questa domanda e so che non avrebbe perfettamente senso nel contesto che ho descritto, ma penso che potrei farlo funzionare usando metriche un po 'diverse. Fondamentalmente, potrei fare in modo che il programma suggerisca scommesse (n. Di scommesse triple e doppie) per ogni possibile somma di denaro che potrei giocare (da 1a 4nel mio esempio), applicando lo pseudo-algoritmo che ho descritto sopra e calcolando un valore di classifica globale (qualcosa tipo % of symbols * match stdev- lo so, non ha senso).
La scommessa con il punteggio più alto (che copre l'incertezza) sarebbe la scommessa suggerita. Il problema con questo approccio (oltre al fatto che non ha ancora senso) è che i giochi con cui il mio programma funzionerà non sono limitati a 3 partite e il numero di combinazioni di scommesse doppie e triple per quelle partite sarebbe sostanzialmente più alto.
Sento che esiste una soluzione elegante, ma non riesco proprio ad afferrarla ...
Qualsiasi aiuto per risolvere questo problema è molto apprezzato, grazie.
Sembra esserci un po 'di confusione riguardo al mio problema, l'ho già affrontato in questa domanda e anche nei commenti, ma la cattiva interpretazione sembra ancora prevalere, almeno per alcuni.
Devo sapere quante scommesse triple, doppie e singole giocherò per una partita specifica (tutte le partite). Conosco già quali simboli voglio giocare guardando ogni partita individualmente.