Es gibt ein Problem, das nicht mit Python zusammenhängt. Stellen Sie die Einstellungen so ein, dass Sie mit dem Computer zufrieden sind und lösen.
Der Spieler zog eine der 52 Spielkarten ohne den Joker heraus und legte sie verdeckt ab. Als der Händler zufällig 3 Blätter vom verbleibenden Stapel auswählte und sie nach vorne drehte, waren sie alle Diamanten.
(Lösung)
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
Es gibt eine Lotterie mit einer Gewinnwahrscheinlichkeit von $ p $. Wenn alle Menschen auf der Erde einmal viel ziehen, beträgt die Wahrscheinlichkeit, alle zu verlieren, 0,5 oder mehr Wie viel muss $ p $ sein? Die Bevölkerung der Erde beträgt 7,2 Milliarden.
(Lösung) Ungefähr mit Poisson-Verteilung.
N = 7200000000
F = sym.exp(-p*N) - 0.5
sym.solve([F], [p])
Wenn Sie so viel versuchen, beträgt die Normalverteilung übrigens etwa das 7-fache der Standardabweichung. In der Pareto-Verteilung ist es nicht verwunderlich, dass Werte auftreten, die mehr als 100 Millionen Mal voneinander entfernt sind.
(Lösung)
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)
Stellen Sie sich einen zufälligen Gang vor, der vom zentralen gelben Teil des Dreiecksgitters in der Abbildung ausgeht und sich jede Sekunde mit gleicher Wahrscheinlichkeit zum benachbarten Gitter bewegt. Sei $ P_t $ die Wahrscheinlichkeit, nach $ t $ Sekunden in der Mitte zu sein.
(Lösung)
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])
Angenommen, es werden $ n $ einheitliche Zufallszahlen im Bereich von 0 bis 65535 generiert.
(Lösung)
def birthday(N, K):
return sym.functions.combinatorial.numbers.nP(N, K)/N**K
N = 65536
K = 255 #Sie können von der Quadratwurzel ausgehen
P = 0.0
while P <= 0.5:
K += 1
P = 1 - birthday(N, K)
print(K)
sym.N(P, 10)
Der Grenzteil von $ K / 2 $ hat keine große Wirkung. Fügen Sie ihn hinzu, ohne sich darum zu kümmern.
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