二进制数组范围内的异或

给定一个大小为N的二进制数组arr[]和一些查询。每个查询代表一个索引范围[l, r] 。任务是为每个查询找到给定索引范围内元素的异或，即arr[l] ^ arr[l + 1] ^ ... ^ arr[r] 。
例子：

Input: arr[] = {1, 0, 1, 1, 0, 1, 1}, q[][] = {{0, 3}, {0, 2}}
Output:
1
0
Query 1: arr[0] ^ arr[1] ^ arr[2] ^ arr[3] = 1 ^ 0 ^ 1 ^ 1 = 1
Query 1: arr[0] ^ arr[1] ^ arr[2] = 1 ^ 0 ^ 1 = 0
Input: arr[] = {1, 0, 1, 1, 0, 1, 1}, q[][] = {{1, 1}}
Output: 0

编程需要懂一点英语

方法：主要观察是所需的答案总是0或1 。如果给定范围内 1 的数量是奇数，则答案将为1 。否则为 0 。要在恒定时间内回答多个查询，请使用前缀和数组pre[]其中pre[i]存储索引范围[0, i]中原始数组中 1 的数量，可用于查找 1 的数量给定数组的任何索引范围。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return Xor in a range
// of a binary array
int xorRange(int pre[], int l, int r)
{
 
    // To store the count of 1s
    int cntOnes = pre[r];
    if (l - 1 >= 0)
        cntOnes -= pre[l - 1];
 
    // If number of ones are even
    if (cntOnes % 2 == 0)
        return 0;
 
    // If number of ones are odd
    else
        return 1;
}
 
// Function to perform the queries
void performQueries(int queries[][2], int q,
                    int a[], int n)
{
    // To store prefix sum
    int pre[n];
 
    // pre[i] stores the number of
    // 1s from pre[0] to pre[i]
    pre[0] = a[0];
    for (int i = 1; i < n; i++)
        pre[i] = pre[i - 1] + a[i];
 
    // Perform queries
    for (int i = 0; i < q; i++)
        cout << xorRange(pre, queries[i][0],
                         queries[i][1])
             << endl;
}
 
// Driver code
int main()
{
    int a[] = { 1, 0, 1, 1, 0, 1, 1 };
    int n = sizeof(a) / sizeof(a[0]);
 
    // Given queries
    int queries[][2] = { { 0, 3 }, { 0, 2 } };
    int q = sizeof(queries) / sizeof(queries[0]);
 
    performQueries(queries, q, a, n);
 
    return 0;
}

Java

// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Function to return Xor in a range
// of a binary array
static int xorRange(int pre[], int l, int r)
{
 
    // To store the count of 1s
    int cntOnes = pre[r];
    if (l - 1 >= 0)
        cntOnes -= pre[l - 1];
 
    // If number of ones are even
    if (cntOnes % 2 == 0)
        return 0;
 
    // If number of ones are odd
    else
        return 1;
}
 
// Function to perform the queries
static void performQueries(int queries[][], int q,
                           int a[], int n)
{
    // To store prefix sum
    int []pre = new int[n];
 
    // pre[i] stores the number of
    // 1s from pre[0] to pre[i]
    pre[0] = a[0];
    for (int i = 1; i < n; i++)
        pre[i] = pre[i - 1] + a[i];
 
    // Perform queries
    for (int i = 0; i < q; i++)
        System.out.println(xorRange(pre, queries[i][0],
                                         queries[i][1]));
}
 
// Driver code
public static void main(String[] args)
{
    int a[] = { 1, 0, 1, 1, 0, 1, 1 };
    int n = a.length;
 
    // Given queries
    int queries[][] = { { 0, 3 }, { 0, 2 } };
    int q = queries.length;
 
    performQueries(queries, q, a, n);
}
}
 
// This code is contributed by Princi Singh

Python3

# Python3 implementation of the approach
 
# Function to return Xor in a range
# of a binary array
def xorRange(pre, l, r):
 
    # To store the count of 1s
    cntOnes = pre[r]
    if (l - 1 >= 0):
        cntOnes -= pre[l - 1]
 
    # If number of ones are even
    if (cntOnes % 2 == 0):
        return 0
 
    # If number of ones are odd
    else:
        return 1
 
# Function to perform the queries
def performQueries(queries, q, a, n):
     
    # To store prefix sum
    pre = [0 for i in range(n)]
 
    # pre[i] stores the number of
    # 1s from pre[0] to pre[i]
    pre[0] = a[0]
    for i in range(1, n):
        pre[i] = pre[i - 1] + a[i]
 
    # Perform queries
    for i in range(q):
        print(xorRange(pre, queries[i][0],
                            queries[i][1]))
 
# Driver code
a = [ 1, 0, 1, 1, 0, 1, 1 ]
n = len(a)
 
# Given queries
queries = [[ 0, 3 ], [ 0, 2 ]]
q = len(queries)
 
performQueries(queries, q, a, n)
 
# This code is contributed by Mohit Kumar

C#

// C# implementation of the approach
using System;
 
class GFG
{
 
// Function to return Xor in a range
// of a binary array
static int xorRange(int []pre, int l, int r)
{
 
    // To store the count of 1s
    int cntOnes = pre[r];
    if (l - 1 >= 0)
        cntOnes -= pre[l - 1];
 
    // If number of ones are even
    if (cntOnes % 2 == 0)
        return 0;
 
    // If number of ones are odd
    else
        return 1;
}
 
// Function to perform the queries
static void performQueries(int [,]queries, int q,
                           int []a, int n)
{
    // To store prefix sum
    int []pre = new int[n];
 
    // pre[i] stores the number of
    // 1s from pre[0] to pre[i]
    pre[0] = a[0];
    for (int i = 1; i < n; i++)
        pre[i] = pre[i - 1] + a[i];
 
    // Perform queries
    for (int i = 0; i < q; i++)
        Console.WriteLine(xorRange(pre, queries[i, 0],
                                        queries[i, 1]));
}
 
// Driver code
public static void Main()
{
    int []a = { 1, 0, 1, 1, 0, 1, 1 };
    int n = a.Length;
 
    // Given queries
    int [,]queries = { { 0, 3 }, { 0, 2 } };
    int q = queries.Length;
 
    performQueries(queries, q, a, n);
}
}
 
// This code is contributed
// by Akanksha Rai

Javascript

输出：

1
0