Предположим, мы начинаем с бесконечного списка простых чисел:

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, ...

Затем мы берем абсолютные различия между каждой парой чисел, многократно:

[1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, ...
[1, 0, 2, 2, 2, 2, 2, 2, 4, 4, 2, 2, 2, 2, 0, 4, 4, 2, ...
[1, 2, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 2, 4, 0, 2, ...
[1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 4, 2, ...

Обратите внимание, что ведущий номер равен 1 каждый раз. Гипотеза Гилбрита - это предсказание, что так будет всегда.

Единственный способ, чтобы старшее число перестало быть 1, это если следующий номер после него не был ни 0, ни 2. Единственный способ, которым второе число не было бы 0 или 2, это если бы число после этого не было ни 0 ни 2. И так далее.

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

В этом задании вам дадут индекс последовательности, и вы должны вывести индекс первого числа в этой последовательности, которое не является ведущим 1 и не является 0 или 2.

Например, в 4-й последовательности абсолютных разностей выше:

[1, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 4, 2, ...

Первая запись, которая не является ни нулем, ни двумя, кроме первой записи, является 15-й позицией, 14 индексированными нулями. Так что, если на входе было 4, вы бы вывели 14.

Для входов от 1 до 30 выходы должны быть:

[3, 8, 14, 14, 25, 24, 23, 22, 25, 59, 98, 97, 98, 97, 174, 176, 176, 176, 176, 291, 290, 289, 740, 874, 873, 872, 873, 872, 871, 870]

Это OEIS A000232 .

Предполагается, что у вас есть 1 проиндексированный вход и 0 проиндексированных выходов. Вы можете индексировать свои входы и выходы, начиная с любых постоянных целых чисел, при условии, что вы можете принять диапазон входных данных, соответствующий всем последовательностям.

Требования: Ваше решение должно работать не более 1 минуты при входе до 30. Если оно достаточно близко, чтобы зависеть от характеристик компьютера, оно разрешено.

Самый короткий код выигрывает.

Желе , 17 байт

ÆNạ2\Ḋ¿Ḣ’Ị
R‘ÇпL

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

Ввод 2-индексация. Выход 1-индексация.

На TIO все тесты в общей сложности занимают 22,309 с.

Mathematica, 66 байт

(For[z=1,Last@Nest[Abs@*Differences,Array[Prime,z+#],#]<3,z++];z)&

Чистая функция, принимающая положительное целое число в качестве аргумента и возвращающая целое число с 1 индексом. Nest[Abs@*Differences,Array[Prime,z+#],#]вычисляет #повторный список абсолютных разностей списка первых z+#простых чисел. For[z=1,Last@...<3,z++]Зацикливает это вычисление до тех пор, пока не будет хотя бы последний элемент результирующего списка 3, а затем zвыводится. (Обратите внимание, что правильность алгоритма предполагает гипотезу Гилбрита!)

Pyth , 32 байта

-l.W>3h.WtHaVZtZ>QH+ZfP_TheZ.fP_

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

Использует 2-индексацию.

MATL , 18 байт

`@:YqG:"d|]3<A}@G-

Вход и выход основаны на 1. Для каждого из тестовых случаев в TIO требуется менее 40 секунд.

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

объяснение

Это продолжает пробовать более длинные начальные последовательности простых чисел, пока повторяющиеся абсолютные последовательные различия не дадут хотя бы одно превышение значения 2.

`        % Do... while loop
  @:Yq   %   Array of first k primes, where k is iteration index
  G:"    %   Do this as many times as the input
    d|   %     Absolute value of consecutive differences
  ]      %   End
  3<A    %   Are they all less than 3? This is the loop condition
}        % Finally (execute before exiting loop)
  @G-    %   Push last iteration index minus input. This is the output
         % End (implicit). Continue with next iteration if top of stack is true
         % Display (implicit)

Perl 6 , 136 120 байт

{->\i,\n{i??&?BLOCK(i-1,lazy
n.rotor(2=>-1).map: {abs .[1]-.[0]})!!1+n.skip.first:
:k,none 0,2}($_,grep &is-prime,2..*)}

Ungolfed:

{   # Anonymous function with argument in $_
    sub f(\i, \n) {  # Recursive helper function
        if i != 0 {  # If we're not done,
            # Recurse on the absolute differences between adjacent entries:
            f(i - 1, lazy n.rotor(2 => -1).map: { abs .[1] - .[0] });
        } else {
            # Otherwise, return the first index after 0
            # where the value is neither 0 nor 2.
            1 + n.skip.first: :k, none 0, 2;
        }
    }
    # Call the helper function with the argument passed to the top-level
    # anonymous function (the recursion depth), and with the prime numbers
    # as the initial (infinite, lazy) list:
    f($_, grep &is-prime, 2 .. *);
}

При вводе 30 функция запускается примерно за четыре секунды на моем скромном ноутбуке.

... который становится равным 1,4 секундам после обновления моей семимесячной установки Perl 6 (что также дает мне skipметод, который позволяет мне сбрить несколько байтов из моего первого решения). Все тестовые случаи от 1 до 30 занимают около десяти секунд.

Haskell , 94 байта

f(a:b:r)=abs(a-b):f(b:r)
length.fst.span(<3).(iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)

Попробуйте онлайн! Последняя строка является анонимной функцией. Привязать к например gи позвонить, как g 4. Все тестовые случаи в совокупности занимают менее 2 секунд на TIO.

Как это устроено

[n|n<-[2..],all((>0).mod n)[2..n-1]]генерирует бесконечный список простых чисел.
f(a:b:r)=abs(a-b):f(b:r)является функцией, дающей абсолютные различия элементов бесконечного списка. Учитывая число n, (iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)применяется f nраз к списку простых чисел. length.fst.span(<3)вычисляет длину префикса результирующего списка, где элементы меньше 3.

Аксиома, 289 байт

g(n:PI):PI==(k:=n*10;c:List NNI:=[i for i in 1..(k quo 2)|prime?(i)];repeat(a:=concat(c,[i for i in (k quo 2+1)..k|prime?(i)]);j:=0;c:=a;repeat(j=n=>break;j:=j+1;b:=a;a:=[abs(b.(i+1)-b.i)for i in 1..(#b-1)]);j:=2;repeat(j>#a=>break;a.j~=2 and a.j~=1 and a.j~=0=>return j-1;j:=j+1);k:=k*2))

раскрутить и проверить

f(n:PI):PI==
  k:=n*10
  c:List NNI:=[i for i in 1..(k quo 2)|prime?(i)]
  repeat
    a:=concat(c,[i for i in (k quo 2+1)..k|prime?(i)])
    j:=0;c:=a
    repeat
       j=n=>break
       j:=j+1
       b:=a
       a:=[abs(b.(i+1)-b.i)  for i in 1..(#b-1)]
    j:=2
    repeat
       j>#a=>break
       a.j~=2 and a.j~=1 and a.j~=0 => return j-1
       j:=j+1
    k:=k*2

(4) -> [g(i)  for i in 1..30]
   (4)
   [3, 8, 14, 14, 25, 24, 23, 22, 25, 59, 98, 97, 98, 97, 174, 176, 176, 176,
    176, 291, 290, 289, 740, 874, 873, 872, 873, 872, 871, 870]

Если решение не найдено, разверните список простых чисел 2 * x в цикле и пересчитайте все оставшиеся списки. 3 секунды для поиска г (30)