He estado tratando de codificar un algoritmo para sugerir apuestas en juegos 1X2 (ponderados).
Básicamente, cada juego tiene un conjunto de partidos (equipos locales vs fuera):
1: casa ganaX: dibujar2: visitante gana
Para cada coincidencia y símbolo ( 1, Xy 2), asignaré un porcentaje que represente las posibilidades / probabilidades de que ese símbolo sea el resultado correcto de la coincidencia. Aquí hay una matriz que representa la estructura:
$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
),
);
También calculo la desviación estándar para cada apuesta (comentada en el fragmento anterior); las desviaciones estándar más altas representan una certeza más alta, mientras que los partidos con las desviaciones estándar más bajas se traducen en un mayor nivel de incertidumbre e, idealmente, deberían cubrirse con una apuesta doble o triple, si es posible.
El siguiente pseudo-algoritmo debe describir el flujo de trabajo general:
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
Hasta ahora todo bien, pero necesito decirle al algoritmo cuánto quiero gastar. Digamos que una sola apuesta cuesta 1en cualquier moneda, la fórmula para calcular cuánto cuesta una apuesta múltiple es:
2^double_bets * 3^triple_bets * cost_per_bet (= 1)
Obviamente, el algoritmo debería tratar de asignar la mayor cantidad de dinero disponible en la sugerencia de apuesta (de lo contrario no tendría mucho sentido), y ahora es donde esto se vuelve más complicado ...
Digamos que quiero pagar un máximo de 4, enumerando todos los múltiplos posibles en 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 el siguiente resultado:
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
)
)
El problema
Si elijo jugar la cantidad máxima de dinero disponible ( 4), tendría que apostar con dos dobles, si uso el pseudo-algoritmo que describí anteriormente, terminaría con la siguiente sugerencia de apuesta:
match #1=>X1match #2=>2match #3=>12
Lo que parece subóptimo en comparación con una apuesta triple que cuesta 3y cubre más incertidumbre:
match #1=>X12match #2=>2match #3=>2
El ejemplo anterior gana aún más relevancia si considera que las match #3probabilidades podrían ser:
$game['match #3'] = array // stdev = 0.4714
(
'1' => 0.0, // 0% home wins
'X' => 0.0, // 0% draw
'2' => 1.0, // 100% away wins
);
En este caso estaría desperdiciando un doble sin una buena razón.
Básicamente, solo puedo elegir la apuesta más grande (posiblemente estúpida) y no la apuesta más inteligente y más grande .
He estado golpeándome la cabeza contra la pared durante algunos días, esperando obtener algún tipo de epifanía, pero hasta ahora solo he podido encontrar dos soluciones a medias [malas]:
1) Dibuja una "línea"
Básicamente, diría que los partidos con un stdev más bajo que un valor específico serían triples, los partidos con un stdev mucho más alto serían apuestas dobles y el resto apuestas simples.
El problema con esto, por supuesto, es encontrar los límites específicos apropiados, e incluso si encuentro los valores perfectos para la apuesta "más inteligente", todavía no sé si tengo suficiente dinero para jugar la apuesta sugerida o si Podría hacer una apuesta aún más grande (también inteligente) ...
2) fuerza bruta
Se me ocurrió esta idea mientras escribía esta pregunta y sé que no tendrá mucho sentido en el contexto que describí, pero creo que podría hacer que funcione utilizando métricas algo diferentes. Básicamente, podría hacer que el programa sugiera apuestas (# de apuestas triples y dobles) por cada cantidad posible de dinero que pueda jugar (desde 1hasta 4en mi ejemplo), aplicando el pseudo-algoritmo que describí anteriormente y calculando un valor de clasificación global (algo como % of symbols * match stdev- Lo sé, no tiene sentido).
La apuesta con la clasificación más alta (cubriendo la incertidumbre) sería la apuesta sugerida. El problema con este enfoque (además del hecho de que todavía no tiene ningún sentido) es que los juegos con los que trabajará mi programa no se limitan a 3 partidos y el número de combinaciones de apuestas dobles y triples para esos partidos sería sustancialmente más alto.
Siento que hay una solución elegante, pero no puedo entenderla ...
Cualquier ayuda para resolver este problema es muy apreciada, gracias.
Parece haber cierta confusión con respecto a mi problema, ya he abordado esto en esta pregunta y también en los comentarios, pero la interpretación errónea todavía parece prevalecer, al menos para algunos.
Necesito saber cuántas apuestas triples, dobles y simples jugaré para un juego específico (todos los partidos). Ya sé qué símbolos quiero jugar mirando cada partido individualmente.