Programme JavaScript pour vérifier si toutes les lignes d'une matrice sont des rotations cycliques les unes des autres

Matrix est une sorte de tableau 2D dans lequel il y a un tableau de tableaux fixes qui définit les lignes et pour chaque index de ce tableau il y a des tableaux de longueur fixe présents et la longueur de ces tableaux définit le nombre de colonnes présents dans la matrice. Nous pouvons stocker tout type de données dans ces cellules fournies par la matrice.

Nous recevrons une matrice et chaque ligne contient des entiers et nous devons vérifier si chaque ligne est la rotation l'une de l'autre ou non. La rotation les uns des autres signifie que par un certain nombre ou des rotations à gauche ou à droite, nous pouvons produire la même combinaison de chaque rangée.

Exemple 1

让我们假设给定的矩阵是：

mat = [ [1, 2, 3],
   [2, 3, 1],
   [3, 1, 2]]
Output: Yes

Explication : en supposant que la première ligne est constante et en faisant pivoter la ligne restante, nous pouvons obtenir le résultat suivant :

En tournant la deuxième rangée une fois vers la droite et en tournant la deuxième rangée deux fois vers la droite, nous pouvons rendre les deux identiques à la première rangée.

Exemple 2

的翻译为：

示例2

mat = [ [1, 2, 3],
   [ 2, 1, 3],
   [ 1, 2, 3]]
Output: No

解释：在上面的矩阵中，第一行和第三行是相同的，但我们无法通过任意次数的旋转将第二行转换为第一行。

Approche

Nous avons vu un exemple approprié pour comprendre le problème, voyons maintenant les étapes pour implémenter le code −

Rotation, rotation, rotation的元素。
之后，我们将定义检查函数，并将给定的矩阵传递给检查函数。
在该函数中，我们首先通过获取行和列的数量来获取矩阵的长度，并使用for循环从第1行到最后一行与第0行进行比较。
如果当前行与第一行相同，则我们将跳过到下一行。
否则，我们将调用 rotation 函数，并将给定的行旋转到其下一个旋转位置。
Nous ferons ce processus jusqu'à ce que nous trouvions le même tableau que la zéroième ligne ou la longueur des colonnes un certain nombre de fois.
Si la ligne actuelle n'est pas égale au zéro même après les rotations maximales, nous renverrons false.
如果所有的行最终变得相等，那么我们将返回true。
Exemple

在下面的示例中，我们检查矩阵的所有行是否是彼此的循环旋转。输入和预期输出如下所示。

输入：matrice = [ [ 1, 2, 3 ], [ 2, 3, 1 ], [ 3, 1, 2 ] ]

Sortie : Oui

// function to rotate the given array
function rotate(arr){
   var l = 0;
   var r = arr.length-1;
   while(l < r){
      arr[l] += arr[r];
      arr[r] = arr[l]-arr[r];
      arr[l] = arr[l]-arr[r];
      l++;
   }
   return arr;
}

// function to check if the given matrix can have the same rows
// after the certain number of rotations
function check(mat){

   // getting number of rows
   var rows = mat.length
   
   // getting number of columns
   var cols = mat[0].length
   
   // traversing over the each row of given matrix
   for(var i = 1; i < rows; i++){
      var k = 0;
      while(k < cols) {
         var j = 0;
         for(j = 0; j<cols; j++){
            if(mat[0][j] != mat[i][j]){
               break;
            }
         }
         if(j == cols){
            break;
         }
         else{
            mat[i] = rotate(mat[i]);
         }
         k++;
      }
      if(k == cols){
         return false;
      }
   }
   return true;
}

// defining the matrix
var mat = [ [1, 2, 3],
   [2, 3, 1],
   [3, 1, 2]];
console.log("The given matrix is: ");
console.log(mat);
if(check(mat) == true){
   console.log("Yes, all the rows of the matrix are circular rotation of each other");
}
else{
   console.log("NO, all the rows of the matrix are not in the circular rotation of each other");
}

输出

The given matrix is: 
[ [ 1, 2, 3 ], [ 2, 3, 1 ], [ 3, 1, 2 ] ]
Yes, all the rows of the matrix are circular rotation of each other

时间和空间复杂度

La complexité temporelle du code ci-dessus est O(N*M*M) où N est le nombre de lignes et M est le nombre de colonnes présentes dans la matrice donnée. Nous parcourons la matrice par ligne, ce qui donne le facteur ou N et pour la comparaison et les rotations des lignes, le facteur ou M*M.

上述代码的空间复杂度为O(1)，因为我们没有使用任何额外的空间。

Conclusion

在本教程中，我们已经实现了JavaScript程序，通过旋转每一行并与第一行进行比较，来检查给定矩阵的所有行是否彼此为循环旋转。我们使用了两个指针和交换方法来旋转给定矩阵的行。上述代码的时间复杂度为O(N*M*M),空间复杂度为O(1)。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!