Betrachten Sie die folgende Reihenfolge:

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

Die geraden Ziffern beginnen bei 0 und sind in Läufe mit zunehmender Länge gruppiert. Sie sind zyklisch angeordnet, dh, sie werden in aufsteigender Reihenfolge sortiert, bis 8 erreicht ist, und dann von 0 zurückgespult . 1 trennt die Abläufe von geraden Ziffern und startet auch die Sequenz. Stellen wir uns vor, wie diese Sequenz gebildet wird:

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

Akzeptable Eingabe- und Ausgabemethoden:

• Empfangen Sie eine Ganzzahl N als Eingabe und geben Sie den N- ten Term dieser Sequenz aus.

• Empfangen Sie eine Ganzzahl N als Eingabe und geben Sie die ersten N Terme dieser Sequenz aus.

• Drucken Sie die Sequenz auf unbestimmte Zeit.

Sie können für die ersten beiden Methoden zwischen 0- und 1-Indizierung wählen.

Sie können in jeder Programmiersprache mit den Standard-Eingabe- und Ausgabemethoden konkurrieren . Standardlücken sind verboten. Das ist Code-Golf , also gewinnt der kürzeste Code in jeder Sprache.

Haskell , 50 46 Bytes

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

Probieren Sie es online!

1#cycle[0,2..8] Gibt die Sequenz als unendliche Liste zurück.

-4 Bytes danke an Ørjan Johansen!

Gelee , 10 Bytes

5ḶḤṁR€1pFḣ

Gibt die ersten n Elemente der Sequenz zurück.

Probieren Sie es online!

Wie es funktioniert

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.

Schale , 12 11 10 Bytes

ṁ:1CN¢mDŀ5

Probieren Sie es online!

Druckt die Sequenz auf unbestimmte Zeit.

Alternative:

J1CΘN¢mDŀ5

Probieren Sie es online!

Erläuterung

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

Für die alternative Lösung:

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

Wir könnten auch tun ...ΘCN..., weil Θ"Standardelement voranstellen", das eine Null für Listen von ganzen Zahlen und eine leere Liste für Listen von Listen voranstellt.

Python 3 , 52 Bytes

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

Nimmt einen 1-basierten Index und gibt True oder einen ganzzahligen Gleitkommawert zurück .

Probieren Sie es online!

Python 2 , 51 Bytes

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

Druckt die gesamte Sequenz.

Probieren Sie es online!

APL, 25 Bytes

Gibt den n-ten Ausdruck zurück.

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

Erläuterung

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 Bytes

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

Probieren Sie es online!

Dies ist ein tradfn ( einf itional f unctio n ) ein Argument nimmt , kund die ersten wiederkehrenden kElemente der Sequenz.

Vielen Dank an @GalenIvanov für den Hinweis auf einen Fehler in der Funktion. Vielen Dank an @ Adám für 3 Bytes.

Wie es funktioniert:

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.

Unten sind ein Dfn( d irect f unctio n ) und eine stillschweigende Funktion auch , dass die Herausforderung lösen, sowohl freundlicherweise von @ Adám vorgesehen.

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

JavaScript (ES6), 62 54 52 Bytes

Gibt den N- ten Term der Sequenz mit dem Index 0 zurück.

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 Bytes

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

Probieren Sie es online!

Eine Funktion ( f()), die die Sequenz unendlich ausgibt, getrennt durch Leerzeichen.

i ist die Länge des aktuellen geraden Laufs.

j ist der Index im aktuellen geraden Lauf

(2*j+++i*i-i)%10 gibt die richtige gerade Zahl an, wenn i und j (und die Schritte j) gegeben sind, die ((j + Tr (i))% 5) * 2 entspricht, wobei Tr (x) die x-te dreieckige Zahl ist (die die Zahl der geraden Zahlen ist) Zahlen, die vor dem aktuellen geraden Lauf gedruckt wurden;

Java 8, 96 Bytes

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

Druckt auf unbestimmte Zeit jede Nummer in einer neuen Zeile.

Erläuterung:

Probieren Sie es hier aus.

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 Bytes

@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

Gibt den N-ten Term der Sequenz aus. Arbeitet durch Berechnung der nächsten Dreieckszahl.

Perl 5 , 44 Bytes

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

Probieren Sie es online!

Unendliche Ausgabe

J , 46 42 40 Bytes

-6 bytes dank cole

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

Gibt die ersten N Terme dieser Sequenz aus.

Wie es funktioniert:

10|[:+:i. - erzeugt eine Liste der Länge N von 0 2 4 6 8 0 2 4 ... Es werden einfach mod 10 der verdoppelten Elemente einer Liste von Ganzzahlen ab 0 verwendet.

[:;[:#:&.>2^i. - erzeugt eine Bitmaske zum Ausschneiden der obigen Liste.

(1 bedeutet Start): 1 1 0 1 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 ... Findet 2 zur Potenz der aufeinanderfolgenden nicht negativen ganzen Zahlen, wandelt sie in Binärzahlen um, verflacht die list und nimmt nur die ersten N Items, so dass die Länge der beiden Listen gleich ist.

;@(1,&.><;.1) - Teilt (schneidet) die Liste der geraden Ziffern in Unterlisten entsprechend der Zuordnung von Einsen und Nullen, fügt die Unterliste an 1 an und glättet schließlich die resultierende Liste

]{. - Nimmt nur die ersten N Elemente und entfernt die zusätzlichen Nummern in der Liste aufgrund der hinzugefügten Einsen.

Probieren Sie es online!

Common Lisp, 74 Bytes

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

Probieren Sie es online!

Druckt die Sequenz auf unbestimmte Zeit.

Perl 5, 35 Bytes

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

versuche es online

Gelee , 17 Bytes

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

Probieren Sie es online!

Proton , 55 Bytes

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

Probieren Sie es online!

Druckt die Sequenz auf unbestimmte Zeit

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

Probieren Sie es online!

Mathematica, 68 Bytes

Gibt den N-ten Ausdruck zurück

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 61 Bytes

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

Probieren Sie es online!

JavaScript, 45 Bytes

1 indiziert:

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

0 indiziert:

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 Bytes

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

Probieren Sie es online!

Drucken Sie die Sequenz auf unbestimmte Zeit

Bash, 42 Bytes

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

oder 34 falls gültig

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

versuche es online