Isso vem de http://programmers.blogoverflow.com/2012/08/20-controversial-programming-opinions/

"Dado que o Pi pode ser estimado usando a função 4 * (1 - 1/3 + 1/5 - 1/7 + ...) com mais termos dando maior precisão, escreva uma função que calcule o Pi com uma precisão de 5 casas decimais. "

• Observe que a estimativa deve ser feita calculando a sequência fornecida acima.

JavaScript, 46 58 56 45 bytes

Atualização do ES6 : Acontece que há mais recursos disponíveis agora que cinco anos se passaram.

let f=(i=0,a=0)=>i>1e6?a:f(i+4,a+8/-~i/(i+3))

Esta versão ( 45 bytes; sim, leté necessária) funciona no modo estrito do ES6 em teoria . Na prática, você pode executá-lo na V8 (por exemplo, com nó) com --use-strict --harmony-tailcalls; o recurso Adequado Tailcalls ainda não foi amplamente implementado, infelizmente. No entanto, é um comportamento especificado, portanto tudo deve estar bem.

Se quisermos manter o que é amplamente implementado, e não exigir o modo estrito, podemos simplesmente usar a sintaxe ES6 da seta de fatura para funções, mas manter a mesma implementação de antes (sugerida por Brian H) por um custo de 48 bytes.

a=>{for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}

A escolha do nome para o parâmetro único não importa realmente , mas podemos escolher um dos nomes que usamos para minimizar a poluição no escopo global.

function(){for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}

Esta versão é uma expressão de função; adicione dois caracteres (por exemplo, " f") se desejar que ele seja nomeado. Esta versão derruba os globais ae i; isso pode ser evitado se adicionarmos " a,i" à lista de parâmetros.

Utiliza uma versão reformulada do algoritmo para contornar a necessidade de subtração.

 1/1 - 1/3  +   1/5 - 1/7   +    1/9 - 1/11  + ...
(3/3 - 1/3) + (7/35 - 5/35) + (11/99 - 9/99) + ...
    2/3     +      2/35     +       2/99     + ...
  2/(1*3)   +    2/(5*7)    +     2/(9*11)   + ...

Aqui está uma versão "simples" sem esse ajuste:

function(){for(a=0,i=1;i<1e6;i+=2)a+=[,4,,-4][i%4]/i;return a}

com 64 62 caracteres.

Obrigado a @ardnew pela sugestão de se livrar do 4*antes do return.

História

function(){for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}     // got rid of `i+=4`; restructured
// Old versions below.
function(){for(a=0,i=1;i<1e6;i+=4)a+=8/i/-~-~i;return a}    // got rid of `4*`
function(){for(a=0,i=1;i<1e6;i+=4)a+=2/i/-~-~i;return 4*a}

Python 59 bytes

print reduce(lambda x,p:p/2*x/p+2*10**999,range(6637,1,-2))

Isso imprime 1000 dígitos; um pouco mais do que o necessário 5. Em vez de usar a iteração prescrita, ele usa o seguinte:

pi = 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + 5/11*(2 + ...)))))

O 6637(o denominador mais interno) pode ser formulado como:

dígitos * 2 * log 2 (10)

Isso implica uma convergência linear. Cada iteração mais profunda produzirá mais um bit binário de pi .

Se , no entanto, você insistir em usar aidentidade tan ^-1 , uma convergência semelhante poderá ser alcançada, se você não se importar em abordar o problema de maneira ligeiramente diferente. Analisando as somas parciais:

4.0, 2.66667, 3.46667, 2.89524, 3.33968, 2.97605, 3.28374, ...

é evidente que cada termo pula para frente e para trás em ambos os lados do ponto de convergência; a série tem convergência alternada. Além disso, cada termo está mais próximo do ponto de convergência do que o termo anterior; é absolutamente monotônico em relação ao seu ponto de convergência. A combinação dessas duas propriedades implica que a média aritmética de dois termos vizinhos está mais próxima do ponto de convergência do que qualquer um dos termos em si. Para ter uma idéia melhor do que quero dizer, considere a seguinte imagem:

A série externa é a original e a série interna é encontrada calculando a média de cada um dos termos vizinhos. Uma diferença notável. Mas o que é realmente notável é que essa nova série também possui convergência alternada e é absolutamente monotônica em relação ao seu ponto de convergência. Isso significa que esse processo pode ser aplicado repetidamente, ad nauseum.

Está bem. Mas como?

Algumas definições formais. Deixe- P ₁ (n) ser o n ^th termo da primeira sequência, P ₂ (n) ser o n ^th termo da segunda sequência, e semelhante P _k (n) o N ^° termo do k ^th sequência tal como acima definido .

P ₁ = [P ₁ (1), P ₁ (2), P ₁ (3), P ₁ (4), P ₁ (5), ...]

P ₂ = [(P ₁ (1) + P ₁ (2)) / 2, (P ₁ (2) + P ₁ (3)) / 2, (P ₁ (3) + P ₁ (4)) / 2, (P ₁ (4) + P ₁ (5)) / 2, ...]

P ₃ = [(P ₁ (1) + 2P ₁ (2) + P ₁ (3)) / 4, (P ₁ (2) + 2P ₁ (3) + P ₁ (4)) / 4, (P ₁ (3) + 2P ₁ (4) + P ₁ (5)) / 4, ...]

P ₄ = [(P ₁ (1) + 3P ₁ (2) + 3P ₁ (3) + P ₁ (4)) / 8, (P ₁ (2) + 3P ₁ (3) + 3P ₁ (4) + P ₁ (5)) / 8, ...]

Não surpreendentemente, esses coeficientes seguem exatamente os coeficientes binomiais e podem ser expressos como uma única linha do triângulo de Pascal. Como uma linha arbitrária do Triângulo de Pascal é trivial de calcular, uma série arbitrariamente 'profunda' pode ser encontrada, simplesmente tomando as primeiras n somas parciais, multiplicando cada pelo termo correspondente na k- ^ésima linha do Triângulo de Pascal e dividindo por 2 ^k-1 .

Dessa forma, a precisão total do ponto flutuante de 32 bits (~ 14 casas decimais) pode ser alcançada com apenas 36 iterações, momento em que as somas parciais nem convergiram para a segunda casa decimal. Obviamente, isso não é um jogo de golfe:

# 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

Se você queria precisão arbitrária, isso pode ser alcançado com uma pequena modificação. Aqui, mais uma vez, calculando 1000 dígitos:

# 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

O valor inicial de p começa 2 ¹⁰ maior, para neutralizar os efeitos da divisão inteira de s / d à medida que d se torna maior, fazendo com que os últimos dígitos não convergam. Observe aqui novamente que 3318também é:

dígitos * log 2 (10)

O mesmo número de iterações que o primeiro algoritmo (dividido pela metade porque t diminui em 1 em vez de 2 em cada iteração). Mais uma vez, isso indica uma convergência linear: um bit binário de pi por iteração. Em ambos os casos, são necessárias 3318 iterações para calcular 1000 dígitos de pi , como uma cota ligeiramente melhor que 1 milhão de iterações para calcular 5.

Mathematica 42 39 34 33 31 26 32

Abordagem de Arquimedes 26 caracteres

N@#*Sin[180 Degree/#]&

Isso atinge o critério quando a entrada é 822.

Pergunta: Alguém sabe como ele calculou o pecado de 180 graus? Eu não.

Abordagem de Leibniz (série de Gregory) 32 caracteres

Esta é a mesma função que o poser do problema deu como exemplo. Atinge o critério em aproximadamente meio milhão de iterações.

N@4Sum[(-1)^k/(2k+1),{k,0,10^6}]

Abordagem Madhava-Leibniz 37 caracteres

Essa variação usa mais alguns caracteres, mas converge para o critério em apenas 9 iterações!

N@Sqrt@12 Sum[(-1/3)^k/(2k+1),{k,0,9}]

APL (14)

4×-/÷1-⍨2×⍳1e6

Java (67 chars)

float r(){float p=0,s=4,i=1E6f;while(--i>0)p+=(s=-s)/i--;return p;}

Note that this avoids loss of significance by adding the numbers up in the correct order.

Haskell, 32

foldr(\k->(4/(2*k+1)-))0[0..8^7]

GHCi> foldr(\k->(4/(2*k+1)-))0[0..8^7]
3.141593130426724

Counting a function name it's

34

π=foldr(\k->(4/(2*k+1)-))0[0..8^7]

R - 25 chars

sum(c(4,-4)/seq(1,1e6,2))

C (GCC) (44 chars)

float p(i){return i<1E6?4./++i-p(++i):0;}

That's 41 chars, but it also has to be compiled with -O2 to get the optimiser to eliminate the tail recursion. This also relies on undefined behaviour with respect to the order in which the ++ are executed; thanks to ugoren for pointing this out. I've tested with gcc 4.4.3 under 64-bit Linux .

Note that unless the optimiser also reorders the sum, it will add from the smallest number, so it avoids loss of significance.

Call as p().

J, 26 chars

+/+/_2((4 _4)&%)>:+:i.100

Moved from 100 items of sequence to 1e6 items. Also now it's a code tagged and could be copypasted from browser to the console without errors.

+/+/_2((4 _4)&%)\>:+:i.1e6

Javascript - 33 Characters

p=x=>4*(1-(x&2))/x+(x>1?p(x-2):0)

Call p passing a positive odd number x and it will calculate Pi with (x-1)/2 terms.

Ruby - 82 chars

def f(n,k=n)k>0?(f(n,k-1)+f(n+1,k-1))/2:n<0?0:f(n-1,0)+(-1)**n/(2*n+1.0)end;4*f(9)

Try it : https://repl.it/LQ8w

The approach uses the given series indirectly using a numerical acceleration approach. The resulting output is

pi ≈ 3.14159265161

vs.

pi = 3.14159265359

It starts with

f(n,0) = 1/1 - 1/3 + 1/5 - ... + ((-1)**n)/(2*n+1)

And then, since this is alternating, we can accelerate the convergence using

f(n,1) = (f(n,0) + f(n+1,0))/2

And it repeatedly applies this:

f(n,k) = (f(n,k-1) + f(n+1,k-1))/2

And for simplicity, f(n) = f(n,n).

Ruby - 50 chars

If you don't mind running for a really long while, then you could simply use

def f(n)n<0?0:f(n-1)+(-1)**n/(2*n+1.0)end;4*f(1e7)

or

a=0;for k in 0..1e7 do a+=(-1)**k/(2*k+1.0)end;4*a

C, 69 chars

float p,b;void main(a){b++<9e6?p+=a/b++,main(-a):printf("%f\n",4*p);}

• Run with no command line parameters (so a is initialized to 1).
• Must be compiled with optimization.
• void main is strange and non-standard, but makes things work. Without it, the recursion is implemented as a real call, leading to a stack overflow. An alternative is adding return.
• Two characters 4* can be saved, if running with three command line parameters.

Clojure - 79 chars

(fn [](* 4(apply +(map #(*(Math/pow -1 %1)(/ 1.0(+ 1 %1 %1)))(range 377000)))))

This creates a function of no arguments which will calculate a float which approximates pi correctly to five decimal places. Note that this does not bind the function to a name such as pi, so this code must either be evaluated in place with eval as (<code>) or bound to a name in which case the solution is

(defn p[](* 4(apply +(map #(*(Math/pow -1 %1)(/ 1.0(+ 1 %1 %1)))(range 377000)))))

for 82 chars

About

(defn nth-term-of-pi [n] (* (Math/pow -1 n) (/ 1.0 (+ 1 n n))))
(defn pi [c] (* 4 (apply + (map nth-term-of-pi (range c)))))
(def  pi-accuracy-constant (loop [c 1000] (if (< (pi c) 3.14159) (recur (inc c)) c)))
; (pi pi-accuracy-constant) is then the value of pi to the accuracy of five decimal places

PHP - 56 55 chars

<?for($j=$i=-1;1e6>$j;){$p+=($i=-$i)/($j+=2);}echo$p*4;

I don't know that I can get it much smaller without breaking the algorithm rule.

Perl - 43 39 chars

not sure the rules on anonymous subroutines, but here's another implementation using @FireFly's series construction

sub{$s+=8/((4*$_+2)**2-1)for 0..1e6;$s}

sub p{$s+=(-1)**$_*4/(2*$_+1)for 0..1e6;$s}

Java - 92 84 chars

I cannot beat by far Peter Taylor's result, but here is mine:

double d(){float n=0,k=0,x;while(n<9E5){x=1/(1+2*n++);k+=(n%2==0)?-x:x;}return 4*k;}

Ungolfed version:

double d() {
    float n = 0, k = 0, x;
    while (n < 9E5) {
        x = 1 / (1 + 2 * n++);
        k += (n % 2 == 0) ? -x : x;
    }
    return 4 * k;
}

Edit: Saved a few characters using ternary operator.

Python - 56 chars

Meh, My python-fu is not strong enough. I couldn't see any more shortcuts but maybe a more experienced golfer could find something to trim here?

t=s=0
k=i=1
while t<1e6:t,s,i,k=t+1,k*4./i+s,i+2,-k

Ruby - 54 chars

def a()p=0;1000000.times{|i|p+=8/(4*i*(4*i+2))};p;end;

My first try on console

def a()i=1;p=0;while i<2**100 do p+=8/(i*(i+2));i+=4;end;p;end;

63 chars.

Perl (76 chars)

$y=1e4;for$x(0..1e4-1){$y--while sqrt($x**2+$y**2)>1e4;$a+=$y}print 4*$a/1e8

(Result: 3.14159052)

Not the shortest possible solution, but maybe interesting. It's a geometrical one. I calculate the area under a circle.

I got another funny approach, but it's really slow. It counts the number of discrete points in a square that are below a quarter circle and calculates pi from it:

$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2

It expects the number of iterations as command line argument. Here you can see how run time relates to accuracy. ;)

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 100
3.1796
real    0m0.011s
user    0m0.005s
sys 0m0.003s

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 1000
3.14552
real    0m0.354s
user    0m0.340s
sys 0m0.004s

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 10000
3.14199016
real    0m34.941s
user    0m33.757s
sys 0m0.097s

k (25 chars)

4*+/%(i#1 -1)'1+2!i:1000000

Slightly shorter:

+/(i#4 -4)%1+2*!i:1000000

Python (49)

print 4*sum((-1)**i/(2*i+1.)for i in range(9**6))

3.14159453527

CJam - 21

1e6{WI#4d*I2*)/}fI]:+

Pretty straightforward calculation of the given series.
CJam is http://sf.net/p/cjam

Julia - 30 characters

sum(4./[1:4:1e6] - 4./[3:4:1e6])

SQL, 253 bytes

DECLARE @B int=3, @A varchar(max), @C varchar(max)='1'
WHILE @B<100000
BEGIN
SELECT @C=@C+(select case when (@B-1)%4=0 then'+'else'-'end)+
(SELECT cast(cast(1.0/@B as decimal(9,8)) as varchar(max)))
SELECT @B=@B+2
END
EXECUTE('SELECT 4*('+@C+')')

I would provide a SQL Fiddle, but this goes too many loops deep finding the 1/3 1/5 1/7 etc. fractions and gives errors lol. However, if you change @B<100000 to 1000 then it runs (obviously not to the same number of digits of accuracy).

Befunge, 129 bytes

p08p109p^v*86%+55:<$$$<
\$\>:#,_@>+\55+/:#^_"."
v>p"~"/:"~"%08p"~"/00p:2\4%-*"(}"
8^90%"~":+2:+g90*+g80*<
>*:**\/+>"~~"00g:"~"`!|

Try it online!

In case anyone is wondering, it's an elephant.