Pi Calculation Code Golf

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

Python3, 7

Runs in the interactive shell

355/113

Output: 3.1415929203539825, correct to 6 decimal places

And finally I have a solution that beats APL!

Oh, and in case you are wondering, this ratio is called the 密率 (literally "precise ratio"), and is proposed by the Chinese mathematician Zu Chongzhi (429-500 AD). A related wikipedia article can be found here. Zu also gave the ratio 22/7 as the "rough ratio", and he is known to be the first mathematician to propose that 3.1415926 <= pi <=3.1415927

Answer 2

PHP — 132 127 125 124 bytes

Basic Monte-Carlo simulation. Every 10M iterations, it prints the current status:

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

Thanks to cloudfeet and zamnuts for suggestions!

Sample output:

$ 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

Answer 3

J 6

{:*._1

Explanation: *. gives length and angle of a complex number. The angle of -1 is pi. {: takes the tail of the list [length, angle]

Just for the slowly-converging-series-fettishists, for 21 bytes, a Leibniz series:

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

Answer 4

Perl, 42 bytes

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

It's calculates π using the Leibniz formula:

999999 is used as largest n to get the precision of five decimal digits.

Result: 3.14159165358977

Answer 5

Piet, many codels

Not my answer, but this is the best solution I've seen to this problem:

My understanding is that it adds up the pixels in the circle and divides by the radius, and then once again. That is:

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

A better approach in my mind is a program that generates this image at an arbitrary size and then runs it through a Piet interpreter.

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

Answer 6

TECHNICALLY I'M CALCULATING, 9

0+3.14159

TECHNICALLY I'M STILL CALCULATING, 10

PI-acos(1)

I'M CALCULATING SO HARD, 8

acos(-1)

I ACCIDENTALLY PI, 12

"3.14"+"159"

And technically, this answer stinks.

Answer 7

APL - 6

2ׯ1○1

Outputs 3.141592654. It computes twice the arcsine of 1.

A 13-char solution would be:

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

This outputs 3.141591654 for me, which fits the requested precision.
It uses the simple + 4/1 - 4/3 + 4/5 - 4/7 ... series to calculate though.

Answer 8

J - 5 bytes

|^._1

This means |log(-1)|.

Answer 9

Google Calculator, 48

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

Takes a stick of butter, does advanced calculations, makes pi out of it. I figured since everyone else was doing simple math answers I would add a slightly more unique one.

Example

Answer 10

Octave, 31

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

Calculates the area of one quarter of a circle with radius 2, through numerical integration.

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

Answer 11

Mathematica 6

180N@° 
-->3.14159

Answer 12

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

Sample output in Python shell :

>>> print s
3.14159265359

Manages to avoid any imports. Can easily be swapped to use the arbitrary precision Decimal library; just replace 3. with Decimal('3'), set the precision before and after, then unary plus the result to convert precision.

And unlike a whole lot of the answers here, actually computes π instead of relying on built-in constants or math fakery, i.e. math.acos(-1), math.radians(180), etc.

Answer 13

x86 assembly language (5 characters)

fldpi

Whether this loads a constant from ROM or actually calculates the answer depends on the processor though (but on at least some, it actually does a calculation, not just loading the number from ROM). To put things in perspective, it's listed as taking 40 clock cycles on a 387, which is rather more than seems to make sense if it were just loading the value from ROM.

If you really want to ensure a calculation you could do something like:

fld1
fld1
fpatan
fimul f

f dd 4

[for 27 characters]

Answer 14

bc -l, 37 bytes

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

I don't see any other answers using the Wallis product, so since its named after my namesake (my History of Mathematics lecturer got a big kick out of that), I couldn't resist.

Turns out its a fairly nice algorithm from the golfing perspective, but its rate of convergence is abysmal - approaching 1 million iterations just to get 5 decimal places:

$ 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

Alternatively, we can use Newton-Raphson to solve sin(x)=0, with a starting approximation of 3. Because this converges in so few iterations, we simply hard-code 2 iterations, which gives 10 decimal places:

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

The iterative formula according to Newton-Raphson is:

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

sin' === cos and cos(pi) === -1, so we simply approximate the cos term to get:

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

Output:

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

Answer 15

Javascript, 43 36

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

x becomes zeta(2)=pi^2/6 so sqrt(6*x)=pi. (47 characters)

After using the distributive property and deleting the curly brackets from the for loop you get:

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

(43 characters)

It returns:

3.14159169865946

Edit:

I found an even shorter way using the Wallis product:

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

(36 characters)

It returns:

3.141591082792245

Answer 16

python - 47 45

pi is actually being calculated without trig functions or constants.

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

result:

>>> a
3.1415907719167966

Answer 17

C, 99

Directly computes area / r^2 of a circle.

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

This function will calculate pi by counting the number of pixels in a circle of radius r then dividing by r*r (actually it just calculates one quadrant). With r as 10000, it is accurate to 5 decimal places (3.1415904800). The parameters to the function are ignored, I just declared them there to save space.

Answer 18

Python, Riemann zeta (58 41 char)

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

Or spare two characters, but use scipy

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

Edit: Saved 16 (!) characters thanks to amcgregor

Answer 19

TI CAS, 35

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

Answer 20

Javascript: 99 characters

Using the formula given by Simon Plouffe in 1996, this works with 6 digits of precision after the decimal point:

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)

This longer variant (130 characters) has a better precision, 15 digits after the decimal point:

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)

I made this based in my two answers to this question.

Answer 21

Ruby, 54 50 49

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

Online Version for testing.

Another version without creating an array (50 chars):

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

Online Version for testing.

Answer 22

Perl - 35 bytes

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

Produces full floating point precision. A derivation of the formula used can be seen elsewhere.

Sample usage:

$ perl pi.pl
3.14159265358979

---

Arbitrary Precision Version

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

Extend as needed. The length of the iteration (e.g. -329..-1) should be adjusted to be approximately log₂(10) &approx; 3.322 times the number of digits.

3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211707

Or, using bigint instead:

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

This runs noticably faster, but doesn't include a decimal point.

3141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067

Answer 23

Game Maker Language, 34

Assumes all uninitialized variables as 0. This is default in some versions of Game Maker.

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

Result:

3.14159169865946

Answer 24

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

Outputs:

3.14159265

No math involved. Just looks up the current version of TeX and does some primitive parsing of the resulting html. Eventually it will become π according to Wikipedia.

Answer 25

Python 3 Monte Carlo (103 char)

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

Answer 26

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

Answer 27

R: 33 characters

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

Hopefully this follows the rules.

Answer 28

Ruby, 12

p 1.570796*2

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

Answer 29

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

Answer 30

JavaScript - 19 bytes

Math.pow(29809,1/9)

Calculates the 9th root of 29809.

3.1415914903890925

Answer 31

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 32

R

A few years back I was taking a math course and the instructor asked the class how we might compute pi from scratch. A guy at the back of the class suggested drawing a circle of diameter 1 and then laying a piece of string around it.

I couldn't figure out how to do that in R. I decided the second most primitive approach would be to approximate the circle with a regular polygons. A 4096-gon gets us 5 digits. The polygons are approximated with a simple binary search using only the midpoint and distance formulae (i.e. no trigonometric functions are used).

a <- c(0,1); b <- c(0,0); c <-c(1,0)
eps <- 0.000000001
mid  <- function(a,b) { c(mean(c(a[1],b[1])), mean(c(a[2],b[2])))}
dist <- function(a,b) { sqrt((a[1]-b[1])^2 + (a[2]-b[2])^2)}
for (i in 1:10)
{
    ab1 <- mid(a,b)
    ab2 <- mid(b, ab1)
    bc1 <- mid(b,c)
    bc2 <- mid(b, bc1)
    repeat
    {
        newab <- mid(ab1,ab2)
        newbc <- mid(bc1, bc2)
        corner <- dist(newab,newbc)
        side   <- dist(a,b) - 2*dist(newab,b)
        dif <- side - corner
        if (abs(dif) < eps)
        {
            a <- c(0,newab[2]+dist(newab,newbc))
            b <- newab
            c <- newbc
            break
        }
        if (dif > 0){ab2 <- newab;bc2 <- newbc}
        if (dif < 0){ab1 <- newab;bc1 <- newbc}
    }
}
print((2^(i+2))*dist(newab,newbc))

Answer 33

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 34

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 35

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 36

AppleScript, 8 characters

Solution :

3+.14159

Result :

3.14159

Answer 37

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 38

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 39

AppleScript, 4 characters !

Solution :

pi+0

Displayed result :

3.14159265359

Answer 40

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 41

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 42

Groovy: 25

print Math.log(10691/462)

Output is 3.141592653932079

de Jerphanion approximation

Answer 43

APL : 2 chars

    ○1
3.141592653589793

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

Answer 44

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 45

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 46

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 47

Python 3, 91 (with display), 82 (just calculation)

This knows that Pi is 3, then it uses the Nilakantha method to calculate Pi accurately to 6 decimal places.

p,n,s=3,2,1
while s<99:
 n,s,z=n+2,s+1,4/(n*(n+1)*(n+2))
 if s%2<1:p+=z
 else:p-=z
print(p)

It starts with the humorous 3,2,1, but also with the rather distasteful p,n,s...

Output

3.141592 395970107
The space is to separate the correct output from the incorrect.

Answer 48

Smalltalk, 9

1arcSin*2

will do

Answer 49

Python : 8 bytes

acos(-1)

do i have to include imports??

Answer 50

q [7 chars]

acos -1

Example

acos -1
3.141593

355%113       // [7 Chars]
3.141593

2*asin 1      // [8 Chars]
3.141593

Answer 51

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 52

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 53

Python, 27

import math
math.atan(1)*4

Answer 54

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 55

C

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

Answer 56

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 57

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 58

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 59

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 60

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 61

C++ 26

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

Answer 62

Python 3.x - 123

Sadly this has very little precision... giving only 1-2 decimal places correct.

Anyway this is a fun method of calculating pi.

import random
R = lambda: random.uniform(-1,1)
print(sum(1 for _ in range(10**6) if abs(R() + R()*1j) < 1)*4/10**6)

Answer 63

Ruby 8

-0.0.arg 

Output takes 2 more chars:

p -0.0.arg  # => 3.141592653589793

Answer 64

Java, 55

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

Hooray for static blocks ^_^

Answer 65

bc, 8 characters

Solution :

3+.14159

Usage :

$ bc <<< "3+.14159"
3.14159
$ 

Answer 66

Python, 27 chars

print "%.5f"%(355.0/113.0)

Answer 67

Windows Calculator, 1 click

Inspired by This Answer

Answer 68

Matlab or Octave

0+pi

So short stackexchange won't let me post it without this. The output:

octave:5> 0+pi
ans =  3.14159265358979