Dados dos enteros N y K , la tarea es encontrar el valor de N XOR N XOR N XOR N … XOR N (K veces) .
Ejemplos:
Entrada: N = 123, K = 3
Salida: 123
(123 ^ 123 ^ 123) = 123
Entrada: N = 123, K = 2
Salida: 0
(123 ^ 123) = 0
Enfoque ingenuo: simplemente ejecute un bucle for y xor N, K veces.
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
// Function to return n ^ n ^ ... k times
int xorK(int n, int k)
{
// Find the result
int res = n;
for (int i = 1; i < k; i++)
res = (res ^ n);
return res;
}
// Driver code
int main()
{
int n = 123, k = 3;
cout << xorK(n, k);
return 0;
}
Java
// Java implementation of the approach
class GFG
{
// Function to return n ^ n ^ ... k times
static int xorK(int n, int k)
{
// Find the result
int res = n;
for (int i = 1; i < k; i++)
res = (res ^ n);
return n;
}
// Driver code
public static void main(String[] args)
{
int n = 123, k = 3;
System.out.print(xorK(n, k));
}
}
// This code is contributed by 29AjayKumar
Python3
# Python3 implementation of the approach # Function to return n ^ n ^ ... k times def xorK(n, k): # Find the result res = n for i in range(1, k): res = (res ^ n) return n # Driver code n = 123 k = 3 print(xorK(n, k)) # This code is contributed by Mohit Kumar
C#
// C# implementation of the approach
using System;
class GFG
{
// Function to return n ^ n ^ ... k times
static int xorK(int n, int k)
{
// Find the result
int res = n;
for (int i = 1; i < k; i++)
res = (res ^ n);
return n;
}
// Driver code
static public void Main ()
{
int n = 123, k = 3;
Console.Write(xorK(n, k));
}
}
// This code is contributed by ajit.
Javascript
<script>
// JavaSCript implementation of the approach
// Function to return n ^ n ^ ... k times
function xorK(n, k)
{
// Find the result
let res = n;
for (let i = 1; i < k; i++)
res = (res ^ n);
return n;
}
// Driver code
let n = 123, k = 3;
document.write(xorK(n, k));
// This code is contributed by Surbhi Tyagi.
</script>
Producción:
123
Complejidad de tiempo: O(K)
Complejidad de espacio: O(1)
Enfoque eficiente: a partir de las propiedades X XOR X = 0 y X ^ 0 = X , se puede observar que cuando K es impar , la respuesta será N , de lo contrario, la respuesta será 0 .
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
// Function to return n ^ n ^ ... k times
int xorK(int n, int k)
{
// If k is odd the answer is
// the number itself
if (k % 2 == 1)
return n;
// Else the answer is 0
return 0;
}
// Driver code
int main()
{
int n = 123, k = 3;
cout << xorK(n, k);
return 0;
}
Java
// Java implementation of the approach
class GFG
{
// Function to return n ^ n ^ ... k times
static int xorK(int n, int k)
{
// If k is odd the answer is
// the number itself
if (k % 2 == 1)
return n;
// Else the answer is 0
return 0;
}
// Driver code
public static void main(String[] args)
{
int n = 123, k = 3;
System.out.print(xorK(n, k));
}
}
// This code is contributed by PrinciRaj1992
Python3
# Python implementation of the approach # Function to return n ^ n ^ ... k times def xorK(n, k): # If k is odd the answer is # the number itself if (k % 2 == 1): return n # Else the answer is 0 return 0 # Driver code n = 123 k = 3 print(xorK(n, k)) # This code is contributed by Sanjit_Prasad
C#
// C# implementation of the approach
using System;
class GFG
{
// Function to return n ^ n ^ ... k times
static int xorK(int n, int k)
{
// If k is odd the answer is
// the number itself
if (k % 2 == 1)
return n;
// Else the answer is 0
return 0;
}
// Driver code
public static void Main(String[] args)
{
int n = 123, k = 3;
Console.Write(xorK(n, k));
}
}
// This code is contributed by 29AjayKumar
Javascript
<script>
// Javascript implementation of the approach
// Function to return n ^ n ^ ... k times
function xorK(n, k)
{
// If k is odd the answer is
// the number itself
if (k % 2 == 1)
return n;
// Else the answer is 0
return 0;
}
let n = 123, k = 3;
document.write(xorK(n, k));
</script>
Producción:
123
Complejidad de tiempo: O(1)
Complejidad de espacio: O(1)