เขียนโปรแกรมที่พิมพ์การประมาณเหตุผลที่ดีทั้งหมดของ pi ด้วยตัวส่วน <1000000 เพื่อเพิ่มลำดับตัวส่วน a/bคือ "เหตุผลประมาณดี" ของพี่ถ้ามันเป็นความใกล้ชิดกับปี่กว่าที่อื่น ๆ bที่มีเหตุผลกับตัวหารไม่ใหญ่กว่า

ผลลัพธ์ควรมีทั้งหมด 167 บรรทัดและเริ่มต้นและสิ้นสุดดังนี้:

3/1
13/4
16/5
19/6
22/7
179/57
...
833719/265381
1146408/364913
3126535/995207

โปรแกรมที่สั้นที่สุดชนะ

Golfscript, 71 70 69 ตัวอักษร

2\!:^2^..292^15.2/3]{(.)2/.9>+{\+.((}*;.}do;;]-1%{^0@{2$*+\}/"/"\n}/;

(สมมติว่าคุณไม่ผ่านสิ่งใดบน stdin)

ฉันไม่ต้องการได้ยินเสียงหอนของคนที่ไม่มีค่าคงที่ในตัวสำหรับ pi อีกต่อไป ฉันไม่มีเลขทศนิยม!

ดูhttp://en.wikipedia.org/wiki/Continued_fraction#Best_rational_approximationsสำหรับพื้นหลัง

# No input, so the stack contains ""
2\!:^2^..292^15.2/3]
# ^ is used to store 1 because that saves a char by allowing the elimination of whitespace
# Otherwise straightforward: stack now contains [2 1 2 1 1 1 292 1 15 7 3]
# Pi as a continued fraction is 3+1/(7+1/(15+1/(...)))
# If you reverse the array now on the stack you get the first 10 continuants followed by 2
# (rather than 3)
# That's a little hack to avoid passing the denominator 1000000

{
    # Stack holds: ... [c_n c_{n-1} ... c_0]
    (.)2/.9>+
    # Stack holds ... [c_{n-1} ... c_0] c_n (1+c_n)/2+((1+c_n)/2 > 9 ? 1 : 0)
    # (1+c_n)/2 > 9 is an ad-hoc approximation of the "half rule"
    # which works in this case but not in general
    # Let k = (1+c_n)/2+((1+c_n)/2 > 9 ? 1 : 0)
    # We execute the next block k times
    {
        # ... [c_{n-1} ... c_0] z
        \+.((
        # ... [z c_{n-1} ... c_0] [c_{n-1} ... c_0] z-1
    }*
    # So we now have ... [c_n c_{n-1} ... c_0] [(c_n)-1 c_{n-1} ... c_0] ...
    #                    [(c_n)-k+1 c_{n-1} ... c_0] [c_{n-1} ... c_0] c_n-k
    ;
    # Go round the loop until the array runs out
    .
}do

# Stack now contains all the solutions as CFs in reverse order, plus two surplus:
# [2 1 2 1 1 1 292 1 15 7 3] [1 2 1 1 1 292 1 15 7 3] ... [6 3] [5 3] [4 3] [3] [2] []
# Ditch the two surplus ones, bundle everything up in an array, and reverse it
;;]-1%

# For each CF...
{
    # Stack holds ... [(c_n)-j c_{n-1} ... c_0]
    # We now need to convert the CF into a rational in canonical form
    # We unwind from the inside out starting with (c_n)-j + 1/infinity,
    # representing infinity as 1/0
    ^0@
    # ... 1 0 [c_n-j c_{n-1} ... c_0]
    # Loop over the terms of the CF
    {
        # ... numerator denominator term-of-CF
        2$*+\
        # ... (term-of-CF * numerator + denominator) numerator
    }/

    # Presentation
    "/"\n
    # ... numerator "/" denominator newline
}/

# Pop that final newline to avoid a trailing blank line which isn't in the spec
;

Mathematica, 67 63

สิ่งนี้จะไม่เร็ว แต่ฉันเชื่อว่ามันถูกต้องทางเทคนิค

Round[π,1/Range@1*^6]//.x_:>First/@Split[x,#2≥#&@@Abs[π-{##}]&]

Round[π, x]xจะช่วยให้ส่วนที่อยู่ใกล้πในขั้นตอนของ นี่คือ "listable" ดังนั้นRound[π,1/Range@1*^6]จะทำเช่นนี้สำหรับเศษส่วนทั้งหมดตาม1/10^6ลำดับ รายการผลลัพธ์ที่มีการประมาณด้วยเหตุผล "ไม่ดี" จำนวนมากจะถูก//.ประมวลผลซ้ำแล้วซ้ำอีก ( ) โดยการลบองค์ประกอบใด ๆ ที่อยู่ห่างจากπมากกว่ารายการก่อนหน้า

Perl, 77 ตัวอักษร

$e=$p=atan2 0,-1;($f=abs$p-($==$p*$_+.5)/$_)<$e&&($e=$f,say"$=/$_")for 1..1e6

ความท้าทายที่รองลงมาก็คือว่า Perl ไม่ได้มีในตัวπatan2(0,-1)คงใช้ได้ดังนั้นครั้งแรกที่ผมได้มีการคำนวณว่ามันเป็น ฉันแน่ใจว่าสิ่งนี้จะถูกทำลายโดยภาษาที่เหมาะกับงานมากกว่า แต่มันก็ไม่เลวสำหรับภาษาที่ออกแบบมาเพื่อการประมวลผลข้อความเป็นหลัก

งูหลาม96 93 89 ตัวอักษร

a=b=d=1.
while b<=1e6:
 e=3.14159265359-a/b;x=abs(e)
 if x<d:print a,b;d=x
 a+=e>0;b+=e<0

Python 95 95ตัวอักษรอัลกอริทึมที่แตกต่างกัน

p=3.14159265359;d=1
for a in range(3,p*1e6):
 b=round(a/p);e=abs(p-a/b)
 if e<d:print a,b;d=e

หมายเหตุ:มันเป็นตัวละครน้อยที่จะเขียนมากกว่าp=3.14159265359; from math import*ยี้การนำเข้าคำเหล่านั้น!

JS (95 ตัวอักษร)

for(i=k=1,m=Math;i<1e6;i++)if((j=m.abs((x=m.round(m.PI*i))/i-m.PI))<k)k=j,console.log(x+'/'+i)

มันพิมพ์ 167 บรรทัด

Ruby 1.9, 84 ตัวอักษร

m=1;(1..1e6).map{|d|n=(d*q=Math::PI).round;k=(n-q*d).abs/d;k<m&&(m=k;puts [n,d]*?/)}

C99, 113 ตัวอักษร

main(d,n){double e=9,p=2*asin(1),c,a=1;for(;n=d*p+.5,c=fabsl(p-a*n/d),d<1e6;++d)c<e&&printf("%d/%d\n",n,d,e=c);}

จำเป็นต้องรวบรวม-lmและอาจเต็มไปด้วยพฤติกรรมที่ไม่ได้กำหนด แต่มันใช้ได้สำหรับฉัน

สกาลา - 180 ตัวอักษร

import math._
def p(z:Int,n:Int,s:Double):Unit=
if(n==1e6)0 else{val q=1.0*z/n
val x=if(abs(Pi-q)<s){println(z+"/"+n)
abs(Pi-q)}else s
if(Pi-q<0)p(z,n+1,x)else p(z+1,n,x)}
p(3,1,1)

// ungolfed: 457

val pi=math.Pi
@annotation.tailrec
def toPi (zaehler: Int = 3, nenner: Int = 1, sofar: Double=1): Unit = {
  if (nenner == 1000000) () 
  else {
    val quotient = 1.0*zaehler/nenner
    val diff = (pi - quotient)
    val adiff= math.abs (diff)
    val next = if (adiff < sofar) {
      println (zaehler + "/" + nenner) 
      adiff 
    }
    else sofar
    if (diff < 0) toPi (zaehler, nenner + 1, next) 
    else toPi (zaehler + 1, nenner, next) 
  }  
}

คำอธิบายประกอบ tailrec เป็นเพียงการตรวจสอบเพื่อตรวจสอบว่าเป็นแบบเรียกซ้ำซึ่งมักจะเป็นการปรับปรุงประสิทธิภาพ

Mathematica 18ตัวอักษร 17 ตัว

ฉันเลือกที่จะใช้เป็นมาตรวัด "ดีที่สุด" จำนวนคำศัพท์ในการแสดงเศษส่วนต่อเนื่องของπ จากเกณฑ์นี้การประมาณด้วยเหตุผลที่ดีที่สุดของπคือคอนเวอร์เจนท์

มีคอนเวอร์เจนต์ 10 รายการของπโดยมีตัวหารน้อยกว่าหนึ่งล้าน นี่คือน้อยกว่า 167 ข้อกำหนดที่ร้องขอ แต่ฉันรวมมันที่นี่เพราะมันอาจเป็นที่สนใจของผู้อื่น

Convergents[π, 10] 

(* out *)
{3, 22/7, 333/106, 355/113, 103993/33102, 104348/33215, 208341/66317,
312689/99532, 833719/265381, 1146408/364913}

หากคุณต้องการเห็นตัวหารสำหรับคอนเวอร์เจนต์แรกมันจะเสียค่าใช้จ่ายเพิ่มอีก 11 ตัวอักษร:

Convergents[π, 10] /. {3 -> "3/1"}
(* out *)
{"3/1", 22/7, 333/106, 355/113, 103993/33102, 104348/33215,
208341/66317, 312689/99532, 833719/265381, 1146408/364913}

สำหรับผู้ที่มีความสนใจต่อไปนี้แสดงให้เห็นถึงความสัมพันธ์ในหมู่คอนเวอร์เจนต์หารบางส่วนและการแสดงออกของเศษส่วนต่อเนื่องของคอนเวอร์เจนซ์ของπ:

Table[ContinuedFraction[π, k], {k, 10}]
w[frac_] := Row[{Fold[(#1^-1 + #2) &, Last[#], Rest[Reverse[#]]] &[Text@Style[#, Blue, Bold, 14] & /@ ToString /@ ContinuedFraction[frac]]}];
w /@ FromContinuedFraction /@ ContinuedFraction /@ Convergents[π, 10]

โปรดแก้ตัวการจัดรูปแบบที่ไม่สอดคล้องของเศษส่วนต่อเนื่อง

C # 140 129 ตัวอักษร

double n=3,d=1,e=d;while(n<4e5){double w=n/d-Math.PI,a=Math.Abs(w);if(a<e){e=a;Console.WriteLine(n+"/"+d);}if(w>0)d++;else n++;}

รหัสที่ไม่บีบอัด

var numerator = 3d;
var denominator = 1d;
var delta = 4d;
while (numerator < 4e5) 
{
    var newDelta = (numerator / denominator) - Math.PI;
    var absNewDelta = Math.Abs(newDelta);
    if (absNewDelta < delta)
    {
        delta = absNewDelta;
        Console.WriteLine(string.Format("{0}/{1}", numerator, denominator));
    }

    if (newDelta > 0)
    {
        denominator++;
    }
    else
    {
        numerator++;
    }
}

J, ⁶⁹ 65

ใหม่

]`,@.(<&j{.)/({~(i.<./)@j=.|@-l)@(%~(i:3x)+<.@*l=.1p1&)"0>:_i.1e3

ยังคงเป็นวิธีการที่ดุร้าย แต่เร็วกว่าและสั้นกว่าเล็กน้อย

เก่า

"กำลังดุร้าย" ง่าย ๆ :

(#~({:<<./@}:)\@j)({~(i.<./)@j=.|@-l)@(%~(i:6x)+<.@*l=.1p1&)"0>:i.1e3

ทำให้รายการของ และแล้วทิ้งผู้ที่อยู่ไกลออกไปจากπสำหรับบางคนa/bb'<b

หมายเหตุ: เปลี่ยน1e3เป็น1e6สำหรับรายการทั้งหมด ไปทำอย่างอื่นแล้วกลับมาใหม่