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

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-ответе с помощью Мартина Эндера для игры в гольф с Retina.

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

Попробуйте онлайн!

Объяснения можно найти в моем ответе Perl. Различия:

*
[
$
]

Вместо того, s/^ *(.+)/[$1]/gmчтобы оба убрать начальные пробелы и добавить скобки вокруг строк.

^.|]$

Снять ведущие и конечные скобки для третьего выхода.

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

Lambda. Выполнить в REPL. Принимает входные данные в качестве параметра с тройными кавычками String, возвращает выходные данные в виде трехкратного набора требуемых выходных данных. REPL отображает кортежи, разделенные запятыми, с круглыми скобками.

Объяснение:

Новая версия:

В основном та же логика, что и в других ответах на основе регулярных выражений, за исключением хитрого взгляда сзади для обработки начальных пробелов в строках.

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

Мы разбиваем представление входной матрицы на двумерный Stringмассив, затем сопоставляем его с одномерным массивом, сворачивая внутренние массивы, разделяя элементы с помощью ,. Наконец, мы просто создаем различные выходные данные, свернув одномерные массивы, используя необходимые разделители новой строки и граничные маркеры (префиксы и суффиксы). Это все реализовано через 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).

После написания этого решения я попытался добавить ответ Retina Мартина Эндера, но он оказался на 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],'], [','; ')

Попробуйте онлайн!

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

Это чудовище и ваааыыы слишком длинные, но я с этим покончил. Наверное, должен был пойти по другому пути.

Попробуйте онлайн!

Второй контрольный пример | Третий контрольный пример | Четвертый контрольный пример | Пятый контрольный пример | Шестой контрольный пример | Седьмой контрольный пример

Желе , 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)

В , 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.

Громоздкий ответ на громоздкий вызов: 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("; ","}, {")+"}}");}}

Как пользоваться?

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

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

Mathematica, 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"; "']

Принимает ввод от стандартного ввода. Попробуйте онлайн!

объяснение

                 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

(Этот формат объяснения кажется мне немного запутанным, поэтому дайте мне знать, если что-то не имеет смысла.)

СКАЛА, 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