Pi Calculation Code Golf [closed]

Question

The Challenge

You must calculate pi in the shortest length you can. Any language is welcome to join and you can use any formula to calculate pi. It must be able to calculate pi to at least 5 decimal places. Shortest, would be measured in characters. Competition lasts for 48 hours. Begin.

---

^{Note: This similar question states that PI must be calculated using the series 4 * (1 – 1/3 + 1/5 – 1/7 + …). This question does not have this restriction, and in fact a lot of answers here (including the most likely to win) would be invalid in that other question. So, this is not a duplicate.}

Answer 1

Python, 37 chars

Using zeta(10) for fast convergence:

    sum(93555./i**10 for i in[1,2,3])**.1
    3.1415923154068

Using the same serie to get 15 correct digits:

    sum(93555./i**10 for i in range(1,40))**.1
    3.141592653589793

Answer 2

53 characters of Javascript:

x=3;d=1;while(d>1e-8){d=Math.sin(x);x+=d;};alert(x);

With an arbitrary numeric precision implementation of sin (e.g. taylor expansion), this will give an arbitrarily exact result with good convergence and a roughly estimated precision while keeping the code very simple.

Answer 3

TI CAS , 4

Assuming you're in radians mode,

180°

If you really insist, to put it into radians mode:

Radians:180°

(suggested by AJMansfield)

(similar to the Mathematica answer)

Answer 4

AppleScript, 8 characters

Solution :

3+.14159

Result :

3.14159

Answer 5

Python - 68 characters

Quite a long solution.

_=lambda x,y=1:x^y and y*2-1+y**2/_(x,y+1)or x*2.0+1
print 4/_(99)

Answer 6

bc -l, 6

4*a(1)

This requires the -l option to bc. Do I need to declare extra points for that?

Using -l calculates to 20 decimal places:

$ bc -l<<<"4*a(1)"
3.14159265358979323844
$ 

Answer 7

Groovy, 77

def x=0;for(k in 0..99){x+=Math.pow(-1/3,k)/(2*k+1)};println x*Math.sqrt(12)

This uses the Madhava-Leibniz series, which converges more quickly than the plain Leibniz series:

Output:

3.141592653616969

Answer 8

AppleScript, 4 characters !

Solution :

pi+0

Displayed result :

3.14159265359

Answer 9

TI BASIC, 24

Disp fnInt(√(4-X²),X,0,2

returns:

3.141593074
Done

This does not use any trig function, instead it uses numerical integration of the function of half a circle with radius 2. That circle has area 4pi, so half that circle has area 2pi, but i integrate from 0 to 2 wich is half of that, so a quarter of the circle, area pi.

Answer 10

Groovy: 25

print Math.log(10691/462)

Output is 3.141592653932079

de Jerphanion approximation

Answer 11

Windows Calculator - cheat: 1, less cheating: 5

p (not my final answer, but I just had to include this for lulz)

or

F₁ 1 i t * 4 ↲
F₄ 1 F₉ i o

(F₄ sets mode to radians, F₉ negates the buffer)

If it must be a pasteable/savable string, and mode is already set to radians and the buffer is 0.0: io*2=

Answer 12

APL : 2 chars

    ○1
3.141592653589793

Reference for monadic circle: http://www.microapl.co.uk/apl_help/ch_020_020_230.htm

Answer 13

Julia

Hiperarmonic series:

julia> s=0;sqrt(6*([s+=1/i^2 for i=1:8^6][end]))
3.1415890108270967

Zeta function:

julia> sqrt(zeta(2)*6)
3.141592653589793

Bailey-Borwein-Plouffe formula:

julia> s=0;[s+=(-1)^k/4^k*(2/(4k+1)+2/(4k+2)+1/(4k+3)) for k=0:7]
8-element Array{Any,1}:
 3.33333
 3.11429
 3.14636
 3.14068
 3.14178
 3.14155
 3.1416 
 3.14159

Ramanujan formula (fastest convergence):

julia> !n=factorial(n);s=0;([s+=!4n*(1103+26390n)/(!n*396^n)^4 for n=0][end]*(sqrt(8)/9801))^-1
3.1415927300133055

Answer 14

Javascript 44

I am new to golfing, so this is my best shot:

p=0;for(i=1;i<1e7;i+=4)p+=8/i/(i+2);alert(p)

Answer 15

JavaScript 50 (30 decimal places, including alert call...)

alert((m=Math).log(pow(640320,3)+744)/pow(163,.5))
....5....0....5....0....5....0....5....0....5....0

Based on the entry under Miscellaneous Approximations section in wikipedia: http://en.wikipedia.org/wiki/Approximations_of_%CF%80

Or for less accurate...

JavaScript 40 (10 decimal places, including alert call)

alert(Math.pow(1e100/11222.11122,1/193))
....5....0....5....0....5....0....5....0

Output:

3.1415926536438223
...........^ Accuracy finishes after this digit!)

Or for even less accurate...

JavaScript 28 (8 decimal places, including alert call!)

alert(Math.pow(2143/22,.25))
....5....0....5....0....5..8

Output:

3.1415926525826463
.........^ Accuracy finishes after this digit!)

Answer 16

Smalltalk, 9

1arcSin*2

will do

Answer 17

q [7 chars]

acos -1

Example

acos -1
3.141593

355%113       // [7 Chars]
3.141593

2*asin 1      // [8 Chars]
3.141593

Answer 18

Python : 8 bytes

acos(-1)

do i have to include imports??

Answer 19

Ruby, 35

Using Euler's formula. No reliance on trigonometric functions that might store π somewhere (though CMath might use Math::PI internally...).

require('cmath');CMath.log(-1).imag

Returns

3.141592653589793

Answer 20

Java: 89

class j{public static void main(String[]a){System.out.print(4-Math.pow(105./166,1./3));}}

unGolfed:

class j {
    public static void main(String a[]){
        //E. Pegg approximation
        System.out.print(4-Math.pow(105./166,1./3));
    }
}

Answer 21

Python, 27

import math
math.atan(1)*4

Answer 22

This was originally a comment to this answer, but since the full program is shorter than the other C solution (which is only a function), I might as well post it as an answer:

C, 64

double x,i;main(){for(;i++<1e8;)x+=6/i/i;printf("%f",sqrt(x));}

output:

3.141593

Answer 23

C

main(){printf("%f",22/7.0);}

Answer 24

bc -l, 9 chars

2*a(2^99)

Even with bc(1)'s default scale this is correct up to as many digits as I memorised. Raise the potence (and the scale) to get more precisions.

Answer 25

PHP, 281

Not going to win, but more of a challenge for myself.

Calculates PI to the nth precision (determined by the value of $d, currently 5). This is a PHP implementation of the Gauss–Legendre algorithm. I discovered after the fact this was almost exactly done by someone 7 years ago... *smh* ...posting anyway.

Golfed:

$d=5;$r=$d+4;$n=floor(log($r)/log(2));bcscale($r);$a=1;$b=bcdiv(1,bcsqrt(2));$t=.25;$p=1;while($n--){$x=bcdiv(bcadd($a,$b),2);$y=bcsqrt(bcmul($a,$b));$t=bcsub($t,bcmul($p,bcsub(bcpow($x,2),bcpow($y,2))));$p=bcmul(2,$p);$a=$x;$b=$y;}echo bcdiv(bcpow(bcadd($a,$b),2),bcmul(4,$t),$d);

$d = 5 outputs 3.14159

$d = 19 outputs 3.1415926535897932384

$d = 41 outputs 3.14159265358979323846264338327950288419716

etc...

---

Community Help: I would like to set the scale/precision more appropriately on each iteration (rather than fixed at 4: $r=$d+4), but I can't seem to find a way to reliably determine the error precision, i.e. the rate of convergence isn't constant.

Answer 26

Java 8, 155

class P{public static void main(String[] s){System.out.print(4*java.util.stream.IntStream.range(0,999999).mapToDouble(x->Math.pow(-1,x)/(2*x+1)).sum());}}

Uses the same approach as @HeikoOberdiek's Perl solution i.e., the Leibniz formula.

Here's the same program in a longer form, formatted for easier reading:

import static java.lang.Math.pow;
import static java.util.stream.IntStream.range;

public class Pie {
    public static void main(String[] args) {
        System.out.println(4 * range(0, 999_999).mapToDouble(x -> pow(-1, x) / (2*x + 1)).sum());
    }
}

Output:

3.1415936535907933

Answer 27

JavaScript, 94 characters

+function p(n){return~n?(4/(8*n+1)-1/(4*n+2)-1/(8*n+5)-1/(8*n+6))/Math.pow(16,n)+p(n-1):0}(9)

Answer 28

Windows Calculator, 1 click

Inspired by This Answer

Answer 29

R, Monte Carlo 68

Old square inscribed in circle method.

z=n=0;repeat{z=z+ifelse(sum(runif(2)^2)<1,1,0);n=n+1;write(4*z/n,1)}

Check if x^2 + y^2 <= r^2, if yes z += z, else n += n. Pi ~= 4z/n as iteration -> inf.

Answer 30

C++ 26

main(){cout<<6*asin(0.5);}