Modifique una array girando la i-ésima fila exactamente i veces en el sentido de las agujas del reloj

Dada una array mat[][] de dimensiones M * N , la tarea es imprimir la array obtenida después de rotar cada i -ésima fila de la array i veces en el sentido de las agujas del reloj.

Ejemplos:

Entrada: mat[][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
Salida:
1 2 3
6 4 5
8 9 7
Explicación:
La fila 0 se gira 0 veces. Por lo tanto, la fila 0 sigue siendo la misma que {1, 2, 3} .
La primera fila se gira 1 vez. Por lo tanto, la primera fila se modifica a {6, 4, 5}.
La segunda fila se gira 2 veces. Por lo tanto, la segunda fila se modifica a {8, 9, 7}.
Después de completar las operaciones anteriores, la array dada se modifica a {{1, 2, 3}, {6, 4, 5}, {8, 9, 7}}.

Entrada: mat[][] = {{1, 2, 3, 4}, {4, 5, 6, 7}, {7, 8, 9, 8}, {7, 8, 9, 8}}
Salida :
1 2 3 4
7 4 5 6
9 8 7 8
8 9 8 7

Enfoque: siga los pasos a continuación para resolver el problema:

  • Recorra la array dada en fila, de manera inteligente y para cada i -ésima fila , realice los siguientes pasos:
    • Invierte la fila actual de la array .
    • Invierte los primeros i elementos de la fila actual.
    • Invierta los últimos (N – i) elementos de la fila actual, donde N es el tamaño actual de la fila.
  • Después de completar los pasos anteriores, imprima la array mat[][] .

A continuación se muestra la implementación del enfoque anterior:

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to rotate every i-th
// row of the matrix i times
void rotateMatrix(vector<vector<int> >& mat)
{
    int i = 0;
 
    // Traverse the matrix row-wise
    for (auto& it : mat) {
 
        // Reverse the current row
        reverse(it.begin(), it.end());
 
        // Reverse the first i elements
        reverse(it.begin(), it.begin() + i);
 
        // Reverse the last (N - i) elements
        reverse(it.begin() + i, it.end());
 
        // Increment count
        i++;
    }
 
    // Print final matrix
    for (auto rows : mat) {
        for (auto cols : rows) {
            cout << cols << " ";
        }
        cout << "\n";
    }
}
 
// Driver Code
int main()
{
    vector<vector<int> > mat
        = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
    rotateMatrix(mat);
 
    return 0;
}

Java

// java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
 
  // Function to reverse arr[] from start to end
  static void reverse(int arr[], int start, int end)
  {
    while (start < end) {
      int temp = arr[start];
      arr[start] = arr[end];
      arr[end] = temp;
      start++;
      end--;
    }
  }
 
  // Function to rotate every i-th
  // row of the matrix i times
  static void rotateMatrix(int mat[][])
  {
    int i = 0;
 
    // Traverse the matrix row-wise
    for (int rows[] : mat) {
 
      // Reverse the current row
      reverse(rows, 0, rows.length - 1);
 
      // Reverse the first i elements
      reverse(rows, 0, i - 1);
 
      // Reverse the last (N - i) elements
      reverse(rows, i, rows.length - 1);
 
      // Increment count
      i++;
    }
 
    // Print final matrix
    for (int rows[] : mat) {
      for (int cols : rows) {
        System.out.print(cols + " ");
      }
      System.out.println();
    }
  }
 
  // Driver Code
  public static void main(String[] args)
  {
 
    int mat[][] = { { 1, 2, 3 },
                   { 4, 5, 6 },
                   { 7, 8, 9 } };
 
    rotateMatrix(mat);
  }
}
 
// This code is contributed by Kingash.

Python3

# Python3 program for the above approach
 
# Function to rotate every i-th
# row of the matrix i times
def rotateMatrix(mat):
     
    i = 0
    mat1 = []
 
    # Traverse the matrix row-wise
    for it in mat:
 
        # Reverse the current row
        it.reverse()
 
        # Reverse the first i elements
        it1 = it[:i]
        it1.reverse()
 
        # Reverse the last (N - i) elements
        it2 = it[i:]
        it2.reverse()
 
        # Increment count
        i += 1
        mat1.append(it1 + it2)
 
    # Print final matrix
    for rows in mat1:
        for cols in rows:
            print(cols, end = " ")
 
        print()
 
# Driver Code
if __name__ == "__main__":
 
    mat = [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ]
     
    rotateMatrix(mat)
 
# This code is contributed by ukasp

C#

// C# program to Modify a matrix
// by rotating ith row exactly
// i times in clockwise direction
using System;
 
class GFG
{
 
  // Reverse each row of matrix
  static void reverse(int N, int[, ] mat, int start, int end)
  {
 
    // Till start < end, swap the element
    // at start and end index
    while (start < end) {
 
      // Swap the element
      int temp = mat[N,start];
      mat[N, start] = mat[N, end];
      mat[N, end] = temp;
 
      // Increment start and decrement
      // end for next pair of swapping
      start++;
      end--;
    } 
  }
 
  // An Inplace function to
  // rotate a N x N matrix
  // by 90 degrees in anti-
  // clockwise direction
  static void rotateMatrix(int N, int[, ] mat)
  {
    int i = 0;
 
    // Performing Transpose
    for(int j = 0; j < N; j++)
    {
      // Reverse the current row
      reverse(j, mat, 0, N - 1);
      // Reverse the first i elements
      reverse(j, mat, 0, i - 1);
 
      // Reverse the last (N - i) elements
      reverse(j, mat, i, N - 1);
 
      // Increment count
      i++;
    }
 
    for (i = 0; i < N; i++) {
      for (int j = 0; j < N; j++)
        Console.Write(mat[i, j] + " ");
      Console.Write("\n");
    }
 
  }
 
  // Driver Code
  static public void Main()
  {
    int N = 3;
 
    // Test Case 1
    int[, ] mat = { { 1, 2, 3 },
                   { 4, 5, 6 },
                   { 7, 8, 9 }};
 
    rotateMatrix(N, mat);
  }
}
 
// This code is contributed by Aarti_Rathi

Javascript

<script>
// javascript program for the above approach
 
// Function to reverse arr[] from start to end
function  reverse(arr,start,end)
{
    while (start < end) {
      let temp = arr[start];
      arr[start] = arr[end];
      arr[end] = temp;
      start++;
      end--;
    }
}
 
 // Function to rotate every i-th
  // row of the matrix i times
function rotateMatrix(mat)
{
    let i = 0;
  
    // Traverse the matrix row-wise
    for (let rows=0;rows<mat.length;rows++) {
  
      // Reverse the current row
      reverse(mat[rows], 0, mat[rows].length - 1);
  
      // Reverse the first i elements
      reverse(mat[rows], 0, i - 1);
  
      // Reverse the last (N - i) elements
      reverse(mat[rows], i, mat[rows].length - 1);
  
      // Increment count
      i++;
    }
  
    // Print final matrix
    for (let rows=0;rows< mat.length;rows++) {
      for (let cols=0;cols< mat[rows].length;cols++) {
        document.write(mat[rows][cols] + " ");
      }
      document.write("<br>");
    }
}
 
// Driver Code
let mat=[[ 1, 2, 3 ],
                   [ 4, 5, 6 ],
                   [ 7, 8, 9 ]];
rotateMatrix(mat);
 
 
// This code is contributed by avanitrachhadiya2155
</script>
Producción: 

1 2 3 
6 4 5 
8 9 7

 

Complejidad de Tiempo: O(M * N)
Espacio Auxiliar: O(1)

Publicación traducida automáticamente

Artículo escrito por ajaykr00kj y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *