Czasami w moim kodzie mam listy stałych macierzy:

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

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

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

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

To okropne wykorzystanie nieruchomości ekranowych. Wolę pisać je obok siebie:

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

Przekonasz się, że jest to nadal poprawna składniowo lista zagnieżdżona, po prostu nie jest już prostokątna i ma bardzo inną strukturę (w szczególności pogłębia się za każdym razem, gdy dodam matrycę większą niż 1x1). Nadal jednak możliwe jest zrekonstruowanie początkowej listy macierzy z tej nowej listy.

Aby móc korzystać z tej składni w przyszłości, muszę napisać kod, który konwertuje tablice napisane w układzie poziomym na listę reprezentowanych macierzy.

Aby upewnić się, że odpowiedzi nie wykonują dopasowania wzorca 2D na układzie w kodzie źródłowym, dane wejściowe zostaną podane albo jako obiekt tablicy, albo jeśli weźmie się ciąg znaków, to nie będzie zawierał białych znaków wskazujących, w jaki sposób literał został napisany w kodzie. Więc dostaniesz jakieś dane wejściowe:

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

Wyjście powinno być następującą tablicą lub jej ciągiem znaków (znowu nie jest potrzebny żaden dodatkowy układ):

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

To pierwsza i łatwiejsza część dwuczęściowego wyzwania. W tym przypadku możesz założyć, że wszystkie macierze są kwadratowe i mają takie same wymiary oraz że są odpowiednio wyrównane obok siebie. W drugiej części rozluźnimy te założenia.

Zasady

Dane wejściowe będą listą zagnieżdżoną lub jej kanoniczną reprezentacją ciągu znaków (w wybranym języku) i wynik powinien być wyprowadzany w tym samym formacie. Wynik zawsze będzie zawierał przynajmniej jedną matrycę, a matryce mogą być tak małe jak 1x1. Macierze będą zawierały (podpisane) liczby całkowite o wartości bezwzględnej mniejszej niż 128.

Możesz napisać program lub funkcję i użyć dowolnej ze standardowych metod odbierania danych wejściowych i dostarczania danych wyjściowych.

Możesz używać dowolnego języka programowania , ale pamiętaj, że te luki są domyślnie zabronione.

To jest golf golfowy , więc wygrywa najkrótsza ważna odpowiedź - mierzona w bajtach .

Przypadki testowe

Każdy przypadek testowy ma a) macierze list rozmieszczone ładnie obok siebie, tak jak byłyby w kodzie (to nie jest twoja informacja wejściowa), b) niesformatowaną listę bez dodatkowych białych znaków ( to twoje dane wejściowe), c) oczekiwany wynik.

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

Galaretka , 20 15 13 11 bajtów

Fðs⁹œsZµḢḢL

Wypróbuj online!

tło

Jak większość rzeczy, to wyzwanie jest dość proste, gdy już zorientujesz się, co musisz zrobić. I ostatecznie to zrobiłem, po trzech usunięciach i jednym cofnięciu ...

Najpierw musimy obliczyć wymiary macierzy. Łatwiej to zrobić niż powiedziano: pierwszy element pierwszego elementu jest pierwszym rzędem pierwszej macierzy wyjściowej, więc jego długość jest równa liczbie kolumn kwadratowej macierzy wyjściowej.

Na przykład, jeśli dane wejściowe to

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

pierwszym elementem pierwszego elementu jest [1, 0, 0], którego długość wynosi ℓ = 3 .

Jeśli spłaszczimy dane wejściowe i podzielimy je na kawałki o tej długości, otrzymamy wszystkie wiersze macierzy wyjściowych, choć w niewłaściwej kolejności. Dla naszego przykładowego wejścia daje to

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

Aby uzyskać końcowy wynik, musimy najpierw podzielić tablicę wierszy na ℓ kawałków o równej długości. Dla naszego przykładowego wejścia daje to

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

Każda kolumna jest teraz jedną z macierzy wyjściowych, więc transponowanie powstałej macierzy tablic to wszystko, co pozostało do zrobienia. Dla naszego przykładowego wejścia to daje

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

zgodnie z życzeniem.

Jak to działa

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 bajtów

CcJlhhQc.nQJ

To jest port mojej odpowiedzi na żelki.

Wypróbuj online!

Jak to działa

Pyth analizuje program w następujący sposób (pseudo-kod).

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

Q jest zmienną, która przechowuje dane wejściowe. J jest niezdefiniowaną zmienną.

Najpierw J = l(h(h(Q)))przechowuje długość głowy (pierwszy element) głowy Q w J .

Następnie .n(Q)wyrównuje Q i c(..., J)dzieli wynik na kawałki o długości J .

Następnie c(J, ...)dzieli wynik na J części.

Wreszcie C(...)transponuje wynik.

Pyth , 29 bajtów

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

Zestaw testowy.

Jak to działa

.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

Algorytm

Pracujmy nad danymi wejściowymi [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]].

Będziemy tutaj używać operacji na czystych ciągach.

Po pierwsze, dzielimy dane wejściowe przecinkami, które nie są częścią najgłębszej listy (odbywa się to przez dzielenie wyrażenia regularnego \B,):

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

Następnie znajdujemy indeks pierwszego podłańcucha, który nie zaczyna się od [[(odbywa się to poprzez sprawdzenie, czy znak przy indeksie 1to [). W tym przypadku jest tak 4, ponieważ podciąg o indeksie 4 to taki, [0,1]]który się nie zaczyna [[.

Następnie grupujemy podciągi w grupy po 4, a następnie transponujemy:

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

A następnie łączymy je przecinkami:

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

JavaScript (ES6), 132 130 bajtów

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

Istnieją cztery przypadki:

• Tablica 1 × n, która właśnie została zwrócona (jest to pierwszy test, ale odwrócony)
• Tablica m × n, która nie została jeszcze spłaszczona, którą rekurencyjnie spłaszczamy o jeden krok, licząc n jednocześnie.
• Tablica m × n, która została spłaszczona, gdzie filtrujemy co n th element.
• Tablica m × 1, która właśnie została zwrócona

05AB1E , 11 bajtów

Port Dennisa odpowiedź ' . Kod:

¬¬g¹˜sô¬gäø

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Mathematica, 104 bajty

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

Wkład

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

wydajność

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

wkład

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

wydajność

{{{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}}} i {{{-1}}, {{0}}, {{1}}} też działają

-11 bajtów dzięki Martinowi Enderowi