Ich habe einige Herausforderungen im Zusammenhang mit Matrizen geschrieben. Allen ist gemeinsam, dass ich ein Format wie das folgende verwende, um die Matrizen sowohl in Beispielen als auch in Testfällen darzustellen:

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

Dies ist wahrscheinlich ein umständliches Format in vielen Sprachen.

Herausforderung:

Schreiben Sie ein Programm / eine Funktion, die eine Matrix in der oben angegebenen Form als Eingabe annehmen kann (direktes Kopieren / Einfügen aus diesem Beitrag), und geben Sie dieselbe Matrix in allen drei anderen unten gezeigten herkömmlichen Formaten aus .

Das Eingabeformat:

Durch eine unterschiedliche Anzahl von Leerzeichen getrennte Zahlen und Zeilenumbrüche zur Darstellung von Zeilen (siehe Testfälle).

• Es kann nicht garantiert werden, dass die Anzahl der Leerzeichen zwischen den Zahlen übereinstimmt. Sie können jedoch davon ausgehen, dass die letzte Ziffer in jeder Spalte ausgerichtet ist (sofern dies hilfreich ist).
• Es kann sowohl Ganzzahlen als auch Gleitkommazahlen geben, und sie können positiv, negativ oder null sein. Eine Matrix enthält keine ganzen Zahlen und Gleitkommazahlen.
• Sie können davon ausgehen, dass keine Zahl länger als 10 Zeichen ist, einschließlich des Minus- und Dezimalpunkts für negative Gleitkommazahlen.
• Sie können davon ausgehen, dass in jeder Zeile und in jeder Spalte die gleiche Anzahl von Einträgen vorhanden ist.
• Es gibt keine leeren Eingabematrizen, aber es können einzelne Zahlen oder Matrizen mit nur einer Zeile oder Spalte vorhanden sein.
  • In diesen Fällen können Sie zwischen den in den Testfällen gezeigten Ausgabeformaten wählen

Ihr Programm / Ihre Funktion muss die Eingabe verarbeiten, wenn sie direkt aus diesem Beitrag kopiert und in den Interpreter eingefügt wird (STDIN oder als Funktionsargument oder etwas Äquivalentes). Sie können beliebig viele Zeichen (Klammern, Anführungszeichen, Klammern) vor und / oder nach der Matrix einfügen, aber Sie müssen die Matrix als Zeichenfolge betrachten, die nicht geändert werden kann (einschließlich der Zeilenumbrüche).

Zur Verdeutlichung: Angenommen, Ihre Funktion / Ihr Programm wird aufgerufen fund die Matrix lautet:

1 -2
3  5
6  7

Dann können Sie die Matrix wie folgt als Funktionsargumente angeben (und unendlich viele andere Optionen):

f(1 -2
3  5
6  7)

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

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

Wenn Ihre Sprache die kopierte / eingefügte Matrix in keiner Weise als Eingabe verwenden kann, müssen Sie leider eine andere Sprache auswählen.

Das Ausgabeformat:

Sie sollten die Matrix in den folgenden drei Formaten ausgeben (Reihenfolge spielt keine Rolle):

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

• Sie können die drei Ausgänge nach Belieben trennen (zB eine Newline)
• Sie müssen die Zahlen mit der gleichen Genauigkeit wie die Eingabe ausgeben (z. B. dürfen Sie die Anzahl der Dezimalstellen nicht kürzen und Ganzzahlen nicht als Gleitkommazahlen ausgeben).
• Die Leerzeichen sind Pflichtfelder
• Sie müssen -für negative Zahlen verwenden, nicht _oder ähnlich.

Testfälle:

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]

Ich bin voll und ganz bewusst diese , aber in dieser Herausforderung, das umständlichen E / A - Format ist der springende Punkt. Die Herausforderung besteht darin, die Ausgabe in einigen Sprachen zu formatieren, während das Lesen der Eingabe in anderen Sprachen am schwierigsten ist.

Bitte lassen Sie sich nicht entmutigen, wenn das Lesen der Beiträge schwierig ist. Diese Einsendungen könnten die interessantesten sein. Kurz ist nicht unbedingt das Gleiche wie beeindruckend. Und wie immer sind Erklärungen erwünscht!

Netzhaut , 52 Bytes

Diese Antwort basiert auf meiner Perl-Antwort mit Hilfe von Martin Ender für das Golfen mit Retina.

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

Probieren Sie es online!

Die Erklärungen finden Sie auf meiner Perl-Antwort. Die Unterschiede sind:

*
[
$
]

Anstatt s/^ *(.+)/[$1]/gmdie führenden Leerzeichen zu entfernen und Klammern um die Linien zu setzen.

^.|]$

Entfernen der vorderen und hinteren Klammern für die dritte Ausgabe.

Retina , 57-54 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

m`^ +

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

Probieren Sie es online!

Die TIO-Verbindung druckt derzeit keine Zeilenvorschübe zwischen den drei Formaten, aber das liegt daran, dass sie ein instabiles Commit verwendet. Das Programm druckt die Zwischenzeilenvorschübe in Retina 0.8.2.

Erläuterung

m`^ +

Entferne führende Leerzeichen in jeder Zeile.

¶
] [

Ersetzen Sie Zeilenvorschübe durch ] [.

 +
, 

Ersetzen Sie alle Leerzeichen durch ein Komma und ein Leerzeichen.

:`.+
[[$&]]

Wickeln Sie das Ganze in [[...]]das erste Format. Drucken Sie das Ergebnis.

*T`[]`{}

Ersetzen Sie die Klammern durch geschweifte Klammern und drucken Sie das Ergebnis aus, ohne die Arbeitszeichenfolge zu ändern (dh das erste Format wird nach dem Ausdruck wiederhergestellt).

], .
; 

Ersetzen Sie ], [durch ein Semikolon und einen Zeilenumbruch.

^.|]$

Entfernen Sie den ersten [und den letzten ]. Dies vervollständigt das dritte Format.

Scala, 183 181 149 Bytes

Probieren Sie es online!

Neue Version mit StringErsetzungen und regulären Ausdrücken:

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

Die neue Version hat die gleiche Semantik und Verwendung wie die alte Version mit split, mapundmkString .

Alte Version, mit split, mapund mkString:

Bearbeiten: Redundante Zeichenklasse für Leerzeichen entfernt

(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. In REPL ausführen. Akzeptiert die Eingabe als StringParameter in dreifachen Anführungszeichen und gibt die Ausgabe als 3-Tupel der erforderlichen Ausgaben zurück. Die REPL rendert Tupel durch Kommas getrennt und in Klammern.

Erläuterung:

Neue Version:

Meistens die gleiche Logik wie bei den anderen auf Regex basierenden Antworten, mit Ausnahme des kniffligen Aussehens, mit dem führende Leerzeichen in Zeilen behandelt werden müssen.

Alte Version:

Wir teilen die Eingabematrixdarstellung in ein 2D- StringArray auf und ordnen sie dann einem 1D-Array zu, indem wir die inneren Arrays durch Trennen der Elemente mit zusammenfalten ,. Zuletzt erstellen wir die verschiedenen Ausgaben, indem wir die 1D-Arrays mit den erforderlichen Zeilenumbrüchen und Begrenzungsmarkierungen (Präfixen und Suffixen) zusammenfassen. Es ist alles implementiert über split(Lesen), map(Transformieren) undmkString (Reduzieren) .

Beispiel für eine REPL-Sitzung:

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

Für die Fälle mit wenigen Elementkanten liefert dies die gewünschte Ausgabe.

Japt , 63 53 Bytes

Dies kam bei 44 Bytes an, bevor ich bemerkte, dass der Abstand in der Ausgabe obligatorisch war.

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

Probier es aus

Erläuterung

          :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 Byte Code + -p0Flags.

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

Probieren Sie es online!

Erklärungen

s/^ *(.+)/[$1]/gm;wird []um jede Zeile herum eingefügt, während die führenden Leerzeichen entfernt werden.
s/\s+/, /g;Ersetzt Leerzeichen und Zeilenumbrüche durch ein Komma und ein Leerzeichen.
Die erste Ausgabe wird dann durch Umgeben mit Zahnspange erhalten: [$_].
Der zweite muss die geschweiften Klammern durch geschweifte Klammern ( y/[]/{}/r) ersetzen und mit geschweiften Klammern umgeben "{" ... "}".
Beim dritten ], [werden durch ein Semikolon und ein Leerzeichen ( s/], \[/; /gr) ersetzt.

Nachdem ich diese Lösung geschrieben habe, habe ich versucht, die Retina-Antwort von Martin Ender zu übernehmen, aber sie hat sich um 10 Byte verlängert ( TryItOnline ):

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

Für diese Version siehe Martins Antwort für die Erklärungen.

MATL , 60 Bytes

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

Probieren Sie es online!

Vielen Dank an Luis Mendo für das Abschneiden eines Viertels meines Bytecount in einer Meisterklasse im Chat.

Fügen Sie die Eingabe ein, gefolgt von einer leeren Zeile.

% 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…[ÿ]=„[]„{}‡,"], ["„; :=

Probieren Sie es online!

Erste Ausgabe

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

Zweiter Ausgang

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

Dritte Ausgabe

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

Probieren Sie es online!

Javascript (ES6), 121 110 106 Bytes

-15 Bytes dank @Shaggy und @Justin

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

Beispielcode-Snippet:

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 Bytes

-5 Bytes danke an Felipe Nardi Batista, der die Verwendung von Splats vorgeschlagen hat (sorry, ich brauche nur eine Entschuldigung, um dieses Wort zu sagen: 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],'], [','; ')

Probieren Sie es online!

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

Eingabe- / Ausgabeformat: Ausgabe mit einem Leerzeichen zwischen den Matrizen und Eingabe mit diesem Funktionsaufruf (wie bei TIO gezeigt):

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

Dies ist die Funktion:

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

Probieren Sie es online!

* Dank @officialaimm wurden 6 Bytes gespeichert (von 169 auf 163 Bytes).

* 4 Bytes dank @FelipeNardiBatista gespeichert.

Erklärung nach weiterem Golfen zu kommen.

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 ist ein Monster und waaayyyy zu lang, aber ich bin damit fertig. Sollte wahrscheinlich einen anderen Ansatz gewählt haben.

Probieren Sie es online!

Zweiter Testfall | Dritter Testfall | Vierter Testfall | Fünftes Testfall | Sechstes Testfall | Siebter Testfall

Jelly , 37 Bytes

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

Ein vollständiges Programm, das die drei Formate in drei Zeilen druckt.

Probieren Sie es online!

Wie?

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[

Probieren Sie es online!

Erläuterung

ò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),']'))

Probieren Sie es online!

eine anonyme Funktion. Nimmt Eingaben wie

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

Sie werden in derselben Reihenfolge wie die Testfälle gedruckt, jedoch mit Leerzeichen als Trennzeichen.

Erläuterung:

Es tauscht zuerst die Leerzeichen mit ,und speichert das Ergebnis als y. Dann tauscht es Zeilenumbrüche mit ], [, setzt [[und ]]an beiden Enden und speichert das Ergebnis alsz .

Als nächstes wird mit und mit in chartrgewechselt[{]}z .

Schließlich nimmt y, tauscht es Zeilenumbrüche mit ;und setzt [und] an beiden Enden .

Dann werden alle Ergebnisse in dieser Reihenfolge an übergeben cat der sie ausgedruckt, alle gut formatiert und durch ein einzelnes Leerzeichen getrennt werden.

Mild ungolfed:

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

Java 8 mit Netbeans 8+, 209 Bytes

Count ist 208 aus dem Code plus 1 Byte, um ihn durch Drücken von auszuführen F6 .

Umständliche Antwort für umständliche Herausforderung: 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("; ","}, {")+"}}");}}

Wie benutzt man?

Fügen Sie diesen Code in Netbeans in eine Datei mit dem Namen ein M.java. Kopieren Sie dann die Matrix, die Sie verwenden möchten. ""Drücken Sie dann zwischen den beiden aufeinanderfolgenden Zeichen ctrl+v wie es für die Herausforderung erforderlich ist.

Drücken F6Sie jetzt ! Dadurch wird der Code kompiliert, ausgeführt und die erwarteten Matrixdarstellungen ausgegeben.

Mathematica, 129 Bytes

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

Die dritte und vierte Zeile definieren zusammen eine reine Funktion, die eine Zeichenfolge als Eingabe verwendet. Wenn wir beispielsweise festlegen f=Print...&, wird der letzte Testfall wie folgt aufgerufen:

f@"4
5"

Der Ausschnitt

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

Analysiert die Eingabezeichenfolge als Matrix (aus Zeichenfolgen - wir versuchen niemals, die Einträge als numerische Größen zu interpretieren) und konvertiert den resultierenden Ausdruck zurück in eine Zeichenfolge. Dadurch wird automatisch das Ausgabeformat mit geschweiften Klammern generiert. Anschließend werden Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}]das Ausgabeformat und die beiden anderen, durch Zeilenumbrüche getrennt, mit einfachen Regeln zum Ersetzen von Zeichenfolgen gedruckt.

Pip , 49 46 Bytes

45 Byte Code, +1 für -rFlag.

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

Übernimmt die Eingabe von stdin. Probieren Sie es online!

Erläuterung

                 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

(Dieses Erklärungsformat fühlt sich für mich etwas verworren an. Lassen Sie mich wissen, wenn etwas keinen Sinn ergibt.)

SCALA, 590 Bytes

War schwer, aber ich denke ich bin damit fertig

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

Kurze Erklärung: Ich nehme Eingaben, die von dreifachen Anführungszeichen umgeben sind, und entferne dann nicht benötigte Leerzeichen. Teilen Sie die Zeichenfolge zweimal (einmal für Zeilen und einmal für Spalten). und ich drucke mit meinen drei Routinen. Es könnte möglich sein, eine Funktion zu definieren, die sich gegenseitig beeinflussen lässt, aber ich weiß nicht wie.

Probieren Sie es online!

05AB1E , 34 Bytes

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

Probieren Sie es online!

ε...}wurde durch vy...})auf TIO ersetzt, da es dort noch nicht gezogen wurde.

C # (.NET Core) , 214 Byte

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

Probieren Sie es online!

Nimmt die Matrix als Zeichenfolge und gibt die drei Formate als einzelne Zeichenfolge zurück, die durch Zeilenumbrüche getrennt sind.

Kohle , 38 Bytes

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

Probieren Sie es online! Hinweis: Leerzeichen am Ende. Link ist eine ausführliche Version des Codes. Charcoal verfügt über eine mehrzeilige Eingabemöglichkeit, die mit begrenzt wird[""" und"""] . Erläuterung:

   θ                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

Das nimmt die Eingabe und bereitet sie vor, indem es sie in Zeilen aufteilt und die Trennzeichen normalisiert.

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

Dies behandelt die [[ ... ], [ ... ]]und{{ ... }, { ... }} Fälle .

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

Dies behandelt den [ ... ; ... ]Fall.

Bevor ich ein Byte von der obigen Lösung ablegte, hatte ich zwei 39-Byte-Lösungen; das ist der andere:

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

Probieren Sie es online! Hinweis: Leerzeichen am Ende. Link ist eine ausführliche Version des Codes. Erläuterung:

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