Рассмотрим следующую последовательность:

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 байта благодаря Орджану Йохансену!

Желе , 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..., потому Θчто «добавляет элемент по умолчанию», который добавляет ноль для списков целых чисел и пустой список для списков списков.

Python 3 , 52 байта

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

Принимает индекс на основе 1 и возвращает True или целое число с плавающей точкой .

Попробуйте онлайн!

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( д Прям ая ф unctio п ) и подразумеваемое функцию , которая также решить проблему, и любезно предоставленный @ AdaM.

• 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 ... Он просто берет mod 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 в степени последовательных неотрицательных целых чисел, преобразует их в двоичные, выравнивает list и занимает только первые N элементов, так что длина обоих списков одинакова.

;@(1,&.><;.1) - разбивает (режет) список четных цифр на подсписки в соответствии с картой единиц и нулей, добавляет подсписок к 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 Language (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

попробуйте это онлайн