XOR of major diagonal elements of a 3D Matrix
Last Updated :
08 Jun, 2021
Given a 3D matrix mat[][][] of dimensions N * N * N consisting of positive integers, the task is to calculate Bitwise XOR of all matrix elements present in the major diagonal.
Examples:
Input: arr[][][] = {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}
Output: 12
Explanation: The major diagonal elements are {1, 8, 2, 7}. Therefore, the Bitwise XOR of all these elements is 12.
Input: arr[][][]={{{1}}}
Output: 0
Explanation: There 2 major diagonals of the matrix are {1}, {1}. Therefore, the Bitwise XOR of the major diagonal elements is 0.
Naive Approach: The simplest approach top solve the problem is to traverse the given 3D matrix mat[][][] using three nested loops, using variables, say i, j, and k, and calculate Bitwise XOR of mat[i][j][k] and mat[i][j][N – k – 1], if the value of i, j, and k are equal. After completing the traversal of the matrix, print the value of Bitwise XOR obtained.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void findXOR(
vector<vector<vector<int> > >& mat,
int N)
{
int XOR = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
if ((i == j && j == k)) {
XOR ^= mat[i][j][k];
XOR ^= mat[i][j][N - k - 1];
}
}
}
}
cout << XOR << "\n";
}
int main()
{
vector<vector<vector<int> > > mat
= { { { 1, 2 }, { 3, 4 } },
{ { 5, 6 }, { 7, 8 } } };
int N = mat.size();
findXOR(mat, N);
return 0;
}
|
Java
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG{
static void findXOR(int mat[][][], int N)
{
int XOR = 0;
for(int i = 0; i < N; i++)
{
for(int j = 0; j < N; j++)
{
for(int k = 0; k < N; k++)
{
if ((i == j && j == k))
{
XOR ^= mat[i][j][k];
XOR ^= mat[i][j][N - k - 1];
}
}
}
}
System.out.println(XOR);
}
public static void main(String[] args)
{
int mat[][][] = { { { 1, 2 }, { 3, 4 } },
{ { 5, 6 }, { 7, 8 } } };
int N = mat.length;
findXOR(mat, N);
}
}
|
Python3
def findXOR(mat, N):
XOR = 0
for i in range(N):
for j in range(N):
for k in range(N):
if ((i == j and j == k)):
XOR ^= mat[i][j][k]
XOR ^= mat[i][j][N - k - 1]
print(XOR)
mat = [ [ [ 1, 2 ], [ 3, 4 ] ],
[ [ 5, 6 ], [ 7, 8 ] ] ]
N = len(mat)
findXOR(mat, N)
|
C#
using System;
class GFG{
static void findXOR(int[, , ] mat, int N)
{
int XOR = 0;
for(int i = 0; i < N; i++)
{
for(int j = 0; j < N; j++)
{
for(int k = 0; k < N; k++)
{
if ((i == j && j == k))
{
XOR ^= mat[i, j, k];
XOR ^= mat[i, j, N - k - 1];
}
}
}
}
Console.WriteLine(XOR);
}
public static void Main(string[] args)
{
int[,,] mat = { { { 1, 2 }, { 3, 4 } },
{ { 5, 6 }, { 7, 8 } } };
int N = mat.GetLength(0);
findXOR(mat, N);
}
}
|
Javascript
<script>
function findXOR(mat, N)
{
let XOR = 0;
for(let i = 0; i < N; i++)
{
for(let j = 0; j < N; j++)
{
for(let k = 0; k < N; k++)
{
if ((i == j && j == k))
{
XOR ^= mat[i][j][k];
XOR ^= mat[i][j][N - k - 1];
}
}
}
}
document.write(XOR);
}
let mat = [[[1, 2 ], [ 3, 4 ]],
[[ 5, 6 ], [ 7, 8 ]]];
let N = mat.length;
findXOR(mat, N);
</script>
|
Time Complexity: O(N3)
Auxiliary Space: O(1)
Efficient Approach: The above approach can be optimized by using the fact that the element whose indices i, j, and k are same as the diagonal elements. Therefore, the idea is to iterate over the range of indices [0, N – 1] using a variable i and calculate Bitwise XOR of all the elements that are a part of major diagonals at indices (i, i, i) and (i, i, N – i – 1) in the given matrix mat[][][] as mat[i][i][i] and mat[i][i][N – i – 1] respectively.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void findXOR(
vector<vector<vector<int> > >& mat,
int N)
{
int XOR = 0;
for (int i = 0; i < N; i++) {
XOR ^= mat[i][i][i];
XOR ^= mat[i][i][N - i - 1];
}
cout << XOR << "\n";
}
int main()
{
vector<vector<vector<int> > > mat
= { { { 1, 2 }, { 3, 4 } },
{ { 5, 6 }, { 7, 8 } } };
int N = mat.size();
findXOR(mat, N);
return 0;
}
|
Java
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG{
static void findXOR(int mat[][][], int N)
{
int XOR = 0;
for(int i = 0; i < N; i++)
{
XOR ^= mat[i][i][i];
XOR ^= mat[i][i][N - i - 1];
}
System.out.println(XOR);
}
public static void main(String[] args)
{
int mat[][][] = { { { 1, 2 }, { 3, 4 } },
{ { 5, 6 }, { 7, 8 } } };
int N = mat.length;
findXOR(mat, N);
}
}
|
Python3
def findXOR(mat, N):
XOR = 0
for i in range(N):
XOR ^= mat[i][i][i]
XOR ^= mat[i][i][N - i - 1]
print(XOR)
mat = [ [ [ 1, 2 ], [ 3, 4 ] ],
[ [ 5, 6 ], [ 7, 8 ] ] ]
N = len(mat)
findXOR(mat, N)
|
C#
using System;
class GFG{
static void findXOR(int[,,] mat, int N)
{
int XOR = 0;
for(int i = 0; i < N; i++)
{
XOR ^= mat[i, i, i];
XOR ^= mat[i, i, N - i - 1];
}
Console.Write(XOR);
}
static public void Main ()
{
int[,,] mat = { { { 1, 2 }, { 3, 4 } },
{ { 5, 6 }, { 7, 8 } } };
int N = mat.GetLength(0);
findXOR(mat, N);
}
}
|
Javascript
<script>
function findXOR( mat, N)
{
let XOR = 0;
for(let i = 0; i < N; i++)
{
XOR ^= mat[i][i][i];
XOR ^= mat[i][i][N - i - 1];
}
document.write(XOR);
}
let mat = [ [ [ 1, 2 ], [ 3, 4 ] ],
[ [ 5, 6 ], [ 7, 8 ] ] ];
let N = mat.length;
findXOR(mat, N);;
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...