Я написав кілька викликів, пов’язаних з матрицями, і загальним для всіх є те, що я використовую такий формат, як наведений нижче, коли представляю матриці, як у прикладах, так і в тестових випадках:

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

Це, ймовірно, громіздкий формат на багатьох мовах.

Виклик:

Напишіть програму / функцію, яка може приймати матрицю у формі, заданій вгорі, як вхід (безпосередньо скопіювати / вставити з цієї публікації) та вивести ту саму матрицю на всі три інші звичайні формати, показані нижче .

Формат введення:

Числа, розділені різною кількістю пробілів, та нові рядки для відображення рядків (див. Тестові випадки).

• Кількість пробілів між номерами не гарантується послідовністю. Однак ви можете припустити, що остання цифра кожного стовпця вирівнюється (якщо це допомагає).
• Тут можуть бути як цілі числа, так і поплавці, і вони можуть бути додатними, від’ємними або нульовими. Матриця не буде містити цілих чисел і плаває одночасно.
• Ви можете припустити, що жодне число не перевищує 10 символів, включаючи мінус та десяткову точку для негативних поплавків.
• Ви можете припустити, що в кожній рядці та в кожному стовпчику однакова кількість записів.
• Не буде порожніх вхідних матриць, але можуть бути одиничні числа або матриці, що містять лише один рядок або стовпець.
  • Ви можете в цих випадках вибирати між вихідними форматами, показаними в тестових випадках

Ваша програма / функція повинна обробляти дані, якщо вона безпосередньо скопійована з цього повідомлення та вставлена ​​в інтерпретатор (STDIN або як аргумент функції або щось еквівалентне). Ви можете мати все, що вам подобається (дужки, лапки, дужки) перед та / або після матриці, але ви повинні вважати матрицю послідовністю символів, яку неможливо змінити (що включає нові рядки).

Для уточнення: Припустимо, ваша функція / програма викликається, fа матриця:

1 -2
3  5
6  7

тоді ви можете надати матрицю як аргументи функції на зразок цього (і нескінченно багато інших варіантів):

f(1 -2
3  5
6  7)

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

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

Якщо ваша мова ні в якому разі не може взяти матрицю копіювання / вставлення як вхід, я боюся, що вам доведеться вибрати іншу мову.

Формат виводу:

Ви повинні вивести матрицю в наступних трьох форматах (порядок не має значення):

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

Я цілком усвідомлюю це , але в цьому виклику суттєвий суперечливий формат вводу / виводу. Завдання стосуватиметься форматування вихідних даних на деяких мовах, тоді як читання входів буде найважчою частиною в інших мовах.

Будь ласка, не варто відмовлятися, якщо читання вправ важке, вони можуть бути найцікавішими. Короткий не обов'язково такий же, як вражаючий. І як завжди, пояснення заохочуються!

Сітківка , 52 байти

Ця відповідь заснована на моїй відповіді Perl , за допомогою Мартіна Ендера для гри в гольф з Ретіною.

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

Спробуйте в Інтернеті!

Пояснення можна знайти в моїй відповіді Perl. Відмінності:

*
[
$
]

Замість того, s/^ *(.+)/[$1]/gmщоб обидва видалити провідні пробіли та додати дужки навколо рядків.

^.|]$

Щоб зняти провідні та кінцеві дужки для третього виводу.

Сітківка , 57 54 байти

Кількість байтів передбачає кодування ISO 8859-1.

m`^ +

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

Спробуйте в Інтернеті!

Посилання TIO в даний час не друкує каналів рядків між трьома форматами, але це тому, що він використовує нестабільну фіксацію. Програма друкує проміжні канали рядків у Retina 0.8.2.

Пояснення

m`^ +

Позбудьтеся провідних пробілів у кожному рядку.

¶
] [

Замініть канали ліній на ] [.

 +
, 

Замініть всі пробіли пробілів комою та пробілом.

:`.+
[[$&]]

Загорніть всю річ, в [[...]]якій завершується перший формат. Роздрукуйте результат.

*T`[]`{}

Замініть дужки дужками та надрукуйте результат, не змінюючи фактично робочий рядок (тобто перший формат відновлюється після друку).

], .
; 

Замініть ], [крапкою з комою та рядком.

^.|]$

Видаліть перше [і останнє ]. Цим завершується третій формат.

Scala, 183 181 149 байт

Спробуйте в Інтернеті!

Нова версія, що використовує Stringзаміни та регулярні вирази:

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

Нова версія має ту ж семантику і використання як стара версія , використовуючи split, mapі mkString.

Стара версія, використовуючи split, mapі mkString:

Редагувати: надлишковий клас символів для вилученого простору

(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("[","; ","]"))}

Лямбда. Виконати в REPL. Приймає введення як Stringпараметр з потрійним котируванням , повертає вихід у вигляді 3-х кращих необхідних виходів. REPL надає кортежі, розділені комами, облямовані дужками.

Пояснення:

Нова версія:

Здебільшого та ж логіка, що й інші відповіді на основі регулярних виразів, за винятком хитрої перспективи обробки провідних просторів на лініях.

Стара версія:

Ми розділили подання матриці вводу на 2D Stringмасив, потім зіставимо його на 1D масив, згорнувши внутрішні масиви, розділивши елементи на ,. Нарешті, ми просто створюємо різні виходи, згортаючи 1D масиви, використовуючи необхідні роздільники нового рядка та граничні маркери (префікси та суфікси). Це все реалізується за допомогою split(читання), map(перетворення) та mkString(згортання).

Приклад сеансу 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])

Для кейсів з декількома елементами це забезпечує бажаний вихід.

Japt , 63 53 байти

Це входило в 44 байти, перш ніж я помітив, що інтервал у висновку є обов'язковим.

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

Перевірте це

Пояснення

          :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 байт

69 байт коду + -p0прапори.

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

Спробуйте в Інтернеті!

Пояснення

s/^ *(.+)/[$1]/gm;додає []навколо кожного рядка, видаляючи провідні пробіли.
s/\s+/, /g;замінює пробіли пробілів та нових рядків комою та пробілом.
Перший вихід потім виходить шляхом оточення з фігурними дужками: [$_].
Другий повинен замінити дужки фігурними дужками ( y/[]/{}/r) і оточити фігурними дужками "{" ... "}".
По-третє, ], [замінюються крапкою з комою та пробілом ( s/], \[/; /gr).

Написавши це рішення, я спробував додати відповідь Сітківки Мартіна Ендера, але це закінчилося на 10 байт довше ( TryItOnline ):

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

Для цієї версії див. Відповідь Мартіна для пояснень.

MATL , 60 байт

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

Спробуйте в Інтернеті!

Велике спасибі Луїсу Мендо за те, що поголив чверть мого обліку в майстер-класі в чаті.

Вставте вхід, а потім порожній рядок.

% 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 байт

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

Спробуйте в Інтернеті!

Перший вихід

|                           # 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 

Другий вихід

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

Третій вихід

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

Python 2 , 143 байти

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]

Спробуйте в Інтернеті!

Javascript (ES6), 121 110 106 байт

-15 байт завдяки @Shaggy та @Justin

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

Приклад фрагмента коду:

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 байт

-5 байт завдяки Феліпе Нарді Батісті, який запропонував використовувати значки (вибачте, мені просто потрібна привід, щоб сказати це слово: 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],'], [','; ')

Спробуйте в Інтернеті!

Пітон 3 , 184 178 174 173 169 163 * 157 * 153 байт

Формат вводу / виводу: Виведення з пробілом між матрицями та вхід за допомогою виклику цієї функції (як показано на TIO):

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

Це функція:

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

Спробуйте в Інтернеті!

* Збережено 6 байт завдяки @officialaimm (від 169 до 163 байт).

* Збережено 4 байти завдяки @FelipeNardiBatista.

Пояснення, щоб прийти після подальшого гольфу.

C, 415 байт

#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);}

Це монстр і waaayyyy занадто довго, але я з цим закінчую. Мабуть, пішли на інший підхід, ймовірно.

Спробуйте в Інтернеті!

Другий тестовий випадок | Третій тестовий випадок | Четвертий тестовий випадок | П'ятий тестовий випадок | Шостий тестовий випадок | Сьомий тестовий випадок

Желе , 37 байт

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

Повна програма, що друкує три формати на три рядки.

Спробуйте в Інтернеті!

Як?

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 байт

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

Спробуйте в Інтернеті!

Пояснення

ò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 байти

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

Спробуйте в Інтернеті!

анонімна функція. Приймає вхід як

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

Він друкує їх у тому ж порядку, що і тестові приклади, але з пробілами, як роздільник.

Пояснення:

Він спочатку замінює пробіли ,і зберігає результат як y. Потім він заміняє нові рядки ], [, ставить [[і ]]на будь-якому кінці, і зберігає результат цього як z.

Потім chartrпереключається [з {і ]з }в z.

Нарешті, він займає y, замінює нові рядки з ;і ставить [і ]на будь-якому кінці.

Потім всі результати передаються в тому порядку, до catякого вони друкуються, всі добре відформатовані та розділені одним пробілом.

Легко незворушний:

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

Java 8 з Netbeans 8+, 209 байт

Код дорівнює 208 від коду, плюс 1 байт, щоб запустити його, натиснувши F6.

Громіздка відповідь на громіздкий виклик: с

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("; ","}, {")+"}}");}}

Як користуватись?

В межах Netbeans вставте цей код у файл, який називається M.java. Потім скопіюйте матрицю, яку ви хочете використовувати. Потім між двома послідовними символами ""натисніть ctrl+v як того вимагає виклик.

Тепер натисніть F6! Це складе код, запустить його та виведе очікувані матричні подання.

Математика, 129 байт

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

Третій та четвертий рядки разом визначають чисту функцію, приймаючи рядок як вхідний; Наприклад, якщо ми встановимо f=Print...&, то останній тестовий випадок буде називатися таким:

f@"4
5"

Фрагмент

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

розбирає вхідний рядок як матрицю (рядків - ми ніколи не намагаємось інтерпретувати записи як числові величини) і перетворює отриманий вираз назад у рядок; це автоматично генерує вихідний формат з фігурними дужками. Потім Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}]друкує вихідний формат та два інші, розділені новими рядками, використовуючи прямі правила заміни рядків.

Піп , 49 46 байт

45 байт коду, +1 для -r прапора.

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

Бере вхід з stdin. Спробуйте в Інтернеті!

Пояснення

                 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

(Цей формат пояснення для мене трохи заплутаний, тому повідомте мені, якщо щось не має сенсу.)

SCALA, 590 байт

Було важко, але я думаю, що я з цим закінчився

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("]")

Швидке пояснення: я беру введення в оточенні потрійних лапок, потім знімаю непотрібні пробіли; розділити рядок два рази (один раз для рядків і один раз для стовпців); і я друкую разом із трьома рутинами. Можливо, визначити функцію для муалізації, але я не знаю як.

Спробуйте в Інтернеті!

05AB1E , 34 байти

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

Спробуйте в Інтернеті!

ε...}його замінили vy...})на TIO, оскільки його ще не витягнули.

C # (.NET Core) , 214 байт

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

Спробуйте в Інтернеті!

Приймає Матрицю як рядок, повертає три формати у вигляді однієї рядка, розділеної новими рядками.

Вугілля деревне , 38 байт

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

Спробуйте в Інтернеті! Примітка: простір. Посилання на багатослівну версію коду. Вугільне вугілля має опцію багаторядкового введення, розмежувану на ["""і """]. Пояснення:

   θ                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

Це приймає вхід і готує його, розділяючи його на рядки і нормалізуючи роздільники.

 ⪪[]{}²             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

Це обробляє [[ ... ], [ ... ]]і {{ ... }, { ... }}справи.

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

Це справляється з [ ... ; ... ] справи.

Перед тим, як я розіграв байт від вищевказаного рішення, у мене було два 39-байтних рішення; це інше:

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

Спробуйте в Інтернеті! Примітка: простір. Посилання на багатослівну версію коду. Пояснення:

  ⪪[]{}[]²                              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