挑战：

Pi应该是无限的。这意味着每个数字都包含在pi的小数部分内。您的任务将是在输入上取一个正整数，并在输出上以pi位返回此数字的位置。

例如，如果输入为59，我们将返回4

这就是为什么：我们将59在pi的数字中查找数字

3.14159265...
     ^^

该值从第4位开始，因此输出为4。

其他一些例子：

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

规则：

• 您不必处理前200个数字中不存在的数字
• 与往常一样，标准漏洞是被禁止的。
• 这是codegolf，所以较少的字节获胜。

Python 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零位成本6 2字节。输入以字符串形式给出。

在线尝试！

无限版本

Python 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只是硬编码。对于这个挑战，这应该是一个相当微弱的上限。

Java 8，615 217 202 184 182 166 165字节（计算的999200位）

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索引

在线尝试。

Math.PI与许多其他语言一样，Java的内建精度为15个十进制值。要获得更多数字，您必须自己使用BigIntegers或进行计算BigDecimals。上面这是一个办法做到这一点.. 也许有人可以高尔夫这个下面211个字节，哈哈..
编辑：创建的端口@primo S” Python的2答案（请务必给予好评他！），所以计算比硬更短编码不再那么牵强。高尔夫只需要增加7个字节就可以使它更短。

使用@Neil可以得到 -15个字节，这比下面的硬编码答案还要短！
-36字节感谢@primo。
-1字节更改java.math.BigInteger t=null,T=t.TEN.pow(200),r=T;为var T=java.math.BigInteger.TEN.pow(200);var r=T;，因为var比1字节短null（必须爱新的Java 10）。

说明：

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.在开头包含a ，因此我们先将其去除，substring然后与匹配regexec，这将返回匹配的索引以及有关该匹配的一些元数据。

果冻，23 个字节

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

单子链接接受一个字符列表（要查找的整数）并返回索引。适用于包含在π小数部分的前252位数字内的输入。

在线尝试！

怎么样？

这使用π的Leibniz公式来计算前253位数字，包括前导3（再加上四个尾随的不正确数字）。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）。

BASH（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%%:*}

这是一个使用单个参数（即数字）的shell脚本。测试

$ 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

该管道的结果分配给shell变量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

JavaScript中，197 187

^{-10：谢谢，尼尔！}

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

接受一系列9位以36为底的整数，将其转换为10以底，然后将它们连接起来以创建pi的前200位。

第一次做代码高尔夫。使用委托和lambda表达式可以减少函数调用。V2将类名缩短为一个字节。

[C＃]，361355字节

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

伊迪奥！

注意：我误算了第一个版本。它是361个字节，而不是363个字节。

[C＃]，tio版本218字节

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

在线尝试！

Haskell中，208 120个字节

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

在线尝试！

^{非常感谢乔纳森·艾伦的建议！}

旧版本（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中以不到4s的时间计算了10 000个数字）。

输入是一个列表，其中包含要查找的数字。

在线尝试！

Haskell，230字节

使用惰性可以在pi的无限位数中的任意位置查找数字，而不仅仅是在前200位中。哦，是的，它返回给您该数字的每个（无限多个？）实例，而不仅仅是第一个实例。

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'是pi数字的无限流，取自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字节

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-> #。

该字符串包含不可打印的字符，因此以下是用十六进制写入的字节： 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，因此我们需要剥离前三个字符。最后的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开始的索引。
多亏了奥利弗，剃光了两个字节。

在线尝试！

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×（...）））））

Python 2 239 238 229 214字节

-9个字节（由于@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

使用Chudnovsky-Ramanujan算法查找π 的前一百万个数字 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个部分，因为问题表明“您不必”，而不是“您不应该”，希望我做对了:)

Javascript 217个字节（200个硬编码）

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

PHP，27字节

^{这不是一个很明智的答案，它需要更改php.ini设置，因为pi（）默认为14位，而不是200位，但是对于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字节（":如果不允许）。

最终解释。

Perl 5，带有-MMath::BigFloat+bpi和-n，20个字节

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

在线尝试！

我不确定$>支架的用途，因为它EFFECTIVE_USER_ID不是便携式的，但在TIO上为1000，可以满足我们对-1字节vs.的要求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.