O desafio

Você deve calcular pi no menor comprimento possível. Qualquer idioma é bem-vindo, e você pode usar qualquer fórmula para calcular pi. Ele deve ser capaz de calcular pi com pelo menos 5 casas decimais. O menor, seria medido em caracteres. A competição dura 48 horas. Início.

^{Nota : Essa pergunta semelhante afirma que o PI deve ser calculado usando a série 4 * (1 - 1/3 + 1/5 - 1/7 +…). Esta pergunta não possui essa restrição e, de fato, muitas respostas aqui (incluindo as que têm maior probabilidade de ganhar) seriam inválidas nessa outra pergunta. Portanto, isso não é uma duplicata.}

Python3, 7

Executa no shell interativo

355/113

Saída: 3.1415929203539825corrija até 6 casas decimais

E, finalmente, tenho uma solução que supera o APL!

Ah, e no caso de você estar se perguntando, essa proporção é chamada de 密 率 (literalmente "proporção precisa") e é proposta pelo matemático chinês Zu Chongzhi (429-500 dC). Um artigo relacionado da Wikipedia pode ser encontrado aqui . Zu também forneceu a relação 22/7 como a "relação aproximada" e é conhecido por ser o primeiro matemático a propor que 3,1415926 <= pi <= 3,1415927

PHP - 132 127 125 124 bytes

Simulação básica de Monte-Carlo. A cada 10 milhões de iterações, ele imprime o status atual:

for($i=1,$j=$k=0;;$i++){$x=mt_rand(0,1e7)/1e7;$y=mt_rand(0,1e7)/1e7;$j+=$x*$x+$y*$y<=1;$k++;if(!($i%1e7))echo 4*$j/$k."\n";}

Obrigado a cloudfeet e zamnuts por sugestões!

Saída de amostra:

$ php pi.php
3.1410564
3.1414008
3.1413388
3.1412641
3.14132568
3.1413496666667
3.1414522857143
3.1414817
3.1415271111111
3.14155092
...
3.1415901754386
3.1415890482759
3.1415925423731

J 6

{:*._1

Explicação: *.fornece o comprimento e o ângulo de um número complexo. O ângulo de -1 é pi. {:pega o final da lista [comprimento, ângulo]

Apenas para os fetiche por séries de convergência lenta, por 21 bytes, uma série de Leibniz:

      +/(4*_1&^%>:@+:)i.1e6
 3.14159

Perl, 42 bytes

map{$a+=(-1)**$_/(2*$_+1)}0..9x6;print$a*4

Ele calcula π usando a fórmula de Leibniz :

999999 é usado como o maior n para obter a precisão de cinco dígitos decimais.

Resultado: 3.14159165358977

Piet, muitos codéis

Não é minha resposta, mas esta é a melhor solução que já vi para esse problema:

Meu entendimento é que ele soma os pixels do círculo e divide pelo raio, e depois novamente. Isso é:

A = πr²  # solve for π
π = A/r²
π = (A/r)/r

Uma abordagem melhor em minha mente é um programa que gera essa imagem em um tamanho arbitrário e a executa através de um intérprete Piet.

Fonte: http://www.dangermouse.net/esoteric/piet/samples.html

Tecnicamente estou calculando, 9

0+3.14159

Tecnicamente, ainda estou calculando, 10

PI-acos(1)

Estou calculando tão difícil, 8

acos(-1)

ACIDENTEMENTE PI, 12

"3.14"+"159"

E tecnicamente, essa resposta é ruim.

APL - 6

2ׯ1○1

Saídas 3.141592654 . Ele calcula o dobro do arco de seno de 1.

Uma solução de 13 caracteres seria:

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

Isso gera 3.141591654para mim, que se ajusta à precisão solicitada.
No + 4/1 - 4/3 + 4/5 - 4/7 ...entanto, ele usa as séries simples para calcular.

J - 5 bytes

|^._1

Isto significa |log(-1)|.

Calculadora do Google, 48

stick of butter*(26557.4489*10^-9)/millimeters^3

Toma um pedaço de manteiga, faz cálculos avançados, faz pi com isso. Imaginei que, como todo mundo estava fazendo respostas matemáticas simples, eu adicionaria uma mais leve.

Exemplo

Oitava, 31

quad(inline("sqrt(4-x^2)"),0,2)

Calcula a área de um quarto de círculo com raio 2, através da integração numérica.

octave:1> quad(inline("sqrt(4-x^2)"),0,2)
ans =     3.14159265358979

Mathematica 6

180N@° 
-->3.14159

Python, 88

Solução:

l=q=d=0;t,s,n,r=3.,3,1,24
while s!=l:l,n,q,d,r=s,n+q,q+8,d+r,r+32;t=(t*n)/d;s+=t
print s

Exemplo de saída no shell Python:

>>> print s
3.14159265359

Consegue evitar importações. Pode ser facilmente trocado para usar a biblioteca Decimal de precisão arbitrária; apenas substitua3. por Decimal('3'), defina a precisão antes e depois e, em seguida, unário mais o resultado para converter a precisão.

E ao contrário de um lote inteiro das respostas aqui, na verdade, calcula π em vez de confiar em built-in constantes ou fakery matemática, ou seja math.acos(-1), math.radians(180), etc.

linguagem assembly x86 (5 caracteres)

fldpi

Se isso carrega uma constante da ROM ou realmente calcula a resposta, depende do processador (mas, pelo menos em algumas, ele efetua um cálculo, não apenas carregando o número da ROM). Para colocar as coisas em perspectiva, ele é listado como tendo 40 ciclos de clock em um 387, o que é um pouco mais do que parece fazer sentido se ele estivesse carregando o valor da ROM.

Se você realmente deseja garantir um cálculo, pode fazer algo como:

fld1
fld1
fpatan
fimul f

f dd 4

[para 27 caracteres]

bc -l, 37 bytes

for(p=n=2;n<7^7;n+=2)p*=n*n/(n*n-1);p

Não vejo nenhuma outra resposta usando o produto Wallis , então, desde que recebeu o nome do meu homônimo (meu professor de História da Matemática recebeu um grande impulso disso), não pude resistir.

Acontece que é um algoritmo bastante bom da perspectiva do golfe, mas sua taxa de convergência é péssima - chegando a 1 milhão de iterações apenas para obter 5 casas decimais:

$ time bc -l<<<'for(p=n=2;n<7^7;n+=2)p*=n*n/(n*n-1);p'
3.14159074622629555058

real    0m3.145s
user    0m1.548s
sys 0m0.000s
$ 

bc -l, 15 bytes

Como alternativa, podemos usar Newton-Raphson para resolver sin(x)=0, com uma aproximação inicial de 3. Como isso converge em tão poucas iterações, simplesmente codificamos duas iterações, o que fornece 10 casas decimais:

x=3+s(3);x+s(x)

A fórmula iterativa de acordo com Newton-Raphson é:

x[n+1] = x[n] - ( sin(x[n]) / sin'(x[n]) )

sin'=== cose cos(pi)=== -1, simplesmente aproximamos o costermo para obter:

x[n+1] = x[n] + sin(x[n])

Resultado:

$ bc -l<<<'x=3+s(3);x+s(x)'
3.14159265357219555873
$ 

Pitão - 47 45

pi está realmente sendo calculado sem funções trigonométricas ou constantes.

a=4
for i in range(9**6):a-=(-1)**i*4/(2*i+3)

resultado:

>>> a
3.1415907719167966

C, 99

Calcula diretamente a área / r ^ 2 de um círculo.

double p(n,x,y,r){r=10000;for(n=x=0;x<r;++x)for(y=1;y<r;++y)n+=x*x+y*y<=r*r;return(double)n*4/r/r;}

Esta função calculará pi contando o número de pixels em um círculo de raio e rdepois dividindo por r*r(na verdade, apenas calcula um quadrante). Com r10000, é preciso ter 5 casas decimais (3,1415904800). Os parâmetros para a função são ignorados, eu apenas os declarei lá para economizar espaço.

Javascript, 43 36

x=0;for(i=1;i<1e6;i++){x+=1/i/i};Math.sqrt(6*x)

xtorna zeta(2)=pi^2/6- se assim sqrt(6*x)=pi. (47 caracteres)

Depois de usar a propriedade distributiva e excluir os colchetes do forloop, você obtém:

x=0;for(i=1;i<1e6;i++)x+=6/i/i;Math.sqrt(x)

(43 caracteres)

Retorna:

3.14159169865946

Editar:

Encontrei uma maneira ainda mais curta usando o produto Wallis:

x=i=2;for(;i<1e6;i+=2)x*=i*i/(i*i-1)

(36 caracteres)

Retorna:

3.141591082792245

Python, Riemann zeta (58 41 caracteres)

(6*sum(n**-2for n in range(1,9**9)))**0.5

Ou poupe dois caracteres, mas use scipy

import scipy.special as s
(6*s.zeta(2,1))**0.5

Editar : salvou 16 (!) Caracteres graças a amcgregor

Javascript: 99 caracteres

Usando a fórmula dada por Simon Plouffe em 1996, isso funciona com 6 dígitos de precisão após o ponto decimal:

function f(k){return k<2?1:f(k-1)*k}for(y=-3,n=1;n<91;n++)y+=n*(2<<(n-1))*f(n)*f(n)/f(2*n);alert(y)

Essa variante mais longa (130 caracteres) tem uma precisão melhor, 15 dígitos após o ponto decimal:

function e(x){return x<1?1:2*e(x-1)}function f(k){return k<2?1:f(k-1)*k}for(y=-3,n=1;n<91;n++)y+=n*e(n)*f(n)*f(n)/f(2*n);alert(y)

Fiz isso com base nas minhas duas respostas a esta pergunta .

Rubi, 54 50. 49.

p (0..9**6).map{|e|(-1.0)**e/(2*e+1)*4}.reduce :+

Versão online para teste.

Outra versão sem criar uma matriz (50 caracteres):

x=0;(0..9**6).each{|e|x+=(-1.0)**e/(2*e+1)*4}; p x

Versão online para teste.

TI CAS, 35

lim(x*(1/(tan((180-360/x)/2))),x,∞)

Perl - 35 bytes

$\=$\/(2*$_-1)*$_+2for-46..-1;print

Produz precisão total de ponto flutuante. Uma derivação da fórmula usada pode ser vista em outro lugar .

Uso da amostra:

$ perl pi.pl
3.14159265358979

Versão de Precisão Arbitrária

use bignum a,99;$\=$\/(2*$_-1)*$_+2for-329..-1;print

Estenda conforme necessário. O comprimento da iteração (por exemplo -329..-1) deve ser ajustado para ser aproximadamente log ₂ (10) ≈ 3.322 vezes o número de dígitos.

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211707

Ou, usando bigint:

use bigint;$\=$\/(2*$_-1)*$_+2e99for-329..-1;print

Isso é notavelmente mais rápido, mas não inclui um ponto decimal.

3141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067

C # 192

class P{static void Main(){var s=(new System.Net.WebClient()).DownloadString("http://www.ctan.org/pkg/tex");System.Console.WriteLine(s.Substring(s.IndexOf("Ver­sion")+21).Split(' ')[0]);}}

Saídas:

3.14159265

Nenhuma matemática envolvida. Apenas consulta a versão atual do TeX e faz algumas análises primitivas do html resultante. Eventualmente, ele se tornará π de acordo com a Wikipedia .

Python 3 Monte Carlo (103 caracteres)

from random import random as r
sum(1 for x,y in ((r(),r()) for i in range(2**99)) if x**2+y**2<1)/2**97

Linguagem do Game Maker, 34

Assume todas as variáveis ​​não inicializadas como 0. Isso é padrão em algumas versões do Game Maker.

for(i=1;i<1e8;i++)x+=6/i/i;sqrt(x)

Resultado:

3.14159169865946

Java - 83 55

Versão mais curta graças ao Navin.

class P{static{System.out.print(Math.toRadians(180));}}

Versão antiga:

class P{public static void main(String[]a){System.out.print(Math.toRadians(180));}}

R : 33 caracteres

sqrt(8*sum(1/seq(1,1000001,2)^2))
[1] 3.141592

Espero que isso siga as regras.

Ruby, 82

q=1.0
i=0
(0.0..72).step(8){|k|i+=1/q*(4/(k+1)-2/(k+4)-1/(k+5)-1/(k+6))
q*=16}
p i

Usa uma fórmula que eu realmente não entendo e apenas copio. : P

Resultado: 3.1415926535897913

Ruby, 12

p 1.570796*2

Eu estou tecnicamente "cálculo" pi uma aproximação do pi.

JavaScript - 19 bytes

Math.pow(29809,1/9)

Calcula a 9ª raiz de 29809 .

3.1415914903890925