Range Queries for finding the Sum of all even parity numbers
Last Updated :
25 Apr, 2023
Given Q queries where each query consists of two numbers L and R which denotes a range [L, R]. The task is to find the sum of all Even Parity Numbers lying in the given range [L, R].
Parity of a number refers to whether it contains an odd or even number of 1-bits. The number has Even Parity if it contains even number of 1-bits.
Examples:
Input: Q = [ [1, 10], [121, 211] ]
Output:
33
7493
Explanation:
binary(1) = 01, parity = 1
binary(2) = 10, parity = 1
binary(3) = 11, parity = 2
binary(4) = 100, parity = 1
binary(5) = 101, parity = 2
binary(6) = 110, parity = 2
binary(7) = 111, parity = 3
binary(8) = 1000, parity = 1
binary(9) = 1001, parity = 2
binary(10) = 1010, parity = 2
From 1 to 10, 3, 5, 6, 9 and 10 are the Even Parity numbers. Therefore the sum is 33.
From 121 to 211 the sum of all the even parity numbers is 7493.
Input: Q = [ [ 10, 10 ], [ 258, 785 ], [45, 245], [ 1, 1000]]
Output:
10
137676
14595
250750
Approach:
The idea is to use a Prefix Sum Array. The sum of all Even Parity Numbers till that particular index is precomputed and stored in an array pref[] so that every query can be answered in O(1) time.
- Initialise the prefix array pref[].
- Iterate from 1 to N and check if the number has even parity or not:
- If the number is Even Parity Number then, the current index of pref[] will store the sum of Even Parity Numbers found so far.
- Else the current index of pref[] is same as the value at previous index of pref[].
- For Q queries the sum of all Even Parity Numbers for range [L, R] can be calculated as follows:
sum = pref[R] - pref[L - 1]
Below is the implementation of the above approach
C++
#include <bits/stdc++.h>
using namespace std;
int pref[100001] = { 0 };
int isEvenParity(int num)
{
int parity = 0;
int x = num;
while (x != 0) {
if (x & 1)
parity++;
x = x >> 1;
}
if (parity % 2 == 0)
return num;
else
return 0;
}
void preCompute()
{
for (int i = 1; i < 100001; i++) {
pref[i] = pref[i - 1]
+ isEvenParity(i);
}
}
void printSum(int L, int R)
{
cout << (pref[R] - pref[L - 1])
<< endl;
}
void printSum(int arr[2][2], int Q)
{
preCompute();
for (int i = 0; i < Q; i++) {
printSum(arr[i][0],
arr[i][1]);
}
}
int main()
{
int N = 2;
int Q[2][2] = { { 1, 10 },
{ 121, 211 } };
printSum(Q, N);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
static int[] pref = new int[100001];
static int isEvenParity(int num)
{
int parity = 0;
int x = num;
while (x != 0)
{
if ((x & 1) == 1)
parity++;
x = x >> 1;
}
if (parity % 2 == 0)
return num;
else
return 0;
}
static void preCompute()
{
for(int i = 1; i < 100001; i++)
{
pref[i] = pref[i - 1] + isEvenParity(i);
}
}
static void printSum(int L, int R)
{
System.out.println(pref[R] - pref[L - 1]);
}
static void printSum(int arr[][], int Q)
{
preCompute();
for(int i = 0; i < Q; i++)
{
printSum(arr[i][0], arr[i][1]);
}
}
public static void main(String[] args)
{
int N = 2;
int[][] Q = { { 1, 10 },
{ 121, 211 } };
printSum(Q, N);
}
}
|
Python3
class GFG :
pref = [0] * (100001)
@staticmethod
def isEvenParity( num) :
parity = 0
x = num
while (x != 0) :
if ((x & 1) == 1) :
parity += 1
x = x >> 1
if (parity % 2 == 0) :
return num
else :
return 0
@staticmethod
def preCompute() :
i = 1
while (i < 100001) :
GFG.pref[i] = GFG.pref[i - 1] + GFG.isEvenParity(i)
i += 1
@staticmethod
def printsum( L, R) :
print(GFG.pref[R] - GFG.pref[L - 1])
@staticmethod
def printSum( arr, Q) :
GFG.preCompute()
i = 0
while (i < Q) :
GFG.printsum(arr[i][0], arr[i][1])
i += 1
@staticmethod
def main( args) :
N = 2
Q = [[1, 10], [121, 211]]
GFG.printSum(Q, N)
if __name__=="__main__":
GFG.main([])
|
C#
using System;
class GFG {
static int[] pref = new int[100001];
static int isEvenParity(int num)
{
int parity = 0;
int x = num;
while (x != 0)
{
if ((x & 1) == 1)
parity++;
x = x >> 1;
}
if (parity % 2 == 0)
return num;
else
return 0;
}
static void preCompute()
{
for(int i = 1; i < 100001; i++)
{
pref[i] = pref[i - 1] + isEvenParity(i);
}
}
static void printSum(int L, int R)
{
Console.WriteLine(pref[R] - pref[L - 1]);
}
static void printSum(int[,] arr, int Q)
{
preCompute();
for(int i = 0; i < Q; i++)
{
printSum(arr[i, 0], arr[i, 1]);
}
}
public static void Main()
{
int N = 2;
int[,] Q = { { 1, 10 },
{ 121, 211 } };
printSum(Q, N);
}
}
|
Javascript
<script>
let pref = new Array(100001).fill(0);
function isEvenParity(num)
{
let parity = 0;
let x = num;
while (x != 0) {
if (x & 1 == 1)
parity++;
x = x >> 1;
}
if (parity % 2 == 0)
return num;
else
return 0;
}
function preCompute() {
for (let i = 1; i < 100001; i++) {
pref[i] = pref[i - 1] + isEvenParity(i);
}
}
function printSum2(L, R) {
document.write(pref[R] - pref[L - 1] + "<br>");
}
function printSum(arr, Q) {
preCompute();
for (let i = 0; i < Q; i++) {
printSum2(arr[i][0], arr[i][1]);
}
}
let N = 2;
let Q = [[1, 10],
[121, 211]];
printSum(Q, N);
</script>
|
Time Complexity: O(Q*log(N)), where n is the size of the array and Q is the number of queries.
Auxiliary Space: O(1)
Please Login to comment...