Tôi đã viết một vài thử thách liên quan đến ma trận và phổ biến là tôi sử dụng một định dạng như dưới đây khi biểu diễn các ma trận, cả trong ví dụ và trong các trường hợp thử nghiệm:

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

Đây có thể là một định dạng rườm rà trong nhiều ngôn ngữ.

Thử thách:

Viết chương trình / hàm có thể lấy ma trận trên biểu mẫu được đưa ra ở trên cùng làm đầu vào (sao chép / dán trực tiếp từ bài đăng này) và xuất cùng một ma trận trên cả ba định dạng thông thường khác được hiển thị bên dưới .

Định dạng đầu vào:

Các số được phân tách bằng một số lượng không gian khác nhau và dòng mới để thể hiện các hàng (xem trường hợp kiểm tra).

• Số lượng khoảng cách giữa các số không được đảm bảo là nhất quán. Tuy nhiên, bạn có thể giả sử rằng chữ số cuối cùng trong mỗi cột thẳng hàng (nếu điều đó giúp bất kỳ).
• Có thể có cả số nguyên và số float, và chúng có thể dương, âm hoặc bằng không. Một ma trận sẽ không chứa số nguyên và số float cùng một lúc.
• Bạn có thể cho rằng không có số nào dài hơn 10 ký tự, bao gồm dấu trừ và dấu thập phân cho số float âm.
• Bạn có thể giả sử rằng có cùng số lượng mục trong mỗi hàng và trong mỗi cột.
• Sẽ không có bất kỳ ma trận đầu vào trống nào, nhưng có thể có các số đơn hoặc ma trận chỉ có một hàng hoặc cột.
  • Trong các trường hợp này, bạn có thể chọn giữa các định dạng đầu ra được hiển thị trong các trường hợp thử nghiệm

Chương trình / chức năng của bạn phải xử lý đầu vào nếu nó được sao chép trực tiếp từ bài đăng này và dán vào trình thông dịch (STDIN hoặc dưới dạng đối số chức năng hoặc một cái gì đó tương đương). Bạn có thể có bất cứ điều gì bạn thích (dấu ngoặc, dấu ngoặc kép, dấu ngoặc đơn) ở phía trước và / hoặc sau ma trận, nhưng bạn phải xem ma trận là một chuỗi các ký tự không thể thay đổi (bao gồm các dòng mới).

Để làm rõ: Giả sử chức năng / chương trình của bạn được gọi fvà ma trận là:

1 -2
3  5
6  7

sau đó bạn có thể đưa ra ma trận dưới dạng đối số hàm như thế này (và vô số tùy chọn khác):

f(1 -2
3  5
6  7)

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

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

Dù sao đi nữa, nếu ngôn ngữ của bạn không thể lấy ma trận sao chép / dán làm đầu vào thì tôi sợ bạn phải chọn ngôn ngữ khác.

Định dạng đầu ra:

Bạn nên xuất ma trận theo ba định dạng sau (thứ tự không quan trọng):

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

• Bạn có thể tách ba đầu ra theo cách bạn muốn (ví dụ: một dòng mới)
• Bạn phải xuất các số bằng cách sử dụng cùng độ chính xác như đầu vào (ví dụ: bạn không được cắt bớt số thập phân, cũng không phải số nguyên đầu ra là số float).
• Các không gian là bắt buộc
• Bạn phải sử dụng -cho số âm, không _hoặc tương tự.

Các trường hợp thử nghiệm:

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]

Tôi hoàn toàn nhận thức được điều này , nhưng trong thử thách này, định dạng I / O cồng kềnh là toàn bộ vấn đề. Thách thức sẽ là tất cả về định dạng đầu ra trong một số ngôn ngữ, trong khi đọc đầu vào sẽ là phần khó nhất trong các ngôn ngữ khác.

Xin đừng nản lòng nếu đọc đầu vào khó, những bài nộp đó có thể là những bài thú vị nhất. Ngắn không nhất thiết phải giống như ấn tượng. Và như mọi khi, giải thích được khuyến khích!

Võng mạc , 52 byte

Câu trả lời này dựa trên câu trả lời Perl của tôi , với sự giúp đỡ của Martin Ender cho việc chơi golf với Retina.

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

Hãy thử trực tuyến!

Những lời giải thích có thể được tìm thấy trên câu trả lời Perl của tôi. Sự khác biệt là:

*
[
$
]

Thay vì s/^ *(.+)/[$1]/gmđể cả hai loại bỏ khoảng trắng hàng đầu và thêm dấu ngoặc quanh các dòng.

^.|]$

Để loại bỏ dấu ngoặc đứng đầu và dấu cho đầu ra thứ ba.

Võng mạc , 57 54 byte

Số lượng byte giả định mã hóa ISO 8859-1.

m`^ +

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

Hãy thử trực tuyến!

Liên kết TIO hiện không in các nguồn cấp dữ liệu giữa ba định dạng nhưng đó là vì nó sử dụng một cam kết không ổn định. Chương trình này in các nguồn cấp trung gian trong Retina 0.8.2.

Giải trình

m`^ +

Loại bỏ các không gian hàng đầu trên mỗi dòng.

¶
] [

Thay thế các nguồn cấp dữ liệu bằng ] [.

 +
, 

Thay thế tất cả các khoảng trống bằng dấu phẩy và dấu cách.

:`.+
[[$&]]

Gói toàn bộ điều trong [[...]]đó hoàn thành định dạng đầu tiên. In kết quả.

*T`[]`{}

Thay thế dấu ngoặc bằng dấu ngoặc và in kết quả mà không thực sự thay đổi chuỗi làm việc (nghĩa là định dạng đầu tiên được khôi phục sau khi được in).

], .
; 

Thay thế ], [bằng dấu chấm phẩy và linefeed.

^.|]$

Tháo đầu tiên [và cuối cùng ]. Điều này hoàn thành định dạng thứ ba.

Scala, 183 181 149 byte

Hãy thử trực tuyến!

Phiên bản mới, sử dụng Stringthay thế và biểu thức chính quy:

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

Phiên bản mới này có cùng một ngữ nghĩa và sử dụng như phiên bản cũ sử dụng split, mapvàmkString .

Phiên bản cũ, sử dụng split, mapvà mkString:

Chỉnh sửa: Lớp ký tự dự phòng cho không gian bị xóa

(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. Thực thi trong REPL. Chấp nhận đầu vào dưới dạng Stringtham số ba trích dẫn , trả về đầu ra dưới dạng 3 tuple của các đầu ra cần thiết. REPL biểu hiện các bộ dữ liệu được phân tách bằng dấu phẩy, được viền bởi dấu ngoặc đơn.

Giải trình:

Phiên bản mới:

Chủ yếu là logic tương tự như các câu trả lời dựa trên regex khác, ngoại trừ giao diện phức tạp để xử lý các khoảng trắng hàng đầu trên các dòng.

Phiên bản cũ:

Chúng tôi chia biểu diễn ma trận đầu vào thành một Stringmảng 2D , sau đó ánh xạ nó thành mảng 1D bằng cách thu gọn các mảng bên trong bằng cách tách các phần tử với ,. Cuối cùng, chúng ta chỉ cần tạo các đầu ra khác nhau bằng cách thu gọn các mảng 1D bằng cách sử dụng các dấu phân cách dòng mới và các dấu biên giới (tiền tố và hậu tố). Tất cả được thực hiện thông qua split(đọc), map(chuyển đổi) vàmkString (sụp đổ).

Ví dụ phiê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])

Đối với các trường hợp cạnh ít phần tử, điều này cung cấp đầu ra mong muốn.

Japt , 63 53 byte

Điều này đã đến ở 44 byte trước khi tôi nhận thấy rằng khoảng cách trong đầu ra là bắt buộc.

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

Kiểm tra nó

Giải trình

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

69 byte mã + -p0cờ.

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

Hãy thử trực tuyến!

Giải thích

s/^ *(.+)/[$1]/gm;thêm []xung quanh mỗi dòng trong khi loại bỏ các không gian hàng đầu.
s/\s+/, /g;thay thế các khoảng trống và dòng mới bằng dấu phẩy và dấu cách.
Đầu ra đầu tiên sau đó thu được bằng cách bao quanh bằng dấu ngoặc : [$_].
Thứ hai cần thay thế dấu ngoặc nhọn bằng dấu ngoặc nhọn ( y/[]/{}/r) và bao quanh bằng dấu ngoặc nhọn "{" ... "}".
Đối với phần ba, ], [được thay thế bằng dấu chấm phẩy và dấu cách ( s/], \[/; /gr).

Sau khi viết giải pháp này, tôi đã thử quảng cáo câu trả lời Retina của Martin Ender, nhưng nó đã kết thúc lâu hơn 10 byte ( TryItOnline ):

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

Đối với phiên bản này, xem câu trả lời của Martin cho các giải thích.

MATL , 60 byte

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

Hãy thử trực tuyến!

Cảm ơn Luis Mendo rất nhiều vì đã loại bỏ một phần tư số tiền của tôi trong một lớp học trò chuyện.

Dán đầu vào, theo sau là một dòng trống.

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

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

Hãy thử trực tuyến!

Đầu ra đầu tiên

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

Đầu ra thứ hai

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

Đầu ra thứ ba

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

Python 2 , 143 byte

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]

Hãy thử trực tuyến!

Javascript (ES6), 121 110 106 byte

-15 byte nhờ @Shaggy và @Justin

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

Đoạn mã ví dụ:

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

Con trăn 2 , 163 152 150 145 byte

-5 byte nhờ Felipe Nardi Batista, người đã đề xuất sử dụng splat (xin lỗi, tôi chỉ cần một cái cớ để nói từ đó: 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],'], [','; ')

Hãy thử trực tuyến!

Con trăn 3 , 184 178 174 173 169 163 * 157 * 153 byte

Định dạng đầu vào / đầu ra: Đầu ra có khoảng trắng giữa các ma trận và đầu vào với lệnh gọi hàm này (như được hiển thị trên TIO):

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

Đây là chức năng:

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

Hãy thử trực tuyến!

* Đã lưu 6 byte nhờ @officialaimm (từ 169 đến 163 byte).

* Đã lưu 4 byte nhờ @FelipeNardiBatista.

Giải thích để đến sau khi chơi golf.

C, 415 byte

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

Nó là một con quái vật và waaayyyy quá lâu, nhưng tôi đã hoàn thành nó. Có lẽ nên đi cho một cách tiếp cận khác nhau có lẽ.

Hãy thử trực tuyến!

Trường hợp thử nghiệm thứ hai | Trường hợp thử nghiệm thứ ba | Trường hợp thử nghiệm thứ tư | Trường hợp thử nghiệm thứ năm | Trường hợp thử nghiệm thứ sáu | Trường hợp thử nghiệm thứ bảy

Thạch , 37 byte

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

Một chương trình đầy đủ in ba định dạng trên ba dòng.

Hãy thử trực tuyến!

Làm sao?

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 byte

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

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

một chức năng ẩn danh. Có đầu vào như

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

Nó in chúng theo thứ tự giống như các trường hợp thử nghiệm, nhưng với khoảng trắng là dấu phân cách.

Giải trình:

Nó đầu tiên hoán đổi không gian với ,và lưu kết quả như y. Sau đó, nó hoán đổi các dòng mới với ], [, đặt [[và ]]ở hai đầu và lưu kết quả của nó như làz .

Tiếp theo, chartrchuyển đổi [với {và ]với }trongz .

Cuối cùng, phải mất y, hoán đổi các dòng mới với ;và đặt [và] ở một trong hai đầu.

Sau đó, tất cả các kết quả được thông qua theo thứ tự đó để cat in ra, tất cả được định dạng độc đáo và được phân tách bằng một khoảng trắng.

Nhẹ nhàng vô duyên:

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

Java 8 với Netbeans 8+, 209 byte

Đếm là 208 từ mã, cộng với 1 byte để chạy mã bằng cách nhấn F6 .

Câu trả lời rườm rà cho thử thách rườm rà: 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("; ","}, {")+"}}");}}

Sử dụng như thế nào?

Trong Netbeans, dán mã này vào một tệp có tên M.java. Sau đó sao chép ma trận bạn muốn sử dụng. Sau đó, giữa hai ký tự liên tiếp "", nhấn ctrl+v theo yêu cầu của thử thách.

Bây giờ hãy nhấn F6! Điều này sẽ biên dịch mã, chạy nó và xuất các biểu diễn ma trận dự kiến.

Toán học, 129 byte

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

Các dòng thứ ba và thứ tư cùng nhau xác định một hàm thuần túy lấy một chuỗi làm đầu vào; ví dụ: nếu chúng ta đặt f=Print...&, thì trường hợp thử nghiệm cuối cùng sẽ được gọi là:

f@"4
5"

Đoạn trích

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

phân tích chuỗi đầu vào dưới dạng ma trận (của chuỗi, chúng tôi không bao giờ cố gắng diễn giải các mục dưới dạng đại lượng số) và chuyển đổi biểu thức kết quả trở lại thành chuỗi; điều này tự động tạo ra định dạng đầu ra với dấu ngoặc nhọn. Sau đó Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}]in định dạng đầu ra đó và hai định dạng khác, được phân tách bằng các dòng mới, bằng cách sử dụng các quy tắc thay thế chuỗi đơn giản.

Pip , 49 46 byte

45 byte mã, +1 cho -rcờ.

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

Lấy đầu vào từ stdin. Hãy thử trực tuyến!

Giải trình

                 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

(Định dạng giải thích này cảm thấy hơi phức tạp với tôi, vì vậy hãy cho tôi biết nếu có bất cứ điều gì không có ý nghĩa.)

SCALA, 590 byte

Thật khó khăn, nhưng tôi nghĩ rằng tôi đã hoàn thành nó

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

Giải thích nhanh: Tôi lấy đầu vào được bao quanh bởi ba dấu ngoặc kép, sau đó bỏ đi các khoảng trống không được yêu cầu; chia chuỗi hai lần (một lần cho các dòng và một lần cho các cột); và tôi in với ba thói quen của tôi. Có thể xác định một chức năng để tương tác, nhưng tôi không biết làm thế nào.

Hãy thử trực tuyến!

05AB1E , 34 byte

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

Hãy thử trực tuyến!

ε...}đã được thay thế bằng vy...})trên TIO vì nó chưa được kéo đến đó.

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

Hãy thử trực tuyến!

Lấy Ma trận dưới dạng một chuỗi, trả về ba định dạng dưới dạng một chuỗi được phân tách bằng các dòng mới.

than củi , 38 byte

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

Hãy thử trực tuyến! Lưu ý: Không gian lưu trữ. Liên kết là phiên bản dài dòng của mã. Than có một tùy chọn đầu vào đa dòng được phân định bằng cách sử dụng ["""và """]. Giải trình:

   θ                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

Điều này nhận đầu vào và chuẩn bị nó bằng cách chia nó thành các dòng và bình thường hóa các dải phân cách.

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

Điều này xử lý [[ ... ], [ ... ]]và {{ ... }, { ... }}các trường hợp.

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

Điều này xử lý [ ... ; ... ] trường hợp.

Trước khi tôi đánh một byte ra khỏi giải pháp trên, tôi đã từng có hai giải pháp 39 byte; cái này khác

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

Hãy thử trực tuyến! Lưu ý: Không gian lưu trữ. Liên kết là phiên bản dài dòng của mã. Giải trình:

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