He escrito algunos desafíos relacionados con las matrices, y común para todos es que utilizo un formato como el siguiente cuando represento las matrices, tanto en ejemplos como en casos de prueba:

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

Este es probablemente un formato engorroso en muchos idiomas.

Desafío:

Escriba un programa / función que pueda tomar una matriz en la forma dada en la parte superior como entrada (directamente copiada / pegada de esta publicación), y genere la misma matriz en los otros tres formatos convencionales que se muestran a continuación .

El formato de entrada:

Números separados por un número variable de espacios y nuevas líneas para representar filas (ver casos de prueba).

• No se garantiza que el número de espacios entre números sea consistente. Sin embargo, puede suponer que el último dígito en cada columna se alinea (si eso ayuda a alguno).
• Puede haber enteros y flotantes, y pueden ser positivos, negativos o cero. Una matriz no contendrá enteros y flotantes al mismo tiempo.
• Puede suponer que ningún número tiene más de 10 caracteres, incluidos el punto negativo y el decimal para flotantes negativos.
• Puede suponer que hay el mismo número de entradas en cada fila y en cada columna.
• No habrá matrices de entrada vacías, pero puede haber números únicos o matrices con solo una fila o columna.
  • En estos casos, puede elegir entre los formatos de salida que se muestran en los casos de prueba

Su programa / función debe manejar la entrada si se copia directamente de esta publicación y se pega en el intérprete (STDIN o como argumento de función o algo equivalente). Puede tener lo que quiera (corchetes, comillas, paréntesis) delante y / o después de la matriz, pero debe considerar la matriz como una secuencia de caracteres que no se pueden alterar (que incluye las nuevas líneas).

Para aclarar: suponga que se llama a su función / programa fy que la matriz es:

1 -2
3  5
6  7

entonces puede dar la matriz como argumentos de función como este (y muchas otras opciones infinitas):

f(1 -2
3  5
6  7)

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

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

Si su idioma no puede, de ninguna manera, tomar la matriz copiada / pegada como entrada, entonces me temo que debe elegir otro idioma.

El formato de salida:

Debe generar la matriz en los siguientes tres formatos (el orden no importa):

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

• Puede separar las tres salidas como desee (por ejemplo, una nueva línea)
• Debe generar los números con la misma precisión que la entrada (por ejemplo, no debe recortar el número de decimales, ni generar enteros como flotantes).
• Los espacios son obligatorios.
• Debe usar -para números negativos, no _o similares.

Casos de prueba:

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]

Soy plenamente consciente de esto , pero en este desafío, el formato de E / S engorroso es el punto. El desafío consistirá en formatear la salida en algunos idiomas, mientras que leer la entrada será la parte más difícil en otros idiomas.

No se desanime si leer la entrada es difícil, esas presentaciones pueden ser las más interesantes. Corto no es necesariamente lo mismo que impresionante. Y como siempre, ¡se alientan las explicaciones!

Retina , 52 bytes

Esta respuesta se basa en mi respuesta de Perl , con la ayuda de Martin Ender para el golf con Retina.

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

Pruébalo en línea!

Las explicaciones se pueden encontrar en mi respuesta de Perl. Las diferencias son:

*
[
$
]

En lugar de s/^ *(.+)/[$1]/gmeliminar ambos espacios iniciales y agregar corchetes alrededor de las líneas.

^.|]$

Para eliminar los corchetes iniciales y finales para la tercera salida.

Retina , 57 54 bytes

El recuento de bytes supone la codificación ISO 8859-1.

m`^ +

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

Pruébalo en línea!

El enlace TIO actualmente no imprime avances de línea entre los tres formatos, pero eso se debe a que utiliza una confirmación inestable. El programa imprime los avances de línea intermedios en Retina 0.8.2.

Explicación

m`^ +

Deshágase de los espacios iniciales en cada línea.

¶
] [

Reemplace los avances de línea con ] [.

 +
, 

Reemplace todas las carreras de espacios con una coma y un espacio.

:`.+
[[$&]]

Envuelva todo en el [[...]]que completa el primer formato. Imprime el resultado.

*T`[]`{}

Reemplace los corchetes con llaves e imprima el resultado sin cambiar realmente la cadena de trabajo (es decir, el primer formato se restaura después de que se imprime).

], .
; 

Reemplace ], [con un punto y coma y un salto de línea.

^.|]$

Eliminar el primero [y el último ]. Esto completa el tercer formato.

Scala, 183 181 149 bytes

Pruébalo en línea!

Nueva versión, utilizando Stringreemplazos y expresiones regulares:

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

La nueva versión tiene la misma semántica y uso que la versión anterior split, mapymkString .

Versión anterior, usando split, mapymkString :

Editar: clase de caracteres redundantes para el espacio eliminado

(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 Ejecutar en REPL. Acepta entradas como comillas triplesString parámetro con , devuelve la salida como una 3-tupla de las salidas requeridas. El REPL representa tuplas separadas por comas, delimitadas por paréntesis.

Explicación:

Nueva versión:

En su mayoría, la misma lógica que las otras respuestas basadas en expresiones regulares, excepto por la complicada mirada hacia atrás para manejar los espacios iniciales en las líneas.

Versión antigua:

Dividimos la representación de la matriz de entrada en una Stringmatriz 2D , luego la asignamos a una matriz 1D al contraer las matrices internas separando los elementos con ,. Finalmente, simplemente creamos las diferentes salidas al contraer las matrices 1D usando los separadores de línea nueva y los marcadores de límite (prefijos y sufijos). Todo se implementa a través de split(lectura), map(transformación) y mkString(colapso).

Ejemplo de sesión 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])

Para los casos extremos de pocos elementos, esto proporciona el resultado deseado.

Japt , 63 53 bytes

Esto llegaba a 44 bytes antes de notar que el espacio en la salida era obligatorio.

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

Pruébalo

Explicación

          :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 bytes

69 bytes de código + -p0banderas.

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

Pruébalo en línea!

Explicaciones

s/^ *(.+)/[$1]/gm;agrega []alrededor de cada línea mientras elimina los espacios iniciales.
s/\s+/, /g;reemplaza series de espacios y líneas nuevas con una coma y un espacio.
La primera salida se obtiene entonces por circundante con los apoyos: [$_].
El segundo necesita reemplazar las llaves con una llave ( y/[]/{}/r) y rodear con llaves "{" ... "}".
Para el tercero, ], [se reemplaza con un punto y coma y un espacio ( s/], \[/; /gr).

Después de escribir esta solución, intenté adaptar la respuesta Retina de Martin Ender, pero terminó 10 bytes más ( TryItOnline ):

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

Para esta versión, vea la respuesta de Martin para las explicaciones.

MATL , 60 bytes

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

Pruébalo en línea!

Muchas gracias a Luis Mendo por eliminar una cuarta parte de mi bytecount en una clase magistral en el chat.

Pegue la entrada, seguida de una línea vacía.

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

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

Pruébalo en línea!

Primera salida

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

Segunda salida

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

Tercera salida

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

Python 2 , 143 bytes

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]

Pruébalo en línea!

Javascript (ES6), 121 110 106 bytes

-15 bytes gracias a @Shaggy y @Justin

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

Fragmento de código de ejemplo:

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

Pitón 2 , 163 152 150 145 bytes

-5 bytes gracias a Felipe Nardi Batista que sugirió el uso de símbolos (lo siento, solo necesito una excusa para decir esa palabra: 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],'], [','; ')

Pruébalo en línea!

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

Formato de entrada / salida: Salida con un espacio entre las matrices y entrada con esta llamada de función (como se muestra en TIO):

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

Esta es la función:

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

Pruébalo en línea!

* * Guardado 6 bytes gracias a @officialaimm (de 169 a 163 bytes).

* Guardado 4 bytes gracias a @FelipeNardiBatista.

Explicación por venir después de más golf.

C, 415 bytes

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

Es un monstruo y muuuy largo tiempo, pero ya terminé. Debería haber optado por un enfoque diferente probablemente.

Pruébalo en línea!

Segundo caso de prueba | Tercer caso de prueba | Cuarto caso de prueba | Quinto caso de prueba | Sexto caso de prueba | Séptimo caso de prueba

Jalea , 37 bytes

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

Un programa completo que imprime los tres formatos en tres líneas.

Pruébalo en línea!

¿Cómo?

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 bytes

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

Pruébalo en línea!

Explicación

ò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 bytes

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

Pruébalo en línea!

Una función anónima. Toma entrada como

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

Los imprime en el mismo orden que los casos de prueba, pero con espacios como separador.

Explicación:

Primero intercambia espacios con ,y guarda el resultado como y. Luego intercambia líneas nuevas con ], [, pone [[y ]]en cualquier extremo, y guarda el resultado de eso comoz .

A continuación, chartrcambia [con {y ]con }in z.

Finalmente, toma y, intercambia nuevas líneas con ;y pone [y ]en cualquier extremo.

Luego, todos los resultados se pasan en ese orden a cat que los imprime, todos con un formato agradable y separados por un solo espacio.

Ligeramente no golfista:

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

Java 8 con Netbeans 8+, 209 bytes

El recuento es 208 del código, más 1 bytes para ejecutarlo presionando F6 .

Respuesta engorrosa para el desafío engorroso: 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("; ","}, {")+"}}");}}

¿Cómo utilizar?

Dentro de Netbeans, pegue este código en un archivo llamado M.java. Luego copie la matriz que desea usar. Luego, entre los dos caracteres consecutivos "", presione ctrl+ vsegún lo requiera el desafío.

Ahora presiona F6! Esto compilará el código, lo ejecutará y generará las representaciones de matriz esperadas.

Mathematica, 129 bytes

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

Las líneas tercera y cuarta juntas definen una función pura que toma una cadena como entrada; por ejemplo, si establecemos f=Print...&, el último caso de prueba se llamaría como:

f@"4
5"

El fragmento

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

analiza la cadena de entrada como una matriz (de cadenas; nunca intentamos interpretar las entradas como cantidades numéricas) y convierte la expresión resultante nuevamente en una cadena; Esto genera automáticamente el formato de salida con llaves. Luego Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}]imprime ese formato de salida y los otros dos, separados por líneas nuevas, mediante el uso de reglas sencillas de reemplazo de cadenas.

Pip , 49 46 bytes

45 bytes de código, +1 para -rbandera.

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

Toma información de stdin. Pruébalo en línea!

Explicación

                 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

(Este formato de explicación me parece un poco complicado, así que avíseme si algo no tiene sentido).

SCALA, 590 bytes

Fue difícil, pero creo que ya terminé

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

Explicación rápida: tomo la entrada rodeada de comillas triples, luego elimino los espacios no requeridos; dividir la cadena dos veces (una vez para líneas y otra para columnas); e imprimo con mis tres rutinas. Podría ser posible definir una función para mutualizar, pero no sé cómo.

Pruébalo en línea!

05AB1E , 34 bytes

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

Pruébalo en línea!

ε...}ha sido reemplazado vy...})por TIO ya que aún no se ha extraído allí.

C # (.NET Core) , 214 bytes

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

Pruébalo en línea!

Toma la matriz como una cadena, devuelve los tres formatos como una sola cadena separada por nuevas líneas.

Carbón , 38 bytes

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

Pruébalo en línea! Nota: espacio final. El enlace es a la versión detallada del código. El carbón tiene una opción de entrada multilínea delimitada usando ["""y """]. Explicación:

   θ                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

Esto toma la entrada y la prepara dividiéndola en líneas y normalizando los separadores.

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

Esto maneja los casos [[ ... ], [ ... ]]y {{ ... }, { ... }}.

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

Esto maneja el [ ... ; ... ] caso.

Antes de jugar un byte con la solución anterior, solía tener dos soluciones de 39 bytes; este es el otro:

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

Pruébalo en línea! Nota: espacio final. El enlace es a la versión detallada del código. Explicación:

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