Вызов :

Пи должен быть бесконечным. Это означает, что каждое число содержится внутри десятичной части числа pi. Ваша задача будет взять положительное целое число на входе и вернуть позицию этого числа в пи цифрах на выходе.

Например, если ввод 59, мы вернемся4

И вот почему: мы будем искать число 59в цифрах числа пи

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 байт

Сохранено 4 байта из-за caird .

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

Гораздо более быстрый неограниченный патрубок, основанный на Рамануджане № 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 знаков после запятой, поэтому пи просто жестко запрограммирован. Это должно быть довольно слабой верхней границей для этой задачи.

Java 8, 615 217 202 184 182 166 165 байтов (вычислено 999 200 цифр)

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-индексированных

Попробуйте онлайн.

Встроенная в Java Math.PIточность 15 десятичных значений, как и во многих других языках. Чтобы иметь больше цифр, вам придется вычислять их самостоятельно с помощью BigIntegersили BigDecimals. Это выше, способ сделать это .. Может быть, кто-то может сыграть в гольф ниже 211 байт, смеется.
РЕДАКТИРОВАТЬ: Создал порт ответа @primo Python 2 (убедитесь, что его голосовать!), Так что расчет будет короче, чем трудно закодирован уже не так надуманно Всего 7 байтов в гольфе, чтобы он был короче.

-15 байтов благодаря @Neil , что делает его короче, чем жестко закодированный ответ ниже!
-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 цифрах десятичной части числа π.

Попробуйте онлайн!

Как?

При этом используется формула Лейбница для π для вычисления первых 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 байт

Благодаря Софии Лечнер сэкономил 1 байт, а благодаря шарлатанству Коровы - 7 байт.

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

Это сценарий оболочки, который принимает один аргумент, который является числом. Тест с

$ 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

Результат этого конвейера присваивается переменной оболочки 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

Принимает последовательность из девятизначных целых чисел с основанием 36, преобразует их в основание 10 и объединяет их для создания первых 200 цифр числа Пи.

Первый раз занимаюсь гольфом. Используйте делегаты и лямбда-выражения, чтобы уменьшить количество вызовов функций. V2 сокращает имя класса до одного байта.

[C #], 361 355 байт

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

Ideone!

NB.Я пропустил первую версию. Это было 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 и удивительно эффективен (он вычисляет 10 000 цифр на tio.run менее чем за 4 секунды).

Входные данные представляют собой список, состоящий из цифр числа, которое будет найдено.

Попробуйте онлайн!

Haskell, 230 байт

Использование лени, чтобы найти номер где-нибудь в бесконечных цифрах числа Пи, а не только в первых 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' - это бесконечный поток цифр пи, взятый из 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

Цифры пи жестко закодированы и упакованы в значения символов 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

В десятичном виде вы можете увидеть цифры числа пи: 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, поэтому нам нужно убрать первые 3 символа. 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 разделяет 15-значное ограничение Pi в Javascript и 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(5 байт) к ссылке TIO, чтобы разрешить многострочный ввод

{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

Попробуйте онлайн!

Используйте мачиноподобную формулу , а именно 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

ИСПОЛЬЗУЕТ Чудновский-Ramanujan алгоритма для нахождения первой 1 миллиона цифры от 50000 цифр n (изменения 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))

Обратная связь приветствуется!

Я не ограничился первыми 256 частями PI, так как в вопросе написано «Вы не должны», а не «Вы не должны». Надеюсь, я делаю это правильно :)

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 Bytes ( ":), если это не разрешено.

Объяснение в конце концов.

Perl 5 с -MMath::BigFloat+bpiа -n, 20 байтов

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

Попробуйте онлайн!

Я не уверен, где используется $>стенды, так как он не EFFECTIVE_USER_IDявляется переносимым, но на TIO это 1000 и соответствует нашему требованию, для -1 байт против 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.