Progression of Matrix Columns

Question

Consider the infinite matrix:

0  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1
0  0  2  3  0  0  2  3  0  0  2  3  0  0  2  3
0  0  0  4  5  6  0  0  0  4  5  6  0  0  0  4 ...
0  0  0  0  7  8  9 10  0  0  0  0  7  8  9 10
0  0  0  0  0 11 12 13 14 15  0  0  0  0  0 11
              ...

Each new row of the matrix is constructed by starting with z zeros, where z is the length of positive digits we're using in that row. The positive digits are constructed by starting with 1 and incrementing and adding an additional digit each time you iterate rows. That pattern is repeated infinitely to the right. So, for example, the first row starts 0, 1, 0, 1... while the second row starts 0,0, 2,3, 0,0, 2,3.... Following the pattern, the third row starts 0,0,0, 4,5,6, 0,0,0, 4,5,6....

Given two integers as input, n and x, output the first (top-most) x numbers of the nth column of the above matrix. (You can choose 0- or 1-indexing for the columns, just specify which in your submission.)

For example, for input n = 0 (0-indexed), the column is entirely 0s, so the output would just be x 0s.

For input n = 15 and x = 6, the output would be [1, 3, 4, 10, 11, 0].

For input n = 29 and x = 15, the output would be [1, 0, 6, 8, 15, 0, 0, 34, 39, 0, 0, 0, 0, 0, 120].

For input n = 99 and x = 25, the output would be [1, 3, 4, 0, 15, 0, 0, 0, 37, 55, 56, 0, 87, 93, 0, 0, 151, 163, 176, 0, 0, 0, 0, 0, 325].

I/O and Rules

• The input and output can be given by any convenient method.
• The input and output can be assumed to fit in your language's native number type.
• Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
• Standard loopholes are forbidden.
• This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Answer 1

JavaScript (ES6), 45 bytes

Takes input in currying syntax (n)(x).

n=>g=x=>x?[...g(x-1),n/x&1&&n%x+x*~-x/2+1]:[]

Try it online!

How?

We use a direct formula to get the value of the cell at column n (0-indexed) and row x (1-indexed):

n / x & 1 &&     // is this cell zero or non-zero?
n % x +          // column modulo row --> increment for a non-zero value at this position
x * ~-x / 2 + 1  // minimum value of non-zero values for this row:
                 // ∑(i=1...x-1)(i) + 1 = x(x - 1) / 2 + 1

Answer 2

R, 80 76 bytes

Thanks to @JayCe for pointing out a bug!

function(n,x)for(a in 1:x)print(rep(c(rep(0,a),((y=sum(1:a))-a+1):y),,n)[n])

Try it online!

Uses 1-based indexing for n. Very likely a golfier algorithm exists but rep is the enabler for the naive solution.

Answer 3

Python 2, 69 bytes

n,x=input()
a=i=1
exec"print(([0]*i+range(a,a+i))*n)[n];a+=i;i+=1;"*x

Try it online!

Answer 4

APL (Dyalog Classic), 27 24 23 bytes

-1 thanks to @FrownyFrog

⊢∘⍳(<×(+\⊣)--){+\⍵/2}|⊣

Try it online!

Answer 5

MATL, 25 18 bytes

x:"@:t~ys:b@-)h1G)

Try it online!

Thanks to Luis Mendo for golfing out 6 bytes!

This is essentially a MATL port of my R answer.

x		 % implicit input, read n and delete
:		 % implicit input, read x and push [1..x]
"		 % for loop with i = 1..x
 @:		 % push [1..i]
   t		 % duplicate
    ~		 % logical negate, turn to array of zeros
		 % stack: [[1..i], [0 .. (i times)]]
     y		 % duplicate from below
		 % stack: [[1..i], [0 .. (i times)], [1..i]]
      s:	 % sum and range
		 % stack: [[1..i], [0 .. (i times)], [1..(i * (i + 1)/2)]]
	b	 % bubble up
		 % stack: [[0 .. (i times)], [1..(i * (i + 1)/2)], [1..i]]
	 @-	 % push i and subtract. This will be used as a modular index to get the last i elements
		 % stack: [[0 .. (i times)], [1..(i * (i + 1)/2)], [1-i..0]]
	   )	 % index into array modularly to get the last i elements
		 % stack: [[0 .. (i times)], [(i-1)*i/2 + 1, .. (i * (i + 1)/2)]]
	    h	 % horizontally concatenate the array
	     1G) % push n and index modularly, leaving the result on the stack
		 % implicit end of for loop. The stack now contains the appropriate elements in order
		 % implicit end. Print stack contents

Answer 6

Jelly, 11 bytes

ṖS+R¬;$)⁹ịⱮ

Try it online!

-1 thanks to Jonathan Allan.

Argument 1: x
Argument 2: n + 1

Answer 7

Husk, 14 bytes

↑!Tzo¢+MRN0CNN

The argument n (first) is 1-indexed, try it online!

Alternatively we could use ↑!TṠzo¢+†K0CNN for the same number of bytes.

Explanation

↑!Tz(¢+)MRN0CNN -- example inputs n=4, x=3
            C N -- cut the natural numbers: [1,2,3,4,…]
             N  -- | using the natural numbers
                -- : [[1],[2,3],[4,5,6],[7,8,9,10],…]
        M N     -- map over the naturals
         R 0    -- | replicate 0 that many times
                -- : [[0],[0,0],[0,0,0],[0,0,0,0],…]
   z(  )        -- zip these two lists
      +         -- | concatenate
     ¢          -- | cycle
                -- : [[0,1,0,1,…],[0,0,2,3,0,0,2,3,…],…]
  T             -- transpose: [[0,0,0,0,…],[1,0,0,0,…],[0,1,0,0,…],[1,3,4,0,…],…]
 !              -- index into that list using n: [1,3,4,0,…]
↑               -- take x: [1,3,4]

Answer 8

Husk, 21 19 bytes

↑mȯ!⁰¢§+`R0§…ȯ→Σ←ΣN

Takes arguments as n (1-indexed), then x.
Saved 2 bytes thanks to BMO, but still not as short as BMO's answer.
My first attempt at using Husk.
Try it online!

Answer 9

K (ngn/k), 33 31 bytes

{(a>i)*(+\i)-i-a:(2*1+i:!y)!'x}

Try it online!

Answer 10

Haskell, 75 bytes

u!v=take v[cycle((0<$l)++l)!!u|n<-[1..],l<-[take n$drop(sum[1..n-1])[1..]]]

Try it online!

Answer 11

Python 2, 55 bytes

lambda n,x:[n/y%2*(n%y+y*~-y/2+1)for y in range(1,x+1)]

Try it online!

Developed independently; but I note that this ends up being a port of Arnauld's Javascript answer.

Answer 12

Perl 5 -n, 52 bytes

/ /;say+(((0)x$_,($.+=--$_)..$.+$_)x$`)[$`]for 1..$'

Try it online!

Answer 13

05AB1E, 25 bytes

LO©LsL£¹£¹LÅ0s)øε˜®Ì∍}ø¹è

Try it online!

---

05AB1E goes with matrices like toothpaste and orange juice, but not a bad byte-count considered how bad my implementation is. Even my code is laughing at me "LO©L".

Answer 14

Charcoal, 19 bytes

ＩＥ…·¹Ｎ§⁺Ｅι⁰ＥιＬ⊞Ｏυωη

Try it online! Link is to verbose version of code. Explanation:

    ¹               Literal 1
     Ｎ              First input (`x`) as a number
  …·                Inclusive range
 Ｅ                  Map (value `i`, 0-indexed counter `k`)
         ι          Current value
        Ｅ           Map over implicit range
          ⁰         Literal 0 (i.e. create array of `i` zeros)
            ι       Current value
           Ｅ        Map over implicit range
                 ω  Arbitrary variable
                υ   Predefined array
              ⊞Ｏ    Push
             Ｌ      Length
       ⁺            Concatenate arrays
      §           η Index by second input (`n`)
Ｉ                   Cast to string and implicitly print on separate lines

The snippet ＥιＬ⊞Ｏυω generates the next i integers by the expedient of pushing a dummy value to an array each pass through the loop and taking the length of the resulting array.

Answer 15

Java 8, 65 63 60 bytes

n->x->{for(;x>0;)System.out.println(n/x%2*(n%x+x*--x/2+1));}

n is 0-indexed, x is 1-indexed, outputs the numbers new-line delimited and reversed.

Port of @Arnauld's JavaScript (ES6) answer.

Try it online.
A pretty-printed result in correct order is 8 6 bytes longer: Try it online.

Answer 16

Haskell, 67 bytes

i#l=cycle((++)=<<(0<$)$[i..l-1]):l#(l+l-i+1)
n!x=take x$(!!n)<$>1#2

Try it online!

i#l                  -- function # builds the infinite matrix
                     -- input: i and l are lowest and highest+1 non-zero number of
                     -- the current line
   = cycle           -- for the current line, repeat infinitely
           [i..l-1]  --   the non-zero numbers of the line appended 
     (++)=<<(0<$)    --   to a list of 0s with the same length
   :                 -- append next row of the matrix
     l#(l+l-i+1)     --   which is a recursive call with i and l adjusted

n!x =                -- main function
              1#2    -- create matrix
      (!!n)<$>       -- pick nth element of each row
  take x             -- take the first x numbers thereof