에 이어 파이의 몬테 카를로 추정 이 문제는 상수 파이의 짧은 코드를 생성하는 것입니다. 여기를 제외하고 코드는 pi의 연속 숫자를 영원히 출력해야합니다.

이것은 코드 골프이기 때문에 합리적인 PC에서 10 초 이내에 첫 10,000 자리를 출력해야하며 종료해서는 안된다는 점을 제외하고 가장 짧은 제출 (바이트)이 이깁니다.

Pi 또는 trig 기능에는 내장 기능을 사용할 수 없습니다.

코드 크기에 대한 하드 제한을 제거했습니다.

CJam-48

3.1o{1YAZ2*:Z#*{_2$*2$2*)/@)\}h*]:+sX2*:X>X<o1}g

이것은 π를 더 큰 정밀도로 2 * sum (k! / (2k + 1) !!)로 계산하며 모든 단계에서 중단 된 자리부터 여러 자리수를 인쇄합니다.

당신은 할 수 있습니다 온라인으로 시도 단지 8 (외부 루프) 반복을 수행하고 512 자리 숫자를 인쇄하는 수정 된 버전을, 또는 사용하는 자바 인터프리터를 진짜를 위해. 내 노트북에서는 약 6 초 안에 16384 자리 숫자가됩니다.

참고 :이 프로그램은 메모리가 매우 부족합니다. 더 잘 동작하지만 약간 더 긴 버전은 다음과 같습니다.

3.1o{T2AZ2*:Z#*1{@2$+@2$*2$2*)/@)1$}g;;sX2*:X>X<o1}g

설명:

3.1o              print 3.1
{…1}g             repeat indefinitely
    1YA           push 1, 2 and 10 (Y=2, A=10)
    Z2*:Z         push Z*2 (Z=3 initially) and store back in Z
    #*            calculate 2*10^Z (2 from the formula and 10^Z for precision)
                  this is the term for k=0, and the earlier 1 represents k
    {…}h          do-while
                  at each iteration, the stack contains: terms, k, last-term
        _2$*      copy the previous term and k and multiply them
        2$2*)/    divide the previous number by 2*k+1
                  this is the current term of the series
        @)\       increment k and move it before the current term
                  the current term now serves as the loop condition
                  so the loop terminates when the term becomes 0
    *             multiply k and the last term (0), to get rid of k
    ]:+s          put all the terms in an array, add them and convert to string
                  we obtain an approximation of π*10^Z
    X2*:X         push X*2 (X=1 initially) and store back in X
    >X<o          print X digits starting from the X position

파이썬, 138 바이트

q,r,t,i=1,180,60,2
while 1:u,y=27*i*(i+1)+6,(q*(27*i-12)+5*r)//(5*t);print(y,end="");q,r,t,i=10*q*i*(2*i-1),10*u*(q*(5*i-2)+r-y*t),t*u,i+1

구현 http://www.cs.ox.ac.uk/jeremy.gibbons/publications/spigot.pdf .

GolfScript (81 자)

1:i:^3{3i):i*(.(*3*.@*.5*3$27i*12-*+@^*:^5*/.print^*2$5i*2-*--\10*i*2i*(*\10*.}do

온라인 데모 (적절한 데스크톱보다 속도가 느리고 한정된 횟수만큼 반복되는 간단한 코드 변경 사항이 있음)

물론 이전에 언급 한 스피 곳 알고리즘을 사용했지만 만족스럽게 골프를 치는 데 시간이 걸렸습니다. Gibbons의 논문에 제시된 알고리즘은 (의사 코드)

q = 1; r = 180; t = 60; i = 2
while (true) {
    u = 3*(3*i+1)*(3*i+2)
    y = (q*(27*i-12)+5*r) / (5*t)
    print y
    r += q*(5*i-2)-y*t
    r *= 10*u
    q *= 10*i*(2*i-1)
    t *= u
    i += 1
}

위의 GolfScript는 (의사 코드)와 같습니다.

t = i = q = 1; r = 3
while (true) {
    u = 3*(3*i+1)*(3*i+2)
    i += 1
    r *= u
    t *= u
    y = (q*(27*i-12)+5*r) / (5*t)
    print y
    r -= y*t - q*(5*i-2)
    q *= 10*i*(2*i-1)
    r *= 10
}

초기화 및 스택 관리에서 일부 문자를 저장합니다.

Pyth- 87 85 바이트

http://www.cs.ox.ac.uk/jeremy.gibbons/publications/spigot.pdf의 다른 번역 . 나는 파이썬을 할 예정이지만 @orlp가 나를 이겼으므로 Pyth를했다. 트윗에 들어가기에 충분히 작습니다.

=H3=d1=bd=Gd#K+**hb27b6~b1=H*HK=d*dKJ/+*-*27b12G*5H*5d=H*T-H-*Jd*-*5b2G=G***GTbtybpkJ

인쇄 설정 end=""에서 발생하는 인쇄 버퍼로 인해 간헐적 인 단계이지만 출력을 stdout에 제공합니다 . 사양에 "연속 숫자"라고 표시되어 있으므로 현재 소수점을 인쇄하지 않습니다. 내 점수를 죽이는 임무.

=H3                     Set H to 3
=d1                     Set d to 1
=bd                     Set b to d which is 1
=Gd                     Set G to d which is 1
#                       Infinte Loop
  K                     Set K to
    +**hb27b6           27*b*(b+1)+6
  ~b1                   b+=1
  =H*HK                 H*=K
  =d*dK                 d*=K
  J                     Set J to
    /                   Integer division
      +*-*27b12G*5H     G*(27*b-12)+5*H
      *5d               5*d
  =H                    Set H to
    *T-H-*Jd*-*5b2G     10*(H-(J*d -G*(5*b-2)))
  =G                    Set G to
    ***GTbtyb           G*10*b*(2*b-1)
  pkJ                   Print J with the end as "", not a newline

여기서 사용해보십시오 . (참고 : 온라인 인터프리터는 완료된 결과 만 제공하므로 무한 루프가 종료되므로 처음 100 개만 인쇄하여 코드 크기가 증가합니다. 무한대로 시도하려면 로컬 인터프리터를 다운로드하십시오.)

타이밍

gnu 시간에 따르면 내 Google 클라우드 컴퓨팅 마이크로 인스턴스에서는 시간이 real: 0m2.062s너무 빠릅니다.

스칼라, 599 바이트

아래 코드 는 Pi의 Digits를위한 스피 곳 알고리즘 의 부록 2에있는 파스칼 코드의 직선 포트입니다 . 아직 골프는 거의 없었습니다. 이 코드는 10 초 이내에 10,000 자리 piSpigot(10000)를 생성하며 무한 메모리가있는 경우 많은 숫자를 생성하도록 매개 변수화 할 수 있지만 무한하지는 않습니다. 이것이 문제 제약 조건을 충족하는지 확실하지 않으므로 피드백을 제공하십시오.

def piSpigot(n: Int): Unit = {
  val len=10*n/3
  var nines=0
  var predigit=0
  val a=Array.fill(len)(2)
  (1 to n).foreach {_=>
    var q=0
    (1 to n).reverse.foreach{i=>
      var x=10*a(i)+q*i
      a(i)=x%(2*i-1)
      q=x/(2*i-1)
    }
    a(1)=q%10
    q/=10
    if (q==9) {
      nines+=1
    } else if (q==10) {
      print(predigit+1)
      1.to(nines).foreach(_=>print(0))
      predigit=0
      nines=0
    } else {
      print(predigit)
      predigit=q
      if (nines!=0) {
        1.to(nines).foreach(_=>print(9))
        nines=0
      }
    }
  }
  println(predigit)
}
piSpigot(10000)

Befunge-98 (PyFunge), 120 바이트

cf*10p'<20p11>00p1+:30p:::*+39**6+:30g39**c-00g*10gv
>:2*1-*00g*a*^
^:p02*g02p01*a*-*g02\+g01*g00-2*5g03,+*86:/*5g02+*5<

온라인으로 사용해보십시오!

시간 제한 측면에서 경계선입니다. 노트북에는 10,000 자리 숫자가 약 11 초가 걸리지 만, 그보다 더 빠른 속도를 낼 수있는 "합리적인"PC가 있어야합니다.

그러나 TIO에서 시도하는 경우 알고리즘이 계속 진행되도록 설계되었으므로 60 초 시간 제한에 도달 할 때까지 아무것도 반환하지 않습니다. 그때까지 당신은 10,000 자리 이상을 가질 것입니다.

Jeremy Gibbons 스피 곳 알고리즘을 사용하고 있는데, 여기의 다른 답변과 동일하다고 생각합니다. 그러나 이것은 임의의 정밀 메모리 셀을 갖는 인터프리터와 그 지원을 알고있는 유일한 구현은 PyFunge 입니다.

설명

cf*10p                     Initialise r to 180.
      '<20p                Initialise t to 60.
           11              Initialise i and q on the stack to 1.

>                          Start of the main loop.
 00p                       Save the current value of q in memory.
    1+:30p                 Increment i and save a copy in memory.      
          :::*+39**6+      Calculate u = 27*(i*i+i)+6.
                     :     Make a duplicate, since we'll need two copies later.

       30g39**c-00g*10gv   Calculate y = (q*(27*i-12)+5*r)/(5*t).
              /*5g02+*5<
        ,+*86:             Convert y to a character so we can output it.

*a*-*g02\+g01*g00-2*5g03   Calculate r = 10*u*(q*(i*5-2)+r-y*t)

         p01               Save the updated r.
     *g02                  Calculate t = t*u
  p02                      Save the updated t.

>:2*1-*00g*a*              Calculate q = 10*q*i*(i*2-1).
^:
             ^             Return to the start of the main loop.