Python 59 bajtów
print reduce(lambda x,p:p/2*x/p+2*10**999,range(6637,1,-2))
Spowoduje to wydrukowanie 1000 cyfr; nieco więcej niż wymagane 5. Zamiast korzystać z przepisanej iteracji, wykorzystuje to:
pi = 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + 5/11*(2 + ...)))))
6637(Mianownik najgłębsza) można formułować jako:
cyfry * 2 * log 2 (10)
To implikuje liniową zbieżność. Każda głębsza iteracja spowoduje wygenerowanie jeszcze jednego binarnego bitu pi .
Jeśli jednak nalegasz na użycietożsamości tan -1 , możesz osiągnąć podobną zbieżność, jeśli nie masz nic przeciwko temu, aby poradzić sobie z problemem nieco inaczej. Patrząc na kwoty częściowe:
4.0, 2.66667, 3.46667, 2.89524, 3.33968, 2.97605, 3.28374, ...
oczywiste jest, że każdy termin przeskakuje w obie strony w obie strony punktu konwergencji; seria ma przemienną konwergencję. Ponadto, każdy termin jest bliżej punktu zbieżności niż poprzedni termin; jest absolutnie monotoniczny w odniesieniu do punktu zbieżności. Połączenie tych dwóch właściwości implikuje, że średnia arytmetyczna dowolnych dwóch sąsiednich członów jest bliższa punktu zbieżności niż którykolwiek z nich. Aby lepiej zrozumieć, co mam na myśli, rozważ następujący obraz:
Szereg zewnętrzny jest oryginałem, a szereg wewnętrzny można znaleźć, biorąc średnią każdego z sąsiednich terminów. Niezwykła różnica. Ale naprawdę niezwykłe jest to, że ta nowa seria ma również przemienną zbieżność i jest absolutnie monotonna w stosunku do punktu zbieżności. Oznacza to, że proces ten można stosować w kółko, ad nauseum.
Dobrze. Ale jak?
Niektóre formalne definicje. Niech P 1 (n), jest brak p określenie pierwszej kolejności, p 2 (n), jest brak p termin drugiej kolejności, i podobnie P k (n) n p termin z k th sekwencji, jak zdefiniowano powyżej, .
P 1 = [P 1 (1), P 1 (2), P 1 (3), P 1 (4), P 1 (5), ...]
P 2 = [(P 1 (1) + P 1 (2)) / 2, (P 1 (2) + P 1 (3)) / 2, (P 1 (3) + P 1 (4)) / 2, (P 1 (4) + P 1 (5)) / 2, ...]
P 3 = [(P 1 (1) + 2P 1 (2) + P 1 (3)) / 4, (P 1 (2) + 2P 1 (3) + P 1 (4)) / 4, (P 1 (3) + 2P 1 (4) + P 1 (5)) / 4, ...]
P 4 = [(P 1 (1) + 3P 1 (2) + 3P 1 (3) + P 1 (4)) / 8, (P 1 (2) + 3P 1 (3) + 3P 1 (4) + P 1 (5)) / 8, ...]
Nic dziwnego, że współczynniki te są dokładnie zgodne ze współczynnikami dwumianowymi i mogą być wyrażone jako pojedynczy rząd trójkąta Pascala. Ponieważ arbitralny rząd Trójkąta Pascala jest prosty do obliczenia, można znaleźć dowolną „głęboką” serię, po prostu biorąc pierwsze n częściowych sum, mnożąc każdy przez odpowiedni wyraz w k- tym rzędzie Trójkąta Pascala i dzieląc przez 2 k-1 .
W ten sposób można osiągnąć pełną 32-bitową precyzję zmiennoprzecinkową (~ 14 miejsc po przecinku) za pomocą zaledwie 36 iteracji, w których to miejscu częściowe sumy nawet nie są zbieżne na drugim miejscu po przecinku. To oczywiście nie jest gra w golfa:
# used for pascal's triangle
t = 36; v = 1.0/(1<<t-1); e = 1
# used for the partial sums of pi
p = 4; d = 3; s = -4.0
x = 0
while t:
t -= 1
p += s/d; d += 2; s *= -1
x += p*v
v = v*t/e; e += 1
print "%.14f"%x
Jeśli chcesz dowolną precyzję, możesz to osiągnąć z niewielką modyfikacją. Tutaj jeszcze raz obliczając 1000 cyfr:
# used for pascal's triangle
f = t = 3318; v = 1; e = 1
# used for the partial sums of pi
p = 4096*10**999; d = 3; s = -p
x = 0
while t:
t -= 1
p += s/d; d += 2; s *= -1
x += p*v
v = v*t/e; e += 1
print x>>f+9
Początkowa wartość p zaczyna się o 2 10 większa, aby przeciwdziałać efektom s / d dzielenia liczb całkowitych, gdy d staje się większy, powodując, że kilka ostatnich cyfr się nie zbiega. Zauważ tutaj jeszcze raz3318 jest to również:
cyfry * log 2 (10)
Ta sama liczba iteracji co pierwszy algorytm (o połowę, ponieważ t zmniejsza się o 1 zamiast 2 w każdej iteracji). Ponownie oznacza to liniową zbieżność: jeden binarny bit pi na iterację. W obu przypadkach wymagane jest 3318 iteracji, aby obliczyć 1000 cyfr liczby pi , ponieważ jest to nieco lepszy przydział niż 1 milion iteracji w celu obliczenia 5.
p=lambda:3.14159