Rozważ następującą sekwencję:

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

Cyfry parzyste zaczynają się od 0 i są pogrupowane w ciągi o coraz większej długości. Są one rozmieszczone cyklicznie, co oznacza, że ​​są sortowane w porządku rosnącym do osiągnięcia 8 , a następnie cofane od 0 . 1 oddziela przebiegi parzystych cyfr, a także rozpoczyna sekwencję. Wyobraźmy sobie, jak powstaje ta sekwencja:

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

Dopuszczalne metody wejścia i wyjścia:

• Odbierz liczbę całkowitą N jako dane wejściowe i wyślij N- ty człon tej sekwencji.

• Odbierz liczbę całkowitą N jako dane wejściowe i wyślij pierwsze N składników tej sekwencji.

• Wydrukuj sekwencję w nieskończoność.

Możesz wybrać indeksowanie 0 lub 1 dla pierwszych dwóch metod.

Możesz konkurować w dowolnym języku programowania , korzystając ze standardowych metod wejścia i wyjścia . Standardowe luki są zabronione. To jest golf golfowy , więc wygrywa najkrótszy kod w każdym języku.

Haskell , 50 46 bajtów

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

Wypróbuj online!

1#cycle[0,2..8] zwraca sekwencję jako nieskończoną listę.

-4 bajty dzięki Ørjan Johansen!

Galaretka , 10 bajtów

5ḶḤṁR€1pFḣ

Zwraca pierwsze n elementów sekwencji.

Wypróbuj online!

Jak to działa

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.

Łuska , 12 11 10 bajtów

ṁ:1CN¢mDŀ5

Wypróbuj online!

Drukuje sekwencję w nieskończoność.

Alternatywnie:

J1CΘN¢mDŀ5

Wypróbuj online!

Wyjaśnienie

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

Dla alternatywnego rozwiązania:

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

Możemy to również zrobić ...ΘCN..., ponieważ Θ„wstawia domyślny element”, który przygotowuje zero dla list liczb całkowitych i pustą listę dla list list.

Python 3 , 52 bajty

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

Pobiera indeks oparty na 1 i zwraca wartość True lub integralną liczbę zmiennoprzecinkową .

Wypróbuj online!

Python 2 , 51 bajtów

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

Drukuje całą sekwencję.

Wypróbuj online!

APL, 25 bajtów

Zwraca n-ty termin.

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

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

To tradfn ( upr itional F unctio N ), biorąc jeden argument ki powrót pierwsze kelementy sekwencji.

Dzięki @GalenIvanov za wskazanie błędu w funkcji. Dzięki @ Adám za 3 bajty.

Jak to działa:

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.

Poniżej podano Dfn( d Skierować f unctio n ) i ukrytą funkcję również rozwiązać problemu, oba uzyskane dzięki uprzejmości @ ADAM.

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

JavaScript (ES6), 62 54 52 bajty

Zwraca N- ty ciąg sekwencji, 0-indeksowany.

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

Próbny

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 bajtów

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

Wypróbuj online!

Funkcja ( f()), która drukuje sekwencję w nieskończoność, oddzielona spacjami.

i to długość bieżącego parzystego przebiegu.

j jest indeksem w bieżącym parzystym przebiegu

(2*j+++i*i-i)%10 daje poprawną liczbę parzystą, biorąc pod uwagę i i j (i przyrosty j), równoważne ((j + Tr (i))% 5) * 2, gdzie Tr (x) jest x liczbą trójkątną (która jest liczbą parzystą liczby, które zostały wydrukowane przed bieżącym nawet uruchomieniem;

Java 8, 96 bajtów

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

Drukuje w nieskończoność, każdy numer w nowej linii.

Wyjaśnienie:

Wypróbuj tutaj.

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

Partia, 85 bajtów

@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

Wysyła N-ty ciąg sekwencji. Działa poprzez obliczenie następnej liczby trójkątnej.

Perl 5 , 44 bajtów

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

Wypróbuj online!

Nieskończona wydajność

J , 46 42 40 bajtów

-6 bajtów dzięki Cole

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

Wysyła pierwsze N ​​wyrazów tej sekwencji.

Jak to działa:

10|[:+:i. - generuje listę o długości N od 0 2 4 6 8 0 2 4 ... Po prostu pobiera mod 10 z podwójnych pozycji na liście liczb całkowitych zaczynających się od 0.

[:;[:#:&.>2^i. - generuje nieco maskę do wycięcia powyższej listy.

(1 oznacza start): 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 ... Znajduje 2 do potęgi kolejnych liczb całkowitych nieujemnych, konwertuje je na binarne, spłaszcza listy i pobiera tylko pierwsze N ​​elementów, dzięki czemu długość obu list jest taka sama.

;@(1,&.><;.1) - dzieli (przycina) listę cyfr parzystych na podlisty zgodnie z mapą zer i jedynek, dołącza podlistę do 1, a na koniec spłaszcza wynikową listę

]{. - bierze tylko pierwsze N ​​przedmiotów, pozbywając się dodatkowych numerów na liście z powodu dodanych 1.

Wypróbuj online!

Common Lisp, 74 bajty

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

Wypróbuj online!

Drukuje sekwencję w nieskończoność.

Perl 5, 35 bajtów

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

spróbuj online

Galaretka , 17 bajtów

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

Wypróbuj online!

Proton , 55 bajtów

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

Wypróbuj online!

Drukuje sekwencję w nieskończoność

Java (OpenJDK 8) , 107 bajtów

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

Wypróbuj online!

Mathematica, 68 bajtów

Zwraca N-ty termin

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

Wypróbuj online!

Wolfram Language (Mathematica) , 61 bajtów

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

Wypróbuj online!

JavaScript, 45 bajtów

1 indeksowany:

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

0 indeksowanych:

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>

Rubinowy , 48 46 bajtów

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

Wypróbuj online!

Wydrukuj sekwencję w nieskończoność

bash, 42 bajty

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

lub 34, jeśli jest ważny

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

spróbuj online