Friday, January 10, 2025
Google search engine
HomeData Modelling & AISwap the elements between any two given quadrants of a Matrix

Swap the elements between any two given quadrants of a Matrix

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++




// 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


Java




// 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);
    }
}


Python3




# 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


C#




// 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


Javascript




<script>
// javascript program for the
// above approach
 
   // Function to iterate over the X
    // quadrant and swap its element
    // with Y quadrant
    function swap(
        N, M, mat,
        startx_X, starty_X,
        startx_Y, starty_Y)
    {
  
        let row = 0;
        let col = 0;
  
        // Iterate over X quadrant
        for (let i = startx_X;; i++)
        {
            col = 0;
            for (let j = startx_X;; j++) {
  
                // Swap operations
                let 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
    function swapQuadOfMatrix(
        N, M, mat, X, 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
        prletMat(N, M, mat);
    }
  
    // Function to print the matrix
    function prletMat(N, M, mat)
    {
        // Iterate over the rows
        for (let i = 0; i < N; i++) {
  
            // Iterate over the cols
            for (let j = 0; j < M; j++) {
  
                document.write(
                    mat[i][j] + " ");
            }
            document.write("<br/>");
        }
    }
  
// Driver Code
 
     // Given matrix
        let N = 6, M = 6;
        let 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
        let X = 1, Y = 4;
  
        // Function Call
        swapQuadOfMatrix(N, M, mat, X, Y);
 
// This code is contributed by avijitmondal1998.
</script>


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(N*M) // N is the no of rows and M is the no of columns
Auxiliary Space: O(1) 

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments