Giriş

Bir tamsayı listesi listeniz olduğunu varsayalım (veya herhangi bir nesne gerçekten, ancak basitlik için tamsayılara sadık kalalım). Listeler farklı uzunluklarda olabilir ve bazıları boş olabilir. Listeleri tablo biçiminde yazalım:

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

Bu tablo Sayı içeren, 5 dikey sütun var 1, 6, 8, 12, 15, 2, 7, 9, 13, 16, 3, 10, 14, 17, 4, 11, 18, ve 5. Her sütun tersine, biz listeleri elde 15, 12, 8, 6, 1, 16, 13, 9, 7, 2, 17, 14, 10, 3, 18, 11, 4, ve 5. Satırların uzunluklarını daha önce olduğu gibi tutarken bu sayıları tablonun sütunlarına geri ekleyelim:

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

Göreviniz bu işlemi uygulamaktır.

Giriş ve çıkış

Girişiniz, satırları temsil eden negatif olmayan tamsayıların bir listesidir. Satırlar farklı uzunluklara sahip olabilir ve bazıları boş olabilir. Her zaman en az bir satır olacaktır. Çıktınız, yukarıda ayrıntılı olarak açıklandığı gibi her bir sütunu tersine çevirmenin sonucudur. Giriş ve çıkış herhangi bir makul formatta olabilir.

Her dilde en düşük bayt sayısı kazanır. Standart kod golf kuralları geçerlidir.

Test senaryoları

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

Jöle , 16 bayt

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

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Nasıl çalışır

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 bayt

@Shaggy sayesinde 2 bayt kurtardı

y@=XfÊX£o
®fÄ

Çevrimiçi test edin!

Satırları 4 byte tasarruf ederek satırları null değerlerle doldurmamıza izin verilirse ikinci satır kaldırılabilir.

açıklama

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

-4 ngn sayesinde.

Tam program. STDIN'den giriş istenir.

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

Çevrimiçi deneyin!

Örnek gözden geçirme ile açıklama

⎕ değerlendirilmiş girdi istemi
 [[1,8,5],[7,5,4],[],[1]]

* kaldırma e (yani gücüne e ⁿ hiçbir sıfır olmasını sağlar)
 [[2.7,2981,148.4],[1096.6,148.4,54.6],[],[2.7]]

↑ listeleri tek bir matriste karıştırın, sıfırlarla doldurun:
 ┌ ┐
 │2.7E0 3.0E3 1.5E2│
 │1.1E3 1.5E2 5.5E1│
 │0.0E0 0.0E0 0.0E0│
 │2.7E0 0.0E0 0.0E0│
 └ ┘

⍉ devrik
 ┌ ┐
 │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 her satırın pozitif öğelerini tersine çevir
 ┌ ┐
 │2.7E0 1.1E3 0.0E0 2.7E0│
 │1.5E2 3.0E3 0.0E0 0.0E0│
 │5.5E1 1.5E2 0.0E0 0.0E0│
 └ ┘

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

↓ matrisi bir liste listesine bölme
 [[2.7,148.4,54.6],[1096.6,2981,148.4],[0,0,0],[2.7,0,0]]

0~¨⍨ her listeden sıfırları kaldır
 [[2.7,148.4,54.6],[1096.6,2981,148.4],[],[2.7]]

⍟ doğal logaritma
 [[1,5,4],[7,8,5],[],[1]]

K4 , 36 bayt

Çözüm:

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

Örnekler:

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

Açıklama:

Bu bir acı oldu ve ben hala endeksli basitleştirmek için çalışıyorum.

Örneğin, x[0]ilk satırı döndürecek olan at dizinini indekslemek yerine, kullanılarak yapılabilecek ilk sütunu almak istiyoruz x[;0].

Ancak değişken geçirmeden yiçine x[;]yapıyor olarak davranır onu x[y]değil x[;y]dolayısıyla shoving ::orada: x[::;].

Bu, listeler listesini çevirmeye eşdeğerdir, ancak flip, tüm listelerin eşit uzunlukta olmasını gerektirir!

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

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

Çevrimiçi deneyin!

Ungolfed / Açıklama

Fikir, tüm elemanları sarmak []ve satırları []doldurmak (negatif bir tamsayı ile doldurmadan daha kısa olduğu ortaya çıktı, bu da negatif girişlere de izin veriyor), daha sonra transpoze edin, tüm satırları tersine çevirin ve tekrar transpoze edin ve her satırı düzleştirin :

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

^{* Bu transpoze fonksiyonu ( h) hiç eleman yoksa basitçe listeyi döndürür.}

Ters fonksiyon []elemanları yok saymak zorundadır (örn. [[],[1],[],[3],[4]]-> [[],[4],[],[3],[1]]), bunu iki argüman alarak yapar: Birincisi ters sırada (örn. [4,3,1]) Ve ikincisi orijinal satırdaki elemanlardır.

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

Piton 2 , 111 105 92 bayt

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]

Çevrimiçi deneyin!

JavaScript (ES6), 79 76 bayt

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

Düzenleme: @ETHproductions sayesinde 3 bayt kaydedildi.

APL (Dyalog Unicode) , 27 bayt ^SBCS

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

Çevrimiçi deneyin!

Clojure, 123 bayt

#(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)Bir istisna atmayı bekliyordum , ancak şu şekilde değerlendiriyor nil: o

Bu, dolgu olmadan çalışır, bunun yerine önceki satırlardan en az kaçının geçerli satır kadar uzun olduğunu sayar R.