[PYTHON] Calcul de la probabilité de concentration d'étoile FGO / valeur attendue

Mise en garde

Cet article concerne un algorithme dans un jeu social appelé FGO, Fate / Grand Order.

introduction

La critique est une grande partie de la tactique dans FGO, mais le calcul de la concentration d'étoiles critiques est un peu fastidieux.

Statut Serviteur / Caché - Destin / Grand Ordre @wiki [FGO] -Au Wiki

Les spécifications sont

• La concentration (SW) est définie pour chaque serviteur. (10-200)
• Augmente ou diminue en fonction de l'effet de l'augmentation ou de la diminution du degré de concentration.
• Distribuez au hasard 5 cartes de 3 Serviteurs.
• Pour chaque carte, des bonus (+ 0x2, + 20x2, + 50x1) seront ajoutés à la concentration au hasard.
• Triez les étoiles critiques que vous avez en fonction du degré de concentration après avoir ajouté le bonus.
• Plus aucune carte ne peut être distribuée à 10 cartes.

Exemple de calcul

Considérez les serviteurs suivants.

• SW
• Serviteur 1: 200
• Serviteur 2:50
• Serviteur 3:10

Les serveurs 1 à 2, 2 à 2, 3 à 1 seront distribués, et si vous pensez aux bonus comme +0, +0, +50, +20, +20 ...

• Lorsque toutes les cartes ont moins de 10 étoiles

• Lorsque la carte A a 10 étoiles

• Lorsque les cartes A et B ont 10 étoiles

……… Et la probabilité change comme ça.

Calcul

Les bonus ne changent pas pendant le processus de distribution, alors ignorez-les et généralisez-les. La probabilité que $ y $ étoiles soient distribuées à la carte $ n $ est

• Probabilité que $ y-1 $ étoiles soient sur la carte $ n $ et qu'une étoile soit distribuée sur la carte $ n $
• Probabilité qu'il y ait $ y $ étoiles sur la carte $ n $ et qu'une étoile soit distribuée en plus de la carte $ n $

Est le total de. Implémentez ceci dans un programme Python.

la mise en oeuvre

fgostarcalc.py

import math
#SW de chaque carte (bonus compris): Carte 1 à Carte 5
SW = [200, 200, 100, 70, 30]

#Contient la probabilité de 0 à 10 états étoiles pour chaque carte
Probabilities = [None for _ in range(11**6)]
Probabilities[0] = 1

#Obtenez n'importe quel numéro(Nombre d'étoiles sur chaque carte)
def digitnum(decim, base, ind):
    return(math.floor((decim % (base**ind))/(base**(ind-1))))

#Somme des nombres dans chaque chiffre(Total d'étoiles)
def sumdigit(decim, base):
    if decim == 0:
        return 0
    else:
        return(sum([digitnum(decim, base, i) for i in range(1, 2+math.ceil(math.log(decim, base)))]))

#Vérification de la validité
def is_valid(decim, base, totalstar, card, holdstar):
    if digitnum(decim, base, card) == holdstar:
        if sumdigit(decim, base) == totalstar:
            return True
    return False
        
#Fonction récursive du calcul de probabilité pour chaque état
def calc_starprob(decim, base, totalstar, card, holdstar):
    #print(decim, base, totalstar, card, holdstar)
    starweights = [0 if digitnum(decim, base, x+1)
                   == base-1 else SW[x] for x in range(5)]
    starprob = [SW[x]/(sum(starweights)-starweights[x]+SW[x])
                for x in range(5)]
    starweights[card] = SW[card]
    if decim < 0 or totalstar < 0 or holdstar < 0:
        print("Error: ", decim, base, totalstar, card, holdstar)
        raise
    if Probabilities[decim] != None:
        return(Probabilities[decim])
    else:
        tmp = [0]
        for x in range(5):
            if digitnum(decim, base, x+1) == 0:
                continue
            else:
                if x+1 == card and holdstar > 0:
                    tmp += [calc_starprob(decim-base**x, base,
                                          totalstar-1, card, holdstar-1)*starprob[x]]
                elif x+1 != card:
                    tmp += [calc_starprob(decim-base**x, base,
                                          totalstar-1, card, holdstar)*starprob[x]]
        Probabilities[decim] = sum(tmp)
        return(Probabilities[decim])

#Probabilité de tenir des étoiles sur la carte lorsqu'il y a des étoiles totales
def calc_probability(totalstar,card,holdstar):
    return(sum([calc_starprob(x, 11, totalstar, card, holdstar)
                 for x in range(11**5) if is_valid(x, 11, totalstar, card, holdstar)]))

#Probabilité de collecter plus d'étoiles Holdstar sur la carte lorsqu'il y a des étoiles Totalstar
def calc_moreprobability(totalstar,card,holdstar):
    tmp=0
    for star in range(holdstar, 11):
        tmp+=sum([calc_starprob(x, 11, totalstar, card, star)
                for x in range(11**5) if is_valid(x, 11, totalstar, card, star)])
    return(tmp)

#Probabilité de collecter des étoiles inférieures ou égales à holdstar sur la carte lorsqu'il y a des étoiles totalstar
def calc_lessprobability(totalstar,card,holdstar):
    tmp=0
    for star in range(0,holdstar+1):
        tmp+=sum([calc_starprob(x, 11, totalstar, card, star)
                for x in range(11**5) if is_valid(x, 11, totalstar, card, star)])
    return(tmp)

#totalstar Nombre attendu d'étoiles à collecter sur la carte lorsqu'il y a des étoiles
def calc_expectation(totalstar,card):
    tmp=0
    for star in range(0, 11):
        tmp+=calc_probability(totalstar, card, star)*star
    return(tmp)

#Le nombre d'étoiles requis pour que le nombre d'étoiles à collecter sur la carte soit étoile(Valeur entière)
def calc_totalstar_expectation(card,star):
    if star>10:
        star=10
    for totalstar in range(50):
        if calc_expectation(totalstar,card)>star:
            return(totalstar)

tester

#échantillon(Probabilité que 8 se réunissent sur la carte 1 lorsqu'il y a 25 étoiles)
print(calc_probability(25, 1, 8))
#0.1693947010897705

#échantillon(Nombre attendu d'étoiles à collecter sur la carte 1 lorsqu'il y a 20 étoiles)
print(calc_expectation(20, 1))
#6.862519232471602

#échantillon(Nombre d'étoiles requis pour collecter 4 valeurs attendues ou plus sur la carte 1)
print(calc_totalstar_expectation(1,4))
#12

en conclusion

Ce n'est pas une implémentation très rapide, mais j'ai pu la calculer. Vous pouvez également calculer la probabilité, la valeur attendue, le nombre requis, etc. Les bonus aléatoires sont également $ \ frac {5!} {2! 2!} = 30 $, donc si vous appliquez cela, vous pouvez calculer tous les modèles.