행렬이 주어지면 왼쪽 상단 요소가 맨 위에 있고 반대 대각선이 중앙 행이고 오른쪽 하단 요소가 맨 아래에있는 행렬의 표현을 출력하십시오.

예를 들어 다음 매트릭스를 고려하십시오.

1 2 3
4 5 6
7 8 9

이 매트릭스의 다이아몬드 버전은 다음과 같습니다.

  1
 4 2
7 5 3
 8 6
  9

입력 및 출력

입력 매트릭스는 목록 (또는 선택한 언어와 유사한 것)의 목록으로 제공됩니다. 결과는 목록의 목록이어야한다.

행렬에는 양의 정수만 포함됩니다.

입력 행렬은 반드시 정사각형 일 필요는 없습니다.

입력 행렬은 1x1 이상입니다.

테스트 사례

Input:  [[1]]
Output: [[1]]

Input:  [[1,2],[3,4]]
Output: [[1],[3,2],[4]]

Input:  [[1,2,3],[4,5,6]]
Output: [[1],[4,2],[5,3],[6]]

Input:  [[11,2,5],[3,99,3],[4,8,15],[16,23,42]]
Output: [[11],[3,2],[4,99,5],[16,8,3],[23,15],[42]]

채점

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

J, 7 바이트

<@|./.

이것은 이름이없는 모나 딕 동사로 행렬을 가져 와서 반 대각선 목록을 반환합니다.

   input =. i.3 4
   input
0 1  2  3
4 5  6  7
8 9 10 11

   <@|./. input
┌─┬───┬─────┬─────┬────┬──┐
│0│4 1│8 5 2│9 6 3│10 7│11│
└─┴───┴─────┴─────┴────┴──┘

여기에서 테스트하십시오.

설명

• /.각 대각에 기능을 적용하는 J의 내장 기능입니다. 불행히도, 이러한 반 대각선은 여기서 원하는 것과 반대 순서로 제공됩니다.
• 에서 <@|., 우리는 먼저 |.대각선을 반전시키는 것을 적용한 다음 <그것을 박스에 넣습니다 (정상 배열은 항상 직사각형이므로, 반대 대각선은 0으로 채워질 것이므로 J에서 거친 배열을 반환하는 유일한 방법입니다).

파이썬, 91 바이트

e=enumerate
lambda M:[[r[n-i]for i,r in e(M)if-1<n-i<len(r)][::-1]for n,_ in e(M[1:]+M[0])]

Ideone에서 테스트하십시오 .

Python + NumPy, 69 바이트

import numpy
lambda M:map(M[::-1].diagonal,range(1-len(M),len(M[0])))

2D NumPy 배열을 입력으로 예상하고 NumPy 배열 목록을 반환합니다. Ideone에서 테스트하십시오 .

젤리, 7 바이트

ṚŒDṙZL$

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

설명

Ṛ         Reverse the matrix vertically.
 ŒD       Get its diagonals. However these start from 
          the main diagonal, not the corners.
    ZL$   Get the width of the input matrix.
   ṙ      Rotate the list of diagonals left by that many 
          places to obtain the correct order.

매스 매 티카, 58 56 바이트

a=Length;Reverse@#~Diagonal~b~Table~{b,1-a@#,a@#&@@#-1}&

익명 함수는 중첩 배열을 사용합니다.

CJam, 17 바이트

{eeSf.*::+W%zSf-}

명명되지 않은 블록 (함수)은 스택의 행렬을 예상하여 반 대각선으로 대체합니다.

여기에서 테스트하십시오.

이것은 (Sp3000에서 찾은) 동일한 바이트 수에서 작동합니다.

{_,,Sf*\.+W%zSf-}

설명

이것은 예제와 함께 가장 잘 설명됩니다. 입력을 고려하십시오.

[[0  1  2  3]
 [4  5  6  7]
 [8  9 10 11]]

ee    e# Enumerate matrix, turning each row [x ... z] into [i [x ... z]] where
      e# i is the vertical index from the top.

[[0 [0  1  2  3]]
 [1 [4  5  6  7]]
 [2 [8  9 10 11]]]

Sf.*  e# Replace each i with a string of i spaces.

[[""   [0  1  2  3]]
 [" "  [4  5  6  7]]
 ["  " [8  9 10 11]]]

::+   e# Prepend these strings to the rows.

[[0  1  2  3]
 ['  4  5  6  7]
 ['  '  8  9 10 11]]   e# Note that each '  corresponds to a space character.

W%    e# Reverse the rows.

[['  '  8  9 10 11]
 ['  4  5  6  7]
 [0  1  2  3]]

z     e# Zip/transpose.

[[ '  '  0]
 [ '  4  1]
 [ 8  5  2]
 [ 9  6  3]
 [10  7]
 [11]]

Sf-   e# Remove spaces from each row.

[[ 0]
 [ 4  1]
 [ 8  5  2]
 [ 9  6  3]
 [10  7]
 [11]]

파이썬 2, 88 87 바이트

lambda L:[filter(None,x)[::-1]for x in map(None,[],*[i*[0]+r for i,r in enumerate(L)])]

앞에 0을 넣고 압축 한 다음 잘못된 요소를 제거하십시오. 튜플 목록을 반환합니다. 이 용도 map(None,...)수행 zip_longest (반점과 누락 패딩 None)와 filter(None,...)falsy 요소를 제거 하였다.

짜증나게, 우리 는 1x1 행렬이 아닌 리턴 이기 때문에 튜플 목록이 반환되도록 여분의 []행 을 추가해야합니다 . 여분의 행은 그래도 제거됩니다 .mapmap(None,*[[1]])[1][(1,)]filter

(-1 바이트에 대해 @Dennis에게 감사드립니다)

루비, 68 66 바이트

익명의 기능.

->l{i=-1;k=[];l.map{|r|i-=j=-1;r.map{|e|k[i+j+=1]=[e,*k[i+j]]}};k}

• splat 연산자의 작동 방식으로 인해 배열 추가를 생략하여 2 바이트를 절약 할 수있었습니다.

Mathematica, 60 바이트

#&@@@#&/@GatherBy[Join@@MapIndexed[List,#,{2}],Tr@*Last]&

여기서 Mathematica는 접미사 \[Transpose]연산자 로 읽는 유니 코드 문자입니다 .

이것은 다른 Mathematica 솔루션보다 약간 길지만 Diagonals내장 기능을 사용하지 않고 완전히 다른 접근법을 사용하기 때문에 게시 할 것이라고 생각했습니다 .

설명

MapIndexed[List,#,{2}]

이것은 먼저 매트릭스를 바꿉니다 (매트릭스가 평평한 경우 반 대각선이 올바른 순서로 나타남). 그런 다음 List인덱스와 함께 행렬의 셀을 매핑 하여 각 행렬 요소 i를 행렬에서 요소의 {i, {x, y}}위치 x와 y좌표로 변환합니다.

Join@@...

이렇게하면 가장 바깥 쪽 차원이 평평 해 지므로 이제 열-주요 순서로 행렬 요소 (좌표가있는)의 평평한 목록이 생깁니다.

GatherBy[..., Tr@*Last]

좌표의 합으로 해당 요소를 그룹화합니다. 반 대각선은 상수의 선 x+y이므로 원하는 그룹화를 정확하게 수행합니다. 각 그룹 내 순서가 유지됩니다. 이제 좌표를 다시 제거하면됩니다. 이것은 다소 비밀을 통해 수행됩니다.

#&@@@#&/@...

이것은 #&@@@#&그룹의 각 요소에 적용되는 각 그룹에 함수 를 매핑하며 단순히 첫 번째 인수, 즉 원래 행렬 요소입니다.#&#

옥타브, 77 바이트

약간의 accumarray기능 남용으로 :

@(M)char(accumarray(((1:size(M,1))+(0:size(M,2)-1)')(:),M(:),[],@(x){num2str(x')}))

이것은 익명 함수를 정의합니다. 그것을 사용하려면, varible에 할당하거나 사용하십시오ans .

입력은 :행 구분 기호 가있는 행렬입니다 . 출력은 각 행에 대한 배열을 포함하는 셀형 배열입니다 (옥타브는 들쭉날쭉 한 배열에 해당). 이것은 셀 배열의 인덱스와 각 셀의 내용을 보여주는 Octave로 표시됩니다. 여기서 사용해보십시오 .

공백과 줄 바꾸기로 구분하여 결과를 표시하려면 : 83 바이트

@(M)char(accumarray(((1:size(M,1))+(0:size(M,2)-1)')(:),M(:),[],@(x){num2str(x')}))

당신은 또한 수 있습니다 여기를보십시오 .

자바 스크립트 (Firefox), 86 75 바이트

a=>a.concat(a[0]).slice(1).map((_,i)=>[for(v of a)if(n=v[i--])n].reverse())

@Neil 덕분에 11 바이트를 절약했습니다!

Firefox 30 이상에서 작동합니다. 배열의 배열을 취합니다.

옥타브, 63 62 바이트

@DonMue ... @LuisMendo 덕분에 1 바이트를 제거 했습니다!

@(a)cellfun(@(x)x(x>0)',num2cell(spdiags(flipud(a)),1),'un',0)

나는 지루한 길을 갔고 반 대각선을 녹였습니다.

ideone에서 샘플 실행 .

하스켈, 83 82 바이트

r=zip[0..]
\o->fst$span(any(>0))[reverse[e|(x,t)<-r o,(v,e)<-r t,x+v==a]|a<-[0..]]

니미는 바이트를 저장했습니다. 감사!

Python, 128 바이트 (numpy)

(lambda A: (lambda A,S:[[A[U][I-U] for U in range(min(S[1]-1,I),max(I-S[0]+1,0)-1,-1)] for I in range(S[1]+S[0]-1)])(A,A.shape))

Pyth , 41 17 바이트

tm_<dx+dYk.T+LaYk

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

다른 문제에 대한 @Doorknob의 솔루션에서 영감을 얻었습니다. .

작동 방식 :

tm_<dx+dYk.T+LaYk
            +L      prepend to each subarray...
              aYk   (Y += ''). Y is initialized to [],
                    so this prepends [''] to the first
                    subarray, ['', ''] to the second, etc.
                    ['' 1  2  3
                     '' '' 4  5  6
                     '' '' '' 7  8  9
                     '' '' '' '' 10 11 12
                     '' '' '' '' '' 13 14 15]
          .T        transpose, giving us
                    ['' '' '' '' ''
                     1  '' '' '' ''
                     2  4  '' '' ''
                     3  5  7  '' ''
                     6  8  10 ''
                     9  11 13
                     12 14
                     15]
 m_<dx+dYk          removes all empty strings in the
                    subarrays while reversing each one
t                   remove the first subarray

이전 시도 :

JlQKlhQm_m@@Qk-dk}h.MZ,0-dtKh.mb,tJdUt+JK

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

작동 방식 :

JlQKlhQm_m@@Qk-dk}h.MZ,0-dtKh.mb,tJdUt+JK    input array stored as Q
JlQ                                          J = len(Q)
   KlhQ                                      K = len(Q[0])
       m                            Ut+JK    list for d from 0 to J+K-1:
        _m       }AAAAAAAAAABBBBBBBB             reversed list for k from A to B, where:
                  h.MZ,0-dtK                       A = max(0, d-(K-1))
                       0-dtK                               0  d-(K-1)
                            h.mb,tJd               B = min(J-1, d)
                                 tJd                       J-1  d
          @@Qk-dk                                    Q[k][d-k]

그루비, 77 73 75

{i->o=[].withDefault{[]};a=0;i.each{b=0;it.each{o[a+b++].add(0,it)};a++};o}

배열 배열을 입력으로 받아서 배열 배열을 반환합니다.

시도 해봐

편집 : 답변을 추가 한 후 점수를 75까지 올리는 것을 잊었습니다.