Membalikkan kolom sambil mempertahankan bentuk

20

pengantar

Misalkan Anda memiliki daftar daftar bilangan bulat (atau objek apa pun sebenarnya, tetapi mari kita tetap menggunakan bilangan bulat untuk kesederhanaan). Daftarnya mungkin panjangnya berbeda, dan beberapa di antaranya mungkin kosong. Mari kita menulis daftar dalam format tabel:

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

Tabel ini memiliki 5 kolom vertikal, yang berisi nomor 1, 6, 8, 12, 15, 2, 7, 9, 13, 16, 3, 10, 14, 17, 4, 11, 18, dan 5. Jika kita membalikkan setiap kolom, kita memperoleh daftar 15, 12, 8, 6, 1, 16, 13, 9, 7, 2, 17, 14, 10, 3, 18, 11, 4, dan 5. Mari kita pasang angka-angka itu kembali ke kolom tabel sambil menjaga panjang baris sama seperti sebelumnya:

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

Tugas Anda adalah mengimplementasikan operasi ini.

Masukan dan keluaran

Input Anda adalah daftar daftar bilangan bulat negatif, mewakili baris. Baris mungkin memiliki panjang yang berbeda, dan beberapa di antaranya mungkin kosong. Akan selalu ada setidaknya satu baris. Output Anda adalah hasil membalikkan setiap kolom, seperti yang dijelaskan di atas. Input dan output mungkin dalam format yang masuk akal.

Hitungan byte terendah di setiap bahasa menang. Aturan standar kode-golf berlaku.

Uji kasus

[[]] -> [[]]
[[],[]] -> [[],[]]
[[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]]
code-golf array-manipulation Zgarb
sumber
1
Bolehkah kita mengisi baris output dengan nol? (mis. [[1,9],[3],[2,4,5]] -> [[2,4],[3,null],[1,9,5]])
ETHproductions
@ ETHproduksi Tidak, output harus hanya berisi angka.
Zgarb
-1 karena tidak umum (tidak mengizinkan angka negatif, huruf, string, dan semua jenis yang mungkin sebagai elemen baris) + Saya tidak suka (sepertinya tidak perlu sulit)
RosLuP

Jawaban:

5

Jelly , 16 byte

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

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

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.
Dennis
sumber
Bagus, ṣdi baris paling atas sangat pintar! ( ḟṚṁṣjTidak ⁸ḟ⁹Ṛṁ⁸ṣ⁹¤j⁹tepat?) Kalau tidak saya punya ini untuk satu byte
Erik yang Outgolfer
Ya, itulah yang dilakukannya.
Dennis
4

Japt , 15 13 byte

disimpan 2 byte berkat @Shaggy

y@=XfÊX£o
®fÄ

Uji secara online!

Baris kedua dapat dihapus jika kita diizinkan untuk mengisi baris dengan nilai nol, menghemat 4 byte.

Penjelasan

 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
Produksi ETH
sumber
Yang bagus! Anda bisa mendapatkannya hingga 13 byte dengan mengganti l;dengan Êdan mf_Ädengan ®fÄ.
Shaggy
Sebenarnya, mfsepertinya bekerja untuk baris kedua.
Shaggy
@Shaggy Terima kasih, tidak memikirkan itu! mfakan menghilangkan semua nol dalam hasilnya, sayangnya ...
ETHproduksi
Ah, ya, tidak memikirkan itu.
Shaggy
4

APL (Dyalog Unicode) , 20 19 16 byte SBCS

-4 Terima kasih kepada ngn.

Program lengkap. Anjuran untuk input dari STDIN.

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

Cobalah online!

Penjelasan dengan contoh walk-through

⎕ meminta input yang dievaluasi
 [[1,8,5],[7,5,4],[],[1]]

* meningkatkan e untuk kekuatan yang ( e n yang menjamin bahwa tidak akan ada nol)
 [[2.7,2981,148.4],[1096.6,148.4,54.6],[],[2.7]]

↑ campur daftar menjadi satu matriks, padding dengan nol:
 ┌ ┐
 │2.7E0 3.0E3 1.5E2│
 │1.1E3 1.5E2 5.5E1│
 │0.0E0 0.0E0 0.0E0│
 │2.7E0 0.0E0 0.0E0│
 └ ┘

⍉ mengubah urutan
 ┌ ┐
 │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 membalikkan elemen positif dari setiap baris
 ┌ ┐
 │2.7E0 1.1E3 0.0E0 2.7E0│
 │1.5E2 3.0E3 0.0E0 0.0E0│
 │5.5E1 1.5E2 0.0E0 0.0E0│
 └ ┘

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

↓ pisahkan matriks menjadi daftar daftar
 [[2.7,148.4,54.6],[1096.6,2981,148.4],[0,0,0],[2.7,0,0]]

0~¨⍨ hapus angka nol dari setiap daftar
 [[2.7,148.4,54.6],[1096.6,2981,148.4],[],[2.7]]

⍟ logaritma alami
 [[1,5,4],[7,8,5],[],[1]]

Adm
sumber
Bagaimana jika inputnya mengandung -1?
ngn
@ngn Input tidak akan pernah berisi angka negatif; lihat bagian "Input dan output".
Zgarb
@ Zgarb Sempurna, terima kasih.
ngn
@ Adám saya edit untuk menggunakan peringkat 1 alih-alih campuran-masing-masing.
ngn
@ Adám juga: exp / log, bukan + 1 / -1, mencakup tes dengan ⎕fr ← 1287
ngn
3

K4 , 36 byte

Larutan:

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

Contoh:

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

Penjelasan:

Yang ini menyakitkan, dan saya masih berusaha menyederhanakan pengindeksan elided.

Alih-alih mengindeks pada, misalnya, x[0]yang akan mengembalikan baris pertama , kami ingin mengambil kolom pertama , yang dapat dilakukan dengan menggunakan x[;0].

Namun lewat variabel yke x[;]memperlakukan sebagai melakukan x[y]tidak x[;y]maka mendorong para ::di sana: x[::;].

Ini sama dengan membalik daftar, tetapi flip mengharuskan semua daftar memiliki panjang yang sama!

+{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
streetster
sumber
3

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

Cobalah online!

Tidak Terikat / Penjelasan

Idenya adalah untuk membungkus semua elemen di []dan pad baris dengan [](ternyata lebih pendek dari padding dengan bilangan bulat negatif, ini memungkinkan input negatif juga yang bagus), lalu transpos, balikkan semua baris dan transpos lagi dan ratakan setiap baris :

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

* Fungsi transpose ini ( h) mengembalikan daftar jika tidak ada elemen sama sekali.

Fungsi mundur harus mengabaikan []elemen (mis. [[],[1],[],[3],[4]]-> [[],[4],[],[3],[1]]), ia melakukannya dengan menerima dua argumen: Yang pertama adalah elemen dalam urutan terbalik (mis. [4,3,1]) Dan yang kedua adalah baris asli.

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
ბიმო
sumber
2

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]

Cobalah online!

ovs
sumber
Anda bisa menggunakan printalih-alih returnmenyimpan byte.
Jonathan Frech
2

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`

Sunting: Disimpan 3 byte berkat @ETHproductions.

Neil
sumber
@ ETHProduk Benar; Saya tidak tahu mengapa saya pikir itu tidak akan terjadi, kalau tidak saya sudah melakukannya.
Neil
1

APL (Dyalog Unicode) , 27 byte SBCS

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

Cobalah online!

ngn
sumber
Saya pikir Anda terlalu memikirkan yang ini.
Adám
Saya tahu saya bisa menggunakannya @tetapi saya tidak memilikinya.
ngn
0

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

Saya mengharapkan (+ nil)untuk melempar pengecualian, tetapi mengevaluasi untuk nil: o

Ini beroperasi tanpa padding, alih-alih menghitung berapa banyak baris sebelumnya setidaknya selama baris saat ini R.

NikoNyrh
sumber