Giới thiệu

Giả sử bạn có một danh sách các danh sách số nguyên (hoặc bất kỳ đối tượng nào thực sự, nhưng hãy sử dụng các số nguyên để đơn giản). Các danh sách có thể có độ dài khác nhau, và một số trong số chúng có thể trống. Hãy viết các danh sách theo định dạng bảng:

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

Bảng này có 5 cột dọc, có chứa các con số 1, 6, 8, 12, 15, 2, 7, 9, 13, 16, 3, 10, 14, 17, 4, 11, 18, và 5. Nếu chúng ta đảo ngược mỗi cột, chúng tôi có được danh sách 15, 12, 8, 6, 1, 16, 13, 9, 7, 2, 17, 14, 10, 3, 18, 11, 4, và 5. Chúng ta hãy cắm các số đó trở lại vào các cột của bảng trong khi vẫn giữ độ dài của các hàng giống như trước:

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

Nhiệm vụ của bạn là thực hiện thao tác này.

Đầu vào và đầu ra

Đầu vào của bạn là một danh sách các danh sách các số nguyên không âm, đại diện cho các hàng. Các hàng có thể có độ dài khác nhau và một số trong số chúng có thể trống. Sẽ luôn có ít nhất một hàng. Đầu ra của bạn là kết quả của việc đảo ngược từng cột, như chi tiết ở trên. Đầu vào và đầu ra có thể ở bất kỳ định dạng hợp lý.

Số byte thấp nhất trong mỗi ngôn ngữ sẽ thắng. Luật golf tiêu chuẩn được áp dụng.

Các trường hợp thử nghiệm

[[]] -> [[]]
[[],[]] -> [[],[]]
[[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]]

Thạch , 16 byte

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

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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 byte

đã lưu 2 byte nhờ @Shaggy

y@=XfÊX£o
®fÄ

Kiểm tra nó trực tuyến!

Dòng thứ hai có thể được loại bỏ nếu chúng ta được phép đệm các hàng với giá trị null, tiết kiệm 4 byte.

Giải trình

 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 byte ^SBCS

-4 cảm ơn ngn.

Chương trình đầy đủ. Nhắc nhở cho đầu vào từ STDIN.

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

Hãy thử trực tuyến!

Giải thích với ví dụ đi qua

⎕ nhắc nhở đánh giá đầu vào
 [[1,8,5],[7,5,4],[],[1]]

* nâng e lên sức mạnh của điều đó ( e ⁿ đảm bảo rằng sẽ không có số không)
 [[2.7,2981,148.4],[1096.6,148.4,54.6],[],[2.7]]

↑ trộn các danh sách thành một ma trận đơn, đệm với các số không:
 ┌ ┐
 │2.7E0 3.0E3 1.5E2│
 │1.1E3 1.5E2 5.5E1│
 │0.0E0 0.0E0 0.0E0│
 │2.7E0 0.0E0 0.0E0│
 └ ┘

⍉ hoán vị
 ┌ ┐
 │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 đảo ngược các yếu tố tích cực của mỗi hàng
 ┌ ┐
 │2.7E0 1.1E3 0.0E0 2.7E0│
 │1.5E2 3.0E3 0.0E0 0.0E0│
 │5.5E1 1.5E2 0.0E0 0.0E0│
 └ ┘

⍉ hoán vị
 ┌ ┐
 │2.7E0 1.5E2 5.5E1│
 │1.1E3 3.0E3 1.5E2│
 │0.0E0 0.0E0 0.0E0│
 │2.7E0 0.0E0 0.0E0│
 └ ┘

↓ chia ma trận thành một danh sách các danh sách
 [[2.7,148.4,54.6],[1096.6,2981,148.4],[0,0,0],[2.7,0,0]]

0~¨⍨ xóa số không trong mỗi danh sách
 [[2.7,148.4,54.6],[1096.6,2981,148.4],[],[2.7]]

⍟ logarit tự nhiên
 [[1,5,4],[7,8,5],[],[1]]

K4 , 36 byte

Dung dịch:

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

Ví dụ:

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

Giải trình:

Điều này đã là một nỗi đau, và tôi vẫn đang làm việc để đơn giản hóa việc lập chỉ mục.

Thay vì lập chỉ mục tại, ví dụ, x[0]sẽ trả về hàng đầu tiên , chúng tôi muốn lấy cột đầu tiên , có thể được thực hiện bằng cách sử dụng x[;0].

Tuy nhiên, việc chuyển biến ythành x[;]xử lý nó như x[y]không làm cho nó bị x[;y]đẩy ::vào đó : x[::;].

Điều này tương đương với việc lật danh sách các danh sách, nhưng lật đòi hỏi tất cả các danh sách phải có độ dài bằng nhau!

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

Haskell , 174 byte

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

Hãy thử trực tuyến!

Ungolfed / Giải thích

Ý tưởng là bọc tất cả các phần tử vào []và đệm các hàng với [](hóa ra là ngắn hơn phần đệm với một số nguyên âm, điều này cho phép các đầu vào âm cũng tốt), sau đó hoán vị, đảo ngược tất cả các hàng và hoán đổi lại mỗi hàng :

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àm transpose này ( h) chỉ đơn giản trả về danh sách nếu không có phần tử nào cả.}

Hàm đảo ngược phải bỏ qua []các phần tử (ví dụ: [[],[1],[],[3],[4]]-> [[],[4],[],[3],[1]]), nó làm như vậy bằng cách nhận hai đối số: Đối số thứ nhất là các phần tử theo thứ tự ngược lại (ví dụ [4,3,1]:) và phần thứ hai là hàng ban đầu.

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

Python 2 , 111 105 92 byte

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]

Hãy thử trực tuyến!

JavaScript (ES6), 79 76 byte

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

Chỉnh sửa: Đã lưu 3 byte nhờ @ETHproductions.

APL (Dyalog Unicode) , 27 byte ^SBCS

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

Hãy thử trực tuyến!

Clojure, 123 byte

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

Tôi đã mong đợi (+ nil)để ném một ngoại lệ, nhưng nó đánh giá là nil: o

Điều này hoạt động mà không có phần đệm, thay vào đó, nó đếm có bao nhiêu hàng trước ít nhất là bằng hàng hiện tại R.