One naïve approach can be of course to compute values ( XORing elements) for all subarrays. This is going to be real tedious as we need to find out all subarrays.

Effective approach can be the XOR nature. We know XORing an element twice results 0.

i^i=0

Let's revise our example:

    For input array:
    1, 2, 3, 4
    Sub arrays are:
    {1}
    {2}
    {3}
    {4}
    {1, 2}
    {2, 3}
    {3, 4}
    {1, 2, 3}
    {2, 3, 4}
    {1, 2, 3, 4}

    This is all possible sub arrays
    A prompt observation leads to the fact that every element 
    actually occurred even number of times while XORing all values
    1^2^3^4^(1^2)^(2^3)^(3^4)^(1^2^3)^(2^3^4)^(1^2^3^4)

    1 has appeared 4 times
    2 has appeared 6 times
    3 has appeared 6 times
    4 has appeared 4 times
    So the final result is actually 0

    Now take any even length array
    You will find all elements appearing even no of times 
    if you expand the XORing sequence like the previous one.
    So,
    For even length array the output will be always 0, 
    no matter what the elements are.

    Now what about odd lengths.
    Let's quickly revise an example
    The array be:
    1, 2, 3, 4, 5
    So,
    Subarrays are:
    {1}
    {2}
    {3}
    {4}
    {1, 2}
    {2, 3}
    {3, 4}
    {4, 5}
    {1, 2, 3}
    {2, 3, 4}
    {3, 4, 5}
    {1, 2, 3, 4}
    {2, 3, 4, 5}
    {1, 2, 3, 4, 5}
    So the expanded result sequence would be:

    1^2^3^4^5^(1^2)^(2^3)^(3^4)^(4^5)^(1^2^3) ^ 
    (2^3^4) ^ (3^4^5) ^ (1^2^3^4) ^(2^3^4^5) ^ (1^2^3 ^4^5)
    
    So, 1 appears 5 times //resulting 1
    2 appears 8 times //resulting 0
    3 appears 9 times //resulting 3
    4 appears 8 times //resulting 0
    5 appears 5 times //resulting 5
    Output will be : 1^3^5

Thus for an odd length array it's found that:

Result will be XORing of all even indexed elements (0-based indexing)

You can check the argue by doing few more examples your own.

So the entire problem actually reduced to a simple concept-

1. Even length array: output 0
2. Odd length array: XORing all even-indexed elements

No need to compute all the sub arrays at all!!

C++ implementation:

#include <bits/stdc++.h>
using namespace std;

int gameOfXor(vector<int> a,int n){
	if(a.size()%2==0) //for even length array
		return 0;
		
	int sum=a[0];
	// for odd length array
	for(int it=2;it<a.size();it=it+2) 
		sum=sum^a[it];
	return sum;    
}

int main(){
	int n,item;

	cout<<"Enter number of elements\n";
	scanf("%d",&n);
	
	vector<int> a;
	
	cout<<"Enter array elements\n";
	for(int j=0;j<n;j++){
		scanf("%d",&item);
		a.push_back(item);
	}
	
	cout<<"Output is:\n";
	cout<<gameOfXor(a,n)<<endl;

	return 0;
}

Output

First run:
Enter number of elements
4
Enter array elements
1 2 3 4
Output is:
0

Second run:
Enter number of elements
5
Enter array elements
1 2 3 4 5
Output is:
7