Étant donné une liste non vide L d'entiers supérieurs à 1 , nous définissons d (L) comme le plus petit entier positif tel que n + d (L) est composite pour chaque n dans L .

Nous définissons la séquence a _n comme:

• un ₀ = 2
• a _{i + 1} est le plus petit entier supérieur à a _i tel que d (a ₀ , ..., a _i , a _{i + 1} )> d (a ₀ , ..., a _i )

Ta tâche

Vous pouvez soit:

• Prenez un entier N et retournez le N-ème terme de la séquence (indexé 0 ou indexé 1)
• Prenez un entier N et retournez les N premiers termes de la séquence
• Ne saisissez rien et imprimez la séquence pour toujours

C'est du code-golf , donc la réponse la plus courte en octets l'emporte!

C'est OK si votre code devient lent comme N , mais il devrait au moins trouver les 20 premiers termes en moins de 2 minutes.

Premiers termes

• a ₀ = 2 et d (2) = 2 (nous devons ajouter 2 pour que 2 + 2 soit composite)
• a ₁ = 3 car d (2, 3) = 6 (nous devons ajouter 6 pour que 2 + 6 et 3 + 6 soient composites)
• a ₂ = 5 car d (2, 3, 5) = 7 (il faut ajouter 7 pour que 2 + 7, 3 + 7 et 5 + 7 soient tous composites), alors que d (2, 3, 4) est toujours égal à 6
• etc.

Voici les 100 premiers termes de la séquence (inconnus sur OEIS au moment de la publication).

  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 octets

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

Manifestation

Fondamentalement, nous commençons par [2], puis ajoutons les éléments 1 à la fois en trouvant alternativement d, puis en ajoutant un élément, et ainsi de suite. Sort les premiers néléments de la séquence.

Contient un filtre à l'intérieur d'un premier filtre entier à l'intérieur d'un premier filtre entier à l'intérieur d'une boucle d'application répétée.

Explication:

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

Il y a un effort répété évident entre les deux appels "Ajouter et vérifier si le premier", mais je ne sais pas comment l'éliminer.

Gelée , 31 octets

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

Essayez-le en ligne!

La gelée suce lors des séquences de récidive. : /

Rétine , 74 octets

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

Essayez-le en ligne! 0 indexé. Explication:

K`__;

Chaque ligne idans la zone de travail contient deux valeurs unaire, aᵢ;d+aᵢ. Nous commençons par a₀=2et d+a₀=0(parce que c'est golfier).

"$+"{
...
)

Répétez les Ntemps de boucle .

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

Répétez tant qu'il y a au moins un nombre non composite.

;
;_

Incrément d.

.+$
$&¶$&

Dupliquez la dernière ligne, copiez aᵢ₋₁vers aᵢ.

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

Répéter pendant que d+aᵢc'est composite.

.+$
_$&_

Incrément aᵢ.

%`\G_

Convertissez les résultats en décimal.

Nettoyer , 138 130 128 octets

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

Essayez-le en ligne!

Étendu:

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

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

Essayez-le en ligne!

(-15 octets en utilisant mes compétences de golf nouvelles et améliorées - surcharges de l'opérateur, remplacement conditionnel par ternaire et donc suppression du returnmot-clé.)

Développé :

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