A volte, ho elenchi di matrici costanti nel mio codice:

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

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

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

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

È un uso terribile del settore immobiliare dello schermo. Preferirei scriverli uno di fianco all'altro:

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

Scoprirai che questo è ancora un elenco nidificato sintatticamente valido, non è più rettangolare e ha una struttura molto diversa (in particolare, diventa più profondo ogni volta che aggiungo una matrice più grande di 1x1). Tuttavia, è ancora possibile ricostruire l'elenco iniziale di matrici da questo nuovo elenco.

Per poter utilizzare questa sintassi in futuro, ho bisogno che tu scriva del codice che converte le matrici che sono state scritte in una disposizione orizzontale nell'elenco delle matrici che rappresentano.

Per assicurarsi che le risposte non eseguano la corrispondenza del modello 2D sul layout nel codice sorgente, l'input verrà fornito come solo oggetto array o se si prende una rappresentazione di stringa, quindi non conterrà alcuno spazio che indichi come letterale è stato scritto nel codice. Quindi otterrai alcuni input come questo:

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

E l'output dovrebbe essere il seguente array o la sua rappresentazione in formato stringa (di nuovo, non sono necessari ulteriori layout):

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

Questa è la prima e più semplice parte di una sfida in due parti. In questo caso, puoi presumere che tutte le matrici siano quadrate e abbiano le stesse dimensioni e che siano allineate correttamente l'una accanto all'altra. Nella seconda parte rilasseremo questi presupposti.

Regole

L'input sarà un elenco nidificato o la sua rappresentazione di stringa canonica (nella tua lingua preferita) e dovresti produrre il risultato nello stesso formato. Il risultato conterrà sempre almeno una matrice e le matrici possono essere piccole come 1x1. Le matrici conterranno solo numeri interi (firmati) con valore assoluto inferiore a 128.

È possibile scrivere un programma o una funzione e utilizzare uno dei metodi standard per ricevere input e fornire output.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

Questo è code-golf , quindi la risposta valida più breve - misurata in byte - vince.

Casi test

Ogni caso di test ha a) le matrici dell'elenco disposte una accanto all'altra come sarebbero nel codice (questo non è il tuo input), b) l'elenco non formattato senza lo spazio bianco estraneo ( questo è il tuo input), c) il uscita prevista.

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

Gelatina , 20 15 13 11 byte

Fðs⁹œsZµḢḢL

Provalo online!

sfondo

Come la maggior parte delle cose, questa sfida è piuttosto semplice una volta che hai capito cosa devi fare. E alla fine l'ho fatto, dopo tre eliminazioni e un rollback ...

Innanzitutto, dobbiamo capire le dimensioni delle matrici. Questo è più facile di quanto detto: il primo elemento del primo elemento è la prima riga della prima matrice di output, quindi la sua lunghezza è uguale al numero di colonne delle matrici di output quadrate.

Ad esempio, se l'ingresso è

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

il primo elemento del primo elemento è [1, 0, 0], la cui lunghezza è ℓ = 3 .

Se appiattiamo l'input e lo dividiamo in blocchi di quella lunghezza, otteniamo tutte le righe delle matrici di output, sebbene nell'ordine sbagliato. Per il nostro esempio di input, questo dà

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

Per ottenere l'output finale, dobbiamo prima dividere l'array di righe in ℓ blocchi di uguale lunghezza. Per il nostro esempio di input, questo dà

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

Ogni colonna è ora una delle matrici di output, quindi è sufficiente trasporre la matrice di array risultante. Per il nostro esempio di input, questo dà

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

come desiderato.

Come funziona

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 byte

CcJlhhQc.nQJ

Questa è una porta della mia risposta Jelly.

Provalo online!

Come funziona

Pyth analizza il programma come segue (pseudo-codice).

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

Q è una variabile che contiene l'input. J è una variabile indefinita.

Primi J = l(h(h(Q)))memorizza la lunghezza della testa (primo elemento) della testa di Q in J .

Poi, .n(Q)appiattisce Q , e c(..., J)divide il risultato in pezzi di lunghezza J .

Successivamente, c(J, ...)divide il risultato in J pezzi.

Infine, C(...)traspone il risultato.

Pyth , 29 byte

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

Suite di test.

Come funziona

.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

Algoritmo

Lavoriamo sull'input [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]].

Useremo le operazioni di stringa pure qui.

In primo luogo, dividiamo l'input nelle virgole che non fanno parte dell'elenco più profondo (questo viene fatto dividendo in regex \B,):

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

Quindi, troviamo l'indice della prima sottostringa che non inizia con [[(questo viene fatto controllando se il carattere all'indice 1è [). In questo caso, è 4perché la sottostringa all'indice 4 è [0,1]]che non inizia con [[.

Quindi, raggruppiamo le sottostringhe in gruppi di 4, quindi trasponiamo:

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

E poi ci uniamo a loro con le virgole:

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

Esistono quattro casi:

• Un array 1 × n, appena restituito (questo è il primo test, ma invertito)
• Un array m × n che non è stato ancora appiattito, che abbiamo appiattito ricorsivamente di un passo, contando nallo stesso tempo.
• Un array m × n che è stato appiattito, in cui filtriamo ogni nelemento th.
• Un array m × 1, che è appena stato restituito

05AB1E , 11 byte

Una risposta da parte di Dennis . Codice:

¬¬g¹˜sô¬gäø

Utilizza la codifica CP-1252 . Provalo online!

Mathematica, 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}])&

Ingresso

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

produzione

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

ingresso

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

produzione

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

Anche {{{0}}} e {{{-1}}, {{0}}, {{1}}} funzionano anche

-11 byte grazie a Martin Ender