Desafío:

Se supone que Pi es infinito. Eso significa que cada número está contenido dentro de la parte decimal de pi. Su tarea será tomar un número entero positivo en la entrada y devolver la posición de este número en dígitos pi en la salida.

Por ejemplo, si la entrada es 59, volveremos4

He aquí por qué: buscaremos el número 59en los dígitos de pi

3.14159265...
     ^^

El valor comienza en el cuarto dígito, por lo que la salida será 4.

Algunos otros ejemplos:

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

Reglas :

• No tiene que manejar dígitos que no existen dentro de los primeros 200 dígitos
• Las lagunas estándar están, como siempre, prohibidas.
• Esto es codegolf , por lo que gana menos bytes.

Python 2, 69 75 71 67 bytes

Guardado 4 bytes debido a caird coinheringaahing .

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

No encontrar 3en la posición cero cuesta 6 2 bytes. La entrada se da como una cadena.

Pruébalo en línea!

Versión sin límites

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

Usando una espita sin límites basada en la misma fórmula utilizada anteriormente.

Pruébalo en línea!

Versión más rápida

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

Una espita ilimitada mucho más rápida, basada en Ramanujan # 39 .

Pruébalo en línea!

Casco , 5 bytes

€tİπd

Pruébalo en línea!

Explicación

€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 solo maneja 15 decimales, por lo que pi solo está codificado. Este debería ser un límite superior bastante débil para este desafío.

Java 8, 615 217 202 184 182 166 165 bytes (calculado 999 200 dígitos)

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 indexado

Pruébalo en línea.

El código incorporado de Java Math.PItiene una precisión de 15 valores decimales, como muchos otros idiomas. Para tener más dígitos, deberá calcularlos usted mismo con BigIntegerso BigDecimals. Esto es una forma de hacerlo. Tal vez alguien pueda jugar golf por debajo de 211 bytes, jajaja.
EDITAR: creó un puerto de la respuesta de Python 2 de @primo ( ¡ asegúrate de votarlo !), Así que calcular ser más corto que difícil -coded ya no es tan descabellado. Solo 7 bytes más para jugar golf para que sea más corto.

-15 bytes gracias a @Neil , lo que lo hace más corto que la respuesta codificada a continuación.
-36 bytes gracias a @primo .
-1 byte cambiando java.math.BigInteger t=null,T=t.TEN.pow(200),r=T;a var T=java.math.BigInteger.TEN.pow(200);var r=T;, porque vares 1 byte más corto que null(tengo que amar el nuevo Java 10).

Explicación:

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 dígitos codificados)

"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196"::indexOf

0 indexado

Pruébalo en línea.

05AB1E , 6 bytes

₁žs¦¹k

Pruébalo en línea!

¿Cómo?

₁        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

Pruébalo en línea!

Explicación

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

Paquete de números R +, 52 bytes

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

Pruébalo en línea!

dropletPicalcula los primeros 200 dígitos decimales de pipero incluye un 3.al principio, por lo que eliminamos eso substringy luego lo combinamos regexec, lo que devuelve el índice de la coincidencia junto con algunos metadatos sobre la coincidencia.

Jalea , 23 bytes

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

Un enlace monádico que acepta una lista de caracteres (el entero para buscar) y devuelve el índice. Funciona para entradas contenidas dentro de los primeros 252 dígitos de la parte decimal de π.

Pruébalo en línea!

¿Cómo?

Utiliza la fórmula de Leibniz para π para calcular los primeros 253 dígitos, incluidos los primeros 3(más cuatro dígitos incorrectos finales). El líder 3se deja caer a continuación, y se encuentra el índice de la entrada:

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

Si prefiere una lista de dígitos como uso de entrada ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊw(también 23), mientras que si realmente desea darle un uso entero ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊwD(para 24).

BASH (GNU / Linux), 75 67 66 bytes

Guardado 1 byte gracias a Sophia Lechner, y 7 bytes gracias a Cows quack.

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

Este es un script de shell que toma un solo argumento, que es el número. Prueba con

$ bash <script-path> 59
4

Este script primero ejecuta una tubería de tres comandos:

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

El resultado de esta tubería se asigna a la variable de shell a, que luego se repite con cualquier cosa que no sea el primer número eliminado:

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

Desafortunadamente, bctiene la tendencia a romper las líneas de salida cuando se vuelven demasiado largas. Esto puede conducir a resultados incorrectos si el número que se encuentra no está en la primera línea. Puede evitar eso configurando la variable de entorno BC_LINE_LENGTH:

export BC_LINE_LENGTH=0

Esto desactiva la función de salto de línea por completo.

Obviamente, los dos últimos comandos pueden omitirse si se tolera otra salida.
Esto da un recuento de 48 bytes :

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

Con la salida resultante:

$ 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: ¡Gracias Neil !}

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

Toma una serie de enteros de base 36 de nueve dígitos, los convierte en base 10 y los concatena para crear los primeros 200 dígitos de pi.

Primera vez haciendo código golf. Use delegados y expresiones lambda para reducir las llamadas a funciones. V2 acorta el nombre de la clase en un solo 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"));}}

Versión formateada:

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!

Nota: desconté la primera versión. Tenía 361 bytes, no 363 bytes.

[C #], tio versión 218 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

^{¡Muchas gracias a Jonathan Allan por sus sugerencias!}

Versión anterior (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

En realidad no sé cómo funciona el código anterior; Lo tomé de este documento y todo lo que implementé fue la parte de búsqueda. g(1,0,1,1,3,3)devuelve los dígitos de pi y es sorprendentemente eficiente (calcula 10 000 dígitos en tio.run en menos de 4s).

La entrada es una lista que consta de los dígitos del número que se encuentra.

Pruébalo en línea!

Haskell, 230 bytes

Usando la pereza para encontrar el número en cualquier parte de los dígitos infinitos de pi, no solo en los primeros 200 dígitos. Ah, sí, y te devuelve cada (¿infinidad de?) Instancia (s) del número, no solo la primera.

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]

Ejemplos del desafío

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

Créditos

'p' es la secuencia infinita de dígitos pi, tomada de 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

Los dígitos de pi están codificados y empaquetados en los valores ascii de los caracteres. 14 -> CHR$(14), 15 -> CHR$(15), 92 -> \, 65 -> A, 35 -> #.

La cadena contiene caracteres no imprimibles, así que aquí están los bytes escritos en hexadecimal: 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

En decimal, puedes ver los dígitos de 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

Ruby , 37 35 bytes

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

Pruébalo en línea!

Nada especial, solo muestra la biblioteca incorporada. La salida está indexada en 0. La cadena Pi está formateada como 0.31415...e1, por lo que necesitamos quitar los primeros 3 caracteres. La e1parte al final realmente no hace ningún daño, pero también se elimina, ya que de todos modos debemos proporcionar un valor de final de rango (o longitud de corte).

Carbón , 27 15 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Funciona hasta casi 1000 dígitos. Explicación:

        ≕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

Dado que Japt comparte la restricción Pi de 15 dígitos de JavaScript y shoco , la codificación utilizada por Japt no codifica números, se requieren algunas travesuras para la compresión.

Brevemente explicado, el comienzo es la siguiente cadena en forma codificada:

"nqnrvosrpruvtvpopuqsosqppupotvrmouuqnvtnsvpvvptrnmruomvtqvqqrvopmtunsqmsousomuvvusoumpquorpqonntmstvuonqumusrnpouopmssqtmvpuqqsmvrrmruoopntorprvqmunouqunnntqrmouqnmotmnvpuronnmrrrvsqqsoovquvrqvpmpunvs"

Que es una cadena donde cada letra es 'm' + corresponding digit of pi . Probé todo el alfabeto y esa letra da la mejor compresión en unos pocos bytes.

Los backticks le dicen a Japt que decodifique la cadena. El resto es bastante sencillo:

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

Emite un índice basado en 0 del fragmento coincidente.
Afeitó otros dos bytes gracias a Oliver .

Pruébalo en línea!

AWK -M, 131 119 117 bytes

Utiliza la -Mbandera para cálculos de precisión arbitrarios. Agregado p=k=0(5 bytes) al enlace TIO para permitir la entrada multilínea

{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

Pruébalo en línea!

Explicación:

{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

Jalea , 24 bytes

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

Pruébalo en línea!

Use una fórmula similar a Machin , específicamente 1/4 pi == tan ^-1 (1/2) + tan ^-1 (1/3).

Use la fórmula pi / 2 == 1 + 1/3 × (1 + 2/5 × (1 + 3/7 × (1 + 4/9 × (...))))

Python 2 239 238 229 214 bytes

-9 bytes debido a @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

Utiliza el algoritmo Chudnovsky-Ramanujan para encontrar los primeros 1 millón de dígitos 50000 dígitos de π (cambiar 10**10**5a 10**10**6más, pero lleva años ejecutarlos) y luego busca la cadena deseada.

Visual Basic - 114 bytes

Bien, primera presentación. ¡Se paciente conmigo!

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

Comentarios bienvenidos!

No me he limitado a las primeras 256 partes de PI ya que la pregunta dice "No tienes que hacerlo", no "No deberías" Espero que esté haciendo esto correctamente :)

Javascript 217 bytes (200 codificados)

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

PHP, 27 bytes

^{No es una respuesta muy seria, requiere un cambio en la configuración de php.ini ya que pi () está predeterminado a 14 dígitos, no a 200, pero por una vez la solución PHP es bastante elegante:}

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

Julia 0.6 , 53 bytes

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

Establezca la precisión para BigFloats lo suficientemente alta, luego conviértala pien una cadena y busque. Precisión de 9^6asas 159980 dígitos.

Pruébalo en línea!

J, 25 bytes

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

Pruébalo en línea!

0-indexado

Toma la entrada como una cadena, +2 Bytes ( ":) si eso no está permitido.

Explicación eventualmente.

Perl 5 con -MMath::BigFloat+bpiy -n, 20 bytes

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

Pruébalo en línea!

No estoy seguro de donde el uso de $>soportes, ya que es la EFFECTIVE_USER_IDque no es portátil, pero en esta TIO es de 1000 y satisface nuestras necesidades, por -1 bytes vs 200.

Casco , 5 bytes

€tİπd

Pruébalo en línea!

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