Іноді в коді є списки постійних матриць:

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

Ви побачите, що це все ще синтаксично дійсний вкладений список, він просто більше не прямокутний і має зовсім іншу структуру (зокрема, він стає глибшим щоразу, коли я додаю матрицю, що перевищує 1х1). Однак, все ще можливо реконструювати початковий список матриць із цього нового списку.

Щоб я міг використовувати цей синтаксис у майбутньому, мені потрібно, щоб ви написали якийсь код, який перетворює масиви, записані в горизонтальному розташуванні, у список матриць, які вони представляють.

Щоб переконатися, що відповіді не виконують 2D узгодження шаблону на макеті у вихідному коді, вхід буде наданий як просто об’єкт масиву, або якщо ви будете представляти рядок, він не буде містити пробілів, що вказують на те, як Буквально було написано в коді. Отже, ви отримаєте такий вклад:

[[[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х1. Матриці містять лише (підписані) цілі числа з абсолютним значенням менше 128.

Ви можете написати програму або функцію та використовувати будь-який із стандартних методів отримання вводу та надання виводу.

Ви можете використовувати будь-яку мову програмування , але зауважте, що ці лазівки за замовчуванням заборонені.

Це код-гольф , тому найкоротший вірний відповідь - вимірюється в байтах - виграє.

Випробування

Кожен тестовий випадок має: а) матриці списку, розташовані неподалік одна від одної, як це було б у коді (це не ваш внесок), б) неформатований список без сторонніх пробілів ( це ваш вхід), в) очікуваний вихід.

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

Для отримання кінцевого результату ми повинні спершу розділити масив рядків на ℓ шматки однакової довжини. Для нашого прикладу введення це дає

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

Це портрет моєї відповіді на желе.

Спробуйте в Інтернеті!

Як це працює

Pyth аналізує програму наступним чином (псевдо-код).

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

Q - змінна, яка містить вхід. J - невизначена змінна.

Перші J = l(h(h(Q)))зберігає довжину голови (перший елемент) глави Q в J .

Потім, .n(Q)згладжує 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]]].

Тут ми будемо використовувати чисті струнні операції.

По-перше, ми розділили вхід на коми, які не входять до найглибшого списку (це робиться шляхом розщеплення на регулярному вираженні \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 . Спробуйте в Інтернеті!

Математика, 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 байт завдяки Мартіну Ендеру