두 양수를 감안 N >= 2하고 N <= 100다음과 같은 규칙을 따르는 행렬을 작성 :

• 첫 번째 번호는 위치에서 시작 [0,0]
• 두 번째 숫자는 위치에서 시작 [0,1]
• 세 번째 숫자는 첫 번째 숫자 (위치 [1,0]) 아래로 내려갑니다.
• 다음 숫자는 "슬래시"방향으로갑니다
• 사용 된 숫자의 범위는 [1, N1 * N2]입니다. 따라서 숫자는 1부터 시작하여 두 입력의 곱셈 결과로 이어집니다.

입력

• 두 개의 숫자 N >= 2와 N <= 100. 첫 번째 숫자는 행의 양이고, 두 번째 숫자는 열의 양입니다.

산출

• 매트릭스. (다차원 배열 또는 줄 바꿈이있는 문자열로 출력 가능)

예:

주어진 숫자 3 and 5출력 :

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

주어진 숫자 2 and 2

1   2
3   4

주어진 숫자 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

바이트 단위의 가장 짧은 코드가 이깁니다.

젤리 , 6 5 바이트

pSÞỤs

온라인으로 사용해보십시오!

작동 원리

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.

파이썬 3 , 91 바이트

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

온라인으로 사용해보십시오!

R , 101 60 54 바이트

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

온라인으로 사용해보십시오!

제안을 해준 @nwellnhof에게 감사드립니다. rank

포트 데니스의 젤리가 대답 합니다.

이전 답변, 101 바이트 :

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

온라인으로 사용해보십시오!

split여기서 대부분의 작업을 수행하고 있습니다. 골퍼 알고리즘이있을 수 있지만 이것은 확실히 작동합니다.

설명:

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
}

온라인으로 사용해보십시오! - print과제의 오른쪽을 감싸서 <-최종 결과를 변경하지 않고 중간 결과를 볼 수 print있습니다. 입력 을 반환합니다.

자바 10 121 120 109 105 바이트

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

@ OlivierGrégoire 덕분에 -11 바이트 . @ceilingcat
덕분에 -4 바이트 .

온라인으로 사용해보십시오.

설명:

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 바이트

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

이 솔루션에 대해 -4 바이트 더 많은 마일. 감사!

온라인으로 사용해보십시오!

J , 22 19 바이트

FrownyFrog 덕분에 -3 바이트!

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

온라인으로 사용해보십시오!

J에서 Dennis의 환상적인 Jelly 솔루션 구현

설명:

Dyadic 동사, 왼쪽과 오른쪽 인수 (MFN)

+/&i. 목록 0..m-1 및 0..n-1을 작성하고 추가 테이블을 작성합니다.

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

[:>:@/:@/:@, 테이블을 평평하게하고 목록을 두 번 채점하고 1을 추가합니다.

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

,$ 목록을 다시 mxn 테이블로 재구성합니다.

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

APL + WIN, 38 또는 22 바이트

정수 입력 열에 대해 프롬프트 한 다음 행을 표시하십시오.

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

또는:

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

Dennis의 등급 업 이중 적용을 기준으로합니다. 그리워 :(

Wolfram Language (Mathematica) , 73 67 바이트

위의 행에서 요소를 세십시오. Min[j+k,#2]~Sum~{k,i-1}

현재 행과 그 아래에있는 요소를 세십시오. Max[j-k+i-1,0]~Sum~{k,i,#}

테이블에 넣고 1을 추가하십시오.

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

업데이트 : 매트릭스에서 정상적으로 지정된 위치보다 먼저 모든 위치를 계산하는 두 가지 방법에 대해 하나의 합계로 더 짧은 방법이 있다는 것을 깨달았습니다.

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

온라인으로 사용해보십시오!

온라인으로 사용해보십시오!

APL (Dyalog Unicode) , 14 12 바이트

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

온라인으로 사용해보십시오!

그의 영리한 사용법으로 인해 ngn 에게 감사합니다 ↑⍳.

Dennis의 5 바이트 젤리 솔루션을 기반으로합니다.

05AB1E , 23 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 164 바이트

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

온라인으로 사용해보십시오!

이것은 확실히 가장 짧은 해결책은 아니지만 재미있는 것이라고 생각했습니다.

파이썬 2 , 93 바이트

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

온라인으로 사용해보십시오!

반 골프 버전 :

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 바이트

거의 우아하지 않지만 작업을 완료합니다. Japt에서 2D 데이터 작업은 까다 롭습니다.

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

-Q결과를 더 쉽게 시각화하기 위해 TIO에 플래그를 추가 했지만 솔루션에는 영향을 미치지 않습니다. Oliver
덕분에 1 바이트를 버립니다 .

온라인으로 사용해보십시오!

자바 스크립트 (Node.js) , 103 바이트

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

온라인으로 사용해보십시오!

TI 기본, 76 바이트

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]

사용자 입력을 요구하고 행렬을 Ans 하고 인쇄합니다.

TI-Basic은 토큰 화 된 언어입니다 . 여기에 사용 된 모든 토큰은 1 바이트입니다.[A] 이며 2 바이트 입니다.

참고 : TI-Basic (적어도 TI-84 Plus CE)은 99x99까지의 행렬 만 지원하므로이 프로그램도 지원합니다.

설명:

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

펄 6 , 61 59 바이트

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

온라인으로 사용해보십시오!

Dennis 'Jelly 솔루션의 또 다른 포트.

자바 (JDK 10) , 142131 바이트

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

온라인으로 사용해보십시오!

설명:

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
}

tio에서 코드를 실행하는 방법을 몰랐기 때문에 Kevin Cruijssen 에게 감사드립니다 . 머리글 및 바닥 글과 같은 일부 코드는 그에게서 도난당했습니다. -> 그의 대답

PHP, 115 바이트

꽤 게으른 접근법; 아마도 가장 짧은 것은 아닐 것입니다.

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

익명 함수, 너비와 높이를 매개 변수로 사용하고 2D 행렬을 반환합니다.

온라인으로 사용해보십시오

자바 스크립트 (Node.js를) , 108 (105) 101 100 바이트

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

온라인으로 사용해보십시오!

첨부 , 45 바이트

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

온라인으로 사용해보십시오!

매개 변수가 전환되는 익명 람다 ~프로그램 앞에 추가 하여 +1 바이트로 고정시킬 수 있습니다 . 테스트 스위트는 이미이를 수행합니다.

설명

이 방법은 J 답변 및 Jelly 답변 과 비슷합니다 .

첫 번째 아이디어는 값 테이블을 생성하는 것입니다.

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

두 입력 매개 변수의 범위를 사용하여 추가 테이블을 생성합니다. input의 [5, 3]경우 다음을 제공합니다.

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

그런 다음, 이것을 다음과 같이 평평하게합니다 Flat!:

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

J 응답의 접근 방식을 사용하여, 우리가 할 수있는 등급입니다 (정렬 된 값의 리턴 인덱스) 배열 두 번과 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]

그런 다음 젤리 답변에서와 같이 값을 올바르게 잘라야합니다. 이를 위해 모든 _요소를 잘라낼 수 있습니다 .

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

그런 다음 Attache의 0 인덱싱을 다음과 같이 보정하면됩니다 +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

따라서 결과가 나타납니다.

파이썬 3 , 259 바이트

그래서 나는 이것을 이상한 방식으로했다. 배열이 형성되는 방식에 두 가지 패턴이 있음을 알았습니다.

첫번째 는 상단 행 패턴이 1-> h에서 증가하는 각 항 사이의 차이를 갖는 방법입니다. 여기서 h는 높이이고 l은 길이입니다. 그 패턴을 기반으로 상단 행을 구성합니다.

dim (3,4)의 행렬은 다음 max RoC = 3과 같습니다.

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

대신에 max RoC = 3우리 에게 dim (3,9)을 주면

`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

두 번째 패턴은 행이 서로 어떻게 변경되는지입니다. 우리가 행렬을 고려하면 :

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

아래 행에서 각 행을 빼십시오 (추가 행 무시).

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

이 행렬을 보면이 행렬이 2 3 4 5 5 4 3 2각 행에 의해이 패턴의 5 개 항이 각 행에 대해 1 씩 이동 된 시퀀스임을 알 수 있습니다 . 시각적은 아래를 참조하십시오.

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

따라서 최종 행렬을 얻기 위해 첫 번째 행을 만들고이 패턴에 필요한 5 개의 항이 추가 된 행을 출력했습니다.

이 패턴은 항상 최대 값이 나타나는 횟수와 횟수가 어디에서 시작 2-> max value하고 끝나는 특성을 갖습니다 .max value -> 2max value = min(h+1, l)appearances of max = h + l -2*c -2c = min(h+1, l) - 2

전체적으로 새 행을 만드는 방법은 다음과 같습니다.

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

아래 관련 코드. 그것은 짧지 않았지만 여전히 방법을 좋아합니다.

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)

온라인으로 사용해보십시오!

apt, 20 바이트

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

시도 해봐