Einführung

Angenommen, Sie haben eine Liste mit Listen mit ganzen Zahlen (oder Objekten, aber der Einfachheit halber bleiben wir bei ganzen Zahlen). Die Listen können unterschiedlich lang und teilweise leer sein. Lassen Sie uns die Listen in einem tabellarischen Format schreiben:

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

Diese Tabelle hat 5 vertikale Spalten, die Zahlen enthalten 1, 6, 8, 12, 15, 2, 7, 9, 13, 16, 3, 10, 14, 17, 4, 11, 18, und 5. Wenn wir jede Spalte umkehren, so erhalten wir die Listen 15, 12, 8, 6, 1, 16, 13, 9, 7, 2, 17, 14, 10, 3, 18, 11, 4, und 5. Lassen Sie uns diese Zahlen wieder in die Spalten der Tabelle einfügen und dabei die Länge der Zeilen wie zuvor beibehalten:

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

Ihre Aufgabe ist es, diese Operation zu implementieren.

Ein- und Ausgabe

Ihre Eingabe ist eine Liste von Listen nichtnegativer Ganzzahlen, die die Zeilen darstellen. Die Zeilen können unterschiedlich lang und teilweise leer sein. Es wird immer mindestens eine Zeile geben. Ihre Ausgabe ist das Ergebnis der Umkehrung jeder Spalte, wie oben beschrieben. Eingabe und Ausgabe können in jedem vernünftigen Format erfolgen.

Die niedrigste Byteanzahl in jeder Sprache gewinnt. Es gelten die Standardregeln für Code-Golf .

Testfälle

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

Gelee , 16 Bytes

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

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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 Bytes

2 Bytes gespart dank @Shaggy

y@=XfÊX£o
®fÄ

Online testen!

Die zweite Zeile kann entfernt werden, wenn wir die Zeilen mit Nullwerten auffüllen dürfen, wodurch 4 Bytes gespart werden.

Erläuterung

 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 danke an ngn.

Volles Programm. Fordert zur Eingabe von STDIN auf.

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

Probieren Sie es online!

Erläuterung mit Beispieldurchgang

⎕ Eingabeaufforderung für ausgewertete Eingabe
 [[1,8,5],[7,5,4],[],[1]]

* Erhöhung e die Kraft , daß ( e ⁿ , die sicherstellt , dass es keine Nullen)
 [[2.7,2981,148.4],[1096.6,148.4,54.6],[],[2.7]]

↑ Mischen Sie die Listen in einer einzigen Matrix, die mit Nullen aufgefüllt ist:
 ┌ ┐
 │2.7E0 3.0E3 1.5E2│
 │1.1E3 1.5E2 5.5E1│
 │0.0E0 0.0E0 0.0E0│
 │2.7E0 0.0E0 0.0E0│
 └ ┘

⍉ transponieren
 ┌ ┐
 │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 kehren Sie die positiven Elemente jeder Reihe um
 ┌ ┐
 │2.7E0 1.1E3 0.0E0 2.7E0│
 │1.5E2 3.0E3 0.0E0 0.0E0│
 │5.5E1 1.5E2 0.0E0 0.0E0│
 └ ┘

⍉ transponieren
 ┌ ┐
 │2.7E0 1.5E2 5.5E1│
 │1.1E3 3.0E3 1.5E2│
 │0.0E0 0.0E0 0.0E0│
 │2.7E0 0.0E0 0.0E0│
 └ ┘

↓ Teilen Sie die Matrix in eine Liste von Listen
 [[2.7,148.4,54.6],[1096.6,2981,148.4],[0,0,0],[2.7,0,0]]

0~¨⍨ Entfernen Sie Nullen aus jeder Liste
 [[2.7,148.4,54.6],[1096.6,2981,148.4],[],[2.7]]

⍟ natürlicher Logarithmus
 [[1,5,4],[7,8,5],[],[1]]

K4 , 36 Bytes

Lösung:

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

Beispiele:

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

Erläuterung:

Dieser hat mir wehgetan, und ich arbeite immer noch daran, die einfache Indizierung zu vereinfachen.

Anstatt zum Beispiel um zu indizieren, x[0]was die erste Zeile zurückgeben würde , möchten wir die erste Spalte nehmen , was mit getan werden kann x[;0].

Jedoch vorbei Variable yin x[;]behandelt sie wie tun x[y]nicht x[;y]damit die schiebend ::dort: x[::;].

Dies ist gleichbedeutend mit dem Umblättern der Listen, erfordert jedoch, dass alle Listen gleich lang sind!

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

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

Probieren Sie es online!

Ungolfed / Erklärung

Die Idee ist, alle Elemente einzuwickeln []und die Zeilen mit Pads zu versehen [](es hat sich herausgestellt, dass es kürzer ist als das Auffüllen mit einer negativen Ganzzahl, was auch negative Eingaben erlaubt, was gut ist), dann zu transponieren, alle Zeilen umzukehren und erneut zu transponieren und jede Zeile zu glätten :

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

^{* Diese Transponierungsfunktion ( h) gibt einfach die Liste zurück, wenn überhaupt keine Elemente vorhanden sind.}

Die Umkehrfunktion muss []Elemente ignorieren (zB [[],[1],[],[3],[4]]-> [[],[4],[],[3],[1]]), indem sie zwei Argumente empfängt: Das erste sind die Elemente in umgekehrter Reihenfolge (zB [4,3,1]) und das zweite die ursprüngliche Zeile.

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 Bytes

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]

Probieren Sie es online!

JavaScript (ES6), 79 76 Bytes

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

Bearbeiten: 3 Bytes dank @ETHproductions gespeichert.

APL (Dyalog Unicode) , 27 Byte ^SBCS

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

Probieren Sie es online!

Clojure, 123 Bytes

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

Ich hatte erwartet (+ nil), eine Ausnahme auszulösen, aber es wird ausgewertet nil: o

Dies funktioniert ohne Auffüllen, stattdessen wird gezählt, wie viele der vorherigen Zeilen mindestens so lang sind wie die aktuelle Zeile R.