Terkadang, saya memiliki daftar matriks konstan dalam kode saya:

[ [[1, 0],
   [0, 1]],

  [[1, 0],
   [0,-1]],

  [[0, 1],
   [1, 0]],

  [[0,-1],
   [1, 0]] ]

Itu penggunaan real estat layar yang mengerikan. Saya lebih suka menulisnya bersebelahan:

[   [[1, 0],    [[1, 0],    [[0, 1],    [[0,-1],
     [0, 1]],    [0,-1]],    [1, 0]],    [1, 0]]   ]

Anda akan menemukan bahwa ini masih merupakan daftar bersarang yang valid secara sintaksis, hanya saja tidak berbentuk persegi panjang dan memiliki struktur yang sangat berbeda (khususnya, semakin dalam setiap kali saya menambahkan matriks yang lebih besar dari 1x1). Namun, masih memungkinkan untuk merekonstruksi daftar matriks awal dari daftar baru ini.

Agar saya dapat menggunakan sintaks ini di masa depan, saya ingin Anda menulis beberapa kode yang mengubah array yang ditulis dalam pengaturan horizontal ke daftar matriks yang mereka wakili.

Untuk memastikan bahwa jawaban tidak melakukan pencocokan pola 2D pada tata letak dalam kode sumber, input akan diberikan baik hanya sebagai objek array, atau jika Anda mengambil representasi string, maka tidak akan berisi spasi kosong yang menunjukkan bagaimana literal ditulis dalam kode. Jadi, Anda akan mendapatkan beberapa input seperti ini:

[[[1, 0], [[1, 0], [[0, 1], [[0,-1], [0, 1]], [0,-1]], [1, 0]], [1, 0]]]

Dan output harus berupa array berikut atau representasi string-nya (sekali lagi, tidak perlu layout lebih lanjut):

[[[1, 0], [0, 1]], [[1, 0], [0,-1]], [[0, 1], [1, 0]], [[0,-1], [1, 0]]]

Ini adalah bagian pertama dan lebih mudah dari tantangan dua bagian. Dalam hal ini, Anda dapat mengasumsikan bahwa semua matriks adalah kuadrat dan memiliki dimensi yang sama dan bahwa mereka disejajarkan dengan benar satu sama lain. Pada bagian kedua kita akan mengendurkan asumsi ini.

Aturan

Input akan berupa daftar bersarang atau representasi string kanoniknya (dalam bahasa pilihan Anda), dan Anda harus menampilkan hasilnya dalam format yang sama. Hasilnya akan selalu mengandung setidaknya satu matriks, dan matriks bisa sekecil 1x1. Matriks hanya akan berisi bilangan bulat (ditandatangani) dengan nilai absolut kurang dari 128.

Anda dapat menulis sebuah program atau fungsi dan menggunakan salah satu metode standar untuk menerima input dan memberikan output.

Anda dapat menggunakan bahasa pemrograman apa pun , tetapi perhatikan bahwa celah ini dilarang secara default.

Ini adalah kode-golf , sehingga jawaban terpendek yang valid - diukur dalam byte - menang.

Uji Kasus

Setiap test case memiliki a) daftar matriks disusun dengan baik di samping satu sama lain karena mereka akan berada dalam kode (ini bukan input Anda), b) daftar yang tidak diformat tanpa spasi kosong ( ini adalah input Anda), c) output yang diharapkan.

Pretty: [ [[0]] ]
Input:  [[[0]]]
Output: [[[0]]]

Pretty: [  [[-1]],  [[0]],  [[1]]  ]
Input:  [[[-1]],[[0]],[[1]]]
Output: [[[-1]],[[0]],[[1]]]

Pretty: [  [[1, 0],   [[1, 0],   [[0, 1],   [[0,-1],
            [0, 1]],   [0,-1]],   [1, 0]],   [1, 0]]  ]
Input:  [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]
Output: [[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

Pretty: [  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
            [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
            [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]
Input:  [[[1,0,0],[[127,63,31],[[1,0,0],[[0,0,0],[0,1,0],[15,0,-15],[0,0,1],[0,0,0],[0,0,1]],[-31,-63,-127]],[0,1,0]],[0,0,0]]]
Output: [[[1,0,0],[0,1,0],[0,0,1]],[[127,63,31],[15,0,-15],[-31,-63,-127]],[[1,0,0],[0,0,1],[0,1,0]],[[0,0,0],[0,0,0],[0,0,0]]]

Jelly , 20 15 13 11 byte

Fðs⁹œsZµḢḢL

Cobalah online!

Latar Belakang

Seperti kebanyakan hal, tantangan ini agak sederhana setelah Anda tahu apa yang harus Anda lakukan. Dan akhirnya saya lakukan, setelah tiga penghapusan dan satu rollback ...

Pertama, kita harus mencari tahu dimensi dari matriks. Itu lebih mudah dilakukan daripada mengatakan: elemen pertama dari elemen pertama adalah baris pertama dari matriks output pertama, sehingga panjangnya sama dengan jumlah kolom dari matriks output persegi.

Misalnya, jika inputnya adalah

[  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
    [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
    [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]

elemen pertama dari elemen pertama adalah [1, 0, 0], yang panjangnya ℓ = 3 .

Jika kita meratakan input dan membaginya menjadi potongan-potongan dengan panjang itu, kita mendapatkan semua baris matriks output, meskipun dalam urutan yang salah. Sebagai contoh input kami, ini memberi

[  [1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0],
   [0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0],
   [0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]  ]

Untuk mendapatkan hasil akhir, pertama-tama kita harus membagi array baris menjadi ℓ chunks dengan panjang yang sama. Sebagai contoh input kami, ini memberi

[ [[1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0]],
  [[0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0]],
  [[0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]] ]

Setiap kolom sekarang menjadi salah satu matriks keluaran, jadi mentransposasikan matriks array yang dihasilkan adalah yang tersisa untuk dilakukan. Sebagai contoh input kami, itu memberi

[
 [[1, 0, 0],
  [0, 1, 0],
  [0, 0, 1]],

 [[127,  63,   31],
  [ 15,   0,  -15],
  [-31, -63, -127]],

 [[1, 0, 0],
  [0, 0, 1],
  [0, 1, 0]],

 [[0, 0, 0],
  [0, 0, 0],
  [0, 0, 0]]
]

seperti yang diinginkan.

Bagaimana itu bekerja

Fðs⁹œsZµḢḢL  Monadic link. Argument: A (ragged array)


F            Monadic chain. Argument: A

F            Flatten A. This yields the vector V.


       µḢḢL  Monadic chain. Argument: A

        Ḣ    Head; retrieve the first element of A.
         Ḣ   Head; retrieve the first element of the first element of A.
          L  Compute ℓ, the length of the resulting array.


 ðs⁹œsZ      Dyadic chain. Left argument: V. Right argument: ℓ

  s⁹         Split V into chunks of length ℓ.
    œs       Split the result into ℓ chunks of equal length.
      Z      Zip/transpose the result.

Pyth , 12 byte

CcJlhhQc.nQJ

Ini adalah port jawaban Jelly saya.

Cobalah online!

Bagaimana itu bekerja

Pyth mem-parsing program sebagai berikut (pseudo-code).

C(c(J = l(h(h(Q))), c(.n(Q), J)))

Q adalah variabel yang menampung input.J adalah variabel yang tidak terdefinisi.

Pertama-tama J = l(h(h(Q)))menyimpan panjang kepala (elemen pertama) dari kepala Q di J .

Kemudian, .n(Q)ratakan Q , dan c(..., J)bagi hasilnya menjadi potongan-potongan dengan panjang J .

Setelah itu, c(J, ...)bagi hasil dalam J potong.

Akhirnya, C(...)transpos hasilnya.

Pyth , 29 byte

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

Suite uji.

Bagaimana itu bekerja

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

              z        input
             :      3  split at matches of the following regex
               "\B,"   /\B,/
            J          store at J
           U           [1,2,...,len(J)]

                           J  J
                        @R1   take the second character of each
                              substring in J
                     x\[      indices of all occurrences of "["

          -   filter away the elements in ^ from the
              elements in ^^ to find the first substring
              which does not start with "[["
         h    the first element
              note: this will generate an error if
              all substrings start with "[[", e.g. in the
              first example. We will deal with the error later.
       cJ     split J in groups of the specified length
      C       transpose                             ^
     s        flatten                               |
  j\,         join with ","                         |
.x            if the above code generated an error (|), return
              the following instead:
                            z      the input

Algoritma

Mari kita bekerja pada input [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]].

Kami akan menggunakan operasi string murni di sini.

Pertama, kami membagi input di koma yang bukan bagian dari daftar terdalam (ini dilakukan dengan memisahkan di regex \B,):

[[[1,0]
[[1,0]
[[0,1]
[[0,-1]
[0,1]]
[0,-1]]
[1,0]]
[1,0]]]

Kemudian, kami menemukan indeks substring pertama yang tidak dimulai dengan [[(ini dilakukan dengan memeriksa apakah karakter pada indeks 1adalah [). Dalam hal ini, itu 4karena substring pada indeks 4 [0,1]]tidak dimulai dengan [[.

Kemudian, kami mengelompokkan substring dalam kelompok 4, dan kemudian mengubah posisinya:

[[[1,0]
[0,1]]
[[1,0]
[0,-1]]
[[0,1]
[1,0]]
[[0,-1]
[1,0]]]

Dan kemudian kita bergabung dengan mereka dengan koma:

[[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

JavaScript (ES6), 132 130 byte

f=(a,n=1)=>a[0][n]?a[0][n][0][0]?f(a,n+1,a[0].splice(n,1,...a[0][n])):n>1?[...Array(n)].map((_,i)=>a[0].filter((_,j)=>j%n==i)):a:a

Ada empat kasus:

• Array 1 × n, yang baru saja dikembalikan (ini adalah tes pertama, tetapi terbalik)
• Array m × n yang belum diratakan, yang kami rekam secara merata satu langkah, menghitung npada saat yang sama.
• Array m × n yang telah diratakan, tempat kami menyaring setiap n elemen.
• Array m × 1, yang baru saja dikembalikan

05AB1E , 11 byte

Port jawaban Dennis . Kode:

¬¬g¹˜sô¬gäø

Menggunakan pengkodean CP-1252 . Cobalah online!

Mathematica, 104 byte

l=Length;(m=l@#[[1,1]];n=l@Flatten@#/m;Table[Partition[#~ArrayReshape~{n,m},n/m][[j,i]],{i,n/m},{j,m}])&

Memasukkan

{{{1, 0}, {{1, 0}, {{0, 1}, {{0, -1}, {0, 1}}, {0, -1}}, {1, 0} }, {1, 0}}}

keluaran

{{{1, 0}, {0, 1}}, {{1, 0}, {0, -1}}, {{0, 1}, {1, 0}}, {{0, -1 }, {1, 0}}}

memasukkan

{{{1, 0, 0}, {{127, 63, 31}, {{1, 0, 0}, {{0, 0, 0}, {0, 1, 0}, {15, 0, -15}, {0, 0, 1}, {0, 0, 0}, {0, 0, 1}}, {-31, -63, -127}}, {0, 1, 0}}, {0, 0, 0}}}

keluaran

{{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}, {{127, 63, 31}, {15, 0, -15}, {-31, - 63, -127}}, {{1, 0, 0}, {0, 0, 1}, {0, 1, 0}}, {{0, 0, 0}, {0, 0, 0},, {0, 0, 0}}}

{{{0}}} dan {{{-1}}, {{0}}, {{1}}} juga berfungsi

-11 byte terima kasih kepada Martin Ender