Saya telah menulis beberapa tantangan terkait dengan matriks, dan yang umum untuk semua adalah bahwa saya menggunakan format seperti di bawah ini ketika mewakili matriks, baik dalam contoh maupun dalam kasus uji:

16    2    3   13
 5   11   10    8
 9    7    6   12
 4   14   15    1

Ini mungkin format yang rumit dalam banyak bahasa.

Tantangan:

Tulis program / fungsi yang dapat mengambil matriks pada formulir yang diberikan di atas sebagai input (langsung salin / tempel dari posting ini), dan output matriks yang sama pada ketiga format konvensional lainnya yang ditunjukkan di bawah ini .

Format input:

Angka dipisahkan oleh jumlah ruang yang bervariasi, dan baris baru untuk mewakili baris (lihat kasus uji).

• Jumlah spasi antar angka tidak dijamin konsisten. Namun Anda dapat mengasumsikan bahwa digit terakhir di setiap kolom sejajar (jika itu membantu).
• Mungkin ada bilangan bulat dan mengapung, dan mereka bisa positif, negatif atau nol. Matriks tidak akan berisi bilangan bulat dan mengapung pada saat yang bersamaan.
• Anda dapat berasumsi bahwa tidak ada angka yang lebih panjang dari 10 karakter, termasuk titik minus dan desimal untuk pelampung negatif.
• Anda dapat mengasumsikan bahwa ada jumlah entri yang sama di setiap baris dan di setiap kolom.
• Tidak akan ada matriks input kosong, tetapi bisa ada angka tunggal, atau matriks dengan hanya satu baris atau kolom.
  • Anda mungkin dalam kasus ini memilih antara format output yang ditunjukkan dalam kasus uji

Program / fungsi Anda harus menangani input jika langsung disalin dari pos ini dan ditempelkan ke penerjemah (STDIN atau sebagai argumen fungsi atau sesuatu yang setara). Anda mungkin memiliki apa pun yang Anda suka (tanda kurung, tanda kutip, tanda kurung) di depan, dan / atau setelah matriks, tetapi Anda harus mempertimbangkan matriks urutan karakter yang tidak dapat diubah (yang termasuk baris baru).

Untuk memperjelas: Asumsikan fungsi / program Anda dipanggil fdan matriksnya adalah:

1 -2
3  5
6  7

maka Anda dapat memberikan matriks sebagai argumen fungsi seperti ini (dan banyak pilihan lainnya):

f(1 -2
3  5
6  7)

f([1 -2
3  5
6  7])

f("""1 -2
3  5
6  7""")

Jika bahasa Anda tidak bisa, dengan cara apa pun, ambil salinan / tempel matriks sebagai masukan maka saya khawatir Anda harus memilih bahasa lain.

Format output:

Anda harus menampilkan matriks pada tiga format berikut (urutan tidak masalah):

[[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]]
{{16, 2, 3, 13}, {5, 11, 10, 8}, {9, 7, 6, 12}, {4, 14, 15, 1}}
[16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1]

• Anda dapat memisahkan tiga output sesuai keinginan Anda (mis. Baris baru)
• Anda harus menampilkan angka menggunakan presisi yang sama dengan input (misalnya, Anda tidak boleh memangkas jumlah desimal, atau output integer sebagai pelampung).
• Ruang-ruang tersebut wajib
• Anda harus menggunakan -angka negatif, bukan _atau serupa.

Kasus uji:

16    2    3   13
 5   11   10    8
 9    7    6   12
 4   14   15    1
----
[[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]]
{{16, 2, 3, 13}, {5, 11, 10, 8}, {9, 7, 6, 12}, {4, 14, 15, 1}}
[16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1]

0.14778   0.27114   0.24415
0.45997   0.12287   0.67470
0.28945   0.37928   0.51887
----
[[0.14778, 0.27114, 0.24415], [0.45997, 0.12287, 0.6747], [0.28945, 0.37928, 0.51887]]
{{0.14778, 0.27114, 0.24415}, {0.45997, 0.12287, 0.6747}, {0.28945, 0.37928, 0.51887}}
[0.14778, 0.27114, 0.24415; 0.45997, 0.12287, 0.6747; 0.28945, 0.37928, 0.51887]

-0.0398301   0.2403455  -0.2253368   0.3565870   0.0605803   0.0830780
-0.3254422  -0.1185191  -0.2989537   0.1647319   0.3621135   0.2018815
-0.0022281  -0.3362287  -0.3568447   0.4419063   0.3801872  -0.2847033
---
[[-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780], [-0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815], [-0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033],]
{{-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780}, {-0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815}, {-0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033},}
[-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780; -0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815; -0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033]

0       4       1       0
0       0      -6       0
0       1       4      -3
2       0       0       8
0       0       0       0
----
[[0, 4, 1, 0], [0, 0, -6, 0], [0, 1, 4, -3], [2, 0, 0, 8], [0, 0, 0, 0]]
{{0, 4, 1, 0}, {0, 0, -6, 0}, {0, 1, 4, -3}, {2, 0, 0, 8}, {0, 0, 0, 0}}
[0, 4, 1, 0; 0, 0, -6, 0; 0, 1, 4, -3; 2, 0, 0, 8; 0, 0, 0, 0]

1
----
[1]     (or [[1]])
{1}     (or {{1}})
[1]     (or 1)

1 2
----
[1, 2]  (or [[1, 2]])
{1, 2}  (or {{1, 2}})
[1, 2]

4
5
----
[[4], [5]]
{{4}, {5}}
[4; 5]

Saya sepenuhnya sadar akan hal ini , tetapi dalam tantangan ini, format I / O yang rumit adalah intinya. Tantangannya adalah tentang memformat output dalam beberapa bahasa, sementara membaca input akan menjadi bagian tersulit dalam bahasa lain.

Tolong jangan berkecil hati jika membaca input sulit, kiriman tersebut mungkin yang paling menarik. Singkat tidak selalu sama dengan mengesankan. Dan seperti biasa, penjelasan didorong!

Retina , 52 byte

Jawaban ini didasarkan pada jawaban Perl saya , dengan bantuan Martin Ender untuk bermain golf bersama Retina.

^ *
[
$
]
\s+
, 
m):`.+
[$&]
*T`[]`{}
], .
; 
^.|]$

Cobalah online!

Penjelasannya dapat ditemukan pada jawaban Perl saya. Perbedaannya adalah:

*
[
$
]

Alih-alih s/^ *(.+)/[$1]/gmmenghapus spasi terkemuka dan menambahkan tanda kurung di sekitar garis.

^.|]$

Untuk menghapus tanda kurung terkemuka dan tertinggal untuk output ketiga.

Retina , 57 54 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1.

m`^ +

¶
] [
 +
, 
:`.+
[[$&]]
*T`[]`{}
], .
; 
^.|]$

Cobalah online!

TIO link saat ini tidak mencetak feed baris antara tiga format tapi itu karena menggunakan komit yang tidak stabil. Program ini memang mencetak umpan baris tengah di Retina 0.8.2.

Penjelasan

m`^ +

Singkirkan ruang utama di setiap baris.

¶
] [

Ganti baris dengan ] [.

 +
, 

Ganti semua ruang berlari dengan koma dan spasi.

:`.+
[[$&]]

Bungkus seluruh hal [[...]]yang melengkapi format pertama. Cetak hasilnya.

*T`[]`{}

Ganti braket dengan kawat gigi dan cetak hasilnya tanpa benar-benar mengubah string kerja (yaitu format pertama dipulihkan setelah ini dicetak).

], .
; 

Ganti ], [dengan titik koma dan linefeed.

^.|]$

Hapus yang pertama [dan yang terakhir ]. Ini melengkapi format ketiga.

Scala, 183 181 149 byte

Cobalah online!

Versi baru, menggunakan Stringpenggantian dan regex:

(x:String)=>{val d=x.replaceAll("\n *","; ").replaceAll("(?<!;) +",", ");(s"[[${d.replace("; ","], [")}]]",s"{{${d.replace("; ","}, {")}}}",s"[$d]")}

Versi baru memiliki semantik dan penggunaan yang sama seperti versi lama menggunakan split, mapdan mkString.

Versi lama, menggunakan split, mapdan mkString:

Sunting: Kelas karakter redundan untuk ruang yang dihapus

(x:String)=>{val d=x.split("\n").map(_.trim.split(" +").mkString(", "));(d.map(x=>s"[$x]").mkString("[",", ","]"),d.map(x=>s"{$x}").mkString("{",", ","}"),d.mkString("[","; ","]"))}

Lambda. Jalankan dalam REPL. Menerima input sebagai Stringparameter tiga kutip , mengembalikan output sebagai 3-tuple dari output yang diperlukan. REPL membuat tupel yang dipisahkan oleh koma, dibatasi oleh tanda kurung.

Penjelasan:

Versi baru:

Sebagian besar logika yang sama dengan jawaban berbasis regex lainnya, kecuali untuk tampilan yang rumit di belakang untuk menangani spasi pada baris.

Versi lama:

Kami membagi representasi matriks input menjadi Stringarray 2D , lalu memetakannya ke array 1D dengan mengosongkan array dalam dengan memisahkan elemen-elemen dengan ,. Akhirnya, kami hanya membuat keluaran berbeda dengan menciutkan susunan 1D dengan menggunakan pemisah baris baru dan penanda batas (awalan dan sufiks). Semuanya diimplementasikan melalui split(membaca), map(mentransformasikan) dan mkString(menciutkan).

Contoh sesi REPL:

scala> val r=(x:String)=>{val d=x.split("\n").map(_.trim.split(" +").mkString(", "));(d.map(x=>s"[$x]").mkString("[",", ","]"),d.map(x=>s"{$x}").mkString("{",", ","}"),d.mkString("[","; ","]"))}

scala> r("""16    2    3   13
     |  5   11   10    8
     |  9    7    6   12
     |  4   14   15    1""")
res12: (String, String, String) = ([[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]],{{16, 2, 3, 13}, {5, 11, 10, 8}, {9, 7, 6, 12}, {4, 14, 15, 1}},[16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1])

Untuk kasus tepi beberapa elemen, ini memberikan output yang diinginkan.

Japt , 63 53 byte

Ini datang pada 44 byte sebelum saya perhatikan bahwa jarak dalam output adalah wajib.

·®¸f
"[[{q"],["}]]
\{\{{q"},\{"}}}
[{q';}]"r",|;"_+S

Menguji

Penjelasan

          :Implicit input of string U
·         :Split to an array on newlines.
®         :Map over the array.
¸         :Split each element to an array on spaces.
f         :Filter to remove empty elements from the subarrays.
"[[       :Start building the output string. In Japt strings, anything enclosed in {}s will be evaluated before being added to the string.
{q"],["}  :Join the array to a string using ],[ The sub-arrays will be cast to comma separated strings in the process.
]]        :That's the first line done.
\{\{      :The start of the second line. A few bytes have to be sacrificed to esapce the {s
{q"},\{"} :Join the array to a string using },{
}}        :That's the second line done.
[         :And on to the last line.
{q';}     :This time we join the array with a semi-colon.
]"        :And that's the string completed.
r         :Except we still need to replace...
",|;"     :  All occurrences of a comma or a semi-colon with...
_+S       :  Itself and a space.
          :Implicit output of resulting string.

Perl 5 , 71 byte

69 byte kode + -p0bendera.

s/^ *(.+)/[$1]/gm;s/\s+/, /g;$_="[$_]
{".y/[]/{}/r."}
".s/], \[/; /gr

Cobalah online!

Penjelasan

s/^ *(.+)/[$1]/gm;menambahkan []sekitar setiap baris sambil menghapus spasi utama.
s/\s+/, /g;menggantikan run spasi dan baris baru dengan koma dan spasi.
Output pertama kemudian diperoleh sekitarnya dengan kawat gigi: [$_].
Yang kedua perlu mengganti kawat gigi dengan braket keriting ( y/[]/{}/r) dan mengelilingi dengan braket keriting "{" ... "}".
Untuk yang ketiga, ], [diganti dengan titik koma dan spasi ( s/], \[/; /gr).

Setelah menulis solusi ini, saya mencoba mengadaptasi jawaban Retina Martin Ender, tetapi akhirnya lebih lama 10 byte ( TryItOnline ):

s/^ +//gm;s/
/] [/g;s/ +/, /g;$_="[[$_]]
{{".y/[]/{}/r."}}
[".s/], \[/; /gr."]"

Untuk versi ini, lihat jawaban Martin untuk penjelasannya.

MATL , 60 byte

`jtU&D32', 'XHYXw]xXhH&Zc91wh93htD[]&D{}&DXED&GxvUH&4$'; 'TD

Cobalah online!

Terima kasih banyak untuk Luis Mendo karena telah mencukur seperempat dari bytecount saya di masterclass dalam obrolan.

Tempel input, diikuti oleh baris kosong.

% Act I: Taking input.

`jt             w]    % Take input line by line until an empty line is encountered.
   U                  % Convert string input to numerical row array
    &D                % Convert back to string, adding brackets and single spaces
      32', 'XHYX      % Add commas before the spaces. Store ',  ' in clipboard H.


% Act II: Nested square brackets

x                     % Discard the tab character
 Xh                   % Concatenate all strings as cell array.
   H&Zc               % Join all the strings together, using clipboard H as a separator
       91wh93h        % Wrap in square brackets (ASCII 91 and 93)
              tD      % Display a copy of the result.

% Act III: Nested curly brackets

[]&D{}&D              % Convert empty array and cell array to string.
        XE            % Use to substitute square for curly brackets.

% Act IV: MATLAB-style input.

&Gxv                  % Get all the input again, discard the tab, and concatenate vertically.
    U                 % Convert to numerical 
     &4$     TD       % Convert to string, using row- and column separators
        H'; '         % Namely, clipboard H and a semicolon.

05AB1E ,  45  44 byte

|„  ð:ðδÛ˜ð¡„, ý''KD…[ÿ]=„[]„{}‡,"], ["„; :=

Cobalah online!

Output pertama

|                           # push a list of the inputs
 „  ð:                      # replace any instance of 2 spaces with 1 space
      ðδÛ                   # remove any leading spaces
         ˜                  # flatten to a 1D list
          ð¡                # split on spaces
            „, ý            # merge on ", "
                ''K         # remove all single quotes
                   D        # duplicate for use in output 3
                    …[ÿ]    # interpolate between square brackets
                        =   # print without popping 

Output kedua

„[]„{}‡,                    # translate square brackets to curly brackets and print

Keluaran ketiga

                            # the copy from the first output is used here
 "], ["„; :                 # replace "], [" with "; "
           =                # print

Python 2 , 143 byte

import re
b=re.sub
def f(s):s='[['+b('\n','], [',b(' +',', ',b('\n +','\n',s)))+']]';print s,b('\[','{',b('\]','}',s)),b('\], \[','; ',s)[1:-1]

Cobalah online!

Javascript (ES6), 121 110 106 byte

-15 byte terima kasih kepada @Shaggy dan @Justin

m=>`[[${(a=m.split`
`.map(x=>x.match(/\S+/g).join`, `)).join`], [`}]]
{{${a.join`}, {`}}}
[${a.join`; `}]`

Cuplikan kode contoh:

f=
m=>`[[${(a=m.split`
`.map(x=>x.match(/\S+/g).join`, `)).join`], [`}]]
{{${a.join`}, {`}}}
[${a.join`; `}]`
console.log(f(
`1 -2
 3  5
 6  7`
))

Python 2 , 163 152 150 145 byte

-5 byte terima kasih kepada Felipe Nardi Batista yang menyarankan penggunaan percikan (maaf, saya hanya perlu alasan untuk mengatakan kata itu: P).

import re
a=str.replace
def f(s):r=a(`[re.findall('[\.\d]+',i)for i in s.split('\n')]`,"'",'');print r,a(a(r,*']}'),*'[{'),a(r[1:-1],'], [','; ')

Cobalah online!

Python 3 , 184 178 174 173 169 163 * 157 * 153 byte

Input / Output Format: Output dengan spasi antara matriks dan input dengan pemanggilan fungsi ini (seperti yang ditunjukkan pada TIO):

g("""<paste matrix here>""")

Ini fungsinya:

def g(s,r=str.replace):a=str([[[int,float]['.'in y](y)for y in x.split()]for x in s.split('\n')]);print(a,r(r(a,*'[{'),*']}'),'['+r(a,'], [','; ')[2:-1])

Cobalah online!

* Menyimpan 6 byte berkat @officialaimm (dari 169 hingga 163 byte).

* Disimpan 4 byte berkat @FelipeNardiBatista.

Penjelasan yang akan datang setelah bermain golf lebih lanjut.

C, 415 byte

#import<stdio.h>
#define A(a,c,o)for(l=strlen(a)-o,k=0;c[k];)a[l+k]=c[k++];
j,k,l;main(i){char s[999],a[999]="[",b[999]="{",c[999]="[",t[]=" ";for(;fgets(s,999,stdin);){A(b,"{",0)A(a,"[",0)for(i=0;s[i];++i){j=0;for(;s[i]-32&&s[i]-10&&s[i];++i){j=1;t[0]=s[i];A(c,t,0)A(b,t,0)A(a,t,0)}if(j){A(c,", ",0)A(b,", ",0)A(a,", ",0)}}A(c,"; ",2)A(b,"}, ",2)A(a,"], ",2)}A(c,"]",2)A(b,"}",2)A(a,"]",2)puts(a);puts(b);puts(c);}

Itu monster dan waaayyyy terlalu lama, tapi aku sudah selesai dengan itu. Seharusnya pergi untuk pendekatan yang berbeda mungkin.

Cobalah online!

Kasing uji kedua | Kasus uji ketiga | Kasing uji keempat | Kasus uji kelima | Kasus uji keenam | Test case ketujuh

Jelly , 37 byte

j€⁾, j⁾; ⁾[]j
ỴḲLÐf$€VµŒṘṄ“[]“{}”yṄȧÇ

Program lengkap mencetak tiga format pada tiga baris.

Cobalah online!

Bagaimana?

j€⁾, j⁾; ⁾[]j - Link 1, create the 3rd format (semicolon-style): list of lists
  ⁾,          - literal [',', ' ']
j€            - join for €ach (place ", " between the elements of each row)
      ⁾;      - literal [';', ' ']
     j        - join (place "; " between the rows)
         ⁾[]  - literal ['[', ']']
            j - join (surround the whole result with a pair of brackets)

ỴḲLÐf$€VµŒṘṄ“[]“{}”yṄȧÇ - Main link: list of characters
Ỵ                       - split at newlines
     $€                 - last two links as a monad for €ach row:
 Ḳ                      -   split at spaces
   Ðf                   -   filter keep those for which the following is truthy:
  L                     -     length (this removes all the empty lists "between" spaces)
       V                - evaluate as jelly code (yields a list of lists of numbers)
        µ               - monadic chain separation, call that x
         ŒṘ             - get a Python string representation of x
           Ṅ            - print that (the 1st format) plus a newline, and yield it
            “[]“{}”     - literal [['[', ']'],['{', '}']]
                   y    - translate (converts all '[' to '{' and all ']' to '}')
                    Ṅ   - print that (the 2nd format) plus a newline, and yield it
                      Ç - call the last link as a monad with argument x
                     ȧ  - logical and
                        - implicit print of the result (the 3rd format)

V , 41 byte

òJé;òÓ¨ä©ó«/±, 
yss]Y.pkÓ; /], [
Ùòcs]}f[

Cobalah online!

Penjelasan

òJé;ò            Join all lines with `; ` (trailing single space)
     Ó¨ä©ó«/±,   :s/\v(\d)\s+/\1, /g
yss]             Surround everything with brackets (completes [x,x;x,x])
Y.pk             (Y)ank, surround with brackets again, (p)aste.  Adds [[x,x;x,x]]
    Ó; /], [     :s/; /[, ]/g (transforms to [[x,x], [x,x]])
Ù                Duplicate this line
 ò               recursively
  cs]}           (c)hange (s)urrounding [] with {}
      f[         go to the next [ until there are none

R , 132 byte

function(x,p=paste0,g=gsub)cat(z<-p('[[',g('\n','], [',y<-g('[:blank:]',', ',x)),']]'),chartr('[]','{}',z),p('[',g('
','; ',y),']'))

Cobalah online!

fungsi anonim. Mengambil input seperti

f('1 -2
3 5
6 7')

Ini mencetaknya dalam urutan yang sama dengan test case, tetapi dengan spasi sebagai pemisah.

Penjelasan:

Pertama kali bertukar ruang dengan ,dan menyimpan hasilnya sebagai y. Kemudian ia bertukar baris baru dengan ], [, meletakkan [[dan ]]di kedua ujung, dan menyimpan hasilnya sebagaiz .

Berikutnya, chartrswitch [dengan {dan ]dengan }diz .

Akhirnya, dibutuhkan y, menukar baris baru dengan ;dan menempatkan [dan] di kedua ujungnya.

Kemudian semua hasil diteruskan dalam urutan catyang mencetaknya, semua diformat dengan baik, dan dipisahkan oleh satu ruang.

Tanpa ungolfed:

function(x)
  cat(
    z<-paste0('[[',gsub('\n','], [',y<-gsub('[:blank:]',', ',x)),']]'),
    chartr('[]','{}',z),
    paste0('[',gsub('\n','; ',y),']'))

Java 8 dengan Netbeans 8+, 209 byte

Hitung adalah 208 dari kode, ditambah 1 byte untuk menjalankannya dengan menekan F6 .

Jawaban rumit untuk tantangan rumit: p

interface M{static void main(String[]a){String s="";s=s.trim().replaceAll(" +",", ").replaceAll("\n(, )?","; ");System.out.println("["+s+"]\n[["+s.replace("; ","], [")+"]]\n{{"+s.replace("; ","}, {")+"}}");}}

Bagaimana cara menggunakan?

Di dalam Netbeans, rekatkan kode ini dalam file bernama M.java. Kemudian salin matriks yang ingin Anda gunakan. Kemudian antara dua karakter berturut-turut "", tekan ctrl+v sesuai kebutuhan oleh tantangan.

Sekarang tekan F6! Ini akan mengkompilasi kode, menjalankannya dan menampilkan representasi matriks yang diharapkan.

Mathematica, 129 byte

s=StringSplit
r=StringReplace
Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}]&@ToString@s@s[#,n="
"]&

Baris ketiga dan keempat bersama-sama mendefinisikan fungsi murni yang mengambil string sebagai input; misalnya, jika kita atur f=Print...&, maka test case terakhir akan disebut sebagai:

f@"4
5"

Cuplikan

ToString@s@s[#,n="
"]

mem-parsing string input sebagai matriks (string - kita tidak pernah mencoba menafsirkan entri sebagai jumlah numerik) dan mengubah ekspresi yang dihasilkan kembali ke string; ini secara otomatis menghasilkan format output dengan kurung kurawal. Kemudian Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}]mencetak format output dan dua lainnya, dipisahkan oleh baris baru, dengan menggunakan aturan penggantian string langsung.

Pip , 49 46 byte

45 byte kode, +1 untuk -rbendera.

g|>:sYP(RPg^w)R';kPyR'['{R']'}O'[OgRwkJ"; "']

Mengambil input dari stdin. Cobalah online!

Penjelasan

                 Preset variables used: s is " ", w is regex `\s+`, k is ", "
g                With -r flag, g is a list of lines from stdin
 |>:s            Left-strip spaces from (elements of) g and assign back to g

YP(RPg^w)R';k
     g^w         Split (elements of) g on runs of whitespace
   RP            Apply Pip's built-in repr, which wraps lists in [] and separates items
                   with ; (e.g. [[1;2];[3;4]])
  (     )R';k    Replace the semicolons with ", " to obtain format #1
YP               Print and yank into y variable

PyR'['{R']'}
 yR'['{          In y, replace [ with {
       R']'}     and ] with }
P                and print (format #2)

O'[OgRwkJ"; "']
O'[              Output [ with no newline
   O             Output with no newline:
    g              Take g (list of lines of stdin, with leading spaces stripped)
     Rwk           Replace runs of whitespace with ", "
        J"; "      and join lines on "; "
             ']  Print the final ] to complete format #3

(Format penjelasan ini terasa agak berbelit-belit bagi saya, jadi beri tahu saya jika ada sesuatu yang tidak masuk akal.)

SCALA, 590 byte

Sulit, tapi saya pikir saya sudah selesai dengan itu

var o=s.replaceAll("  *"," ").replaceAll("\n ","\n")
var z=o.split("\n")
var h=z.length
var k=new Array[Array[String]](h)
for(i<-0 to h-1)k(i)=z(i).split(" ")
var u=k.length-1
print("{")
for(i<-0 to u){print("{")
for(j<-0 to k(i).length-2)print(k(i)(j)+", ")
print(k(i).last)
print("}")}
print("}[")
for(i<-0 to u){print("[")
for(j<-0 to k(i).length-2)print(k(i)(j)+", ")
print(k(i).last)
print("]")}
print("][")
for(i<-0 to u-1){for(j<-0 to k(i).length-2)print(k(i)(j)+", ")
print(k(i).last)
print("; ")}
for(j<-0 to k(k.length-1).length-2)print(k(u)(j)+", ")
print(k.last.last)
print("]")

Penjelasan cepat: Saya mengambil input yang dikelilingi oleh tiga tanda kutip, lalu melepas spasi yang tidak diminta; pisahkan string dua kali (satu kali untuk garis dan satu kali untuk kolom); dan saya mencetak dengan tiga rutinitas saya. Mungkin bisa mendefinisikan fungsi untuk saling menguntungkan, tetapi saya tidak tahu caranya.

Cobalah online!

05AB1E , 34 byte

|εð¡õK}€ï"ÿ"Є[]„{}‡s¦¨"], ["„; :»

Cobalah online!

ε...}telah diganti dengan vy...})di TIO karena belum ditarik ke sana.

C # (.NET Core) , 214 byte

(s)=>{var result=Regex.Replace("[["+Regex.Replace(s.Replace("\n","], [")," +(\\d)",", $0")+"]","  +"," ").Replace("[, ","[");return$"{result}]\n{result.Replace('[','{').Replace(']','}')}}}\n[{result.Replace("[","").Replace("],",";")}";};

Cobalah online!

Mengambil Matrix sebagai string, mengembalikan tiga format sebagai string tunggal yang dipisahkan oleh baris baru.

Arang , 38 byte

≔Ｅ⪪θ¶⪫Φ⪪ι λ, θＥ⪪[]{}²⪫ι⪫Ｅθ⪫ιλ, ⪫[]⪫θ; 

Cobalah online! Catatan: Ruang tambahan. Tautan adalah untuk mengucapkan versi kode. Arang memiliki opsi input multiline yang dibatasi menggunakan ["""dan """]. Penjelasan:

   θ                Input string
  ⪪ ¶               Split on newlines
 Ｅ                  Map over each line
        ι           Current line
       ⪪            Split on spaces
      Φ   λ         Filter out empty strings
     ⪫     ,        Join with `, `
≔            θ      Assign resulting array to variable

Ini mengambil input dan menyiapkannya dengan membaginya menjadi garis-garis dan menormalkan pemisah.

 ⪪[]{}²             Split `[]{}` into substrings of length 2
Ｅ                   Map over the substrings
          Ｅθ        Map over array from above
            ⪫ιλ     Wrap each element with the substring
         ⪫     ,    Join elements with `, `
       ⪫ι           Wrap with the substring
                    Implicitly print each result on a separate line

Ini menangani kasus [[ ... ], [ ... ]]dan {{ ... }, { ... }}.

    θ               Array from above
   ⪫ ;              Join elements with `; `
⪫[]                 Wrap result with `[]`
                    Implicitly print

Ini menangani [ ... ; ... ] kasus ini.

Sebelum saya memainkan byte dari solusi di atas, saya dulu memiliki dua solusi 39-byte; ini yang lain:

⮌Ｅ⪪[]{}[]²⪫ι⪫ＥＥ⪪θ¶⪫Φ⪪λ ν, ⎇κ⪫ιλλ⁺§;,,κ 

Cobalah online! Catatan: Ruang tambahan. Tautan adalah untuk mengucapkan versi kode. Penjelasan:

  ⪪[]{}[]²                              Split `[]{}[]` into substrings of length 2
 Ｅ                                      Map over the substrings
                θ                       Input string
               ⪪ ¶                      Split on newlines
              Ｅ                         Map over each line
                     λ                  Current line
                    ⪪                   Split on spaces
                   Φ   ν                Filter out empty strings
                  ⪫     ,               Join with `, `
             Ｅ                          Map over each line
                          ⎇κ   λ        If outer index is zero, just use the line
                            ⪫ιλ         Otherwise wrap the line in the substring
            ⪫                   ⁺§;,,κ  Join with `; ` or `, ` per outer index
          ⪫ι                            Wrap in the substring
⮌                                       Reverse the order of the results
                                        Implicitly print each result on a separate line