Related Articles

Related Articles

Swap the elements between any two given quadrants of a Matrix
  • Difficulty Level : Medium
  • Last Updated : 03 Nov, 2020

Given a matrix, mat[][] of size N * M, where N and M is always even, and two integers X and Y, the task is to swap all the elements of the quadrant X quadrant with all the corresponding elements of quadrant Y of the given matrix.

Note: The top-left, top-right, bottom-left, and bottom-right quadrants are numbered 1, 2, 3, and 4 respectively.
Examples: 
 

Input: mat[][] = {{99, 10, 11, 12, 13, 14, 15, 16}, {17, 18, 19, 20, 21, 22, 23, 24}, {25, 26, 27, 28, 29, 30, 31, 32}, {33, 34, 35, 36, 37, 38, 39, 40}, {41, 42, 43, 44, 45, 46, 47, 48}, {49, 50, 51, 52, 53, 54, 55, 56}}, X = 1, Y = 4 
Output: {{37, 38, 39, 40, 13, 14, 15, 16}, { 45, 46, 47, 48, 21, 22, 23, 24}, { 53, 54, 55, 56, 29, 30, 31, 32}, {33, 34, 35, 36, 99, 10, 11, 12}, {41, 42, 43, 44, 17, 18, 19, 20}, {49, 50, 51, 52, 25, 26, 27, 28}} 
Explanation: 
Given Matrix: 
 

Swap the 1st quadrant of the matrix with 4th quadrant of the matrix: 
 



 

Input: mat[][] = {{1, 2}, {3, 4}}, X = 1, Y = 4 
Output: {{4, 2}, {3, 1}} 
 

Approach: The idea is to iterate over the X quadrant of the matrix and swap its elements with the corresponding elements of the Y quadrant. To get the starting positions of any quadrant when a matrix mat[][] of size N*M below is the condition for the same:  

  • Quadrant 1: The starting position of the quadrant is (0, 0).
  • Quadrant 2: The starting position of the quadrant is (0, M/2).
  • Quadrant 3: The starting position of the quadrant is (N/2, 0).
  • Quadrant 4: The starting position of the quadrant is (N/2, M/2).

Follow the steps below to solve the problem:  

  1. Iterate over the X and Y quadrants of the matrix simultaneously from their starting positions.
  2. Now, swap the elements of X quadrant with the corresponding indexed elements of Y quadrant.
  3. Print all elements of the matrix mat[][] after performing all the swap operations.

Below is the implementation of the above approach:
 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for
// the above approach
#include<bits/stdc++.h>
using namespace std;
#define N 6
#define M 6
 
// Function to iterate over the X
// quadrant and swap its element
// with Y quadrant
void swap(int mat[N][M],
          int startx_X, int starty_X,
          int startx_Y, int starty_Y)
{
  int row = 0;
  int col = 0;
 
  // Iterate over X quadrant
  for (int i = startx_X;; i++)
  {
    col = 0;
 
    for (int j = startx_X;; j++)
    {
      // Swap operations
      int temp = mat[i][j];
 
      mat[i][j] = mat[startx_Y + row][starty_Y + col];
      mat[startx_Y + row][starty_Y + col] = temp;
      col++;
      if (col >= M / 2)
        break;
    }
    row++;
 
    if (row >= N / 2)
      break;
  }
}
 
// Function to print the matrix
void printMat(int mat[N][M])
{
  // Iterate over the rows
  for (int i = 0; i < N; i++)
  {
    // Iterate over the cols
    for (int j = 0; j < M; j++)
    {
      cout << mat[i][j] << " ";
    }
    cout << endl;
  }
}
 
// Function to swap the elements
// of the two given quadrants
static void swapQuadOfMatrix(int mat[N][M],
                             int X, int Y)
{
  // Swapping the coordinates on
  // basis of the value of X and Y
 
  // For Swapping 1st and 2nd Quadrant
  if (X == 1 && Y == 2)
  {
    swap(mat, 0, 0, 0, M / 2);
  }
 
  // For Swapping 1st and 3rd Quadrant
  else if (X == 1 && Y == 3)
  {
    swap(mat, 0, 0, N / 2, 0);
  }
 
  // For Swapping 1st and 4th Quadrant
  else if (X == 1 && Y == 4)
  {
    swap(mat, 0, 0, N / 2, M / 2);
  }
 
  // For Swapping 2nd and 3rd Quadrant
  else if (X == 2 && Y == 3)
  {
    swap(mat, 0, M / 2, N / 2, 0);
  }
 
  // For Swapping 2nd and 4th Quadrant
  else if (X == 2 && Y == 4)
  {
    swap(mat, 0, M / 2, N / 2, M / 2);
  }
 
  // For Swapping 3rd and 4th Quadrant
  else if (X == 3 && Y == 4)
  {
    swap(mat, N / 2, 0, N / 2, M / 2);
  }
 
  // Print the resultant matrix
  printMat(mat);
}
 
// Driver Code
int main()
{
  // Given matrix
 
  int mat[][M] = {{1, 2, 3, 4, 5, 6},
                  {7, 8, 9, 10, 11, 12},
                  {13, 14, 15, 16, 17, 18},
                  {19, 20, 21, 22, 23, 24},
                  {25, 26, 27, 28, 29, 30},
                  {31, 32, 33, 34, 35, 36}};
 
  // Given quadrants
  int X = 1, Y = 4;
 
  // Function Call
  swapQuadOfMatrix(mat, X, Y);
}
 
// This code is contributed by shikhasingrajput

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
 
public class Main {
 
    // Function to iterate over the X
    // quadrant and swap its element
    // with Y quadrant
    static void swap(
        int N, int M, int mat[][],
        int startx_X, int starty_X,
        int startx_Y, int starty_Y)
    {
 
        int row = 0;
        int col = 0;
 
        // Iterate over X quadrant
        for (int i = startx_X;; i++) {
 
            col = 0;
 
            for (int j = startx_X;; j++) {
 
                // Swap operations
                int temp = mat[i][j];
 
                mat[i][j]
                    = mat[startx_Y + row][starty_Y + col];
                mat[startx_Y + row][starty_Y + col] = temp;
 
                col++;
                if (col >= M / 2)
                    break;
            }
            row++;
 
            if (row >= N / 2)
                break;
        }
    }
 
    // Function to swap the elements
    // of the two given quadrants
    static void swapQuadOfMatrix(
        int N, int M,
        int mat[][], int X, int Y)
    {
        // Swapping the coordinates on
        // basis of the value of X and Y
 
        // For Swapping 1st and 2nd Quadrant
        if (X == 1 && Y == 2) {
            swap(N, M, mat, 0, 0, 0, M / 2);
        }
 
        // For Swapping 1st and 3rd Quadrant
        else if (X == 1 && Y == 3) {
            swap(N, M, mat, 0, 0, N / 2, 0);
        }
 
        // For Swapping 1st and 4th Quadrant
        else if (X == 1 && Y == 4) {
            swap(N, M, mat, 0, 0, N / 2, M / 2);
        }
 
        // For Swapping 2nd and 3rd Quadrant
        else if (X == 2 && Y == 3) {
            swap(N, M, mat, 0,
                 M / 2, N / 2, 0);
        }
 
        // For Swapping 2nd and 4th Quadrant
        else if (X == 2 && Y == 4) {
            swap(N, M, mat, 0, M / 2,
                 N / 2, M / 2);
        }
 
        // For Swapping 3rd and 4th Quadrant
        else if (X == 3 && Y == 4) {
            swap(N, M, mat, N / 2, 0,
                 N / 2, M / 2);
        }
 
        // Print the resultant matrix
        printMat(N, M, mat);
    }
 
    // Function to print the matrix
    static void printMat(int N, int M,
                         int mat[][])
    {
        // Iterate over the rows
        for (int i = 0; i < N; i++) {
 
            // Iterate over the cols
            for (int j = 0; j < M; j++) {
 
                System.out.print(
                    mat[i][j] + " ");
            }
            System.out.println();
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given matrix
        int N = 6, M = 6;
        int[][] mat = { { 1, 2, 3, 4, 5, 6 },
                        { 7, 8, 9, 10, 11, 12 },
                        { 13, 14, 15, 16, 17, 18 },
                        { 19, 20, 21, 22, 23, 24 },
                        { 25, 26, 27, 28, 29, 30 },
                        { 31, 32, 33, 34, 35, 36 } };
 
        // Given quadrants
        int X = 1, Y = 4;
 
        // Function Call
        swapQuadOfMatrix(N, M, mat, X, Y);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for
# the above approach
N, M = 6, 6
 
# Function to iterate over
# the X quadrant and swap
# its element with Y quadrant
def swap(mat, startx_X, starty_X,
         startx_Y, starty_Y):
     
    row,col = 0, 0
 
    # Iterate over X quadrant
    i = startx_X
     
    while(bool(True)):
     
        col = 0       
        j = startx_X
         
        while(bool(True)):
           
            # Swap operations
            temp = mat[i][j]
         
            mat[i][j] = mat[startx_Y + row][starty_Y + col]
            mat[startx_Y + row][starty_Y + col] = temp
            col += 1
            if col >= M // 2:
                break
             
            j += 1
             
        row += 1
     
        if row >= N // 2:
            break
         
        i += 1
 
# Function to print the
# matrix
def printMat(mat):
 
    # Iterate over the rows
    for i in range(N):
     
        # Iterate over the cols
        for j in range(M):       
            print(mat[i][j],
                  end = " ")
           
        print()
 
# Function to swap the
# elements of the two
# given quadrants
def swapQuadOfMatrix(mat, X, Y):
 
    # Swapping the coordinates
    # on basis of the value of
    # X and Y
     
    # For Swapping 1st and
    # 2nd Quadrant
    if (X == 1 and Y == 2):
     
        swap(mat, 0, 0,
             0, M // 2)
     
    # For Swapping 1st and
    # 3rd Quadrant
    elif (X == 1 and Y == 3):
     
        swap(mat, 0, 0,
             N // 2, 0)
     
    # For Swapping 1st and
    # 4th Quadrant
    elif (X == 1 and Y == 4):
     
        swap(mat, 0, 0,
             N // 2, M // 2)
     
    # For Swapping 2nd and
    # 3rd Quadrant
    elif (X == 2 and Y == 3):
     
        swap(mat, 0, M // 2,
             N // 2, 0)
     
    # For Swapping 2nd and
    # 4th Quadrant
    elif (X == 2 and Y == 4):
     
        swap(mat, 0, M // 2,
             N // 2, M // 2)
     
    # For Swapping 3rd and
    # 4th Quadrant
    elif (X == 3 and Y == 4):
     
        swap(mat, N // 2, 0,
             N // 2, M // 2)
     
    # Print the resultant
    # matrix
    printMat(mat)   
 
# Driver code
# Given matrix
mat = [[1, 2, 3, 4, 5, 6],
       [7, 8, 9, 10, 11, 12],
       [13, 14, 15, 16, 17, 18],
       [19, 20, 21, 22, 23, 24],
       [25, 26, 27, 28, 29, 30],
       [31, 32, 33, 34, 35, 36]]
 
# Given quadrants
X, Y = 1, 4
 
# Function Call
swapQuadOfMatrix(mat, X, Y)
 
# This code is contributed by divyeshrabadiya07

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for
// the above approach
using System;
class GFG{
 
// Function to iterate over the X
// quadrant and swap its element
// with Y quadrant
static void swap(int N, int M, int [,]mat,
                 int startx_X, int starty_X,
                 int startx_Y, int starty_Y)
{
  int row = 0;
  int col = 0;
 
  // Iterate over X quadrant
  for (int i = startx_X;; i++)
  {
    col = 0;
 
    for (int j = startx_X;; j++)
    {
      // Swap operations
      int temp = mat[i, j];
 
      mat[i, j] = mat[startx_Y + row,
                      starty_Y + col];
      mat[startx_Y + row, starty_Y + col] = temp;
 
      col++;
      if (col >= M / 2)
        break;
    }
    row++;
 
    if (row >= N / 2)
      break;
  }
}
 
// Function to swap the elements
// of the two given quadrants
static void swapQuadOfMatrix(int N, int M,
                             int [,]mat,
                             int X, int Y)
{
  // Swapping the coordinates on
  // basis of the value of X and Y
 
  // For Swapping 1st and 2nd Quadrant
  if (X == 1 && Y == 2)
  {
    swap(N, M, mat, 0, 0, 0, M / 2);
  }
 
  // For Swapping 1st and 3rd Quadrant
  else if (X == 1 && Y == 3)
  {
    swap(N, M, mat, 0, 0, N / 2, 0);
  }
 
  // For Swapping 1st and 4th Quadrant
  else if (X == 1 && Y == 4)
  {
    swap(N, M, mat, 0, 0, N / 2, M / 2);
  }
 
  // For Swapping 2nd and 3rd Quadrant
  else if (X == 2 && Y == 3)
  {
    swap(N, M, mat, 0, M / 2, N / 2, 0);
  }
 
  // For Swapping 2nd and 4th Quadrant
  else if (X == 2 && Y == 4)
  {
    swap(N, M, mat, 0, M / 2, N / 2, M / 2);
  }
 
  // For Swapping 3rd and 4th Quadrant
  else if (X == 3 && Y == 4)
  {
    swap(N, M, mat, N / 2, 0, N / 2, M / 2);
  }
 
  // Print the resultant matrix
  printMat(N, M, mat);
}
 
// Function to print the matrix
static void printMat(int N, int M,
                     int [,]mat)
{
  // Iterate over the rows
  for (int i = 0; i < N; i++)
  {
    // Iterate over the cols
    for (int j = 0; j < M; j++)
    {
      Console.Write(mat[i, j] + " ");
    }
    Console.WriteLine();
  }
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given matrix
  int N = 6, M = 6;
  int[,] mat = {{1, 2, 3, 4, 5, 6},
                {7, 8, 9, 10, 11, 12},
                {13, 14, 15, 16, 17, 18},
                {19, 20, 21, 22, 23, 24},
                {25, 26, 27, 28, 29, 30},
                {31, 32, 33, 34, 35, 36}};
 
  // Given quadrants
  int X = 1, Y = 4;
 
  // Function Call
  swapQuadOfMatrix(N, M, mat, X, Y);
}
}
 
// This code is contributed by gauravrajput1

chevron_right


Output: 

22 23 24 4 5 6 
28 29 30 10 11 12 
34 35 36 16 17 18 
19 20 21 1 2 3 
25 26 27 7 8 9 
31 32 33 13 14 15







 

Time Complexity: O(N2
Auxiliary Space: O(1) 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up
Recommended Articles
Page :