View Discussion
Improve Article
Save Article
View Discussion
Improve Article
Save Article
Given a sequence arr[] of N-1 elements which is xor of all adjacent pairs in an array, the task is to find that
original array from the arr[].
Note: It is given that the N is always odd and arr[] contains the permutation of N natural number.
Examples:
Input: arr[] = {3, 1}
Output: 1 2 3
Explanation:
The XOR of the output array will lead to the given array that is:
1 ^ 2 = 3
2 ^ 3 = 1
Input: arr[] = {7, 5, 3, 7}
Output: 3 4 1 2 5
Explanation:
The XOR of the output array will lead to the given array that is:
3 ^ 4 = 7
4 ^ 1 = 5
1 ^ 2 = 3
2 ^ 5 = 7
Approach:
- The idea is to find the XOR of all the elements of the 1 to N and the xor of the adjacent elements of the given array to find the last element of the expected array.
- As the XOR of adjacent elements will contain all the elements except the last element, then the XOR of this with all the numbers from 1 to N will give the last element of the expected permutation.
For Example:
Let's the expected array be - {a, b, c, d, e} Then the XOR array for this array will be - {a^b, b^c, c^d, d^e} Now XOR of all the element from 1 to N - xor_all => a ^ b ^ c ^ d ^ e XOR of the adjacent elements - xor_adjacent => [[a ^ b] ^ [c ^ d]] Now the XOR of the both the array will be the last element of the expected permutation => [a ^ b ^ c ^ d ^ e] ^ [[a ^ b] ^ [c ^ d]] => As all elements are in pair except the last element. => [a ^ a ^ b ^ b ^ c ^ c ^ d ^ d ^ e] => [0 ^ 0 ^ 0 ^ 0 ^ e] => e
- Now for the rest of the element, continuously, on xor of this last element we will get last second element, i.e, d.
- Repeatedly, Update the last element and finally get the first element, i.e, a.
Below is the implementation of the above approach:
C++
#include
using
namespace
std;
int
xor_all_elements[
int
n]
{
switch
[n & 3] {
case
0:
return
n;
case
1:
return
1;
case
2:
return
n + 1;
case
3:
return
0;
}
}
vector findArray[
int
xorr[],
int
n]
{
vector arr;
int
xor_all = xor_all_elements[n];
int
xor_adjacent = 0;
for
[
int
i = 0; i < n - 1; i += 2] {
xor_adjacent = xor_adjacent ^ xorr[i];
}
int
last_element = xor_all ^ xor_adjacent;
arr.push_back[last_element];
for
[
int
i = n - 2; i >= 0; i--] {
last_element = xorr[i] ^ last_element;
arr.push_back[last_element];
}
return
arr;
}
int
main[]
{
vector arr;
int
xorr[] = { 7, 5, 3, 7 };
int
n = 5;
arr = findArray[xorr, n];
for
[
int
i = n - 1; i >= 0; i--] {
cout =
0
; i--]
{
System.out.print[arr.get[i]+
" "
];
}
}
}
Python3
def
xor_all_elements[n]:
if
n &
3
=
=
0
:
return
n
elif
n &
3
=
=
1
:
return
1
elif
n &
3
=
=
2
:
return
n
+
1
else
:
return
0
def
findArray[xorr, n]:
arr
=
[]
xor_all
=
xor_all_elements[n]
xor_adjacent
=
0
for
i
in
range
[
0
, n
-
1
,
2
]:
xor_adjacent
=
xor_adjacent ^ xorr[i]
last_element
=
xor_all ^ xor_adjacent
arr.append[last_element]
for
i
in
range
[n
-
2
,
-
1
,
-
1
]:
last_element
=
xorr[i] ^ last_element
arr.append[last_element]
return
arr
xorr
=
[
7
,
5
,
3
,
7
]
n
=
5
arr
=
findArray[xorr, n]
for
i
in
range
[n
-
1
,
-
1
,
-
1
]:
print
[arr[i], end
=
" "
]
C#
using
System;
using
System.Collections.Generic;
class
GFG{
static
int
xor_all_elements[
int
n]
{
switch
[n & 3] {
case
0:
return
n;
case
1:
return
1;
case
2:
return
n + 1;
}
return
0;
}
static
List findArray[
int
[]xorr,
int
n]
{
List arr =
new
List[];
int
xor_all = xor_all_elements[n];
int
xor_adjacent = 0;
for
[
int
i = 0; i < n - 1; i += 2] {
xor_adjacent = xor_adjacent ^ xorr[i];
}
int
last_element = xor_all ^ xor_adjacent;
arr.Add[last_element];
for
[
int
i = n - 2; i >= 0; i--]
{
last_element = xorr[i] ^ last_element;
arr.Add[last_element];
}
return
arr;
}
public
static
void
Main[String[] args]
{
List arr =
new
List[];
int
[]xorr = { 7, 5, 3, 7 };
int
n = 5;
arr = findArray[xorr, n];
for
[
int
i = n - 1; i >= 0; i--]
{
Console.Write[arr[i]+
" "
];
}
}
}
Javascript
function
xor_all_elements[n]
{
switch
[n & 3] {
case
0:
return
n;
case
1:
return
1;
case
2:
return
n + 1;
case
3:
return
0;
}
}
function
findArray[xorr, n]
{
let arr = [];
let xor_all = xor_all_elements[n];
let xor_adjacent = 0;
for
[let i = 0; i < n - 1; i += 2] {
xor_adjacent = xor_adjacent ^ xorr[i];
}
let last_element = xor_all ^ xor_adjacent;
arr.push[last_element];
for
[let i = n - 2; i >= 0; i--] {
last_element = xorr[i] ^ last_element;
arr.push[last_element];
}
return
arr;
}
let arr = [];
let xorr = [ 7, 5, 3, 7 ];
let n = 5;
arr = findArray[xorr, n];
for
[let i = n - 1; i >= 0; i--] {
document.write[arr[i] +
" "
];
}
Performance Analysis:
- Time Complexity: In the above approach we iterate over the entire xor array to find the XOR of the Adjacent elements, then the complexity in the worst case will be O[N]
- Space Complexity: In the above approach there is a vector array used to store the Permutation of the numbers from 1 to N, then the space complexity will be O[N]