Formule pour calculer des paris exotiques tels que Trifecta et Superfecta

Question

J'essaie de créer une application qui permettra de calculer le coût des coûts de pari exotique parimutuel. J'ai trouvé plusieurs pour certains types de paris mais jamais un qui résout tous les scénarios pour un seul type de pari. Si je pouvais trouver un algorithme qui pourrait calculer toutes les combinaisons possibles, je pourrais utiliser cette formule pour résoudre mes autres problèmes. Informations supplémentaires: J'ai besoin de calculer les permutations de groupes de nombres. Par exemple;

Groupe 1 = 1,2,3
Groupe 2 = 2,3,4
Groupe 3 = 3,4,5

Quelles sont toutes les permutations possibles pour ces 3 groupes de nombres prenant 1 nombre de chaque groupe par permutation. Aucune répétition par permutation, ce qui signifie qu'un nombre ne peut pas apparaître dans plus d'une position. Donc 2,4,3 est valide mais 2,4,4 n'est pas valide.

Merci pour toute l'aide.

Answer 1

Comme la plupart des problèmes intéressants, votre question a plusieurs solutions. L'algorithme que j'ai écrit (ci-dessous) est la chose la plus simple qui me vient à l'esprit. J'ai trouvé plus facile de penser au problème comme une recherche d'arbre: Le premier groupe, la racine, a un enfant pour chaque nombre qu'il contient, où chaque enfant est le deuxième groupe. Le deuxième groupe a un enfant du troisième groupe pour chaque nombre qu'il contient, le troisième groupe a un enfant du quatrième groupe pour chaque nombre qu'il contient, etc. Tout ce que vous avez à faire est de trouver tous les chemins valides de la racine aux feuilles.

Cependant, pour de nombreux groupes avec beaucoup de nombres, cette approche s'avérera lente sans aucune heuristique. Une chose que vous pourriez faire est de trier la liste des groupes par groupe de taille, le plus petit groupe en premier. Ce serait une approche rapide qui, en général, découvrirait qu'une permutation n'est pas valide plus tôt que plus tard. Look-ahead, arc-consistency, et backtracking sont d'autres choses que vous pourriez vouloir penser. [Désolé, je ne peux inclure un lien, car il est mon premier post, mais vous pouvez trouver ces choses sur 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

un parieur, je peux vous dire qu'il ya une façon beaucoup plus simple:

Pour un tiercé, vous avez besoin de 3 combinaisons.Dites qu'il y a 8 coureurs, le nombre total de permutations possibles est 8 (coureurs au total) * 7 (coureurs restants après le vainqueur omis) * 6 (coureurs restants après le vainqueur et 2e omis) = 336

Pour une exacte (avec 8 coureurs) 8 * 7 = 56

Les quinellas sont une exception, car il vous suffit de prendre chaque pari une fois que 1/2 paie ainsi que 2/1 alors la réponse est 8 * 7/2 = 28

simple

Answer 3

révisée après quelques années: -

Je re connecter à mon compte SE après un certain temps et a remarqué cette question, et réalisé ce que j'avais écrit n'a même pas vous répondre: -

Voici un code 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) ] 

appeler exploser des œuvres sur la base que chaque branche est séparée par un /, et chaque position par un,

pour le calcul de votre tiercé gagnant, vous pouvez travailler dehors par ce qui suit: -

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

pour une 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 

pour un pick4 (Set Unique sur False)

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

espoir qui aide

Answer 4

C'est la plus simple formule générale je sais Trifectas. A = le nombre de sélections que vous avez pour la première fois;

B = nombre de sélections pour la seconde; C = nombre de sélections pour le troisième; AB = nombre de sélections que vous avez en premier et en second; AC = non. pour le premier et le troisième; BC = non. pour les deuxièmes et troisièmes; et ABC = le non. des sélections pour tous les 1er, 2e et 3e. la formule est (AxBxC) - (ABxC) - (ACxB) - (BCxA) + (2xABC)

Ainsi, par votre exemple ::

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

la solution est :: (3x3x3) - (2x3) - (1x3) - (2x3) + (2x1) = 14. J'espère que cela aidera Il pourrait y avoir une méthode plus facile que je ne suis pas au courant. Est-ce que quelqu'un connaît une formule générale pour First4?

Answer 5

La réponse fournie par luskin est correcte pour les trifectas. Il a posé une autre question que je devais résoudre concernant First4. J'ai regardé partout mais je n'ai pas trouvé de formule. J'ai cependant trouvé un moyen simple de déterminer le nombre de permutations uniques, en utilisant des boucles imbriquées pour exclure des séquences répétées.

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 

Cette fonction prend quatre matrices de chaînes pour chaque position. Je suis parti en code de test (commenté) donc vous pouvez voir comment cela fonctionne pour 1/2/3/4 pour chacune des quatre positions