Le défi

Vous devez calculer pi dans la plus courte longueur possible. N'importe quelle langue est la bienvenue pour rejoindre et vous pouvez utiliser n'importe quelle formule pour calculer pi. Il doit pouvoir calculer pi à au moins 5 décimales. Le plus court, serait mesuré en caractères. La compétition dure 48 heures. Commencer.

^{Remarque : Cette question similaire indique que PI doit être calculé en utilisant la série 4 * (1 - 1/3 + 1/5 - 1/7 +…). Cette question n'a pas cette restriction, et en fait beaucoup de réponses ici (y compris les plus susceptibles de gagner) seraient invalides dans cette autre question. Donc, ce n'est pas un doublon.}

Python3, 7

Fonctionne dans le shell interactif

355/113

Sortie:, 3.1415929203539825corriger à 6 décimales

Et enfin j'ai une solution qui bat APL!

Oh, et au cas où vous vous poseriez la question, ce rapport est appelé le 密 率 (littéralement "rapport précis"), et est proposé par le mathématicien chinois Zu Chongzhi (429-500 après JC). Un article wikipedia connexe peut être trouvé ici . Zu a également donné le ratio 22/7 comme le "ratio approximatif", et il est connu pour être le premier mathématicien à proposer que 3,1415926 <= pi <= 3,1415927

PHP - 132 127 125 124 octets

Simulation de base de Monte-Carlo. Toutes les 10 millions d'itérations, il imprime l'état actuel:

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

Merci à cloudfeet et zamnuts pour vos suggestions!

Exemple de sortie:

$ 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

Explication: *.donne la longueur et l'angle d'un nombre complexe. L'angle de -1 est pi. {:prend la queue de la liste [longueur, angle]

Juste pour les fettishists de séries lentement convergentes, pour 21 octets, une série de Leibniz:

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

Perl, 42 octets

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

Il calcule π en utilisant la formule de Leibniz :

999999 est utilisé comme le plus grand n pour obtenir la précision de cinq chiffres décimaux.

Résultat: 3.14159165358977

Piet, de nombreux codels

Pas ma réponse, mais c'est la meilleure solution que j'ai vue à ce problème:

Ma compréhension est qu'il additionne les pixels dans le cercle et divise par le rayon, puis encore une fois. C'est:

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

Une meilleure approche dans mon esprit est un programme qui génère cette image à une taille arbitraire, puis l'exécute via un interpréteur Piet.

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

TECHNIQUEMENT JE CALCULE, 9

0+3.14159

TECHNIQUEMENT, JE CALCULE ENCORE, 10

PI-acos(1)

JE CALCULE TELLEMENT, 8

acos(-1)

JE ACCIDENTELLEMENT PI, 12

"3.14"+"159"

Et techniquement, cette réponse pue.

APL - 6

2ׯ1○1

Sorties 3.141592654. Il calcule deux fois l'arc sinus de 1.

Une solution à 13 caractères serait:

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

Cela sort 3.141591654pour moi, ce qui correspond à la précision demandée.
Il utilise cependant la + 4/1 - 4/3 + 4/5 - 4/7 ...série simple pour calculer.

J - 5 octets

|^._1

Cela signifie |log(-1)|.

Calculatrice Google, 48

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

Prend un bâton de beurre, fait des calculs avancés, en fait pi. J'ai pensé que puisque tout le monde faisait des réponses mathématiques simples, j'en ajouterais un peu plus unique.

Exemple

Octave, 31

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

Calcule l'aire d'un quart de cercle de rayon 2, par intégration numérique.

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

Mathematica 6

180N@° 
-->3.14159

Python, 88

Solution :

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

Exemple de sortie dans le shell Python:

>>> print s
3.14159265359

Permet d'éviter toute importation. Peut facilement être échangé pour utiliser la bibliothèque Decimal de précision arbitraire; il suffit de remplacer 3.par Decimal('3'), définir la précision avant et après, puis unaire plus le résultat pour convertir la précision.

Et contrairement à beaucoup de réponses ici, calcule en fait π au lieu de s'appuyer sur des constantes intégrées ou des faux mathématiques, c'est math.acos(-1)-à- dire math.radians(180), etc.

langage d'assemblage x86 (5 caractères)

fldpi

Que cela charge une constante à partir de la ROM ou calcule réellement la réponse dépend du processeur (mais au moins pour certains, il effectue un calcul, pas seulement le chargement du nombre à partir de la ROM). Pour mettre les choses en perspective, il est répertorié comme prenant 40 cycles d'horloge sur un 387, ce qui est un peu plus que logique s'il ne s'agissait que de charger la valeur à partir de la ROM.

Si vous voulez vraiment assurer un calcul, vous pouvez faire quelque chose comme:

fld1
fld1
fpatan
fimul f

f dd 4

[pour 27 caractères]

bc -l, 37 octets

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

Je ne vois aucune autre réponse en utilisant le produit Wallis , donc comme il porte le nom de mon homonyme (mon histoire des mathématiques professeur d' tiré un gros coup), je n'ai pas pu résister.

Il s'avère que c'est un algorithme assez agréable du point de vue du golf, mais son taux de convergence est abyssal - approchant 1 million d'itérations juste pour obtenir 5 décimales:

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

Alternativement, nous pouvons utiliser Newton-Raphson pour résoudre sin(x)=0, avec une approximation de départ de 3. Parce que cela converge en si peu d'itérations, nous codons simplement en dur 2 itérations, ce qui donne 10 décimales:

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

La formule itérative selon Newton-Raphson est:

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

sin'=== coset cos(pi)=== -1, nous approximons donc simplement le costerme pour obtenir:

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

Production:

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

python - 47 45

pi est en fait calculé sans fonctions trigonométriques ni constantes.

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

résultat:

>>> a
3.1415907719167966

C, 99

Calcule directement l'aire / r ^ 2 d'un cercle.

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

Cette fonction calculera pi en comptant le nombre de pixels dans un cercle de rayon rpuis en divisant par r*r(en fait, elle ne calcule qu'un quadrant). Avecr 10000, il est précis à 5 décimales près (3,1415904800). Les paramètres de la fonction sont ignorés, je viens de les déclarer pour économiser de l'espace.

Javascript, 43 36

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

xdevient zeta(2)=pi^2/6ainsi sqrt(6*x)=pi. (47 caractères)

Après avoir utilisé la propriété distributive et supprimé les accolades de la forboucle, vous obtenez:

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

(43 caractères)

Il renvoie:

3.14159169865946

Éditer:

J'ai trouvé un moyen encore plus court d'utiliser le produit Wallis:

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

(36 caractères)

Il renvoie:

3.141591082792245

Python, Riemann zeta (58 41 car.)

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

Ou épargnez deux caractères, mais utilisez scipy

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

Edit : 16 (!) Caractères enregistrés grâce à amcgregor

Javascript: 99 caractères

En utilisant la formule donnée par Simon Plouffe en 1996, cela fonctionne avec 6 chiffres de précision après la virgule décimale:

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)

Cette variante plus longue (130 caractères) a une meilleure précision, 15 chiffres après la virgule décimale:

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)

J'ai fait ceci basé dans mes deux réponses à cette question .

Rubis, 54 50 49

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

Version en ligne pour les tests.

Une autre version sans créer de tableau (50 caractères):

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

Version en ligne pour les tests.

TI CAS, 35

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

Perl - 35 octets

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

Produit une précision en virgule flottante complète. Une dérivation de la formule utilisée peut être vue ailleurs .

Exemple d'utilisation:

$ perl pi.pl
3.14159265358979

Version de précision arbitraire

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

Prolongez au besoin. La longueur de l'itération (par exemple -329..-1) doit être ajustée pour être environ log ₂ (10) ≈ 3,322 fois le nombre de chiffres.

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211707

Ou, en utilisant à la bigintplace:

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

Cela s'exécute sensiblement plus rapidement, mais n'inclut pas de point décimal.

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

Les sorties:

3.14159265

Aucun calcul impliqué. Recherche simplement la version actuelle de TeX et effectue une analyse primitive du code HTML résultant. Finalement, il deviendra π selon Wikipedia .

Python 3 Monte Carlo (103 caractères)

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

Langue de Game Maker, 34

Suppose que toutes les variables non initialisées sont égales à 0. C'est la valeur par défaut dans certaines versions de Game Maker.

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

Résultat:

3.14159169865946

Java - 83 55

Shorter version thanks to Navin.

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

Old version:

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

R: 33 characters

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

Hopefully this follows the rules.

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

Uses some formula I don't really understand and just copied down. :P

Output: 3.1415926535897913

Ruby, 12

p 1.570796*2

I am technically "calculating" pi an approximation of pi.

JavaScript - 19 bytes

Math.pow(29809,1/9)

Calculates the 9th root of 29809.

3.1415914903890925