Die Herausforderung

Sie müssen pi in der kürzesten Länge berechnen, die Sie können. Jede Sprache kann teilnehmen und Sie können jede Formel verwenden, um pi zu berechnen. Es muss in der Lage sein, pi mit mindestens 5 Dezimalstellen zu berechnen. Kürzeste, würde in Zeichen gemessen. Der Wettbewerb dauert 48 Stunden. Start.

^{Hinweis : Diese ähnliche Frage besagt, dass PI unter Verwendung der Reihe 4 * (1 - 1/3 + 1/5 - 1/7 +…) berechnet werden muss. Diese Frage unterliegt nicht dieser Einschränkung, und in der Tat wären viele Antworten hier (einschließlich der wahrscheinlichsten zu gewinnen) in dieser anderen Frage ungültig. Das ist also kein Duplikat.}

Python3, 7

Läuft in der interaktiven Shell

355/113

Ausgabe: Auf 3.14159292035398256 Nachkommastellen korrigieren

Und schließlich habe ich eine Lösung, die APL schlägt!

Oh, und für den Fall, dass Sie sich fragen, wird dieses Verhältnis als 密 密 (wörtlich "genaues Verhältnis") bezeichnet und vom chinesischen Mathematiker Zu Chongzhi (429-500 n. Chr.) Vorgeschlagen. Einen verwandten Wikipedia-Artikel finden Sie hier . Zu gab das Verhältnis 22/7 auch als "grobes Verhältnis" an, und er ist bekanntermaßen der erste Mathematiker, der 3.1415926 <= pi <= 3.1415927 vorschlägt

PHP - 132 127 125 124 Bytes

Grundlegende Monte-Carlo-Simulation. Alle 10 Millionen Iterationen wird der aktuelle Status ausgegeben:

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

Danke an cloudfeet und zamnuts für Vorschläge!

Beispielausgabe:

$ 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

Erklärung: *.Gibt die Länge und den Winkel einer komplexen Zahl an. Der Winkel von -1 ist pi. {:Nimmt das Ende der Liste [Länge, Winkel]

Nur für die langsam konvergierenden Serien-Fettishisten, für 21 Bytes, eine Leibniz-Serie:

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

Perl, 42 Bytes

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

Es berechnet π mit der Leibniz-Formel :

999999 wird als größtes n verwendet , um die Genauigkeit von fünf Dezimalstellen zu erhalten.

Ergebnis: 3.14159165358977

Piet, viele Codels

Nicht meine Antwort, aber dies ist die beste Lösung, die ich für dieses Problem gesehen habe:

Meines Wissens addiert es die Pixel im Kreis und dividiert durch den Radius und dann noch einmal. Das ist:

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

Ein besserer Ansatz für mich ist ein Programm, das dieses Bild in einer beliebigen Größe generiert und es dann über einen Piet-Interpreter ausführt.

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

TECHNISCH BERECHNE ICH, 9

0+3.14159

TECHNISCH BERECHNE ICH NOCH, 10

PI-acos(1)

Ich berechne so hart, 8

acos(-1)

Ich versehentlich PI, 12

"3.14"+"159"

Und technisch stinkt diese Antwort.

APL - 6

2ׯ1○1

Ausgänge 3.141592654. Es wird der doppelte Arkussinus von 1 berechnet.

Eine 13-Zeichen-Lösung wäre:

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

Das ergibt 3.141591654für mich die gewünschte Präzision. Zur Berechnung
wird jedoch die einfache + 4/1 - 4/3 + 4/5 - 4/7 ...Reihe verwendet.

J - 5 Bytes

|^._1

Das heißt |log(-1)|.

Google-Rechner, 48

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

Nimmt ein Stück Butter, führt fortgeschrittene Berechnungen durch und macht Pi daraus. Ich dachte, da alle anderen einfache mathematische Antworten machten, würde ich eine etwas einzigartigere hinzufügen.

Beispiel

Oktave, 31

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

Berechnet die Fläche eines Viertelkreises mit Radius 2 durch numerische Integration.

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

Mathematica 6

180N@° 
-->3.14159

Python, 88

Lösung:

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

Beispielausgabe in der Python-Shell:

>>> print s
3.14159265359

Verwaltet, um Importe zu vermeiden. Kann einfach ausgetauscht werden, um die Dezimalbibliothek mit beliebiger Genauigkeit zu verwenden. ersetzen Sie einfach 3.mit Decimal('3'), stellen Sie die Präzision vor und nach, dann einstellige und das Ergebnis zu konvertieren Präzision.

Und im Gegensatz zu einer ganzen Menge der Antworten hier tatsächlich berechnet π statt auf der Berufung integrierte Konstanten oder Mathematik fakery, das heißt math.acos(-1), math.radians(180)etc.

x86-Assemblersprache (5 Zeichen)

fldpi

Ob dies eine Konstante aus dem ROM lädt oder die Antwort tatsächlich berechnet, hängt jedoch vom Prozessor ab (aber zumindest von einigen wird tatsächlich eine Berechnung durchgeführt und nicht nur die Zahl aus dem ROM geladen). Um die Dinge ins rechte Licht zu rücken: Auf einer 387 werden 40 Taktzyklen benötigt. Dies ist mehr als sinnvoll, wenn nur der Wert aus dem ROM geladen wird.

Wenn Sie wirklich eine Berechnung sicherstellen möchten, können Sie Folgendes tun:

fld1
fld1
fpatan
fimul f

f dd 4

[für 27 Zeichen]

bc -l, 37 Bytes

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

Ich sehe keine anderen Antworten für das Wallis-Produkt . Da es nach meinem Namensvetter benannt ist (mein Dozent für Geschichte der Mathematik hatte einen großen Kick davon), konnte ich nicht widerstehen.

Es stellt sich heraus, dass der Algorithmus aus der Sicht des Golfsports ziemlich gut ist, aber die Konvergenzrate ist miserabel - er nähert sich 1 Million Iterationen, um nur 5 Dezimalstellen zu erhalten:

$ 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

Alternativ können wir Newton-Raphson verwenden, um sin(x)=0mit einer Anfangsnäherung von 3 zu lösen . Da dies in so wenigen Iterationen konvergiert, codieren wir einfach 2 Iterationen hart, was 10 Dezimalstellen ergibt:

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

Die iterative Formel nach Newton-Raphson lautet:

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

sin' === cos und cos(pi)=== -1, also approximieren wir einfach den cosBegriff, um zu erhalten:

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

Ausgabe:

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

Python - 47 45

pi wird tatsächlich ohne Triggerfunktionen oder Konstanten berechnet.

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

Ergebnis:

>>> a
3.1415907719167966

C 99

Berechnet direkt die Fläche / r ^ 2 eines Kreises.

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

Diese Funktion berechnet pi, indem sie die Anzahl der Pixel in einem Radiuskreis zählt und rdann durch dividiert r*r(tatsächlich berechnet sie nur einen Quadranten). Mit r10000 ist es auf 5 Dezimalstellen genau (3.1415904800). Die Parameter der Funktion werden ignoriert, ich habe sie nur dort deklariert, um Platz zu sparen.

Javascript, 43 36

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

xwird zeta(2)=pi^2/6so sqrt(6*x)=pi. (47 Zeichen)

Nachdem Sie die distributive Eigenschaft verwendet und die geschweiften Klammern aus der forSchleife entfernt haben, erhalten Sie:

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

(43 Zeichen)

Es gibt zurück:

3.14159169865946

Bearbeiten:

Mit dem Wallis-Produkt habe ich einen noch kürzeren Weg gefunden:

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

(36 Zeichen)

Es gibt zurück:

3.141591082792245

Python, Riemann Zeta (58 41 Zeichen)

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

Oder ersparen Sie sich zwei Zeichen, aber verwenden Sie scipy

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

Bearbeiten : Dank amcgregor wurden 16 (!) Zeichen gespeichert

Javascript: 99 Zeichen

Nach der Formel von Simon Plouffe aus dem Jahr 1996 funktioniert dies mit einer Genauigkeit von 6 Nachkommastellen:

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)

Diese längere Variante (130 Zeichen) hat eine bessere Genauigkeit, 15 Nachkommastellen:

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)

Ich habe dies anhand meiner zwei Antworten auf diese Frage gemacht .

Rubin, 54 50 49

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

Online-Version zum Testen.

Eine andere Version ohne Array (50 Zeichen):

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

Online-Version zum Testen.

TI CAS, 35

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

Perl - 35 Bytes

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

Erzeugt volle Gleitkommapräzision. Eine Ableitung der verwendeten Formel ist an anderer Stelle zu sehen .

Beispielnutzung:

$ perl pi.pl
3.14159265358979

Willkürliche Präzisionsversion

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

Bei Bedarf erweitern. Die Länge der Iteration (z. B. -329..-1) sollte so angepasst werden, dass sie ungefähr log ₂ (10) ≈ 3.322 mal der Anzahl der Stellen entspricht.

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211707

Oder verwenden Sie bigintstattdessen:

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

Dies läuft deutlich schneller, enthält jedoch kein Dezimalzeichen.

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

Ausgänge:

3.14159265

Keine Mathematik beteiligt. Schlägt einfach die aktuelle Version von TeX nach und analysiert das resultierende HTML primitiv. Irgendwann wird es laut Wikipedia π .

Python 3 Monte Carlo (103 Zeichen)

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

Nimmt an, dass alle nicht initialisierten Variablen 0 sind. Dies ist in einigen Versionen von Game Maker Standard.

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

Ergebnis:

3.14159169865946

Java - 83 55

Kürzere Version dank Navin.

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

Alte Version:

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

R : 33 Zeichen

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

Hoffentlich folgt dies den Regeln.

Rubin, 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

Verwendet eine Formel, die ich nicht wirklich verstehe und die ich nur kopiert habe. : P

Ausgabe: 3.1415926535897913

Rubin, 12

p 1.570796*2

Ich bin technisch „Berechnung“ pi eine Annäherung von pi.

JavaScript - 19 Bytes

Math.pow(29809,1/9)

Calculates the 9th root of 29809.

3.1415914903890925