Data una lista non vuota L di numeri interi maggiori di 1 , definiamo d (L) come il più piccolo intero positivo tale che n + d (L) è composto per ogni n in L .

Definiamo la sequenza a _n come:

• a ₀ = 2
• a _{i + 1} è il numero intero più piccolo maggiore di a _i tale che d (a ₀ , ..., a _i , a _{i + 1} )> d (a ₀ , ..., a _i )

Il tuo compito

Puoi:

• Prendi un numero intero N e restituisce il termine N-esimo della sequenza (0-indicizzato o 1-indicizzato)
• Prendi un numero intero N e restituisce i primi N termini della sequenza
• Non inserire input e stampare la sequenza per sempre

Questo è code-golf , quindi vince la risposta più breve in byte!

Va bene se il tuo codice sta diventando lento man mano che N diventa più grande, ma dovrebbe almeno trovare i primi 20 termini in meno di 2 minuti.

Primi termini

• a ₀ = 2 e d (2) = 2 (dobbiamo aggiungere 2 in modo che 2 + 2 sia composito)
• a ₁ = 3 perché d (2, 3) = 6 (dobbiamo aggiungere 6 in modo che 2 + 6 e 3 + 6 siano compositi)
• a ₂ = 5 perché d (2, 3, 5) = 7 (dobbiamo aggiungere 7 in modo che 2 + 7, 3 + 7 e 5 + 7 siano tutti compositi), mentre d (2, 3, 4) è ancora uguale a 6
• eccetera.

Di seguito sono riportati i primi 100 termini della sequenza (sconosciuti su OEIS al momento della pubblicazione).

  2,   3,   5,   6,  10,  15,  17,  19,  22,  24,
 30,  34,  35,  39,  41,  47,  51,  54,  56,  57,
 70,  79,  80,  82,  92,  98, 100, 103, 106, 111,
113, 116, 135, 151, 158, 162, 165, 179, 183, 186,
191, 192, 200, 210, 217, 223, 226, 228, 235, 240,
243, 260, 266, 274, 277, 284, 285, 289, 298, 307,
309, 317, 318, 329, 341, 349, 356, 361, 374, 377,
378, 382, 386, 394, 397, 405, 409, 414, 417, 425,
443, 454, 473, 492, 494, 502, 512, 514, 519, 527,
528, 560, 572, 577, 579, 598, 605, 621, 632, 642

Pyth, 24 byte

Pu+GfP_+Tf!fP_+ZYG)eGQ]2

Dimostrazione

Fondamentalmente, iniziamo con [2], quindi aggiungiamo elementi 1 alla volta trovando alternativamente d, quindi aggiungendo un elemento e così via. Emette i primi nelementi della sequenza.

Contiene un filtro all'interno di un primo filtro intero all'interno di un primo filtro intero all'interno di un ciclo Apply ripetutamente.

Spiegazione:

Pu+GfP_+Tf!fP_+ZYG)eGQ]2
 u                   Q]2    Starting with `[2]`, do the following as many times
                            as the input
         f        )         Starting from 1 and counting upward, find d where
          !f     G          None of the elements in the current list
            P_+ZY           plus d give a prime.
    f              eG       Starting from the end of the current list and counting
                            upward, find the first number which
     P_+T                   plus d gives a prime.
  +G                        Append the new number to the current list
P                           Trim the last element of the list

C'è evidente sforzo ripetuto tra le due chiamate "Aggiungi e verifica se prime", ma non sono sicuro di come eliminarlo.

Gelatina , 31 byte

ṛ,;1+ÆPẸṆʋ1#ⱮẎ</
Ḷ߀‘Ṫç1#ƊḢƲ2⁸?

Provalo online!

Jelly succhia le sequenze di ricorrenza. : /

Retina , 74 byte

K`__;
"$+"{/;(?!(__+)\1+\b)/+`;
;_
.+$
$&¶$&
)/;(__+)\1+$/+`.+$
_$&_
%`\G_

Provalo online! 0-indicizzati. Spiegazione:

K`__;

Ogni riga inell'area di lavoro contiene due valori unari aᵢ;d+aᵢ. Iniziamo con a₀=2e d+a₀=0(perché è più golfista).

"$+"{
...
)

Ripeti i Ntempi di ciclo .

/;(?!(__+)\1+\b)/+`

Ripetere finché è presente almeno un numero non composito.

;
;_

Incremento d.

.+$
$&¶$&

Duplica l'ultima riga, copiandola aᵢ₋₁in aᵢ.

/;(__+)\1+$/+`

Ripeti finché d+aᵢè composto.

.+$
_$&_

Incremento aᵢ.

%`\G_

Converti i risultati in decimale.

Pulito , 138 130 128 byte

import StdEnv
$l=until(\v=all(\n=any((<)1o gcd(n+v))[2..n+v-1])l)inc 1

map hd(iterate(\l=hd[[n:l]\\n<-[hd l..]| $[n:l]> $l])[2])

Provalo online!

Allargato:

$l=until(\v=all(\n=any((<)1o gcd(n+v))[2..n+v-1])l)inc 1
$l=until(                                         )inc 1  // first value from 1 upwards where _
         \v=all(                                )l        // _ is true for everything in l
                \n=any(              )[2..n+v-1]          // any of [2,3..n+v-1] match _
                             gcd(n+v)                     // the gcd of (n+v) and ^
                           o                              // (composed) ^ is _
                       (<)1                               // greater than 1

map hd(iterate(\l=hd[[n:l]\\n<-[hd l..]| $[n:l]> $l])[2]) 
map hd(                                                 ) // the first element of each list in _
       iterate(                                     )[2]  // infinite repeated application of _ to [2]
               \l=hd[                              ]      // the head of _
                     [n:l]                                // n prepended to l
                          \\n<-[hd l..]                   // for every integer n greater than the head of l
                                       | $[n:l]> $l       // where d(n0..ni+1) > d(n0..ni)

Julia 0.6 , 145 130 byte

~L=(x=1;while any(map(m->all(m%i>0 for i=2:m-1),L+x));x+=1;end;x)
!n=n<1?[2]:(P=!(n-1);t=P[end]+1;while ~[P;t]<=~P;t+=1;end;[P;t])

Provalo online!

(-15 byte usando le mie abilità golfistiche nuove e migliorate - sovraccarichi dell'operatore, sostituzione del condizionale con ternario e quindi rimozione della returnparola chiave.)

Espanso :

function primecheck(m)
    all(m%i>0 for i∈2:m-1)
end

function d(L)
    x = 1
    while any(map(primecheck, L+x))
        x += 1
    end
    return x
end

function a(n)
    n > 0 || return [2]
    Prev = a(n-1)
    term = Prev[end] + 1
    while d([Prev;term]) ≤ d(Prev)
        term += 1
    end
    return [Prev;term]
end