소개

정수 목록 (또는 실제로는 객체이지만 단순성을 위해 정수를 고수합시다) 목록이 있다고 가정하십시오. 목록의 길이는 다를 수 있으며 일부는 비어있을 수 있습니다. 목록을 표 형식으로 작성해 봅시다.

[[ 1,   2,   3,   4,   5],
 [ 6,   7],
 [ 8,   9,  10,  11],
 [],
 [12,  13,  14],
 [15,  16,  17,  18]]

이 표는 숫자를 포함, 5 수직 열이 1, 6, 8, 12, 15, 2, 7, 9, 13, 16, 3, 10, 14, 17, 4, 11, 18,와 5. 우리는 각 열을 반대하는 경우, 우리는 목록을 얻을 수 15, 12, 8, 6, 1, 16, 13, 9, 7, 2, 17, 14, 10, 3, 18, 11, 4,와 5. 행의 길이를 이전과 동일하게 유지하면서 해당 숫자를 테이블의 열에 다시 연결합시다.

[[15,  16,  17,  18,   5],
 [12,  13],
 [ 8,   9,  14,  11],
 [],
 [ 6,   7,  10],
 [ 1,   2,   3,   4]]

당신의 임무는이 작업을 구현하는 것입니다.

입력과 출력

입력은 행을 나타내는 음이 아닌 정수 목록의 목록입니다. 행의 길이는 다를 수 있으며 일부는 비어있을 수 있습니다. 항상 하나 이상의 행이 있습니다. 결과는 위에서 설명한대로 각 열을 반전 한 결과입니다. 입력과 출력은 합리적인 형식 일 수 있습니다.

각 언어에서 가장 낮은 바이트 수가 이깁니다. 표준 코드 골프 규칙이 적용됩니다.

테스트 사례

[[]] -> [[]]
[[],[]] -> [[],[]]
[[8,5,1]] -> [[8,5,1]]
[[1,200],[0,3]] -> [[0,3],[1,200]]
[[],[3,9],[1],[]] -> [[],[1,9],[3],[]]
[[],[5,8,7],[0,6,5,7,1]] -> [[],[0,6,5],[5,8,7,7,1]]
[[1,8,5],[7,5,4],[],[1]] -> [[1,5,4],[7,8,5],[],[1]]
[[],[],[2],[],[31],[],[5],[],[],[],[7]] -> [[],[],[7],[],[5],[],[31],[],[],[],[2]]
[[1,10,100,1000],[2,20,200],[3,30],[4],[5,50,500],[6,60],[7]] -> [[7,60,500,1000],[6,50,200],[5,30],[4],[3,20,100],[2,10],[1]]
[[8,4],[3,0,4,8,1],[8],[0,8],[9,7,1,6],[3,8,1,9,5]] -> [[3,8],[9,7,1,9,5],[0],[8,8],[3,0,1,6],[8,4,4,8,1]]
[[3,9,3],[5],[1],[3,5],[9,0,6,2],[1,3],[4,9,2],[6,6,7,8,7]] -> [[6,6,7],[4],[1],[9,9],[3,3,2,8],[1,0],[5,5,6],[3,9,3,2,7]]
[[8,5,6],[3,5,2,4,9],[4,3,8,3,7],[6,1,1],[1,8,9,9],[9,1,2],[8,7]] -> [[8,7,2],[9,1,9,9,7],[1,8,1,3,9],[6,1,8],[4,3,2,4],[3,5,6],[8,5]]
[[2,4],[1,4],[0,8,7,3],[4,9,2,5],[2,8,0],[0,8,3],[7,3,1],[],[3,3,7,8]] -> [[3,3],[7,3],[0,8,7,8],[2,8,1,5],[4,9,3],[0,8,0],[1,4,2],[],[2,4,7,3]]

젤리 , 16 바이트

ḟṚṁṣj
z-ç€-ZFḟ-ṁ

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

z-ç€-ZFḟ-ṁ  Main link. Argument: M (matrix / 2D array)

z-          Zip the rows of M, using -1 as filler.
  ç€-       Map the helper link over the result, with right argument -1.
     Z      Zip the rows of the result.
      F     Flatten the resulting matrix.
       ḟ-   Filterfalse -1; remove all occurrences of -1.
         ṁ  Mold; shape the result like M.


ḟṚṁṣj       Helper link.
            Left argument: A (row / 1D array). Right argument: -1

ḟ           Filterfalse; remove all occurrences of -1.
 Ṛ          Reverse the resulting vector.
   ṣ        Split A at occurrences of -1.
  ṁ         Mold; shape the vector to the left like the 2D array to the right.
    j       Join the resulting 2D array, separating by -1.

Japt , 15 13 바이트

@Shaggy 덕분에 2 바이트를 절약했습니다.

y@=XfÊX£o
®fÄ

온라인으로 테스트하십시오!

두 번째 줄은 4 바이트를 절약하여 널값으로 행을 채울 수있는 경우 제거 할 수 있습니다.

설명

 y@  =XfÊ X£  o      Implicit: U = input array
UyX{U=Xfl Xm{Uo}}    (Ungolfed)
UyX{            }    Map each column X in the input by this function:
    U=Xfl              Set U to X filtered to only items whose factorial is truthy;
                       this just gets rid of the empty slots in the column.
          Xm{  }       Map each item in X to
             Uo          the last item in U, popping this item from the list.
                       Due to the way .map works in JS, this is only called on real items
                       and not empty slots, so this preserves empty slots.
                     Newline: set U to the resulting column-reversed array
 ®   fÄ              Due to the way y works, there will now be `undefined` in some rows.
UmZ{Zf+1}            (Ungolfed)
 mZ{    }            Map each row Z in U to
    Zf+1               Z filtered to only items where the item + 1 is truthy.
                     undefined + 1 is NaN, which is falsy, and thus eliminated.
                     Implicit: output result of last expression

APL (Dyalog Unicode) , 20 19 16 바이트 ^SBCS

ngn 덕분에 -4입니다.

전체 프로그램. STDIN에서 입력하라는 메시지를 표시합니다.

⍟0~¨⍨↓⍉⌽@×⍤1⍉↑*⎕

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

연습을 통한 설명

⎕ 평가 입력을위한 프롬프트
 [[1,8,5],[7,5,4],[],[1]]

*e 를 그것의 거듭 제곱으로  올린다 ( e ⁿ 은 0이 ^없음 을 보장한다)
 [[2.7,2981,148.4],[1096.6,148.4,54.6],[],[2.7]]

↑ 목록을 단일 행렬로 혼합하고 0으로 채 웁니다.
 ┌ ┐
 │2.7E0 3.0E3 1.5E2│
 │1.1E3 1.5E2 5.5E1│
 │0.0E0 0.0E0 0.0E0│
 │2.7E0 0.0E0 0.0E0│
 └ ┘

⍉ 바꾸어 놓다
 ┌ ┐
 │2.7E0 1.1E3 0.0E0 2.7E0│
 │3.0E3 1.5E2 0.0E0 0.0E0│
 │1.5E2 5.5E1 0.0E0 0.0E0│
 └ ┘

⌽@×⍤1 각 행의 양의 요소를 뒤집습니다
 ┌ ┐
 │2.7E0 1.1E3 0.0E0 2.7E0│
 │1.5E2 3.0E3 0.0E0 0.0E0│
 │5.5E1 1.5E2 0.0E0 0.0E0│
 └ ┘

⍉ 바꾸어 놓다
 ┌ ┐
 │2.7E0 1.5E2 5.5E1│
 │1.1E3 3.0E3 1.5E2│
 │0.0E0 0.0E0 0.0E0│
 │2.7E0 0.0E0 0.0E0│
 └ ┘

↓ 행렬을 목록의 목록으로 나누십시오
 [[2.7,148.4,54.6],[1096.6,2981,148.4],[0,0,0],[2.7,0,0]]

0~¨⍨ 각 목록에서 0을 제거
 [[2.7,148.4,54.6],[1096.6,2981,148.4],[],[2.7]]

⍟ 자연 로그
 [[1,5,4],[7,8,5],[],[1]]

K4 , 36 바이트

해결책:

+{x[w]:|x w:&~^x;x}'x'[::;]@!|/#:'x:

예 :

q)k)+{x[w]:|x w:&~^x;x}'x'[::;]@!|/#:'x:(1 2 3 4 5;6 7;8 9 10 11;0#0N;12 13 14;15 16 17 18)
15 16 17 18 5
12 13        
8  9  14 11  

6  7  10     
1  2  3  4

q)k)+{x[w]:|x w:&~^x;x}'x'[::;]@!|/#:'x:(0#0N;5 8 7; 0 6 5 7 1)

0 6 5    
5 8 7 7 1

설명:

이것은 고통스럽고, 여전히 인덱싱을 단순화하기 위해 노력하고 있습니다.

예를 들어 x[0]첫 번째 행을 반환하는 에서 인덱싱하는 대신을 사용하여 수행 할 수있는 첫 번째 열 을 가져 오려고합니다 x[;0].

그러나 변수를 전달 y로 x[;]하고 같은 취급을 x[y]하지 x[;y]따라서를 밀어 ::거기 : x[::;].

이것은리스트의리스트를 뒤집는 것과 동일하지만 플립은 모든리스트의 길이가 같아야합니다!

+{x[w]:|x w:&~^x;x}'x'[::;]@!|/#:'x: / the solution
                                  x: / save input as variable x
                               #:'   / count (#:) each (') 
                             |/      / take the max of these lengths
                            !        / til, range 0..max-1
                           @         / apply (index into)
                      [::;]          / :: is a kind of null, 
                    x'               / index into x at each of these    
 {              ; }'                 / two statement lambda on each (')
              ^x                     / null x (returns true if entry is null)
             ~                       / not, so flip true/false
            &                        / where, indexes where true
          w:                         / save as variable w  
        x                            / index into w at these indexes
       |                             / reverse
  x[w]:                              / store this back in variable x at indexes w
                 x                   / return x from function
+                                    / flip the result

하스켈 , 174 바이트

f x=map g.h.map(g.reverse>>=(!)).h$take(maximum$length<$>x).(++z).map pure<$>x
g=concat
h x|g x==[]=x|4>2=foldr(zipWith(:))z x
x!(c:d)|c==[]=c:x!d|a:b<-x=[a]:b!d
_!y=y
z=[]:z

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

언 골프 / 설명

아이디어는 모든 요소를 ​​포장하는 것입니다 [] 행을 []채우고 (음수로 채우는 것보다 짧게 나타납니다. 음수 입력도 좋습니다), 모든 행을 바꾸고 뒤집고 각 행을 평평하게하는 것이 좋습니다 :

map concat                                   -- flatten each row
  . transpose'                               -- transpose (*)
  . map (\row-> reverse (concat row) ! row)  -- reverse each row (see below)
  . transpose'                               -- tranpose (*)
  $ take (maximum $ length <$> x)            -- only keep up as many as longest row
      . (++ z)                               -- pad row with [],[],..
      . map (\e-> [e])                       -- wrap elements in []
 <$> x

^{*이 조옮김 함수 ( h)는 요소가없는 경우 단순히 목록을 반환합니다.}

역함수는 []요소 (예 : [[],[1],[],[3],[4]]-> [[],[4],[],[3],[1]]) 를 무시 해야하며, 두 개의 인수를 수신하면됩니다 [4,3,1].

x@(a:b) ! (c:d)
 | c == []   = c:x ! d    -- if current element is []: skip it
 | otherwise = [a]:b ! d  -- else: replace with new one (a) and continue
_ ! y = y                 -- base case (if no new elements are left): done

파이썬 (2) , 111 (105) 92 바이트

def f(l):x=map(lambda*n:[v for v in n if-1<v],*l);return[map(list.pop,x[:len(k)])for k in l]

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

자바 스크립트 (ES6), 79 76 바이트

(a,d=[],g=s=>a.map(b=>b.map((c,i)=>(d[i]=d[i]||[])[s](c))))=>g`push`&&g`pop`

편집 : @ETHproductions 덕분에 3 바이트가 절약되었습니다.

APL (Dyalog Unicode) , 27 바이트 ^SBCS

≢¨⍴¨∘↓∘⍉⍉∘↑{⍵\⌽⍵/⍺}⍤1∘⍉∘↑=⍨

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

클로저, 123 바이트

#(map(fn[i R](map(fn[j _](let[V(for[Q %](get Q j))F filter](nth(reverse(F + V))(count(F +(take i V))))))(range)R))(range)%)

(+ nil)예외를 던질 것으로 예상 했지만 다음과 같이 평가됩니다 nil.

이것은 패딩없이 작동합니다. 대신 현재 행만큼 적어도 이전 행 수를 계산합니다 R.