J'ai écrit quelques défis liés aux matrices, et commun à tous, c'est que j'utilise un format comme celui ci-dessous pour représenter les matrices, à la fois dans les exemples et dans les cas de test:

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

Il s'agit probablement d'un format encombrant dans de nombreuses langues.

Défi:

Écrivez un programme / une fonction qui peut prendre une matrice sur la forme donnée en haut comme entrée (directement copiée / collée à partir de ce post), et sortir la même matrice sur les trois autres formats conventionnels illustrés ci-dessous .

Le format d'entrée:

Des nombres séparés par un nombre variable d'espaces et des retours à la ligne pour représenter les lignes (voir les cas de test).

• Le nombre d'espaces entre les nombres n'est pas garanti pour être cohérent. Vous pouvez cependant supposer que le dernier chiffre de chaque colonne s'aligne (si cela peut aider).
• Il peut y avoir à la fois des entiers et des flottants, et ils peuvent être positifs, négatifs ou nuls. Une matrice ne contiendra pas d'entiers et de flottants en même temps.
• Vous pouvez supposer qu'aucun nombre ne dépasse 10 caractères, y compris le point négatif et décimal pour les flottants négatifs.
• Vous pouvez supposer qu'il y a le même nombre d'entrées dans chaque ligne et dans chaque colonne.
• Il n'y aura pas de matrices d'entrée vides, mais il peut y avoir des nombres simples ou des matrices avec une seule ligne ou colonne.
  • Dans ces cas, vous pouvez choisir entre les formats de sortie affichés dans les cas de test

Votre programme / fonction doit gérer l'entrée si elle est directement copiée de ce message et collée dans l'interpréteur (STDIN ou comme argument de fonction ou quelque chose d'équivalent). Vous pouvez avoir tout ce que vous voulez (crochets, guillemets, parenthèses) devant et / ou après la matrice, mais vous devez considérer la matrice comme une séquence de caractères qui ne peut pas être modifiée (y compris les nouvelles lignes).

Pour clarifier: Supposons que votre fonction / programme est appelé fet que la matrice est:

1 -2
3  5
6  7

alors vous pouvez donner à la matrice des arguments de fonction comme celui-ci (et infiniment d'autres options):

f(1 -2
3  5
6  7)

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

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

Si votre langue ne peut, en aucune façon, prendre la matrice copier / coller comme entrée, alors je crains que vous ne deviez choisir une autre langue.

Le format de sortie:

Vous devez sortir la matrice dans les trois formats suivants (l'ordre n'a pas d'importance):

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

• Vous pouvez séparer les trois sorties comme vous le souhaitez (par exemple une nouvelle ligne)
• Vous devez sortir les nombres en utilisant la même précision que l'entrée (par exemple, vous ne devez pas couper le nombre de décimales, ni sortir les entiers sous forme de flottants).
• Les espaces sont obligatoires
• Vous devez utiliser -pour les nombres négatifs, non _ou similaires.

Cas de test:

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]

Je suis pleinement conscient de cela , mais dans ce défi, le format d'E / S encombrant est tout l'intérêt. Le défi consistera à formater la sortie dans certaines langues, tandis que la lecture de l'entrée sera la partie la plus difficile dans d'autres langues.

Ne vous découragez pas si la lecture de l'entrée est difficile, ces soumissions pourraient être les plus intéressantes. Court n'est pas nécessairement le même qu'impressionnant. Et comme toujours, les explications sont encouragées!

Rétine , 52 octets

Cette réponse est basée sur ma réponse Perl , avec l'aide de Martin Ender pour le golf avec Retina.

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

Essayez-le en ligne!

Les explications se trouvent sur ma réponse Perl. Les différences sont les suivantes:

*
[
$
]

Au lieu de s/^ *(.+)/[$1]/gmsupprimer les espaces de tête et d'ajouter des crochets autour des lignes.

^.|]$

Pour supprimer les crochets avant et arrière pour la troisième sortie.

Rétine , 57 54 octets

Le nombre d'octets suppose un codage ISO 8859-1.

m`^ +

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

Essayez-le en ligne!

Le lien TIO n'imprime actuellement aucun saut de ligne entre les trois formats, mais c'est parce qu'il utilise un commit instable. Le programme imprime les sauts de ligne intermédiaires dans Retina 0.8.2.

Explication

m`^ +

Débarrassez-vous des espaces de tête sur chaque ligne.

¶
] [

Remplacez les sauts de ligne par ] [.

 +
, 

Remplacez toutes les séries d'espaces par une virgule et un espace.

:`.+
[[$&]]

Enveloppez le tout dans [[...]]lequel se termine le premier format. Imprimez le résultat.

*T`[]`{}

Remplacez les crochets par des accolades et imprimez le résultat sans réellement changer la chaîne de travail (c'est-à-dire que le premier format est restauré après l'impression).

], .
; 

Remplacez-le ], [par un point-virgule et un saut de ligne.

^.|]$

Retirez le premier [et le dernier ]. Ceci termine le troisième format.

Scala, 183 181 149 149 octets

Essayez-le en ligne!

Nouvelle version, utilisant des Stringremplacements et des expressions régulières:

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

La nouvelle version a la même sémantique et la même utilisation que l'ancienne version utilisant split, mapet mkString.

Ancienne version, en utilisant split, mapet mkString:

Edit: classe de personnage redondante pour l'espace supprimé

(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. Exécutez dans REPL. Accepte l'entrée comme Stringparamètre entre guillemets triples , renvoie la sortie sous la forme d'un triplet des sorties requises. Le REPL rend les tuples séparés par des virgules, bordés de parenthèses.

Explication:

Nouvelle version:

Surtout la même logique que les autres réponses basées sur des expressions rationnelles, à l'exception du lookbehind difficile à gérer les espaces de début sur les lignes.

Ancienne version:

Nous divisons la représentation de la matrice d'entrée en un Stringtableau 2D , puis la mappons à un tableau 1D en réduisant les tableaux intérieurs en séparant les éléments avec ,. Enfin, nous créons simplement les différentes sorties en réduisant les tableaux 1D en utilisant les séparateurs de nouvelle ligne et les marqueurs de limite requis (préfixes et suffixes). Tout est implémenté via split(lecture), map(transformation) et mkString(effondrement).

Exemple de session 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])

Pour les cas de bord à quelques éléments, cela fournit la sortie souhaitée.

Japt , 63 53 octets

Cela arrivait à 44 octets avant de remarquer que l'espacement dans la sortie était obligatoire.

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

Essaye-le

Explication

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

69 octets de code + -p0drapeaux.

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

Essayez-le en ligne!

Explications

s/^ *(.+)/[$1]/gm;ajoute []autour de chaque ligne tout en supprimant les espaces de tête.
s/\s+/, /g;remplace les séries d'espaces et de nouvelles lignes par une virgule et un espace.
La première sortie est alors obtenue en l' entourant avec des accolades: [$_].
Le second doit remplacer les accolades par des accolades ( y/[]/{}/r) et entourer par des accolades "{" ... "}".
Pour le troisième, ], [sont remplacés par un point-virgule et un espace ( s/], \[/; /gr).

Après avoir écrit cette solution, j'ai essayé d'adapter la réponse Retina de Martin Ender, mais cela a fini par 10 octets de plus ( TryItOnline ):

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

Pour cette version, voir la réponse de Martin pour les explications.

MATL , 60 octets

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

Essayez-le en ligne!

Merci beaucoup à Luis Mendo d'avoir rasé un quart de mon bytecount dans une masterclass sur le chat.

Collez l'entrée, suivie d'une ligne vide.

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

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

Essayez-le en ligne!

Première sortie

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

Deuxième sortie

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

Troisième sortie

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

Python 2 , 143 octets

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]

Essayez-le en ligne!

Javascript (ES6), 121 110 106 octets

-15 octets grâce à @Shaggy et @Justin

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

Exemple d'extrait de code:

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 152 150 145 octets

-5 octets merci à Felipe Nardi Batista qui a suggéré l'utilisation de splats (désolé, j'ai juste besoin d'une excuse pour dire ce mot: 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],'], [','; ')

Essayez-le en ligne!

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

Format d'entrée / sortie: sortie avec un espace entre les matrices et entrée avec cet appel de fonction (comme indiqué sur TIO):

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

Voici la fonction:

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

Essayez-le en ligne!

* Sauvegardé 6 octets grâce à @officialaimm (de 169 à 163 octets).

* Sauvegardé 4 octets grâce à @FelipeNardiBatista.

Explication à venir après un nouveau golf.

C, 415 octets

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

C'est un monstre et waaayyyy trop longtemps, mais j'en ai fini avec. Aurait probablement dû opter pour une approche différente.

Essayez-le en ligne!

Deuxième cas de test | Troisième cas de test | Quatrième cas de test | Cinquième cas de test | Sixième cas de test | Septième cas de test

Gelée , 37 octets

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

Un programme complet imprimant les trois formats sur trois lignes.

Essayez-le en ligne!

Comment?

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 octets

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

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

une fonction anonyme. Prend l'entrée comme

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

Il les imprime dans le même ordre que les cas de test, mais avec des espaces comme séparateur.

Explication:

Il échange d'abord les espaces avec ,et enregistre le résultat sous y. Ensuite, il échange les sauts de ligne avec ], [, met [[et ]]à chaque extrémité, et enregistre le résultat de cela sous z.

Prochain, chartr bascule [avec {et ]avec }dansz .

Enfin, il prend y, échange de nouvelles lignes avec ;et met [et ]à chaque extrémité.

Ensuite, tous les résultats sont passés dans cet ordre dans catlequel ils sont imprimés, tous bien formatés et séparés par un seul espace.

Légèrement non golfé:

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

Java 8 avec Netbeans 8+, 209 octets

Le nombre est de 208 à partir du code, plus 1 octet pour l'exécuter en appuyant sur F6 .

Réponse lourde pour défi encombrant: 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("; ","}, {")+"}}");}}

Comment utiliser?

Dans Netbeans, collez ce code dans un fichier appelé M.java. Copiez ensuite la matrice que vous souhaitez utiliser. Puis entre les deux caractères consécutifs "", appuyez sur ctrl+v comme requis par le défi.

Maintenant, appuyez sur F6! Cela compilera le code, l'exécutera et affichera les représentations matricielles attendues.

Mathematica, 129 octets

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

Les troisième et quatrième lignes définissent ensemble une fonction pure prenant une chaîne en entrée; par exemple, si nous définissons f=Print...&, le dernier cas de test sera appelé comme:

f@"4
5"

L'extrait

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

analyse la chaîne d'entrée comme une matrice (de chaînes - nous n'essayons jamais d'interpréter les entrées comme des quantités numériques) et reconvertit l'expression résultante en chaîne; cela génère automatiquement le format de sortie avec des accolades. Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}]Imprime ensuite ce format de sortie et les deux autres, séparés par des retours à la ligne, en utilisant des règles de remplacement de chaîne simples.

Pip , 49 46 octets

45 octets de code, +1 pour l' -rindicateur.

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

Prend l'entrée de stdin. Essayez-le en ligne!

Explication

                 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

(Ce format d'explication me semble un peu compliqué, alors faites-moi savoir si quelque chose n'a pas de sens.)

SCALA, 590 octets

C'était dur, mais je pense que j'en ai fini avec ça

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

Explication rapide: je prends une entrée entourée de guillemets triples, puis je supprime les espaces non requis; diviser la chaîne deux fois (une fois pour les lignes et une fois pour les colonnes); et j'imprime avec mes trois routines. Il serait peut-être possible de définir une fonction à mutualiser, mais je ne sais pas comment.

Essayez-le en ligne!

05AB1E , 34 octets

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

Essayez-le en ligne!

ε...}a été remplacé par vy...})sur TIO car il n'y a pas encore été retiré.

C # (.NET Core) , 214 octets

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

Essayez-le en ligne!

Prend la matrice sous forme de chaîne, renvoie les trois formats sous la forme d'une chaîne unique séparée par des retours à la ligne.

Fusain , 38 octets

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

Essayez-le en ligne! Remarque: Espace de fin. Le lien est vers la version détaillée du code. Le charbon de bois a une option d'entrée multiligne délimitée à l'aide de ["""et """]. Explication:

   θ                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

Cela prend l'entrée et la prépare en la divisant en lignes et en normalisant les séparateurs.

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

Cela gère les cas [[ ... ], [ ... ]]et {{ ... }, { ... }}.

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

Cela gère la [ ... ; ... ] cas.

Avant de jouer un octet sur la solution ci-dessus, j'avais deux solutions de 39 octets; c'est l'autre:

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

Essayez-le en ligne! Remarque: Espace de fin. Le lien est vers la version détaillée du code. Explication:

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