สิ่งนี้มาจากhttp://programmers.blogoverflow.com/2012/08/20-controversial-programming-opinions/

"เนื่องจาก Pi สามารถประมาณได้โดยใช้ฟังก์ชั่น 4 * (1 - 1/3 + 1/5 - 1/7 + …) พร้อมเงื่อนไขเพิ่มเติมที่ให้ความแม่นยำมากขึ้นเขียนฟังก์ชันที่คำนวณ Pi ถึงความแม่นยำทศนิยม 5 ตำแหน่ง "

• หมายเหตุการประเมินจะต้องทำโดยการคำนวณลำดับที่ได้รับข้างต้น

JavaScript, 46 58 56 45 ไบต์

อัปเดต ES6 : ปรากฎว่ามีคุณสมบัติอื่น ๆ อีกมากมายสำหรับเราที่ผ่านมาห้าปี

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

รุ่นนี้ ( 45ไบต์; ใช่letเป็นสิ่งจำเป็น) ทำงานในโหมดเข้มงวด ES6 ในทฤษฎี ในทางปฏิบัติคุณสามารถรันใน V8 (เช่นกับโหนด) ด้วย--use-strict --harmony-tailcalls; คุณลักษณะ Tailcalls ที่เหมาะสมยังไม่ได้ใช้อย่างกว้างขวาง อย่างไรก็ตามมันเป็นพฤติกรรมที่ระบุดังนั้นควรปรับ

ถ้าเราต้องการที่จะยึดติดกับสิ่งที่นำมาใช้กันอย่างแพร่หลายและไม่จำเป็นต้องเข้มงวดโหมดเราก็สามารถใช้ ES6 ไวยากรณ์ไขมันลูกศรสำหรับฟังก์ชั่น แต่อย่างอื่นยังคงมีการดำเนินการเช่นเดียวกับก่อน (แนะนำโดยไบรอัน H) สำหรับค่าใช้จ่ายของ48ไบต์

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

ทางเลือกของชื่อสำหรับพารามิเตอร์เดียวไม่ได้จริงๆว่า แต่เราอาจรวมทั้งเลือกหนึ่งในรายชื่อที่เราใช้เพื่อลดมลพิษทั่วโลกขอบเขต

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

รุ่นนี้เป็นฟังก์ชั่นการแสดงออก; เพิ่มอักขระสองตัว (เช่น " f") หากคุณต้องการตั้งชื่อ รุ่นนี้ปิดบัง globals aและi; สิ่งนี้สามารถป้องกันได้หากเราเพิ่ม "a,i " ลงในรายการพารามิเตอร์

ทำให้การใช้อัลกอริทึมรุ่น reformulated เพื่อหลีกเลี่ยงความต้องการในการลบ

 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)   + ...

นี่คือรุ่น "ธรรมดา" ที่ไม่มีการปรับค่านี้:

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

ซึ่งนาฬิกาในที่64 62ตัวอักษร

ขอบคุณ @ardnew สำหรับข้อเสนอแนะที่จะกำจัด4*ก่อนreturnก่อน

ประวัติศาสตร์

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 ไบต์

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

พิมพ์ออก 1,000 หลัก มากกว่าเล็กน้อยที่ต้องการเล็กน้อย 5. แทนที่จะใช้การวนซ้ำตามที่กำหนดมันใช้สิ่งนี้:

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

6637(ตัวหารสุด) สามารถสูตร:

ตัวเลข * 2 * บันทึก2 (10)

สิ่งนี้แสดงถึงการลู่เชิงเส้น แต่ละซ้ำลึกจะผลิตหนึ่งบิตไบนารีมากขึ้นของปี่

อย่างไรก็ตามหากคุณยืนยันในการใช้เอกลักษณ์ tan ^-1การลู่เข้าที่คล้ายกันสามารถทำได้ถ้าคุณไม่สนใจปัญหาจะแตกต่างกันเล็กน้อย ดูที่ผลรวมบางส่วน:

4.0, 2.66667, 3.46667, 2.89524, 3.33968, 2.97605, 3.28374, ...

เห็นได้ชัดว่าแต่ละเทอมกระโดดข้ามไปมาทั้งสองข้างของจุดบรรจบกัน ชุดนี้มีการบรรจบกัน นอกจากนี้แต่ละคำศัพท์จะอยู่ใกล้กับจุดบรรจบมากกว่าคำก่อนหน้าคือ มันเป็นเสียงเดียวอย่างแน่นอนด้วยความเคารพต่อจุดบรรจบของมัน การรวมกันของคุณสมบัติทั้งสองนี้แสดงว่าค่าเฉลี่ยเลขคณิตของคำศัพท์สองคำที่อยู่ใกล้กันนั้นอยู่ใกล้กับจุดบรรจบกันมากกว่าคำศัพท์ใดคำหนึ่ง เพื่อให้คุณมีความคิดที่ดีขึ้นเกี่ยวกับสิ่งที่ฉันหมายถึงพิจารณาภาพต่อไปนี้:

ซีรี่ส์ด้านนอกเป็นต้นฉบับและซีรีย์ด้านในพบได้โดยการหาค่าเฉลี่ยของแต่ละคำที่อยู่ใกล้เคียง ความแตกต่างที่น่าทึ่ง แต่สิ่งที่โดดเด่นอย่างแท้จริงคือซีรีย์ใหม่นี้ยังมีคอนเวอร์เจนซ์แบบสลับและเป็นแบบโมโนโทนิกที่เกี่ยวกับจุดบรรจบของมัน ซึ่งหมายความว่ากระบวนการนี้สามารถนำมาใช้ซ้ำแล้วซ้ำอีกโฆษณาคลื่นไส้

ตกลง. แต่อย่างไร

คำจำกัดความบางอย่างเป็นทางการ Let P ₁ (n)เป็นn ^THระยะของลำดับแรกP ₂ (n)เป็นn ^THระยะของลำดับที่สองและในทำนองเดียวกันP _k (n) n ^THระยะเวลาของk ^THลำดับตามที่ระบุไว้ข้างต้น .

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, ... ]

ไม่น่าแปลกใจที่ค่าสัมประสิทธิ์เหล่านี้เป็นไปตามสัมประสิทธิ์ทวินามและสามารถแสดงเป็นแถวเดียวของสามเหลี่ยมปาสคาล เนื่องจากแถวใด ๆ ของสามเหลี่ยมปาสคาลนั้นมีความสำคัญในการคำนวณจึงสามารถหาอนุกรม 'ลึก' แบบสุ่มได้โดยการหาผลรวมnส่วนแรกคูณด้วยแต่ละคำที่สอดคล้องกันในแถว^{ลำดับที่} kของสามเหลี่ยมปาสกาลและหารด้วย2 K-1

ด้วยวิธีนี้ความแม่นยำของจุดลอยตัวแบบ 32 บิตเต็มรูปแบบ (ทศนิยม 14 ตำแหน่ง) สามารถทำได้เพียง 36 รอบโดยที่ผลรวมบางส่วนยังไม่ได้รวมอยู่ในตำแหน่งทศนิยมที่สอง เห็นได้ชัดว่านี่ไม่ใช่การเล่นกอล์ฟ:

# 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

หากคุณต้องการความแม่นยำโดยพลการสิ่งนี้สามารถทำได้ด้วยการดัดแปลงเล็กน้อย ที่นี่อีกครั้งคำนวณ 1,000 หลัก:

# 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

ค่าเริ่มต้นของpเริ่มใหญ่ขึ้น2 ¹⁰เพื่อต่อสู้กับผลกระทบของการหารจำนวนเต็มของs / dเมื่อdกลายเป็นใหญ่ขึ้นทำให้ตัวเลขสองสามหลักสุดท้ายไม่มาบรรจบกัน แจ้งให้ทราบที่นี่อีกครั้งว่า3318 :

ตัวเลข * บันทึก2 (10)

จำนวนการทำซ้ำเดียวกันกับอัลกอริทึมแรก (ลดลงครึ่งหนึ่งเนื่องจากtลดลง1แทนที่จะเป็น2ซ้ำในแต่ละครั้ง) สิ่งนี้บ่งบอกถึงการลู่เข้าเชิงเส้น: ไบนารี่บิตหนึ่งของpiต่อการวนซ้ำ ในทั้งสองกรณีต้องใช้การคำนวณซ้ำ 3318 ครั้งเพื่อคำนวณ 1,000 หลักของpiซึ่งเป็นโควต้าที่ดีกว่า 1 ล้านซ้ำในการคำนวณ 5

Mathematica 42 39 34 33 31 26 32

วิธีการของอาร์คิมีดีส 26 ตัว

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

สิ่งนี้ถึงเกณฑ์เมื่ออินพุตคือ 822

คำถาม: ไม่มีใครรู้ว่าเขาคำนวณบาป 180 องศาได้อย่างไร ฉันไม่.

แนวทางของ Leibniz (ชุดของ Gregory) 32 ตัวอักษร

นี่เป็นฟังก์ชั่นเดียวกับที่ปัญหาที่ตอบยากให้เป็นตัวอย่าง ถึงเกณฑ์ในรอบครึ่งล้านซ้ำแล้วซ้ำอีก

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

Madhava-Leibniz เข้าใกล้ 37 ตัวอักษร

ชุดรูปแบบนี้ใช้อักขระเพิ่มอีกไม่กี่ตัว แต่มาบรรจบกันเป็นเกณฑ์ในการทำซ้ำ 9 ครั้งเท่านั้น!

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

APL (14)

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

Java (67 ตัวอักษร)

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

โปรดทราบว่านี่เป็นการหลีกเลี่ยงการสูญเสียความสำคัญโดยการเพิ่มตัวเลขในลำดับที่ถูกต้อง

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

นับชื่อฟังก์ชั่นมัน

34

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

R - 25 ตัวอักษร

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

C (GCC) (44 ตัวอักษร)

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

นั่นคือ 41 ตัวอักษร แต่ก็ต้องมีการคอมไพล์ด้วย-O2เพื่อให้เครื่องมือเพิ่มประสิทธิภาพเพื่อกำจัดการเรียกซ้ำหาง สิ่งนี้ยังขึ้นอยู่กับพฤติกรรมที่ไม่ได้กำหนดด้วยความเคารพต่อลำดับที่++ถูกดำเนินการ ขอบคุณ ugoren ที่ชี้เรื่องนี้ออกมา ฉันทดสอบกับ gcc 4.4.3 ภายใต้ Linux 64 บิต

โปรดทราบว่าหากเครื่องมือเพิ่มประสิทธิภาพจัดเรียงผลรวมนั้นจะเพิ่มจากจำนวนที่เล็กที่สุดเพื่อหลีกเลี่ยงการสูญเสียความสำคัญ

โทรp()มา

J, 26 ตัวอักษร

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

ย้ายจากลำดับ 100 รายการไปเป็น 1e6 รายการ ตอนนี้มันเป็นรหัสที่ติดแท็กและสามารถคัดลอกจากเบราว์เซอร์ไปยังคอนโซลได้โดยไม่มีข้อผิดพลาด

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

Javascript - 33 ตัวอักษร

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

การโทรpผ่านจำนวนคี่บวกxและจะคำนวณ Pi ด้วย(x-1)/2คำศัพท์

Ruby - 82 ตัวอักษร

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)

ลองใช้: https://repl.it/LQ8w

วิธีการใช้ชุดที่กำหนดทางอ้อมโดยใช้วิธีการเร่งความเร็วเชิงตัวเลข ผลลัพธ์ที่ได้คือ

pi ≈ 3.14159265161

เมื่อเทียบกับ

pi = 3.14159265359

มันเริ่มต้นด้วย

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

แล้วเนื่องจากสิ่งนี้สลับกันเราจึงสามารถเร่งการบรรจบกันโดยใช้

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

และมันใช้ซ้ำ:

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

และเพื่อความเรียบง่าย, f(n) = f(n,n).

Ruby - 50 ตัวอักษร

หากคุณไม่คิดที่จะทำงานนานมากคุณก็สามารถใช้งานได้

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

หรือ

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

C, 69 ตัวอักษร

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

• เรียกใช้โดยไม่มีพารามิเตอร์บรรทัดคำสั่ง (เช่นนั้น aถูกเตรียมข้อมูลเบื้องต้นเป็น 1)
• จะต้องรวบรวมด้วยการปรับให้เหมาะสม
• void mainแปลกและไม่ได้มาตรฐาน แต่ทำให้ทุกอย่างทำงาน หากไม่มีการเรียกซ้ำการเรียกใช้จะเป็นการเรียกใช้จริงซึ่งนำไปสู่การโอเวอร์โฟลว์แบบสแต็ก อีกทางเลือกหนึ่งคือการเพิ่มreturnอีกทางเลือกหนึ่งคือการเพิ่ม
• 4*สามารถบันทึกอักขระสองตัวได้หากรันด้วยพารามิเตอร์บรรทัดคำสั่งสามตัว

Clojure - 79 ตัวอักษร

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

สิ่งนี้จะสร้างฟังก์ชั่นที่ไม่มีข้อโต้แย้งซึ่งจะคำนวณการลอยที่ใกล้เคียงกับ pi อย่างถูกต้องกับทศนิยมห้าตำแหน่ง โปรดทราบว่านี้ไม่ได้ผูกฟังก์ชั่นเป็นชื่อเช่นpiดังนั้นรหัสนี้จะต้องได้รับการประเมินในสถานที่ที่evalเป็น(<code>)หรือผูกไว้กับชื่อซึ่งในกรณีการแก้ปัญหาเป็น

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

82 ตัวอักษร

เกี่ยวกับ

(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 ตัวอักษร

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

ฉันไม่รู้ว่าฉันจะทำให้เล็กลงได้โดยไม่ทำลายกฎของอัลกอริทึม

Perl - 43 39 ตัวอักษร

ไม่แน่ใจว่ากฎเกี่ยวกับรูทีนย่อยที่ไม่ระบุชื่อ แต่นี่คือการใช้งานอื่นโดยใช้การสร้างซีรีส์ของ @ FireFly

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 ตัวอักษร

ฉันไม่สามารถเอาชนะผลลัพธ์ของปีเตอร์เทย์เลอร์ได้ไกล แต่นี่คือของฉัน:

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

เวอร์ชันที่ไม่ถูกปรับแต่ง:

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

แก้ไข: บันทึกสองสามตัวอักษรโดยใช้โอเปอร์เรเตอร์

Python - 56 ตัวอักษร

ฉัน, งูหลามฟูของฉันไม่แข็งแรงพอ ฉันไม่เห็นทางลัดอีกต่อไป แต่อาจมีนักกอล์ฟที่มีประสบการณ์มากกว่าสามารถหาสิ่งที่จะตัดแต่งได้ที่นี่

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

Ruby - 54 ตัวอักษร

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

ฉันลองคอนโซลครั้งแรก

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

63 ตัวอักษร

Perl (ตัวอักษร 76 ตัว)

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

(ผลลัพธ์: 3.14159052)

ไม่ใช่ทางออกที่สั้นที่สุด แต่อาจน่าสนใจ มันเป็นเรขาคณิต ฉันคำนวณพื้นที่ใต้วงกลม

ฉันเข้าใกล้อีกวิธีตลก แต่มันช้ามาก มันนับจำนวนจุดที่ไม่ต่อเนื่องในสี่เหลี่ยมจัตุรัสที่ต่ำกว่าหนึ่งในสี่ของวงกลมและคำนวณ pi จากมัน:

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

คาดว่าจำนวนการวนซ้ำเป็นอาร์กิวเมนต์บรรทัดคำสั่ง ที่นี่คุณสามารถดูว่าเวลาทำงานเกี่ยวข้องกับความถูกต้องอย่างไร ;)

$ 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 ตัวอักษร)

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

สั้นลงเล็กน้อย:

+/(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]:+

การคำนวณแบบตรงไปตรงมาของอนุกรมที่ให้มา
CJam คือhttp://sf.net/p/cjam

Julia - 30 ตัวอักษร

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

SQL, 253 ไบต์

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+')')

ฉันจะให้ซอฟแวร์ SQL, แต่มันวนมากเกินไปที่จะหาเศษส่วน 1/3/1/7 1/7 และลึกเกินไปและให้ข้อผิดพลาด lol อย่างไรก็ตามหากคุณเปลี่ยน@B<100000เป็น1000มันจะทำงาน (เห็นได้ชัดว่าไม่ใช่จำนวนหลักของความแม่นยำเท่ากัน)

Befunge ขนาด 129 ไบต์

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

ลองออนไลน์!

ในกรณีที่มีคนสงสัยว่ามันเป็นช้าง