Пи получил твой номер

30

Вызов :

Пи должен быть бесконечным. Это означает, что каждое число содержится внутри десятичной части числа 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 цифрах
  • Стандартные лазейки, как всегда, запрещены.
  • Это , поэтому побеждает меньше байтов.
Случайный парень
источник
41
Числа с указанным вами свойством известны как нормальные числа . Бесконечное десятичное разложение, даже если оно непериодическое, не подразумевает нормальности. 0.101001000100001 ... контрпример.
Деннис
38
И, безусловно, Пи не должен быть бесконечным. Это десятичное представление, однако, имеет бесконечные цифры.
rafa11111
11
@Dennis Normal - гораздо более сильное условие (единообразный против все-существующего)
user202729
6
Разрешено ли выводить nиндекс с индексом 0? Таким образом, текстовые случаи будут возвращаться 0, 6, 41, 8вместо 1, 7, 42, 9.
Кевин Круйссен
7
@ rafa11111 Я согласен. Мы должны отказаться от целых чисел и использовать числа в base-PI. Тогда целые числа будут иметь бесконечные цифры.
mbomb007

Ответы:

22

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 .

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

Примо
источник
Хорошо,
2
@Dennis 31 должен соответствовать в 137: /
primo
2
Какой алгоритм приближения это? Это один из перечисленных здесь? ru.wikipedia.org/wiki/Approximations_of_%CF%80
Sphinxxx
4
@Sphinxxx - это результат применения преобразования Эйлера к ряду Лейбница. Я разместил вывод в предыдущем посте .
Примо
19

Шелуха , 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
Fyr
источник
1
Смешно - но я должен признать, что впечатлен.
Floris
6
Для языков игры в гольф, как правило, полезно добавить объяснение, поскольку тот, кто не знает языка, не сможет его прочитать. Если я правильно понимаю, это: Возьмите индекс ( ) с первым удаленным элементом (первые 3) ( t) из цифр PI ( İπ), преобразуйте его в base-10 ( d) и выведите в STDOUT (неявно).
Кевин Круйссен,
Согласился, понятия не имею, на что смотрю.
А.А. Терроба
1
@gggg выглядит как пример ленивого представления , проверка
только ASCII
1
@gggg İπ- это бесконечный список цифр, созданный с неограниченным источником
H.PWiz
18

Excel, 212 байт

=FIND(A1,"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196")

Excel обрабатывает только 15 знаков после запятой, поэтому пи просто жестко запрограммирован. Это должно быть довольно слабой верхней границей для этой задачи.

Инженер Тост
источник
4
Мне жаль комментировать мой собственный пост, но могут ли некоторые из пользователей сказать мне, почему им нравится этот ответ? Это игра в гольф, как это может быть в формуле Excel, но она очень длинная и совсем не умная.
Инженер Тост
6
Мне это нравится, потому что он не опирается на языки игры в гольф, которые имеют встроенные функции для вычисления числа Пи до произвольного десятичного знака. Это может быть не креативно, но практично (здесь не важна практичность).
Скотт
Поскольку вопрос не определяет , что входной или ответ должен быть базой 10, вы могли бы гольф это, используя CONCATи формулу ББПА для вычисления первых 200 цифр пи-base16 и поиска в шестнадцатеричном вместо этого? (У меня нет 365, поэтому не могу проверить)
Хроноцидный
2
Только в Office 365: я использовал CONCAT, CODEи MIDя сократил строку PI с 202 символов (включая кавычки) до 143:CONCAT(CODE(MID(".ÜÁ£ÙÏ ¦®š«¦ Ï²œÔ“ÇŧÝËŠº”ᱬ»—‡ÑÀ†œ¾ˆãÖœƒ°™¢•‘†ÏÒŽÐÖ³ ÒžÂ¯‰¦¬¼ß²º–ŸÈµ»¨Ñœ°‹‘­‚ÔŠ›ÝÕ•Š·»À®–Þٶ݃Ñà",2*ROW(A1:A100)-1,2))-32)
Chronocidal
1
Тестирование с Office365, похоже, что он выводит 14 независимо от ввода?
Мэтью Шлахтер
9

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

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

Кевин Круйссен
источник
1
!p.equals(t.ONE)возможно? Также indexOf(n,1)-1работает, я думаю. Или сохраните 2 байта и сделайте его 1-проиндексированным.
Нейл
Не уверен, как я пропустил первое, но второе мне действительно нужно запомнить. Не знал, что есть indexOfметод, который пропускает первые mсимволы. ТИЛ, спасибо!
Кевин Круйссен
1
Как насчет сохранения p целым числом ?
Primo
1
Вы также можете уменьшить pна единицу каждый раз ( for(int p=667;p-->1;)), а затем умножить на pи разделить на p-~p.
Примо
1
Начальное значение rможет буквально быть чем угодно, хотя крайние значения потребуют большего количества итераций. Лучшее семя (наименьшее количество итераций) на самом деле 4e200.
Примо
6

05AB1E , 6 байтов

₁žs¦¹k

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

Как?

₁        push 256
 žs      push pi to 256 places
   ¦     remove the leading 3
    ¹    push the input
     k   index inside that string
Уриэль
источник
Если я получу аналогичное 6-байтовое решение на том же языке, я удалю после вас мой ответ?
nicael
@nicael обычно это не имеет значения, но ваше решение 3все равно не сработает
Уриэль
О, действительно, спасибо
Nicael
6

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
Луис Мендо
источник
Очень красиво и коротко! Можете ли вы объяснить, как это работает?
Случайный парень
@Therandomguy Конечно, объяснение добавлено
Луис Мендо
4

R + пакет номеров, 52 байта

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

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

dropletPiвычисляет первые 200 десятичных цифр, piно включает 3.в начале символ a , поэтому мы удаляем его с помощью, substringа затем сопоставляем regexec, что возвращает индекс совпадения вместе с некоторыми метаданными о совпадении.

Giuseppe
источник
Может быть regexpr(scan(),numbers::dropletPi(200))-2?
Джурио
@djhurio, который не работает, потому что мы должны сопоставлять цифры после десятичной точки. Это была моя первая мысль, но этот случай разрушает ее. Может быть "if"?
Джузеппе
Я не вижу здесь проблемы. Не входные данные будут содержать 3.(я предполагаю, что мы имеем дело с целыми числами, а не с реальными числами на входе). Тестовые примеры работают с этим.
Джурио
3
@djhurio верно, но regexpr(3,numbers::dropletPi(200))-2возвращается, -1 когда он должен вернуться 9, попробуйте
Giuseppe
3

Желе , 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).

Джонатан Аллан
источник
Вы имеете в виду преобразование Эйлера, примененное к формуле Лейбница. Вычисление 252 цифр по формуле Лейбница заняло бы чуть больше времени, чем большинство людей хотели бы ждать.
Прим
Да, это заняло бы много времени в необработанном виде (я все еще "использую формулу Лейбница", я верю!)
Джонатан Аллан
3

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
cmaster
источник
Ницца! Вам не нужно это пространство между -lи <<<хотя.
София Лехнер
Вы можете преобразовать в программу и использовать sed, чтобы сохранить несколько байтов, попробуйте онлайн!
Критиси Литос
@ Cowsquack Разве мне не нужно включать строку байтов в число байтов?
Мастер
Линии @cmaster shebang не учитываются при подсчете байтов ни для каких языков
Kritixi Lithos,
@ Cowsquack Спасибо за предложение. Тем не менее, если вы разрешите дополнительный вывод, вы также можете не sedуказывать (см. Вторую часть моего ответа). Тем не менее, преобразование в программу дало мне 7 байтов, так что спасибо за это! Я также заменил tr/ headcombo на магическую переменную оболочки, чтобы сохранить еще один байт.
cmaster
2

JavaScript, 197 187

-10: Спасибо, Нил !

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

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

apsillers
источник
Хорошо, вы провалили мои попытки кодирования данных из воды, ваш подход экономит 38 байтов на необработанных данных.
Нить
+1 - я собирался опубликовать точно такой же подход.
darrylyeo
Используйте x=>'50...'.replace(/.{9}/g,a=>parseInt(a,36)).search(x)+1для сохранения 10 байтов.
Нил
2

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

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

Хан
источник
Вам не нужно включать тестовые сценарии в ваш код, и вы можете просто использовать лямбда-функцию (анонимную) вместо полной программы
Zac Faragher
Hyarus предлагается using System;f=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".IndexOf(f)+1;в качестве правки.
овс
Я новичок здесь, и я подумал, что должен включить полную программу, включая контрольный пример. Кажется, что люди используют tio.run для демонстрации вместо ideone. Я вижу, что tio.run делит код на части.
Хан
2

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 секунды).

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

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

Кристиан Лупаску
источник
Я предполагаю, что формула Лейбница будет намного короче.
Джонатан Аллан
@JonathanAllan Спасибо! Я дам ему попробовать. Я очень люблю этот сайт! Я так много узнал от вас, ребята! :)
Кристиан Лупаску
@JonathanAllan Я пытался аппроксимировать пи, используя l=4*sum[((-1)**x/(2*x+1))|x<-[0..1e6]], но для запуска требуется 5 с, а 7-я цифра уже неверна. Таким образом, может оказаться невозможным вычислить 200 цифр. В любом случае, это было интересное упражнение, так что спасибо!
Кристиан Лупаску
1
Вы бы хотели использовать преобразование Эйлера (см. Мой ответ на Jelly или ответ на языке Python для primo)
Джонатан Аллан
1
Что касается статьи, на которую вы ссылаетесь, вас может заинтересовать этот пост , в котором я повторно реализую код, найденный в этой статье, без «преднамеренного запутывания». Это также немного проще (короче) в результате. См. Метод g1_refв разделе « Быстрые неограниченные генераторы» . Код является питоном.
Примо
2

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]
tombop
источник
Я думаю, вы уже знаете это, но вам нужно вывести только первое число в вашей последовательности ...
Timtech
Просто думал, что
приму
2

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

12Me21
источник
Если вы разместите полный код, вам будет проще проверить ваш ответ.
Прим
1
Я не могу опубликовать это, потому что есть недопустимые символы, которые удалены / не отображаются. Я думаю, что я могу опубликовать коды ASCII, хотя.
12Me21
Вы можете опубликовать hexdump, используя, например, xxd.
Натаниэль
2

Рубин , 37 35 байт

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

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

Ничего особенного, просто демонстрация встроенной библиотеки. Вывод 0 проиндексирован. Строка Pi отформатирована как 0.31415...e1, поэтому нам нужно убрать первые 3 символа. e1Часть в конце концов , на самом деле не причинит никакого вреда, но он снял тоже, как нам нужно в любом случае , чтобы обеспечить конечный диапазон (или длину среза) значение.

Кирилл Л.
источник
коротко и читабельно!
PJS
2

Древесный уголь , 27 15 байт

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

Попробуйте онлайн! Ссылка на подробную версию кода. Работает почти до 1000 цифр. Объяснение:

        ≕Pi     Get variable `Pi`
           φ    Predefined variable 1000
     ▷N⟦    ⟧   Evaluate variable to specified precision
    I           Cast to string
             θ  First input
   ⌕            Find
              χ Predefined variable 10
   ∨             Logical OR
  ⊖              Decrement
 I               Cast to string
                 Implicitly print
Нил
источник
исправлено 13 байт . примечание стороны: это кажется очень обманчивым: P
ASCII-only
фактически исправлено, 13 байтов . использует неявный ввод. (не предполагаемое поведение, но оно кажется более полезным, чем любой другой способ). также не могли бы вы дать ссылку на пример ошибки заполнения?
Только для ASCII
@ ASCII-only Заполнить странность - почему курсор оказывается там?
Нил
: | о, я понятия не имею, что я должен исправить это как можно скорее
только ASCII
Н.В.М. Я идиот , преданный делу.
Только для ASCII,
2

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 соответствующего фрагмента.
Побрил еще два байта благодаря Оливеру .

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

гнида
источник
1
Умная идея! Вы можете заменить £Xна ®и } сÃ
Оливер
@ Оливер Большое спасибо за это, я все еще учу Джапта, поэтому вся помощь очень ценится.
Нить
1
Вы отлично справляетесь до сих пор! Мне было любопытно посмотреть, было ли лучшее смещение, чем 109. Я сделал брутфорсер , и оказалось, что 109 является оптимальным. Отлично сделано :)
Оливер
@Oliver Спасибо за это, я просто попробовал весь диапазон az вручную, так как это не было слишком много работы. : P
Nit
1

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
Роберт Бенсон
источник
Моя первая попытка sprintfполучить десятичные дроби. Использование CONVFMTопределенно чище.
Роберт Бенсон
Хорошо знать. Я полагаю, что мне следует больше времени уделять мета ... свободному времени. :)
Роберт Бенсон
1

Желе , 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 × (...))))

user202729
источник
Есть ли способ получить цифры из ØPM?
Дилнан
@ Dylnan В некотором смысле , но М - не желе.
user202729
Я знаю, что они разные. Не могу поверить, что я не думал floor. Имейте в виду, если я использую это, чтобы отправить как ответ в М?
Дилнан,
Не берите в голову. Не работает выше 104 цифр ...
dylnan
1

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течение более, но он принимает возрасты , чтобы бежать) , а затем ищут в них нужной строке.

DividedByZero
источник
Я пытался подтвердить результат, но он не заканчивается ( n=10**10**5занимает около 10 секунд).
Прим
@ primo Я никогда не говорил, что это быстро! 10**10**6занимает около 7 минут на моей машине .. Чтобы быть честным, 10**10**5дает первые 50000 цифр, так что я думаю, что это не так уж и плохо :)
DividedByZero
@primo Я изменил библиотеку произвольной точности на bigfloat, теперь она работает намного быстрее.
DividedByZero
Сейчас это намного быстрее, я собирался предложить переключиться на него gmpy2, но bigfloatэкономит дюжину или около того байтов. Назначение kможно объединить, k=b=0если вы перейдете k+=1к началу итерации. -(6*k-5)*(2*k-1)*(6*k-1)может быть написано более кратко, как k*(k*(108-72*k)-46)+5. Если вы объявляете Python 2, //целочисленные деления можно заменить на /, а также скобки не нужны print. Пространство также может быть удалено в import*. Подтверждает только до 50000 цифр, кстати.
прима
nВ , sqrt(10005*n)кажется, проблема; он перемещает десятичную точку на 50000-е место. Если вам интересно, вот моя собственная реализация Чудновского: попробуйте онлайн!
прима
1

Visual Basic - 114 байт

Хорошо, первая подача. Полегче со мной!

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

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

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

user9338709
источник
Я не очень разбираюсь в virtual basic, но, думаю, вы можете сэкономить несколько байтов, удалив все пробелы. Вы также должны иметь возможность хранить свой код в функции и возвращать значение вместо «console.log» (я думаю, вы получите несколько таких байтов). О, и вы должны ввести значение, а не жестко его кодировать.
Случайный парень
Спасибо. Удалены пробелы и удалено жестко закодированное значение в пользу ввода. Увеличивает счет до 114! Будет ли функция возврата значения не включена в число байтов? Я предполагаю, что это сделало бы это дольше, если так.
user9338709
Добро пожаловать на сайт! Похоже, что это работает ( попробуйте онлайн! ), Но похоже, что это фрагмент кода, и представления должны быть либо полной программой, либо функцией.
Дом Гастингс
Нечто подобное может сработать, но, возможно, есть лучшие способы сделать это! Проверьте меню ссылок в верхней части этой страницы для шаблона, который используют многие материалы!
Дом Гастингс
На самом деле, похоже, что константа не имеет 200 цифр :( Попробуйте онлайн! - это должно вернуть 197.
Dom Hastings
0

Javascript 217 байт (200 в жестком коде)

a=>"14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196".search(a)+1
Луис Фелипе Де Иисус Муньос
источник
0

PHP, 27 байт

Не очень серьезный ответ, он требует изменения настроек php.ini, так как по умолчанию pi () - 14 цифр, а не 200, но на этот раз решение PHP довольно элегантно:

<?=strpos(pi(),$_GET[n])-1;
Мартейн
источник
Я не думаю, что это на самом деле будет работать. precisionтег в php.ini только изменяет точность отображения, и фактически не увеличивает точность определенных констант. свидетель
прим
0

Юлия 0.6 , 53 байта

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

Установите точность для BigFloats достаточно высокой, затем конвертируйте piв строку и выполните поиск. Точность 9^6ручек 159980 цифр.

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

GGGG
источник
0

J, 25 байт

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

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

0-индексированные

Принимает ввод в виде строки, +2 Bytes ( ":), если это не разрешено.

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

Bolce Bussiere
источник
0

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

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

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

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

Дом Гастингс
источник