Given an integer \$1 < n < 10 \$ generate a table like below.
For \$n = 5\$,
1 2 3 4 5 2 2 3 4 5 3 3 3 4 5 4 4 4 4 5 5 5 5 5 5 For \$n = 8\$,
1 2 3 4 5 6 7 8 2 2 3 4 5 6 7 8 3 3 3 4 5 6 7 8 4 4 4 4 5 6 7 8 5 5 5 5 5 6 7 8 6 6 6 6 6 6 7 8 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 Shortest code wins! Trailing whitespace allowed
Output format isn't strict, you can output a 2D list/matrix in any reasonable format.
»þ Outputs an n x n matrix. If the output format is required, 4 bytes
This is simply a table of maximums. For each cell \$A_{i,j}\$ in the output, the result is equal to \$\max(i,j)\$. The 4 byte answer has ` to reuse the argument, and G to format the output as a grid.
Anonymous tacit prefix function.
∘.⌈⍨⍳ ∘.⌈⍨ maximum-table for
⍳ integers 1 through the argument
[ [1,b] dup [ max ] cartesian-map ] cartesian-map Takes two sequences (in this case, both are [1, n]) and applies a quotation to each pair of elements, resulting in a matrix. In effect, we are mapping max over a coordinate matrix.
i,tTv v`j1< >I)iIT‹!0jv v < >J)jJI≥v_~ v >~ v ^ v≤TJ<\23< ` ^ < i pops the top of the stack (by default 0) and stores it into the variable i. , reads an integer from stdin, then t pops it and stores it into variable t. T pushes to the stack the value of the variable t and v redirects the intruction pointer towards the end of the next line. < tells the instruction pointer to go left. 1 pushes 1 onto the stack and j stores it into the variable j, and ` prints a newline. Then v and > sends the instruction towards the right on the next line. I pushes the variable i's value onto the stack, ) increments it, i takes it and puts it into i, I pushes the value of i onto the stack and T brings onto the stack the number that was previously read to stdin. ‹ compares them and terminates the program if the grid has finished printing. Then it initializes j to 0 and sends the instruction pointer into a loop that increments j, then prints a space (\23 (pointer is currently going left, that's why it is reversed) pushes 32 (ASCII id of " ") and prints it) (32\ is used instead of " "~ because it is one character shorter), prints j if j is lower than i, or else prints i. When j is greater or equal to t, it exits the loop, prints a new line and goes back into the outer loop.
In the code, the t variable contains the number read from stdin, i is the current line number, and j is the current character number.
1+>./~@i. 1+>./~@i. input: n i. range from 0 to n-1 inclusive /~ table: >. max(n, n) 1+ add 1 to each 
@(n)max(x=1:n,x') \$\endgroup\$ 
˙⊞↥⇡₁ is shorter and more idiomatic now. \$\endgroup\$ 
ƛ£⁰ƛ¥∴ Try it Online! Returns an array of arrays
ƛ # (1...input) Map... £ # Push to register ⁰ƛ # (1...input) Map... ¥ # Register ∴ # Maximum of the two Or, for grid output, 10 bytes:
ƛ£⁰ƛ¥∴;Ṅ;⁋ ƛ ; # (1...input) Map... £ # Push to register ⁰ƛ ; # (1...input) Map... ¥ # Push register ∴ # Max Ṅ # Joined by spaces ⁋ # Joined by newlines. 
{x|\x}1+!: Somewhat surprisingly, using a seeded scan x|\x returns the same results as an each-right (x|/:x) or each-left (x|\:x).
1+!: generate 1..n from the (implicit) input{x|\x} set up a scan, seeded with the input, run over the input
a => new int[a][].Select((x,p)=>new int[a].Select((y,q)=>p>q?p+1:q+1)) I'm sure there is a shorter way to do this, but I can't find it.
((${$2+1}|1)( $2){$2-1}( ${$4+1}{1-$4/$~1}| ${$2+1}{1-$2/$~1}){$~1-$2+1}\n){$~1} Takes the argument from the command-line. Try it here!
(Spaces are replaced with underscores to improve visibility.)
Each line is generated in three parts. Top-level structure:
( ) Group 1: a line of output (...) Group 2: the first digit (...){...} Group 3: repetitions of the first digit (...){...} Group 4: count up to N \n Add a newline {$~1} Repeat, generating N lines Group 2, the first digit on each line:
( ) ${$2+1} Add 1 to the previous value of group 2 | Or, if group 2 has not been previously matched... 1 Use 1 Group 3, the rest of the digits on the line that are identical to the first number:
(_$2) The most recent value of group 2 (with a space in front of it) {$2-1} repeated (group 2) - 1 times Group 4, the remaining numbers on the line, starting with (group 2) + 1 and counting up to N:
( ${$4+1}{1-$4/$~1}| ${$2+1}{1-$2/$~1}){$~1-$2+1} ( ) _ Space ${$4+1} Previous value of group 4, plus 1 { } Repeat the value this many times: $4/$~1 1 if group 4 == N, 0 otherwise 1- Subtract from 1: 1 -> 0 and 0 -> 1 So if the new value would have been N+1, it instead becomes empty string | If the previous value of group 4 was not a number, the arithmetic fails, and we instead use... _ Space ${$2+1} Last value of group 2, plus 1 {1-$2/$~1} Repeat 0 times if group 2 == N { } Repeat the above $~1-$2+1 N - (group 2) + 1 times Suppose the input is 3.
Line 1:
1 1 repeated 1-1 = 0 times, so empty string3-1+1 = 3 times: followed by 2 repeated 1-1/3 = 1 time (the division is integer division) 2, so followed by 3 repeated 1-2/3 = 1 time 3, so followed by 4 repeated 1-3/3 = 0 timesResult: 1 2 3
Line 2:
1, so 2 2 repeated 2-1 = 1 time3-2+1 = 2 times: , which is not a number, so followed by 3 repeated 1-2/3 = 1 time 3, so followed by 4 repeated 1-3/3 = 0 timesResult: 2 2 3
Line 3:
2, so 3 3 repeated 3-1 = 2 times3-3+1 = 1 time: , which is not a number, so followed by 4 repeated 1-3/3 = 0 timesResult: 3 3 3
Input N identity(N→[A] For(I,1,N For(J,1,N max(I,J→[A](I,J End End [A] Output is stored as a matrix in Ans and is displayed.
|n|(1..=n).fold("".into(),|a,i|(1..=n).fold(a,|b,j|format!("{}{} ",b,i.max(j)))+" ") The output will be a String. The newline is given literally inside quotes, which saves one byte.
ＮθＥθ⭆θ⊕⌈⟦ιλ Try it online! Link is to verbose version of code. Explanation:
Ｎθ First input as an integer θ Input Ｅ Map over implicit range (0-indexed) θ Input ⭆ Map over implicit range and join ι Outer index λ Inner index ⌈⟦ Maximum of all of the above ⊕ Incremented Implicitly print Would be 14 bytes if spacing was desired (13 bytes if a leading space was acceptable).
Outputs a 2D-array.
õ@õwX õ@õwX :Implicit input of integer U õ :Range [1,U] @ :Map each X õ : Range [1,U] wX : Max of each with X Or, if outputting a 1D-array is allowed:
õ ïw õ ïw :Implicit input of integer U õ :Range [1,U] ï :Cartesian product with itself w :Reduce each pair by Max 
õwõ but not quite :( \$\endgroup\$ n=>[...Array(n)].map((_,x,a)=>a.map((_,y)=>x>y++?-~x:y)) Outputs an array of arrays.
Thanks to Shaggy for -5 bytes
Thanks to Arnauld for further -2 bytes
n=>[...Array(n)].map((_,x,a)=>a.map((_,y)=>x>y++?-~x:y).join``).join` ` Outputs string
n=>[...Array(n)].map((_,x,a)=>a.map((_,y)=>-~x>++y?-~x:y)) // 58 n=>[...m=Array(n)].map((_,a)=>[...m].map((_,b)=>-~a>++b?-~a:b)) // 63 n=>[...(m=Array(n))].map((_,a)=>[...m].map((_,b)=>-~a>++b?-~a:b)) // 65 n=>[...(m=Array(n)).keys()].map(a=>[...m.keys()].map(b=>-~a>++b?-~a:b)) // 71 Lã€àsä Try it online! Outputs as a 2D list. Link includes a footer to format the output.
Lã€àsä # full program € # list of... à # maximum... € # s... à # of... € # each element of... ã # list of distinct combinations of two elements in... L # [1, 2, 3, ..., # ..., implicit input... L # ]... ã # repeated twice... ä # split into pieces of length... s # implicit input # implicit output 
M works here tbh. ;p) \$\endgroup\$ f n=(<$>[1..n]).max<$>[1..n] Generates each row by taking the max of each element of [1..n] and a fixed value equal to the row number.
map(max 3)[1,2,3,4,5] = [3,3,3,4,5] We use <$> as an infix synonym for map.
It would be nice to reuse the <$>[1..n], but it runs into type-checking issues
26 bytes, doesn't work
f n|q<-(<$>[1..n])=q$q.max If a 1D output is allowed, we can do:
25 bytes
f n=max<$>[1..n]<*>[1..n] 
lambda n:[print(*(max(y,x)+1 for y in range(n))) for x in range(n)] 
