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