나는 행렬과 관련된 몇 가지 과제를 작성 했으며 모두에게 공통적 인 점은 예제와 테스트 사례 모두에서 행렬을 나타낼 때 아래 형식과 같은 형식을 사용한다는 것입니다.

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

이것은 많은 언어에서 번거로운 형식 일 수 있습니다.

도전:

상단에 입력 된 형태 (이 게시물에서 직접 복사 / 붙여 넣기)로 주어진 형식으로 행렬을 취할 수있는 프로그램 / 함수를 작성하고 아래에 표시된 세 가지 다른 기존 형식 모두에서 동일한 행렬을 출력하십시오 .

입력 형식 :

다양한 수의 공백으로 구분 된 숫자와 행을 나타내는 줄 바꿈 (테스트 사례 참조).

• 숫자 사이의 공백 수는 일관성이 보장되지 않습니다. 그러나 각 열의 마지막 숫자가 정렬되어 있다고 가정 할 수 있습니다 (만약 도움이되는 경우).
• 정수와 부동 소수점이 모두있을 수 있으며 양수, 음수 또는 0 일 수 있습니다. 행렬에는 정수 와 부동 소수점이 동시에 포함되지 않습니다 .
• 음수 부동 소수점의 마이너스 및 소수점을 포함하여 10자를 넘지 않는 것으로 가정 할 수 있습니다.
• 각 행과 각 열에 동일한 수의 항목이 있다고 가정 할 수 있습니다.
• 빈 입력 행렬은 없지만 단일 숫자 또는 행이나 열이 하나 뿐인 행렬이있을 수 있습니다.
  • 이 경우 테스트 사례에 표시된 출력 형식 중에서 선택할 수 있습니다.

이 게시물에서 직접 복사하여 인터프리터에 붙여 넣은 경우 프로그램 / 함수는 입력을 처리해야합니다 (STDIN 또는 함수 인수 또는 이와 동등한 것으로). 행렬 앞뒤에 원하는 것을 사용할 수 있지만 (괄호, 인용 부호, 괄호) 행렬 앞에는 변경할 수없는 문자 (줄 바꿈 포함)를 고려해야합니다.

명확히하기 위해 : 함수 / 프로그램이 호출 f되고 행렬이 다음과 같다고 가정하십시오 .

1 -2
3  5
6  7

그런 다음 행렬을 다음과 같은 함수 인수로 제공 할 수 있습니다.

f(1 -2
3  5
6  7)

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

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

언어가 어떤 식 으로든 복사 / 붙여 넣기 매트릭스를 입력으로 사용할 수 없다면 다른 언어를 선택해야합니다.

출력 형식 :

다음 세 가지 형식으로 행렬을 출력해야합니다 (순서는 중요하지 않음).

[[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]]
{{16, 2, 3, 13}, {5, 11, 10, 8}, {9, 7, 6, 12}, {4, 14, 15, 1}}
[16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1]

• 원하는대로 세 개의 출력을 분리 할 수 ​​있습니다 (예 : 줄 바꿈)
• 입력과 동일한 정밀도를 사용하여 숫자를 출력해야합니다 (예를 들어, 소수를 자르거나 출력 정수를 부동 수로 트리밍해서는 안 됨).
• 공간은 필수입니다
• -음수가 아니 _거나 비슷한 음수에 사용해야합니다 .

테스트 사례 :

16    2    3   13
 5   11   10    8
 9    7    6   12
 4   14   15    1
----
[[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]]
{{16, 2, 3, 13}, {5, 11, 10, 8}, {9, 7, 6, 12}, {4, 14, 15, 1}}
[16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1]

0.14778   0.27114   0.24415
0.45997   0.12287   0.67470
0.28945   0.37928   0.51887
----
[[0.14778, 0.27114, 0.24415], [0.45997, 0.12287, 0.6747], [0.28945, 0.37928, 0.51887]]
{{0.14778, 0.27114, 0.24415}, {0.45997, 0.12287, 0.6747}, {0.28945, 0.37928, 0.51887}}
[0.14778, 0.27114, 0.24415; 0.45997, 0.12287, 0.6747; 0.28945, 0.37928, 0.51887]

-0.0398301   0.2403455  -0.2253368   0.3565870   0.0605803   0.0830780
-0.3254422  -0.1185191  -0.2989537   0.1647319   0.3621135   0.2018815
-0.0022281  -0.3362287  -0.3568447   0.4419063   0.3801872  -0.2847033
---
[[-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780], [-0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815], [-0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033],]
{{-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780}, {-0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815}, {-0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033},}
[-0.0398301, 0.2403455, -0.2253368, 0.3565870, 0.0605803, 0.0830780; -0.3254422, -0.1185191, -0.2989537, 0.1647319, 0.3621135, 0.2018815; -0.0022281, -0.3362287, -0.3568447, 0.4419063, 0.3801872, -0.2847033]

0       4       1       0
0       0      -6       0
0       1       4      -3
2       0       0       8
0       0       0       0
----
[[0, 4, 1, 0], [0, 0, -6, 0], [0, 1, 4, -3], [2, 0, 0, 8], [0, 0, 0, 0]]
{{0, 4, 1, 0}, {0, 0, -6, 0}, {0, 1, 4, -3}, {2, 0, 0, 8}, {0, 0, 0, 0}}
[0, 4, 1, 0; 0, 0, -6, 0; 0, 1, 4, -3; 2, 0, 0, 8; 0, 0, 0, 0]

1
----
[1]     (or [[1]])
{1}     (or {{1}})
[1]     (or 1)

1 2
----
[1, 2]  (or [[1, 2]])
{1, 2}  (or {{1, 2}})
[1, 2]

4
5
----
[[4], [5]]
{{4}, {5}}
[4; 5]

나는 이것을 완전히 알고있다 있지만,이 도전에서 성가신 I / O 형식이 요점입니다. 일부 언어에서는 출력 형식을 지정해야하는 반면, 입력을 읽는 것이 다른 언어에서는 가장 어려운 부분입니다.

입력을 읽는 것이 어려운 경우에는 실망하지 마십시오. 이러한 제출은 가장 흥미로운 제출일 수 있습니다. 쇼트는 반드시 인상적인 것과 같을 필요는 없습니다. 그리고 항상 그렇듯이 설명이 권장됩니다!

레티 나 , 52 바이트

이 답변은 내 Perl 답변을 기반으로 하며 Retina와의 골프를 위해 Martin Ender 의 도움을 받았습니다.

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

온라인으로 사용해보십시오!

설명은 내 Perl 답변에서 찾을 수 있습니다. 차이점은 다음과 같습니다.

*
[
$
]

s/^ *(.+)/[$1]/gm선행 공백을 제거하고 선 주위에 대괄호를 추가하는 대신 .

^.|]$

세 번째 출력에서 ​​선행 및 후행 괄호를 제거합니다.

망막 , 57 54 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

m`^ +

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

온라인으로 사용해보십시오!

TIO 링크는 현재 세 가지 형식 사이에 줄 바꿈을 인쇄하지 않지만 불안정한 커밋을 사용하기 때문입니다. 이 프로그램은 Retina 0.8.2의 중간 줄 바꿈을 인쇄합니다.

설명

m`^ +

각 줄에서 선행 공백을 제거하십시오.

¶
] [

줄 바꿈을로 바꿉니다 ] [.

 +
, 

모든 공백을 쉼표와 공백으로 바꿉니다.

:`.+
[[$&]]

[[...]]첫 번째 형식을 완성 하는 모든 것을 감싸십시오 . 결과를 인쇄하십시오.

*T`[]`{}

대괄호를 중괄호로 바꾸고 실제로 작업 문자열을 변경하지 않고 결과를 인쇄하십시오 (즉, 첫 번째 형식이 인쇄 된 후 복원됩니다).

], .
; 

], [세미콜론과 줄 바꿈으로 교체하십시오 .

^.|]$

첫 번째 [와 마지막을 제거하십시오 ]. 이것으로 세 번째 형식이 완성되었습니다.

스칼라, 183 (181) 149 바이트

온라인으로 사용해보십시오!

String대체 및 정규식을 사용하는 새 버전 :

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

새 버전은 이전 버전과 동일한 의미 및 사용법을 사용합니다. split , map그리고mkString .

이전 버전 split , map및 mkString:

편집 : 공백에 대한 중복 문자 클래스 제거

(x:String)=>{val d=x.split("\n").map(_.trim.split(" +").mkString(", "));(d.map(x=>s"[$x]").mkString("[",", ","]"),d.map(x=>s"{$x}").mkString("{",", ","}"),d.mkString("[","; ","]"))}

람다. REPL에서 실행하십시오. 입력을 3 중 인용 String매개 변수 로 승인하고 출력을 필요한 출력의 3 튜플로 리턴합니다. REPL은 튜플을 쉼표로 구분하고 괄호로 묶습니다.

설명:

새로운 버전:

대부분의 다른 정규식 기반 답변과 동일한 논리이지만 행의 선행 공백을 처리하는 까다로운 모양을 제외하고.

구 버전:

입력 행렬 표현을 2D String배열 로 분할 한 다음 요소를로 분리하여 내부 배열을 축소하여 1D 배열에 매핑합니다 ,. 마지막으로 필요한 줄 바꿈 구분자와 경계 표시 (접두사 및 접미사)를 사용하여 1D 배열을 축소하여 다른 출력을 만듭니다. 그것은 split(읽기), map(변형) 및mkString (축소) .

REPL 세션 예 :

scala> val r=(x:String)=>{val d=x.split("\n").map(_.trim.split(" +").mkString(", "));(d.map(x=>s"[$x]").mkString("[",", ","]"),d.map(x=>s"{$x}").mkString("{",", ","}"),d.mkString("[","; ","]"))}

scala> r("""16    2    3   13
     |  5   11   10    8
     |  9    7    6   12
     |  4   14   15    1""")
res12: (String, String, String) = ([[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]],{{16, 2, 3, 13}, {5, 11, 10, 8}, {9, 7, 6, 12}, {4, 14, 15, 1}},[16, 2, 3, 13; 5, 11, 10, 8; 9, 7, 6, 12; 4, 14, 15, 1])

요소가 적은 경우에는 원하는 출력을 제공합니다.

apt , 63 53 바이트

출력의 간격이 필수임을 알기 전에 44 바이트로 들어 왔습니다.

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

그것을 테스트

설명

          :Implicit input of string U
·         :Split to an array on newlines.
®         :Map over the array.
¸         :Split each element to an array on spaces.
f         :Filter to remove empty elements from the subarrays.
"[[       :Start building the output string. In Japt strings, anything enclosed in {}s will be evaluated before being added to the string.
{q"],["}  :Join the array to a string using ],[ The sub-arrays will be cast to comma separated strings in the process.
]]        :That's the first line done.
\{\{      :The start of the second line. A few bytes have to be sacrificed to esapce the {s
{q"},\{"} :Join the array to a string using },{
}}        :That's the second line done.
[         :And on to the last line.
{q';}     :This time we join the array with a semi-colon.
]"        :And that's the string completed.
r         :Except we still need to replace...
",|;"     :  All occurrences of a comma or a semi-colon with...
_+S       :  Itself and a space.
          :Implicit output of resulting string.

펄 5 , 71 바이트

코드 69 바이트 + -p0 플래그.

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

온라인으로 사용해보십시오!

설명

s/^ *(.+)/[$1]/gm;[]선행 공백을 제거하면서 각 줄을 추가 합니다.
s/\s+/, /g;공백과 개행을 쉼표와 공백으로 바꿉니다.
그런 다음 중괄호로 묶어 첫 번째 출력을 얻습니다 [$_].
두 번째는 중괄호를 중괄호 ( y/[]/{}/r) 로 바꾸고 서라운드를 중괄호로 바꿔야 "{" ... "}"합니다.
세 번째 ], [는 세미콜론과 공백 (s/], \[/; /gr ) .

이 솔루션을 작성한 후 Martin Ender의 Retina 답변을 수정하려고 시도했지만 10 바이트 더 길어졌습니다 ( TryItOnline ).

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

이 버전 에 대한 설명 은 Martin의 답변 을 참조하십시오 .

MATL , 60 바이트

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

온라인으로 사용해보십시오!

채팅에서 마스터 클래스에서 내 바이트 수의 4 분의 1을 깎아 준 Luis Mendo에게 감사드립니다.

입력 내용을 붙여 넣은 다음 빈 줄을 붙여 넣습니다.

% Act I: Taking input.

`jt             w]    % Take input line by line until an empty line is encountered.
   U                  % Convert string input to numerical row array
    &D                % Convert back to string, adding brackets and single spaces
      32', 'XHYX      % Add commas before the spaces. Store ',  ' in clipboard H.


% Act II: Nested square brackets

x                     % Discard the tab character
 Xh                   % Concatenate all strings as cell array.
   H&Zc               % Join all the strings together, using clipboard H as a separator
       91wh93h        % Wrap in square brackets (ASCII 91 and 93)
              tD      % Display a copy of the result.

% Act III: Nested curly brackets

[]&D{}&D              % Convert empty array and cell array to string.
        XE            % Use to substitute square for curly brackets.

% Act IV: MATLAB-style input.

&Gxv                  % Get all the input again, discard the tab, and concatenate vertically.
    U                 % Convert to numerical 
     &4$     TD       % Convert to string, using row- and column separators
        H'; '         % Namely, clipboard H and a semicolon.

05AB1E ,  45  44 바이트

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

온라인으로 사용해보십시오!

첫 번째 출력

|                           # push a list of the inputs
 „  ð:                      # replace any instance of 2 spaces with 1 space
      ðδÛ                   # remove any leading spaces
         ˜                  # flatten to a 1D list
          ð¡                # split on spaces
            „, ý            # merge on ", "
                ''K         # remove all single quotes
                   D        # duplicate for use in output 3
                    …[ÿ]    # interpolate between square brackets
                        =   # print without popping 

두 번째 출력

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

세 번째 출력

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

파이썬 2 , 143 바이트

import re
b=re.sub
def f(s):s='[['+b('\n','], [',b(' +',', ',b('\n +','\n',s)))+']]';print s,b('\[','{',b('\]','}',s)),b('\], \[','; ',s)[1:-1]

온라인으로 사용해보십시오!

자바 (ES6) 121 110 106 바이트

@Shaggy 및 @Justin 덕분에 -15 바이트

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

코드 스 니펫 예제 :

f=
m=>`[[${(a=m.split`
`.map(x=>x.match(/\S+/g).join`, `)).join`], [`}]]
{{${a.join`}, {`}}}
[${a.join`; `}]`
console.log(f(
`1 -2
 3  5
 6  7`
))

파이썬 (2) , 163 (152) 150 145 바이트

표시를 사용하도록 제안한 Felipe Nardi Batista에게 -5 바이트 덕분에 죄송합니다 (죄송 합니다만, 그 단어 : P라고 말하면됩니다).

import re
a=str.replace
def f(s):r=a(`[re.findall('[\.\d]+',i)for i in s.split('\n')]`,"'",'');print r,a(a(r,*']}'),*'[{'),a(r[1:-1],'], [','; ')

온라인으로 사용해보십시오!

파이썬 3 , 1841781741773169163 * 157 * 153 바이트

입출력 형식 : 이 함수 호출을 사용하여 매트릭스와 입력 사이에 공백이있는 출력 (TIO에 표시됨) :

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

이것은 기능입니다 :

def g(s,r=str.replace):a=str([[[int,float]['.'in y](y)for y in x.split()]for x in s.split('\n')]);print(a,r(r(a,*'[{'),*']}'),'['+r(a,'], [','; ')[2:-1])

온라인으로 사용해보십시오!

* 저장된 @officialaimm 6 행 (169 내지 163 바이트)에서 확실히 바이트.

* @FelipeNardiBatista 덕분에 4 바이트가 절약되었습니다.

추가 골프 후 올 설명.

C, 415 바이트

#import<stdio.h>
#define A(a,c,o)for(l=strlen(a)-o,k=0;c[k];)a[l+k]=c[k++];
j,k,l;main(i){char s[999],a[999]="[",b[999]="{",c[999]="[",t[]=" ";for(;fgets(s,999,stdin);){A(b,"{",0)A(a,"[",0)for(i=0;s[i];++i){j=0;for(;s[i]-32&&s[i]-10&&s[i];++i){j=1;t[0]=s[i];A(c,t,0)A(b,t,0)A(a,t,0)}if(j){A(c,", ",0)A(b,", ",0)A(a,", ",0)}}A(c,"; ",2)A(b,"}, ",2)A(a,"], ",2)}A(c,"]",2)A(b,"}",2)A(a,"]",2)puts(a);puts(b);puts(c);}

그것은 괴물이고 waaayyyy가 너무 길지만 나는 끝났습니다. 아마도 다른 접근법으로 가야했을 것입니다.

온라인으로 사용해보십시오!

두 번째 테스트 사례 | 세 번째 테스트 사례 | 네 번째 테스트 사례 | 다섯 번째 테스트 사례 | 여섯 번째 테스트 사례 | 일곱 번째 테스트 사례

젤리 , 37 바이트

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

세 가지 형식을 세 줄로 인쇄하는 전체 프로그램.

온라인으로 사용해보십시오!

방법?

j€⁾, j⁾; ⁾[]j - Link 1, create the 3rd format (semicolon-style): list of lists
  ⁾,          - literal [',', ' ']
j€            - join for €ach (place ", " between the elements of each row)
      ⁾;      - literal [';', ' ']
     j        - join (place "; " between the rows)
         ⁾[]  - literal ['[', ']']
            j - join (surround the whole result with a pair of brackets)

ỴḲLÐf$€VµŒṘṄ“[]“{}”yṄȧÇ - Main link: list of characters
Ỵ                       - split at newlines
     $€                 - last two links as a monad for €ach row:
 Ḳ                      -   split at spaces
   Ðf                   -   filter keep those for which the following is truthy:
  L                     -     length (this removes all the empty lists "between" spaces)
       V                - evaluate as jelly code (yields a list of lists of numbers)
        µ               - monadic chain separation, call that x
         ŒṘ             - get a Python string representation of x
           Ṅ            - print that (the 1st format) plus a newline, and yield it
            “[]“{}”     - literal [['[', ']'],['{', '}']]
                   y    - translate (converts all '[' to '{' and all ']' to '}')
                    Ṅ   - print that (the 2nd format) plus a newline, and yield it
                      Ç - call the last link as a monad with argument x
                     ȧ  - logical and
                        - implicit print of the result (the 3rd format)

V , 41 바이트

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

온라인으로 사용해보십시오!

설명

òJé;ò            Join all lines with `; ` (trailing single space)
     Ó¨ä©ó«/±,   :s/\v(\d)\s+/\1, /g
yss]             Surround everything with brackets (completes [x,x;x,x])
Y.pk             (Y)ank, surround with brackets again, (p)aste.  Adds [[x,x;x,x]]
    Ó; /], [     :s/; /[, ]/g (transforms to [[x,x], [x,x]])
Ù                Duplicate this line
 ò               recursively
  cs]}           (c)hange (s)urrounding [] with {}
      f[         go to the next [ until there are none

R , 132 바이트

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

온라인으로 사용해보십시오!

익명의 기능. 다음과 같은 입력을받습니다.

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

테스트 사례와 동일한 순서로 공백을 구분 기호로 사용하여 인쇄합니다.

설명:

먼저 공백을로 바꾸고 ,결과를로 저장합니다 y. 그런 다음에 줄 바꿈 스왑 ], [, 풋 [[와 ]]양쪽 끝에를하고 그 결과를 저장한다 z.

다음으로, chartr스위치 [로 {와 ]함께 }에서 z.

마지막으로, 소요 y와 뉴 라인 스왑 ;과 풋 [과] 양쪽 끝에.

그런 다음 모든 결과가 순서대로 전달됩니다. cat 잘 인쇄되고 단일 형식으로 구분됩니다.

온화한 골퍼

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

Netbeans 8 이상, 209 바이트가있는 Java 8

코드에서 카운트는 208이며 +를 눌러 실행하려면 1 바이트 F6 입니다.

성가신 도전에 대한 성가신 답변 : p

interface M{static void main(String[]a){String s="";s=s.trim().replaceAll(" +",", ").replaceAll("\n(, )?","; ");System.out.println("["+s+"]\n[["+s.replace("; ","], [")+"]]\n{{"+s.replace("; ","}, {")+"}}");}}

사용하는 방법?

Netbeans 내에서이 코드를이라는 파일에 붙여 넣습니다 M.java. 그런 다음 사용하려는 매트릭스를 복사하십시오. 그런 다음 연속 된 두 문자 사이에서 +를 ""누릅니다.ctrlv 챌린지에 필요한대로 를 .

이제 F6! 코드를 컴파일하고 실행하여 예상되는 매트릭스 표현을 출력합니다.

Mathematica, 129 바이트

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

세 번째와 네 번째 줄은 함께 문자열을 입력으로 사용하는 순수한 함수를 정의합니다. 예를 들어f=Print...& 하면 마지막 테스트 사례는 다음과 같이 호출됩니다.

f@"4
5"

스 니펫

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

입력 문자열을 문자열 (문자열의 숫자로 해석하지 않음)을 구문 분석하고 결과 표현식을 다시 문자열로 변환합니다. 중괄호가있는 출력 형식을 자동으로 생성합니다. 그런 다음 Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}]간단한 문자열 교체 규칙을 사용하여 해당 출력 형식과 다른 두 개를 줄 바꿈으로 구분하여 인쇄합니다.

씨 , 49 46 바이트

45 바이트 코드, +1 -r 플래그의

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

stdin에서 입력을받습니다. 온라인으로 사용해보십시오!

설명

                 Preset variables used: s is " ", w is regex `\s+`, k is ", "
g                With -r flag, g is a list of lines from stdin
 |>:s            Left-strip spaces from (elements of) g and assign back to g

YP(RPg^w)R';k
     g^w         Split (elements of) g on runs of whitespace
   RP            Apply Pip's built-in repr, which wraps lists in [] and separates items
                   with ; (e.g. [[1;2];[3;4]])
  (     )R';k    Replace the semicolons with ", " to obtain format #1
YP               Print and yank into y variable

PyR'['{R']'}
 yR'['{          In y, replace [ with {
       R']'}     and ] with }
P                and print (format #2)

O'[OgRwkJ"; "']
O'[              Output [ with no newline
   O             Output with no newline:
    g              Take g (list of lines of stdin, with leading spaces stripped)
     Rwk           Replace runs of whitespace with ", "
        J"; "      and join lines on "; "
             ']  Print the final ] to complete format #3

(이 설명 형식은 약간 복잡하게 느껴지므로 이해가되지 않는 경우 알려주십시오.)

스칼라, 590 바이트

힘들었지 만 난 끝났어

var o=s.replaceAll("  *"," ").replaceAll("\n ","\n")
var z=o.split("\n")
var h=z.length
var k=new Array[Array[String]](h)
for(i<-0 to h-1)k(i)=z(i).split(" ")
var u=k.length-1
print("{")
for(i<-0 to u){print("{")
for(j<-0 to k(i).length-2)print(k(i)(j)+", ")
print(k(i).last)
print("}")}
print("}[")
for(i<-0 to u){print("[")
for(j<-0 to k(i).length-2)print(k(i)(j)+", ")
print(k(i).last)
print("]")}
print("][")
for(i<-0 to u-1){for(j<-0 to k(i).length-2)print(k(i)(j)+", ")
print(k(i).last)
print("; ")}
for(j<-0 to k(k.length-1).length-2)print(k(u)(j)+", ")
print(k.last.last)
print("]")

빠른 설명 : 삼중 따옴표로 묶은 입력을 취한 다음 불필요한 공백을 제거합니다. 문자열을 두 번 나눕니다 (한 줄과 한 번 열); 나는 세 가지 일상으로 인쇄합니다. 상호 작용하는 함수를 정의하는 것이 가능할 수도 있지만 방법을 모르겠습니다.

온라인으로 사용해보십시오!

05AB1E , 34 바이트

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

온라인으로 사용해보십시오!

ε...}vy...})아직 TIO를 가져 오지 않았기 때문에 TIO 로 대체 되었습니다.

C # (. NET 코어) , 214 바이트

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

온라인으로 사용해보십시오!

Matrix를 문자열로 가져 와서 세 개의 형식을 줄 바꿈으로 구분 된 단일 문자열로 반환합니다.

숯 , 38 바이트

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

온라인으로 사용해보십시오! 참고 : 후행 공간. 링크는 자세한 버전의 코드입니다. 차콜에는 ["""및을 사용하여 구분 된 여러 줄 입력 옵션이 """]있습니다. 설명:

   θ                Input string
  ⪪ ¶               Split on newlines
 Ｅ                  Map over each line
        ι           Current line
       ⪪            Split on spaces
      Φ   λ         Filter out empty strings
     ⪫     ,        Join with `, `
≔            θ      Assign resulting array to variable

입력을 가져 와서 줄로 나누고 구분 기호를 정규화하여 준비합니다.

 ⪪[]{}²             Split `[]{}` into substrings of length 2
Ｅ                   Map over the substrings
          Ｅθ        Map over array from above
            ⪫ιλ     Wrap each element with the substring
         ⪫     ,    Join elements with `, `
       ⪫ι           Wrap with the substring
                    Implicitly print each result on a separate line

이것은 [[ ... ], [ ... ]]및 {{ ... }, { ... }}경우를 처리합니다 .

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

이 [ ... ; ... ]경우를 처리합니다 .

위의 솔루션에서 1 바이트를 골프화하기 전에 두 개의 39 바이트 솔루션을 사용했습니다. 이것은 다른 것입니다 :

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

온라인으로 사용해보십시오! 참고 : 후행 공간. 링크는 자세한 버전의 코드입니다. 설명:

  ⪪[]{}[]²                              Split `[]{}[]` into substrings of length 2
 Ｅ                                      Map over the substrings
                θ                       Input string
               ⪪ ¶                      Split on newlines
              Ｅ                         Map over each line
                     λ                  Current line
                    ⪪                   Split on spaces
                   Φ   ν                Filter out empty strings
                  ⪫     ,               Join with `, `
             Ｅ                          Map over each line
                          ⎇κ   λ        If outer index is zero, just use the line
                            ⪫ιλ         Otherwise wrap the line in the substring
            ⪫                   ⁺§;,,κ  Join with `; ` or `, ` per outer index
          ⪫ι                            Wrap in the substring
⮌                                       Reverse the order of the results
                                        Implicitly print each result on a separate line