Fórmula para el cálculo de apuestas Exóticas tales como Trifecta y Superfecta

Question

Estoy tratando de crear una aplicación que calcule el costo de exóticos parimutuel apuesta cuesta.He encontrado varias para ciertos tipos de apuestas, pero nunca uno que resuelve todos los escenarios de un solo tipo de apuesta.Si yo pudiera encontrar un algoritmo que podría calcular todas las combinaciones posibles que podría utilizar esa fórmula para resolver mis problemas de otros.

Información adicional:Necesito calcular las permutaciones de los grupos de números.Por ejemplo;

Grupo 1 = 1,2,3
Grupo 2 = 2,3,4
Grupo 3 = 3,4,5

¿Cuáles son todas las posibles permutaciones de estos 3 grupos de números de tomar 1 número de cada grupo de cada permutación.No se repite por permutación, es decir, un número no puede aparecer en más de 1 posición.Así 2,4,3 es válida, pero 2,4,4 no es válido.

Gracias por toda la ayuda.

Answer 1

Al igual que la mayoría de los problemas interesantes, su pregunta tiene varias soluciones. El algoritmo que escribí (abajo) es la cosa más simple que vino a la mente.

Me pareció más fácil pensar en el problema como un árbol de búsqueda: El primer grupo, la raíz, tiene un niño para cada número que contiene, en donde cada niño es el segundo grupo. El segundo grupo tiene un niño de tercer grupo para cada número que contiene, el tercer grupo tiene un niño de cuarto grupo para cada número que contiene, etc. Todo lo que tiene que hacer es encontrar todas las rutas de acceso válidas desde la raíz hasta las hojas.

Sin embargo, para muchos grupos con una gran cantidad de números de este enfoque demostrará ser lento sin ningún heurística. Una cosa que podría hacer es ordenar la lista de grupos por grupo grande, grupo más pequeño primero. Eso sería un enfoque rápido a prueba de que, en general, descubren que una permutación no es válido más pronto que tarde. Look-ahead, de arco-consistencia y retroceso son otras cosas que usted puede pensar. [Lo siento, sólo pueden incluir un enlace porque es mi primer post, pero se pueden encontrar estas cosas en Wikipedia.]

## Algorithm written in Python ##
## CodePad.org has a Python interpreter

Group1 = [1,2,3] ## Within itself, each group must be composed of unique numbers
Group2 = [2,3,4]
Group3 = [3,4,5]
Groups = [Group1,Group2,Group3] ## Must contain at least one Group

Permutations = [] ## List of valid permutations

def getPermutations(group, permSoFar, nextGroupIndex):
  for num in group:
    nextPermSoFar = list(permSoFar) ## Make a copy of the permSoFar list

    ## Only proceed if num isn't a repeat in nextPermSoFar
    if nextPermSoFar.count(num) == 0: 
      nextPermSoFar.append(num)  ## Add num to this copy of nextPermSoFar

      if nextGroupIndex != len(Groups): ## Call next group if there is one...
        getPermutations(Groups[nextGroupIndex], nextPermSoFar, nextGroupIndex + 1)
      else: ## ...or add the valid permutation to the list of permutations
        Permutations.append(nextPermSoFar)

## Call getPermutations with:
##  * the first group from the list of Groups
##  * an empty list
##  * the index of the second group
getPermutations(Groups[0], [], 1)

## print results of getPermutations
print 'There are', len(Permutations), 'valid permutations:'
print Permutations

Answer 2

Esta es la fórmula general simple que conozco para Trifectas.

A = el número de selecciones que tiene para la primera; B = número de selecciones para segundos; C = Número de selecciones para tercera; AB = número de selecciones que tiene en primera y segunda; AC = no. para ambos primero y tercero; AC = no. para ambos días 2 y 3; y ABC = el no. de selecciones para todos primero, segundo y tercero. la fórmula es     (AxBxC) - (ABxC) - (ACxB) - (BCxA) + (2xABC)

Así que, por su ejemplo ::

 Group 1 = 1,2,3
 Group 2 = 2,3,4
 Group 3 = 3,4,5

la solución es :: (3x3x3) - (2x3) - (1x3) - (2x3) + (2x1) = 14. Espero que ayude Puede haber un método más fácil que yo no sepa. Ahora, ¿alguien sabe una fórmula general para First4?

Answer 3

Revisado después de un par de años:-

Me re conectado a mi SE cuenta después de un tiempo y se percató de esta pregunta, y se dio cuenta de lo que había escrito ni siquiera respondo:-

Aquí está algo de código en python

import itertools
def explode(value, unique):
    legs = [ leg.split(',') for leg in value.split('/') ]
    if unique:
        return [ tuple(ea) for ea in itertools.product(*legs) if len(ea) == len(set(ea)) ]
    else:
        return [ tuple(ea) for ea in itertools.product(*legs) ]

llamar a explotar las obras sobre la base de que cada pata está separado por una /, y la posición de cada uno por una ,

para su trifecta cálculo se puede deducir por el siguiente:-

result = explode('1,2,3/2,3,4/3,4,5', True)
stake = 2.0
cost = stake * len(result)
print cost

para una superfecta

result = explode('1,2,3/2,4,5/1,3,6,9/2,3,7,9', True)
stake = 2.0
cost = stake * len(result)
print cost

para un pick4 (Conjunto Único False)

result = explode('1,2,3/2,4,5/3,9/2,3,4', False)
stake = 2.0
cost = stake * len(result)
print cost

Espero que ayude

Answer 4

Como apostador te puedo decir que hay una manera mucho más simple:

Para una trifecta, necesita 3 combinaciones. Digamos que hay 8 corredores, el número total de posibles permutaciones es 8 (corredores totales) * 7 (restantes corredores después del ganador se omite) * 6 (restantes corredores después el ganador y segundo omitido) = 336

Para una exacta (con 8 corredores) 8 * 7 = 56

Quinellas son una excepción, ya que sólo se necesita tomar cada apuesta una vez como media paga, así como 2/1 por lo que la respuesta es 8 * 7/2 = 28

Simple

Answer 5

La respuesta suministrada por Luskin es correcto para Trifectas. Se plantea otra cuestión que tenía que resolver con respecto First4. Busqué por todas partes, pero no pude encontrar una fórmula. Yo sin embargo encontrar una forma sencilla de determinar el número de permutaciones únicas, utilizando bucles anidados para excluir secuencias repetidas.

    Public Function fnFirst4PermCount(arFirst, arSecond, arThird, arFourth) As Integer


Dim intCountFirst As Integer
Dim intCountSecond As Integer
Dim intCountThird As Integer
Dim intCountFourth As Integer
Dim intBetCount As Integer

'Dim arFirst(3) As Integer
'Dim arSecond(3) As Integer
'Dim arThird(3) As Integer
'Dim arFourth(3) As Integer

'arFirst(0) = 1
'arFirst(1) = 2
'arFirst(2) = 3
'arFirst(3) = 4
'
'arSecond(0) = 1
'arSecond(1) = 2
'arSecond(2) = 3
'arSecond(3) = 4
'
'arThird(0) = 1
'arThird(1) = 2
'arThird(2) = 3
'arThird(3) = 4
'
'arFourth(0) = 1
'arFourth(1) = 2
'arFourth(2) = 3
'arFourth(3) = 4

intBetCount = 0
For intCountFirst = 0 To UBound(arFirst)
    For intCountSecond = 0 To UBound(arSecond)
        For intCountThird = 0 To UBound(arThird)
            For intCountFourth = 0 To UBound(arFourth)
                If (arFirst(intCountFirst) <> arSecond(intCountSecond)) And (arFirst(intCountFirst) <> arThird(intCountThird)) And (arFirst(intCountFirst) <> arFourth(intCountFourth)) Then
                    If (arSecond(intCountSecond) <> arThird(intCountThird)) And (arSecond(intCountSecond) <> arFourth(intCountFourth)) Then
                        If (arThird(intCountThird) <> arFourth(intCountFourth)) Then
                        '    Debug.Print "First " & arFirst(intCountFirst), " Second " & arSecond(intCountSecond), "Third " & arThird(intCountThird), " Fourth " & arFourth(intCountFourth)
                            intBetCount = intBetCount + 1
                        End If
                    End If
                End If
            Next intCountFourth
        Next intCountThird
    Next intCountSecond
Next intCountFirst
fnFirst4PermCount = intBetCount

End Function

Esta función toma cuatro matrices de cadenas para cada posición. Salí en el código de prueba (comentada) para que pueda ver cómo funciona para 1/2/3/4 para cada una de las cuatro posiciones