Wyzwanie:

Pi ma być nieskończony. Oznacza to, że każda liczba jest zawarta w części dziesiętnej liczby pi. Twoim zadaniem będzie przyjęcie dodatniej liczby całkowitej na wejściu i zwrócenie pozycji tej liczby cyframi pi na wyjściu.

Na przykład, jeśli dane wejściowe są 59, wrócimy4

Oto dlaczego: szukamy liczby 59w cyfrach pi

3.14159265...
     ^^

Wartość zaczyna się od 4 cyfry, więc wyjście będzie 4.

Kilka innych przykładów:

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

Zasady:

• Nie musisz obsługiwać cyfr, które nie istnieją w ciągu pierwszych 200 cyfr
• Standardowe luki są, jak zawsze, zabronione.
• To jest codegolf , więc wygrywa mniej bajtów.

Python 2, 69 75 71 67 bajtów

Zaoszczędzono 4 bajty z powodu Cairney Coheringaahing .

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

Nie znajdowanie 3na pozycji zero kosztuje 6 2 bajty. Dane wejściowe są podawane jako ciąg.

Wypróbuj online!

Wersja bez ograniczeń

Python 2, 224 bajty

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

Korzystanie z niezwiązanego czopa opartego na tej samej formule, co powyżej.

Wypróbuj online!

Szybsza wersja

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

Znacznie szybszy niezwiązany czop, oparty na Ramanujan # 39 .

Wypróbuj online!

Łuska , 5 bajtów

€tİπd

Wypróbuj online!

Wyjaśnienie

€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 bajtów

=FIND(A1,"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196")

Excel obsługuje tylko 15 miejsc po przecinku, więc pi jest po prostu zakodowane na stałe. To powinno być dość słabe górne ograniczenie tego wyzwania.

Java 8, 615 217 202 184 182 182 166 165 bajtów (obliczone 999 200 cyfr)

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-indeksowany

Wypróbuj online.

Wbudowana Java Math.PIma dokładność 15 wartości dziesiętnych, podobnie jak wiele innych języków. Aby mieć więcej cyfr, musisz je obliczyć samodzielnie za pomocą BigIntegerslub BigDecimals. Powyższy sposób to zrobić. Może ktoś może zagrać w golfa poniżej 211 bajtów, lol ..
EDYCJA: Utworzono port odpowiedzi @primo na Python 2 (pamiętaj, aby go głosować!), Więc obliczanie jest krótsze niż trudne -coded nie jest już do tej pory pobierane. Jeszcze 7 bajtów do gry w golfa, aby był krótszy.

-15 bajtów dzięki @Neil , dzięki czemu jest krótszy niż na sztywno zakodowana odpowiedź poniżej!
-36 bajtów dzięki @primo .
-1 bajt zmienia się java.math.BigInteger t=null,T=t.TEN.pow(200),r=T;na var T=java.math.BigInteger.TEN.pow(200);var r=T;, ponieważ varjest o 1 bajt krótszy niż null(muszę pokochać nową Javę 10).

Wyjaśnienie:

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 bajtów (na stałe 200 cyfr)

"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196"::indexOf

0-indeksowane

Wypróbuj online.

05AB1E , 6 bajtów

₁žs¦¹k

Wypróbuj online!

W jaki sposób?

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

MATL , 16 15 bajtów

YP8WY$4L)jXfX<q

Wypróbuj online!

Wyjaśnienie

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

Pakiet numerów R +, 52 bajty

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

Wypróbuj online!

dropletPioblicza pierwsze 200 cyfr dziesiętnych z, piale zawiera 3.na początku, więc usuwamy to za pomocą, substringa następnie dopasowujemy do regexec, co zwraca indeks dopasowania wraz z pewnymi metadanymi dotyczącymi dopasowania.

Galaretka , 23 bajty

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

Monadyczny link akceptujący listę znaków (liczba całkowita do znalezienia) i zwracający indeks. Działa dla danych wejściowych zawartych w pierwszych 252 cyfrach części dziesiętnej π.

Wypróbuj online!

W jaki sposób?

Wykorzystuje to wzór Leibniza dla π do obliczenia pierwszych 253 cyfr, w tym wiodących 3(plus cztery niepoprawne cyfry końcowe). Prowadzenie 3jest następnie usuwane i znajduje się indeks danych wejściowych:

⁵*⁹Ḥ;ȷḊ+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

Jeśli wolisz listę cyfr jako wejściową ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊw(także 23), a jeśli naprawdę chcesz nadać jej liczbę całkowitą ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊwD(dla 24).

BASH (GNU / Linux), 75 67 66 bajtów

Zaoszczędzony 1 bajt dzięki Sophii Lechner i 7 bajtów dzięki szarlatanowi Krowy.

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

To jest skrypt powłoki, który przyjmuje pojedynczy argument, którym jest liczba. Przetestuj za pomocą

$ bash <script-path> 59
4

Ten skrypt najpierw wykonuje potok trzech poleceń:

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

Wynik tego potoku jest przypisywany do zmiennej powłoki a, która jest następnie wywoływana echem po usunięciu pierwszej liczby:

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

Niestety bcma tendencję do przerywania linii wyjściowych, gdy stają się zbyt długie. Może to prowadzić do błędnych wyników, jeśli znaleziony numer nie znajduje się w pierwszym wierszu. Można tego uniknąć, ustawiając zmienną środowiskową BC_LINE_LENGTH:

export BC_LINE_LENGTH=0

To całkowicie wyłącza funkcję łamania linii.

Oczywiście ostatnie dwa polecenia mogą zostać pominięte, jeśli inne dane wyjściowe są tolerowane.
Daje to liczbę 48 bajtów :

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

Z wynikowym wynikiem:

$ 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

JavaScript, 197 187

^{-10: Dzięki, Neil !}

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

Pobiera serię dziewięciocyfrowych liczb całkowitych base-36, konwertuje je na base 10 i łączy je, aby utworzyć pierwsze 200 cyfr liczby pi.

Pierwszy raz uprawiam golfa kodowego. Użyj delegatów i wyrażeń lambda, aby zredukować wywołania funkcji. V2 skraca nazwę klasy do jednego bajtu.

[C #], 361 355 bajtów

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"));}}

Wersja sformatowana:

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"));
    }
}

Ideone!

Uwaga: błędnie przeliczyłem pierwszą wersję. Miał 361 bajtów, a nie 363 bajtów.

[C #], tio wersja 218 bajtów

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

Wypróbuj online!

Haskell , 208 120 bajtów

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

Wypróbuj online!

^{Bardzo dziękuję Jonathanowi Allanowi za jego sugestie!}

Stara wersja (208 bajtów)

(+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

Tak naprawdę nie wiem, jak działa powyższy kod; Wziąłem go z tego artykułu i wszystko, co wdrożyłem, to część przeglądowa. g(1,0,1,1,3,3)zwraca cyfry pi i jest zaskakująco skuteczny (oblicza 10 000 cyfr na tio.run w mniej niż 4 s).

Dane wejściowe to lista składająca się z cyfr numeru, który można znaleźć.

Wypróbuj online!

Haskell, 230 bajtów

Używanie lenistwa do znajdowania numeru w dowolnym miejscu nieskończonych cyfr pi, nie tylko pierwszych 200 cyfr. O tak, i zwraca ci każdą (nieskończenie wiele) liczbę wystąpień liczby, nie tylko pierwszą.

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]

Przykłady z wyzwania

>  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]

Kredyty

„p” to nieskończony strumień cyfr pi, zaczerpnięty z https://rosettacode.org/wiki/Pi#Haskell

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

SmileBASIC, 179 164 bajtów

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

Cyfry pi są zakodowane na stałe i pakowane w wartości ascii znaków. 14 -> CHR$(14), 15 -> CHR$(15), 92 -> \, 65 -> A, 35 -> #.

Ciąg zawiera znaki niedrukowalne, więc oto bajty zapisane szesnastkowo: 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

W systemie dziesiętnym widoczne są cyfry 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

Rubinowy , 37 35 bajtów

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

Wypróbuj online!

Nic specjalnego, tylko prezentacja wbudowanej biblioteki. Wyjście jest indeksowane na 0. Łańcuch Pi jest sformatowany jako 0.31415...e1, więc musimy usunąć pierwsze 3 znaki. e1Część w końcu naprawdę nie wyrządzić żadnej szkody, ale odpędza się też, że musimy zapewnić końcowy zakres (lub długość Slice) wartość tak.

Węgiel drzewny , 27 15 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Działa do prawie 1000 cyfr. Wyjaśnienie:

        ≕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 bajtów

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

Ponieważ Japt dzieli 15-cyfrowe ograniczenie Javascript i pi sho , kodowanie stosowane przez Japt nie koduje liczb, niektóre shenanigany są wymagane do kompresji.

Krótko wyjaśnione, początek jest poniższym ciągiem w postaci zakodowanej:

"nqnrvosrpruvtvpopuqsosqppupotvrmouuqnvtnsvpvvptrnmruomvtqvqqrvopmtunsqmsousomuvvusoumpquorpqonntmstvuonqumusrnpouopmssqtmvpuqqsmvrrmruoopntorprvqmunouqunnntqrmouqnmotmnvpuronnmrrrvsqqsoovquvrqvpmpunvs"

Który jest ciągiem, w którym znajduje się każda litera 'm' + corresponding digit of pi. Przetestowałem cały alfabet i ta litera zapewnia najlepszą kompresję o kilka bajtów.

Backticks nakazują Japtowi odkodować ciąg. Reszta jest dość prosta:

®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.

Zwraca indeks pasującego fragmentu na podstawie 0.
Ogolił kolejne dwa bajty dzięki Oliverowi .

Wypróbuj online!

AWK- M, 131 119 117 bajtów

Używa -Mflagi do dowolnych obliczeń precyzji. Dodano p=k=0(5 bajtów) do łącza TIO, aby umożliwić wprowadzanie wielu wierszy

{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

Wypróbuj online!

Wyjaśnienie:

{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

Galaretka , 24 bajty

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

Wypróbuj online!

Użyj formuły podobnej do Machina , a konkretnie 1/4 pi == tan ^-1 (1/2) + tan ^-1 (1/3).

Użyj wzoru pi / 2 == 1 + 1/3 × (1 + 2/5 × (1 + 3/7 × (1 + 4/9 × (...))))

Python 2 239 238 229 214 bajtów

-9 bajtów z powodu @primo

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

Wykorzystuje algorytm Chudnovsky-Ramanujan aby znaleźć pierwsze 1 mln cyfry 50000 cyfr Õ (zmiana 10**10**5na 10**10**6dłużej, ale to trwa wieki, aby uruchomić), a następnie przeszukuje je w żądanej ciąg.

Visual Basic - 114 bajtów

Dobra, pierwsze zgłoszenie. Uspokój się!

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

Witamy mile widziane!

Nie ograniczyłem się do pierwszych 256 części PI, ponieważ pytanie brzmi „Nie musisz”, a nie „Nie powinieneś” Mam nadzieję, że robię to dobrze :)

JavaScript 217 bajtów (200 na stałe)

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

PHP, 27 bajtów

^{Niezbyt serieusowa odpowiedź, wymaga zmiany ustawień php.ini, ponieważ domyślnie pi () ma 14 cyfr, a nie 200, ale raz rozwiązanie PHP jest dość eleganckie:}

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

Julia 0.6 , 53 bajty

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

Ustaw wystarczająco wysoką precyzję dla BigFloats, a następnie przekonwertuj pina ciąg i wyszukaj. Precyzja 9^6uchwytów 159980 cyfr.

Wypróbuj online!

J, 25 bajtów

{.I.(}.":<[email protected]^999)E.~

Wypróbuj online!

Indeksowane 0

Pobiera dane wejściowe jako ciąg znaków, +2 Bytes ( ":), jeśli nie jest to dozwolone.

Wyjaśnienie w końcu.

Perl 5 z -MMath::BigFloat+bpia -n, 20 bajtów

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

Wypróbuj online!

Nie jestem pewien, gdzie korzystanie z $>trybun, ponieważ jest to EFFECTIVE_USER_ID, co nie jest przenośny, ale na TIO to 1000 i spełnia nasze wymagania, do -1 bajt vs 200.

Łuska , 5 bajtów

€tİπd

Wypróbuj online!

€        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.