Pertimbangkan urutan berikut:

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

Digit genap dimulai dari 0 dan dikelompokkan menjadi run dengan panjang yang bertambah. Mereka diatur secara siklis, artinya mereka disortir dalam urutan menaik hingga 8 tercapai, dan kemudian bersepeda kembali dari 0 . 1 memisahkan run dari digit genap, dan itu juga memulai urutan. Mari kita bayangkan bagaimana urutan ini terbentuk:

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

Metode Input dan Output yang dapat diterima:

• Menerima bilangan bulat N sebagai input dan output istilah N urutan ini.

• Terima bilangan bulat N sebagai input dan hasilkan syarat N pertama dari urutan ini.

• Cetak urutan tanpa batas.

Anda dapat memilih pengindeksan 0 atau 1 untuk dua metode pertama.

Anda dapat bersaing dalam bahasa pemrograman apa pun , sambil menggunakan metode input dan output standar . Celah standar dilarang. Ini adalah kode-golf , sehingga kode terpendek dalam setiap bahasa menang.

Haskell , 50 46 byte

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

Cobalah online!

1#cycle[0,2..8] mengembalikan urutan sebagai daftar tanpa batas.

-4 bytes terima kasih kepada Ørjan Johansen!

Jelly , 10 byte

5ḶḤṁR€1pFḣ

Mengembalikan yang pertama n item dari urutan.

Cobalah online!

Bagaimana itu bekerja

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.

Sekam , 12 11 10 byte

ṁ:1CN¢mDŀ5

Cobalah online!

Mencetak urutan tanpa batas.

Kalau tidak:

J1CΘN¢mDŀ5

Cobalah online!

Penjelasan

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

Untuk solusi alternatif:

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

Kita juga bisa melakukannya ...ΘCN..., karena Θmelakukan "elemen standar awal", yang menambahkan nol untuk daftar bilangan bulat dan daftar kosong untuk daftar daftar.

Python 3 , 52 byte

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

Mengambil indeks berbasis 1 dan mengembalikan True atau float integral .

Cobalah online!

Python 2 , 51 byte

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

Mencetak seluruh urutan.

Cobalah online!

APL, 25 byte

Mengembalikan istilah ke-n.

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

Penjelasan

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

Cobalah online!

Ini adalah tradfn ( trad itional f unctio n ) mengambil satu argumen kdan mengembalikan pertamak item dari urutan.

Terima kasih kepada @GalenIvanov karena menunjukkan kesalahan dalam fungsinya. Terima kasih kepada @ Adám selama 3 byte.

Bagaimana itu bekerja:

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.

Di bawah ini adalah Dfn( d irect f unctio n ) dan fungsi diam-diam yang juga memecahkan tantangan, baik disediakan oleh @ Adám.

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

JavaScript (ES6), 62 54 52 byte

Mengembalikan istilah N urutan, diindeks 0.

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 byte

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

Cobalah online!

Fungsi ( f()) yang mencetak urutan tanpa batas, dipisahkan oleh spasi.

i adalah panjang even-run saat ini.

j adalah indeks saat ini bahkan dijalankan

(2*j+++i*i-i)%10 memberikan angka genap yang benar, mengingat i dan j (dan kenaikan j), setara dengan ((j + Tr (i))% 5) * 2, di mana Tr (x) adalah bilangan segitiga xth (yang merupakan jumlah genap angka-angka yang telah dicetak bahkan sebelum dijalankan;

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

Mencetak tanpa batas, setiap nomor di baris baru.

Penjelasan:

Coba di sini.

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

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

Menghasilkan jangka N urutan. Bekerja dengan menghitung angka segitiga berikutnya.

Perl 5 , 44 byte

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

Cobalah online!

Output tak terbatas

J , 46 42 40 byte

-6 byte berkat cole

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

Menghasilkan istilah N pertama dari urutan ini.

Bagaimana itu bekerja:

10|[:+:i. - Menghasilkan daftar panjang N dari 0 2 4 6 8 0 2 4 ... Ini hanya membutuhkan mod 10 dari item yang digandakan dari daftar bilangan bulat mulai dari 0.

[:;[:#:&.>2^i. - Menghasilkan topeng bit untuk memotong daftar di atas.

(1 berarti mulai): 1 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 ... Ia menemukan 2 pangkat bilangan bulat non-negatif berturut-turut, mengubahnya menjadi biner, meratakannya daftar dan hanya mengambil item N pertama, sehingga panjang kedua daftar adalah sama.

;@(1,&.><;.1) - Membagi (memotong) daftar angka genap menjadi sublists menurut peta satu dan nol, menambahkan sublist ke 1 dan akhirnya meratakan daftar yang dihasilkan

]{. - hanya mengambil item N pertama, menyingkirkan nomor tambahan dalam daftar karena 1s ditambahkan.

Cobalah online!

Gangguan Umum, 74 byte

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

Cobalah online!

Mencetak urutan tanpa batas.

Perl 5, 35 byte

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

coba online

Jelly , 17 byte

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

Cobalah online!

Proton , 55 byte

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

Cobalah online!

Mencetak urutan tanpa batas

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

Cobalah online!

Mathematica, 68 byte

Mengembalikan istilah Nth

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

Cobalah online!

Bahasa Wolfram (Mathematica) , 61 byte

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

Cobalah online!

JavaScript, 45 byte

1 diindeks:

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

0 diindeks:

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

Cobalah online!

Cetak urutan tanpa batas

bash, 42 byte

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

atau 34 jika valid

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

coba online