Herausforderung :

Pi soll unendlich sein. Das bedeutet, dass jede Zahl im Dezimalteil von pi enthalten ist. Ihre Aufgabe wird es sein, bei der Eingabe eine positive Ganzzahl zu verwenden und die Position dieser Zahl in pi-Ziffern bei der Ausgabe zurückzugeben.

Wenn die Eingabe beispielsweise lautet 59, werden wir zurückkehren4

Hier ist der Grund: Wir werden nach der Zahl 59in den Ziffern von pi suchen

3.14159265...
     ^^

Der Wert beginnt bei der 4. Stelle, die Ausgabe erfolgt also 4.

Einige andere Beispiele:

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

Regeln:

• Sie müssen keine Ziffern verarbeiten, die nicht innerhalb der ersten 200 Ziffern vorhanden sind
• Standardlücken sind wie immer verboten.
• Das ist Codegolf , also gewinnt die geringere Anzahl an Bytes.

Python 2, 69 75 71 67 Bytes

4 Bytes wegen Caird Coinheringaahing gespeichert .

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

Nicht 3auf Position Null zu finden kostet 6 2 Bytes. Die Eingabe erfolgt als String.

Probieren Sie es online!

Ungebundene Version

Python 2, 224 Bytes

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

Verwendung eines unbegrenzten Zapfens, der auf der oben verwendeten Formel basiert.

Probieren Sie es online!

Schnellere Version

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

Ein viel schnellerer, unbegrenzter Zapfen, basierend auf Ramanujan Nr. 39 .

Probieren Sie es online!

Schale , 5 Bytes

€tİπd

Probieren Sie es online!

Erläuterung

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

=FIND(A1,"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196")

Excel verarbeitet nur 15 Dezimalstellen, daher ist pi nur hartcodiert. Dies sollte eine ziemlich schwache Obergrenze für diese Herausforderung sein.

Java 8, 615 217 202 184 182 166 165 Bytes (berechnet 999 200 Stellen)

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

Probieren Sie es online aus.

Math.PIWie viele andere Sprachen hat auch Java eine Genauigkeit von 15 Dezimalwerten. Um mehr Ziffern zu haben, müssen Sie diese mit BigIntegersoder selbst berechnen BigDecimals. Das oben genannte ist eine Möglichkeit , es zu tun .. Vielleicht Golf jemand kann dies unter 211 Bytes, lol ..
EDIT: einen Hafen Erstellt @primo ‚s Python 2 Antwort (stellen Sie sicher , ihn upvote!), So die Berechnung kürzer ist als hart -coded ist nicht mehr so ​​weit hergeholt. Nur noch 7 Bytes zum Golfen, damit es kürzer wird.

-15 Bytes dank @Neil , was es kürzer macht als die hartcodierte Antwort unten!
-36 Bytes dank @primo .
-1 Byte wechselt java.math.BigInteger t=null,T=t.TEN.pow(200),r=T;zu var T=java.math.BigInteger.TEN.pow(200);var r=T;, weil var1 Byte kürzer ist als null(ich muss das neue Java 10 lieben).

Erläuterung:

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 Bytes (200 Ziffern fest codiert)

"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196"::indexOf

0-indiziert

Probieren Sie es online aus.

05AB1E , 6 Bytes

₁žs¦¹k

Probieren Sie es online!

Wie?

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

MATL , 16 15 Bytes

YP8WY$4L)jXfX<q

Probieren Sie es online!

Erläuterung

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 + Nummernpaket, 52 Bytes

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

Probieren Sie es online!

dropletPiBerechnet die ersten 200 Dezimalstellen von pi, enthält aber 3.am Anfang ein, so dass wir das mit entfernen substringund dann mit abgleichen regexec, wodurch der Index der Übereinstimmung zusammen mit einigen Metadaten über die Übereinstimmung zurückgegeben wird.

Jelly , 23 Bytes

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

Ein monadischer Link, der eine Liste von Zeichen (die zu suchende Ganzzahl) akzeptiert und den Index zurückgibt. Funktioniert für Eingaben innerhalb der ersten 252 Stellen des Dezimalteils von π.

Probieren Sie es online!

Wie?

Hierbei werden nach der Leibniz-Formel für π die ersten 253 Stellen einschließlich der führenden 3(plus vier nachgestellten falschen Stellen) berechnet . Der führende Punkt 3wird dann gelöscht und der Index der Eingabe gefunden:

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

Wenn Sie eine Liste von Ziffern als Eingabe bevorzugen, verwenden Sie ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊw(auch 23), während Sie der Liste eine ganzzahlige Verwendung geben möchten ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊwD(für 24).

BASH (GNU / Linux), 75 67 66 Bytes

Dank Sophia Lechner 1 Byte und dank Cows Quack 7 Byte eingespart.

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

Dies ist ein Shell-Skript, das ein einziges Argument verwendet, nämlich die Zahl. Testen Sie mit

$ bash <script-path> 59
4

Dieses Skript führt zunächst eine Pipeline mit drei Befehlen aus:

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

Das Ergebnis dieser Pipeline wird der Shell-Variablen zugewiesen a, die dann mit Ausnahme der ersten entfernten Zahl als Echo ausgegeben wird:

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

Leider bchat die Tendenz, Ausgangsleitungen zu unterbrechen, wenn sie zu lang werden. Dies kann zu falschen Ergebnissen führen, wenn die zu findende Nummer nicht in der ersten Zeile steht. Sie können dies vermeiden, indem Sie die Umgebungsvariable festlegen BC_LINE_LENGTH:

export BC_LINE_LENGTH=0

Dadurch wird die Zeilenumbruchfunktion vollständig deaktiviert.

Offensichtlich können die letzten beiden Befehle weggelassen werden, wenn eine andere Ausgabe toleriert wird.
Dies ergibt eine Anzahl von 48 Bytes :

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

Mit der resultierenden Ausgabe:

$ 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: Danke, Neil !}

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

Nimmt eine Reihe von neunstelligen Ganzzahlen zur Basis 36, konvertiert sie zur Basis 10 und verknüpft sie, um die ersten 200 Stellen von pi zu erstellen.

Zum ersten Mal Code Golf spielen. Verwenden Sie Delegaten und Lambda-Ausdrücke, um die Funktionsaufrufe zu reduzieren. V2 verkürzt den Klassennamen in ein einzelnes Byte.

[C #], 361 355 Bytes

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

Formatierte Version:

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!

Ich habe die erste Version falsch gezählt. Es waren 361 Bytes, nicht 363 Bytes.

[C #], Version 218 Bytes

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

Probieren Sie es online!

Haskell , 208, 120 Bytes

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

Probieren Sie es online!

^{Vielen Dank an Jonathan Allan für seine Vorschläge!}

Alte Version (208 Bytes)

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

Ich weiß eigentlich nicht, wie der obige Code funktioniert; Ich habe es diesem Artikel entnommen und alles, was ich implementiert habe, war das Nachschlagen. g(1,0,1,1,3,3)gibt die Stellen von pi zurück und ist überraschend effizient (es berechnet 10 000 Stellen bei tio.run in weniger als 4s).

Die Eingabe ist eine Liste, die aus den Ziffern der zu findenden Nummer besteht.

Probieren Sie es online!

Haskell, 230 Bytes

Verwenden Sie Faulheit, um die Zahl irgendwo in den unendlichen Stellen von pi zu finden, nicht nur in den ersten 200 Stellen. Oh ja, und es gibt Ihnen jede (unendlich viele?) Instanz (en) der Nummer zurück, nicht nur die erste.

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]

Beispiele aus der Herausforderung

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

Credits

'p' ist der unendliche Strom von pi-Ziffern, entnommen aus 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 Bytes

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

Ziffern von pi werden fest codiert und in die ASCII-Werte von Zeichen gepackt. 14 ->CHR$(14) , 15 -> CHR$(15), 92 -> \, 65 -> A, 35 -> #.

Die Zeichenfolge enthält nicht druckbare Zeichen. Die folgenden Bytes sind hexadezimal geschrieben: 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

In Dezimalschrift sehen Sie die Ziffern von 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

Rubin , 37-35 Bytes

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

Probieren Sie es online!

Nichts Besonderes, nur die eingebaute Bibliothek. Der Ausgang ist 0-indiziert. Die Pi-Zeichenfolge ist wie folgt formatiert: 0.31415...e1Die ersten drei Zeichen müssen entfernt werden. Der e1Teil am Ende schadet nicht wirklich, wird aber ebenfalls entfernt, da wir ohnehin einen Wert für das Bereichsende (oder die Slice-Länge) angeben müssen.

Kohle , 27 15 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Funktioniert bis zu fast 1000 Stellen. Erläuterung:

        ≕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 Bytes

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

Da Japt die 15-stellige Pi-Einschränkung und das Shoco von Javascript verwendet, codiert die von Japt verwendete Codierung keine Zahlen. Für die Komprimierung sind einige Spielereien erforderlich.

Kurz erklärt, der Anfang ist die folgende Zeichenfolge in codierter Form:

"nqnrvosrpruvtvpopuqsosqppupotvrmouuqnvtnsvpvvptrnmruomvtqvqqrvopmtunsqmsousomuvvusoumpquorpqonntmstvuonqumusrnpouopmssqtmvpuqqsmvrrmruoopntorprvqmunouqunnntqrmouqnmotmnvpuronnmrrrvsqqsoovquvrqvpmpunvs"

Welches ist eine Zeichenfolge, in der jeder Buchstabe ist 'm' + corresponding digit of pi. Ich habe das gesamte Alphabet getestet und dieser Buchstabe bietet die beste Komprimierung um einige Bytes.

Backticks weisen Japt an, den String zu dekodieren. Der Rest ist ziemlich einfach:

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

Gibt den 0-basierten Index des übereinstimmenden Fragments aus.
Noch zwei Bytes weniger dank Oliver .

Probieren Sie es online!

AWK- M, 131 119 117 Bytes

Verwendet -MFlag für willkürliche Präzisionsberechnungen. Dem p=k=0TIO-Link wurden (5 Byte) hinzugefügt , um eine mehrzeilige Eingabe zu ermöglichen

{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

Probieren Sie es online!

Erläuterung:

{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

Gelee , 24 Bytes

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

Probieren Sie es online!

Verwenden Sie eine Machin-ähnliche Formel , insbesondere 1/4 pi == tan ^-1 (1/2) + tan ^-1 (1/3).

Verwenden Sie die Formel pi / 2 == 1 + 1/3 × (1 + 2/5 × (1 + 3/7 × (1 + 4/9 × (...)))

Python 2 239 238 229 214 Bytes

-9 Bytes aufgrund von @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

Verwendet den Chudnovsky-Ramanujan - Algorithmus und finden Sie die ersten 1 Million Ziffern 50000 Stellen von π (Änderung 10**10**5an 10**10**6für mehr, aber es dauert ewig zu laufen) , und dann sucht sie für die gewünschte Zeichenfolge.

Visual Basic - 114 Bytes

Okay, erste Vorlage. Sei nicht zu streng mit mir!

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

Feedback erwünscht!

Ich habe mich nicht auf die ersten 256 Teile von PI beschränkt, da die Frage "Das musst du nicht" und nicht "Das solltest du nicht" lautet. Hoffe, ich mache das richtig :)

Javascript 217 Bytes (200 fest codiert)

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

PHP, 27 Bytes

^{Keine sehr serielle Antwort, es erfordert eine Änderung der php.ini-Einstellungen, da pi () standardmäßig 14 Stellen hat, nicht 200, aber ausnahmsweise ist die PHP-Lösung ziemlich elegant:}

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

Julia 0,6 , 53 Bytes

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

Stellen Sie die Genauigkeit für BigFloats hoch genug ein, konvertieren Sie dann piin einen String und suchen Sie. Präzision der 9^6Griffe 159980 Stellen.

Probieren Sie es online!

J, 25 Bytes

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

Probieren Sie es online!

0-indiziert

Übernimmt die Eingabe als Zeichenfolge, +2 Bytes ( ":), wenn dies nicht zulässig ist.

Erklärung schließlich.

Perl 5 mit -MMath::BigFloat+bpiund -n, 20 Bytes

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

Probieren Sie es online!

Ich bin nicht sicher , wo der Gebrauch von $>Ständen, da es das ist , EFFECTIVE_USER_IDdie nicht tragbar ist, sondern auf TIO ist dies 1000 und erfüllt unsere Anforderung, für -1 Byte vs. 200.

Schale , 5 Bytes

€tİπd

Probieren Sie es 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.