 Open in App
Not now

# Check if rows of a Matrix can be rearranged to make Bitwise XOR of first column non-zero

• Last Updated : 23 Apr, 2021

Given a matrix mat[][] of size N * M, the task is to check if it is possible to rearrange the row elements of the matrix such that Bitwise XOR of the first column element is non-zero. If it is possible then print “Yes” else print “No”.

Examples:

Input: mat[][] = {{1, 1, 2}, {2, 2, 2}, {3, 3, 3}}
Output: Yes
Explanation:
After rearranging the first row as 2, 1, 1.
Bitwise XOR of the first column will be 3 i.e., (2 ^ 2 ^ 3).

Input: mat[][] = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}}
Output: No
Explanation:
As all the rearrangements give same first element so the only combination is (1 ^ 2 ^ 3) which equals zero.
Therefore, it is not possible to obtain non-zero Bitwise XOR of the first column.

Approach: Follow the steps below to solve the problem:

• Find the Bitwise XOR of the elements of the first column of the matrix and store it in a variable res.
• If res is non-zero then print “Yes”.
• Else, iterate over all the rows and find the element in a row which is not equal to the element at the first index of this row.
• If no such element is present in any row in the above step then print “No” else then print “Yes”.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to check if there is any``// row where number of unique elements``// are greater than 1``string checkRearrangements(``    ``vector > mat, ``int` `N, ``int` `M)``{``    ``// Iterate over the matrix``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``for` `(``int` `j = 1; j < M; j++) {` `            ``if` `(mat[i] != mat[i][j]) {` `                ``return` `"Yes"``;``            ``}``        ``}``    ``}``    ``return` `"No"``;``}` `// Function to check if it is possible``// to rearrange mat[][] such that XOR``// of its first column is non-zero``string nonZeroXor(vector > mat,``                  ``int` `N, ``int` `M)``{``    ``int` `res = 0;` `    ``// Find bitwise XOR of the first``    ``// column of mat[][]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``res = res ^ mat[i];``    ``}` `    ``// If bitwise XOR of the first``    ``// column of mat[][] is non-zero``    ``if` `(res != 0)``        ``return` `"Yes"``;` `    ``// Otherwise check rearrangements``    ``else``        ``return` `checkRearrangements(mat, N, M);``}` `// Driver Code``int` `main()``{``    ``// Given Matrix mat[][]``    ``vector > mat``        ``= { { 1, 1, 2 },``            ``{ 2, 2, 2 },``            ``{ 3, 3, 3 } };` `    ``int` `N = mat.size();``    ``int` `M = mat.size();` `    ``// Function Call``    ``cout << nonZeroXor(mat, N, M);` `    ``return` `0;``}`

## Java

 `// Java program for the``// above approach``import` `java.util.*;``class` `GFG{` `// Function to check if there is any``// row where number of unique elements``// are greater than 1``static` `String checkRearrangements(``int``[][] mat,``                                  ``int` `N, ``int` `M)``{``  ``// Iterate over the matrix``  ``for` `(``int` `i = ``0``; i < N; i++)``  ``{``    ``for` `(``int` `j = ``1``; j < M; j++)``    ``{``      ``if` `(mat[i][``0``] != mat[i][j])``      ``{``        ``return` `"Yes"``;``      ``}``    ``}``  ``}``  ``return` `"No"``;``}` `// Function to check if it is possible``// to rearrange mat[][] such that XOR``// of its first column is non-zero``static` `String nonZeroXor(``int``[][] mat,``                         ``int` `N, ``int` `M)``{``  ``int` `res = ``0``;` `  ``// Find bitwise XOR of the``  ``// first column of mat[][]``  ``for` `(``int` `i = ``0``; i < N; i++)``  ``{``    ``res = res ^ mat[i][``0``];``  ``}` `  ``// If bitwise XOR of the first``  ``// column of mat[][] is non-zero``  ``if` `(res != ``0``)``    ``return` `"Yes"``;` `  ``// Otherwise check``  ``// rearrangements``  ``else``    ``return` `checkRearrangements(mat,``                               ``N, M);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``// Given Matrix mat[][]``  ``int``[][] mat = {{``1``, ``1``, ``2``},``                 ``{``2``, ``2``, ``2``},``                 ``{``3``, ``3``, ``3``}};` `  ``int` `N = mat.length;``  ``int` `M = mat[``0``].length;` `  ``// Function Call``  ``System.out.print(nonZeroXor(mat,``                              ``N, M));``}``}` `// This code is contributed by gauravrajput1`

## Python3

 `# Python3 program for the above approach` `# Function to check if there is any``# row where number of unique elements``# are greater than 1``def` `checkRearrangements(mat, N, M):``    ` `    ``# Iterate over the matrix``    ``for` `i ``in` `range``(N):``        ``for` `j ``in` `range``(``1``, M):``            ``if` `(mat[i][``0``] !``=` `mat[i][j]):``                ``return` `"Yes"``                ` `    ``return` `"No"` `# Function to check if it is possible``# to rearrange mat[][] such that XOR``# of its first column is non-zero``def` `nonZeroXor(mat, N, M):` `    ``res ``=` `0` `    ``# Find bitwise XOR of the first``    ``# column of mat[][]``    ``for` `i ``in` `range``(N):``        ``res ``=` `res ^ mat[i][``0``]` `    ``# If bitwise XOR of the first``    ``# column of mat[][] is non-zero``    ``if` `(res !``=` `0``):``        ``return` `"Yes"` `    ``# Otherwise check rearrangements``    ``else``:``        ``return` `checkRearrangements(mat, N, M)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Given Matrix mat[][]``    ``mat ``=` `[ [ ``1``, ``1``, ``2` `],``            ``[ ``2``, ``2``, ``2` `],``            ``[ ``3``, ``3``, ``3` `] ]` `    ``N ``=` `len``(mat)``    ``M ``=` `len``(mat[``0``])` `    ``# Function Call``    ``print``(nonZeroXor(mat, N, M))` `# This code is contributed by chitranayal`

## C#

 `// C# program for the``// above approach``using` `System;` `class` `GFG{` `// Function to check if there is any``// row where number of unique elements``// are greater than 1``static` `String checkRearrangements(``int``[,] mat,``                                  ``int` `N, ``int` `M)``{``  ` `  ``// Iterate over the matrix``  ``for``(``int` `i = 0; i < N; i++)``  ``{``    ``for``(``int` `j = 1; j < M; j++)``    ``{``      ``if` `(mat[i, 0] != mat[i, j])``      ``{``        ``return` `"Yes"``;``      ``}``    ``}``  ``}``  ``return` `"No"``;``}` `// Function to check if it is possible``// to rearrange [,]mat such that XOR``// of its first column is non-zero``static` `String nonZeroXor(``int``[,] mat,``                         ``int` `N, ``int` `M)``{``  ``int` `res = 0;` `  ``// Find bitwise XOR of the``  ``// first column of [,]mat``  ``for``(``int` `i = 0; i < N; i++)``  ``{``    ``res = res ^ mat[i, 0];``  ``}` `  ``// If bitwise XOR of the first``  ``// column of [,]mat is non-zero``  ``if` `(res != 0)``    ``return` `"Yes"``;` `  ``// Otherwise check``  ``// rearrangements``  ``else``    ``return` `checkRearrangements(mat,``                               ``N, M);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ` `  ``// Given Matrix [,]mat``  ``int``[,] mat = { { 1, 1, 2 },``                 ``{ 2, 2, 2 },``                 ``{ 3, 3, 3 } };` `  ``int` `N = mat.GetLength(0);``  ``int` `M = mat.GetLength(1);` `  ``// Function Call``  ``Console.Write(nonZeroXor(mat,``                           ``N, M));``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(N * M)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up