เขียนฟังก์ชั่นหรือโปรแกรมที่สมบูรณ์แบบที่จะใช้เวลาเป็นจำนวนบวกnและดำเนินการnตามขั้นตอนของอัลกอริทึมซ้ำสำหรับการคำนวณπที่มีการบรรจบกันเป็นกำลังสอง (คือมันประมาณสองเท่าจำนวนของตัวเลขที่ถูกต้องในทุกซ้ำ) แล้วผลตอบแทนหรือพิมพ์ออก 2 ⁿตัวเลขที่ถูกต้อง (รวมถึง จุดเริ่มต้น 3) อัลกอริธึมแบบหนึ่งคืออัลกอริธึมGauss – Legendreแต่คุณสามารถใช้อัลกอริทึมที่แตกต่างได้ถ้าคุณต้องการ

ตัวอย่าง:

อินพุต1→ 3.1
อินพุต2เอาต์พุต→ 3.141
อินพุตอินพุต5→เอาต์พุต3.1415926535897932384626433832795

ที่ต้องการ:

• การวนซ้ำของอัลกอริทึมจะต้องดำเนินการจำนวนคงที่ของการดำเนินงานขั้นพื้นฐานเช่นการบวกการลบการคูณการหารพลังงานและราก ถ้ามันเกี่ยวข้องกับการวนรอบอย่างน้อยหนึ่งภายใน เพื่อความชัดเจนฟังก์ชั่นตรีโกณมิติและพลังที่เกี่ยวข้องกับจำนวนเชิงซ้อนไม่ใช่การดำเนินการขั้นพื้นฐาน
• อัลกอริทึมที่คาดว่าจะมีขั้นตอนการเริ่มต้นซึ่งจะต้องมีจำนวนคงที่ของการดำเนินงาน
• หากขั้นตอนวิธีการตอบสนองความต้องการ 1 หรือ 2 มากขึ้นซ้ำที่จะได้รับ 2 ⁿตัวเลขที่ถูกต้องคุณสามารถดำเนินการได้ถึงการทำซ้ำแทนเพียงn+2n
• หากมันไม่ชัดเจนพอหลังจากตัวเลข2 ^{n ที่}ถูกต้องโปรแกรมของคุณจะต้องไม่พิมพ์อะไรอีก (เช่นตัวเลขที่ถูกต้องมากขึ้นตัวเลขที่ไม่ถูกต้องหรือผลงานที่สมบูรณ์ของ Shakespeare)
• โปรแกรมของคุณต้องรองรับค่าnตั้งแต่ 1 ถึงอย่างน้อย 20
• โปรแกรมของคุณไม่ควรใช้เวลาเกินกว่าหนึ่งชั่วโมงสำหรับn= 20 ในคอมพิวเตอร์ทันสมัย ​​(ไม่ใช่กฎที่ยาก แต่พยายามทำให้เหมาะสม)
• โปรแกรมต้องไม่ได้รับตัวเลขที่ถูกต้องมากกว่า 20 หลักหลังจากการเริ่มต้นและการวนซ้ำครั้งแรกของอัลกอริทึม
• โปรแกรมต้องสามารถรันได้ใน Linux โดยใช้ซอฟต์แวร์ที่มีให้ฟรี
• ซอร์สโค้ดต้องใช้อักขระ ASCII เท่านั้น

เกณฑ์การให้คะแนน:

รหัสกอล์ฟที่ตรงไปตรงมารหัสที่สั้นที่สุดชนะ

ผู้ชนะ:

ผู้ชนะคือ Digital Trauma ในที่สุดฉันก็จบโค้ดของเขาใน n = 20 (ล้อเล่น) รางวัลพิเศษตกเป็นของพรีโม่สำหรับโซลูชันไพ ธ อนที่รวดเร็วและอัลกอริธึมที่แตกต่าง :)

dc, 99 ไบต์

แข็งแรงเล่นกอล์ฟ:

2?dsi1+^k1dddsa2v/sb4/stsp[lalb*vlalb+2/dla-d*lp*ltr-stsasblp2*spli1-dsi0<m]dsmxK2/1-klalb+d*4lt*/p

ด้วยช่องว่างและความคิดเห็นสำหรับ "การอ่าน":

2?dsi               # Push 2. push input n, duplicate and store in i
1+^k                # Set calculation precision to 2^(n+1)
1dddsa              # Push four 1s. Store 1st in a
2v/sb               # Store 1/sqrt(2) in b
4/st                # Store 1/4 in t
sp                  # Store 1 in p
[                   # Start iteration loop macro
lalb*v              # Save sqrt(a*b) on stack
lalb+2/d            # Save a[i+1] = (a[i]+b[i])/2 on stack and duplicate
la-d*lp*ltr-        # Save t-p(a[i]-a[i+1])^2 on the stack
st                  # Store t result from stack
sa                  # Store a result from stack
sb                  # Store b result from stack
lp2*sp              # Store 2p in p
li1-dsi0<m]         # Decrement iteration counter i; recurse into macro if < 0
dsmx                # Duplicate, store and run macro
K2/1-k              # Set display precision to 2^n-1
lalb+d*4lt*/        # Save (a+b)^2/4t on stack
p                   # Print result

dcจะต้องมีการบอกจำนวนความแม่นยำที่ควรใช้ ความแม่นยำในการคำนวณจะต้องสูงกว่าความแม่นยำในการแสดงผลขั้นสุดท้ายดังนั้นความแม่นยำในการคำนวณจึงถูกกำหนดให้เป็น2^(n+1)ตัวเลข ฉันได้รับการตรวจสอบความถูกต้องของการส่งออกที่มี n = 10 กับhttp://www.angio.net/pi/digits/pi1000000.txt

สิ่งนี้ช้าลงอย่างมากสำหรับ n ที่ใหญ่กว่า n = 12 ใช้เวลา 1.5 นาทีบน VM ของฉัน การรันตัวอยางที่แตกตางกันสองสามตัวแสดงความซับซ้อนของเวลาคือ O (e ^ n) (ไมแปลกใจ) การคาดการณ์สิ่งนี้ถึง n = 20 จะมีเวลารันไทม์ 233 วัน โอ้ดี ดีกว่าความร้อนแห่งความตายของจักรวาลอย่างน้อย

นี่คือสนามกอล์ฟในระดับปานกลาง - สแต็กถูกใช้เพื่อกำจัดตัวแปรชั่วคราวในระหว่างการคำนวณของการวนซ้ำแต่ละครั้ง แต่อาจมีการใช้สแต็กมากขึ้น

$ dc glpi.dc <<< 1
3.1
$ dc glpi.dc <<< 2
3.141
$ dc glpi.dc <<< 5
3.1415926535897932384626433832795
$ time dc glpi.dc <<< 7
3.1415926535897932384626433832795028841971693993751058209749445923078\
164062862089986280348253421170679821480865132823066470938446

real    0m0.048s
user    0m0.039s
sys 0m0.000s
$ 

หากคุณไม่ชอบการdcห่อผลลัพธ์ที่ 70 ตัวอักษรคุณสามารถตั้งค่าตัวแปรสภาพแวดล้อมDC_LINE_LENGTHเป็น 0:

$ DC_LINE_LENGTH=0 dc glpi.dc <<< 8
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648
$ 

R, 156 ไบต์

มาเริ่มปาร์ตี้กันเถอะ ... ด้วยการใช้อัลกอริทึม Gauss-Legendre อย่างไร้เดียงสาอย่างแท้จริง

for(i in 1:scan()){if(i<2){a=p=Rmpfr::mpfr(1,2e6);t=a/4;b=t^t}else{x=(a+b)/2;b=(a*b)^.5;t=t-p*(a-x)^2;a=x;p=2*p};o=(a+b)^2/(4*t)};cat(Rmpfr::format(o,2^i))

คำอธิบาย Ungolfed +:

# Generate n approximations of pi, where n is read from stdin
for (i in 1:scan()) {

    # Initial values on the first iteration
    if (i < 2) {
        a <- p <- Rmpfr::mpfr(1, 1e7)
        t <- a/4
        b <- t^t
    } else {
        # Compute new values
        x <- (a + b) / 2
        b <- (a*b)^0.5
        t <- t - p*(a - x)^2

        # Store values for next iteration
        a <- x
        p <- 2*p
    }

    # Approximate pi 
    o <- (a + b)^2 / (4*t)
}

# Print the result with 2^n digits
cat(Rmpfr::format(o, 2^i))

mpfr()ฟังก์ชั่นเป็นส่วนหนึ่งของRmpfrแพคเกจ มันสร้างmpfrวัตถุโดยใช้อาร์กิวเมนต์แรกเป็นค่าและอาร์กิวเมนต์ที่สองเป็นจำนวนบิตความแม่นยำ เรากำหนดaและpเป็น 1 และโดยการกำหนดtตามa(และbตามt), mpfrชนิดที่นำเสนอให้กับตัวแปรทั้งสี่จึงรักษาความแม่นยำตลอด

ดังที่กล่าวมานี้ต้องใช้แพ็คเกจ R Rmpfrซึ่งเป็นตัวย่อของ "หลายจุดลอยตัวแม่นยำหลายจุดที่เชื่อถือได้" แพคเกจใช้ GMP ในพื้นหลัง น่าเสียดายที่ base R ไม่มีความสามารถในการคำนวณทางคณิตศาสตร์ที่มีความแม่นยำสูงดังนั้นการพึ่งพาแพคเกจ

ไม่มีRmpfrเหรอ ไม่มีเหงื่อ. install.packages("Rmpfr")และความฝันทั้งหมดของคุณจะเป็นจริง

ขอให้สังเกตว่า2e6ถูกระบุว่าเป็นความแม่นยำ นั่นหมายความว่าเรามีความแม่นยำ 2,000,000 บิตซึ่งเพียงพอที่จะรักษาความแม่นยำอย่างน้อยn= 20 (หมายเหตุ: n= 20 ใช้เวลานาน แต่น้อยกว่าหนึ่งชั่วโมงในคอมพิวเตอร์ของฉัน)

วิธีการที่นี่เป็นเพียงการสำรอกสูตรในหน้า Wikipedia แต่เฮ้เราต้องเริ่มต้นที่ไหนสักแห่ง

ยินดีต้อนรับการป้อนข้อมูลใด ๆ เช่นเคย!

ฉันต้องเขียนสิ่งนี้อีกมาก แต่ฉันยังต้องยอมรับว่า Peter Taylor ช่วยให้ฉันสามารถทำคะแนนแรกได้ถึง 70 ไบต์ ในคำพูดของ DigitalTrauma "boom"

Python 2, 214 ไบต์

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

ปรับปรุง

ฉันได้ปรับปรุงโปรแกรมเพื่อปรับปรุงความแม่นยำและความเร็วด้วยค่าใช้จ่ายในการเล่นกอล์ฟ โดยใช้sqrt()วิธีทศนิยมและแทนที่การx**2ใช้ด้วยx*xตอนนี้จะเร็วขึ้น 200 เท่า ซึ่งหมายความว่าขณะนี้สามารถคำนวณ 20 ลูปที่ให้ผลลัพธ์หลักล้านในเวลา 6.5 ชั่วโมง ตัวเลขทศนิยมมักจะมีข้อผิดพลาดในหลักสุดท้าย (เกิดจากการดำเนินการตามขีด จำกัด ของความแม่นยำ) ดังนั้นโปรแกรมใช้และทิ้ง 5 หลักพิเศษเพื่อพิมพ์เฉพาะตัวเลขที่ถูกต้องเท่านั้น

from decimal import*
d=Decimal
e=input()
getcontext().prec=5+(1<<e)
k=d(1)
j=d(2)
g=j*j
h=k/j
a=k
b=k/j.sqrt()
t=k/g
p=k
for i in[0]*e:f=a;a,b=(a+b)/j,(a*b).sqrt();c=f-a;t-=c*c*p;p+=p
l=a+b
print str(l*l/g/t)[:-5]

วิ่งตัวอย่าง:

$ echo 1 | python min.py 
3.1
$ echo 2 | python min.py 
3.141
$ echo 3 | python min.py 
3.1415926
$ echo 5 | python min.py 
3.1415926535897932384626433832795
$ echo 12 | python min.py
3.141592653589793238462643383279502884197169399375105820974944592307816406286208
99862803482534211706798214808651328230664709384460955058223172535940812848111745
02841027019385211055596446229489549303819644288109756659334461284756482337867831
65271201909145648566923460348610454326648213393607260249141273724587006606315588
17488152092096282925409171536436789259036001133053054882046652138414695194151160
94330572703657595919530921861173819326117931051185480744623799627495673518857527
24891227938183011949129833673362440656643086021394946395224737190702179860943702
77053921717629317675238467481846766940513200056812714526356082778577134275778960
91736371787214684409012249534301465495853710507922796892589235420199561121290219
60864034418159813629774771309960518707211349999998372978049951059731732816096318
59502445945534690830264252230825334468503526193118817101000313783875288658753320
83814206171776691473035982534904287554687311595628638823537875937519577818577805
32171226806613001927876611195909216420198938095257201065485863278865936153381827
96823030195203530185296899577362259941389124972177528347913151557485724245415069
59508295331168617278558890750983817546374649393192550604009277016711390098488240
12858361603563707660104710181942955596198946767837449448255379774726847104047534
64620804668425906949129331367702898915210475216205696602405803815019351125338243
00355876402474964732639141992726042699227967823547816360093417216412199245863150
30286182974555706749838505494588586926995690927210797509302955321165344987202755
96023648066549911988183479775356636980742654252786255181841757467289097777279380
00816470600161452491921732172147723501414419735685481613611573525521334757418494
68438523323907394143334547762416862518983569485562099219222184272550254256887671
79049460165346680498862723279178608578438382796797668145410095388378636095068006
42251252051173929848960841284886269456042419652850222106611863067442786220391949
45047123713786960956364371917287467764657573962413890865832645995813390478027590
09946576407895126946839835259570982582262052248940772671947826848260147699090264
01363944374553050682034962524517493996514314298091906592509372216964615157098583
87410597885959772975498930161753928468138268683868942774155991855925245953959431
04997252468084598727364469584865383673622262609912460805124388439045124413654976
27807977156914359977001296160894416948685558484063534220722258284886481584560285
06016842739452267467678895252138522549954666727823986456596116354886230577456498
03559363456817432411251507606947945109659609402522887971089314566913686722874894
05601015033086179286809208747609178249385890097149096759852613655497818931297848
21682998948722658804857564014270477555132379641451523746234364542858444795265867
82105114135473573952311342716610213596953623144295248493718711014576540359027993
44037420073105785390621983874478084784896833214457138687519435064302184531910484
81005370614680674919278191197939952061419663428754440643745123718192179998391015
91956181467514269123974894090718649423196156794520809514655022523160388193014209
37621378559566389377870830390697920773467221825625996615014215030680384477345492
02605414665925201497442850732518666002132434088190710486331734649651453905796268
56100550810665879699816357473638405257145910289706414011097120628043903975951567
71577004203378699360072305587631763594218731251471205329281918261861258673215791
98414848829164470609575270695722091756711672291098169091528017350671274858322287
18352093539657251210835791513698820914442100675103346711031412671113699086585163
98315019701651511685171437657618351556508849099898599823873455283316355076479185
35893226185489632132933089857064204675259070915481416549859461637180270981994309
92448895757128289059232332609729971208443357326548938239119325974636673058360414
28138830320382490375898524374417029132765618093773444030707469211201913020330380
19762110110044929321516084244485963766983895228684783123552658213144957685726243
34418930396864262434107732269780280731891544110104468232527162010526522721116603
96665573092547110557853763466820653109896526918620564769312570586356620185581007
29360659876486117

รหัสที่ไม่ดีนัก:

from decimal import *
d = Decimal

loops = input()
# this is a conservative estimate for precision increase with each loop:
getcontext().prec = 5 + (1<<loops)

# constants:
one = d(1)
two = d(2)
four = two*two
half = one/two

# initialise:
a = one
b = one / two.sqrt()
t = one / four
p = one

for i in [0]*loops :
    temp = a;
    a, b = (a+b)/two, (a*b).sqrt();
    pterm = temp-a;
    t -= pterm*pterm * p;
    p += p

ab = a+b
print str(ab*ab / four / t)[:-5]

Python (2.7) - 131 ไบต์

from gmpy import*
n=input()
p=a=fsqrt(mpf(8,4<<n));b=0
exec"a=fsqrt(a/2);b=1/(a-a*b+b/a+1);p*=b+a*a*b;a+=1/a;"*n
print`p`[5:2**n+6]

ปรับปรุง:ตอนนี้ใช้มากกว่าgmpy gmpy2ไม่ว่าจะด้วยเหตุผลใดก็ตามในgmpy2การตั้งค่าความแม่นยำในค่าเดียวจะไม่แพร่กระจายไปยังค่าอื่น ผลลัพธ์ของการคำนวณใด ๆ จะย้อนกลับไปเป็นความแม่นยำของบริบทปัจจุบัน ความแม่นยำทำให้เกิดการแพร่กระจายgmpyซึ่งดูเหมือนง่ายสำหรับฉัน นอกจากนี้ยัง verbose น้อยมาก

ใช้หนึ่งในอัลกอริธึมที่คิดค้นโดยBorwein และ Borweinซึ่งได้รับการปรับปรุงเล็กน้อย n = 20 ใช้เวลาประมาณ 11 วินาทีในกล่องของฉัน ไม่ใช่วิธีที่มีประสิทธิภาพที่สุด แต่ก็ยังไม่เลว

refactoring

อัลกอริทึมดั้งเดิมมีดังต่อไปนี้:

การรีแฟคเตอร์นั้นเพิ่มขึ้น แต่ผลลัพธ์สุดท้ายก็คือ

เรียบง่ายที่สำคัญที่เกิดขึ้นในหน้า 1 _{+ n} นอกจากนี้ยังเร็วขึ้นเล็กน้อยเนื่องจากมีการยกเลิกการแบ่ง

การใช้งานปัจจุบันผลักดันให้_nซ้ำหนึ่งครั้งในการคำนวณp _{n + 1}ซึ่งช่วยให้การเริ่มต้นที่แตกต่างกันของp ₀ ( 2√2 ) แต่เป็นอย่างอื่นเหมือนกัน

ตัวอย่างการใช้งาน

$ echo 1 | python pi-borwein.py
3.1

$ echo 2 | python pi-borwein.py
3.141

$ echo 5 | python pi-borwein.py
3.1415926535897932384626433832795

$ echo 10 | python pi-borwein.py
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609433057270365759591953092186117381932611793105118548074462379962749567351885752724891227938183011949129833673362440656643086021394946395224737190702179860943702770539217176293176752384674818467669405132000568127145263560827785771342757789609173637178721468440901224953430146549585371050792279689258923542019956112129021960864034418159813629774771309960518707211349999998372978049951059731732816096318595024459455346908302642522308253344685035261931188171010003137838752886587533208381420617177669147303598253490428755468731159562863882353787593751957781857780532171226806613001927876611195909216420198938095257201065485863278

bc และวิธีของนิวตัน 43 ไบต์

วิธีการของนิวตันในการหาค่าศูนย์ของฟังก์ชั่นใด ๆ มาบรรจบกันเป็นสองส่วนและอัลกอริทึมนั้นง่ายกว่าสำหรับ Gauss-Legendre โดยทั่วไปแล้วจะเดือดลงไปที่:

ดังนั้นที่นี่ไปตัวอย่างตาม:

n=20;x=3;scale=2^n;while(n--)x-=s(x)/c(x);x

อ่านง่ายขึ้นอีกเล็กน้อย:

/* desired number of iterations */
n = 20;

/* starting estimate for pi */
x = 3;

/* set precision to 2^n */
scale = 2^n;

/* perform n iteration steps */
while(n--)
  // f:=sin, f'=cos
  x -= s(x)/c(x)

หากต้องการทดสอบสิ่งนี้ให้เรียกใช้bc -lในเชลล์แล้ววางข้อมูลโค้ดด้านบน เตรียมพร้อมที่จะรอสักครู่; n=20ได้รับการทำงานประมาณ 5 นาทีในขณะนี้และยังไม่มีที่สิ้นสุด n=10ใช้เวลาประมาณ 40 วินาที