Hãy xem xét trình tự sau:

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

Các chữ số chẵn bắt đầu từ 0 và được nhóm thành các chuỗi có độ dài tăng dần. Chúng được sắp xếp theo chu kỳ, có nghĩa là chúng được sắp xếp theo thứ tự tăng dần cho đến khi đạt được 8 , và sau đó quay vòng từ 0 . 1 phân tách các chữ số chẵn và nó cũng bắt đầu chuỗi. Hãy hình dung cách trình tự này được hình thành:

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

Phương thức nhập và xuất được chấp nhận:

• Nhận một số nguyên N làm đầu vào và đầu ra số hạng thứ N của chuỗi này.

• Nhận một số nguyên N làm đầu vào và đầu ra N điều khoản đầu tiên của chuỗi này.

• In trình tự vô thời hạn.

Bạn có thể chọn lập chỉ mục 0 hoặc 1 cho hai phương thức đầu tiên.

Bạn có thể cạnh tranh trong bất kỳ ngôn ngữ lập trình nào , trong khi sử dụng các phương thức nhập và xuất chuẩn . Sơ hở tiêu chuẩn bị cấm. Đây là môn đánh gôn , vì vậy mã ngắn nhất trong mỗi ngôn ngữ sẽ thắng.

Haskell , 50 46 byte

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

Hãy thử trực tuyến!

1#cycle[0,2..8] trả về chuỗi dưới dạng danh sách vô hạn.

-4 byte nhờ rjan Johansen!

Thạch , 10 byte

5ḶḤṁR€1pFḣ

Trả về n mục đầu tiên của chuỗi.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

ṁ:1CN¢mDŀ5

Hãy thử trực tuyến!

In trình tự vô thời hạn.

Cách khác:

J1CΘN¢mDŀ5

Hãy thử trực tuyến!

Giải trình

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

Đối với giải pháp thay thế:

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

Chúng tôi cũng có thể làm ...ΘCN..., bởi vì Θ"trả trước phần tử mặc định", phần trước bằng 0 cho danh sách số nguyên và danh sách trống cho danh sách danh sách.

Python 3 , 52 byte

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

Mất một chỉ số 1 có trụ sở và trả Đúng hay không thể thiếu phao .

Hãy thử trực tuyến!

Python 2 , 51 byte

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

In toàn bộ chuỗi.

Hãy thử trực tuyến!

APL, 25 byte

Trả về số hạng thứ n.

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

Giải trình

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

Hãy thử trực tuyến!

Đây là một tradfn ( trad itional f unctio n ) lấy một đối sốk và trả lại đầu kmục của dãy.

Cảm ơn @GalenIvanov đã chỉ ra một lỗi trong hàm. Cảm ơn @ Adám cho 3 byte.

Làm thế nào nó hoạt động:

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.

Dưới đây là một Dfn( d irect f unstio n ) và một hàm ngầm cũng giải quyết thách thức, cả hai đều được cung cấp bởi @ Adám.

• Dfn: {⍵⍴1,∊1,⍨¨j⍴¨(+\¯1+j←⍳⍵)⌽¨⊂0,2×⍳4} Hãy thử trực tuyến!
• Tacit: ⊢⍴1,∘∊1,⍨¨⍳⍴¨(⊂0,2×⍳4)⌽⍨¨(+\¯1+⍳) Hãy thử trực tuyến!

JavaScript (ES6), 62 54 52 byte

Trả về số hạng thứ N của chuỗi, được lập chỉ mục 0.

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

Bản giới thiệu

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

Hãy thử trực tuyến!

Một hàm ( f()) in chuỗi vô hạn, cách nhau bởi khoảng trắng.

i là chiều dài của hoạt động chẵn hiện tại.

j là chỉ số trong hoạt động chẵn

(2*j+++i*i-i)%10 đưa ra số chẵn chính xác, cho i và j (và gia số j), tương đương với ((j + Tr (i))% 5) * 2, trong đó Tr (x) là số tam giác thứ x (là số chẵn các số đã được in trước khi chạy hiện tại;

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

In vô thời hạn, mỗi số trên một dòng mới.

Giải trình:

Hãy thử nó ở đây.

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

Mẻ, 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

Xuất ra số hạng thứ N của chuỗi. Hoạt động bằng cách tính số tam giác tiếp theo.

Perl 5 , 44 byte

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

Hãy thử trực tuyến!

Sản lượng vô hạn

J , 46 42 40 byte

-6 byte nhờ cole

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

Xuất ra các điều khoản N đầu tiên của chuỗi này.

Làm thế nào nó hoạt động:

10|[:+:i. - tạo danh sách độ dài N là 0 2 4 6 8 0 2 4 ... Đơn giản chỉ cần mod 10 trong số các mục được nhân đôi của danh sách các số nguyên bắt đầu từ 0.

[:;[:#:&.>2^i. - tạo ra một mặt nạ bit để cắt danh sách trên.

(1 có nghĩa là bắt đầu): 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 ... Nó tìm thấy 2 với sức mạnh của các số nguyên không âm liên tiếp, chuyển đổi chúng thành nhị phân, làm phẳng liệt kê và chỉ lấy N mục đầu tiên, sao cho độ dài của cả hai danh sách là như nhau.

;@(1,&.><;.1) - chia (cắt) danh sách các chữ số chẵn thành danh sách phụ theo bản đồ của số và số 0, nối thêm danh sách con vào 1 và cuối cùng làm phẳng danh sách kết quả

]{. - chỉ mất N mục đầu tiên, loại bỏ các số bổ sung trong danh sách do thêm 1s.

Hãy thử trực tuyến!

Lisp thông thường, 74 byte

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

Hãy thử trực tuyến!

In trình tự vô thời hạn.

Perl 5, 35 byte

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

thử trực tuyến

Thạch , 17 byte

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

Hãy thử trực tuyến!

Proton , 55 byte

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

Hãy thử trực tuyến!

In trình tự vô thời hạn

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

Hãy thử trực tuyến!

Toán học, 68 byte

Trả về thuật ngữ thứ N

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 61 byte

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

Hãy thử trực tuyến!

JavaScript, 45 byte

1 chỉ mục:

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

0 được lập chỉ mục:

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 byte

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

Hãy thử trực tuyến!

In trình tự vô thời hạn

bash, 42 byte

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

hoặc 34 nếu hợp lệ

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

thử trực tuyến