Considera la seguente sequenza:

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

Le cifre pari iniziano da 0 e sono raggruppate in serie di lunghezza crescente. Sono disposti ciclicamente, il che significa che sono ordinati in ordine crescente fino a quando non viene raggiunto 8 , e quindi riavviati da 0 . 1 separa le serie di cifre pari e avvia anche la sequenza. Visualizziamo come si forma questa sequenza:

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

Metodi di input e output accettabili:

• Ricevere un numero intero N come ingresso e uscita del N esimo termine di questa sequenza.

• Ricevi un intero N come input e genera i primi N termini di questa sequenza.

• Stampa la sequenza indefinitamente.

Puoi scegliere 0 o 1-indicizzazione per i primi due metodi.

Puoi competere in qualsiasi linguaggio di programmazione , utilizzando i metodi di input e output standard . Sono vietate le scappatoie standard . Questo è code-golf , quindi vince il codice più corto in ogni lingua.

Haskell , 50 46 byte

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

Provalo online!

1#cycle[0,2..8] restituisce la sequenza come lista infinita.

-4 byte grazie a Ørjan Johansen!

Gelatina , 10 byte

5ḶḤṁR€1pFḣ

Restituisce i primi n elementi della sequenza.

Provalo online!

Come funziona

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.

Buccia , 12 11 10 byte

ṁ:1CN¢mDŀ5

Provalo online!

Stampa la sequenza indefinitamente.

In alternativa:

J1CΘN¢mDŀ5

Provalo online!

Spiegazione

        ŀ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.

Per la soluzione alternativa:

     ¢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.

Potremmo anche fare ...ΘCN..., perché Θ"antepone elemento predefinito", che antepone uno zero per gli elenchi di numeri interi e un elenco vuoto per gli elenchi di elenchi.

Python 3 , 52 byte

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

Prende un indice basato su 1 e restituisce True o un float integrale .

Provalo online!

Python 2 , 51 byte

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

Stampa l'intera sequenza.

Provalo online!

APL, 25 byte

Restituisce l'ennesimo termine.

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

Spiegazione

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 byte

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

Provalo online!

Questo è un tradfn ( trad pre- sentano f unctio n ) avendo un argomento ke restituire i primi kelementi della sequenza.

Grazie a @GalenIvanov per aver segnalato un errore nella funzione. Grazie a @ Adám per 3 byte.

Come funziona:

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.

Qui di seguito sono Dfn( d ire f unctio n ) e una funzione tacita che anche a risolvere la sfida, sia gentilmente fornito da @ ADAM.

• Dfn: {⍵⍴1,∊1,⍨¨j⍴¨(+\¯1+j←⍳⍵)⌽¨⊂0,2×⍳4} provalo online!
• Tacit: ⊢⍴1,∘∊1,⍨¨⍳⍴¨(⊂0,2×⍳4)⌽⍨¨(+\¯1+⍳) provalo online!

JavaScript (ES6), 62 54 52 byte

Restituisce la N esimo termine della sequenza, 0-indicizzati.

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

dimostrazione

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 byte

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

Provalo online!

Una funzione ( f()) che stampa la sequenza all'infinito, separata da spazi.

i è la lunghezza dell'attuale corsa uniforme.

j è l'indice nell'attuale corsa regolare

(2*j+++i*i-i)%10 fornisce il numero pari corretto, dato i e j (e incrementi j), equivalente a ((j + Tr (i))% 5) * 2, dove Tr (x) è il numero esimo triangolare (che è il numero di pari numeri che sono stati stampati prima che l'attuale corrente venga eseguita;

Java 8, 96 byte

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;}

Stampa indefinitamente, ogni numero su una nuova riga.

Spiegazione:

Provalo qui.

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

Lotto, 85 byte

@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

Emette l'ennesimo termine della sequenza. Funziona calcolando il prossimo numero triangolare.

Perl 5 , 44 byte

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

Provalo online!

Uscita infinita

J , 46 42 40 byte

-6 byte grazie a Cole

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

Emette i primi N termini di questa sequenza.

Come funziona:

10|[:+:i. - genera un elenco di lunghezza N di 0 2 4 6 8 0 2 4 ... Prende semplicemente mod 10 degli elementi doppi di un elenco di numeri interi che inizia da 0.

[:;[:#:&.>2^i. - genera una maschera di bit per tagliare l'elenco sopra.

(1 significa start): 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 ... Trova 2 alla potenza degli interi consecutivi non negativi, li converte in binari, appiattisce il elenca e accetta solo i primi N elementi, in modo che la lunghezza di entrambi gli elenchi sia la stessa.

;@(1,&.><;.1) - suddivide (taglia) l'elenco delle cifre pari in elenchi secondari secondo la mappa di uno e zero, accoda l'elenco secondario a 1 e infine appiattisce l'elenco risultante

]{. - accetta solo i primi N elementi, eliminando i numeri aggiuntivi nell'elenco a causa degli 1 aggiunti.

Provalo online!

Lisp comune, 74 byte

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

Provalo online!

Stampa la sequenza indefinitamente.

Perl 5, 35 byte

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

provalo online

Gelatina , 17 byte

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

Provalo online!

Proton , 55 byte

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

Provalo online!

Stampa la sequenza indefinitamente

Java (OpenJDK 8) , 107 byte

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;}

Provalo online!

Mathematica, 68 byte

Restituisce l'ennesimo termine

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

Provalo online!

Wolfram Language (Mathematica) , 61 byte

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

Provalo online!

JavaScript, 45 byte

1 indicizzato:

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

0 indicizzato:

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>

Rubino , 48 46 byte

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

Provalo online!

Stampa la sequenza indefinitamente

bash, 42 byte

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

o 34 se valido

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

provalo online