Иногда в моем коде есть списки постоянных матриц:

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

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

Чтобы я мог использовать этот синтаксис в будущем, мне нужно, чтобы вы написали некоторый код, который преобразует массивы, которые были написаны в горизонтальном расположении, в список матриц, которые они представляют.

Чтобы убедиться, что ответы не выполняют сопоставление двумерного шаблона с макетом в исходном коде, входные данные будут заданы либо просто как объект массива, либо, если вы возьмете строковое представление, то оно не будет содержать пробелов, указывающих, как литерал был написан в коде. Таким образом, вы получите некоторый вклад, как это:

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

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

Вы можете использовать любой язык программирования , но учтите, что эти лазейки по умолчанию запрещены.

Это код-гольф , поэтому самый короткий действительный ответ - измеренный в байтах - выигрывает.

Тестовые случаи

Каждый тестовый пример имеет: а) матрицы списков, удобно расположенные рядом друг с другом в том виде, в каком они были бы в коде (это не ваш ввод), б) неформатированный список без лишних пробелов ( это ваш ввод), в) ожидаемый результат.

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 . Попробуйте онлайн!

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 байт благодаря Мартину Эндеру