La sfida

Devi calcolare il pi nella minor lunghezza possibile. È possibile partecipare a qualsiasi lingua e puoi utilizzare qualsiasi formula per calcolare pi. Deve essere in grado di calcolare pi con almeno 5 cifre decimali. Più breve, verrebbe misurato in caratteri. La competizione dura 48 ore. Inizio.

^{Nota : questa domanda simile afferma che il PI deve essere calcolato usando la serie 4 * (1 - 1/3 + 1/5 - 1/7 +…). Questa domanda non ha questa limitazione, e in effetti molte risposte qui (inclusa la più probabile da vincere) non sarebbero valide in quell'altra domanda. Quindi, questo non è un duplicato.}

Python3, 7

Funziona nella shell interattiva

355/113

Output:, 3.1415929203539825corretto con 6 decimali

E finalmente ho una soluzione che batte APL!

Oh, e nel caso vi stiate chiedendo, questo rapporto è chiamato 密 率 (letteralmente "rapporto preciso"), ed è proposto dal matematico cinese Zu Chongzhi (429-500 d.C.). Un articolo relativo a Wikipedia può essere trovato qui . Zu ha anche dato il rapporto 22/7 come "rapporto approssimativo", ed è noto per essere il primo matematico a proporre che 3.1415926 <= pi <= 3.1415927

PHP - 132 127 125 124 byte

Simulazione di base Monte-Carlo. Ogni 10 M iterazioni, stampa lo stato corrente:

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

Grazie a cloudfeet e zamnuts per i suggerimenti!

Uscita campione:

$ 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

Spiegazione: *.fornisce lunghezza e angolo di un numero complesso. L'angolo di -1 è pi. {:prende la coda della lista [lunghezza, angolo]

Solo per i feticisti della serie che convergono lentamente, per 21 byte, una serie di Leibniz:

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

Perl, 42 byte

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

Calcola π usando la formula di Leibniz :

999999 viene utilizzato come n più grande per ottenere la precisione di cinque cifre decimali.

Risultato: 3.14159165358977

Piet, molti codici

Non è la mia risposta, ma questa è la migliore soluzione che ho visto a questo problema:

La mia comprensione è che somma i pixel nel cerchio e si divide per il raggio, e poi ancora una volta. Questo è:

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

Un approccio migliore nella mia mente è un programma che genera questa immagine a dimensioni arbitrarie e quindi la esegue attraverso un interprete Piet.

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

TECNICAMENTE STO CALCOLANDO, 9

0+3.14159

TECNICAMENTE STO ANCORA CALCOLANDO, 10

PI-acos(1)

STO CALCOLANDO COSÌ DURO, 8

acos(-1)

I ACCIDENTAMENTE PI, 12

"3.14"+"159"

E tecnicamente, questa risposta puzza.

APL - 6

2ׯ1○1

Uscite 3.141592654. Calcola il doppio dell'arcoseno di 1.

Una soluzione a 13 caratteri sarebbe:

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

Questo 3.141591654mi dà risultati che si adattano alla precisione richiesta.
Usa però le + 4/1 - 4/3 + 4/5 - 4/7 ...serie semplici per calcolare.

J - 5 byte

|^._1

Questo significa |log(-1)|.

Google Calculator, 48

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

Prende un bastoncino di burro, esegue calcoli avanzati, ne ricava pi. Ho pensato che dal momento che tutti gli altri facevano semplici risposte matematiche, ne avrei aggiunto uno leggermente più unico.

Esempio

Ottava, 31

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

Calcola l'area di un quarto di un cerchio con raggio 2, attraverso l'integrazione numerica.

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

Mathematica 6

180N@° 
-->3.14159

Python, 88

Soluzione:

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

Output di esempio nella shell Python:

>>> print s
3.14159265359

Riesce a evitare qualsiasi importazione. Può essere facilmente scambiato per utilizzare la libreria decimale di precisione arbitraria; basta sostituire 3.con Decimal('3'), impostare la precisione prima e dopo, quindi unaria più il risultato per convertire la precisione.

E a differenza di un sacco di risposte qui, in realtà calcola π invece di affidarsi a built-in costanti o matematica falsità, vale a dire math.acos(-1), math.radians(180), etc.

linguaggio assembly x86 (5 caratteri)

fldpi

Se questo carica una costante dalla ROM o calcola effettivamente la risposta dipende comunque dal processore (ma almeno da alcuni, esegue effettivamente un calcolo, non solo caricando il numero dalla ROM). Per mettere le cose in prospettiva, è elencato come prendere 40 cicli di clock su un 387, il che è piuttosto più che sembra sensato se stesse caricando il valore dalla ROM.

Se vuoi davvero garantire un calcolo, potresti fare qualcosa del tipo:

fld1
fld1
fpatan
fimul f

f dd 4

[per 27 caratteri]

bc -l, 37 byte

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

Non vedo altre risposte usando il prodotto Wallis , quindi dal momento che prende il nome dal mio omonimo (il mio professore di Storia della Matematica ne è stato entusiasta), non ho potuto resistere.

Si scopre che è un algoritmo abbastanza carino dal punto di vista del golf, ma il suo tasso di convergenza è spaventoso - si avvicina a 1 milione di iterazioni solo per ottenere 5 cifre decimali:

$ 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 byte

In alternativa, possiamo usare Newton-Raphson per risolvere sin(x)=0, con un'approssimazione iniziale di 3. Poiché questo converge in così poche iterazioni, possiamo semplicemente codificare 2 iterazioni, che danno 10 cifre decimali:

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

La formula iterativa secondo Newton-Raphson è:

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

sin'=== cose cos(pi)=== -1, quindi approssimiamo semplicemente il costermine per ottenere:

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

Produzione:

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

pitone - 47 45

pi viene attualmente calcolato senza funzioni di trig o costanti.

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

risultato:

>>> a
3.1415907719167966

C, 99

Calcola direttamente l'area / r ^ 2 di un cerchio.

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

Questa funzione calcolerà pi contando il numero di pixel in un cerchio di raggio rquindi dividendolo per r*r(in realtà calcola solo un quadrante). Con r10000, è preciso al 5 decimale (3.1415904800). I parametri della funzione vengono ignorati, li ho appena dichiarati lì per risparmiare spazio.

Javascript, 43 36

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

xdiventa zeta(2)=pi^2/6così sqrt(6*x)=pi. (47 caratteri)

Dopo aver usato la proprietà distributiva e aver eliminato le parentesi graffe dal forciclo si ottiene:

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

(43 caratteri)

Restituisce:

3.14159169865946

Modificare:

Ho trovato un modo ancora più breve usando il prodotto Wallis:

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

(36 caratteri)

Restituisce:

3.141591082792245

Python, Riemann zeta (58 41 caratteri)

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

O risparmia due personaggi, ma usa scipy

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

Modifica : salvati 16 (!) Caratteri grazie ad amcgregor

Javascript: 99 caratteri

Usando la formula data da Simon Plouffe nel 1996, funziona con 6 cifre di precisione dopo il punto decimale:

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)

Questa variante più lunga (130 caratteri) ha una precisione migliore, 15 cifre dopo il punto decimale:

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)

L'ho fatto basandomi sulle mie due risposte a questa domanda .

Rubino, 54 50 49

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

Versione online per il test.

Un'altra versione senza creare un array (50 caratteri):

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

Versione online per il test.

TI CAS, 35

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

Perl - 35 byte

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

Produce la massima precisione in virgola mobile. Una derivazione della formula utilizzata può essere vista altrove .

Esempio di utilizzo:

$ perl pi.pl
3.14159265358979

Versione arbitraria di precisione

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

Estendere se necessario. La lunghezza dell'iterazione (ad es. -329..-1) Deve essere regolata per essere approssimativamente log ₂ (10) ≈ 3.322 volte il numero di cifre.

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211707

Oppure, usando bigintinvece:

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

Funziona notevolmente più velocemente, ma non include un punto decimale.

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]);}}

Uscite:

3.14159265

Nessuna matematica coinvolta. Cerca la versione corrente di TeX e analizza in modo primitivo l'html risultante. Alla fine diventerà π secondo Wikipedia .

Python 3 Monte Carlo (103 caratteri)

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

Presuppone tutte le variabili non inizializzate come 0. Questo è predefinito in alcune versioni di Game Maker.

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

Risultato:

3.14159169865946

Java - 83 55

Versione più corta grazie a Navin.

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

Vecchia versione:

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

R : 33 caratteri

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

Speriamo che questo segua le regole.

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 una formula che non capisco davvero e che ho appena copiato. : P

Produzione: 3.1415926535897913

Ruby, 12

p 1.570796*2

Io sto tecnicamente "Calcolo" pi greco un'approssimazione di pi greco.

JavaScript - 19 bytes

Math.pow(29809,1/9)

Calculates the 9th root of 29809.

3.1415914903890925