Cho hai số dương N >= 2và N <= 100tạo một ma trận theo các quy tắc sau:

• Số đầu tiên bắt đầu tại vị trí [0,0]
• Số thứ hai bắt đầu tại vị trí [0,1]
• Số thứ ba nằm dưới Số thứ nhất (vị trí [1,0])
• Các số sau đi theo hướng "gạch chéo"
• Phạm vi số được sử dụng là [1, N1 * N2]. Vì vậy, các số đi từ bắt đầu 1 đến kết quả của phép nhân của cả hai đầu vào.

Đầu vào

• Hai số N >= 2và N <= 100. Số thứ nhất là số lượng hàng, Số thứ hai số lượng cột.

Đầu ra

• Ma trận. (Có thể được xuất ra dưới dạng một mảng nhiều chiều hoặc một chuỗi có ngắt dòng)

Thí dụ:

Cho số 3 and 5đầu ra:

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

Cho số 2 and 2

1   2
3   4

Cho số 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

Mã ngắn nhất tính bằng byte thắng.

Thạch , 6 5 byte

pSÞỤs

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Python 3 , 91 byte

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

Hãy thử trực tuyến!

R , 101 60 54 byte

function(M,N)matrix(rank(outer(1:M,1:N,"+"),,"l"),M,N)

Hãy thử trực tuyến!

Cảm ơn @nwellnhof vì gợi ý của rank

Cổng Dennis 'Jelly trả lời .

Câu trả lời cũ, 101 byte:

function(M,N)matrix(unsplit(lapply(split(1:(M*N),unlist(split(x,x))),rev),x<-outer(1:M,1:N,"+")),M,N)

Hãy thử trực tuyến!

splitđang làm hầu hết các công việc ở đây; có thể có một thuật toán golfier nhưng điều này chắc chắn hoạt động.

Giải trình:

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
}

Hãy thử trực tuyến! - bạn có thể sử dụng bọc printxung quanh bất kỳ phía bên phải của bài tập nào <-để xem kết quả trung gian mà không thay đổi kết quả cuối cùng, khi printtrả về đầu vào của nó.

Java 10, 121 120 109 105 byte

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 byte nhờ @ OlivierGrégoire .
-4 byte nhờ @ceilingcat .

Hãy thử trực tuyến.

Giải trình:

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

J , 15 byte

$1(+/:@;)</.@i.

-4 byte nữa cho giải pháp này bằng cách dặm. Cảm ơn!

Hãy thử trực tuyến!

J , 22 19 byte

-3 byte nhờ FrownyFrog!

,$[:>:@/:@/:@,+/&i.

Hãy thử trực tuyến!

Một triển khai giải pháp Jelly tuyệt vời của Dennis trong J.

Giải trình:

Động từ Dyadic, lấy đối số trái và phải (mfn)

+/&i. tạo danh sách 0..m-1 và 0..n-1 và tạo bảng bổ sung cho chúng:

   3 +/&i. 5
0 1 2 3 4
1 2 3 4 5
2 3 4 5 6

[:>:@/:@/:@, làm phẳng bảng và xếp hạng danh sách hai lần và thêm 1 vào bảng:

   3 ([:>:@/:@/:@,+/&i.) 5
1 2 4 7 10 3 5 8 11 13 6 9 12 14 15

,$ định hình lại danh sách trở lại bảng mxn:

   3 (-@],\[:>:@/:@/:@,+/&i.) 5
1 2  4  7 10
3 5  8 11 13
6 9 12 14 15

APL + THẮNG, 38 hoặc 22 byte

Nhắc cho cột đầu vào số nguyên sau đó hàng:

m[⍋+⌿1+(r,c)⊤m-1]←m←⍳(c←⎕)×r←⎕⋄(r,c)⍴m

hoặc là:

(r,c)⍴⍋⍋,(⍳r←⎕)∘.+⍳c←⎕

dựa trên ứng dụng tăng gấp đôi của Dennis. Bỏ lỡ điều đó :(

Ngôn ngữ Wolfram (Mathicala) , 73 67 byte

Đếm các phần tử trong các hàng trên: Min[j+k,#2]~Sum~{k,i-1}

Đếm các phần tử trên hàng hiện tại và bên dưới: Max[j-k+i-1,0]~Sum~{k,i,#}

Đặt vào một bảng và thêm 1. Voila:

1+Table[Min[j+k,#2]~Sum~{k,i-1}+Max[j-k+i-1,0]~Sum~{k,i,#},{i,#},{j,#2}]&

Cập nhật: Tôi nhận ra có một cách ngắn hơn để đếm tất cả các vị trí trước một vị trí được chỉ định thông thường trong ma trận chỉ với một tổng trên hai thứ nguyên:

Table[1+Sum[Boole[s-i<j-t||s-i==j-t<0],{s,#},{t,#2}],{i,#},{j,#2}]&

Hãy thử trực tuyến!

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 14 12 byte

{⍵⍴⍋⍋∊+/↑⍳⍵}

Hãy thử trực tuyến!

-2 nhờ ngn , do cách sử dụng thông minh của anh ấy ↑⍳.

Dựa trên giải pháp Jelly 5 byte của Dennis.

05AB1E , 23 byte

*L<DΣ¹LILâOsè}UΣXsè}Á>ô

Hãy thử trực tuyến!

Python 3 , 164 byte

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

Hãy thử trực tuyến!

Đây chắc chắn không phải là giải pháp ngắn nhất, nhưng tôi nghĩ đó là một giải pháp thú vị.

Python 2 , 93 byte

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

Hãy thử trực tuyến!

Phiên bản bán sẵn:

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

Japt , 25 24 byte

Khó thanh lịch, nhưng hoàn thành công việc. Làm việc với dữ liệu 2D trong Japt rất khó.

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

Tôi đã thêm -Qcờ trong TIO để dễ hình dung hơn về kết quả, nó không ảnh hưởng đến giải pháp.
Giảm một byte nhờ Oliver .

Hãy thử trực tuyến!

JavaScript (Node.js) , 103 byte

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

Hãy thử trực tuyến!

TI-Basic, 76 byte

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]

Nhắc nhở đầu vào của người dùng và trả về ma trận trong Ans và in nó.

TI-Basic là ngôn ngữ được mã hóa ; tất cả các mã thông báo được sử dụng ở đây là một byte, khác với [A]2 byte.

Lưu ý: TI-Basic (ít nhất là trên TI-84 Plus CE) chỉ hỗ trợ ma trận lên tới 99x99, và chương trình này cũng vậy.

Giải trình:

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

Perl 6 , 61 59 byte

{($!={sort($_ Z=>1..*)>>.{*}})($!([X+] ^<<$_)).rotor(.[1])}

Hãy thử trực tuyến!

Một cổng khác của giải pháp Dennis 'Jelly.

Java (JDK 10) , 142 131 byte

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

Hãy thử trực tuyến!

Giải trình:

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
}

Xin chân thành cảm ơn Kevin Cruijssen vì tôi không biết cách chạy mã trên tio .
Một số mã như tiêu đề và chân trang bị đánh cắp từ anh ta. -> Câu trả lời của anh ấy

PHP, 115 byte

một cách tiếp cận khá lười biếng; có lẽ không phải là ngắn nhất có thể

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

Hàm ẩn danh, lấy chiều rộng và chiều cao làm tham số, trả về ma trận 2d

thử trực tuyến

JavaScript (Node.js) , 108 105 101 100 byte

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

Hãy thử trực tuyến!

Tùy viên , 45 byte

{Chop[Grade//2<|Flat!Table[`+,1:_2,1:_],_]+1}

Hãy thử trực tuyến!

Lambda ẩn danh, nơi các paramaters được chuyển đổi. Điều này có thể được sửa cho byte 1, bằng cách thêm trước~ chương trình. Bộ thử nghiệm đã làm điều này rồi.

Giải trình

Cách tiếp cận này tương tự như câu trả lời J và câu trả lời Jelly .

Ý tưởng đầu tiên là tạo một bảng các giá trị:

Table[`+,1:_2,1:_]

Điều này tạo ra một bảng bổ sung sử dụng phạm vi của cả hai tham số đầu vào. Đối với đầu vào [5, 3], điều này mang lại:

A> Table[`+,1:3,1:5]
 2 3 4 5 6
 3 4 5 6 7
 4 5 6 7 8

Sau đó, chúng tôi làm phẳng điều này với Flat!:

A> Flat!Table[`+,1:3,1:5]
[2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8]

Sử dụng cách tiếp cận trong câu trả lời J, chúng ta có thể phân loại mảng (nghĩa là trả về các chỉ số của các giá trị được sắp xếp) hai lần, với 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]

Sau đó, chúng ta cần cắt các giá trị lên một cách chính xác, như trong câu trả lời Jelly. Chúng tôi có thể cắt mọi _yếu tố để làm điều này:

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

Sau đó, chúng ta chỉ cần bù cho việc lập chỉ mục 0 của Attache với +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

Và do đó chúng tôi có kết quả.

Python 3 , 259 byte

Vì vậy, tôi đã làm điều này một cách kỳ lạ. Tôi nhận thấy rằng có hai mẫu trong cách hình thành mảng.

Đầu tiên là cách mẫu hàng trên cùng có sự khác biệt giữa mỗi thuật ngữ tăng từ 1 -> h trong đó h là chiều cao và l là chiều dài. Vì vậy, tôi xây dựng hàng trên cùng dựa trên mẫu đó

Đối với ma trận mờ (3,4), max RoC = 3chúng ta sẽ thấy hàng trên cùng của biểu mẫu

1, (1+1), (2+2), (4+3) = 1, 2, 4, 7

Thay vào đó, giả sử thay vì mờ (3,9), max RoC = 3chúng ta sẽ thấy một hàng trên cùng của

`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

Mẫu thứ hai là cách các hàng thay đổi lẫn nhau. Nếu chúng ta xem xét ma trận:

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

và trừ từng hàng từ hàng bên dưới (bỏ qua hàng thừa) chúng tôi nhận được

2 3 4 5 5
3 4 5 5 4
4 5 5 4 3
5 5 4 3 2

Khi nhìn thấy ma trận này, chúng ta có thể nhận thấy ma trận này là chuỗi 2 3 4 5 5 4 3 2trong đó mỗi hàng là 5 số hạng của mẫu này được dịch chuyển 1 cho mỗi hàng. Xem dưới đây để trực quan.

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

Vì vậy, để có được ma trận cuối cùng, chúng tôi lấy hàng đầu tiên của chúng tôi, chúng tôi đã tạo và xuất ra hàng đó được thêm vào với 5 điều khoản cần thiết của mẫu này.

Mẫu này sẽ luôn có các đặc điểm bắt đầu 2-> max valuevà kết thúc max value -> 2trong đó max value = min(h+1, l)và số lần giá trị tối đa sẽ xuất hiện là appearances of max = h + l -2*c -2ở đâuc = min(h+1, l) - 2

Vì vậy, trong toàn bộ phương pháp tạo hàng mới của tôi trông giống như

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

Mã liên quan dưới đây. Nó không kết thúc ngắn nhưng tôi vẫn thích phương pháp này.

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)

Hãy thử trực tuyến!

Japt, 20 byte

õ ïVõ)ñx
£bYgUñ¹ÄÃòV

Thử nó