Matrislerle ilgili birkaç zorluk yazdım ve herkes için yaygın olan, matrisleri temsil ederken hem örneklerde hem de test durumlarında aşağıdaki gibi bir format kullanmamdır:

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

Bu muhtemelen birçok dilde hantal bir formattır.

Meydan okuma:

Üstte verilen forma girdi olarak (doğrudan bu yazıdan kopyala / yapıştır) bir matris alabilen bir program / fonksiyon yazın ve aşağıda gösterilen diğer üç geleneksel formatta da aynı matrisi çıktılayın .

Giriş biçimi:

Değişen sayıda boşlukla ayrılmış sayılar ve satırları temsil eden yeni satırlar (bkz. Test senaryoları).

• Sayılar arasındaki boşluk sayısının tutarlı olması garanti edilmez. Ancak, her sütundaki son basamağın hizalandığını varsayabilirsiniz (eğer bu işe yararsa).
• Hem tamsayılar hem de kayan noktalar olabilir ve pozitif, negatif veya sıfır olabilirler. Bir matris aynı anda tamsayı ve kayan sayı içermez .
• Negatif kayan reklamlar için eksi ve ondalık nokta da dahil olmak üzere hiçbir sayının 10 karakterden uzun olmadığını varsayabilirsiniz.
• Her satırda ve her sütunda aynı sayıda giriş olduğunu varsayabilirsiniz.
• Boş giriş matrisi olmayacaktır, ancak tek sayılar veya yalnızca bir satır veya sütuna sahip matrisler olabilir.
  • Bu durumlarda test senaryolarında gösterilen çıktı biçimleri arasında seçim yapabilirsiniz

Programınız / işleviniz doğrudan bu gönderiden kopyalanır ve yorumlayıcıya yapıştırılırsa (STDIN veya işlev bağımsız değişkeni veya eşdeğeri bir şey) girdiyi işlemelidir. Matrisin önünde ve / veya sonrasında istediğiniz her şeye (parantez, tırnak işaretleri, parantez) sahip olabilirsiniz, ancak matrisi değiştirilemeyen bir karakter dizisi olarak düşünmelisiniz (satırsonlarını içerir).

Açıklığa kavuşturmak için: Fonksiyonunuzun / programınızın çağrıldığını fve matrisin:

1 -2
3  5
6  7

bu durumda matrise aşağıdaki gibi işlev bağımsız değişkenleri (ve sonsuz sayıda seçenek) verebilirsiniz:

f(1 -2
3  5
6  7)

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

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

Diliniz herhangi bir şekilde kopyala / yapıştırılan matrisi giriş olarak alamazsa, korkarım başka bir dil seçmeniz gerekir.

Çıktı biçimi:

Matrisi aşağıdaki üç formatta çıkarmalısınız (sıra önemli değildir):

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

• Üç çıktıyı istediğiniz gibi ayırabilirsiniz (örn. Yeni satır)
• Sayıları girdi ile aynı hassasiyeti kullanarak çıkarmalısınız (örneğin, ondalık sayısını veya kayan sayı olarak tam sayıları kesmemelisiniz).
• Alanlar zorunludur
• -Negatif sayılar için kullanmalısınız , değil _veya benzer.

Test senaryoları:

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]

Ben tam olarak farkında değilim bu ama bu mücadelede, hantal G / Ç biçimi bütün noktasıdır. Buradaki zorluk, çıktıyı bazı dillerde biçimlendirmekle ilgili olurken, girişi okumak diğer dillerde en zor kısım olacaktır.

Eğer girişi okumak zorsa lütfen cesaretiniz kırılmasın, bu sunumlar en ilginç olanlar olabilir. Kısa, etkileyici olmak zorunda değildir. Ve her zaman olduğu gibi açıklamalar teşvik edilir!

Retina , 52 bayt

Bu cevap Perl cevabıma dayanıyor, Retina ile golf oynamak için Martin Ender'in yardımıyla .

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

Çevrimiçi deneyin!

Açıklamaları Perl cevabımda bulabilirsiniz. Farklar:

*
[
$
]

s/^ *(.+)/[$1]/gmHem ön boşlukları kaldırmak hem de çizgilerin etrafına köşeli parantez eklemek yerine .

^.|]$

Üçüncü çıkış için ön ve arka parantezleri çıkarmak için.

Retina , 57 54 bayt

Bayt sayımı ISO 8859-1 kodlamasını varsayar.

m`^ +

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

Çevrimiçi deneyin!

TIO bağlantısı şu anda üç format arasında satır besleme yazdırmıyor, ancak bunun nedeni kararsız bir taahhüt kullanmasıdır. Program, Retina 0.8.2'deki ara hat beslemelerini yazdırır.

açıklama

m`^ +

Her hatta önde gelen boşluklardan kurtulun.

¶
] [

Hat beslemelerini ile değiştirin ] [.

 +
, 

Tüm boşluk çalışmalarını virgül ve boşlukla değiştirin.

:`.+
[[$&]]

[[...]]İlk biçimi tamamlayan her şeyi tamamlayın. Sonucu yazdırın.

*T`[]`{}

Köşeli parantezleri köşeli parantezlerle değiştirin ve çalışma dizesini gerçekten değiştirmeden sonucu yazdırın (yani, yazdırıldıktan sonra ilk biçim geri yüklenir).

], .
; 

], [Noktalı virgül ve satır besleme ile değiştirin .

^.|]$

İlk [ve sonuncuyu kaldırın ]. Bu üçüncü formatı tamamlar.

Scala, 183 181 149 bayt

Çevrimiçi deneyin!

StringDeğiştirmeleri ve normal ifadeleri kullanan yeni sürüm :

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

Yeni sürüm kullanılarak eski sürüm ile aynı anlam ve kullanımını vardır split, mapve mkString.

Eski versiyon kullanılarak split, mapve mkString:

Düzenleme: Kaldırılan alan için yedek karakter sınıfı

(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. REPL'de yürütün. Girişi üç tırnaklı Stringparametre olarak kabul eder, çıktıyı gerekli çıktıların 3 parçası olarak döndürür. REPL, parantezlerle çevrelenmiş tuplleri virgülle ayırır.

Açıklama:

Yeni sürüm:

Çoğunlukla diğer regex tabanlı cevaplarla aynı mantık.

Eski versiyon:

Giriş matrisi temsilini bir 2D Stringdiziye böldük, sonra elemanları ayırarak iç dizileri daraltarak 1D dizisine eşleştiriyoruz ,. Son olarak, gerekli yeni satır ayırıcılarını ve sınır işaretleyicilerini (önekler ve sonekler) kullanarak 1D dizilerini daraltarak farklı çıktılar oluştururuz. Her şey split(okuma), map(dönüştürme) ve mkString(daraltma) yoluyla uygulanır.

Örnek REPL oturumu:

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

Birkaç elemanlı kenar kasaları için bu istenen çıktıyı sağlar.

Japt , 63 53 bayt

Çıktıdaki aralığın zorunlu olduğunu fark etmeden önce bu 44 baytta geliyordu.

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

Dene

açıklama

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

69 bayt kod + -p0bayrak.

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

Çevrimiçi deneyin!

açıklamalar

s/^ *(.+)/[$1]/gm;[]önde gelen boşlukları kaldırırken her satırın çevresini ekler .
s/\s+/, /g;boşluk ve satır satırlarını virgül ve boşlukla değiştirir.
İlk çıkış sonra parantez ile çevrelenmesiyle elde edilir: [$_].
İkincisi, parantezleri kıvırcık parantez ( y/[]/{}/r) ile değiştirmeli ve kıvırcık parantez ile çevrelemelidir "{" ... "}".
Üçüncüsü, ], [noktalı virgül ve boşluk ( s/], \[/; /gr) ile değiştirilir.

Bu çözümü yazdıktan sonra, Martin Ender'in Retina cevabını benimsemeyi denedim, ancak 10 bayt daha uzun sürdü ( TryItOnline ):

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

Bu sürüm için, açıklamalar için Martin'in cevabına bakınız .

MATL , 60 bayt

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

Çevrimiçi deneyin!

Luis Mendo'ya bayt hesabımın dörtte birini sohbet eden bir masterclass'ta traş ettiği için çok teşekkürler.

Girişi, ardından boş bir satır yapıştırın.

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

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

Çevrimiçi deneyin!

İlk çıktı

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

İkinci çıktı

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

Üçüncü çıktı

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

Python 2 , 143 bayt

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]

Çevrimiçi deneyin!

JavaScript (ES6), 121 110 106 bayt

@Shaggy ve @Justin sayesinde -15 bayt

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

Örnek kod snippet'i:

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 bayt

Uyarıların kullanılmasını öneren Felipe Nardi Batista sayesinde -5 bayt (üzgünüm, sadece bu kelimeyi söylemek için bir bahaneye ihtiyacım var: 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],'], [','; ')

Çevrimiçi deneyin!

Python 3 , 1841781741731616163 * 157 * 153 bayt

Giriş / Çıkış Formatı: Matrisler ve bu fonksiyon çağrısıyla giriş (TIO'da gösterildiği gibi) arasında boşluk olan çıkış:

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

Bu işlev:

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

Çevrimiçi deneyin!

* Kaydedilen 6 @officialaimm için (169 ila 163 bayt) sayesinde bayt.

* @FelipeNardiBatista sayesinde 4 bayt kaydedildi.

Daha fazla golf sonrası gelecek açıklama.

C, 415 bayt

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

Bu bir canavar ve waaayyyy çok uzun, ama bitirdim. Muhtemelen farklı bir yaklaşım için gitmiş olmalı.

Çevrimiçi deneyin!

İkinci test senaryosu | Üçüncü test durumu | Dördüncü test davası | Beşinci Test Çantası | Altıncı test örneği | Yedinci test örneği

Jöle , 37 bayt

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

Üç biçimi üç satıra yazdıran tam bir program.

Çevrimiçi deneyin!

Nasıl?

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 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

isimsiz bir işlev. Gibi girdi alır

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

Bunları test senaryolarıyla aynı sırada, ancak ayırıcı olarak boşluklarla yazdırır.

Açıklama:

Önce boşlukları takas eder ,ve sonucu olarak kaydeder y. Daha sonra, yeni satırları her iki ucuyla değiştirir, her iki ucuna ], [koyar [[ve ]]sonucunu olarak kaydeder z.

Daha sonra, chartranahtarları [ile {ve ]ile }de z.

Son olarak, yyeni satırları alır , değiştirir ve her iki ucuna da ;koyar .[]

Sonra tüm sonuçlar bu sırayla cat onları güzel bir şekilde biçimlendirilmiş ve tek bir boşlukla ayrılmış şekilde basan .

Hafifçe soluksuz:

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

Netbeans ile Java 8 8+, 209 bayt

Sayı koddan 208, artı tuşuna basarak çalıştırmak için 1 bayt F6.

Hantal meydan okuma için hantal cevap: 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("; ","}, {")+"}}");}}

Nasıl kullanılır?

Netbeans içinde bu kodu adlı bir dosyaya yapıştırın M.java. Ardından kullanmak istediğiniz matrisi kopyalayın. Ardından arka arkaya iki karakter arasında , sınama için gereken şekilde + ""tuşuna basın .ctrlv

Şimdi basın F6! Bu, kodu derleyecek, çalıştıracak ve beklenen matris gösterimlerini çıkaracaktır.

Mathematica, 129 bayt

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

Üçüncü ve dördüncü çizgiler birlikte, bir dizgiyi girdi olarak alan saf bir işlevi tanımlar; örneğin, biz ayarlarsak f=Print...&, son test senaryosu şu şekilde adlandırılır:

f@"4
5"

Snippet

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

giriş dizesini bir matris olarak ayrıştırır (dizelerden oluşur - girişleri asla sayısal büyüklükler olarak yorumlamaya çalışmazız) ve elde edilen ifadeyi bir dizgeye dönüştürür; bu otomatik olarak kıvırcık parantezlerle çıktı biçimini oluşturur. Daha sonra Print[#,n,#~r~{"{"->"[","}"->"]"},n,#~r~{"{{"->"[","}}"->"]","}, {"->"; "}], basit dize değiştirme kuralları kullanarak, çıktı biçimini ve diğer iki satır, satırsonu ile ayrılmış olarak yazdırılır.

Pip , 49 46 bayt

45 bayt kod, -rbayrak için +1 .

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

Stdin'den girdi alır. Çevrimiçi deneyin!

açıklama

                 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

(Bu açıklama biçimi bana biraz kıvrımlı geliyor, bu yüzden bir şey mantıklı gelmiyorsa bana bildirin.)

SCALA, 590 bayt

Zordu, ama bence işim bitti

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

Hızlı açıklama: Üçlü tırnaklarla çevrili girdi alırım, sonra da gerekli olmayan alanları çıkarırım; dizeyi iki kez bölün (satırlar için bir kez ve sütunlar için bir kez); ve üç rutinimle baskı yapıyorum. Karşılıklı olunacak bir işlevi tanımlamak mümkün olabilir, ama nasıl yapacağımı bilmiyorum.

Çevrimiçi deneyin!

05AB1E , 34 bayt

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

Çevrimiçi deneyin!

ε...}vy...})henüz çekilmediğinden TIO ile değiştirildi .

C # (.NET Core) , 214 bayt

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

Çevrimiçi deneyin!

Matrisi bir dize olarak alır, üç biçimi yeni satırlarla ayrılmış tek bir dize olarak döndürür.

Kömür , 38 bayt

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

Çevrimiçi deneyin! Not: Sondaki boşluk. Bağlantı, kodun ayrıntılı versiyonudur. Kömür ["""ve ile sınırlandırılmış çok satırlı giriş seçeneğine sahiptir """]. Açıklama:

   θ                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

Bu, girdiyi alır ve satırlara bölerek ve ayırıcıları normalleştirerek hazırlar.

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

Bu [[ ... ], [ ... ]]ve {{ ... }, { ... }}vakaları ele alır .

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

Bu [ ... ; ... ]davayı ele alır .

Yukarıdaki çözümden bir bayt golf yapmadan önce iki 39 baytlık çözümüm vardı; bu diğeri:

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

Çevrimiçi deneyin! Not: Sondaki boşluk. Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

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