Dada una array 3D mat[][][] de dimensiones N * N * N que consta de números enteros positivos, la tarea es calcular Bitwise XOR de todos los elementos de la array presentes en la diagonal principal.
Ejemplos:
Entrada: arr[][][] = {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}
Salida: 12
Explicación: Los elementos principales de la diagonal son { 1, 8, 2, 7}. Por lo tanto, el Bitwise XOR de todos estos elementos es 12.Entrada: arr[][][]={{{1}}}
Salida: 0
Explicación: Hay 2 diagonales principales de la array {1}, {1}. Por lo tanto, el Bitwise XOR de los principales elementos diagonales es 0.
Enfoque ingenuo: el enfoque más simple para resolver el problema es atravesar la array 3D dada mat[][][] usando tres bucles anidados , usando variables, digamos i , j y k , y calcular Bitwise XOR de mat[i][ j][k] y mat[i][j][N – k – 1] , si el valor de i , j y k son iguales. Después de completar el recorrido de la array, imprima el valor de Bitwise XOR obtenido.
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to calculate Bitwise XOR of
// major diagonal elements of 3D matrix
void findXOR(
vector<vector<vector<int> > >& mat,
int N)
{
// Stores the Bitwise XOR of
// the major diagonal elements
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 element is part
// of major diagonal
if ((i == j && j == k)) {
XOR ^= mat[i][j][k];
XOR ^= mat[i][j][N - k - 1];
}
}
}
}
// Print the resultant Bitwise XOR
cout << XOR << "\n";
}
// Driver Code
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
// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG{
// Function to calculate Bitwise XOR of
// major diagonal elements of 3D matrix
static void findXOR(int mat[][][], int N)
{
// Stores the Bitwise XOR of
// the major diagonal elements
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 element is part
// of major diagonal
if ((i == j && j == k))
{
XOR ^= mat[i][j][k];
XOR ^= mat[i][j][N - k - 1];
}
}
}
}
// Print the resultant Bitwise XOR
System.out.println(XOR);
}
// Driver Code
public static void main(String[] args)
{
int mat[][][] = { { { 1, 2 }, { 3, 4 } },
{ { 5, 6 }, { 7, 8 } } };
int N = mat.length;
findXOR(mat, N);
}
}
// This code is contributed by Kingash
Python3
# Python3 program for the above approach # Function to calculate Bitwise XOR of # major diagonal elements of 3D matrix def findXOR(mat, N): # Stores the Bitwise XOR of # the major diagonal elements XOR = 0 for i in range(N): for j in range(N): for k in range(N): # If element is part # of major diagonal if ((i == j and j == k)): XOR ^= mat[i][j][k] XOR ^= mat[i][j][N - k - 1] # Print the resultant Bitwise XOR print(XOR) # Driver Code mat = [ [ [ 1, 2 ], [ 3, 4 ] ], [ [ 5, 6 ], [ 7, 8 ] ] ] N = len(mat) findXOR(mat, N) # This code is contributed by splevel62
C#
// C# program for the above approach
using System;
class GFG{
// Function to calculate Bitwise XOR of
// major diagonal elements of 3D matrix
static void findXOR(int[, , ] mat, int N)
{
// Stores the Bitwise XOR of
// the major diagonal elements
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 element is part
// of major diagonal
if ((i == j && j == k))
{
XOR ^= mat[i, j, k];
XOR ^= mat[i, j, N - k - 1];
}
}
}
}
// Print the resultant Bitwise XOR
Console.WriteLine(XOR);
}
// Driver Code
public static void Main(string[] args)
{
int[,,] mat = { { { 1, 2 }, { 3, 4 } },
{ { 5, 6 }, { 7, 8 } } };
int N = mat.GetLength(0);
findXOR(mat, N);
}
}
// This code is contributed by ukasp
Javascript
<script>
// JavaScript program for the above approach
// Function to calculate Bitwise XOR of
// major diagonal elements of 3D matrix
function findXOR(mat, N)
{
// Stores the Bitwise XOR of
// the major diagonal elements
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 element is part
// of major diagonal
if ((i == j && j == k))
{
XOR ^= mat[i][j][k];
XOR ^= mat[i][j][N - k - 1];
}
}
}
}
// Print the resultant Bitwise XOR
document.write(XOR);
}
// Driver Code
let mat = [[[1, 2 ], [ 3, 4 ]],
[[ 5, 6 ], [ 7, 8 ]]];
let N = mat.length;
findXOR(mat, N);
</script>
12
Complejidad de Tiempo: O(N 3 )
Espacio Auxiliar: O(1)
Enfoque eficiente: el enfoque anterior se puede optimizar utilizando el hecho de que el elemento cuyos índices i , j y k son los mismos que los elementos diagonales. Por lo tanto, la idea es iterar sobre el rango de índices [0, N – 1] usando una variable i y calcular Bitwise XOR de todos los elementos que forman parte de las diagonales principales en los índices (i, i, i) y (i , i, N – i – 1) en la array dada mat[][][] como mat[i][i][i] y mat[i][i][N – i – 1] respectivamente.
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to find the Bitwise XOR of
// both diagonal elements of 3D matrix
void findXOR(
vector<vector<vector<int> > >& mat,
int N)
{
// Stores the Bitwise XOR of the
// major diagonal elements
int XOR = 0;
for (int i = 0; i < N; i++) {
XOR ^= mat[i][i][i];
XOR ^= mat[i][i][N - i - 1];
}
// Print the resultant Bitwise XOR
cout << XOR << "\n";
}
// Driver Code
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
// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG{
// Function to calculate Bitwise XOR of
// major diagonal elements of 3D matrix
static void findXOR(int mat[][][], int N)
{
// Stores the Bitwise XOR of the
// major diagonal elements
int XOR = 0;
for(int i = 0; i < N; i++)
{
XOR ^= mat[i][i][i];
XOR ^= mat[i][i][N - i - 1];
}
// Print the resultant Bitwise XOR
System.out.println(XOR);
}
// Driver Code
public static void main(String[] args)
{
int mat[][][] = { { { 1, 2 }, { 3, 4 } },
{ { 5, 6 }, { 7, 8 } } };
int N = mat.length;
findXOR(mat, N);
}
}
// This code is contributed by Kingash
Python3
# Python3 program for the above approach # Function to find the Bitwise XOR of # both diagonal elements of 3D matrix def findXOR(mat, N): # Stores the Bitwise XOR of the # major diagonal elements XOR = 0 for i in range(N): XOR ^= mat[i][i][i] XOR ^= mat[i][i][N - i - 1] # Print the resultant Bitwise XOR print(XOR) # Driver Code mat = [ [ [ 1, 2 ], [ 3, 4 ] ], [ [ 5, 6 ], [ 7, 8 ] ] ] N = len(mat) findXOR(mat, N) # This code is contributed by sanjoy_62
C#
// C# program for the above approach
using System;
class GFG{
// Function to calculate Bitwise XOR of
// major diagonal elements of 3D matrix
static void findXOR(int[,,] mat, int N)
{
// Stores the Bitwise XOR of the
// major diagonal elements
int XOR = 0;
for(int i = 0; i < N; i++)
{
XOR ^= mat[i, i, i];
XOR ^= mat[i, i, N - i - 1];
}
// Print the resultant Bitwise XOR
Console.Write(XOR);
}
// Driver Code
static public void Main ()
{
int[,,] mat = { { { 1, 2 }, { 3, 4 } },
{ { 5, 6 }, { 7, 8 } } };
int N = mat.GetLength(0);
findXOR(mat, N);
}
}
// This code is contributed by avijitmondal1998
Javascript
<script>
// Javascript program for the above approach
// Function to calculate Bitwise XOR of
// major diagonal elements of 3D matrix
function findXOR( mat, N)
{
// Stores the Bitwise XOR of the
// major diagonal elements
let XOR = 0;
for(let i = 0; i < N; i++)
{
XOR ^= mat[i][i][i];
XOR ^= mat[i][i][N - i - 1];
}
// Print the resultant Bitwise XOR
document.write(XOR);
}
// Driver Code
let mat = [ [ [ 1, 2 ], [ 3, 4 ] ],
[ [ 5, 6 ], [ 7, 8 ] ] ];
let N = mat.length;
findXOR(mat, N);;
</script>
12
Complejidad temporal: O(N)
Espacio auxiliar: O(1)
Publicación traducida automáticamente
Artículo escrito por ajaykr00kj y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA