पाई गणना कोड गोल्फ [बंद]

Question

चुनौती

आपको कम से कम लंबाई में पाई की गणना करनी चाहिए। किसी भी भाषा में शामिल होने का स्वागत है और आप पीआई की गणना करने के लिए किसी भी सूत्र का उपयोग कर सकते हैं। यह कम से कम 5 दशमलव स्थानों पर पाई की गणना करने में सक्षम होना चाहिए। सबसे छोटा, वर्णों में मापा जाएगा। प्रतियोगिता 48 घंटे तक चलती है। शुरू।

---

^{नोट : यह समान प्रश्न बताता है कि PI को श्रृंखला 4 * (1 - 1/3 + 1/5 - 1/7 +…) का उपयोग करके गणना की जानी चाहिए। इस प्रश्न में यह प्रतिबंध नहीं है, और वास्तव में यहां बहुत सारे उत्तर (जीतने की संभावना सहित) उस अन्य प्रश्न में अमान्य होंगे। तो, यह कोई डुप्लिकेट नहीं है।}

Comments

@hvd आपको क्यों लगता है कि इसे अयोग्य घोषित किया जाना चाहिए? यह चश्मा फिट बैठता है ...

— डॉ। Belisarius

@ एचवीडी एकोस (-1)। मैं जीता!

— लेवल रिवर सेंट

यह अजीब, असंगत लग रहा है। गणना its को अपने व्यास द्वारा एक चक्र को विभाजित करना होगा, या कुछ अन्य ऑपरेशन π देना होगा। यदि हम 355/113 को करना स्वीकार करते हैं - जिसका luck भाग्य के अलावा - π से कोई लेना-देना नहीं है - @ की तरह, तो तार्किक रूप से हमें 3.14159 करना चाहिए ।

— निकोलस बारबुल्स्को

मुझे नहीं लगता कि लोग इस सवाल को क्यों पसंद करते हैं। यह मेरे द्वारा देखे गए सबसे अ-परिभाषित और निर्बाध प्रश्नों में से एक है। इस और हैलो दुनिया के बीच एकमात्र अंतर यह है कि यह पाई के साथ कुछ करना है।

— क्रंचर

इस सवाल को दिलचस्प बनाने के लिए इसे एक स्कोरिंग फ़ंक्शन की आवश्यकता होती है जो कोड के प्रति बाइट के अंकों को पुरस्कृत करता है।

— बेन जैक्सन

Answer 1

पायथन 3, 7

इंटरेक्टिव शेल में चलता है

355/113

आउटपुट: 3.14159292035398256 दशमलव स्थानों के लिए सही

और अंत में मेरे पास एक समाधान है जो एपीएल को धड़कता है!

ओह, और यदि आप सोच रहे हैं, तो इस अनुपात को you literally (शाब्दिक रूप से "सटीक अनुपात") कहा जाता है, और चीनी गणितज्ञ ज़ू चोंगज़ी (429-500 ईस्वी) द्वारा प्रस्तावित किया जाता है। एक संबंधित विकिपीडिया लेख यहां पाया जा सकता है । ज़ू ने भी 22/7 को "खुरदरा अनुपात" के रूप में अनुपात दिया, और उन्हें प्रस्ताव करने वाले पहले गणितज्ञ के रूप में जाना जाता है कि 3.1415926 <= pi <= 3.1415927

Comments

mhmh - यह वास्तव में एक बहुभाषी उत्तर है। स्मालटाक में भी काम करता है!

— blabla999

ईश - निंदा! यह मुश्किल से एक गणना है!

— mniip

ठीक है, यह एक विभाजन है, और यह परिशुद्धता आवश्यकता को संतुष्ट करती है ... (और यहां तक ​​कि बाइबिल भी कम सटीक है; आप उस निन्दा को लेबल नहीं करेंगे - क्या आप? 3 * ;-)

— blabla999

अजीब क्षण जब मैंने इसे एक गंभीर उत्तर के रूप में लिखा था, लेकिन हर कोई इसे मजाक के रूप में व्याख्या करता है ...

— user12205

उच्चतम जवाब मतदान: 355/113। निम्नतम जवाब मतदान: 3+.14159। मैं वास्तव में बहुत अंतर नहीं देखता।

— प्रिमो

Answer 2

PHP - 132 127 125 124 बाइट्स

बेसिक मोंटे-कार्लो सिमुलेशन। प्रत्येक 10M पुनरावृत्तियों, यह वर्तमान स्थिति को प्रिंट करता है:

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

सुझावों के लिए क्लाउडफ़ाइट और ज़मानट्स के लिए धन्यवाद!

नमूना उत्पादन:

$ 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

Comments

एक जवाब के लिए जो वास्तव में गणना करता है!

— blabla999

PHP के बारे में न जानें, लेकिन JS में आप कुछ ऐसा कर सकते हैं: $j+=$x*$x+$y*$y<=1;जो आपको चार बाइट्स से बचाएगा।

— मेघावी

इसके अलावा $k+=1/4;और print $j/$kकरने के लिए कम किया जा सकता $k++;है और print 4*$j/$kएक और बाइट के लिए।

— मेघावी

@cloudfeet - परिवर्तन किए गए, पुष्टि किए गए कोड अभी भी समान हैं। धन्यवाद!

@MarkC - वैचारिक रूप से यह डार्ट्स को बेतरतीब ढंग से एक आयत 0,0 से 1,1 में फेंक रहा है। 0,0 से 1 की दूरी के बराबर या उससे कम वालों को अंदर, बाहर की ओर माना जाता है। इस दूरी 1 का आकार एक चौथाई वृत्त या 1/4 होता है। [चौथाई सर्कल के अंदर डार्ट्स की संख्या] / [डार्ट्स की कुल संख्या] लगभग π / ४ है क्योंकि नमूनों की संख्या बढ़ जाती है।

Answer 3

जे ६

{:*._1

स्पष्टीकरण: *.एक जटिल संख्या की लंबाई और कोण देता है। -1 का कोण pi है। {:सूची की पूंछ लेता है [लंबाई, कोण]

बस धीरे-धीरे परिवर्तित-श्रृंखला-फेटिशिस्ट के लिए, 21 बाइट्स के लिए, एक लाइबनिज श्रृंखला:

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

Comments

दूसरे शब्दों में, यह है atan(0) + pi। मुझे नहीं लगता कि त्रिकोणमितीय कार्यों और पीआई के उपयोग को "गणना" के रूप में गिना जाना चाहिए।

— जेसन सी

@JasonC Arg(जो कि एक जटिल संख्या का तर्क है) एक त्रिकोणमितीय फ़ंक्शन नहीं है, जो कि

— आर्कटेंट के

@ मुन्नीप हां, यह है। यह वास्तविक और काल्पनिक भागों पर एटैन (वेल, एटान 2) का सिर्फ एक पर्याय है। जैसा कि आप देख सकते हैं, यह परिभाषा के अनुसार, ठीक बराबर है atan(0) + pi।

— जेसन सी

Answer 4

पर्ल, 42 बाइट्स

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

यह गणना करता है Le लाइबनिज सूत्र का उपयोग करते हुए :

पांच दशमलव अंकों की सटीकता प्राप्त करने के लिए 999999 का उपयोग सबसे बड़े n के रूप में किया जाता है ।

परिणाम: 3.14159165358977

Comments

यह अच्छा है! इसने मुझे जावा 8. में एक लिखने के लिए प्रेरित किया

— डेविड कॉनरड

Answer 5

पीट, कई कोडल

मेरा जवाब नहीं है, लेकिन यह इस समस्या का सबसे अच्छा समाधान है:

मेरी समझ यह है कि यह सर्कल में पिक्सल को जोड़ता है और त्रिज्या द्वारा विभाजित करता है, और फिर एक बार फिर से। अर्थात्:

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

मेरे दिमाग में एक बेहतर दृष्टिकोण एक ऐसा कार्यक्रम है जो इस छवि को एक मनमाना आकार में उत्पन्न करता है और फिर इसे एक पीआईटी दुभाषिया के माध्यम से चलाता है।

स्रोत: http://www.dangermouse.net/esoteric/piet/samples.html

Comments

क्या आप बता सकते हैं कि यह वास्तव में क्या करता है? (मैं Piet के पीछे के सामान्य विचार को जानता हूं, लेकिन यह स्पष्टीकरण कि यह विशेष कार्यक्रम कैसे काम करता है, यह आपके उत्तर के लिए एक अच्छा अतिरिक्त होगा)।

— प्लेनैपस

मैं वास्तव में पीट को नहीं जानता, लेकिन मुझे लगता है कि यह शाब्दिक रूप से लाल वृत्त के क्षेत्र को मापता है और फिर दो बार त्रिज्या से विभाजित होता है,, = A / (r * r) के लिए हल करता है

— नहीं कि चार्ल्स

वैसे यह क्षेत्र काफी स्पष्ट है, क्योंकि जब सूचक लाल घेरे में प्रवेश करता है तो यह लाल क्षेत्र में कोडल्स की संख्या को गिनता है और बाहर निकलते समय इसे ढेर पर धकेल देता है (चूंकि निकास बिंदु गहरा लाल है, इसलिए कोई ह्यू परिवर्तन नहीं होता है लेकिन एक कदम गहरा होता है ), यह "त्रिज्या वर्ग द्वारा विभाजित" हिस्सा है जिसे मुझे समझने में परेशानी हुई।

— प्लेनैपस

@plannapus त्रिज्या गहरे लाल रेखा में "हार्ड-कोडित" है जो बाएं किनारे से नीचे बाएं किनारे तक फैला हुआ है (यह छवि में देखना मुश्किल है)। पीट का पालन करना कठिन है लेकिन रंग का ब्लॉक उनके क्षेत्र के बराबर मूल्य है (बाएं किनारे पर लाइन में आर पिक्सल है, सर्कल में क्षेत्र पिक्सल है), और बीच में सामान केवल स्टैक और अंकगणितीय संचालन का एक गुच्छा है। टॉप लेफ्ट में प्रोग्राम शुरू होते हैं। शीर्ष दाईं ओर का पाठ अनिवार्य रूप से एक टिप्पणी है।

— जेसन सी

@JasonC ah of course! The circle touches both upper and lower side so the dark red line descending from the upper side to the exact middle is necessary the radius! Smart!

— plannapus

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.

Comments

So header, much big title, very pain for my eyes, wow.

— Pierre Arlaud

pluzz wan for much lulz, thankz

— Jonathan Van Matre

Hey baby, wanna expand my Taylor series?

— Jason C

meta.codegolf.stackexchange.com/questions/1061/…

— SimonT

@SimonT You didn't answer my question about the Taylor series. But while you're thinking about it, see my comments on the question and most of the other answers here. :P

— Jason C

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.

Comments

Wow, that's one slow convergence!

My first thought was “why not ¯2○¯1?” (i.e acos -1). But that gives a complex approximation on repl.it (3.1415926425236J¯1.1066193467303274e¯8). Any idea why? Do all implementations do that?

— James Wood

+1 for your second solution. 2 * asin(1) is a bit of a cheat, though.

— Jason C

@JamesWood I don't know APL but if I had to guess I'd say it tried to do a sqrt(1-theta^2) (which pops up in a lot of trig identities) at some point and lost some precision somewhere, ending up with a slightly negative 1-theta^2.

— Jason C

What's strange is that there's still a tiny imaginary part for acos -0.75. There's no way it could calculate 1 - 0.75 ^ 2 to be negative.

— James Wood

Answer 8

J - 5 bytes

|^._1

This means |log(-1)|.

Comments

Clever use of Euler's Identity.

— primo

Cool, another algebraic identity answer. About as clever as ln(e^(42*pi))/42 or pi*113/113.

— Jason C

Also works in TI-BASIC

— Timtech

(Totally unrelated, I wish we could use LaTeX on codegolf.)

— Jason C

(Answer to totally unrelated question, I get by with google charts, for example here.) On topic, this is the sortest answer, and thus should have been accepted.

— primo

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

Comments

The stick of butter is cute and funny but this is essentially yet another pi*x/x+y-y algebraic identity.

— Jason C

There are so many better ways to make pi using a stick of butter

— Not that Charles

Have you tried making butter with a stick of pi?

— mbomb007

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

Comments

Nice! +1 when my votes recharge.

— Jason C

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]

Comments

Can you explain, please ?

— Nicolas Barbulesco

And, on some processors, what calculcation would fldpi do ?

— Nicolas Barbulesco

I don't think using a command that loads pi (or even computes it based on somebody else's asin implementation or any existing trig function implementations at all) really counts in the spirit of "calculating" anything (the "omg assembler" factor doesn't really change that). Perhaps port this to the shortest assembler implementation possible, and it can be called a "calculation".

— Jason C

@JasonC: Sounds like an entirely arbitrary notion to me, with no more real sense than my deciding that people had to implement addition, subtraction, multiplication and division on their own if they're doing to use them.

— Jerry Coffin

@JerryCoffin Instead of arguing technicalities, suffice it to say that neither asin(-1) nor fldpi are particularly interesting or creative. There's not much purpose in competing to see whose favorite language has the shortest name for predefined trig functions and pi constants.

— Jason C

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
$ 

Comments

+1 now that's more like it!

— Jason C

@JasonC What is your opinion of application of Newton-Raphson to solve sin(x)=0 (see edit)?

— Digital Trauma

Answer 15

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

Comments

Should be able to save a byte by dropping the zero after the decimal place for forced float interpretation. :) Bonus points for brevity, but I like mine for arbitrary accuracy and lower memory utilization. (Edited to scratch the parenthesis idea; I see what's going on there and my isolated test didn't catch the issue.)

— amcgregor

Uh… no. After your modification this no longer gives valid output. (265723 ≭ π) You still need the period, just not the trailing zero.

— amcgregor

@amcgregor use python 3?

— qwr

I do, though I primarily develop under 2.7 and make my code work in both. However on the stock Mac 10.9 python3 installation your code causes a segmentation fault.

— amcgregor

@amcgregor I just tested it, it works for me (python 3.3.4)

— qwr

Answer 16

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 17

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

Comments

Can potentially avoid the math import and sqrt call by pivoting to exponentiation instead: (6*sum(n**-2 for n in range(1,9**9)))**0.5

— amcgregor

Answer 19

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 20

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.

Comments

It's interesting to see the language differences that such compact solutions can give. For example, the Python translation of the above is 105 characters (after using some trivial code compression tricks): a=__import__;reduce(a('operator').__add__,a('itertools').imap(lambda e:(-1.0)**e/(2*e+1)*4,xrange(9**6))) -- note the use of xrange/imap; in Python 3 you can avoid this; basically I don't want all of your RAM to get consumed constructing a list with so many entries.

— amcgregor

You're absolutely right. It is often very convenient to use (especially Ruby's) Array and Enumerable functions, though it might really not be the best idea in terms of performance and speed... Well, thinking about that, it should be possible to do the calculation with the Range.each method instead of creating a map.

— David Herrmann

Yes, it's possible - just one character more...

— David Herrmann

Your first answer is not as precise as your second.

— Josh

Could you elaborate, please? Same algorithm, same output for me?

— David Herrmann

Answer 21

TI CAS, 35

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

Comments

I looked back at this and i completely forget how it works :P

— TheDoctor

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) ≈ 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

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.

Comments

I'm 5 years late, but this is a standard loophole that was created 4 days before this answer.

— Benjamin Urquhart

Answer 24

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 25

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

Comments

very nice. also, in C float k(){double x=0,i=0;for(;i++<999999;)x+=6/i/i;return sqrt(x);} is shorter than this one

— izabera

even shorter with 1e8 instead of 999999

— izabera

Could you use for(i=1;i<1e8;)x+=6/i/i++;sqrt(x) to save a byte (or alternatively for(i=1;i++<1e8;))?

— mbomb007

@mbomb007 Unfortunately not, GML requires all 3 parameters.

— Timtech

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

Comments

This doesn't do any calculation.

I don't understand the downvote, although - I'd answered with "Math.toRadians(180)". It is also questionable, who computes pi: the compiler or the program. But that was not part of the question.

— blabla999

@user2509848 It most certainly does: it multiplies 180 by pi/180.

— AJMansfield

You mean it multiplies pi by 1? It is essentially the same thing. I did not downvote it, but I don't think it really counts.

Can be shorter: codegolf.stackexchange.com/a/22057/14610

— Navin

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

Ruby, 12

p 1.570796*2

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

Comments

No, you are not technically calculating pi. You are technically calculating 3.141592, which happens to be close to pi, but will never converge to exactly acos(-1).

— wchargin

@Wchar Ok, edited

— Doorknob

I don't think hard-coding pi/2 then multiplying it by 2 really counts; the point is to calculate pi, not obfuscate a numeric literal.

— Jason C

Answer 30

JavaScript - 19 bytes

Math.pow(29809,1/9)

Calculates the 9th root of 29809.

3.1415914903890925