Considere la siguiente secuencia:

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

Los dígitos pares comienzan desde 0 y se agrupan en series de longitud creciente. Se organizan cíclicamente, lo que significa que se ordenan en orden ascendente hasta alcanzar 8 y luego se vuelven a poner en ciclo desde 0 . 1 separa las corridas de dígitos pares, y también comienza la secuencia. Visualicemos cómo se forma esta secuencia:

                 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étodos de entrada y salida aceptables:

• Recibe un número entero N como entrada y salida de la N º término de esta secuencia.

• Reciba un entero N como entrada y salida de los primeros N términos de esta secuencia.

• Imprime la secuencia indefinidamente.

Puede elegir 0 o 1 indexación para los dos primeros métodos.

Puede competir en cualquier lenguaje de programación , mientras usa los métodos estándar de entrada y salida . Las lagunas estándar están prohibidas. Este es el código de golf , por lo que gana el código más corto en cada idioma.

Haskell , 50 46 bytes

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

Pruébalo en línea!

1#cycle[0,2..8] devuelve la secuencia como lista infinita.

-4 bytes gracias a Ørjan Johansen!

Jalea , 10 bytes

5ḶḤṁR€1pFḣ

Devuelve el primero n elementos de la secuencia.

Pruébalo en línea!

Cómo funciona

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.

Casco , 12 11 10 bytes

ṁ:1CN¢mDŀ5

Pruébalo en línea!

Imprime la secuencia indefinidamente.

Alternativamente:

J1CΘN¢mDŀ5

Pruébalo en línea!

Explicación

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

Para la solución 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.

También podríamos hacerlo ...ΘCN..., porque Θ"antepone el elemento predeterminado", que antepone un cero para las listas de enteros y una lista vacía para las listas de listas.

Python 3 , 52 bytes

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

Toma un índice basado en 1 y devuelve True o un flotante integral .

Pruébalo en línea!

Python 2 , 51 bytes

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

Imprime toda la secuencia.

Pruébalo en línea!

APL, 25 bytes

Devuelve el enésimo término.

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

Explicación

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 bytes

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

Pruébalo en línea!

Este es un tradfn ( trad itional f unctio n ) teniendo un argumento ky devolver la primerak elementos de la secuencia.

Gracias a @GalenIvanov por señalar un error en la función. Gracias a @ Adám por 3 bytes.

Cómo funciona:

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.

A continuación se presentan Dfn( d directo teléfono f unctio n ) y una función tácito de que también a resolver el reto, tanto amablemente proporcionado por @ ADAM.

• Dfn: ¡ {⍵⍴1,∊1,⍨¨j⍴¨(+\¯1+j←⍳⍵)⌽¨⊂0,2×⍳4} Pruébalo en línea!
• Tácito: ¡ ⊢⍴1,∘∊1,⍨¨⍳⍴¨(⊂0,2×⍳4)⌽⍨¨(+\¯1+⍳) Pruébelo en línea!

JavaScript (ES6), 62 54 52 bytes

Devuelve el N º término de la secuencia, 0-indexados.

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

Manifestación

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 bytes

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

Pruébalo en línea!

Una función ( f()) que imprime la secuencia infinitamente, separada por espacios.

i es la longitud de la ejecución par actual.

j es el índice en el par actual

(2*j+++i*i-i)%10 da el número par correcto, dados i y j (e incrementos j), equivalente a ((j + Tr (i))% 5) * 2, donde Tr (x) es el número triangular x (que es el número de pares números que se han impreso antes de la ejecución actual;

Java 8, 96 bytes

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 indefinidamente, cada número en una nueva línea.

Explicación:

Pruébalo aquí.

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

Lote, 85 bytes.

@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

Emite el enésimo término de la secuencia. Funciona calculando el siguiente número triangular.

Perl 5 , 44 bytes

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

Pruébalo en línea!

Salida infinita

J , 46 42 40 bytes

-6 bytes gracias a cole

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

Emite los primeros N términos de esta secuencia.

Cómo funciona:

10|[:+:i. - genera una lista de longitud N de 0 2 4 6 8 0 2 4 ... Simplemente toma el mod 10 de los elementos duplicados de una lista de enteros que comienzan en 0.

[:;[:#:&.>2^i. - genera una máscara de bits para cortar la lista anterior.

(1 significa inicio): 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 ... Encuentra 2 a la potencia de los enteros consecutivos no negativos, los convierte en binarios, aplana el lista y toma solo los primeros N elementos, de modo que la longitud de ambas listas sea la misma.

;@(1,&.><;.1) - divide (corta) la lista de los dígitos pares en sublistas según el mapa de unos y ceros, agrega la sublista a 1 y finalmente aplana la lista resultante

]{. - toma solo los primeros N elementos, eliminando los números adicionales en la lista debido a los 1s agregados.

Pruébalo en línea!

Lisp común, 74 bytes

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

Pruébalo en línea!

Imprime la secuencia indefinidamente.

Perl 5, 35 bytes

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

pruébalo en línea

Jalea , 17 bytes

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

Pruébalo en línea!

Protón , 55 bytes

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

Pruébalo en línea!

Imprime la secuencia indefinidamente

Java (OpenJDK 8) , 107 bytes

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

Pruébalo en línea!

Mathematica, 68 bytes

Devuelve el enésimo término

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 61 bytes

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

Pruébalo en línea!

JavaScript, 45 bytes

1 indexado:

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

0 indexado:

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>

Ruby , 48 46 bytes

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

Pruébalo en línea!

Imprime la secuencia indefinidamente

bash, 42 bytes

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

o 34 si es válido

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

pruébalo en línea