Diberi dua angka positif N >= 2dan N <= 100buat matriks yang mengikuti aturan berikut:

• Nomor Pertama dimulai dari posisi [0,0]
• Nomor Kedua dimulai dari posisi [0,1]
• Angka ketiga berada di bawah Angka Pertama (posisi [1,0])
• Angka-angka berikut berjalan ke arah "garis miring"
• Rentang angka yang digunakan adalah [1, N1 * N2]. Jadi, bilangan beralih dari mulai 1 ke hasil dari perkalian kedua input.

Memasukkan

• Dua angka N >= 2dan N <= 100. Angka pertama adalah jumlah baris, angka kedua jumlah kolom.

Keluaran

• Matriks. (Dapat dihasilkan sebagai array multidimensi atau string dengan jeda baris)

Contoh:

3 and 5Output angka yang diberikan :

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

Angka yang diberikan 2 and 2

1   2
3   4

Bilangan yang Diberikan 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

Kode terpendek dalam byte menang.

Jelly , 6 5 byte

pSÞỤs

Cobalah online!

Bagaimana itu bekerja

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

Cobalah online!

R , 101 60 54 byte

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

Cobalah online!

Terima kasih kepada @nwellnhof untuk sarannya rank

Jawaban Ports Dennis 'Jelly .

Jawaban lama, 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)

Cobalah online!

splitmelakukan sebagian besar pekerjaan di sini; mungkin ada algoritma pegolf tetapi ini pasti bekerja.

Penjelasan:

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
}

Cobalah online! - Anda dapat menggunakan membungkus di printsekitar sisi kanan penugasan <-untuk melihat hasil antara tanpa mengubah hasil akhir, karena printmengembalikan inputnya.

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 terima kasih kepada @ OlivierGrégoire .
-4 byte terima kasih kepada @ceilingcat .

Cobalah online.

Penjelasan:

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 lebih banyak untuk solusi ini dengan mil. Terima kasih!

Cobalah online!

J , 22 19 byte

-3 byte terima kasih kepada FrownyFrog!

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

Cobalah online!

Implementasi solusi Jelly fantastis Dennis di J.

Penjelasan:

Kata kerja Dyadic, mengambil argumen kiri dan kanan (mfn)

+/&i. membuat daftar 0..m-1 dan 0..n-1 dan membuat tabel tambahan untuk mereka:

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

[:>:@/:@/:@, meratakan tabel dan menilai daftar dua kali dan menambahkan 1 ke dalamnya:

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

,$ membentuk kembali daftar kembali ke tabel mxn:

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

APL + WIN, 38 atau 22 byte

Anjuran untuk kolom masukan bilangan bulat lalu baris:

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

atau:

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

berdasarkan aplikasi ganda Dennis naik kelas. Ketinggalan :(

Bahasa Wolfram (Mathematica) , 73 67 byte

Hitung elemen dalam baris di atas: Min[j+k,#2]~Sum~{k,i-1}

Hitung elemen pada baris saat ini dan di bawah ini: Max[j-k+i-1,0]~Sum~{k,i,#}

Masukkan ke dalam tabel dan tambahkan 1. Voila:

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

Pembaruan: Saya menyadari ada cara yang lebih pendek untuk menghitung semua posisi di depan posisi yang biasanya ditentukan dalam matriks dengan hanya satu penjumlahan dari dua dimensi:

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

Cobalah online!

Cobalah online!

APL (Dyalog Unicode) , 14 12 byte

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

Cobalah online!

-2 Berkat ngn , karena penggunaannya yang pintar ↑⍳.

Didasarkan pada solusi Jelly 5-byte milik Dennis.

05AB1E , 23 byte

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

Cobalah online!

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

Cobalah online!

Ini jelas bukan solusi terpendek, tapi saya pikir itu solusi yang menyenangkan.

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

Cobalah online!

Versi Semi-Tidak Serigala:

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

Tidak anggun, tetapi menyelesaikan pekerjaan. Bekerja dengan data 2D di Japt itu rumit.

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

Saya menambahkan -Qbendera di TIO untuk visualisasi hasil yang lebih mudah, itu tidak mempengaruhi solusi.
Bit satu byte terima kasih kepada Oliver .

Cobalah online!

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

Cobalah online!

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]

Meminta input pengguna dan mengembalikan matriks dalam Ans dan mencetaknya.

TI-Basic adalah bahasa tokenized ; semua token yang digunakan di sini adalah satu byte, selain[A] itu adalah 2 byte.

Catatan: TI-Basic (setidaknya pada TI-84 Plus CE) hanya mendukung matriks hingga 99x99, dan begitu juga program ini.

Penjelasan:

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

Cobalah online!

Port lain dari solusi 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;}

Cobalah online!

Penjelasan:

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
}

Terima kasih banyak kepada Kevin Cruijssen karena saya tidak tahu cara menjalankan kode saya di tio .
Beberapa kode seperti header dan footer dicuri darinya. -> Jawabannya

PHP, 115 byte

pendekatan yang cukup malas; mungkin bukan yang sesingkat mungkin.

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

fungsi anonim, mengambil lebar dan tinggi sebagai parameter, mengembalikan matriks 2d

coba online

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

Cobalah online!

Attache , 45 byte

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

Cobalah online!

Lambda anonim, di mana paramaters diaktifkan. Ini bisa diperbaiki untuk +1 byte, dengan menambahkan terlebih dahulu~ ke program. Test suite sudah melakukannya.

Penjelasan

Pendekatan ini mirip dengan jawaban J dan jawaban Jelly .

Ide pertama adalah membuat tabel nilai:

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

Ini menghasilkan tabel tambahan menggunakan rentang kedua parameter input. Untuk input [5, 3], ini memberi:

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

Kemudian, kami meratakan ini dengan Flat!:

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

Dengan menggunakan pendekatan dalam jawaban J, kita dapat menilai array (yaitu, mengembalikan indeks nilai yang diurutkan) dua kali, dengan 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]

Kemudian, kita perlu memotong nilainya dengan benar, seperti pada jawaban Jelly. Kita dapat memotong setiap _elemen untuk melakukan ini:

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

Kemudian, kita hanya perlu mengompensasi Attache 0-indexing dengan +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

Dan dengan demikian kita mendapatkan hasilnya.

Python 3 , 259 byte

Jadi saya melakukan ini dengan cara yang aneh. Saya perhatikan bahwa ada dua pola dalam bentuk array.

Yang pertama adalah bagaimana pola baris atas memiliki perbedaan antara setiap suku yang meningkat dari 1 -> h di mana h adalah tinggi dan l adalah panjangnya. Jadi saya membuat baris teratas berdasarkan pola itu

Untuk matriks redup (3,4) memberi max RoC = 3Kita akan melihat baris atas formulir

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

Misalkan saja redup (3,9) yang memberi max RoC = 3kita malah akan melihat baris atas

`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

Pola kedua adalah bagaimana baris berubah dari satu sama lain. Jika kita mempertimbangkan matriks:

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

dan kurangi setiap baris dari baris di bawah ini (mengabaikan baris tambahan) yang kita dapatkan

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

Setelah melihat matriks ini, kita dapat melihat bahwa matriks ini adalah urutan di 2 3 4 5 5 4 3 2mana oleh setiap baris adalah 5 istilah dari pola ini digeser oleh 1 untuk setiap baris. Lihat di bawah untuk 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|

Jadi untuk mendapatkan matriks terakhir kita ambil baris pertama yang kita buat dan output baris yang ditambahkan dengan 5 syarat yang diperlukan dari pola ini.

Pola ini akan selalu memiliki karakteristik awal 2-> max valuedan akhir di max value -> 2mana max value = min(h+1, l)dan berapa kali nilai maksimum akan muncul adalah di appearances of max = h + l -2*c -2manac = min(h+1, l) - 2

Jadi secara keseluruhan metode saya membuat baris baru terlihat seperti

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

Kode yang relevan di bawah ini. Itu tidak berakhir pendek tapi saya masih suka metode.

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)

Cobalah online!

Japt, 20 byte

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

Cobalah