Given a matrix arr[][] of size M*N, where M is the number of rows and N is the number of columns. The task is to reverse the rows and columns of the matrix alternatively i.e start with reversing the 1st row, then the 2nd column, and so on.
Examples:
Input: arr[][] = {
{3, 4, 1, 8},
{11, 23, 43, 21},
{12, 17, 65, 91},
{71, 56, 34, 24}
}
Output: {
{8, 56, 4, 24},
{11, 17, 43, 12},
{91, 65, 23, 21},
{71, 1, 34, 3}
}
Explanation: Operations to be followed:
- Reverse the first row
- Reverse the second column
- Reverse the third row
- Reverse the fourth row
Input: { {11, 23, 43, 21}, {12, 17, 65, 91}, {71, 56, 34, 24} }
Output: { {21, 56, 23, 71}, {12, 17, 65, 91}, {24, 34, 43, 11} }
Approach: The task can be solved by simply running two while loops for traversing rows and columns alternatively. In the end, print the resultant matrix.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
const int N = 4;
const int M = 4;
void showArray(int arr[][N])
{
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++)
cout << arr[i][j] << " ";
cout << endl;
}
}
void reverseAlternate(int arr[][N])
{
int turn = 0;
while (turn < M && turn < N) {
if (turn % 2 == 0) {
int start = 0, end = N - 1, temp;
while (start < end) {
temp = arr[turn][start];
arr[turn][start] = arr[turn][end];
arr[turn][end] = temp;
start += 1;
end -= 1;
}
turn += 1;
}
if (turn % 2 == 1) {
int start = 0, end = M - 1, temp;
while (start < end) {
temp = arr[start][turn];
arr[start][turn] = arr[end][turn];
arr[end][turn] = temp;
start += 1;
end -= 1;
}
turn += 1;
}
}
}
int main()
{
int matrix[][N] = { { 3, 4, 1, 8 },
{ 11, 23, 43, 21 },
{ 12, 17, 65, 91 },
{ 71, 56, 34, 24 } };
reverseAlternate(matrix);
showArray(matrix);
}
|
Java
import java.util.*;
public class GFG
{
static int N = 4;
static int M = 4;
static void showArray(int arr[][])
{
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++)
System.out.print(arr[i][j] + " ");
System.out.println();
}
}
static void reverseAlternate(int arr[][])
{
int turn = 0;
while (turn < M && turn < N) {
if (turn % 2 == 0) {
int start = 0, end = N - 1, temp;
while (start < end) {
temp = arr[turn][start];
arr[turn][start] = arr[turn][end];
arr[turn][end] = temp;
start += 1;
end -= 1;
}
turn += 1;
}
if (turn % 2 == 1) {
int start = 0, end = M - 1, temp;
while (start < end) {
temp = arr[start][turn];
arr[start][turn] = arr[end][turn];
arr[end][turn] = temp;
start += 1;
end -= 1;
}
turn += 1;
}
}
}
public static void main(String args[])
{
int matrix[][] = { { 3, 4, 1, 8 },
{ 11, 23, 43, 21 },
{ 12, 17, 65, 91 },
{ 71, 56, 34, 24 } };
reverseAlternate(matrix);
showArray(matrix);
}
}
|
Python3
N = 4
M = 4
def showArray(arr):
for i in range(M):
for j in range(N):
print(arr[i][j], end = " ")
print()
def reverseAlternate(arr):
turn = 0
while turn < M and turn < N:
if (turn % 2 == 0):
start = 0
end = N - 1
while (start < end):
temp = arr[turn][start]
arr[turn][start] = arr[turn][end]
arr[turn][end] = temp
start += 1
end -= 1
turn += 1
if (turn % 2 == 1):
start = 0
end = M - 1
while (start < end):
temp = arr[start][turn]
arr[start][turn] = arr[end][turn]
arr[end][turn] = temp
start += 1
end -= 1
turn += 1
matrix = [ [ 3, 4, 1, 8 ],
[ 11, 23, 43, 21 ],
[ 12, 17, 65, 91 ],
[ 71, 56, 34, 24 ] ]
reverseAlternate(matrix)
showArray(matrix)
|
C#
using System;
class GFG {
const int N = 4;
const int M = 4;
static void showArray(int[, ] arr)
{
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++)
Console.Write(arr[i, j] + " ");
Console.WriteLine();
}
}
static void reverseAlternate(int[, ] arr)
{
int turn = 0;
while (turn < M && turn < N) {
if (turn % 2 == 0) {
int start = 0, end = N - 1, temp;
while (start < end) {
temp = arr[turn, start];
arr[turn, start] = arr[turn, end];
arr[turn, end] = temp;
start += 1;
end -= 1;
}
turn += 1;
}
if (turn % 2 == 1) {
int start = 0, end = M - 1, temp;
while (start < end) {
temp = arr[start, turn];
arr[start, turn] = arr[end, turn];
arr[end, turn] = temp;
start += 1;
end -= 1;
}
turn += 1;
}
}
}
public static void Main()
{
int[, ] matrix = { { 3, 4, 1, 8 },
{ 11, 23, 43, 21 },
{ 12, 17, 65, 91 },
{ 71, 56, 34, 24 } };
reverseAlternate(matrix);
showArray(matrix);
}
}
|
Javascript
<script>
const N = 4;
const M = 4;
const showArray = (arr) => {
for (let i = 0; i < M; i++) {
for (let j = 0; j < N; j++)
document.write(`${arr[i][j]} `);
document.write("<br/>");
}
}
const reverseAlternate = (arr) => {
let turn = 0;
while (turn < M && turn < N) {
if (turn % 2 == 0) {
let start = 0, end = N - 1, temp;
while (start < end) {
temp = arr[turn][start];
arr[turn][start] = arr[turn][end];
arr[turn][end] = temp;
start += 1;
end -= 1;
}
turn += 1;
}
if (turn % 2 == 1) {
let start = 0, end = M - 1, temp;
while (start < end) {
temp = arr[start][turn];
arr[start][turn] = arr[end][turn];
arr[end][turn] = temp;
start += 1;
end -= 1;
}
turn += 1;
}
}
}
let matrix = [[3, 4, 1, 8],
[11, 23, 43, 21],
[12, 17, 65, 91],
[71, 56, 34, 24]];
reverseAlternate(matrix);
showArray(matrix);
</script>
|
Output8 56 4 24
11 17 43 12
91 65 23 21
71 1 34 3
Time Complexity: O(M*N)
Space Complexity: O(1), no additional extra space is used.