Đôi khi, tôi có danh sách các ma trận không đổi trong mã của mình:

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

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

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

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

Đó là một cách sử dụng khủng khiếp của bất động sản màn hình. Tôi muốn viết chúng bên cạnh nhau hơn:

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

Bạn sẽ thấy rằng đây vẫn là một danh sách lồng nhau hợp lệ về mặt cú pháp, nó không còn là hình chữ nhật nữa và nó có cấu trúc rất khác nhau (đặc biệt, nó sẽ sâu hơn mỗi khi tôi thêm một ma trận lớn hơn 1x1). Tuy nhiên, vẫn có thể xây dựng lại danh sách ma trận ban đầu từ danh sách mới này.

Để tôi có thể sử dụng cú pháp này trong tương lai, tôi cần bạn viết một số mã chuyển đổi các mảng được viết theo cách sắp xếp theo chiều ngang thành danh sách ma trận mà chúng đại diện.

Để đảm bảo rằng các câu trả lời không thực hiện khớp mẫu 2D trên bố cục trong mã nguồn, đầu vào sẽ được cung cấp dưới dạng đối tượng mảng hoặc nếu bạn lấy biểu diễn chuỗi, thì nó sẽ không chứa bất kỳ khoảng trắng nào cho biết cách nghĩa đen đã được viết trong mã. Vì vậy, bạn sẽ nhận được một số đầu vào như thế này:

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

Và đầu ra phải là mảng sau hoặc biểu diễn chuỗi của nó (một lần nữa, không cần bố trí thêm):

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

Đây là phần đầu tiên và dễ dàng hơn trong thử thách hai phần. Trong phần này, bạn có thể giả sử rằng tất cả các ma trận đều là hình vuông và có cùng kích thước và chúng được căn chỉnh chính xác cạnh nhau. Trong phần thứ hai, chúng ta sẽ thư giãn những giả định này.

Quy tắc

Đầu vào sẽ là một danh sách lồng nhau hoặc biểu diễn chuỗi chính tắc của nó (theo ngôn ngữ bạn chọn) và bạn nên xuất kết quả theo cùng định dạng. Kết quả sẽ luôn chứa ít nhất một ma trận và ma trận có thể nhỏ bằng 1x1. Các ma trận sẽ chỉ chứa các số nguyên (đã ký) có giá trị tuyệt đối nhỏ hơn 128.

Bạn có thể viết một chương trình hoặc một chức năng và sử dụng bất kỳ phương pháp tiêu chuẩn nào để nhận đầu vào và cung cấp đầu ra.

Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào , nhưng lưu ý rằng các lỗ hổng này bị cấm theo mặc định.

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

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

Mỗi trường hợp kiểm tra có a) các ma trận danh sách được đặt độc đáo cạnh nhau vì chúng sẽ nằm trong mã (đây không phải là đầu vào của bạn), b) danh sách không được định dạng mà không có khoảng trắng bên ngoài ( đây là đầu vào của bạn), c) sản lượng dự kiến.

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

Thạch , 20 15 13 11 byte

Fðs⁹œsZµḢḢL

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

Lý lịch

Giống như hầu hết mọi thứ, thử thách này khá đơn giản một khi bạn đã tìm ra những gì bạn phải làm. Và cuối cùng tôi đã làm được, sau ba lần xóa và một lần quay lại ...

Đầu tiên, chúng ta phải tìm ra kích thước của ma trận. Điều đó được thực hiện dễ dàng hơn so với nói: phần tử đầu tiên của phần tử đầu tiên là hàng đầu tiên của ma trận đầu ra đầu tiên, do đó độ dài của nó bằng với số cột của ma trận đầu ra vuông.

Ví dụ: nếu đầu vào 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]]  ]

phần tử đầu tiên của phần tử đầu tiên là [1, 0, 0], có độ dài là ℓ = 3 .

Nếu chúng ta làm phẳng đầu vào và chia nó thành các đoạn có độ dài đó, chúng ta sẽ nhận được tất cả các hàng của ma trận đầu ra, mặc dù theo thứ tự sai. Đối với đầu vào ví dụ của chúng tôi, điều này mang lại

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

Để có được kết quả cuối cùng, đầu tiên chúng ta phải chia các mảng hàng vào ℓ khối chiều dài bằng nhau. Đối với đầu vào ví dụ của chúng tôi, điều này mang lại

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

Mỗi cột bây giờ là một trong các ma trận đầu ra, do đó, việc hoán vị ma trận kết quả của các mảng là tất cả những gì phải làm. Đối với đầu vào ví dụ của chúng tôi, điều đó mang lại

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

như mong muốn.

Làm thế nào nó hoạt động

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.

Bình thường , 12 byte

CcJlhhQc.nQJ

Đây là một cổng của câu trả lời Jelly của tôi.

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

Làm thế nào nó hoạt động

Pyth phân tích chương trình như sau (mã giả).

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

Q là một biến giữ đầu vào. J là một biến không xác định.

Đầu tiên J = l(h(h(Q)))các cửa hàng theo chiều dài của đầu (phần tử đầu tiên) của người đứng đầu Q tại J .

Sau đó, .n(Q)flattens Q , và c(..., J)chia kết quả thành từng miếng có độ dài J .

Sau đó, c(J, ...)chia kết quả thành các mảnh J.

Cuối cùng, C(...)chuyển kết quả.

Bình thường , 29 byte

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

Bộ thử nghiệm.

Làm thế nào nó hoạt động

.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

Thuật toán

Hãy làm việc với đầu vào [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]].

Chúng tôi sẽ sử dụng các hoạt động chuỗi thuần ở đây.

Đầu tiên, chúng tôi chia đầu vào tại các dấu phẩy không phải là một phần của danh sách sâu nhất (điều này được thực hiện bằng cách tách ở regex \B,):

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

Sau đó, chúng tôi tìm thấy chỉ mục của chuỗi con đầu tiên không bắt đầu bằng [[(điều này được thực hiện bằng cách kiểm tra xem ký tự trong chỉ mục 1có phải không [). Trong trường hợp này, đó là 4bởi vì chuỗi con ở chỉ số 4 [0,1]]không bắt đầu bằng [[.

Sau đó, chúng tôi nhóm các chuỗi con theo nhóm 4, và sau đó hoán vị:

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

Và sau đó chúng tôi tham gia với họ bằng dấu phẩy:

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

JavaScript (ES6), 132 130 byte

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

Có bốn trường hợp:

• Mảng 1 × n, vừa được trả về (đây là thử nghiệm đầu tiên, nhưng đảo ngược)
• Một mảng m × n chưa được làm phẳng, mà chúng ta đã làm phẳng đệ quy một bước, đếm n cùng một lúc.
• Một mảng m × n đã được làm phẳng, nơi chúng tôi lọc ra mọi n phần tử thứ.
• Một mảng m × 1, vừa được trả về

05AB1E , 11 byte

Một câu trả lời của Dennis . Mã số:

¬¬g¹˜sô¬gäø

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Toán học, 104 byte

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

Đầu vào

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

đầu ra

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

đầu vào

{{{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}}}

đầu ra

{{{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}}} và {{{-1}}, {{0}}, {{1}}} cũng hoạt động

-11 byte nhờ Martin Ender