Considérez la séquence suivante:

1, 0, 1, 2, 4, 1, 6, 8, 0, 1, 2, 4, 6, 8, 1, 0, 2, 4, 6, 8, 1, 0, 2, 4, 6, 8, 0, 1, ...

Les chiffres pairs commencent à 0 et sont regroupés en séries de longueur croissante. Ils sont organisés de manière cyclique, ce qui signifie qu'ils sont triés par ordre croissant jusqu'à ce que 8 soit atteint, puis reviennent de 0 . 1 sépare les séries de chiffres pairs et démarre également la séquence. Voyons comment cette séquence est formée:

                 1, 0, 1, 2, 4, 1, 6, 8, 0, 1, 2, 4, 6, 8, 1, 0, 2, 4, 6, 8, 1,  ...

                    -     ----     -------     ----------     -------------
run length:         1      2          3            4                5            ...
position of 1:   X     X        X           X              X                 X   ...
even sequence:      0,    2, 4,    6, 8, 0,    2, 4, 6, 8,    0, 2, 4, 6, 8      ...

Méthodes d'entrée et de sortie acceptables:

• Recevez un entier N en entrée et sortez le N ème terme de cette séquence.

• Recevoir un entier N en entrée et sortez les N premiers termes de cette séquence.

• Imprimez la séquence indéfiniment.

Vous pouvez choisir l'indexation 0 ou 1 pour les deux premières méthodes.

Vous pouvez rivaliser dans n'importe quel langage de programmation , tout en utilisant les méthodes d'entrée et de sortie standard . Les failles standard sont interdites. C'est le code-golf , donc le code le plus court dans chaque langue l'emporte.

Haskell , 50 46 octets

1#cycle[0,2..8]
n#r=1:take n r++(n+1)#drop n r

Essayez-le en ligne!

1#cycle[0,2..8] renvoie la séquence sous forme de liste infinie.

-4 octets grâce à Ørjan Johansen!

Gelée , 10 octets

5ḶḤṁR€1pFḣ

Renvoie les n premiers éléments de la séquence.

Essayez-le en ligne!

Comment ça fonctionne

5ḶḤṁR€1pFḣ  Main libk. Argument: n

5           Set the return value to 5.
 Ḷ          Unlength; yield [0, 1, 2, 3, 4].
  Ḥ         Unhalve; yield [0, 2, 4, 6, 8].
    R€      Range each; yield [[1], [1, 2], [1, 2, 3], ..., [1, ..., n]].
   ṁ        Mold; in the result to the left, replace [1] with [0], [1, 2] with
            [2, 4], [1, 2, 3] with [6, 8, 0], and so forth.
      1p    Take the Cartesian product of [1] and the result.
        F   Flatten the result.
         ḣ  Head; take the first n items of the result.

Husk , 12 11 10 octets

ṁ:1CN¢mDŀ5

Essayez-le en ligne!

Imprime la séquence indéfiniment.

Alternativement:

J1CΘN¢mDŀ5

Essayez-le en ligne!

Explication

        ŀ5   Start from [0, 1, 2, 3, 4]
      mD     Double each value to get [0, 2, 4, 6, 8]
     ¢       Repeat this list indefinitely, [0, 2, 4, 6, 8, 0, 2, ...]
   CN        Cut it into chunks of increasing lengths, 
             [[0], [2, 4], [6, 8, 0], ...]
ṁ:1          Prepend 1 to each sublist and concate the resulting lists.

Pour la solution alternative:

     ¢mDŀ5   Again, get [0, 2, 4, 6, 8, 0, 2, ...].
  CΘN        This time we prepend a zero to the natural numbers, which
             prepends an empty list to the resulting chunks.
J1           Join all the sublists with 1.

Nous pourrions aussi le faire ...ΘCN..., parce Θque "préfixe l'élément par défaut", qui ajoute un zéro pour les listes d'entiers et une liste vide pour les listes de listes.

Python 3 , 52 octets

def f(n):t=(8*n+1)**.5+1;return 0==t%1or(n-t//2)%5*2

Prend un index basé sur 1 et renvoie True ou un flottant intégral .

Essayez-le en ligne!

Python 2 , 51 octets

k=n=0
while 1:print 1;k+=1;exec'print n%10;n+=2;'*k

Imprime toute la séquence.

Essayez-le en ligne!

APL, 25 octets

Renvoie le nième terme.

1,(⌽n↑⌽(+/⍳n←⎕)⍴0,2×⍳4),1

Explication

n←⎕     Prompts for screen input of integer
+/⍳      Creates a vector of integers of 1 to n and sums
⍴0,2×⍳4  Creates a vector by replicating 0 2 4 6 8 to the length of sum
⌽n↑⌽   Rotates the vector, selects first n elements and rotates result
        (selects last n elements}    
1,...,1 Concatenates 1s in front and behind result

APL (Dyalog Unicode) , 52 59 56 octets

r←c k
r←~n←0
:For j :In ⍳k
n+←j-1
r,←1,⍨j⍴n⌽0,2×⍳4
:End
r←k⍴r

Essayez-le en ligne!

Ceci est un tradfn ( trad itional f unctio n ) avec un argument ket renvoyant les premiers kéléments de la séquence.

Merci à @GalenIvanov d'avoir signalé une erreur dans la fonction. Merci à @ Adám pour 3 octets.

Comment ça fonctionne:

r←c k             ⍝ The function c takes the argument k and results in r
r n←1 0           ⍝ Initializing the variables r and n, and setting them to 1 and 0, respectively.
:For j :In ⍳k     ⍝ For loop. ⍳k yields [1, 2, 3, ..., k], and j is the control variable.
n+←j-1            ⍝ Accumulates j-1 into n, so it follows the progression (0, 1, 3, 6, 10, 15...)
r,←1,⍨j⍴n⌽0,2×⍳4  ⍝ This line is explained below.
:End              ⍝ Ends the loop
r←k⍴r             ⍝ return the first k items of r.
                  ⍝ ⍴ actually reshapes the vector r to the shape of k;
                  ⍝ since k is a scalar, ⍴ reshapes r to a vector with k items.
            2×⍳4  ⍝ APL is 1-indexed by default, so this yields the vector 2 4 6 8
          0,      ⍝ Prepend a 0 to it. We now have 0 2 4 6 8
        n⌽        ⍝ Rotate the vector n times to the left.
      j⍴          ⍝ Reshape it to have j items, which cycles the vector.
   1,⍨            ⍝ Append a 1, then
r,←               ⍝ Append everything to r.

Voici un Dfn( d IRECT f unctio n ) et une fonction tacite qui résolvent aussi le défi, à la fois aimablement fourni par @ Adám.

• Dfn: {⍵⍴1,∊1,⍨¨j⍴¨(+\¯1+j←⍳⍵)⌽¨⊂0,2×⍳4} Essayez-le en ligne!
• Tacite: ⊢⍴1,∘∊1,⍨¨⍳⍴¨(⊂0,2×⍳4)⌽⍨¨(+\¯1+⍳) Essayez-le en ligne!

JavaScript (ES6), 62 54 52 octets

Renvoie le N ème terme de la séquence, indexé 0.

n=>(g=e=>n--?g(e+=k++<l?2:k=!++l):k<l?e%10:1)(k=l=0)

Démo

let f =

n=>(g=e=>n--?g(e+=k++<l?2:k=!++l):k<l?e%10:1)(k=l=0)

for(n = 0; n < 30; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

C (gcc), 84 octets

i;j;f(){for(i=1;;i++){printf("%d ",1);for(j=0;j<i;)printf("%d ",(2*j+++i*i-i)%10);}}

Essayez-le en ligne!

Une fonction (f() ) qui imprime la séquence à l'infini, séparée par des espaces.

i est la longueur du cycle pair actuel.

j est l'indice dans le cycle pair actuel

(2*j+++i*i-i)%10 donne le nombre pair correct, étant donné i et j (et les incréments j), équivalent à ((j + Tr (i))% 5) * 2, où Tr (x) est le xième nombre triangulaire (qui est le nombre de paires les nombres qui ont été imprimés avant la même exécution en cours;

Java 8, 96 octets

v->{for(int i=0,j=-2,k;;i++,System.out.println(1))for(k=0;k++<i;System.out.println(j%=10))j+=2;}

Imprime indéfiniment, chaque numéro sur une nouvelle ligne.

Explication:

Essayez-le ici.

v->{                               // Method with empty unused parameter and no return-type
  for(int i=0,                     //  Index integer, starting at 1
          j=-2,                    //  Even index integer, starting at -2
          k;                       //  Inner index integer
      ;                            //  Loop (1) indefinitely
                                   //    After every iteration:
       i++,                        //     Increase index `i` by 1
       System.out.println(1))      //     And print a 1
    for(k=0;                       //   Reset index `k` to 0
        k++<i;                     //   Inner loop (2) from 0 to `i`
                                   //     After every iteration:
       System.out.println(j%=10))  //      Set `j` to `j` modulo-10, and print it
      j+=2;                        //    Increase `j` by 2
                                   //   End of inner loop (2) (implicit / single-line body)
                                   //  End of loop (1) (implicit / single-line body)
}                                  // End of method

Lot, 85 octets

@set/an=%2+1,t=n*-~n/2
@if %t% lss %1 %0 %1 %n%
@cmd/cset/a(%1-n)%%5*2*!!(t-=%1)+!t

Sort le Nième terme de la séquence. Fonctionne en calculant le nombre triangulaire suivant.

Perl 5 , 44 octets

do{say 1;map{say(($r+=2)%10)}0..$i++}while 1

Essayez-le en ligne!

Sortie infinie

J , 46 42 40 octets

-6 octets grâce au cole

{.({.[:;[:#:&.>2^i.);@(1,&.><;.1)10|2*i.

Génère les N premiers termes de cette séquence.

Comment ça fonctionne:

10|[:+:i. - génère une liste de longueur N de 0 2 4 6 8 0 2 4 ... Il prend simplement le mod 10 des éléments doublés d'une liste d'entiers commençant à 0.

[:;[:#:&.>2^i. - génère un masque de bits pour couper la liste ci-dessus.

(1 signifie commencer): 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 ... Il trouve 2 à la puissance des entiers non négatifs consécutifs, les convertit en binaire, aplatit le liste et prend uniquement les N premiers éléments, de sorte que la longueur des deux listes est la même.

;@(1,&.><;.1) - divise (coupe) la liste des chiffres pairs en sous-listes selon la carte des uns et des zéros, ajoute la sous-liste à 1 et aplatit finalement la liste résultante

]{. - ne prend que les N premiers éléments, en supprimant les numéros supplémentaires dans la liste en raison des 1 ajoutés.

Essayez-le en ligne!

Lisp commun, 74 octets

(do((b 1(1+ b))(k -2))(())(print 1)(dotimes(m b)(print(mod(incf k 2)10))))

Essayez-le en ligne!

Imprime la séquence indéfiniment.

Perl 5, 35 octets

{say$i--?$r++%5*2:($i=++$j)>0;redo}

essayez-le en ligne

Gelée , 17 octets

9Ḷm2ẋ⁸ṁJR$$j1 1;ḣ

Essayez-le en ligne!

Proton , 55 octets

i=0 j=-2while1{for k:0..i print(j=(j+2)%10)print(1)i++}

Essayez-le en ligne!

Imprime la séquence indéfiniment

Java (OpenJDK 8) , 107 octets

i->{String b="";for(int l=i,r=0,z=0;i>0;b+=l-i--==r?(l=i)<1+r++*0?"1":"1":"02468".charAt(z++%5));return b;}

Essayez-le en ligne!

Mathematica, 68 octets

Renvoie le Nième terme

Insert[Join@@Table[{0,2,4,6,8},#^2],1,Array[{(2-#+#^2)/2}&,#]][[#]]&

Essayez-le en ligne!

Wolfram Language (Mathematica) , 61 octets

Flatten[TakeList[2Mod[r=0~Range~#,5],UpTo/@r]~Riffle~1][[#]]&

Essayez-le en ligne!

JavaScript, 45 octets

1 indexé:

f=(x,t=0,p=0)=>p<x?f(x-1,t+1,p+t):x-p?x%5*2:1

0 indexé:

g=(x,p=0)=>p<x?g(x-1,p?++t+p:t=1):x-p?x%5*2:1

    f=(x,t=0,p=0)=>p<x?f(x-1,t+1,p+t):x-p?x%5*2:1

g=(x,p=0)=>p<x?g(x-1,p?++t+p:t=1):x-p?x%5*2:1


a.value=[...Array(100)].map((_,i)=>f(i+1))
b.value=[...Array(100)].map((_,i)=>g(i))

<output id=a></output>
<output id=b></output>

Rubis , 48 46 octets

a=b=c=0;loop{a>b&&(p 2*b%10;b+=1)||a+=c+=p(1)}

Essayez-le en ligne!

Imprimez la séquence indéfiniment

bash, 42 octets

for((;;)){ echo $[i--?r++%5*2:(i=++j)>0];}

ou 34 si valide

echo $[i--?r++%5*2:(i=++j)>0];. $0

essayez-le en ligne