Припустимо, ми почнемо з нескінченного списку простих чисел:

[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 як перший елемент.

У цьому виклику вам буде надано індекс послідовності, і ви повинні вивести індекс першого числа в тій послідовності, яка не є першою і не є 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 с.

Математика, 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..*)}

Безголовки:

{   # 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. Усі тестові випадки в TIO займають менше 2 секунд.

Як це працює

[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))

ungolf це і тест

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 секунди для пошуку g (30)