Điều này xuất phát từ http://programmers.blogoverflow.com/2012/08/20-contputial-programming-opinions/

"Cho rằng Pi có thể được ước tính bằng cách sử dụng hàm 4 * (1 - 1/3 + 1/5 - 1/7 +,) với nhiều thuật ngữ cho độ chính xác cao hơn, hãy viết hàm tính toán Pi với độ chính xác 5 chữ số thập phân. "

• Lưu ý, việc ước tính phải được thực hiện bằng cách tính toán trình tự được đưa ra ở trên.

JavaScript, 46 58 56 45 byte

Cập nhật ES6 : Hóa ra có nhiều tính năng khả dụng hơn cho chúng tôi khi năm năm đã trôi qua.

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

Phiên bản này ( 45 byte; có, letbắt buộc) hoạt động ở chế độ nghiêm ngặt ES6 về lý thuyết . Trong thực tế, bạn có thể chạy nó trong V8 (ví dụ với nút) với --use-strict --harmony-tailcalls; Tính năng Tailcalls thích hợp chưa được triển khai rộng rãi, than ôi. Tuy nhiên, đó là hành vi được chỉ định, vì vậy nó sẽ ổn.

Nếu chúng ta muốn tuân thủ những gì được triển khai rộng rãi và không yêu cầu chế độ nghiêm ngặt, chúng ta chỉ cần sử dụng cú pháp mũi tên béo ES6 cho các hàm nhưng mặt khác vẫn giữ nguyên cách thực hiện như trước đây (được đề xuất bởi Brian H) với chi phí 48 byte.

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

Việc lựa chọn tên cho tham số duy nhất không thực sự quan trọng, nhưng chúng tôi cũng có thể chọn một trong những tên chúng tôi sử dụng để giảm thiểu ô nhiễm phạm vi toàn cầu.

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

Phiên bản này là một biểu thức chức năng; thêm hai ký tự (ví dụ " f") nếu bạn muốn nó được đặt tên. Phiên bản này làm tắc nghẽn toàn cầu avà i; điều này có thể được ngăn chặn nếu chúng ta thêm " a,i" vào danh sách tham số.

Làm cho việc sử dụng một phiên bản được cải cách của thuật toán để tránh sự cần thiết phải trừ.

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

Đây là phiên bản "đơn giản" mà không cần điều chỉnh này:

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

mà đồng hồ ở 64 62 ký tự.

Cảm ơn @ardnew đã gợi ý để thoát khỏi 4*trước return.

Lịch sử

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 byte

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

Điều này in ra 1000 chữ số; nhiều hơn một chút so với yêu cầu 5. Thay vì sử dụng phép lặp theo quy định, nó sử dụng điều này:

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

6637( Mẫu số trong cùng) có thể được định dạng là:

chữ số * 2 * log 2 (10)

Điều này ngụ ý một sự hội tụ tuyến tính. Mỗi lần lặp sâu hơn sẽ tạo ra thêm một bit nhị phân của pi .

Nếu , tuy nhiên, bạn nhấn mạnh vào việc sử dụng tan ^-1 bản sắc, một sự hội tụ tương tự có thể đạt được, nếu bạn không nhớ đi về vấn đề hơi khác nhau. Nhìn vào các khoản tiền một phần:

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

Rõ ràng là mỗi thuật ngữ nhảy qua lại ở hai bên của điểm hội tụ; chuỗi có sự hội tụ xen kẽ. Ngoài ra, mỗi thuật ngữ gần với điểm hội tụ hơn thuật ngữ trước đó; nó hoàn toàn đơn điệu đối với điểm hội tụ của nó. Sự kết hợp của hai tính chất này ngụ ý rằng trung bình số học của bất kỳ hai thuật ngữ lân cận nào gần với điểm hội tụ hơn chính các thuật ngữ đó. Để cho bạn biết rõ hơn về ý tôi, hãy xem xét hình ảnh sau:

Chuỗi bên ngoài là bản gốc, và chuỗi bên trong được tìm thấy bằng cách lấy trung bình của mỗi thuật ngữ lân cận. Một sự khác biệt đáng chú ý. Nhưng điều thực sự đáng chú ý là loạt phim mới này cũng có sự hội tụ xen kẽ, và hoàn toàn đơn điệu đối với điểm hội tụ của nó. Điều đó có nghĩa là quá trình này có thể được áp dụng nhiều lần, quảng cáo.

Đồng ý. Nhưng bằng cách nào?

Một số định nghĩa chính thức. Đặt P ₁ (n) là số hạng ^thứ n của dãy thứ nhất, P ₂ (n) là số hạng ^thứ n của dãy thứ hai và tương tự P _k (n) số hạng ^thứ n của ^{thứ thứ} k dãy như được định nghĩa ở trên .

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

Không có gì đáng ngạc nhiên, các hệ số này tuân theo chính xác các hệ số nhị thức và có thể được biểu thị dưới dạng một hàng của Tam giác Pascal. Kể từ khi một dòng độc đoán của Tam giác Pascal là tầm thường để tính toán, một cách tùy tiện 'sâu' loạt có thể được tìm thấy, chỉ đơn giản bằng cách lấy đầu tiên n khoản tiền một phần, nhân mỗi bằng thuật ngữ tương ứng trong k ^thứ dãy Tam giác Pascal, và chia cho 2 ^k-1 .

Theo cách này, có thể đạt được độ chính xác của dấu phẩy động 32 bit đầy đủ (~ 14 vị trí thập phân) chỉ với 36 lần lặp, tại thời điểm đó, tổng một phần thậm chí không hội tụ ở vị trí thập phân thứ hai. Điều này rõ ràng là không chơi gôn:

# 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

Nếu bạn muốn độ chính xác tùy ý, điều này có thể đạt được với một chút sửa đổi. Ở đây một lần nữa tính 1000 chữ số:

# 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

Giá trị ban đầu của p bắt đầu lớn hơn 2 ¹⁰ , để chống lại các hiệu ứng phân chia số nguyên của s / d khi d trở nên lớn hơn, làm cho một vài chữ số cuối cùng không hội tụ. Thông báo ở đây một lần nữa 3318cũng là:

chữ số * log 2 (10)

Số lần lặp tương tự như thuật toán đầu tiên (giảm một nửa vì t giảm 1 thay vì 2 lần lặp). Một lần nữa, điều này chỉ ra sự hội tụ tuyến tính: một bit nhị phân pi trên mỗi lần lặp. Trong cả hai trường hợp, 3318 lần lặp được yêu cầu để tính 1000 chữ số pi , vì hạn ngạch tốt hơn một chút so với 1 triệu lần lặp để tính 5.

Toán học 42 39 34 33 31 26 32

Cách tiếp cận 26 ký tự của Archimedes

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

Điều này đạt tiêu chí khi đầu vào là 822.

Câu hỏi: Có ai biết anh ta đã tính Sin thế nào 180 độ không? Tôi không.

Cách tiếp cận của Leibniz (sê-ri của Gregory) 32 ký tự

Đây là chức năng tương tự mà người đặt vấn đề đưa ra làm ví dụ. Nó đạt tiêu chí trong khoảng một nửa triệu lần lặp.

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

Phương pháp tiếp cận Madhava-Leibniz 37 ký tự

Biến thể này sử dụng thêm một vài ký tự nhưng hội tụ theo tiêu chí chỉ trong 9 lần lặp!

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

APL (14)

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

Java (67 ký tự)

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

Lưu ý rằng điều này tránh mất ý nghĩa bằng cách thêm các số theo đúng thứ tự.

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

Đếm tên hàm

34

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

R - 25 ký tự

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

C (GCC) (44 ký tự)

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

That's 41 chars, but it also has to be compiled with -O2 to get the optimiser to eliminate the tail recursion. This also relies on undefined behaviour with respect to the order in which the ++ are executed; thanks to ugoren for pointing this out. I've tested with gcc 4.4.3 under 64-bit Linux .

Note that unless the optimiser also reorders the sum, it will add from the smallest number, so it avoids loss of significance.

Call as p().

J, 26 chars

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

Moved from 100 items of sequence to 1e6 items. Also now it's a code tagged and could be copypasted from browser to the console without errors.

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

Javascript - 33 Characters

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

Call p passing a positive odd number x and it will calculate Pi with (x-1)/2 terms.

Ruby - 82 chars

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)

Try it : https://repl.it/LQ8w

The approach uses the given series indirectly using a numerical acceleration approach. The resulting output is

pi ≈ 3.14159265161

vs.

pi = 3.14159265359

It starts with

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

And then, since this is alternating, we can accelerate the convergence using

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

And it repeatedly applies this:

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

And for simplicity, f(n) = f(n,n).

Ruby - 50 chars

If you don't mind running for a really long while, then you could simply use

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

or

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

C, 69 chars

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

• Run with no command line parameters (so a is initialized to 1).
• Must be compiled with optimization.
• void main is strange and non-standard, but makes things work. Without it, the recursion is implemented as a real call, leading to a stack overflow. An alternative is adding return.
• Two characters 4* can be saved, if running with three command line parameters.

Clojure - 79 chars

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

This creates a function of no arguments which will calculate a float which approximates pi correctly to five decimal places. Note that this does not bind the function to a name such as pi, so this code must either be evaluated in place with eval as (<code>) or bound to a name in which case the solution is

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

for 82 chars

About

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

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

I don't know that I can get it much smaller without breaking the algorithm rule.

Perl - 43 39 chars

không chắc chắn các quy tắc về chương trình con ẩn danh, nhưng đây là một triển khai khác sử dụng chuỗi xây dựng của @ 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 ký tự

Tôi không thể đánh bại kết quả của Peter Taylor, nhưng đây là của tôi:

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

Phiên bản bị đánh cắp:

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

Chỉnh sửa: Đã lưu một vài ký tự bằng toán tử ternary.

Python - 56 ký tự

Meh, python-fu của tôi không đủ mạnh. Tôi không thể thấy bất kỳ phím tắt nào nữa nhưng có lẽ một tay golf giàu kinh nghiệm hơn có thể tìm thấy thứ gì đó để cắt ở đây?

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

Ruby - 54 ký tự

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

Lần thử đầu tiên của tôi trên console

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

63 ký tự.

Perl (76 ký tự)

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

(Kết quả: 3.14159052)

Không phải là giải pháp ngắn nhất có thể, nhưng có thể thú vị. Đó là một hình học. Tôi tính diện tích dưới một vòng tròn.

Tôi có một cách tiếp cận hài hước khác, nhưng nó rất chậm. Nó đếm số điểm rời rạc trong một hình vuông nằm dưới một phần tư hình tròn và tính pi từ nó:

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

Nó hy vọng số lần lặp là đối số dòng lệnh. Ở đây bạn có thể thấy thời gian chạy liên quan đến độ chính xác. ;)

$ 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 ký tự)

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

Hơi ngắn hơn một chút:

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

Con trăn (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]:+

Tính toán khá đơn giản của loạt đã cho.
CJam là http://sf.net/p/cjam

Julia - 30 ký tự

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

SQL, 253 byte

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

Tôi sẽ cung cấp một SQL Fiddle, nhưng điều này đi quá nhiều vòng lặp tìm kiếm phân số 1/3 1/5 1/7, v.v. và đưa ra lỗi lol. Tuy nhiên, nếu bạn thay đổi @B<100000thành 1000thì nó sẽ chạy (rõ ràng là không có cùng số chữ số chính xác).

Befunge, 129 byte

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

Hãy thử trực tuyến!

Trong trường hợp bất cứ ai thắc mắc, đó là một con voi.