Dies kommt von http://programmers.blogoverflow.com/2012/08/20-controversial-programming-opinions/

"Da Pi unter Verwendung der Funktion 4 * (1 - 1/3 + 1/5 - 1/7 + ...) mit mehr Termen mit höherer Genauigkeit geschätzt werden kann, schreiben Sie eine Funktion, die Pi mit einer Genauigkeit von 5 Dezimalstellen berechnet. "

• Beachten Sie, dass die Schätzung durch Berechnung der oben angegebenen Reihenfolge erfolgen muss.

JavaScript, 46 58 56 45 Bytes

ES6-Update : Es hat sich herausgestellt, dass uns nach fünf Jahren mehr Funktionen zur Verfügung stehen.

let f=(i=0,a=0)=>i>1e6?a:f(i+4,a+8/-~i/(i+3))

Diese Version ( 45 Bytes; ja, das letist erforderlich) arbeitet theoretisch im strengen ES6-Modus . In der Praxis kann man es in V8 (zB mit Node) mit ausführen --use-strict --harmony-tailcalls; Die Proper Tailcalls-Funktion ist leider noch nicht weit verbreitet. Da es sich jedoch um ein bestimmtes Verhalten handelt, sollte es in Ordnung sein.

Wenn wir uns an die weit verbreitete Implementierung halten möchten und keinen Strict-Modus benötigen, können wir einfach die ES6-Syntax für Fettpfeile für Funktionen verwenden, aber ansonsten die gleiche Implementierung wie zuvor (vorgeschlagen von Brian H) für 48 Byte beibehalten .

a=>{for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}

Die Wahl des Namens für den einzelnen Parameter spielt eigentlich keine Rolle, aber wir können auch einen der von uns verwendeten Namen auswählen, um die Verschmutzung des globalen Bereichs zu minimieren.

function(){for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}

Diese Version ist ein Funktionsausdruck. Fügen Sie zwei Zeichen hinzu (zB " f"), wenn Sie möchten, dass es benannt wird. Diese Version überfordert die Globals aund i; Dies könnte verhindert werden, wenn wir a,ider Parameterliste " " hinzufügen .

Verwendet eine umformulierte Version des Algorithmus, um die Notwendigkeit einer Subtraktion zu umgehen.

 1/1 - 1/3  +   1/5 - 1/7   +    1/9 - 1/11  + ...
(3/3 - 1/3) + (7/35 - 5/35) + (11/99 - 9/99) + ...
    2/3     +      2/35     +       2/99     + ...
  2/(1*3)   +    2/(5*7)    +     2/(9*11)   + ...

Hier ist eine "normale" Version ohne diese Anpassung:

function(){for(a=0,i=1;i<1e6;i+=2)a+=[,4,,-4][i%4]/i;return a}

Das entspricht 64 bis 62 Zeichen.

Danke an @ardnew für den Vorschlag, den 4*vor dem loszuwerden return.

Geschichte

function(){for(a=i=0;i<1e6;a+=8/++i/~-(i+=3));return a}     // got rid of `i+=4`; restructured
// Old versions below.
function(){for(a=0,i=1;i<1e6;i+=4)a+=8/i/-~-~i;return a}    // got rid of `4*`
function(){for(a=0,i=1;i<1e6;i+=4)a+=2/i/-~-~i;return 4*a}

Python 59 Bytes

print reduce(lambda x,p:p/2*x/p+2*10**999,range(6637,1,-2))

Dies druckt 1000 Stellen aus; etwas mehr als die erforderlichen 5. Anstatt die vorgeschriebene Iteration zu verwenden, verwendet es diese:

pi = 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + 5/11*(2 + ...)))))

Der 6637(innerste Nenner) kann wie folgt formuliert werden:

Ziffern * 2 * log 2 (10)

Dies impliziert eine lineare Konvergenz. Jede tiefere Iteration erzeugt ein weiteres binäres Bit von pi .

Wenn Sie jedoch darauf bestehen, die tan- ^1- Identität zu verwenden, kann eine ähnliche Konvergenz erzielt werden, wenn es Ihnen nichts ausmacht, das Problem etwas anders anzugehen. Betrachten Sie die Teilsummen:

4,0, 2,66667, 3,46667, 2,89524, 3,33968, 2,97605, 3,28374, ...

es ist offensichtlich, dass jeder Term zu beiden Seiten des Konvergenzpunkts hin und her springt; die serie hat wechselnde konvergenz. Außerdem ist jeder Term näher am Konvergenzpunkt als der vorherige Term. es ist absolut monoton in Bezug auf seinen Konvergenzpunkt. Die Kombination dieser beiden Eigenschaften impliziert, dass das arithmetische Mittel zweier benachbarter Terme näher am Konvergenzpunkt liegt als die beiden Terme selbst. Betrachten Sie das folgende Bild, um eine bessere Vorstellung davon zu bekommen, was ich meine:

Die äußere Reihe ist das Original, und die innere Reihe ergibt sich aus dem Durchschnitt aller benachbarten Begriffe. Ein bemerkenswerter Unterschied. Aber was wirklich bemerkenswert ist, ist, dass diese neue Serie auch eine abwechselnde Konvergenz aufweist und in Bezug auf ihren Konvergenzpunkt absolut monoton ist. Dies bedeutet, dass dieser Prozess ad nauseum immer wieder angewendet werden kann.

In Ordnung. Aber wie?

Einige formale Definitionen. Sei P ₁ (n) der n- ^te Term der ersten Sequenz, P ₂ (n) der n- ^te Term der zweiten Sequenz und P _k (n) der n- ^te Term der k- ^ten Sequenz wie oben definiert .

P ₁ = [P ₁ (1), P ₁ (2), P ₁ (3), P ₁ (4), P ₁ (5), ...]

P ₂ = [(P ₁ (1) + P ₁ (2)) / 2, (P ₁ (2) + P ₁ (3)) / 2, (P ₁ (3) + P ₁ (4)) / 2, (P ₁ (4) + P ₁ (5)) / 2, ...]

P ₃ = [(P ₁ (1) + 2P ₁ (2) + P ₁ (3)) / 4, (P ₁ (2) + 2P ₁ (3) + P ₁ (4)) / 4, (P ₁ (3) + 2P ₁ (4) + P ₁ (5)) / 4, ...]

P ₄ = [(P ₁ (1) + 3P ₁ (2) + 3P ₁ (3) + P ₁ (4)) / 8, (P ₁ (2) + 3P ₁ (3) + 3P ₁ (4) + P ₁ (5)) / 8, ...]

Es überrascht nicht, dass diese Koeffizienten genau den Binomialkoeffizienten folgen und als einzelne Zeile des Pascalschen Dreiecks ausgedrückt werden können. Da eine beliebige Reihe des Pascalschen Dreiecks trivial zu berechnen ist, kann eine beliebige "tiefe" Reihe gefunden werden, indem einfach die ersten n Teilsummen genommen, mit dem entsprechenden Term in der k- ^ten Reihe des Pascalschen Dreiecks multipliziert und durch 2 dividiert werden ^k-1 .

Auf diese Weise kann mit nur 36 Iterationen eine vollständige 32-Bit-Gleitkomma-Genauigkeit (~ 14 Dezimalstellen) erreicht werden, bei der die Teilsummen noch nicht einmal auf der zweiten Dezimalstelle konvergieren. Dies ist offensichtlich nicht Golf:

# used for pascal's triangle
t = 36; v = 1.0/(1<<t-1); e = 1
# used for the partial sums of pi
p = 4; d = 3; s = -4.0

x = 0
while t:
  t -= 1
  p += s/d; d += 2; s *= -1
  x += p*v
  v = v*t/e; e += 1

print "%.14f"%x

Wenn Sie eine beliebige Genauigkeit wünschen, kann dies mit einer kleinen Modifikation erreicht werden. Hier nochmal 1000 Stellen rechnen:

# used for pascal's triangle
f = t = 3318; v = 1; e = 1
# used for the partial sums of pi
p = 4096*10**999; d = 3; s = -p

x = 0
while t:
  t -= 1
  p += s/d; d += 2; s *= -1
  x += p*v
  v = v*t/e; e += 1

print x>>f+9

Der Anfangswert von p beginnt 2 ¹⁰ größer zu sein, um den ganzzahligen Divisionseffekten von s / d entgegenzuwirken, wenn d größer wird, wodurch die letzten Stellen nicht konvergieren. Beachten Sie auch hier Folgendes 3318:

Ziffern * log 2 (10)

Die gleiche Anzahl von Iterationen wie beim ersten Algorithmus (halbiert, weil t bei jeder Iteration um 1 anstatt um 2 abnimmt ). Dies deutet erneut auf eine lineare Konvergenz hin: ein binäres Bit pi pro Iteration. In beiden Fällen sind 3318 Iterationen erforderlich, um 1000 Stellen pi zu berechnen. Dies ist eine geringfügig bessere Quote als 1 Million Iterationen zur Berechnung von 5.

Mathematica 42 39 34 33 31 26 32

Archimedes Ansatz 26 Zeichen

N@#*Sin[180 Degree/#]&

Dies erreicht das Kriterium, wenn die Eingabe 822 ist.

Frage: Weiß jemand, wie er die Sünde von 180 Grad berechnet hat? Ich nicht.

Leibniz 'Ansatz (Gregorys Serie) 32 Zeichen

Dies ist die gleiche Funktion, die der Problemsteller als Beispiel angegeben hat. Es erreicht das Kriterium in ungefähr einer halben Million Iterationen.

N@4Sum[(-1)^k/(2k+1),{k,0,10^6}]

Madhava-Leibniz-Ansatz 37 Zeichen

Diese Variante verwendet einige weitere Zeichen, konvergiert jedoch in nur 9 Iterationen zum Kriterium!

N@Sqrt@12 Sum[(-1/3)^k/(2k+1),{k,0,9}]

APL (14)

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

Java (67 Zeichen)

float r(){float p=0,s=4,i=1E6f;while(--i>0)p+=(s=-s)/i--;return p;}

Beachten Sie, dass dies einen Bedeutungsverlust vermeidet, indem Sie die Zahlen in der richtigen Reihenfolge addieren.

Haskell, 32

foldr(\k->(4/(2*k+1)-))0[0..8^7]

GHCi> foldr (\ k -> (4 / (2 · k + 1) -)) 0 [0..8 ^ 7]
3.141593130426724

Es zählt einen Funktionsnamen

34

π=foldr(\k->(4/(2*k+1)-))0[0..8^7]

R - 25 Zeichen

sum(c(4,-4)/seq(1,1e6,2))

C (GCC) (44 Zeichen)

float p(i){return i<1E6?4./++i-p(++i):0;}

Das sind 41 Zeichen, aber es muss auch kompiliert werden -O2, damit der Optimierer die Schwanzrekursion eliminiert. Dies hängt auch von undefiniertem Verhalten in Bezug auf die Reihenfolge ab, in der die++ ausgeführt werden. danke an ugoren für den hinweis. Ich habe mit gcc 4.4.3 unter 64-Bit Linux getestet.

Beachten Sie, dass der Optimierer, sofern er die Summe nicht auch neu anordnet, die kleinste Zahl addiert, um einen Bedeutungsverlust zu vermeiden.

Anrufen als p().

J, 26 Zeichen

+ / + / _ 2 ((4 _4) &%)>: +: i.100

Von 100 Sequenzelementen auf 1e6 Elemente verschoben. Auch jetzt ist es ein Code markiert und könnte ohne Fehler vom Browser auf die Konsole kopiert werden.

+/+/_2((4 _4)&%)\>:+:i.1e6

Javascript - 33 Zeichen

p=x=>4*(1-(x&2))/x+(x>1?p(x-2):0)

Wenn Sie peine positive ungerade Zahl übergeben x, wird der Pi mit (x-1)/2Begriffen berechnet .

Ruby - 82 Zeichen

def f(n,k=n)k>0?(f(n,k-1)+f(n+1,k-1))/2:n<0?0:f(n-1,0)+(-1)**n/(2*n+1.0)end;4*f(9)

Versuch es : https://repl.it/LQ8w

Der Ansatz verwendet die angegebene Reihe indirekt unter Verwendung eines numerischen Beschleunigungsansatzes. Die resultierende Ausgabe ist

pi ≈ 3.14159265161

gegen

pi = 3.14159265359

Es beginnt mit

f(n,0) = 1/1 - 1/3 + 1/5 - ... + ((-1)**n)/(2*n+1)

Und dann, da dies abwechselnd ist, können wir die Konvergenz mit beschleunigen

f(n,1) = (f(n,0) + f(n+1,0))/2

Und es gilt immer wieder:

f(n,k) = (f(n,k-1) + f(n+1,k-1))/2

Und der Einfachheit halber f(n) = f(n,n).

Rubin - 50 Zeichen

Wenn es Ihnen nichts ausmacht, für eine sehr lange Zeit zu laufen, dann können Sie einfach verwenden

def f(n)n<0?0:f(n-1)+(-1)**n/(2*n+1.0)end;4*f(1e7)

oder

a=0;for k in 0..1e7 do a+=(-1)**k/(2*k+1.0)end;4*a

C 69 Zeichen

float p,b;void main(a){b++<9e6?p+=a/b++,main(-a):printf("%f\n",4*p);}

• Ohne Befehlszeilenparameter ausführen (wird also aauf 1 initialisiert).
• Muss mit Optimierung kompiliert werden.
• void mainist seltsam und nicht standard, bringt aber die Dinge zum Laufen. Ohne sie wird die Rekursion als echter Aufruf implementiert, was zu einem Stapelüberlauf führt. Eine Alternative ist das Hinzufügen return.
• 4*Bei Ausführung mit drei Befehlszeilenparametern können zwei Zeichen gespeichert werden.

Clojure - 79 Zeichen

(fn [](* 4(apply +(map #(*(Math/pow -1 %1)(/ 1.0(+ 1 %1 %1)))(range 377000)))))

Dies erzeugt eine Funktion ohne Argumente, die einen Gleitkommawert berechnet, der pi korrekt auf fünf Dezimalstellen approximiert. Beachten Sie, dass die Funktion dadurch nicht an einen Namen wie pigebunden wird. Daher muss dieser Code entweder an Ort und Stelle mit evalas ausgewertet werden(<code>) gebunden wird. In diesem Fall oder an einen Namen gebunden werden

(defn p[](* 4(apply +(map #(*(Math/pow -1 %1)(/ 1.0(+ 1 %1 %1)))(range 377000)))))

für 82 Zeichen

Über

(defn nth-term-of-pi [n] (* (Math/pow -1 n) (/ 1.0 (+ 1 n n))))
(defn pi [c] (* 4 (apply + (map nth-term-of-pi (range c)))))
(def  pi-accuracy-constant (loop [c 1000] (if (< (pi c) 3.14159) (recur (inc c)) c)))
; (pi pi-accuracy-constant) is then the value of pi to the accuracy of five decimal places

PHP - 56 55 Zeichen

<?for($j=$i=-1;1e6>$j;){$p+=($i=-$i)/($j+=2);}echo$p*4;

Ich weiß nicht, dass ich es viel kleiner bekommen kann, ohne die Algorithmusregel zu brechen.

Perl - 43 39 Zeichen

Ich bin mir nicht sicher, welche Regeln für anonyme Subroutinen gelten, aber hier ist eine weitere Implementierung, die die @ FireFly-Serienkonstruktion verwendet

sub{$s+=8/((4*$_+2)**2-1)for 0..1e6;$s}

sub p{$s+=(-1)**$_*4/(2*$_+1)for 0..1e6;$s}

Java - 92 84 Zeichen

Ich kann Peter Taylors Ergebnis bei weitem nicht schlagen, aber hier ist meins:

double d(){float n=0,k=0,x;while(n<9E5){x=1/(1+2*n++);k+=(n%2==0)?-x:x;}return 4*k;}

Ungolfed-Version:

double d() {
    float n = 0, k = 0, x;
    while (n < 9E5) {
        x = 1 / (1 + 2 * n++);
        k += (n % 2 == 0) ? -x : x;
    }
    return 4 * k;
}

Bearbeiten: Mit dem ternären Operator wurden einige Zeichen gespeichert.

Python - 56 Zeichen

Meh, mein Python-Fu ist nicht stark genug. Ich konnte keine Abkürzungen mehr sehen, aber vielleicht könnte ein erfahrener Golfer hier etwas zum Trimmen finden?

t=s=0
k=i=1
while t<1e6:t,s,i,k=t+1,k*4./i+s,i+2,-k

Ruby - 54 Zeichen

def a()p=0;1000000.times{|i|p+=8/(4*i*(4*i+2))};p;end;

Mein erster Konsolenversuch

def a()i=1;p=0;while i<2**100 do p+=8/(i*(i+2));i+=4;end;p;end;

63 Zeichen.

Perl (76 Zeichen)

$y=1e4;for$x(0..1e4-1){$y--while sqrt($x**2+$y**2)>1e4;$a+=$y}print 4*$a/1e8

(Ergebnis: 3.14159052)

Nicht die kürzest mögliche Lösung, aber vielleicht interessant. Es ist eine geometrische. Ich berechne die Fläche unter einem Kreis.

Ich habe einen anderen lustigen Ansatz, aber es ist sehr langsam. Es zählt die Anzahl der diskreten Punkte in einem Quadrat, die unter einem Viertelkreis liegen, und berechnet daraus den Pi:

$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2

Die Anzahl der Iterationen wird als Befehlszeilenargument erwartet. Hier können Sie sehen, wie die Laufzeit mit der Genauigkeit zusammenhängt. ;)

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 100
3.1796
real    0m0.011s
user    0m0.005s
sys 0m0.003s

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 1000
3.14552
real    0m0.354s
user    0m0.340s
sys 0m0.004s

$ time perl -e '$i=shift;for$x(0..$i){for$y(0..$i){$h++if sqrt($x**2+$y**2)<$i}}print$h*4/$i**2' 10000
3.14199016
real    0m34.941s
user    0m33.757s
sys 0m0.097s

k (25 Zeichen)

4 * + /% (i # 1 - 1) '1 + 2 ! I: 1000000

Etwas kürzer:

+/(i#4 -4)%1+2*!i:1000000

Python (49)

print 4*sum((-1)**i/(2*i+1.)for i in range(9**6))

3,14159 453527

CJam-21

1e6{WI#4d*I2*)/}fI]:+

Ziemlich einfache Berechnung der angegebenen Serie.
CJam ist http://sf.net/p/cjam

Julia - 30 Zeichen

sum(4./[1:4:1e6] - 4./[3:4:1e6])

SQL, 253 Bytes

DECLARE @B int=3, @A varchar(max), @C varchar(max)='1'
WHILE @B<100000
BEGIN
SELECT @C=@C+(select case when (@B-1)%4=0 then'+'else'-'end)+
(SELECT cast(cast(1.0/@B as decimal(9,8)) as varchar(max)))
SELECT @B=@B+2
END
EXECUTE('SELECT 4*('+@C+')')

Ich würde eine SQL-Geige bereitstellen, aber dies geht zu viele Schleifen tief, die 1/3 1/5 1/7 usw. Brüche finden und gibt Fehler lol. Wenn Sie jedoch auf wechseln @B<100000, 1000wird es ausgeführt (offensichtlich nicht mit der gleichen Anzahl von Stellen Genauigkeit).

Befunge, 129 Bytes

p08p109p^v*86%+55:<$$$<
\$\>:#,_@>+\55+/:#^_"."
v>p"~"/:"~"%08p"~"/00p:2\4%-*"(}"
8^90%"~":+2:+g90*+g80*<
>*:**\/+>"~~"00g:"~"`!|

Probieren Sie es online!

Falls sich jemand wundert, ist es ein Elefant.