도전 :

파이는 무한해야합니다. 즉, 모든 숫자는 pi의 소수 부분에 포함됩니다. 당신의 임무는 입력시 양의 정수를 취하고 출력 시이 숫자의 위치를 ​​pi 자리로 반환하는 것입니다.

입력이 경우 예를 들어 59, 우리는 돌아갑니다4

이유는 다음과 같습니다.59 pi의 숫자로 숫자를 찾습니다.

3.14159265...
     ^^

값은 네 번째 자리에서 시작하므로 출력은입니다 4.

다른 예 :

input : 1      output : 1
input : 65     output : 7
input : 93993  output : 42
input : 3      output : 9

규칙 :

• 처음 200 자리 안에 존재하지 않는 숫자는 처리하지 않아도됩니다.
• 표준 허점은 항상 금지되어 있습니다.
• 이것은 codegolf 이므로 적은 바이트가 이깁니다.

파이썬 2, 69 75 71 67 바이트

caird coinheringaahing 으로 인해 4 바이트가 절약되었습니다 .

x=p=1333
while~-p:x=p/2*x/p+2*10**200;p-=2
print`x`.find(input(),1)

3위치 0에서 찾지 못하면 6 2 바이트가 소요 됩니다. 입력은 문자열로 제공됩니다.

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

무제한 버전

파이썬 2, 224 바이트

def g():
 q,r,t,i,j=1,0,1,0,1
 while True:
  i+=1;j+=2;q,r,t=q*i,(2*q+r)*j,t*j;n=(q+r)/t
  if n*t>4*q+r-t:yield n;q,r=10*q,10*(r-n*t)
a=input()
l=len(`a`)
s=z=10**l;i=1-l
p=g().next;p()
while s!=a:s=(s*10+p())%z;i+=1
print i

위에서 사용한 것과 동일한 공식을 기반으로 무제한 스피 곳 사용.

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

빠른 버전

from gmpy2 import mpz
def g():
  # Ramanujan 39, multi-digit
  q, r, s ,t = mpz(0), mpz(3528), mpz(1), mpz(0)
  i = 1
  z = mpz(10)**3511
  while True:
    n = (q+r)/(s+t)
    if n == (22583*i*q+r)/(22583*i*s+t):
      for d in digits(n, i>597 and 3511 or 1): yield d
      q, r = z*(q-n*s), z*(r-n*t)
    u, v, x = mpz(1), mpz(0), mpz(1)
    for k in range(596):
      c, d, f = i*(i*(i*32-48)+22)-3, 21460*i-20337, -i*i*i*24893568
      u, v, x = u*c, (u*d+v)*f, x*f
      i += 1
    q, r, s, t = q*u, q*v+r*x, s*u, s*v+t*x

def digits(x, n):
  o = []
  for k in range(n):
    x, r = divmod(x, 10)
    o.append(r)
  return reversed(o)

a=input()
l=len(`a`)
s=z=10**l;i=1-l
p=g().next;p()
while s!=a:s=(s*10+p())%z;i+=1
print i

Ramanujan # 39 기반으로 훨씬 더 빠른 무제한 스피 곳 .

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

껍질 , 5 바이트

€tİπd

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

설명

€tİπd                              59
    d  Convert to base-10 digits   [5,9]
  İπ     The digits of pi          [3,1,4,1,5,9..]
 t       Remove the first element  [1,4,1,5,9,2..]
€      Index of the sublist        4

Excel, 212 바이트

=FIND(A1,"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196")

Excel은 소수점 이하 15 자리 만 처리하므로 pi는 하드 코딩됩니다. 이것은이 도전에 대한 약한 상한이어야합니다.

자바 (8) 615 217 202 184 182 166 165 바이트 (연산 999 200 자리)

n->{var t=java.math.BigInteger.TEN.pow(200);var r=t;for(int p=667;p-->1;)r=t.valueOf(p).multiply(r).divide(t.valueOf(p-~p)).add(t).add(t);return(r+"").indexOf(n,1);}

1- 색인

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

Java의 내장 Math.PI은 다른 많은 언어와 같이 15 자리의 정밀도 를가 집니다. 더 많은 자릿수를 얻으려면 BigIntegers또는로 직접 숫자를 계산해야합니다 BigDecimals. 이것은 위의 방법입니다. 어쩌면 누군가가 211 바이트 이하로 골프
를 칠 수 있습니다 . lol .. 편집 : @primo 의 Python 2 답변 포트를 만들었습니다 (그를 공표 해야합니다!), 하드보다 짧은 계산 -coded는 더 이상 가져 오지 않습니다. 짧아지기 위해서는 골프에 7 바이트 만 더 넣으십시오.

@Neil 덕분에 -15 바이트 덕분에 아래의 하드 코딩 된 답변보다 짧습니다! @primo
덕분에 -36 바이트 . -1 바이트의 변화 를 하기 때문에, 1 바이트보다 짧다 (꼭 사랑 새로운 자바 10).
java.math.BigInteger t=null,T=t.TEN.pow(200),r=T;var T=java.math.BigInteger.TEN.pow(200);var r=T;varnull

설명:

n->{                            // Method with String parameter and integer return-type
  var t=java.math.BigInteger.TEN.pow(200);
                                //  Temp BigInteger with value 10^200
  var r=t;                      //  Result BigInteger, also starting at 10^200
  for(int p=667;                //  Index-integer, starting at 667
      p-->1;)                   //  Loop as long as this integer is still larger than 1
                                //  (decreasing `p` by 1 before every iteration with `p--`)
    r=                          //   Replace the Result BigInteger with:
      t.valueOf(p)              //    `p`
       .multiply(r)             //    multiplied by `r`,
       .divide(t.valueOf(p-~p)) //    divided by `2*p+1`
       .add(t).add(t);          //    And add 2*10^200
  return(r+"")                  //  Convert the BigInteger to a String
    .indexOf(n,                 //  And return the index of the input,
               1);}             //  skipping the 3 before the comma

Java 8, 211 바이트 (하드 코드 200 자리)

"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196"::indexOf

0 인덱스

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

05AB1E , 6 바이트

₁žs¦¹k

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

방법?

₁        push 256
 žs      push pi to 256 places
   ¦     remove the leading 3
    ¹    push the input
     k   index inside that string

MATL , 16 15 바이트

YP8WY$4L)jXfX<q

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

설명

YP     % Push pi as a double
8W     % Push 2^8, that is, 256
Y$     % Compute pi with 256 significant digits using variable-precision arithmetic
       % The result as a string
4L)    % Remove first character. This is to avoid finding '3' in the integer part
       % of pi
j      % Push input as a string
Xf     % Strfind: gives array of indices of occurrences of the input string in the
       % pi string
X<     % Mimimum
q      % Subtract 1. Implicitly display

R + 숫자 패키지, 52 바이트

regexec(scan(),substring(numbers::dropletPi(200),3))

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

dropletPi의 첫 번째 200 진수를 계산 pi하지만이 포함되어 3.우리가 가진 것을 스트립, 그래서 처음에 substring일치 다음과 regexec경기에 대한 몇 가지 메타 데이터와 함께 경기의 인덱스를 반환합니다.

젤리 , 23 바이트

⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SṾḊw

문자 목록 (찾을 정수)을 승인하고 색인을 리턴하는 모나드 링크. π의 소수점 이하 자릿수 252 자리에 포함 된 입력에 사용됩니다.

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

방법?

이것은 π 에 Leibniz 공식을 사용하여 선행을 포함하여 처음 253 자리 숫자 3(앞에 잘못된 4 자리 숫자) 를 계산합니다 . 3그런 다음 행간 을 삭제하고 입력 색인을 찾습니다.

⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SṾḊw - Link: list of characters
⁵                       - literal ten
  ⁹                     - literal 256
 *                      - exponentiate = 10000...0 (256 zeros)
   Ḥ                    - double       = 20000...0
          ¤             - nilad followed by links as a nilad:
     ȷ                  -   literal 1000
      Ḋ                 -   dequeue -> [2,3,4,5,...,1000]
         $              -   last two links as a monad:
        J               -     range of length -> [1,2,3,4,...,999]
       +                -     addition (vectorises) -> [3,5,7,9,...,1999]
    ;                   -   concatenate -> [20000...0,3,5,7,9,...,1999]
                  \     - cumulative reduce with:
                 ɗ      -   last three links as a dyad:
               ¤        -     nilad followed by link(s) as a nilad:
            ⁹           -       chain's right argument (the right of the pair as we traverse the pairs in the list -- 3, 5, 7, 9, ...)
              2         -       literal two
             :          -       integer division (i.e. 1, 2, 3, ...)
           ×            -     multiply (the left of the pair, the "current value", by that)
                :       -   integer divide by the right argument (i.e. 3, 5, 7, 9, ...)
                   S    - sum up the values (i.e. 20000...0 + 66666...6 + 26666...6 + 11428...2 + ... + 0)
                    Ṿ   - un-evaluate (makes the integer become a list of characters)
                     Ḋ  - dequeue (drop the '3')
                      w - first (1-based) index of sublist matching the input

입력 목록으로 숫자 목록을 선호하는 경우 ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊw(23) 또한 정수로 사용하려면 ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊwD(24).

배쉬 (GNU / Linux), 75 67 66 바이트

Sophia Lechner 덕분에 1 바이트를 절약하고 Cows quack 덕분에 7 바이트를 절약했습니다.

a=`bc -l<<<"scale=999;4*a(1)"|tail -c+2|grep -ob $1`;echo ${a%%:*}

이것은 하나의 인수 인 숫자 인 쉘 스크립트입니다. 로 테스트

$ bash <script-path> 59
4

이 스크립트는 먼저 세 가지 명령으로 구성된 파이프 라인을 실행합니다.

bc -l<<<"scale=999;4*a(1)"|    #produce pi with its first 999 fractional digits
tail -c+2|                     #cut off the "3."
grep -ob $1                    #compute the byte offsets of our argument in the string

이 파이프 라인의 결과는 셸 변수에 할당 된 a다음 첫 번째 숫자를 제외하고는 에코됩니다.

a=`...`;         #assign the result of the pipeline to a variable
echo ${a%%:*}    #cleave off the first : character and anything following it

불행히도, bc출력 라인이 너무 길어지면 출력 라인을 끊는 경향이 있습니다. 찾은 번호가 첫 번째 행에 없으면 잘못된 결과가 발생할 수 있습니다. 환경 변수를 설정하여 피할 수 있습니다 BC_LINE_LENGTH.

export BC_LINE_LENGTH=0

줄 바꿈 기능이 완전히 비활성화됩니다.

분명히 다른 출력이 허용되는 경우 마지막 두 명령을 생략 할 수 있습니다.
이것은 48 바이트 수를 제공 합니다 .

bc -l<<<"scale=999;4*a(1)"|tail -c+2|grep -ob $1

결과 출력으로 :

$ bash <script-path> 59
4:59
61:59
143:59
179:59
213:59
355:59
413:59
415:59
731:59
782:59
799:59
806:59
901:59
923:59
940:59
987:59

자바 스크립트, 197 187

^{-10 : 고마워, 닐 !}

x=>"50ood0hab15bq91k1j9wo6o2iro3by0h94bg3geu0dnnq5tcxz7lk62855h72el61sx7vzsm1thzibtd23br5tr3xu7wsekkpup10cek737o1gcr6t00p3qpccozbq0bfdtfmgk".replace(/.{9}/g,a=>parseInt(a,36)).search(x)+1

일련의 9 자리 base-36 정수를 취하여 10 진수로 변환 한 다음 연결하여 pi의 처음 200 자리를 만듭니다.

코드 골프를 처음으로. 델리게이트 및 람다 식을 사용하여 함수 호출을 줄입니다. V2는 클래스 이름을 단일 바이트로 줄입니다.

[기음#], 361 355 바이트

using System;class P{static void Main(){Func<string,int>F=f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1;Action<int>w=Console.WriteLine;w(F("1"));w(F("65"));w(F("93993"));w(F("3"));}}

형식화 된 버전 :

using System;

class P
{
    static void Main()
    {
        Func<string,int>F=f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1;
        Action<int>w=Console.WriteLine;
        w(F("1"));
        w(F("65"));
        w(F("93993"));
        w(F("3"));
    }
}

이데온!

NB. 나는 첫 번째 버전을 잘못 계산했습니다. 363 바이트가 아니라 361 바이트였습니다.

[C #], 티오 버전 218 바이트

f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1

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

하스켈 , 208120 바이트

a=1333
x=tail$show$foldr(\p x->p`div`2*x`div`p+2*10^200)a[3,5..a]
x!n|take(length n)x==n=0|1<2=1+tail x!n
f n=1+x!show n

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

^{Jonathan Allan 에게 많은 감사그의 제안에 대해 에게 !}

이전 버전 (208 바이트)

(+1).((tail$g(1,0,1,1,3,3))!)
g(q,r,t,k,n,l)=([n:g(10*q,10*(r-n*t),t,k,div(10*(3*q+r))t-10*n,l)|4*q+r-t<n*t]++[g(q*k,(2*q+r)*l,t*l,k+1,div(q*(7*k+2)+r*l)(t*l),l+2)])!!0
x!n|take(length n)x==n=0|1<2=1+tail x!n

실제로 위의 코드가 어떻게 작동하는지 모르겠습니다. 이 백서 에서 가져 왔으며 구현 한 부분은 조회 부분이었습니다. g(1,0,1,1,3,3)pi의 자릿수를 반환하고 놀랍도록 효율적입니다 (tio.run에서 4 초 미만으로 10,000 자릿수를 계산합니다).

입력은 찾을 숫자의 숫자로 구성된 목록입니다.

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

하스켈, 230 바이트

laziness를 사용하여 처음 200 자리가 아닌 pi의 무한 자리에서 숫자를 찾습니다. 아, 그리고 그것은 첫 번째 인스턴스뿐만 아니라 숫자의 모든 (무한 수?) 인스턴스를 반환합니다.

p=g(1,0,1,1,3,3)where g(q,r,t,k,n,l)=if 4*q+r-t<n*t then n:g(10*q,10*(r-n*t),t,k,div(10*(3*q+r))t-10*n,l) else g(q*k,(2*q+r)*l,t*l,k+1,div(q*(7*k+2)+r*l)(t*l),l+2)
z n=[(i,take n$drop i p)|i<-[1..]]
f l=[n|(n,m)<-z$length l,m==l]

도전의 예

>  take 10 $ f [1]
[1,3,37,40,49,68,94,95,103,110]
>  take 10 $ f [6,5]
[7,108,212,239,378,410,514,672,870,1013]
>  take 1 $ f [9,3,9,9,3]
[42]
>  take 10 $ f [3]
[9,15,17,24,25,27,43,46,64,86]

크레딧

'p'는 https://rosettacode.org/wiki/Pi#Haskell 에서 가져온 무한한 pi 자리 스트림입니다.

> take 20 p
[3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4]

스마일, 179 164 바이트

INPUT I$FOR I=0TO 103Q$=Q$+STR$(ASC("\A#YO &.+& O2TGE']KiRa1,;N(>VYb>P0*uCb0V3 RB/]T._2:H5;(Q0oJ2)&4n7;@.^Y6]&"[I]))NEXT?INSTR(Q$,I$)+1

pi의 숫자는 하드 코딩되어 문자의 ASCII 값으로 압축됩니다. 14->CHR$(14) , 15->CHR$(15) , 92-> \, 65-> A, 35-> #.

문자열에는 인쇄 할 수없는 문자가 포함되어 있으므로 16 진수로 쓴 바이트는 다음과 같습니다. 0E 0F 5C 41 23 59 4F 20 26 2E 1A 2B 26 20 4F 32 1C 54 13 47 45 27 5D 4B 69 52 00 61 31 2C 3B 17 00 4E 10 28 3E 56 14 59 62 3E 50 03 30 19 03 2A 75 00 43 62 15 30 00 56 33 20 52 1E 42 2F 00 5D 54 2E 00 5F 32 3A 16 1F 48 35 3B 28 51 1C 30 6F 4A 32 1C 29 00 1B 00 13 26 34 6E 37 3B 40 2E 16 5E 59 36 5D 00 26 13 06

십진수로 pi의 숫자를 볼 수 있습니다. 14 15 92 65 35 89 79 32 38 46 26 43 38 32 79 50 28 84 19 71 69 39 93 75 105 82 0 97 49 44 59 23 0 78 16 40 62 86 20 89 98 62 80 3 48 25 3 42 117 0 67 98 21 48 0 86 51 32 82 30 66 47 0 93 84 46 0 95 50 58 22 31 72 53 59 40 81 28 48 111 74 50 28 41 0 27 0 19 38 52 110 55 59 64 46 22 94 89 54 93 0 38 19 6

루비 , 37 35 바이트

p"#{BigMath::PI 200}"[3..-3]=~/#$_/

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

내장 라이브러리를 보여주는 특별한 것은 없습니다. 출력은 0 인덱스입니다. Pi 문자열은 형식으로 0.31415...e1되어 있으므로 처음 3자를 제거해야합니다. 마지막 e1부분은 실제로 아무런 해를 끼치 지 않지만 어쨌든 범위 끝 (또는 슬라이스 길이) 값을 제공해야하기 때문에 제거됩니다.

숯 , 27 15 바이트

Ｉ⊖∨⌕Ｉ▷N⟦≕Piφ⟧θχ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 거의 1000 자리까지 작동합니다. 설명:

        ≕Pi     Get variable `Pi`
           φ    Predefined variable 1000
     ▷N⟦    ⟧   Evaluate variable to specified precision
    Ｉ           Cast to string
             θ  First input
   ⌕            Find
              χ Predefined variable 10
   ∨             Logical OR
  ⊖              Decrement
 Ｉ               Cast to string
                 Implicitly print

JAPT , 186 177 바이트

`nqnrvosrpruvtvpopuqsosqppÕÝvr¶uuqnvtnsvpvvptrnmruomvtqvqqrvopmÉæqÛàÑ$vvÔàmpqupqm¡vuqum«rnpopmssqtmvpuqqsmvrrmruoopÌÊprvqÛ$uqunnqr¶uqn¶tmnvpÔnmrrrvsqqsoovquvrqvpmpunvs`®c -#mÃbU

Japt가 Javascript의 15 자리 Pi 제한 조건 및 shoco를 공유하므로 , JAPT에서 사용하는 인코딩하지 않습니다 인코딩 번호, 일부 헛소리는 압축이 필요합니다.

간단히 설명하면 시작 부분은 인코딩 된 형식의 아래 문자열입니다.

"nqnrvosrpruvtvpopuqsosqppupotvrmouuqnvtnsvpvvptrnmruomvtqvqqrvopmtunsqmsousomuvvusoumpquorpqonntmstvuonqumusrnpouopmssqtmvpuqqsmvrrmruoopntorprvqmunouqunnntqrmouqnmotmnvpuronnmrrrvsqqsoovquvrqvpmpunvs"

각 문자가있는 문자열입니다 'm' + corresponding digit of pi . 나는 전체 알파벳을 테스트했으며 그 문자는 몇 바이트로 최고의 압축을 제공합니다.

백틱은 Japt에게 문자열을 해독하도록 지시합니다. 나머지는 매우 간단합니다.

®c -#mÃbU
®          // Given the above string, map each letter
 c         // and return its charcode
   -#m     // minus the charcode of 'm', 109.
      Ã    // When that's done,
        bU // find the index of the implicit input U.

일치하는 조각의 인덱스 (0부터 시작)를 출력합니다. Oliver
덕분에 2 바이트를 더 줄 였습니다.

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

AWK -M, 131 (119) 117 바이트

-M임의 정밀도 계산에 플래그를 사용합니다 . p=k=0멀티 라인 입력을 허용하기 위해 TIO 링크에 (5 바이트) 추가

{CONVFMT="%.999f";PREC=1e3;for(p=k=0;k<1e3;)p+=(4/(8*k+1)-2/(8*k+4)-1/(8*k+5)-1/(8*k+6))/16^k++;$0=$1==3?9:index(p,$1)-2}1

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

설명:

{CONVFMT="%.999f";  # Allows 999 decimal digits to be used when numbers are convert to strings
PREC=1e3;           # Digits of precision to use for calculations
for(;k<1e3;)p+=(4/(8*k+1)-2/(8*k+4)-1/(8*k+5)-1/(8*k+6))/16^k++; # The most concise numerical calculation I could find. It doesn't converge  extremely rapidly, but it seems to work OK
$0=$1==3?9:index(p,$1)-2}  # Replace input line with either 9 or index-2
                           # since indices will either be 1 (meaning 3 was input) or >= 3
1                   # Print the "new" input line

젤리 , 24 바이트

ȷ*
ȷR×¢:Ḥ‘$ƲU×:¢+¢ʋ/ḤṾḊw

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

Machin과 같은 공식을 사용하십시오. 구체적으로 1/4 pi == tan ^-1 (1/2) + tan ^-1 (1/3).

pi / 2 == 1 + 1/3 × (1 + 2/5 × (1 + 3/7 × (1 + 4/9 × (...))) 공식 사용)

파이썬 2 239 238 229 214 바이트

@primo 로 인해 -9 바이트

from bigfloat import*;a=s=n=10**10**5;b=k=0
while a:k+=1;a*=k*(k*(108-72*k)-46)+5;a/=k**3*(640320**3/24);s+=a;b+=k*a
with precision(10**7):print`(426880*sqrt(10005*n)*n)/(13591409*s+545140134*b)`.find(input())-16

Chudnovsky-에 Ramanujan 알고리즘을 사용하는 첫 번째 찾을 수 1 개 백만 자리를 (변경 π의 50000 개 자리 10**10**5에 10**10**6이상을,하지만 실행에 나이 소요) 원하는 문자열을 다음 검색을.

Visual Basic-114 바이트

자, 첫 제출. 쉬워요!

    Dim s,p As String
    s=Console.Readline()
    p=Math.PI
    Console.Write((p.IndexOf(s,2)-1))

피드백 환영합니다!

질문에 "필요하지 않음"이 아니라 "올바른 일이 아니길 바랍니다"라는 질문에 따라 PI의 처음 256 개 부분으로 제한되지 않았습니다.

자바 스크립트 217 바이트 (200 개의 하드 코드)

a=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".search(a)+1

PHP, 27 바이트

^{serieus의 대답은 아니지만, php.ini 설정은 pi ()의 기본값이 200이 아닌 14 자리로 변경되어야하지만, PHP 솔루션이 상당히 우아 해지면 다음과 같이 변경해야합니다.}

<?=strpos(pi(),$_GET[n])-1;

줄리아 0.6 , 53 바이트

setprecision(9^6)
x->searchindex("$(big(π))","$x",3)

BigFloats의 정밀도를 충분히 높게 설정 한 다음 pi문자열 로 변환 하고 검색하십시오. 9^6핸들의 정밀도 는 159980 자리입니다.

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

J, 25 바이트

{.I.(}.":<.@o.10x^999)E.~

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

0 인덱스

입력을 +2 바이트 (":허용되지 않으면 )를 합니다.

결국 설명합니다.

5 펄 로 -MMath::BigFloat+bpi하고 -n, 20 바이트를

bpi($>)=~/.$_/;say@-

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

$>스탠드의 사용 위치 는 확실 EFFECTIVE_USER_ID하지 않습니다. 휴대용이 아니기 때문에 TIO에서는 1000이며 -1 바이트 대에 대한 요구 사항을 충족시킵니다 200.

껍질 , 5 바이트

€tİπd

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

€        The 1-based index as a substring of
    d    the decimal digits of
         the input
  İπ     in the infinite list of digits of pi
 t       after the radix point.