Correction de ma notation pour les listes de matrices, partie 1

21

Parfois, j'ai des listes de matrices constantes dans mon code:

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

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

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

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

C'est une terrible utilisation de l'écran immobilier. Je préfère de loin les écrire côte à côte:

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

Vous constaterez qu'il s'agit toujours d'une liste imbriquée syntaxiquement valide, qu'elle n'est tout simplement plus rectangulaire et qu'elle a une structure très différente (en particulier, elle s'approfondit à chaque fois que j'ajoute une matrice plus grande que 1x1). Cependant, il est toujours possible de reconstruire la liste initiale des matrices à partir de cette nouvelle liste.

Pour pouvoir utiliser cette syntaxe à l'avenir, j'ai besoin que vous écriviez du code qui convertit les tableaux qui ont été écrits dans un arrangement horizontal en liste de matrices qu'ils représentent.

Pour vous assurer que les réponses n'effectuent pas de correspondance de motifs 2D sur la mise en page dans le code source, l'entrée sera donnée soit uniquement comme l'objet tableau, soit si vous prenez une représentation sous forme de chaîne, elle ne contiendra aucun espace indiquant comment littéral a été écrit dans le code. Vous obtiendrez donc une entrée comme celle-ci:

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

Et la sortie doit être le tableau suivant ou sa représentation sous forme de chaîne (encore une fois, aucune autre disposition n'est nécessaire):

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

Il s'agit de la première et plus facile partie d'un défi en deux parties. Dans celui-ci, vous pouvez supposer que toutes les matrices sont carrées et ont les mêmes dimensions et qu'elles sont correctement alignées les unes à côté des autres. Dans la deuxième partie, nous assouplirons ces hypothèses.

Règles

L'entrée sera une liste imbriquée ou sa représentation sous forme de chaîne canonique (dans la langue de votre choix), et vous devez sortir le résultat dans le même format. Le résultat contiendra toujours au moins une matrice, et les matrices peuvent être aussi petites que 1x1. Les matrices ne contiendront que des entiers (signés) avec une valeur absolue inférieure à 128.

Vous pouvez écrire un programme ou une fonction et utiliser l'une des méthodes standard de réception d'entrée et de sortie.

Vous pouvez utiliser n'importe quel langage de programmation , mais notez que ces failles sont interdites par défaut.

Il s'agit de code-golf , donc la réponse valide la plus courte - mesurée en octets - l'emporte.

Cas de test

Chaque cas de test a) les matrices de liste disposées bien à côté de l'autre comme ils le seraient dans le code (ce qui est pas votre entrée), b) la liste non formatée sans les espaces blancs étrangers ( c'est votre entrée), c) production attendue.

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]]]
code-golf  array-manipulation  matrix  syntax 
— Martin Ender
source
1
Je pense que je pourrais savoir ce qui a inspiré ce défi ...
— Neil
La [([1, 0], [0, 1]), ([1, 0], [0, -1]), ([0, 1], [1, 0]), ([0, -1], [1, 0])]sortie est-elle valide pour le troisième testcase? C'est une liste mixte et un tuple.
— ovs
@ovs Non, désolé. Puisque le format d'entrée et de sortie doit correspondre, l'entrée correspondante serait [([1,0], ([1, 0}, ...et cela vous donnerait des informations supplémentaires.
— Martin Ender
@Neil qu'est-ce qui a inspiré ce défi?
— caird coinheringaahing
@RandomUser Le désir de tout jouer au golf. La moindre quantité de biens immobiliers à l'écran gagne!
— Dennis

Réponses:

14

Gelée , 20 15 13 11 octets

Fðs⁹œsZµḢḢL

Essayez-le en ligne!

Contexte

Comme la plupart des choses, ce défi est assez simple une fois que vous avez compris ce que vous devez faire. Et je l'ai finalement fait, après trois suppressions et un retour en arrière ...

Tout d'abord, nous devons déterminer les dimensions des matrices. C'est plus facile à faire que dit: le premier élément du premier élément est la première ligne de la première matrice de sortie, donc sa longueur est égale au nombre de colonnes des matrices de sortie carrées.

Par exemple, si l'entrée est

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

le premier élément du premier élément est [1, 0, 0], dont la longueur est ℓ = 3 .

Si nous aplatissons l'entrée et la divisons en morceaux de cette longueur, nous obtenons toutes les lignes des matrices de sortie, bien que dans le mauvais ordre. Pour notre exemple d'entrée, cela donne

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

Pour obtenir la sortie finale, nous devons d'abord diviser le tableau de lignes en ℓ morceaux de longueur égale. Pour notre exemple d'entrée, cela donne

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

Chaque colonne est maintenant l'une des matrices de sortie, donc il ne reste plus qu'à transposer la matrice de tableaux résultante. Pour notre exemple d'entrée, cela donne

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

comme voulu.

Comment ça marche

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.
— Dennis
source
6

Pyth , 12 octets

CcJlhhQc.nQJ

Ceci est un port de ma réponse Jelly.

Essayez-le en ligne!

Comment ça marche

Pyth analyse le programme comme suit (pseudo-code).

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

Q est une variable qui contient l'entrée. J est une variable non définie.

J = l(h(h(Q)))Enregistre d' abord la longueur de la tête (premier élément) de la tête de Q dans J .

Ensuite, .n(Q)aplatit Q , et c(..., J)divise le résultat en morceaux de longueur J .

Ensuite, c(J, ...)divise le résultat en pièces J.

Enfin, C(...)transpose le résultat.

— Dennis
source
1
sancta mater dei
— Leaky Nun
3

Pyth , 29 octets

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

Suite de tests.

Comment ça marche

.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

Algorithme

Travaillons sur l'entrée [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]].

Nous utiliserons ici des opérations de chaîne pure.

Tout d'abord, nous séparons l'entrée aux virgules qui ne font pas partie de la liste la plus profonde (cela se fait en divisant au niveau de l'expression régulière \B,):

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

Ensuite, nous trouvons l'index de la première sous-chaîne qui ne commence pas par [[(cela se fait en vérifiant si le caractère à index 1est [). Dans ce cas, c'est le cas, 4car la sous-chaîne à l'indice 4 est celle [0,1]]qui ne commence pas par [[.

Ensuite, nous regroupons les sous-chaînes en groupes de 4, puis transposons:

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

Et puis nous les joignons avec des virgules:

[[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]
— Leaky Nun
source
2
Vous étiez massivement surpassé par Dennis.
— Erik the Outgolfer
3

JavaScript (ES6), 132 130 octets

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

Il y a quatre cas:

  • Un tableau 1 × n, qui est juste retourné (c'est le premier test, mais inversé)
  • Un tableau m × n qui n'a pas encore été aplati, que nous aplatissons récursivement d'un pas, en comptant nen même temps.
  • Un tableau m × n qui a été aplati, où nous filtrons chaque ne élément.
  • Un tableau m × 1, qui vient d'être renvoyé
— Neil
source
1

Mathematica, 104 octets

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

Contribution

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

production

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

contribution

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

production

{{{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}}} et {{{-1}}, {{0}}, {{1}}} fonctionnent également

-11 octets grâce à Martin Ender

— J42161217
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.