Transposition d'un tableau 2D en JavaScript

Question

J'ai un tableau de tableaux, quelque chose comme.. :

[
    [1,2,3],
    [1,2,3],
    [1,2,3],
]

Je voudrais le transposer pour obtenir le tableau suivant :

[
    [1,1,1],
    [2,2,2],
    [3,3,3],
]

Il n'est pas difficile de le faire par programmation en utilisant des boucles :

function transposeArray(array, arrayLength){
    var newArray = [];
    for(var i = 0; i < array.length; i++){
        newArray.push([]);
    };

    for(var i = 0; i < array.length; i++){
        for(var j = 0; j < arrayLength; j++){
            newArray[j].push(array[i][j]);
        };
    };

    return newArray;
}

Cependant, cela semble encombrant, et j'ai l'impression qu'il devrait y avoir un moyen plus facile de le faire. Y en a-t-il un ?

Answer 1

Ajout de la version TS ici.

const transpose = <T>(m: Array<Array<T>>): Array<Array<T>> => m[0].map((_, i) => m.map(x => x[i]));

Answer 2

function invertArray(array,arrayWidth,arrayHeight) {
  var newArray = [];
  for (x=0;x<arrayWidth;x++) {
    newArray[x] = [];
    for (y=0;y<arrayHeight;y++) {
        newArray[x][y] = array[y][x];
    }
  }
  return newArray;
}

Answer 3

Une seule ligne qui ne change pas le tableau donné.

a[0].map((col, i) => a.map(([...row]) => row[i]))

Answer 4

reverseValues(values) {
        let maxLength = values.reduce((acc, val) => Math.max(val.length, acc), 0);
        return [...Array(maxLength)].map((val, index) => values.map((v) => v[index]));
}

Answer 5

Celle-ci est non seulement très efficace, mais aussi très courte.

Complexité temporelle de l'algorithme : O(n log n)

const matrix = [
   [1,1,1,1],
   [2,2,2,2],
   [3,3,3,3],
   [4,4,4,4]
];

matrix.every((r, i, a) => (
   r.every((_, j) => (
      j = a.length-j-1,
      [ r[j], a[j][i] ] = [ a[j][i], r[j] ],
      i < j-1
   )), 
   i < length-2
));

console.log(matrix);
/*
Prints:
[
   [1,2,3,4],
   [1,2,3,4],
   [1,2,3,4],
   [1,2,3,4]
]
*/

L'exemple ci-dessus ne fera que 6 itérations.
Pour une matrice plus grande, disons 100x100, il effectuera 4 900 itérations, ce qui est 51% plus rapide que toute autre solution fournie ici.

Le principe est simple, vous ne devez itérer que sur la moitié diagonale supérieure de la matrice, car la ligne diagonale ne change jamais et la moitié diagonale inférieure est commutée en même temps que la supérieure, il n'y a donc aucune raison de l'itérer également. De cette façon, vous économisez beaucoup de temps d'exécution, en particulier dans une grande matrice.