请考虑以下顺序：

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

偶数位从0开始，并分组为长度递增的游程。它们循环排列，这意味着它们以升序排序，直到达到8，然后从0开始循环。1分隔偶数位的运行，它也开始序列。让我们直观地看一下该序列的形成方式：

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

可接受的输入和输出方法：

• 接收整数N作为输入，并输出此序列的第N个项。

• 接收整数N作为输入，并输出此序列的前N个项。

• 无限期打印序列。

您可以为前两种方法选择0或1索引。

使用标准输入和输出方法时，您可以在任何编程语言中竞争。禁止出现标准漏洞。这是代码高尔夫球，因此每种语言中最短的代码将获胜。

Haskell，50 46字节

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

在线尝试！

1#cycle[0,2..8] 将序列作为无限列表返回。

-4个字节感谢ØrjanJohansen！

果冻，10字节

5ḶḤṁR€1pFḣ

返回序列的前n个项目。

在线尝试！

怎么运行的

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.

外壳，12 11 10字节

ṁ:1CN¢mDŀ5

在线尝试！

无限期打印序列。

或者：

J1CΘN¢mDŀ5

在线尝试！

说明

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

对于替代解决方案：

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

我们也可以这样做...ΘCN...，因为Θ“ prepend default element”确实存在，它为整数列表添加了零，为列表列表添加了空列表。

Python 3，52个字节

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

接受从1开始的索引，并返回True或整数float。

在线尝试！

Python 2，51个字节

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

打印整个序列。

在线尝试！

APL，25个字节

返回第n项。

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

说明

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字节

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

在线尝试！

这是一个tradfn（TRAD itional ˚F unctio Ñ）带一个参数k和返回第一k序列的项目。

感谢@GalenIvanov指出函数中的错误。感谢@Adám提供了3个字节。

怎么运行的：

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.

下面是一个Dfn（d I整流器˚F unctio Ñ）和隐性功能也解决了挑战，既麻烦由@亚当提供。

• Dfn：{⍵⍴1,∊1,⍨¨j⍴¨(+\¯1+j←⍳⍵)⌽¨⊂0,2×⍳4} 在线试用！
• 默契：⊢⍴1,∘∊1,⍨¨⍳⍴¨(⊂0,2×⍳4)⌽⍨¨(+\¯1+⍳) 在线尝试！

JavaScript（ES6），62 54 52字节

返回序列的第N个项，索引为0。

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

演示版

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个字节

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

在线尝试！

一个函数（f()），它以空格分隔的无限打印顺序。

i 是当前偶数运行的长度。

j 是当前偶数运行中的索引

(2*j+++i*i-i)%10 给定i和j（并增加j），给出正确的偶数，等效于（（j + Tr（i））％5）* 2，其中Tr（x）是第x个三角数（即偶数当前偶数运行之前已打印的数字；

Java 8，96字节

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

无限期打印每个数字在新行上。

说明：

在这里尝试。

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

批处理，85字节

@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

输出序列的第N个项。通过计算下一个三角数来工作。

Perl 5，44个字节

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

在线尝试！

无限输出

J，46 42 40字节

-6个字节，感谢科尔

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

输出此序列的前N个项。

怎么运行的：

10|[:+:i. -生成长度为N的列表0 2 4 6 8 0 2 4 ...它只是从10开始的整数列表的double项的mod 10。

[:;[:#:&.>2^i. -生成位掩码以剪切上面的列表。

（1表示开始）：1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 ... ...将2取为连续非负整数的幂，将其转换为二进制，然后将其展平列表，并且只接受前N个项目，因此两个列表的长度相同。

;@(1,&.><;.1) -根据1和0的映射将偶数位列表拆分（剪切）成子列表，将子列表附加到1，最后展平结果列表

]{. -仅采用前N个项目，由于添加了1，因此摆脱了列表中的其他数字。

在线尝试！

Common Lisp，74个字节

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

在线尝试！

无限期打印序列。

Perl 5，35个字节

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

在线尝试

果冻，17个字节

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

在线尝试！

质子，55字节

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

在线尝试！

无限期打印序列

Java（OpenJDK 8），107字节

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

在线尝试！

Mathematica，68个字节

返回第N项

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

在线尝试！

Wolfram语言（Mathematica），61字节

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

在线尝试！

JavaScript，45个字节

1个索引：

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

0索引：

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>

红宝石，48 46字节

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

在线尝试！

无限打印顺序

bash，42个字节

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

或34（如果有效）

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

在线尝试