Dada uma lista não-vazia L de números inteiros maiores do que 1 , definimos d (G) como o menor número inteiro positivo, tal que n + d (G) é composta de cada n em G .

Definimos a sequência a _n como:

• a ₀ = 2
• a _{i + 1} é o menor número inteiro maior que a _{i, de} modo que d (a ₀ , ..., a _i , a _{i + 1} )> d (a ₀ , ..., a _i )

Sua tarefa

Você pode:

• Pegue um número inteiro N e retorne o N-ésimo termo da sequência (indexado 0 ou indexado 1)
• Pegue um número inteiro N e retorne os primeiros N termos da sequência
• Não aceite entrada e imprima a sequência para sempre

Isso é código-golfe , então a resposta mais curta em bytes vence!

Tudo bem se seu código estiver ficando lento à medida que N for maior, mas ele deve encontrar pelo menos os 20 primeiros termos em menos de 2 minutos.

Primeiros termos

• um ₀ = 2 e d (2) = 2 (que precisa de adicionar 2, de modo que 2 + 2 é composta)
• a ₁ = 3 porque d (2, 3) = 6 (precisamos adicionar 6 para que 2 + 6 e 3 + 6 sejam compostos)
• a ₂ = 5 porque d (2, 3, 5) = 7 (precisamos adicionar 7 para que 2 + 7, 3 + 7 e 5 + 7 sejam todos compostos), enquanto d (2, 3, 4) ainda é igual a 6
• etc.

Abaixo estão os 100 primeiros termos da sequência (desconhecidos no OEIS no momento da postagem).

  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

Pitão, 24 bytes

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

Demonstração

Basicamente, começamos com [2], em seguida, adicionamos elementos 1 por vez, localizando alternadamente d, adicionando um elemento e assim por diante. Produz os primeiros nelementos da sequência.

Contém um filtro dentro de um primeiro filtro inteiro dentro de um primeiro filtro inteiro dentro de um loop aplicar repetidamente.

Explicação:

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

Existe um esforço óbvio e repetido entre as duas chamadas "Adicionar e verificar se prime", mas não sei como eliminá-la.

Gelatina , 31 bytes

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

Experimente online!

A geléia é uma droga nas seqüências de recorrência. : /

Retina , 74 bytes

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

Experimente online! Indexado a 0. Explicação:

K`__;

Cada linha ina área de trabalho contém dois valores unários aᵢ;d+aᵢ,. Começamos com a₀=2e d+a₀=0(porque é mais golfista).

"$+"{
...
)

Repita os Ntempos do loop .

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

Repita enquanto houver pelo menos um número não composto.

;
;_

Incremento d.

.+$
$&¶$&

Duplique a última linha, copiando aᵢ₋₁para aᵢ.

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

Repita enquanto d+aᵢestiver composto.

.+$
_$&_

Incremento aᵢ.

%`\G_

Converta os resultados em decimal.

Limpo , 138 130 128 bytes

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

Experimente online!

Expandido:

$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 bytes

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

Experimente online!

(-15 bytes usando minhas habilidades novas e aprimoradas de golfe - sobrecargas do operador, substituindo condicional por ternário e, portanto, removendo a returnpalavra-chave.)

Expandido :

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