중첩되지 않은 배열을 입력으로 사용하십시오. 다음 방법을 사용하여 행렬로 변환하십시오.

내 배열이 [1, 2, 3, 4, 5]

먼저, 그 배열을 5 번 반복합니다 : (길이)

[[1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5]]

그런 다음 대각선을 따라 읽습니다.

[[1],
 [2, 1],
 [3, 2, 1],
 [4, 3, 2, 1],
 [5, 4, 3, 2, 1],
 [5, 4, 3, 2],
 [5, 4, 3],
 [5, 4],
 [5]]

이 배열을 평평하게하여 다섯 조각 (길이)으로 나누었습니다.

[[1, 2, 1, 3, 2],
 [1, 4, 3, 2, 1],
 [5, 4, 3, 2, 1],
 [5, 4, 3, 2, 5],
 [4, 3, 5, 4, 5]]

이것은 코드 골프입니다. 가장 적은 바이트가 이깁니다.

05AB1E, 13 바이트

.p¹.sR¦«í˜¹gä

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

설명:

                # Implicit input
 .p             # Get prefixes
   ¹            # Get first input
    .s          # Get suffixes
      R         # Reverse
       ¦        # Remove first element
        «       # Concatenate
         í      # Reverse every one
          ˜     # Flatten
           ¹gä  # Split into pieces of the length
                # Implicit print

젤리 , 11 바이트

WẋLŒDUṙLFsL

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

설명

               Input: array z
WẋL            length(z) copies of z
   ŒD          Diagonals (starting with main diagonal)
     U         Reverse each
      ṙL       Rotate left length(z) places
               (now the top-left diagonal is in front)
        F      Flatten
         sL    Split into chunks of size length(z)

파이썬 2, 105 96 바이트

Flp.Tkc 덕분에 -1 및 -4 및 -4 바이트

a=input()
n=len(a)
L,M=[],[]
for i in range(n):L+=a[i::-1];M+=a[:i:-1]
print zip(*[iter(L+M)]*n)

for 루프는 설명과 같은 항목을 추가하며 실제 마법은 여기 에서 온 zip으로 발생 합니다.

자바 스크립트 (ES6) 100 101 105

a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

덜 골프

a => {
  u = 0
  for(r=[], i=l=a.length; i+l>0; i--)
    for(j=l; j--; )
    {
      v = a[j-i]
      if (v) 
      {
        u %= l
        if (u==0) r.push(s=[])
        s[u++] = v
      }
    }
  return r
}

테스트

F=
a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

function update() {
  var a=I.value.match(/\d+/g)
  if (a) {
    var r=F(a)
    O.textContent = r.join`\n`
  }
}

update()

<input id=I value='1 2 3 4 5' oninput='update()'>
<pre id=O></pre>

MATL , 17 바이트

!Gg*tRwZRhPXzGne!

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

작동 원리

다음 설명은 입력 [1 2 3 4 5]을 예로 사용합니다. 중간 결과를 시각화하려면 %코드에서 명령문 뒤에 (코멘트 기호)를 삽입 하십시오.

참고 ;행렬의 행 세퍼레이터이다. 따라서 [1 2]행 벡터이고, [1; 2]열 벡터이고, [1 0; 0 1]2 × 2 행렬이다.

!     % Implicitly input a row vector. Transpose. Gives a column vector
      % STACK: [1; 2; 3; 4; 5]
Gg    % Push input with all (nonzero) values replaced by ones
      % STACK: [1; 2; 3; 4; 5], [1 1 1 1 1]
*     % Multiply, with broadcast. Gives a square matrix
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5]
tR    % Duplicate. Upper triangular part
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5],
               [1 1 1 1 1
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5]
wZR   % Swap. Lower triangular part, below main diagonal 
      % STACK: [1 1 1 1 1;
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5],
               [0 0 0 0 0;
                2 0 0 0 0;
                3 3 0 0 0;
                4 4 4 0 0;
                5 5 5 5 0]
h     % Concatenate horizontally
      % STACK: [1 1 1 1 1 0 0 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 0 0 5 5 5 5 5 0]
P     % Flip vertically
      % STACK: [0 0 0 0 5 5 5 5 5 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                1 1 1 1 1 0 0 0 0 0]
Xz    % Column vector of nonzeros, taken in column-major order
      % STACK: [1;2;1;3;2;1;4;3;2;1;5;4;3;2;1;5;4;3;2;5;4;3;5;4;5]
Gne   % Reshape into a matrix with as many rows as input size
      % STACK: [1 1 5 5 4;
                2 4 4 4 3;
                1 3 3 3 5;
                3 2 2 2 4;
                2 1 1 5 5]
 !    % Transpose. Implicitly display
      % STACK: [1 2 1 3 2;
                1 4 3 2 1;
                5 4 3 2 1;
                5 4 3 2 5;
                4 3 5 4 5]

자바 스크립트 (ES6), 116 바이트

a=>a.map(_=>b.splice(0,a.length),b=[].concat(...a.map((_,i)=>a.slice(~i)),...a.map((_,i)=>a.slice(0,~i))).reverse())

글쎄, 시작이야 ...

R, 84 바이트

t(matrix(unlist(split(m<-t(matrix(rev(x<-scan()),l<-sum(1|x),l)),row(m)-col(m))),l))

stdin에서 입력을 읽고 R 행렬을 출력 / 반환합니다.

reversed_x <- rev(x<-scan())                # Read input from stdin and reverse
m <- t(matrix(reversed_x,l<-sum(1|x),l))    # Repeat and fit into matrix
diag_list <- split(m,row(m)-col(m))         # Split into ragged list of diagonals
t(matrix(unlist(diag_list),l))              # Flatten and transform back to matrix

설명

이 답변에서 가장 흥미로운 측면은 대각선을 검색하는 방법입니다. 일반적으로 split객체가 분리되는 요인이 포함 된 객체가 제공되는 경우이 기능 을 사용 하여 객체를 분할 할 수 있습니다. 우리가 사용 요인 생성하기 col와 row각각 열 및 행 인덱스를 포함하는 행렬을 반환한다. 차이점을 살펴보면 row(m)-col(m)다음과 같은 행렬이 생깁니다.

     [,1] [,2] [,3] [,4] [,5]
[1,]    0   -1   -2   -3   -4
[2,]    1    0   -1   -2   -3
[3,]    2    1    0   -1   -2
[4,]    3    2    1    0   -1
[5,]    4    3    2    1    0

각 대각선은 고유하게 식별됩니다. 이제이 행렬을 기준으로 분할하고 다음을 적용하여 비정형 목록으로 변환 할 수 있습니다 split.

$`-4`
[1] 1
$`-3`
[1] 2 1 
$`-2`
[1] 3 2 1
$`-1`
[1] 4 3 2 1
$`0`
[1] 5 4 3 2 1
$`1`
[1] 5 4 3 2
$`2`
[1] 5 4 3
$`3`
[1] 5 4
$`4`
[1] 5

(각 벡터의 이름이 위 행렬의 대각선 값과 어떻게 일치하는지 유의하십시오).

마지막 단계는 평평하게하고 다음 형식의 행렬로 바꾸는 것입니다.

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    2    1    3    2
[2,]    1    4    3    2    1
[3,]    5    4    3    2    1
[4,]    5    4    3    2    5
[5,]    4    3    5    4    5

매스 매 티카 93 바이트

Partition[Flatten[Table[If[i>n,#[[n;;(i-n+1);;-1]],#[[i;;1;;-1]]],{i,1,2(n=Length@#)-1}]],n]&

다음은 일반적으로이 코드를 작성하는 방법입니다 (109 바이트).

Partition[Reverse@Flatten[Table[Reverse@Diagonal[ConstantArray[Reverse@#,n],k],{k,-(n=Length@#)+1,n-1}]],n]&

이 매트릭스 플롯은 순차적으로 증가하는 입력 벡터로 인해 구조에서 좋은 아이디어를 제공합니다.

다음은 임의의 입력 벡터가 포함 된 행렬 그림입니다. 분명히 일부 구조가 여전히 존재합니다.

수학, 92 바이트

n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&;{Most@r[#~n~Rest],#~n~Most}~ArrayReshape~{l,l}&

이름이없는 함수는 인수로 목록을 가져옵니다. 그러한 기능에 다른 구조가있을 수 있지만,이 구조를 꽤 좋게 골랐습니다 ....

첫 번째 부분 n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&은 n두 가지 인수 의 함수 를 정의합니다 . 첫 번째 부분 은 length의 목록이고 두 번째 부분 은 목록에 l적용 할 함수입니다. n해당 함수 l-1시간을 역 인수 목록에 적용하여 모든 결과를 출력 목록에 저장합니다. (정의 r하고 l길을 따라 골프입니다.)

n함수 Rest는 목록의 첫 번째 요소를 Most삭제하고 함수 는 마지막 요소를 삭제하면 원래 목록에서 두 번 호출됩니다 . 이렇게하면 원하는 하위 목록이 모두 만들어 지지만 전체 목록은 두 번 (따라서 여분의 Most) 존재하며 전반은 반대 순서로 (따라서 r[...]) 있습니다. 마지막으로 ~ArrayReshape~{l,l}현재 목록 구조를 잊어 버리고 lx l배열로 만듭니다.

Mathematica, 85 바이트

말 그대로 제안 된 단계를 수행하십시오.

(l=Length@#;Partition[Flatten@Table[Reverse@Diagonal[Table[#,l],i],{i,-l+1,l-1}],l])&

내 직감은 Part이 짧은 작업을 수행 하는 데 영리한 방법이 있어야한다고 말 했지만 내가 한 모든 시도는 85 바이트보다 길었습니다.

루비 (110 바이트)

n=a.size
b=[*(0...n)]
b.product(b).group_by{|i,j|i+j}.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}.each_slice(n).to_a
  #=> [[1, 2, 1, 3, 2],
  #    [1, 4, 3, 2, 1],
  #    [5, 4, 3, 2, 1],
  #    [5, 4, 3, 2, 5],
  #    [4, 3, 5, 4, 5]]

그만큼 sort작업이 필요하지 않을 수도 있지만, Enumerable에서 번호를 GROUP_BY에 대한 문서는 해시 값의 값의 순서를 (배열되는) 보증하지 않습니다,하지만 루비의 최신 버전은 주문 하나가 기대 제공하고있는 경우 순서는 내가 필요 sort했다 내 코드에서 제거되었습니다.

단계는 다음과 같습니다.

n=a.size 
  #=> 5 
b=[*(0...n)]
  #=> [0, 1, 2, 3, 4] 
c = b.product(b)
  #=> [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 0], [1, 1], [1, 2], [1, 3],
  #    [1, 4], [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], [3, 0], [3, 1], [3, 2],
  #    [3, 3], [3, 4], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4]] 
d=c.group_by{|i,j|i+j}
  #=> {0=>[[0, 0]],
  #    1=>[[0, 1], [1, 0]],
  #    2=>[[0, 2], [1, 1], [2, 0]],
  #    3=>[[0, 3], [1, 2], [2, 1], [3, 0]],
  #    4=>[[0, 4], [1, 3], [2, 2], [3, 1], [4, 0]],
  #    5=>[[1, 4], [2, 3], [3, 2], [4, 1]],
  #    6=>[[2, 4], [3, 3], [4, 2]],
  #    7=>[[3, 4], [4, 3]],
  #    8=>[[4, 4]]} 
e=d.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}
  #=> [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 5, 4, 3, 5, 4, 5] 
f=e.each_slice(n)
  #=> #<Enumerator: [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2,
  #                  5, 4, 3, 5, 4, 5]:each_slice(5)>

마지막으로 f.to_a이전에 표시된 배열을 반환합니다.