El reto

Debe calcular pi en la longitud más corta posible. Cualquier idioma es bienvenido y puede usar cualquier fórmula para calcular pi. Debe poder calcular pi con al menos 5 decimales. Más corto, se mediría en caracteres. La competencia dura 48 horas. Empezar.

^{Nota : Esta pregunta similar establece que PI debe calcularse utilizando la serie 4 * (1 - 1/3 + 1/5 - 1/7 + ...). Esta pregunta no tiene esta restricción, y de hecho muchas de las respuestas aquí (incluida la más probable de ganar) serían inválidas en esa otra pregunta. Entonces, esto no es un duplicado.}

Python3, 7

Se ejecuta en el shell interactivo

355/113

Salida: 3.1415929203539825correcta a 6 decimales

¡Y finalmente tengo una solución que supera a APL!

Ah, y en caso de que te lo preguntes, esta relación se llama 密 率 (literalmente "relación precisa"), y es propuesta por el matemático chino Zu Chongzhi (429-500 DC). Un artículo relacionado de Wikipedia se puede encontrar aquí . Zu también dio la relación 22/7 como la "relación aproximada", y se sabe que es el primer matemático en proponer que 3.1415926 <= pi <= 3.1415927

PHP - 132 127 125 124 bytes

Simulación básica de Montecarlo. Cada 10 millones de iteraciones, imprime el estado actual:

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";}

¡Gracias a cloudfeet y zamnuts por sus sugerencias!

Salida de muestra:

$ 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

Explicación: *.da la longitud y el ángulo de un número complejo. El ángulo de -1 es pi. {:toma la cola de la lista [longitud, ángulo]

Solo para los fetichistas de la serie de convergencia lenta, para 21 bytes, una serie de Leibniz:

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

Perl, 42 bytes

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

Calcula π usando la fórmula de Leibniz :

999999 se utiliza como n más grande para obtener la precisión de cinco dígitos decimales.

Resultado: 3.14159165358977

Piet, muchos codeles

No es mi respuesta, pero esta es la mejor solución que he visto para este problema:

Entiendo que suma los píxeles en el círculo y los divide por el radio, y luego nuevamente. Es decir:

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

Un mejor enfoque en mi mente es un programa que genera esta imagen en un tamaño arbitrario y luego la ejecuta a través de un intérprete Piet.

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

TÉCNICAMENTE ESTOY CALCULANDO, 9

0+3.14159

TÉCNICAMENTE ESTOY CALCULANDO, 10

PI-acos(1)

ESTOY CALCULANDO TAN DURO, 8

acos(-1)

ACCIDENTEMENTE PI, 12

"3.14"+"159"

Y técnicamente, esta respuesta apesta.

APL - 6

2ׯ1○1

Salidas 3.141592654. Calcula el doble del arcoseno de 1.

Una solución de 13 caracteres sería:

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

Esto resulta 3.141591654para mí, que se ajusta a la precisión solicitada.
Sin + 4/1 - 4/3 + 4/5 - 4/7 ...embargo, utiliza la serie simple para calcular.

J - 5 bytes

|^._1

Este medio |log(-1)|.

Calculadora Google, 48

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

Toma un trozo de mantequilla, hace cálculos avanzados, hace pi con él. Pensé que como todos los demás estaban haciendo respuestas matemáticas simples, agregaría una un poco más única.

Ejemplo

Octava, 31

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

Calcula el área de un cuarto de círculo con radio 2, a través de la integración numérica.

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

Mathematica 6

180N@° 
-->3.14159

Python, 88

Solución:

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

Salida de muestra en Python Shell:

>>> print s
3.14159265359

Logra evitar cualquier importación. Se puede intercambiar fácilmente para usar la biblioteca Decimal de precisión arbitraria; simplemente reemplace 3.con Decimal('3'), establezca la precisión antes y después, luego unario más el resultado para convertir la precisión.

Y a diferencia de una gran cantidad de las respuestas aquí, en realidad calcula π lugar de depender de constantes integradas o falsedad de matemáticas, es decir math.acos(-1), math.radians(180), etc.

lenguaje ensamblador x86 (5 caracteres)

fldpi

Sin embargo, si esto carga una constante desde la ROM o si realmente calcula la respuesta depende del procesador (pero al menos en algunos, en realidad hace un cálculo, no solo carga el número desde la ROM). Para poner las cosas en perspectiva, se enumera como tomar 40 ciclos de reloj en un 387, lo que es más de lo que parece tener sentido si solo cargara el valor de la ROM.

Si realmente desea garantizar un cálculo, puede hacer 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

No veo ninguna otra respuesta usando el producto Wallis , así que dado que lleva el nombre de mi homónimo (mi profesor de Historia de las Matemáticas recibió un gran impulso de eso), no pude resistirme.

Resulta que es un algoritmo bastante agradable desde la perspectiva del golf, pero su tasa de convergencia es abismal: se acerca a 1 millón de iteraciones solo para obtener 5 decimales:

$ 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

Alternativamente, podemos usar Newton-Raphson para resolver sin(x)=0, con una aproximación inicial de 3. Debido a que esto converge en muy pocas iteraciones, simplemente codificamos 2 iteraciones, lo que da 10 decimales:

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

La fórmula iterativa según Newton-Raphson es:

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

sin'=== cosy cos(pi)=== -1, así que simplemente aproximamos el costérmino para obtener:

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

Salida:

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

pitón - 47 45

pi se calcula realmente sin funciones trigonométricas o constantes.

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

resultado:

>>> a
3.1415907719167966

C, 99

Calcula directamente el área / r ^ 2 de un 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 función calculará pi contando el número de píxeles en un círculo de radio y rluego dividiendo entre r*r(en realidad solo calcula un cuadrante). Con r10000, tiene una precisión de 5 decimales (3.1415904800). Los parámetros de la función se ignoran, los acabo de declarar allí para ahorrar espacio.

Javascript, 43 36

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

x se convierte zeta(2)=pi^2/6 así sqrt(6*x)=pi. (47 caracteres)

Después de usar la propiedad distributiva y eliminar los corchetes del forbucle, obtienes:

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

(43 caracteres)

Vuelve:

3.14159169865946

Editar:

Encontré una forma aún más corta usando el producto Wallis:

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

(36 caracteres)

Vuelve:

3.141591082792245

Python, Riemann zeta (58 41 char)

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

O ahorre dos caracteres, pero use scipy

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

Editar : Guardado 16 (!) Caracteres gracias a amcgregor

Javascript: 99 caracteres

Usando la fórmula dada por Simon Plouffe en 1996, esto funciona con 6 dígitos de precisión después del punto 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)

Esta variante más larga (130 caracteres) tiene una mejor precisión, 15 dígitos después del punto 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)

Hice esto basado en mis dos respuestas a esta pregunta .

Rubí, 54 50 49

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

Versión en línea para pruebas.

Otra versión sin crear una matriz (50 caracteres):

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

Versión en línea para pruebas.

TI CAS, 35

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

Perl - 35 bytes

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

Produce precisión de coma flotante completa. Una derivación de la fórmula utilizada se puede ver en otra parte .

Uso de la muestra:

$ perl pi.pl
3.14159265358979

Versión de precisión arbitraria

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

Extienda según sea necesario. La longitud de la iteración (p -329..-1. Ej. ) Debe ajustarse para que sea aproximadamente log ₂ (10) ≈ 3.322 veces el número de dígitos.

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211707

O, usando en su bigintlugar:

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

Esto funciona notablemente más rápido, pero no incluye un punto 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]);}}

Salidas:

3.14159265

No hay matemáticas involucradas. Simplemente busca la versión actual de TeX y realiza un análisis primitivo del html resultante. Eventualmente se convertirá en π según 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

Game Maker Language, 34

Asume todas las variables no inicializadas como 0. Esto es predeterminado en algunas versiones de Game Maker.

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

Resultado:

3.14159169865946

Java - 83 55

Versión más corta gracias a Navin.

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

Versión antigua:

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

Esperemos que esto siga las reglas.

Rubí, 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

Utiliza alguna fórmula que realmente no entiendo y que acabo de copiar. :PAG

Salida: 3.1415926535897913

Rubí, 12

p 1.570796*2

Yo estoy técnicamente "calculando" pi una aproximación de pi.

JavaScript: 19 bytes

Math.pow(29809,1/9)

Calcula el 9 º raíz de 29809 .

3.1415914903890925