[Question]
  [
Given two positive numbers `N >= 2` and `N <= 100` create a matrix which follows the following rules:
* First Number starts at position `[0,0]`
* Second Number starts at position `[0,1]`
* Third number goes below First Number (position `[1,0]`)
* Following numbers goes in "slash" direction
* Range of numbers used is `[1, N1 * N2]`. So, numbers goes from starting 1 to the result of the multiplication of both inputs.
**Input**
* Two numbers `N >= 2` and `N <= 100`. First number is the amount of rows, Second number the amount of columns.
**Output**
* Matrix. (Can be outputted as a multidimensional array or a string with line breaks)
**Example:**
Given numbers `3 and 5` output:
```
1   2   4   7   10
3   5   8   11  13
6   9   12  14  15
```
Given numbers `2 and 2`
```
1   2
3   4
```
Given Numbers `5 and 5`
```
1   2   4   7   11
3   5   8   12  16
6   9   13  17  20
10  14  18  21  23
15  19  22  24  25
```
The shortest code in bytes wins.
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~6~~ 5 bytes
```
pS√û·ª§s
```
[Try it online!](https://tio.run/##y0rNyan8/78g@PC8h7uXFP8/vNxI3/1R05qsR437Dm07tO3/f2MdBVMdBSMwAjJMAQ "Jelly ‚Äì Try It Online")
### How it works
```
pS√û·ª§s  Main link. Left argument: n. Right argument: k
p      Take the Cartesian product of [1, ..., n] and [1, ..., k], yielding
       [[1, 1], [1, 2], ..., [n, k-1], [n, k]].
 S√û    Sort the pairs by their sums.
       Note that index sums are constant on antidiagonals.
   ·ª§   Grade up, sorting the indices of the sorted array of pairs by their values.
    s  Split the result into chunks of length k.
```
[Answer]
# [Python 3](https://docs.python.org/3/), 91 bytes
```
def f(n,k):M=[(t//k+t%k,t)for t in range(n*k)];return zip(*k*[map([M,*sorted(M)].index,M)])
```
[Try it online!](https://tio.run/##LYxNCoMwEIXXeorZiDNpqKB0Y@kRPIG4EExaCZ2EdKQ/l08N7WrevPfxhbfcPHcpLcaCRdaO@uEyojSNO0jltJD1EQRWhjjz1SArR9M5Gtkiw2cNqJwa73PAcdDq4aOYBQeajisv5qX3RCkbdjU4yhrsNJxIA7Ya2nxP@e/LImPRPzNjf/heFiGuLFhX7QY1KHBQZYjK/0DpCw "Python 3 ‚Äì Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~101~~ ~~60~~ 54 bytes
```
function(M,N)matrix(rank(outer(1:M,1:N,"+"),,"l"),M,N)
```
[Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/T8NXx08zN7GkKLNCoygxL1sjv7QktUjD0MpXx9DKT0dJW0lTR0cpB0iCFP5P0zDWMdXkStMwBVL/AQ "R ‚Äì Try It Online")
*Thanks to @nwellnhof for the suggestion of `rank`*
Ports [Dennis' Jelly answer](https://codegolf.stackexchange.com/a/163275/67312).
Old answer, 101 bytes:
```
function(M,N)matrix(unsplit(lapply(split(1:(M*N),unlist(split(x,x))),rev),x<-outer(1:M,1:N,"+")),M,N)
```
[Try it online!](https://tio.run/##LYxBCoAgEEX3nSJazdS0iGgTXUHvIJEgmImNYac3o1af//7jh6zrpc86upXN4UCQxF1xMAmiO701DFZ5b2/4yjCDaCVSdNac/MNECREpbBdSWvoj8haKKWiYJTVdU7b3N2sYacJKw1QiPw "R ‚Äì Try It Online")
`split` is doing most of the work here; possibly there's a golfier algorithm but this definitely works.
Explanation:
```
function(M,N){
x <- outer(1:M,1:N,"+")			# create matrix with distinct indices for the antidiagonals
idx <- split(x,x)			# split into factor groups
items <- split(1:(M*N),unlist(idx))	# now split 1:(M*N) into factor groups using the groupings from idx
items <- lapply(items,rev)		# except that the factor groups are
					# $`2`:1, $`3`:2,3, (etc.) but we need
                                        # $`2`:1, $`3`:3,2, so we reverse each sublist
matrix(unsplit(items,x),M,N)		# now unsplit to rearrange the vector to the right order
					# and construct a matrix, returning the value
}
```
[Try it online!](https://tio.run/##jZHBTsMwDIbP7VNYg0MCAWmbdql4he0ZlrVuF6lLKsfZihDPPtysEwJxoJfIbv4v/n/TtYW3l2ubfM0ueLU1O/1RjtKDkBhJLautWVY7s3he6KIoHqAmtIxwskxuhIvjIzQushMAON@4GiO0gYCPCNaza5ztgrd9LF2TuXHoHavRjDdeLkXJAVpbsyg7CmmQ64yn@C1YVmr7tNMm@V6eUwLTWuQ@XGbEfOEPFKTofJcnyg0pZEYKJxDK9zu9HYb@XeXaEJ71NB6ONQ4sWssZ8BNsCcuiyD4e96t9tTRyrvfVyqwNKOT6VcMhMVwQPGJTwj@/X7i1WRmIYcLIXEgRAW19hJgOUxjlbRkq@VtUNwejNtM2izmk@SdIOLJBIus7zI7OmB1Jf6rIdUeGQA3S3Zn1DdTBR6YkO7bz6o1gOJG/J3u2fcLy89qqtdnoslUbOa5f "R ‚Äì Try It Online") -- you can use wrap a `print` around any of the right-hand sides of the assignments `<-` to see the intermediate results without changing the final outcome, as `print` returns its input.
[Answer]
# Java 10, ~~121~~ ~~120~~ ~~109~~ 105 bytes
```
m->n->{var R=new int[m][n];for(int i=0,j,v=0;i<m+n;)for(j=++i<n?0:i-n;j<i&j<m;)R[j][i-++j]=++v;return R;}
```
-11 bytes thanks to *@OlivierGr√©goire*.  
-4 bytes thanks to *@ceilingcat*.
[Try it online.](https://tio.run/##jZExa8MwEIX3/oqbioVlYRKyRLZLl0KHLsloNKiOE6RaZyPLLiHkt7tyIkhSOhSEuMd7h96HtBxlondfU9XIvocPqfD0BNA76VQF2rtscKph@wErp1pkb2HI3tHVh9rS/4UUulKUoiigghwmkxSYFKdRWtjkWH9ffCNKFHzf2sgrUHlKNR3zlKvMxMjJbOg8jlWGL@laJch1pp51ZjjZlFqUKoljLXxg5LZ2g0XY8PPEPY0/3fDZeKDANbZqB8azRltnFR5KIcmMDeDq3kVLuiL8Jld0eS8XdPHorh7dX7vX8Pla4/79iz@TIp1vExoEfl9pXTHZdc0xQhIGQ8glA7A99q42rB0c6zyBazC6/cOrtfLYM9de6SJJQqU/tkK78/QD)
**Explanation:**
```
m->n->{                // Method with two integer parameters and integer-matrix return-type
  var R=new int[m][n]; //  Result-matrix of size `m` by `n`
  for(int i=0,j,       //  Index integers, starting at 0
          v=0;         //  Count integer, starting at 0
      i<m+n;)          //  Loop as long as `i` is smaller than `m+n`
    for(j=++i<n?0      //   Set `j` to 0 if `i+1` is smaller than `n`
               :i-n;   //   or to the difference between `i` and `n` otherwise
        j<i&j<m;)      //   Inner loop `j` until it's equal to either `i` or `m`,
                       //   so basically check if it's still within bounds:
      R[j][i-++j]=++v; //    Add the current number to cell `j, i-(j+1)`
  return R;}           //  Return the result-matrix
```
[Answer]
# [J](http://jsoftware.com/), 15 bytes
```
$1(+/:@;)</.@i.
```
-4 more bytes for this solution by miles. Thanks!
[Try it online!](https://tio.run/##y/qfVmyrp2CgYKVg8F/FUENb38rBWtNGX88hU@@/JpeSnoJ6mq2euoKOQq2VQloxF1dqcka@QpqCsYIpjGmkYARjmgJF/wMA "J ‚Äì Try It Online")
# [J](http://jsoftware.com/), 22 19 bytes
-3 bytes thanks to FrownyFrog!
```
,$[:>:@/:@/:@,+/&i.
```
[Try it online!](https://tio.run/##y/qfVmyrp2CgYKVg8F9HJdrKzspBH4x0tPXVMvX@a3Ip6Smop9nqqSvoKNRaKaQVc3GlJmfkKxgrpCmYQphGQKYRhGkKFv0PAA "J ‚Äì Try It Online")
An implementation of Dennis' fantastic Jelly solution in J.
## Explanation:
Dyadic verb, takes left and right argument (m f n)
`+/&i.` creates lists 0..m-1 and 0..n-1 and makes an addition table for them:
```
   3 +/&i. 5
0 1 2 3 4
1 2 3 4 5
2 3 4 5 6
```
`[:>:@/:@/:@,` flattens the table and grades the list twice and adds 1 to it:
```
   3 ([:>:@/:@/:@,+/&i.) 5
1 2 4 7 10 3 5 8 11 13 6 9 12 14 15
```
`,$` reshapes the list back into mxn table:
```
   3 (-@],\[:>:@/:@/:@,+/&i.) 5
1 2  4  7 10
3 5  8 11 13
6 9 12 14 15
```
[Answer]
# APL+WIN, 38 or 22 bytes
Prompts for integer input column then row:
```
m[‚çã+‚åø1+(r,c)‚ä§m-1]‚Üêm‚Üê‚ç≥(c‚Üê‚éï)√ór‚Üê‚éï‚ãÑ(r,c)‚ç¥m
```
or:
```
(r,c)‚ç¥‚çã‚çã,(‚ç≥r‚Üê‚éï)‚àò.+‚ç≥c‚Üê‚éï
```
based on Dennis's double application of grade up. Missed that :(
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~73~~ 67 bytes
Count elements in rows above: `Min[j+k,#2]~Sum~{k,i-1}`
Count elements on the current row and below: `Max[j-k+i-1,0]~Sum~{k,i,#}`
Put into a table and add 1. Voila:
```
1+Table[Min[j+k,#2]~Sum~{k,i-1}+Max[j-k+i-1,0]~Sum~{k,i,#},{i,#},{j,#2}]&
```
Update: I realized there is a shorter way to count all the positions ahead of a normally specified position in the matrix with just one sum over two dimensions:
```
Table[1+Sum[Boole[s-i<j-t||s-i==j-t<0],{s,#},{t,#2}],{i,#},{j,#2}]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7PyQxKSc12lA7uDQ32ik/H8gu1s20ydItqakBMmxtgSwbg1id6mId5Vqd6hIdZaNaIC8TzMsC89T@BxRl5pVEp0Ub65jGxv4HAA "Wolfram Language (Mathematica) ‚Äì Try It Online")
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b731A7JDEpJzXaNzMvOks7W0fZKLYuuDS3rjpbJ1PXsFbbN7EiOks3WxvI0TFASOko1@pUQ8gsoJ7aWLX/AUWZeSXRadHGOqaxsf8B "Wolfram Language (Mathematica) ‚Äì Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~14~~ 12 bytes
```
{‚çµ‚ç¥‚çã‚çã‚àä+/‚Üë‚ç≥‚çµ}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v/pR79ZHvVse9XaDUEeXtv6jtomPejcDhWv//3/UO1fBNzEzTyGtNC@5JDM/T0GjuDQpN7O4GMjW5OJKU3jUNkEBnxlcXCAzQlKLSxSSE4tTi4EGpBYkFiWWpCqUZ5ZkKCQq5GTmpSok5@eVAO3JzEtX0HjUNxVo6qPeNZpgG4wVTLngQkC@kYIRCt9UwRQA "APL (Dyalog Unicode) ‚Äì Try It Online")
-2 thanks to [ngn](https://codegolf.stackexchange.com/users/24908/ngn), due to his clever usage of `‚Üë‚ç≥`.
Based off of Dennis's 5-byte Jelly solution.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 23 bytes
```
*L<DŒ£¬πLIL√¢Os√®}UŒ£Xs√®}√Å>√¥
```
[Try it online!](https://tio.run/##MzBNTDJM/f9fy8fG5dziQzt9PH0OL/IvPryiNvTc4ggQfbjR7vCW//@NuUwB "05AB1E ‚Äì Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 164 bytes
```
from numpy import*
r=range
def h(x,y):
 a,i,k,j=-array([i//y+i%y for i in r(x*y)]),1,2,0
 while j<x+y:a[a==-j],i,k,j=r(i,k),k,k+sum(a==~j),j+1
 a.shape=x,y;return a
```
[Try it online!](https://tio.run/##TY07DsIwEER7n2IbJC9Z/qIBfBJEYQkHryGOtTgibrh6MBIFzXw00rxUsu/jbppa6TuIQ5cKcJd6yXMlRmy8OXV1LXg9UsGDAktMdwpmYUVs0WderUrDswJtL8DAEUSP84IXpA1taa3g5fnhIJzGphzs2RqzCJffiejqWOO9eQ6drts7IIVmUznLp7fJmYo9isuDRLBTEo5Ze/1VjmnIGpHgvwHitFf7Dw "Python 3 ‚Äì Try It Online")
This is definitely not the shortest solution, but I thought it was a fun one.
[Answer]
# [Python 2](https://docs.python.org/2/), 93 bytes
```
def f(b,a):i=1;o=[];exec"if b:o+=[],;b-=1\nfor l in o:k=len(l)<a;l+=[i]*k;i+=k\n"*a*b;print o
```
[Try it online!](https://tio.run/##FYtBDsIgEADP@opNT9Cuh2J6AXmJ7QEU4gayNE0P@nqE02SSmf13fgqrWt8hQhQendRkZ1PsczPhG14DRfC6TM3R@JudV47lgAzEUHSyObDI8uFMbgltYzI02bTyMLrRm/0gPqHUvghGSLJ/4o6wSAShEFTn0l1fL7E1SdY/ "Python 2 ‚Äì Try It Online")
Semi-Ungolfed version:
```
def f(b,a):
    i=1
    o=[]
    for _ in range(a*b)
        if b:
            o+=[[]]
            b-=1
        for l in o:
            if len(l)<a:
                l+=[i]
                i+=1
    print o
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~25~~ 24 bytes
Hardly elegant, but gets the job done. Working with 2D data in Japt is tricky.
```
;N√ó√á<U¬©Ap[] A¬Æ√ä<V¬©Zp¬∞T
A
;                      // Set alternative default vars where A is an empty array.
 N√ó√á                   // Multiply the inputs and map the range [0..U*V).
    <U                 // If the current item is less than the second input,
      ¬©Ap[]            // add a new empty subarray into A.
            A¬Æ         // Then, for each item in A,
              √ä<V      // if its length is less than the first input,
                 ¬©Zp¬∞T // Add the next number in the sequence to it.
A                      // Output the results, stored in A.
```
I added the `-Q` flag in TIO for easier visualization of the results, it doesn't affect the solution.  
Bit off one byte thanks to [Oliver](https://codegolf.stackexchange.com/users/61613/oliver).
[Try it online!](https://tio.run/##AS0A0v9qYXB0//87TsOXw4c8VcKpQXBbXSBBwq7DijxWwqlacMKwVApB//8zIDUKLVE)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 103 bytes
```
(a,b,e=[...Array(b)].map(_=>[]))=>f=(x=0,y=i=0)=>(x<a&y<b&&(e[y][x]=++i),x?f(--x,++y):y>a+b?e:f(++y,0))
```
[Try it online!](https://tio.run/##DcpNCoMwEEDh28gM@UEo3Vgn0o2XCKFMbCwWaySWkpzeZvk@3pt/fExp2b9qi89wjnQyGU8GAlmt9T0lLuDR6Q/v8CBjHcqZIFMrCy3UYl1zz03pfdNAsMXZ7EiIBWUeZlAqSyEKdsWw8EPoZqgpW0Q8b1PcjrgGvcYXjHBFuCBU/wM "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# TI-Basic, 76 bytes
```
Prompt A,B
{A,Bü°ídim([A]
1ü°íX
For(E,1,B+A
For(D,1,E
If D≤A and E-D<B
Then
Xü°í[A](D,E-D+1
X+1ü°íX
End
End
End
[A]
```
Prompts for user input and returns the matrix in `Ans` and prints it.
TI-Basic is a [tokenized language](http://tibasicdev.wikidot.com/tokens); all tokens used here are one byte, other than `[A]` which is 2 bytes.
Note: TI-Basic (at least on the TI-84 Plus CE) only supports matrices up to 99x99, and so does this program.
Explanation:
```
Prompt A,B        # 5 bytes, prompt for user input
{A,Bü°ídim([A]      # 9 bytes, make the matrix the right size
1ü°íX               # 4 bytes, counter variable starts at 1
For(E,1,B+A       # 9 bytes, Diagonal counter, 1 to A+B-1, but we can over-estimate since we have to check later anyway.
For(D,1,E         # 7 bytes, Row counter, 1 to diagonal count
If D≤A and E-D<B  # 10 bytes, Check if we are currently on a valid point in the matrix
Then              # 2 bytes, If so,
Xü°í[A](D,E-D+1     # 13 bytes, Store the current number in the current point in the matrix
X+1ü°íX             # 6 bytes, Increment counter
End               # 2 bytes, End dimension check if statement
End               # 2 bytes, End row for loop
End               # 2 bytes, End dimension for loop
[A]               # 2 bytes, Implicitly return the matrix in Ans and print it
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~61~~ 59 bytes
```
{($!={sort($_ Z=>1..*)>>.{*}})($!([X+] ^<<$_)).rotor(.[1])}
```
[Try it online!](https://tio.run/##FYtBCsIwEEWvMpYgMzUMtFI3NjmHWGtxYUDRRqbdlJCzx2T1@O/zfk/5nNJ3g70DkwKqnQmLlxXVBFdjG@aarOVQx0j5xOFyGOHe92oiYvGrF@ShGSmm5bGByxnx279mrG5zRRoKwHkBPGrossBWQ1vYlX1Ofw "Perl 6 ‚Äì Try It Online")
Another port of Dennis' Jelly solution.
[Answer]
# [Java (JDK 10)](http://jdk.java.net/), ~~142~~ 131 bytes
```
X->Y->{var A=new int[X][Y];int E=1;for(int y=0;y<Y+X-1;y++)for(int x=0;x<X;x++){if(y-x<0|y-x>Y-1)continue;A[x][y-x]=E++;}return A;}
```
[Try it online!](https://tio.run/##jVE9b4MwEN37K260xYfy0Sw1IDGkUodOWUDIg0tJ5JQYZI4UK@W3U0OokkodKlmnu/fOfvfOR3EW3vH9Y8hL0TTwKqS6PAA0KFDmcLSs36Is/X2rcpSV8p/nJHhRWBwK7f6vSSrMeMajCHIIYUi8KPWiy1loiENVfE58wrOUM5vBNlyyfaXJmJtwwUyQOom3ZMZx6A/eWbwLEtZZ7CL3xHhdsPiy0b68pHmlUKq2YHHW8cyiPNw6Dut1ga1WELN@YNanPXX7Vlqrs@NzJd/hZLdAdqilOmRc0HEhAFg0SNbuI2W3cuOu78uVu/rNbqayvwrdK0z86CJ1x5jMGrM3K/qU@6KuS0NSOicJpVMPwM40WJz8qkW/tjNiqcjtD2KthWl8rK7zE0Hnkf64NU/XD98 "Java (JDK 10) ‚Äì Try It Online")
**Explanation:**
```
X->Y->{                            // Method with two integer parameters and integer-matrix return-type
    var A=new int[X][Y];           // The Matrix with the size of X and Y
    int E=1;                       // It's a counter
        for(int y=0;y<Y+X-1;y++)   // For each column plus the number of rows minus one so it will run as long as the bottom right corner will be reached
            for(int x=0;x<X;x++){  // For each row
                if(y-x<0|y-x>Y-1)  // If the cell does not exist becouse it's out of range
                    continue;      // Skip this loop cycle
                A[x][y-x]=E++;     // Set the cell to the counter plus 1
            }
    return A;                      // Return the filled Array
}
```
*Big thank to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen) because I didn't know how to run my code on [tio](https://tio.run/).  
Some code like the header and footer are stolen from him. [-> His answer](https://codegolf.stackexchange.com/a/163276/75908)*
[Answer]
# [Husk](https://github.com/barbuz/Husk), 9 bytes
```
·π†CoŒ∑√ñ¬§√ó,·∏£
```
[Try it online!](https://tio.run/##AR0A4v9odXNr///huaBDb863w5bCpMOXLOG4o////zP/NQ "Husk ‚Äì Try It Online") Most of the heavy lifting is done by `√ó`, which creates pairs in the desired order so that it can support infinite lists.
### Explanation
```
CŒ∑√ñ√ó,·∏£¬≤·∏£‚Å∞‚Å∞  (Expanded; let N and K denote the arguments.)
 Œ∑√ñ          Take the list of indices of the sorted values of
   √ó,         the list of all pairs taken from
     ·∏£¬≤        the range from 1 to N and
       ·∏£‚Å∞      the range from 1 to K, and
C        ‚Å∞  cut it into lengths of K.
```
[Answer]
# PHP, 115 bytes
a pretty lazy approach; probably not the shortest possible.
```
function($w,$h){for(;$i++<$h*$w;$r[+$y][+$x]=$i,$x--&&++$y<$h||$x=++$d+$y=0)while($x>=$w|$y<0)$y+=!!$x--;return$r;}
```
anonymous function, takes width and height as parameters, returns 2d matrix
[try it online](http://sandbox.onlinephpfunctions.com/code/67d5f8de325e9267933c5eeb634f3d8f07cece55)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 108 105 101 100 bytes
```
n=>(l=>{for(r=[];i<n*n;n*~-n/2+2>i?l++:l--*y++)for(T=y,t=l;t--;)r[T]=[...r[T++]||[],++i]})(y=i=0)||r
```
[Try it online!](https://tio.run/##FcoxDsIgFADQ3ZMAv6Dp4CB@vEQ3wtDUYjDkYygxIaJXR93e8O7zc96WHB5FUrqu3WMnNCyiefmUWUbrdDiTIE3iI2k/wmjCJQKcopSiAvB/m7AOBaMuUmqe7eTQKqV@AHCtWTcABPfmrGLAA28t9yXRluKqYroxz46c7/oX "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [Attache](https://github.com/ConorOBrien-Foxx/Attache), 45 bytes
```
{Chop[Grade//2<|Flat!Table[`+,1:_2,1:_],_]+1}
```
[Try it online!](https://tio.run/##SywpSUzOSP2fZmX7v9o5I78g2r0oMSVVX9/IpsYtJ7FEMSQxKSc1OkFbx9Aq3ghExOrEx2ob1v73S01NKY5WKShITo/lqlYIKMrMK4mOj9dRUNK1U4q1VnDJLC7ISayMTnNwiAdyIfKxCrUKtnYK0VwKQBBtrGMaqwNhGukYwZimQFGu2P8A "Attache ‚Äì Try It Online")
Anonymous lambda, where paramaters are switched. This can be fixed for +1 byte, by prepending `~` to the program. The test suite does this already.
## Explanation
This approach is similar to the [J answer](https://codegolf.stackexchange.com/a/163281/31957) and the [Jelly answer](https://codegolf.stackexchange.com/a/163275/31957).
The first idea is to generate a table of values:
```
Table[`+,1:_2,1:_]
```
This generates an addition table using ranges of both input parameters. For input `[5, 3]`, this gives:
```
A> Table[`+,1:3,1:5]
 2 3 4 5 6
 3 4 5 6 7
 4 5 6 7 8
```
Then, we flatten this with `Flat!`:
```
A> Flat!Table[`+,1:3,1:5]
[2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8]
```
Using the approach in the J answer, we can grade the array (that is, return indices of sorted values) twice, with `Grade//2`:
```
A> Grade//2<|Flat!Table[`+,1:3,1:5]
[0, 1, 3, 6, 9, 2, 4, 7, 10, 12, 5, 8, 11, 13, 14]
```
Then, we need to chop the values up correctly, as in the Jelly answer. We can cut every `_` elements to do this:
```
A> Chop[Grade//2<|Flat!Table[`+,1:3,1:5],5]
 0 1  3  6  9
 2 4  7 10 12
 5 8 11 13 14
```
Then, we just need to compensate for the 0-indexing of Attache with `+1`:
```
A> Chop[Grade//2<|Flat!Table[`+,1:3,1:5],5]+1
 1 2  4  7 10
 3 5  8 11 13
 6 9 12 14 15
```
And thus we have the result.
[Answer]
# [Python 3](https://docs.python.org/3/), 259 bytes
So I did this a weird way. I noticed that there were two patterns in the way the array forms. 
**The first** is how the top rows pattern has the difference between each term increasing from 1 -> h where h is the height and l is the length. So I construct the top row based on that pattern
For a matrix of dim(3,4) giving a `max RoC = 3` We will see the top row of the form 
```
1, (1+1), (2+2), (4+3) = 1, 2, 4, 7
```
Suppose instead that the dim(3,9) giving a `max RoC = 3` we will instead see a top row of 
```
`1, (1+1), (2+2), (4+3), (7+3), (10+3), (13+3), (16+3), (19+3) = 1, 2, 4, 7, 10, 13, 16, 19, 22
```
**The second** pattern is how the rows change from one another. If we consider the matrix:
```
1   2   4   7   11
3   5   8   12  16
6   9   13  17  20
10  14  18  21  23
15  19  22  24  25
```
and subtract each row from the row below (ignoring the extra row) we get
```
2 3 4 5 5
3 4 5 5 4
4 5 5 4 3
5 5 4 3 2
```
Upon seeing this matrix we can notice this matrix is the sequence `2 3 4 5 5 4 3 2` where by each row is 5 terms of this pattern shifted by 1 for each row. See below for visual.
```
         |2 3 4 5 5| 4 3 2
       2 |3 4 5 5 4| 3 2
     2 3 |4 5 5 4 3| 2
   2 3 4 |5 5 4 3 2|
```
So to get the final matrix we take our first row we created and output that row added with the 5 needed terms of this pattern. 
This pattern will always have the characteristics of beginning `2-> max value` and ending `max value -> 2` where the `max value = min(h+1, l)` and the number of times that the max value will appear is `appearances of max = h + l -2*c -2` where `c = min(h+1, l) - 2`
So in whole my method of creating new rows looks like
```
1  2  3  7  11 +      |2 3 4 5 5|4 3 2  = 3  5  8  12 16
3  5  8  12 16 +     2|3 4 5 5 4|3 4 2  = 6  9  13 17 20
6  9  13 17 20 +   2 3|4 5 5 4 3|4 2    = 10 14 18 21 23
10 14 18 21 23 + 2 3 4|5 5 4 3 2|       = 15 19 22 24 25
```
Relevant code below. It didn't end up being short but I still like the method.
```
o,r=len,range
def m(l,h):
 a,t=[1+sum(([0]+[x for x in r(1,h)]+[h]*(l-h))[:x+1]) for x in r(l)],min(l,h+1);s,c=[x for x in r(2,t)],[a[:]]
 for i in r(h-1):
  for j in r(o(a)):
   a[j]+=(s+[t]*(l+h-2*(t-2)-2)+s[::-1])[0+i:l+i][j]
  c+=[a[:]]
 for l in c:print(l)
```
[Try it online!](https://tio.run/##VY7BbsMgEETvfAVHNguSTdsLEV@COCDHKUQYR5hK7tc7a7uHVEJa7dthZp6/Lc7lY9tmWW0ei6yhfI/sNt75JLKMYBgPslnX4/IzCeE6j27l97nylafCq@hJRCz6i8gqAjizYu/hXZLByymVw@@6yMH@d9CykcAFZ7xnxyGdh6j6Pf9AjxPNIsDBeHAPj1Ys6NoejVHpi2hKAz1cnDGKWrgOk8mYPInp04D2PSbvnoN51lQaldwmqqKBnTtwNolP@UXzD9CuO6k72F4 "Python 3 ‚Äì Try It Online")
[Answer]
# Japt, 20 bytes
```
√µ √ØV√µ)√±x
¬£bYgU√±¬π√Ñ√É√≤V
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=9SDvVvUp8XgKo2JZZ1XxucTD8lY=&input=Myw1Ci1S)
[Answer]
# [Haskell](https://www.haskell.org/), 92 bytes
```
r=[1..]
(#)=take
n!k=[[sum$lookup(i,j)$zip[(i,j)|s<-r,i<-n#r,j<-k#r,i+j==s]r|j<-k#r]|i<-n#r]
```
[Try it online!](https://tio.run/##bY5BCsMgEEX3OcWEuFBqhBK6096gJxApQgM1JkY02ZTc3ZrYQhddzf/z33zmqaPtxzGlIOSZMVXhhohF275ytRVSxnVC4zzb1WNDB4JexstDbZG3gRreuibQgbc2D3MahIgqbMWrrcQqTdo4EPCYK4BJ@9sdfDBuAQRdfcm7r5Of7ny/f3NRR8UuO6V@uVyCMSWGFOw/hVFJCcs4yzhH10KlNw "Haskell ‚Äì Try It Online")
]