Considere a seguinte sequência:

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

Os dígitos pares começam em 0 e são agrupados em execuções de comprimento crescente. Eles são organizados ciclicamente, o que significa que são classificados em ordem crescente até que 8 seja alcançado e depois retornados de 0 . 1 separa as execuções de dígitos pares e também inicia a sequência. Vamos visualizar como essa sequência é formada:

                 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 e saída aceitáveis:

• Receber um número inteiro N como entrada e saída da N th termo desta sequência.

• Receba um inteiro N como entrada e faça a saída do primeiro N termos dessa sequência.

• Imprima a sequência indefinidamente.

Você pode escolher a indexação 0 ou 1 para os dois primeiros métodos.

Você pode competir em qualquer linguagem de programação enquanto usa os métodos padrão de entrada e saída . As brechas padrão são proibidas. Isso é código-golfe , então o código mais curto em cada idioma vence.

Haskell , 50 46 bytes

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

Experimente online!

1#cycle[0,2..8] retorna a sequência como lista infinita.

-4 bytes graças a Ørjan Johansen!

Gelatina , 10 bytes

5ḶḤṁR€1pFḣ

Retorna os primeiros n itens da sequência.

Experimente online!

Como 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

Experimente online!

Imprime a sequência indefinidamente.

Alternativamente:

J1CΘN¢mDŀ5

Experimente online!

Explicação

        ŀ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 a solução 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.

Também podemos fazer isso ...ΘCN..., porque Θ"precede o elemento padrão", que precede zero para listas de números inteiros e uma lista vazia para 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

Pega um índice baseado em 1 e retorna True ou um float integral .

Experimente online!

Python 2 , 51 bytes

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

Imprime a sequência inteira.

Experimente online!

APL, 25 bytes

Retorna o enésimo termo.

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

Explicação

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

Experimente online!

Esta é uma tradfn ( trad itional f unctio n ) recebendo um argumento ke retornando o primeirok itens da sequência.

Agradecemos a @GalenIvanov por apontar um erro na função. Obrigado a @ Adám por 3 bytes.

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

Abaixo estão Dfn( d espirre f unctio n ) e uma função tácita de que também resolver o desafio, tanto gentilmente cedido por @ Adão.

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

JavaScript (ES6), 62 54 52 bytes

Retorna o N ° termo de sequência, 0-indexado.

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

Demo

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

Experimente online!

Uma função (f() ) que imprime a sequência infinitamente, separada por espaços.

i é o comprimento da atual execução uniforme.

j é o índice na atual execução uniforme

(2*j+++i*i-i)%10 fornece o número par correto, dados iej (e incrementos j), equivalente a ((j + Tr (i))% 5) * 2, onde Tr (x) é o décimo número triangular (que é o número de pares) números que foram impressos antes da execução atual;

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 em uma nova linha.

Explicação:

Experimente aqui.

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

Gera o enésimo termo da sequência. Funciona calculando o próximo número triangular.

Perl 5 , 44 bytes

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

Experimente online!

Saída infinita

J , 46 42 40 bytes

-6 bytes graças a cole

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

Emite os primeiros N termos desta sequência.

Como funciona:

10|[:+:i. - gera uma lista de comprimento N de 0 2 4 6 8 0 2 4 ... Simplesmente usa o mod 10 dos itens duplicados de uma lista de números inteiros começando em 0.

[:;[:#:&.>2^i. - gera uma máscara de bits para cortar a lista acima.

(1 significa início): 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 ... Encontra 2 à potência dos números inteiros não negativos consecutivos, converte-os em binário, nivela o lista e leva apenas os primeiros N itens, para que o comprimento das duas listas seja o mesmo.

;@(1,&.><;.1) - divide (corta) a lista dos dígitos pares em sublistas, de acordo com o mapa de um e zeros, anexa a sub-lista a 1 e, por fim, nivela a lista resultante

]{. - pega apenas os primeiros N itens, eliminando os números adicionais na lista devido aos 1s adicionados.

Experimente online!

Lisp comum, 74 bytes

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

Experimente online!

Imprime a sequência indefinidamente.

Perl 5, 35 bytes

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

experimente online

Gelatina , 17 bytes

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

Experimente online!

Próton , 55 bytes

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

Experimente online!

Imprime a sequência 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;}

Experimente online!

Mathematica, 68 bytes

Retorna o enésimo termo

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

Experimente online!

Wolfram Language (Mathematica) , 61 bytes

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

Experimente online!

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

Experimente online!

Imprimir a sequência indefinidamente

bash, 42 bytes

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

ou 34, se válido

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

experimente online