Desafio:

Pi deveria ser infinito. Isso significa que todo número está contido na parte decimal de pi. Sua tarefa será pegar um número inteiro positivo na entrada e retornar a posição desse número em dígitos pi na saída.

Por exemplo, se a entrada for 59, retornaremos4

Eis o porquê: procuraremos o número 59nos dígitos de pi

3.14159265...
     ^^

O valor começa no quarto dígito, então a saída será 4.

Alguns outros exemplos:

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

Regras :

• Você não precisa manipular dígitos que não existem nos primeiros 200 dígitos
• As brechas padrão são, como sempre, proibidas.
• Este é um codegolf , portanto, menos bytes vencem.

Python 2, 69 75 71 67 bytes

Guardado 4 bytes devido a caird coinheringaahing .

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

Não encontrar 3na posição zero custa 6 2 bytes. A entrada é fornecida como uma sequência.

Experimente online!

Versão não vinculada

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 uma torneira ilimitada com base na mesma fórmula usada acima.

Experimente online!

Versão mais 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

Uma torneira ilimitada muito mais rápida, com base no Ramanujan # 39 .

Experimente online!

Casca , 5 bytes

€tİπd

Experimente online!

Explicação

€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")

O Excel lida apenas com 15 casas decimais, portanto, pi é apenas codificado. Esse deve ser um limite superior bastante fraco para esse desafio.

Java 8, 615 217 202 184 182 166 165 bytes (calculados 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);}

Indexado 1

Experimente online.

O builtin do Java Math.PItem uma precisão de 15 valores decimais, como muitas outras linguagens. Para ter mais dígitos, você precisará calculá-los com BigIntegersou BigDecimals. Isso acima é uma maneira de fazê-lo .. Talvez alguém possa jogar golfe abaixo de 211 bytes, lol ..
EDIT: Criou uma porta da resposta Python 2 do @primo (certifique-se de vomitá-lo!), Portanto, calcule ser mais curto do que difícil -coded não é mais tão rebuscado. Apenas mais 7 bytes de golfe para que ele seja mais curto.

-15 bytes graças a @Neil , tornando-o mais curto do que a resposta codificada abaixo!
-36 bytes graças a @primo .
-1 byte mudando java.math.BigInteger t=null,T=t.TEN.pow(200),r=T;para var T=java.math.BigInteger.TEN.pow(200);var r=T;, porque varé 1 byte menor que null(precisa amar o novo Java 10).

Explicação:

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

Indexado a 0

Experimente online.

05AB1E , 6 bytes

₁žs¦¹k

Experimente online!

Quão?

₁        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

Experimente online!

Explicação

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

Pacote de números R +, 52 bytes

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

Experimente online!

dropletPicalcula os primeiros 200 dígitos decimais de, pimas inclui um 3.no início, portanto, removemos isso substringe depois combinamos com regexec, que retorna o índice da correspondência junto com alguns metadados sobre a correspondência.

Gelatina , 23 bytes

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

Um link monádico que aceita uma lista de caracteres (o número inteiro a ser encontrado) e retorna o índice. Funciona para entradas contidas nos primeiros 252 dígitos da parte decimal de π.

Experimente online!

Quão?

Isso usa a fórmula de Leibniz para π para calcular os primeiros 253 dígitos, incluindo os iniciais 3(mais quatro dígitos incorretos à direita). O líder 3é descartado e o índice da entrada é encontrado:

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

Se você preferir uma lista de dígitos como uso de entrada ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊw(também 23), e se você realmente quiser usar um número inteiro ⁵*⁹Ḥ;ȷḊ+J$¤×⁹:2¤:ɗ\SDḊwD(para 24).

BASH (GNU / Linux), 75 67 66 bytes

Economizei 1 byte graças a Sophia Lechner e 7 bytes graças ao charlatão de vacas.

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

Este é um script de shell que usa um único argumento, que é o número. Teste com

$ bash <script-path> 59
4

Este script primeiro executa um pipeline de três 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

O resultado desse pipeline é atribuído à variável do shell a, que é repetida com qualquer coisa, exceto o primeiro número removido:

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

Infelizmente, bctem a tendência de interromper as linhas de saída quando elas se tornam muito longas. Isso pode levar a resultados incorretos se o número a ser encontrado não estiver na primeira linha. Você pode evitar isso definindo a variável de ambiente BC_LINE_LENGTH:

export BC_LINE_LENGTH=0

Isso desativa completamente o recurso de quebra de linha.

Obviamente, os dois últimos comandos podem ser omitidos se outra saída for tolerada.
Isso fornece uma contagem de 48 bytes :

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

Com a saída 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: Obrigado, Neil !}

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

Pega uma série de números inteiros base 36 de nove dígitos, converte-os na base 10 e concatena-os para criar os primeiros 200 dígitos de pi.

Primeira vez fazendo código de golfe. Use expressões delegadas e expressões lambda para reduzir as chamadas de função. V2 encurta o nome da classe em um único 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"));}}

Versão formatada:

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!

NB: eu contei mal a primeira versão. Tinha 361 bytes, não 363 bytes.

[C #], versão tio 218 bytes

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

Experimente 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

Experimente online!

^{Muito obrigado a Jonathan Allan por suas sugestões!}

Versão antiga (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

Na verdade, eu não sei como o código acima funciona; Eu tirei isso de deste artigo e tudo o que implementei foi a parte de pesquisa. g(1,0,1,1,3,3)retorna os dígitos de pi e é surpreendentemente eficiente (calcula 10.000 dígitos em tio.run em menos de 4s).

A entrada é uma lista que consiste nos dígitos do número a ser encontrado.

Experimente online!

Haskell, 230 bytes

Usando a preguiça para encontrar o número em qualquer lugar nos infinitos dígitos de pi, não apenas nos primeiros 200 dígitos. Ah, sim, e ele retorna todas as instâncias (infinitas?) Do número, não apenas o primeiro.

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]

Exemplos do desafio

>  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' é o fluxo infinito de dígitos pi, obtido em 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

Os dígitos de pi são codificados e compactados nos valores ascii dos caracteres. 14 -> CHR$(14), 15 -> CHR$(15), 92 -> \, 65 -> A, 35 -> #.

A string contém caracteres não imprimíveis, então aqui estão os bytes escritos em 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

Em decimal, você pode ver os 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]=~/#$_/

Experimente online!

Nada de especial, apenas mostrando a biblioteca embutida. A saída é indexada em 0. A string Pi é formatada como 0.31415...e1, portanto, precisamos remover os 3 primeiros caracteres. A e1peça no final não causa nenhum dano, mas também é retirada, pois precisamos fornecer um valor de final de intervalo (ou comprimento da fatia) de qualquer maneira.

Carvão , 27 15 bytes

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

Experimente online! Link é a versão detalhada do código. Funciona até quase 1000 dígitos. Explicação:

        ≕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

Como o Japt compartilha a restrição Pi e shoco de 15 dígitos do Javascript , a codificação usada pelo Japt não codifica números, algumas travessuras são necessárias para a compactação.

Resumidamente explicado, o início é a sequência abaixo na forma codificada:

"nqnrvosrpruvtvpopuqsosqppupotvrmouuqnvtnsvpvvptrnmruomvtqvqqrvopmtunsqmsousomuvvusoumpquorpqonntmstvuonqumusrnpouopmssqtmvpuqqsmvrrmruoopntorprvqmunouqunnntqrmouqnmotmnvpuronnmrrrvsqqsoovquvrqvpmpunvs"

Qual é uma string em que cada letra está 'm' + corresponding digit of pi. Testei o alfabeto inteiro e essa letra fornece a melhor compactação em alguns bytes.

Os backticks dizem ao Japt para decodificar a string. O resto é bem direto:

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

Gera um índice baseado em 0 do fragmento correspondente.
Raspou mais dois bytes graças a Oliver .

Experimente online!

AWK -M, 131 119 117 bytes

Usa -Msinalizador para cálculos de precisão arbitrários. Adicionado p=k=0(5 bytes) ao link TIO para permitir a entrada de várias linhas

{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

Experimente online!

Explicação:

{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

Gelatina , 24 bytes

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

Experimente online!

Use uma fórmula semelhante a Machin , especificamente 1/4 pi == tan ^-1 (1/2) + tan ^-1 (1/3).

Use a 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 devido 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

Usa o algoritmo Chudnovsky-Ramanujan para encontrar os primeiros 1 milhão de dígitos 50000 dígitos do π (mudança 10**10**5a 10**10**6mais, mas demora muito tempo para ser executado) e em seguida, procura-los para a cadeia desejada.

Visual Basic - 114 bytes

Ok, primeira submissão. Vai com calma comigo!

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

Feedback bem-vindo!

Eu não restringi as primeiras 256 partes do PI, pois a pergunta diz "Você não precisa", não "Você não deveria" Espero que eu esteja fazendo isso corretamente :)

Javascript 217 bytes (200 codificado)

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

PHP, 27 bytes

^{Não é uma resposta muito seriada, requer uma alteração nas configurações do php.ini, pois o pi () tem como padrão 14 dígitos, não 200, mas desta vez a solução PHP é bastante elegante:}

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

Julia 0.6 , 53 bytes

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

Defina a precisão do BigFloats alta o suficiente e depois converta pi em uma sequência e pesquise. Precisão de 9^6alças 159980 dígitos.

Experimente online!

J, 25 bytes

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

Experimente online!

0-Indexado

Recebe entrada como uma sequência, +2 bytes (": ), se isso não for permitido.

Explicação eventualmente.

Perl 5 com -MMath::BigFloat+bpie -n, 20 bytes

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

Experimente online!

Eu não tenho certeza onde o uso de $>arquibancadas, já que é o EFFECTIVE_USER_IDque não é portátil, mas em TIO este é de 1000 e satisfaz a nossa exigência, para -1 byte vs. 200.

Casca , 5 bytes

€tİπd

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