บทนำ

สมมติว่าคุณมีรายการของจำนวนเต็ม (หรือวัตถุใด ๆ จริง ๆ แต่ลองติดกับจำนวนเต็มเพื่อความเรียบง่าย) รายการอาจมีความยาวต่างกันและบางรายการอาจว่างเปล่า ลองเขียนรายการในรูปแบบตาราง:

[[ 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 ไบต์

บันทึก 2 ไบต์ด้วย @Shaggy

y@=XfÊX£o
®fÄ

ทดสอบออนไลน์!

บรรทัดที่สองสามารถลบออกได้ถ้าเราได้รับอนุญาตให้ pad แถวด้วยค่า Null ซึ่งจะช่วยประหยัด 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

-4 ขอบคุณ ngn

โปรแกรมเต็มรูปแบบ พร้อมต์สำหรับอินพุตจาก STDIN

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

ลองออนไลน์!

คำอธิบายพร้อมตัวอย่างแบบ walk-through

⎕ พรอมต์สำหรับการป้อนข้อมูลที่ประเมิน
 [[1,8,5],[7,5,4],[],[1]]

* ยกeสู่พลังของมัน ( e ⁿซึ่งรับรองว่าจะไม่มีเลขศูนย์)
 [[2.7,2981,148.4],[1096.6,148.4,54.6],[],[2.7]]

↑ ผสมรายการลงในเมทริกซ์เดียวเติมด้วยศูนย์:
 ┌ ┐
 │2.7E0 3.0E3 1.5E2│
 │1.1E3 1.5E2 5.5E1│
 │0.0E0 0.0E0 0.0E0│
 │2.7E0 0.0E0 0.0E0│
 └ ┘

⍉ transpose
 ┌ ┐
 │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│
 └ ┘

⍉ transpose
 ┌ ┐
 │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~¨⍨ ลบศูนย์ออกจากแต่ละรายการ
 [[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

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

ลองออนไลน์!

Ungolfed / คำอธิบาย

ความคิดคือการห่อองค์ประกอบทั้งหมดใน[]และรองแถวด้วย[](กลายเป็นสั้นกว่า padding ด้วยจำนวนเต็มลบซึ่งจะช่วยให้อินพุตเชิงลบเช่นกันซึ่งเป็นสิ่งที่ดี) จากนั้นย้ายสลับย้อนกลับแถวทั้งหมดและแปลงอีกครั้งและแผ่ในแต่ละแถว :

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

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

ลองออนไลน์!

JavaScript (ES6), 79 76 ไบต์

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

แก้ไข: บันทึกแล้ว 3 ไบต์ด้วย @ETHproductions

APL (Dyalog Unicode) , 27 ไบต์^SBCS

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

ลองออนไลน์!

Clojure 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: o

นี้ดำเนินการได้โดยไม่ต้อง padding Rแทนมันจะนับจำนวนแถวก่อนหน้านี้อย่างน้อยเป็นเวลานานเป็นแถวปัจจุบัน