파이 전용으로 이미 30 개의 도전 과제가 있지만 n 번째 10 진수를 찾도록 요구하는 것은 하나도 없습니다.

도전

0 <= n <= 10000표시 범위의 정수에 대해서는 pi의 n 번째 10 진수입니다.

규칙

• 소수점 이하 자릿수 3.
• 프로그램이 기능이거나 전체 프로그램 일 수 있습니다.
• 10 진법으로 결과를 출력해야합니다
• 당신은 얻을 수 n있지만 하드 코딩되지 않은 적합한 입력 방법 (함수 매개 변수가 ... 표준 입력, 입력 ())에서
• 선택한 언어에 고유 한 1 기반 색인 작성을 사용할 수 있습니다.
• 유효하지 않은 입력 ( n == -1, n == 'a'또는 n == 1.5) 을 처리 할 필요가 없습니다.
• 최소 10k 이하의 소수점 을 지원하는 경우 내장이 허용됩니다.
• 가장 짧은 코드가 아니라 가장 짧은 코드이므로 런타임은 중요하지 않습니다.
• 이것은 바이트 단위의 code-golf , 가장 짧은 코드입니다.

테스트 사례

f(0)     == 1
f(1)     == 4 // for 1-indexed languages f(1) == 1
f(2)     == 1 // for 1-indexed languages f(2) == 4
f(3)     == 5
f(10)    == 8
f(100)   == 8
f(599)   == 2
f(760)   == 4
f(1000)  == 3
f(10000) == 5

참고로, 여기 에 pi의 첫 100k 자리가 있습니다.

05AB1E, 3 바이트

žs¤

설명

žs   # push pi to N digits
  ¤  # get last digit

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

1 기반 인덱싱을 사용합니다.
최대 100k 자릿수를 지원합니다.

파이썬 2, 66 바이트

n=input()+9
x=p=5L**7
while~-p:x=p/2*x/p+10**n;p-=2
print`x/5`[-9]

입력은 stdin에서 가져옵니다.

샘플 사용법

$ echo 10 | python pi-nth.py
8

$ echo 100 | python pi-nth.py
8

$ echo 1000 | python pi-nth.py
3

$ echo 10000 | python pi-nth.py
5

Bash + coreutils, 60 49 바이트

echo "scale=10100;4*a(1)"|bc -l|tr -d '\\\n'|cut -c$(($1+2))

bc -l<<<"scale=$1+9;4*a(1)-3"|tr -dc 0-9|cut -c$1

Dennis가 개선했습니다 . 감사!

인덱스는 1부터 시작합니다.

파이썬 2, 73 71 73 바이트

내 점수를 2 바이트 늘리는 @aditsu 덕분에

마지막으로 2 초 안에 완료 될 수있는 알고리즘.

n=10**10010
a=p=2*n
i=1
while a:a=a*i/(2*i+1);p+=a;i+=1
lambda n:`p`[n+1]

무시 했어!

테일러 시리즈를 사용하여 pi = 4*arctan(1)계산 arctan(1)하는 동안 수식 을 사용합니다 .

MATL, 11 10 바이트

@Luis 덕분에 1 바이트 절약

YPiEY$GH+)

이 솔루션은 1 기반 인덱싱을 사용합니다.

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

모든 테스트 사례

설명

YP  % Pre-defined literal for pi
iE  % Grab the input and multiply by 2 (to ensure we have enough digits to work with)
Y$  % Compute the first (iE) digits of pi and return as a string
G   % Grab the input again
H+  % Add 2 (to account for '3.') in the string
)   % And get the digit at that location
    % Implicitly display the result

Mathematica 30 바이트

RealDigits[Pi,10,1,-#][[1,1]]&

f=%

f@0
f@1
f@2
f@3
f@10
f@100
f@599
f@760
f@1000
f@10000

1
4
1
5
8
8
2
4
3
5

세이지, 32 25 바이트

lambda d:`n(pi,9^5)`[d+2]

이런 종류의 언어로 내 첫 대답.

npi17775 자리로 반올림 합니다.

CJam, 32

7e4,-2%{2+_2/@*\/2e10005+}*sq~)=

온라인으로 사용해보십시오 (약간 느립니다).

매스 매 티카, 23 21 바이트

⌊10^# Pi⌋~Mod~10&

SageMath, 24 바이트

lambda n:int(10^n*pi)%10

J , 19 15 바이트

10([|<.@o.@^)>:

정수 n 을 취하여 pi 의 n ^번째 숫자를 출력합니다 . 0부터 시작하는 인덱싱을 사용합니다. n ^번째 숫자 를 얻으려면 pi 곱하기 10 ^{n +1을} 계산 하고 해당 값의 바닥을 취한 다음 modulo 10을 취하십시오.

용법

입력은 확장 정수입니다.

   f =: 10([|<.@o.@^)>:
   (,.f"0) x: 0 1 2 3 10 100 599 760 1000
   0 1
   1 4
   2 1
   3 5
  10 8
 100 8
 599 2
 760 4
1000 3
   timex 'r =: f 10000x'
1100.73
   r
5

내 컴퓨터에서는 10000 ^번째 자리 를 계산하는 데 약 18 분이 걸립니다 .

설명

10([|<.@o.@^)>:  Input: n
             >:  Increment n
10               The constant n
           ^     Compute 10^(n+1)
        o.@      Multiply by pi
     <.@         Floor it
   [             Get 10
    |            Take the floor modulo 10 and return

클로저, 312 바이트

(fn[n](let[b bigdec d #(.divide(b %)%2(+ n 4)BigDecimal/ROUND_HALF_UP)m #(.multiply(b %)%2)a #(.add(b %)%2)s #(.subtract % %2)](-(int(nth(str(reduce(fn[z k](a z(m(d 1(.pow(b 16)k))(s(s(s(d 4(a 1(m 8 k)))(d 2(a 4(m 8 k))))(d 1(a 5(m 8 k))))(d 1(a 6(m 8 k)))))))(bigdec 0)(map bigdec(range(inc n)))))(+ n 2)))48)))48)))

그래서 당신이 아마 알 수 있듯이, 나는 내가하고있는 일을 모른다. 이것은 무엇보다 더 코믹하게되었습니다. Google에서 "pi에서 n 자리 숫자" 를 입력 한 후 Bailey–Borwein–Plouffe 공식 의 Wikipedia 페이지를 방문했습니다 . 수식을 읽을 수있는 미적분학 (?) 만 알면 Clojure로 변환 할 수있었습니다.

번역 자체는 그렇게 어렵지 않았습니다. 공식에는 n이 필요하므로 정밀도를 다루는 데 어려움이있었습니다 (Math/pow 16 precision). 정말 빨리 커집니다. 나는 BigDecimal이것이 작동 하기 위해 모든 곳 에서 사용해야 했는데, 실제로 부풀어 오른다.

언 골프 드 :

(defn nth-pi-digit [n]
  ; Create some aliases to make it more compact
  (let [b bigdec
        d #(.divide (b %) %2 (+ n 4) BigDecimal/ROUND_HALF_UP)
        m #(.multiply (b %) %2)
        a #(.add (b %) %2)
        s #(.subtract % %2)]
    (- ; Convert the character representation to a number...
      (int ; by casting it using `int` and subtracting 48
         (nth ; Grab the nth character, which is the answer
           (str ; Convert the BigDecimal to a string
             (reduce ; Sum using a reduction
               (fn [sum k]
                 (a sum ; The rest is just the formula
                       (m
                         (d 1 (.pow (b 16) k))
                         (s
                           (s
                             (s
                               (d 4 (a 1 (m 8 k)))
                               (d 2 (a 4 (m 8 k))))
                             (d 1 (a 5 (m 8 k))))
                           (d 1 (a 6 (m 8 k)))))))
               (bigdec 0)
               (map bigdec (range (inc n))))) ; Create an list of BigDecimals to act as k
           (+ n 2)))
      48)))

말할 것도없이, 당신이 수학을 알고 있다면 이것에 대해 더 쉽게 갈 수있는 방법이있을 것입니다.

(for [t [0 1 2 3 10 100 599 760 1000 10000]]
  [t (nth-pi-digit t)])

([0 1] [1 4] [2 1] [3 5] [10 8] [100 8] [599 2] [760 4] [1000 3] [10000 5])

클로저, 253 바이트

(defmacro q[& a] `(with-precision ~@a))(defn h[n](nth(str(reduce +(map #(let[p(+(* n 2)1)a(q p(/ 1M(.pow 16M %)))b(q p(/ 4M(+(* 8 %)1)))c(q p(/ 2M(+(* 8 %)4)))d(q p(/ 1M(+(* 8 %)5)))e(q p(/ 1M(+(* 8 %)6)))](* a(-(-(- b c)d)e)))(range(+ n 9)))))(+ n 2)))

이 공식을 사용하여 숫자 pi를 계산하십시오 . 매크로 with-precision가 너무 자주 사용되므로 매크로를 재정의해야합니다 .

당신은 여기에 출력을 볼 수 https://ideone.com/AzumC3 1000 만 걸리는 시간의 ideone 사용 제한 초과 어깨를 으쓱를

파이썬 3 , 338 바이트

이 구현은 pi를 추정하는 가장 빠른 알고리즘 중 하나 인 Chudnovsky 알고리즘을 기반으로합니다 . 각 반복에 대해 대략 14 자리가 추정됩니다 ( 자세한 내용 은 여기 를 참조하십시오).

f=lambda n,k=6,m=1,l=13591409,x=1,i=0:not i and(exec('global d;import decimal as d;d.getcontext().prec=%d'%(n+7))or str(426880*d.Decimal(10005).sqrt()/f(n//14+1,k,m,l,x,1))[n+2])or i<n and d.Decimal(((k**3-16*k)*m//i**3)*(l+545140134))/(x*-262537412640768000)+f(n,k+12,(k**3-16*k)*m

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

자바 (7), (262) 260 바이트

import java.math.*;int c(int n){BigInteger p,a=p=BigInteger.TEN.pow(10010).multiply(new BigInteger("2"));for(int i=1;a.compareTo(BigInteger.ZERO)>0;p=p.add(a))a=a.multiply(new BigInteger(i+"")).divide(new BigInteger((2*i+++1)+""));return(p+"").charAt(n+1)-48;}

사용 LeakyNun의 @ 파이썬 2 알고리즘 .

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

import java.math.*;
class M{
  static int c(int n){
    BigInteger p, a = p = BigInteger.TEN.pow(10010).multiply(new BigInteger("2"));
    for(int i = 1; a.compareTo(BigInteger.ZERO) > 0; p = p.add(a)){
      a = a.multiply(new BigInteger(i+"")).divide(new BigInteger((2 * i++ + 1)+""));
    }
    return (p+"").charAt(n+1) - 48;
  }

  public static void main(String[] a){
    System.out.print(c(0)+", ");
    System.out.print(c(1)+", ");
    System.out.print(c(2)+", ");
    System.out.print(c(3)+", ");
    System.out.print(c(10)+", ");
    System.out.print(c(100)+", ");
    System.out.print(c(599)+", ");
    System.out.print(c(760)+", ");
    System.out.print(c(1000)+", ");
    System.out.print(c(10000));
  }
}

산출:

1, 4, 1, 5, 8, 8, 2, 4, 3, 5

스몰 토크 – 270 바이트

정체성 tan⁻¹(x) = x − x³/3 + x⁵/5 − x⁷/7 ...과 그에 의존 합니다 π = 16⋅tan⁻¹(1/5) − 4⋅tan⁻¹(1/239). SmallTalk는 무제한 정밀도 정수 산술을 사용하므로 기꺼이 기다릴 경우 큰 입력에 작동합니다!

|l a b c d e f g h p t|l:=stdin nextLine asInteger+1. a:=1/5. b:=1/239. c:=a. d:=b. e:=a. f:=b. g:=3. h:=-1. l timesRepeat:[c:=c*a*a. d:=d*b*b. e:=h*c/g+e. f:=h*d/g+f. g:=g+2. h:=0-h]. p:=4*e-f*4. l timesRepeat:[t:=p floor. p:=(p-t)*10]. Transcript show:t printString;cr

pi.st다음 테스트 케이스에서와 같이 저장 하고 실행 하십시오 . 인덱싱은 하나의 기반입니다.

$ gst -q pi.st <<< 1
1
$ gst -q pi.st <<< 2
4
$ gst -q pi.st <<< 3
1
$ gst -q pi.st <<< 4
5
$ gst -q pi.st <<< 11
8
$ gst -q pi.st <<< 101
8
$ gst -q pi.st <<< 600
2
$ gst -q pi.st <<< 761
4
$ gst -q pi.st <<< 1001
3
$ gst -q pi.st <<< 10001 -- wait a long time!
5

JavaScript (Node.js) (Chrome 67+), 75 73 67 63 바이트

n=>`${eval(`for(a=c=100n**++n*20n,d=1n;a*=d;)c+=a/=d+++d`)}`[n]

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

$\pi/2=\sum_{k=0}^{\infty}k!/(2k+1)!!$

n=>`${eval(`for(a=c=100n**n*20n,d=1n;a*=d;)c+=a/=d+++d`)}`[n]

자바 스크립트 (Node.js) (Chrome 67+), 90 89 바이트

n=>`${eval(`for(a=100n**++n*2n,b=a-a/3n,c=0n,d=1n;w=a+b;a/=-4n,b/=-9n,d+=2n)c+=w/d`)}`[n]

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

$\pi/4=\arctan(1/2)+\arctan(1/3)$

n=>`${eval(`for(a=100n**n*2n,b=a-a/3n,c=0n,d=1n;w=a+b;a/=-4n,b/=-9n,d+=2n)c+=w/d`)}`[n]

메이플, 24 바이트

 trunc(10^(n+1)*Pi)mod 10

테스트 사례 :

> f:=n->trunc(10^(n+1)*Pi)mod 10;
> f(0);
  1
> f(1);
  4
> f(2);
  1
> f(3);
  5
> f(10);
  8
> f(100);
  8
> f(599);
  2
> f(760);
  4
> f(1000);
  3
> f(10000);
  5

C #, 252250 바이트

d=>{int l=(d+=2)*10/3+2,j=0,i=0;long[]x=new long[l],r=new long[l];for(;j<l;)x[j++]=20;long c,n,e,p=0;for(;i<d;++i){for(j=0,c=0;j<l;c=x[j++]/e*n){n=l-j-1;e=n*2+1;r[j]=(x[j]+=c)%e;}p=x[--l]/10;r[l]=x[l++]%10;for(j=0;j<l;)x[j]=r[j++]*10;}return p%10+1;}

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