Print a physical multiplication table Rectangles have this nice property - an \$n \times m\$ rectangle consists of exactly \$n \times m\$ characters!

A.. more interesting property is that the rectangles can be aligned nicely in a multiplication table - for example, a \$3 \times 3\$ table:

# ## ###

# ## ###
# ## ###

# ## ###
# ## ###
# ## ###


Your challenge is to, given a number \$n\$ (\$ n &gt; 1\$), output a formatted \$n \times n\$ multiplication table.

Rules


You can take the input one above or below \$n\$
Default I/O rules apply
You can choose any non-whitespace character to represent the blocks; every other character (though newlines are special) is considered whitespace. The chosen character can be different for different inputs, but must be the same throughout the input
The result can have unneeded characters, as long as the table aligns up and there are no occurrences of the chosen character that aren't part of the required output
The separators must be 1 character wide/tall, and the rectangles must be packed (i.e. no separators between their characters)
The empty lines can be empty, padding isn't required
The result can be a string, matrix, vector of lines, array of character arrays, or anything 2Dish
You may alternatively output a matrix/vector-of-vectors/anything 2Dish of numbers, but the background &amp; foreground must be 2 distinct numbers (which can vary input to input, but not throughout an output) and no other numbers can be present. Extra surrounding characters are allowed with this format too (though they must match the background number)
This is code-golf, shortest answer in bytes, per-language, wins!


Examples

For the input 2, a valid ascii-art output, with the character ∙, is:

        ∙ ∙∙

Result: ∙ ∙∙.
        ∙ ∙∙


yes the period is there just to confuse you
Another valid answer as a number matrix, with 2 being the background number and 9 the foreground:

[[9,2,9,9,2,2],
 [2,2,2,2,2,2],
 [9,2,9,9,2,2],
 [9,2,9,9,2,2]]


An invalid output example would be

#  # #


#  # #

#  # #


as the rectangles have separators in between them.

Example outputs for \$4 \times 4\$:

# ## ### ####

# ## ### ####
# ## ### ####

# ## ### ####
# ## ### ####
# ## ### ####

# ## ### ####
# ## ### ####
# ## ### ####
# ## ### ####


1 0 1 1 0 1 1 1 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
1 0 1 1 0 1 1 1 0 1 1 1 1
Haskell, 43 bytes



f n=map=&lt;&lt;flip(map.max)$show.(10^)=&lt;&lt;[1..n]


Try it online!

A clever approach by Ørjan Johansen outputting with 0's and 1's, generating each 10...00 part as the string representation of a power of 10.

111111111
101001000
111111111
101001000
101001000
111111111
101001000
101001000
101001000




Haskell, 49 bytes



f n=map=&lt;&lt;flip(map.max)$[0^i|x&lt;-[1..n],i&lt;-[0..x]]


Try it online!

Generates a pattern like [1,0,1,0,0,1,0,0,0,...], then makes a 2D by taking the min of pairs. The pointfree weirdness saves 2 bytes over the more readable:



f n|l&lt;-do x&lt;-[1..n];0:(1&lt;$[1..x])=[[a*b|a&lt;-l]|b&lt;-l]


Try it online!