Python 59 байт
print reduce(lambda x,p:p/2*x/p+2*10**999,range(6637,1,-2))
Это печатает 1000 цифр; немного больше, чем требуется 5. Вместо того, чтобы использовать предписанную итерацию, он использует это:
pi = 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + 5/11*(2 + ...)))))
6637( Самый внутренний знаменатель) может быть сформулирован как:
цифры * 2 * log 2 (10)
Это подразумевает линейную сходимость. Каждая более глубокая итерация произведет еще один двоичный бит числа пи .
Если , однако, вы настаиваете на использование загара -1 личности, подобная конвергенция может быть достигнута, если вы не возражаете идти о проблеме несколько иначе. Взглянем на частичные суммы:
4.0, 2.66667, 3.46667, 2.89524, 3.33968, 2.97605, 3.28374, ...
очевидно, что каждый член прыгает вперед и назад по обе стороны от точки схождения; ряд имеет переменную сходимость. Кроме того, каждый член ближе к точке схождения, чем предыдущий; оно абсолютно монотонно по отношению к точке сходимости. Сочетание этих двух свойств подразумевает, что среднее арифметическое любых двух соседних слагаемых ближе к точке сходимости, чем любое из самих слагаемых. Чтобы лучше понять, что я имею в виду, рассмотрим следующее изображение:
Внешняя серия является оригинальной, а внутренняя серия определяется по среднему значению каждого из соседних членов. Замечательная разница. Но что действительно примечательно, так это то, что эта новая серия также имеет чередующуюся сходимость и является абсолютно монотонной по отношению к точке схождения. Это означает, что этот процесс может применяться снова и снова, до тошноты.
Ok. Но как?
Некоторые формальные определения. Пусть P 1 (n) - n- й член первой последовательности, P 2 (n) - n- й член второй последовательности, и аналогично P k (n) - n- й член k- й последовательности, как определено выше. ,
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, ...]
Не удивительно, что эти коэффициенты точно следуют биномиальным коэффициентам и могут быть выражены в виде одной строки треугольника Паскаля. Поскольку произвольная строка треугольника Паскаля тривиальна для вычисления, можно найти произвольно «глубокий» ряд, просто взяв первые n частичных сумм, умножив каждый на соответствующий член в k- й строке треугольника Паскаля и разделив на 2 к-1 .
Таким образом, полная 32-битная точность с плавающей запятой (~ 14 знаков после запятой) может быть достигнута всего за 36 итераций, и в этот момент частичные суммы даже не сходятся во втором знаке после запятой. Это явно не игра в гольф
# 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
Если вам нужна произвольная точность, это может быть достигнуто с небольшой модификацией. Здесь еще раз вычисляем 1000 цифр:
# 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
Начальное значение p начинается на 2 10 больше, чтобы нейтрализовать эффекты целочисленного деления s / d, когда d становится больше, в результате чего последние несколько цифр не сходятся. Обратите внимание, что здесь 3318также:
цифры * log 2 (10)
То же количество итераций, что и в первом алгоритме (уменьшается вдвое, поскольку t уменьшается на 1 вместо 2 на каждую итерацию). Еще раз, это указывает на линейную сходимость: один двоичный бит числа пи на итерацию. В обоих случаях для расчета 1000 цифр числа пи требуется 3318 итераций , что несколько лучше, чем 1 миллион итераций для расчета 5.
p=lambda:3.14159