13
\$\begingroup\$

Consider the following sequence:

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

The even digits start from 0 and are grouped into runs of increasing length. They are arranged cyclically, meaning that they are sorted in ascending order until 8 is reached, and then cycled back from 0. 1 separates the runs of even digits, and it also starts the sequence. Let's visualize how this sequence is formed:

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

Acceptable Input and Output methods:

  • Receive an integer N as input and output the Nth term of this sequence.

  • Receive an integer N as input and output the first N terms of this sequence.

  • Print the sequence indefinitely.

You can choose either 0 or 1-indexing for the first two methods.

You can compete in any programming language, while using the standard input and output methods. Standard loopholes are forbidden. This is , so the shortest code in each language wins.

\$\endgroup\$
  • \$\begingroup\$ This challenge has been sandboxed. \$\endgroup\$ – Mr. Xcoder Nov 10 '17 at 13:50

23 Answers 23

8
\$\begingroup\$

Haskell, 50 46 bytes

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

Try it online!

1#cycle[0,2..8] returns the sequence as infinite list.

-4 bytes thanks to Ørjan Johansen!

\$\endgroup\$
  • 1
    \$\begingroup\$ You can save four bytes by making the first argument of # just a number. Try it online! \$\endgroup\$ – Ørjan Johansen Nov 11 '17 at 0:36
7
\$\begingroup\$

Jelly, 10 bytes

5ḶḤṁR€1pFḣ

Returns the first n items of the sequence.

Try it online!

How it works

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.
\$\endgroup\$
  • 2
    \$\begingroup\$ ಠ_ಠ Unhalve... Isn't that just Double? \$\endgroup\$ – Mr. Xcoder Nov 10 '17 at 14:21
  • 4
    \$\begingroup\$ It's just a mnemonic. H is halve, so is unhalve. ÆA is arccosine, so ÆẠ is unarccosine. \$\endgroup\$ – Dennis Nov 10 '17 at 14:25
6
\$\begingroup\$

Husk, 12 11 10 bytes

ṁ:1CN¢mDŀ5

Try it online!

Prints the sequence indefinitely.

Alternatively:

J1CΘN¢mDŀ5

Try it online!

Explanation

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

For the alternative solution:

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

We could also do ...ΘCN..., because Θ does "prepend default element", which prepends a zero for lists of integers and an empty list for lists of lists.

\$\endgroup\$
4
\$\begingroup\$

Python 3, 52 bytes

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

Takes a 1-based index and returns True or an integral float.

Try it online!

\$\endgroup\$
2
\$\begingroup\$

Python 2, 51 bytes

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

Prints the whole sequence.

Try it online!

\$\endgroup\$
2
\$\begingroup\$

APL, 25 bytes

Returns nth term.

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

Explanation

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
\$\endgroup\$
2
\$\begingroup\$

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

Try it online!

This is a tradfn (traditional function) taking one argument k and returning the first k items of the sequence.

Thanks to @GalenIvanov for pointing out an error in the function. Thanks to @Adám for 3 bytes.

How it works:

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.

Below are a Dfn(direct function) and a tacit function that also solve the challenge, both kindly provided by @Adám.

  • Dfn: {⍵⍴1,∊1,⍨¨j⍴¨(+\¯1+j←⍳⍵)⌽¨⊂0,2×⍳4} Try it online!
  • Tacit: ⊢⍴1,∘∊1,⍨¨⍳⍴¨(⊂0,2×⍳4)⌽⍨¨(+\¯1+⍳) Try it online!
\$\endgroup\$
  • \$\begingroup\$ I'm interested in the explanation of the tacit vesrion. Thanks! \$\endgroup\$ – Galen Ivanov Nov 10 '17 at 20:23
  • \$\begingroup\$ @GalenIvanov I'll add one later today. \$\endgroup\$ – J. Sallé Nov 10 '17 at 20:53
  • \$\begingroup\$ I noticed that the 3 functions yield incorrect answers - the subsequences always start from 0 after 1 - they should continue from the last even digit of the previous subsequence. \$\endgroup\$ – Galen Ivanov Nov 13 '17 at 7:14
  • \$\begingroup\$ @GalenIvanov You're right. I'll see if I can fix it and add the explanations today. \$\endgroup\$ – J. Sallé Nov 13 '17 at 12:13
1
\$\begingroup\$

JavaScript (ES6), 62 54 52 bytes

Returns the Nth term of the sequence, 0-indexed.

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

\$\endgroup\$
1
\$\begingroup\$

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

Try it online!

A function (f()) that prints the sequence infinitely, separated by spaces.

i is the length of the current even-run.

j is the index in the current even-run

(2*j+++i*i-i)%10 gives the correct even number, given i and j (and increments j), equivalent to ((j+Tr(i))%5)*2, where Tr(x) is the xth triangular number (which is the number of even numbers that have been printed before the current even run;

\$\endgroup\$
1
\$\begingroup\$

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

Prints indefinitely, each number on a new line.

Explanation:

Try it here.

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
\$\endgroup\$
1
\$\begingroup\$

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

Outputs the Nth term of the sequence. Works by calculating the next triangular number.

\$\endgroup\$
1
\$\begingroup\$

Perl 5, 44 bytes

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

Try it online!

Infinite output

\$\endgroup\$
  • \$\begingroup\$ -4 bytes {...;redo} instead of do{...}while 1 \$\endgroup\$ – Nahuel Fouilleul Nov 13 '17 at 10:39
1
\$\begingroup\$

J, 46 42 40 bytes

-6 bytes thanks to cole

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

Outputs the first N terms of this sequence.

How it works:

10|[:+:i. - generates a list of length N of 0 2 4 6 8 0 2 4... It simply takes mod 10 of the doubled items of a list of integers starting at 0.

[:;[:#:&.>2^i. - generates a bit mask for cutting the above list.

(1 means start): 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 ... It finds 2 to the power of the consecutive non-negative integers, converts them into binary, flattens the list and takes only the first N items, so that the length of the both lists is the same.

;@(1,&.><;.1) - splits (cuts) the list of the even digits into sublistsaccording to the map of ones and zeroes, appends the sublist to 1 and finally flattens the resulting list

]{. - takes only the first N items, getting rid of the additional numbers in the list due to the added 1s.

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ 42 bytes: {.({.[:;[:#:&.>2^i.);@(1,&.><;.1)(10|2*i.). The changes I did were to use hooks and refactor the right tine of the fork to take advantage of how forks work. I like the 2^i. trick. I'm trying to work on the left tine of the fork now. \$\endgroup\$ – cole Nov 11 '17 at 2:15
  • \$\begingroup\$ @cole Thanks, I need to learn to use forks better. Apparently the fork 2*i. is better then than the capped hook [:+:i. \$\endgroup\$ – Galen Ivanov Nov 11 '17 at 8:32
  • 1
    \$\begingroup\$ You can also drop the parens on the right tine (10|2*i.) ->10|2*i. \$\endgroup\$ – cole Nov 11 '17 at 17:04
1
\$\begingroup\$

Common Lisp, 74 bytes

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

Try it online!

Prints the sequence indefinitely.

\$\endgroup\$
1
\$\begingroup\$

Perl 5, 35 bytes

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

try it online

\$\endgroup\$
0
\$\begingroup\$

Jelly, 17 bytes

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

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Proton, 55 bytes

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

Try it online!

Prints the sequence indefinitely

\$\endgroup\$
  • \$\begingroup\$ ಠ_ಠ What is that, new syntax? :p i=0 j=-2while1{... \$\endgroup\$ – Mr. Xcoder Nov 10 '17 at 14:15
  • \$\begingroup\$ @Mr.Xcoder :P -2while is just like Python and while1 is because I made identifiers not able to be a keyword followed by a number \$\endgroup\$ – HyperNeutrino Nov 10 '17 at 14:21
0
\$\begingroup\$

Java (OpenJDK 8), 107 bytes

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

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Mathematica, 68 bytes

Returns the Nth term

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

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Wolfram Language (Mathematica), 61 bytes

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

Try it online!

\$\endgroup\$
0
\$\begingroup\$

JavaScript, 45 bytes

1 indexed:

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

0 indexed:

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>

\$\endgroup\$
0
\$\begingroup\$

Ruby, 48 46 bytes

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

Try it online!

Print the sequence indefinitely

\$\endgroup\$
0
\$\begingroup\$

bash, 42 bytes

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

or 34 if valid

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

try it online

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.