บางครั้งฉันมีรายการเมทริกซ์คงที่ในรหัสของฉัน:

[ [[1, 0],
   [0, 1]],

  [[1, 0],
   [0,-1]],

  [[0, 1],
   [1, 0]],

  [[0,-1],
   [1, 0]] ]

นั่นคือการใช้อสังหาริมทรัพย์ที่น่ากลัวบนหน้าจอ ฉันอยากจะเขียนพวกเขามากถัดจากกัน:

[   [[1, 0],    [[1, 0],    [[0, 1],    [[0,-1],
     [0, 1]],    [0,-1]],    [1, 0]],    [1, 0]]   ]

คุณจะพบว่านี่ยังคงเป็นรายการที่ซ้อนกันที่ถูกต้อง syntactically มันเป็นเพียงไม่เป็นรูปสี่เหลี่ยมผืนผ้าอีกต่อไปและมีโครงสร้างที่แตกต่างกันมาก (โดยเฉพาะมันจะลึกลงทุกครั้งที่ฉันเพิ่มเมทริกซ์ที่มีขนาดใหญ่กว่า 1x1) อย่างไรก็ตามยังคงสามารถสร้างรายการเมทริกซ์เริ่มต้นจากรายการใหม่นี้ได้

เพื่อที่ฉันจะสามารถใช้ไวยากรณ์นี้ได้ในอนาคตฉันต้องการให้คุณเขียนโค้ดที่แปลงอาร์เรย์ที่เขียนในการจัดเรียงแนวนอนไปยังรายการของเมทริกซ์ที่พวกเขาเป็นตัวแทน

เพื่อให้แน่ใจว่าคำตอบไม่ได้ทำการจับคู่รูปแบบ 2 มิติบนเลย์เอาต์ในซอร์สโค้ดอินพุทจะได้รับเป็นเพียงแค่วัตถุอาร์เรย์หรือถ้าคุณใช้การแทนสตริงแล้วมันจะไม่มีช่องว่างใด ๆ ที่ระบุวิธี ตัวอักษรถูกเขียนในรหัส ดังนั้นคุณจะได้รับข้อมูลเช่นนี้:

[[[1, 0], [[1, 0], [[0, 1], [[0,-1], [0, 1]], [0,-1]], [1, 0]], [1, 0]]]

และผลลัพธ์ควรเป็นอาร์เรย์ต่อไปนี้หรือการแสดงสตริง (อีกครั้งไม่จำเป็นต้องมีโครงร่างเพิ่มเติม):

[[[1, 0], [0, 1]], [[1, 0], [0,-1]], [[0, 1], [1, 0]], [[0,-1], [1, 0]]]

นี่เป็นส่วนแรกและง่ายกว่าของการท้าทายสองส่วน ในอันนี้คุณอาจสันนิษฐานว่าเมทริกซ์ทั้งหมดเป็นสี่เหลี่ยมจัตุรัสและมีขนาดเท่ากัน ในส่วนที่สองเราจะผ่อนคลายสมมติฐานเหล่านี้

กฎระเบียบ

อินพุตจะเป็นรายการแบบซ้อนหรือการแสดงสตริงแบบบัญญัติ (ในภาษาที่คุณเลือก) และคุณควรแสดงผลลัพธ์ในรูปแบบเดียวกัน ผลลัพธ์จะมีเมทริกซ์อย่างน้อยหนึ่งเมทริกซ์และเมทริกซ์อาจมีขนาดเล็กเท่า 1x1 เมทริกซ์จะมีจำนวนเต็ม (ลงนาม) เท่านั้นที่มีค่าสัมบูรณ์น้อยกว่า 128

คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่นและใช้วิธีการมาตรฐานใด ๆ ในการรับอินพุตและจัดเตรียมเอาต์พุต

คุณอาจใช้ภาษาการเขียนโปรแกรมใด ๆแต่โปรดทราบว่าช่องโหว่เหล่านี้เป็นสิ่งต้องห้ามตามค่าเริ่มต้น

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดที่ถูกต้อง - วัดเป็นไบต์ - ชนะ

กรณีทดสอบ

แต่ละกรณีทดสอบมีก) เมทริกซ์รายการที่วางไว้ข้าง ๆ กันอย่างที่ควรจะเป็นในรหัส (นี่ไม่ใช่ข้อมูลของคุณ), b) รายการที่ไม่ได้จัดรูปแบบโดยไม่มีช่องว่างภายนอก ( นี่คืออินพุตของคุณ), c) ผลผลิตที่คาดหวัง

Pretty: [ [[0]] ]
Input:  [[[0]]]
Output: [[[0]]]

Pretty: [  [[-1]],  [[0]],  [[1]]  ]
Input:  [[[-1]],[[0]],[[1]]]
Output: [[[-1]],[[0]],[[1]]]

Pretty: [  [[1, 0],   [[1, 0],   [[0, 1],   [[0,-1],
            [0, 1]],   [0,-1]],   [1, 0]],   [1, 0]]  ]
Input:  [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]
Output: [[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

Pretty: [  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
            [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
            [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]
Input:  [[[1,0,0],[[127,63,31],[[1,0,0],[[0,0,0],[0,1,0],[15,0,-15],[0,0,1],[0,0,0],[0,0,1]],[-31,-63,-127]],[0,1,0]],[0,0,0]]]
Output: [[[1,0,0],[0,1,0],[0,0,1]],[[127,63,31],[15,0,-15],[-31,-63,-127]],[[1,0,0],[0,0,1],[0,1,0]],[[0,0,0],[0,0,0],[0,0,0]]]

เยลลี่ , 20 15 13 11 ไบต์

Fðs⁹œsZµḢḢL

ลองออนไลน์!

พื้นหลัง

เช่นเดียวกับสิ่งส่วนใหญ่ความท้าทายนี้ค่อนข้างง่ายเมื่อคุณทราบว่าต้องทำอะไร ในที่สุดฉันก็ทำหลังจากลบสามครั้งและย้อนกลับหนึ่งครั้ง ...

ก่อนอื่นเราต้องหามิติของเมทริกซ์ ทำได้ง่ายกว่าที่กล่าวไว้: องค์ประกอบแรกขององค์ประกอบแรกคือแถวแรกของเมทริกซ์เอาต์พุตแรกดังนั้นความยาวเท่ากับจำนวนคอลัมน์ของเมทริกซ์เอาต์พุตสี่เหลี่ยม

ตัวอย่างเช่นถ้าอินพุตเป็น

[  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
    [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
    [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]

องค์ประกอบแรกขององค์ประกอบแรกคือ[1, 0, 0]ความยาวซึ่งเป็นℓ = 3

ถ้าเราแผ่แบนและแยกมันออกเป็นชิ้น ๆ ของความยาวนั้นเราจะได้เมทริกซ์เอาต์พุตทั้งหมดแถวแม้ว่าจะอยู่ในลำดับที่ไม่ถูกต้อง สำหรับอินพุตตัวอย่างของเราสิ่งนี้จะให้

[  [1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0],
   [0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0],
   [0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]  ]

ในการรับเอาท์พุทสุดท้ายเราต้องแยกแถวอาเรย์ออกเป็นunชิ้นที่มีความยาวเท่ากัน สำหรับอินพุตตัวอย่างของเราสิ่งนี้จะให้

[ [[1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0]],
  [[0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0]],
  [[0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]] ]

ตอนนี้แต่ละคอลัมน์เป็นหนึ่งในเมทริกซ์เอาต์พุตดังนั้นการย้ายเมทริกซ์ผลลัพธ์ของอาร์เรย์จึงเป็นสิ่งที่ต้องทำ สำหรับอินพุตตัวอย่างของเราที่ให้

[
 [[1, 0, 0],
  [0, 1, 0],
  [0, 0, 1]],

 [[127,  63,   31],
  [ 15,   0,  -15],
  [-31, -63, -127]],

 [[1, 0, 0],
  [0, 0, 1],
  [0, 1, 0]],

 [[0, 0, 0],
  [0, 0, 0],
  [0, 0, 0]]
]

ตามที่ต้องการ

มันทำงานอย่างไร

Fðs⁹œsZµḢḢL  Monadic link. Argument: A (ragged array)


F            Monadic chain. Argument: A

F            Flatten A. This yields the vector V.


       µḢḢL  Monadic chain. Argument: A

        Ḣ    Head; retrieve the first element of A.
         Ḣ   Head; retrieve the first element of the first element of A.
          L  Compute ℓ, the length of the resulting array.


 ðs⁹œsZ      Dyadic chain. Left argument: V. Right argument: ℓ

  s⁹         Split V into chunks of length ℓ.
    œs       Split the result into ℓ chunks of equal length.
      Z      Zip/transpose the result.

Pyth , 12 ไบต์

CcJlhhQc.nQJ

นี่คือพอร์ตของคำตอบ Jelly ของฉัน

ลองออนไลน์!

มันทำงานอย่างไร

Pyth จะแยกวิเคราะห์โปรแกรมดังต่อไปนี้ (pseudo-code)

C(c(J = l(h(h(Q))), c(.n(Q), J)))

Qเป็นตัวแปรที่เก็บอินพุต Jเป็นตัวแปรที่ไม่ได้กำหนด

ครั้งแรกที่J = l(h(h(Q)))ร้านค้าความยาวของหัว (องค์ประกอบแรก) ที่ของหัวของQในJ

จากนั้น.n(Q)flattens Qและc(..., J)แยกผลเป็นชิ้นยาวJ

หลังจากนั้นc(J, ...)แยกผลลัพธ์เป็นชิ้นJ

ในที่สุดก็C(...)สลับผลลัพธ์

Pyth , 29 ไบต์

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

ชุดทดสอบ

มันทำงานอย่างไร

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

              z        input
             :      3  split at matches of the following regex
               "\B,"   /\B,/
            J          store at J
           U           [1,2,...,len(J)]

                           J  J
                        @R1   take the second character of each
                              substring in J
                     x\[      indices of all occurrences of "["

          -   filter away the elements in ^ from the
              elements in ^^ to find the first substring
              which does not start with "[["
         h    the first element
              note: this will generate an error if
              all substrings start with "[[", e.g. in the
              first example. We will deal with the error later.
       cJ     split J in groups of the specified length
      C       transpose                             ^
     s        flatten                               |
  j\,         join with ","                         |
.x            if the above code generated an error (|), return
              the following instead:
                            z      the input

ขั้นตอนวิธี

มาทำงานกับอินพุต[[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]กันเถอะ

เราจะใช้การดำเนินการกับสตริงบริสุทธิ์ที่นี่

อันดับแรกเราแบ่งอินพุตที่เครื่องหมายจุลภาคซึ่งไม่ได้เป็นส่วนหนึ่งของรายการที่ลึกที่สุด (ทำได้โดยแยกที่ regex \B,):

[[[1,0]
[[1,0]
[[0,1]
[[0,-1]
[0,1]]
[0,-1]]
[1,0]]
[1,0]]]

จากนั้นเราจะหาดัชนีของสตริงย่อยแรกซึ่งไม่ได้ขึ้นต้นด้วย[[(สิ่งนี้จะทำโดยการตรวจสอบว่าตัวละครที่ดัชนี1เป็น[) ในกรณีนี้มันเป็น4เพราะย่อยที่ดัชนี 4 คือที่ไม่ได้เริ่มต้นด้วย[0,1]][[

จากนั้นเราจัดกลุ่มวัสดุย่อยเป็นกลุ่มที่ 4 จากนั้นแปลงเป็น

[[[1,0]
[0,1]]
[[1,0]
[0,-1]]
[[0,1]
[1,0]]
[[0,-1]
[1,0]]]

จากนั้นเราก็รวมคอมม่าด้วยกัน:

[[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

JavaScript (ES6), 132 130 ไบต์

f=(a,n=1)=>a[0][n]?a[0][n][0][0]?f(a,n+1,a[0].splice(n,1,...a[0][n])):n>1?[...Array(n)].map((_,i)=>a[0].filter((_,j)=>j%n==i)):a:a

มีสี่กรณี:

• อาร์เรย์ 1 × n ซึ่งเพิ่งกลับมา (นี่เป็นการทดสอบครั้งแรก แต่กลับด้าน)
• อาร์เรย์ m × n ที่ยังไม่แบนซึ่งเราทำการแบนซ้ำในขั้นตอนเดียวโดยนับnในเวลาเดียวกัน
• อาร์เรย์ m × n ที่แบนซึ่งเรากรองทุกnส่วนที่
• อาร์เรย์ m × 1 ซึ่งเพิ่งส่งคืน

05AB1E , 11 ไบต์

พอร์ตของเดนนิสคำตอบ ' รหัส:

¬¬g¹˜sô¬gäø

ใช้การเข้ารหัสCP-1252 ลองออนไลน์!

Mathematica, 104 ไบต์

l=Length;(m=l@#[[1,1]];n=l@Flatten@#/m;Table[Partition[#~ArrayReshape~{n,m},n/m][[j,i]],{i,n/m},{j,m}])&

อินพุต

{{{1, 0}, {{1, 0}, {{0, 1}, {{0, -1}, {0, 1}}, {0, -1}}, {1, 0} }, {1, 0}}}

เอาท์พุต

{{{1, 0}, {0, 1}}, {{1, 0}, {0, -1}}, {{0, 1}, {1, 0}}, {{0, -1 }, {1, 0}}}

อินพุต

{{{1, 0, 0}, {{127, 63, 31}, {{1, 0, 0}, {{0, 0, 0}, {0, 1, 0}, {15, 0, -15}, {0, 0, 1}, {0, 0, 0}, {0, 0, 1}}, {-31, -63, -127}}, {0, 1, 0}}, {0, 0, 0}}}}

เอาท์พุต

{{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}, {{127, 63, 31}, {15, 0, -15}, {-31, - 63, -127}}, {{1, 0, 0}, {0, 0, 1}, {0, 1, 0}}, {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}}}}

{{{0}}} และ {{{-1}}, {{0}}, {{1}}} ทำงานเช่นกัน

-11 ไบต์ขอบคุณ Martin Ender