Формула расчета экзотических ставок, таких как Trifecta и Superfecta

Как и у большинства интересных задач, у вашего вопроса есть несколько решений. Алгоритм, который я написал (ниже) — самое простое, что пришло в голову.

Я обнаружил, что проще всего представить эту проблему как поиск по дереву: первая группа, корень, имеет дочерний элемент для каждого числа, которое она содержит, где каждый дочерний элемент является второй группой. У второй группы есть дочерний элемент третьей группы для каждого содержащегося в нем числа, у третьей группы есть дочерний элемент четвертой группы для каждого содержащегося в нем числа и т. д. Все, что вам нужно сделать, это найти все допустимые пути от корня к листьям.

Однако для многих групп с большим количеством чисел этот подход окажется медленным без какой-либо эвристики. Одна вещь, которую вы можете сделать, это отсортировать список групп по размеру группы, начиная с самой маленькой группы. Это был бы отказоустойчивый подход, который, как правило, обнаружит, что перестановка недействительна раньше, чем позже. Упреждение, дуговая согласованность и откат — это другие вещи, о которых вам, возможно, следует подумать. [Извините, я могу включить только одну ссылку, потому что это мой первый пост, но вы можете найти эти вещи в Википедии.]

## 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

Это самая простая общая формула, которую я знаю для trifectas.

A=количество выборов, которые у вас есть для первого; B=количество выборов в секунду; C=количество выборов для третьего; AB=количество выборов, которые у вас есть как в первом, так и во втором; АС=нет. как для первого, так и для третьего; БК=нет. как для 2-го, так и для 3-го; и ABC=нет. выбор для всех 1, 2 и 3. формула (AxBxC)-(ABxC)-(ACxB)-(BCxA)+(2xABC)

Итак, для вашего примера::

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

решение: (3x3x3)-(2x3)-(1x3)-(2x3)+(2x1)=14. Надеюсь, это поможет. Может быть, есть более простой метод, о котором я не знаю. Теперь кто-нибудь знает общую формулу для First4?

Пересмотрено через несколько лет: -

Через некоторое время я снова вошел в свою учетную запись SE, заметил этот вопрос и понял, что то, что я написал, даже не ответило вам: -

Вот немного кода на питоне

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) ]

вызов взорваться работает на основе того, что каждая нога отделена /, а каждая позиция - ,

для вашего расчета trifecta вы можете решить это следующим образом: -

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

для суперфекта

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

для выбора4 (установите для уникальности значение False)

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

надеюсь, это поможет

Как игрок, я могу сказать вам, что есть гораздо более простой способ:

Для трифекта вам нужно 3 комбинации. Скажем, есть 8 участников, общее количество возможных перестановок равно 8 (всего участников) * 7 (оставшиеся участники после победителя опущены) * 6 (оставшиеся участники после победителя и 2-го опущены) = 336

Для точного (с 8 полозьями) 8 * 7 = 56

Кинельи являются исключением, так как вам нужно принимать каждую ставку только один раз, так как 1/2 оплачивается, а также 2/1, поэтому ответ 8 * 7/2 = 28.

Простой

Ответ, предоставленный luskin, верен для trifectas. Он задал еще один вопрос, который мне нужно было решить относительно First4. Я искал везде, но не мог найти формулу. Однако я нашел простой способ определить количество уникальных перестановок, используя вложенные циклы для исключения повторяющихся последовательностей.

    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

эта функция принимает четыре массива строк для каждой позиции. Я оставил тестовый код (закомментирован), чтобы вы могли видеть, как он работает для 1/2/3/4 для каждой из четырех позиций.