Il y a un problème qu'il n'est pas lié à Python, Définissez les paramètres pour que vous soyez satisfait de l'ordinateur et résolvez.
Le joueur a sorti l'une des 52 cartes à jouer à l'exclusion du joker et l'a placée face cachée. Lorsque le croupier a choisi au hasard 3 feuilles de la pile restante et les a tournées vers l'avant, elles étaient toutes des diamants.
(Solution)
P_0 = sym.Rational(1, 4)
P_0dia = sym.Rational(13*12*11, 51*50*49)
P_dia = sym.Rational(14*13*12, 52*51*50)
P_0 * P_0dia / P_dia
Il y a une loterie avec une probabilité de gain de $ p $. Si tous les habitants de la terre tirent beaucoup une fois, la probabilité de tout perdre sera de 0,5 ou plus. Combien doit être $ p $? La population de la terre est de 7,2 milliards.
(Solution) Approximative avec la distribution de Poisson.
N = 7200000000
F = sym.exp(-p*N) - 0.5
sym.solve([F], [p])
À propos, si vous essayez autant, la distribution normale sera environ 7 fois l'écart type. Dans la distribution de Pareto, il n'est pas étrange que des valeurs séparées par plus de 100 millions de fois apparaissent.
(Solution)
import sympy as sym
A = sym.functions.combinatorial.numbers.nC(12, 2)
B = sym.functions.combinatorial.numbers.nC(8, 1)
C = sym.functions.combinatorial.numbers.nC(20, 3)
A*B/C
log_n = n * sym.log(n) - n + sym.log(2 * Pi * n) / 2
A1 = log_n.subs([(n, 4*10**24)])
A2 = log_n.subs([(n, 3*10**24)])
B1 = log_n.subs([(n, 6*10**24)])
B2 = log_n.subs([(n, 2*10**24)])
B3 = log_n.subs([(n, 1*10**24)])
Log_P = A1 + 2 * A2 - B1 - B2 - 2 * B3
sym.N(Log_P, 10)
Considérez une marche aléatoire qui commence à partir de la partie centrale jaune de la grille triangulaire sur la figure et se déplace vers la grille adjacente avec une probabilité égale toutes les secondes. Soit $ P_t $ la probabilité d'être au centre après $ t $ secondes.
(Solution)
N = 1
P = 0
Q = sym.Rational(1, 6)
R = 0
Pn = sym.Rational(3, 2) * q
Qn = p/6 + q/2 + r/2
Rn = q/2
while N < 10:
N += 1
Ptemp = Pn.subs([(q, Q)])
Qtemp = Qn.subs([(p, P), (q, Q), (r, R)])
Rtemp = Rn.subs([(q, Q)])
P = Ptemp
Q = Qtemp
R = Rtemp
print(N)
print(P)
print(Q)
print(R)
F1 = sym.Rational(3, 2) * q - p
F2 = p/6 + q/2 + r/2 - q
F3 = q/2 - r
Ft = p + 6*q + 3*r - 1
sym.solve([F1, F2, F3, Ft], [p, q, r])
Supposons que $ n $ nombres aléatoires uniformes compris entre 0 et 65535 soient générés.
(Solution)
def birthday(N, K):
return sym.functions.combinatorial.numbers.nP(N, K)/N**K
N = 65536
K = 255 #Vous pouvez partir de la racine carrée
P = 0.0
while P <= 0.5:
K += 1
P = 1 - birthday(N, K)
print(K)
sym.N(P, 10)
La partie frontière de $ K / 2 $ n'a pas beaucoup d'effet, alors ajoutez-la sans vous en soucier.
def birthday2(N, K, P1):
return (sym.functions.combinatorial.numbers.nP(N,K) + P1) / N**K
def P1(N,K,X):
return sym.functions.combinatorial.numbers.nC(N-X,X)*sym.functions.combinatorial.numbers.nP(N,K-X)
N = 65536
K = 300
P = 0.0
while P <= 0.5:
K += 1
L = 1
SUM = 0
while L <= K/2:
SUM += P1(N, K, L)
L += 1
P = 1 - birthday2(N, K, SUM)
print(K)
sym.N(P, 10)
Recommended Posts