Виклик:

Пі передбачається нескінченним. Це означає, що кожне число міститься всередині десяткової частини 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 цифр
• Стандартні лазівки, як завжди, заборонені.
• Це кодогольф , тому менша кількість байтів виграє.

Python 2, 69 75 71 67 байт

Збережено 4 байти за рахунок спільної роботи в режимі "coird" .

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

Не знаходячись 3у позиції нуля коштують 6 2 байти. Введення подається у вигляді рядка.

Спробуйте в Інтернеті!

Без обмеженої версії

Пітон 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 байт, хаха ...
EDIT: створив порт відповіді @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але включає a 3.на початку, тому ми знімаємо це з, 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"));
    }
}

Ідеон!

NB.Я першу версію неправильно рахував. Це було 361 байт, а не 363 байти.

[C #], версія 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

Цифри 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, тому нам потрібно зняти перші 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 і šoco Javascript , кодування, яке використовує 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

Використовує алгоритм Чудновського-Рамануджана, щоб знайти перші 1 мільйон цифр 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))

Відгуки Ласкаво просимо!

Я не обмежився першими 256 частинами ПІ, оскільки в запитанні сказано: "Вам не потрібно", а не "Не слід". Сподіваюся, що я це правильно роблю :)

Javascript 217 байт (200 жорстко кодованих)

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

PHP, 27 байт

^{Відповідь не дуже serieus, вона потребує змін у налаштуваннях 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 байт проти 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.