Supponiamo di iniziare con l'elenco infinito di numeri primi:

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

Quindi, prendiamo le differenze assolute tra ogni coppia di numeri, ripetutamente:

[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, ...

Si noti che il numero iniziale è 1 ogni volta. La congettura di Gilbreath è la previsione che questo continua ad essere il caso per sempre.

L'unico modo in cui il numero iniziale smetterebbe di essere 1 è se il numero successivo dopo non era né uno 0 né uno 2. L'unico modo in cui il secondo numero non sarebbe uno 0 o un 2 è se il numero successivo non era né un 0 né un 2. E così via.

L'indice del primo numero, diverso dal 1 iniziale, che non è né uno 0 né un 2, non può mai scendere di più di 1 tra una coppia consecutiva di sequenze. Questo fatto è stato usato per stabilire un limite inferiore molto forte quando, se mai, una sequenza potrebbe non avere un 1 come primo elemento.

In questa sfida, ti verrà dato l'indice di una sequenza e devi generare l'indice del primo numero in quella sequenza che non è il 1 iniziale e non è uno 0 o un 2.

Ad esempio, nella quarta sequenza di differenze assolute sopra:

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

La prima voce che non è né uno zero né due, oltre alla prima, è la 15a posizione, 14 zero indicizzata. Quindi, se l'ingresso fosse 4, si otterrebbe 14.

Per gli ingressi da 1 a 30, le uscite dovrebbero essere:

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

Questo è OEIS A000232 .

Ciò presuppone che tu abbia 1 input indicizzati e 0 output indicizzati. Puoi indicizzare i tuoi input e output a partire da qualsiasi numero intero costante, purché tu possa accettare l'intervallo di input corrispondente a tutte le sequenze.

Requisiti: la soluzione deve essere eseguita al massimo 1 minuto con un input fino a 30. Se è abbastanza vicino da dipendere dalle specifiche del computer, è consentito.

Il codice più corto vince.

Gelatina , 17 byte

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

Provalo online!

L'input è indicizzato 2. L'output è 1-indicizzazione.

Su TIO tutti i test in totale richiedono 22.309 s.

Mathematica, 66 byte

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

Funzione pura che accetta un numero intero positivo come argomento e restituisce un numero intero con 1 indice. Nest[Abs@*Differences,Array[Prime,z+#],#]calcola l' #elenco delle differenze assolute ripetute dell'elenco dei primi z+#primi. For[z=1,Last@...<3,z++]esegue il ciclo di questo calcolo fino a quando l'ultimo elemento dell'elenco risultante è almeno 3e quindi zviene emesso. (Nota che la correttezza dell'algoritmo presuppone la congettura di Gilbreath!)

Pyth , 32 byte

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

Provalo online!

Utilizza l'indicizzazione 2.

MATL , 18 byte

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

Input e output sono basati su 1. Sono necessari meno di 40 secondi in TIO per ciascuno dei casi di test.

Provalo online!

Spiegazione

Ciò continua a provare sequenze iniziali più lunghe di numeri primi fino a quando le differenze consecutive assolute ripetute danno almeno un valore superiore 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 byte

{->\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 .. *);
}

Con un input di 30, la funzione viene eseguita in circa quattro secondi sul mio laptop modesto.

... che diventa 1,4 secondi dopo l'aggiornamento della mia installazione di Perl 6 di sette mesi (che mi dà anche il skipmetodo che mi permette di radere diversi byte dalla mia prima soluzione). Tutti i casi di test da 1 a 30 richiedono circa dieci secondi.

Haskell , 94 byte

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]]!!)

Provalo online! L'ultima riga è una funzione anonima. Associa ad esempio ge chiama like g 4. Tutti i casi di test combinati richiedono meno di 2 secondi su TIO.

Come funziona

[n|n<-[2..],all((>0).mod n)[2..n-1]]genera un elenco infinito di numeri primi.
f(a:b:r)=abs(a-b):f(b:r)è una funzione che produce le differenze assolute degli elementi di un elenco infinito. Dato un numero n, (iterate f[n|n<-[2..],all((>0).mod n)[2..n-1]]!!)applica i f ntempi all'elenco dei numeri primi. length.fst.span(<3)calcola la lunghezza del prefisso dell'elenco risultante in cui gli elementi sono più piccoli 3.

Assioma, 289 byte

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

scappare e testare

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]

se non trova la soluzione espandi la lista principale di 2 * x in un ciclo e ricalcola tutte le liste rimanenti. 3 secondi per find g (30)