Розглянемо таку послідовність:

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 байти завдяки Ørjan Johansen!

Желе , 10 байт

5ḶḤṁR€1pFḣ

Повертає перші п пунктів послідовності.

Спробуйте в Інтернеті!

Як це працює

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..., тому Θщо "додає елемент за замовчуванням", який попередньо дорівнює нулю для списків цілих чисел та порожній список для списків списків.

Python 3 , 52 байти

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

Бере індекс на основі 1 і повертає істинний або цілісний плавець .

Спробуйте в Інтернеті!

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 ( трад itional х 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 пряме f unctio n ) та мовчазна функція, яка також вирішує завдання, обидва надані @ Adám.

• Dfn: {⍵⍴1,∊1,⍨¨j⍴¨(+\¯1+j←⍳⍵)⌽¨⊂0,2×⍳4} Спробуйте в Інтернеті!
• Tacit: ⊢⍴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 подвоєних елементів списку цілих чисел, починаючи з 0.

[:;[:#:&.>2^i. - створює трохи маски для вирізання вищевказаного списку.

(1 означає запуск): 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 ... Він знаходить 2 до сили послідовних невід’ємних цілих чисел, перетворює їх у двійкові, згладжує список і приймає лише перші N елементів, так що довжина обох списків однакова.

;@(1,&.><;.1) - розбиває (розрізає) список парних цифр на підліст, відповідно до карти одиниць і нулів, додає підпис до 1 і, нарешті, розгладжує отриманий список

]{. - бере лише перші N елементів, позбавляючись від додаткових номерів у списку через додані 1.

Спробуйте в Інтернеті!

Лист звичайний, 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;}

Спробуйте в Інтернеті!

Математика, 68 байт

Повертає N-й член

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

Спробуйте в Інтернеті!

Мова Вольфрама (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)}

Спробуйте в Інтернеті!

Друкуйте послідовність нескінченно

баш, 42 байти

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

або 34, якщо вони дійсні

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

спробуйте в Інтернеті