He estado intentando codificar un algoritmo para sugerir apuestas en juegos 1X2 (ponderados).
Básicamente, cada partido tiene una serie de enfrentamientos (equipos locales contra equipos visitantes):
1: victorias localesX: sorteo2: victorias a domicilio
Para cada coincidencia y símbolo ( 1 , X y 2 ), asignaré un porcentaje que represente las probabilidades de que ese símbolo sea el resultado correcto. He aquí 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 típica de cada apuesta (comentada en el fragmento anterior); las desviaciones típicas más altas representan una mayor certeza, mientras que los partidos con las desviaciones típicas 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 pseudoalgoritmo debería 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) symbolHasta aquí todo bien, pero tengo que decirle al algoritmo cuánto quiero gastar. Digamos que una apuesta cuesta 1 en cualquier divisa, 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 debe intentar asignar la mayor cantidad de dinero disponible posible a la apuesta sugerida (de lo contrario no tendría mucho sentido), y ahora es cuando 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);El resultado es el siguiente:
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 decido jugar la cantidad máxima de dinero disponible ( 4 ) tendría que apostar con dos dobles, si utilizo el pseudo-algoritmo que he descrito anteriormente acabaría con la siguiente sugerencia de apuesta:
match #1=>X1match #2=>2match #3=>12
Lo que parece sub-óptimo cuando se compara con una apuesta triple que cuesta 3 y cubre más incertidumbre:
match #1=>X12match #2=>2match #3=>2
El ejemplo anterior adquiere aún más relevancia si se tiene en cuenta que match #3 probabilidades 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 ninguna buena razón.
Básicamente, sólo puedo elegir el mayor apuesta (posiblemente estúpida) y no el la apuesta más inteligente .
Llevo unos días dándome cabezazos contra la pared con la esperanza de conseguir algún tipo de epifanía, pero hasta ahora sólo he sido capaz de dar con dos soluciones medio [malas]:
1) Trazar una "línea"
Básicamente diría que los partidos con un stdev inferior a un valor concreto serían apuestas triples, los partidos con un stdev un poco superior 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", sigo sin saber si tengo suficiente dinero para jugar la apuesta sugerida o si podría hacer una apuesta aún mayor (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 he descrito, pero creo que podría hacer que funcionara utilizando métricas algo diferentes. Básicamente, podría hacer que el programa sugiriera apuestas (# de apuestas triples y dobles) para cada posible cantidad de dinero que pudiera jugar (de 1 a 4 en mi ejemplo), aplicando el pseudoalgoritmo que he descrito anteriormente y calculando un valor de clasificación global (algo así como % of symbols * match stdev - Lo sé, no tiene sentido).
La apuesta con la clasificación más alta (incertidumbre de cobertura) sería la apuesta sugerida. El problema de este planteamiento (además de que aún no tiene sentido) es que los partidos con los que va a 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 mayor.
Tengo la sensación de que existe una solución elegante, pero no consigo entenderla...
Cualquier ayuda para resolver este problema es muy apreciada, gracias.
Parece que hay cierta confusión con respecto a mi problema, ya lo he abordado en esta pregunta y también en los comentarios, pero la mala interpretación parece seguir prevaleciendo, al menos para algunos.
Necesito saber cuántas apuestas triples, dobles y simples voy a jugar para un juego específico (todos los partidos). Ya sé qué símbolos símbolos quiero jugar mirando cada partido individualmente.
