Find all subarray index ranges in given Array with set bit sum equal to X (original) (raw)
Last Updated : 31 Oct, 2023
Given an array **arr (1-based indexing) of length **N and an integer **X, the task is to find and print all index ranges having a set bit sum equal to **X in the array.
**Examples:
**Input: A[] = {1 4 3 5 7}, X = 4
**Output: (1, 3), (3, 4)
**Explanation: In the above array subarray having set bit sum equal to X (= 4).
Starting from index 1 to 3. {1 4 3} = (001) + (100) + (011) = 4 and
other one is from 3 to 4 {3, 5} = (011) + (101) = 4.**Input: arr[] = {5, 3, 0, 4, 10}, X = 7
**Output: (1 5)
**Explanation: In the above array subarrays having set bit sum equal to X(= 7) start from 1 to 5 only.
**Approach: The problem is solved using two pointer approach.
- Write a function countSetBit to count the number of set bits.
- Initialize a counter c=0, to store the individual count for every number in the array.
- Iterate over the array and check for every set bit and increase the counter.
- replace every number with the count of a number of set bits
- Write a function to print a range of subarrays PrintIndex
Run a loop using two pointers i and j and check for the sum as follow:- If the current index sum is less than X then, add the value at arr[j] in currsum
- else if the sum is equal to X push back the start and end index of the array and increment the counter i.
- else decrement the counter, subtract the value at arr[i] from currsum.
- Repeat the same for all elements.
Below is the implementation of the above method :
C++ `
// C++ program to Find all range // Having set bit sum X in array #include <bits/stdc++.h> using namespace std;
// Function to replace elements // With their set bit count void countSetBit(vector& arr, int n) { int c = 0, i;
for (i = 0; i < n; i++) {
int x = arr[i];
while (x) {
int l = x % 10;
if (x & 1)
c++;
x /= 2;
}
// Replace array element
// to set bit count
arr[i] = c;
c = 0;
}}
// Function to find range of subarrays // having set bit sum equal to X. void PrintIndex(vector arr, int N, int X, vector& v) {
int i = 0, j = 0, currSum = arr[0];
while (j < N && i < N) {
if (currSum == X) {
// push back index i start
// point ans end point j
// when sum == X
v.push_back(i + 1);
v.push_back(j + 1);
j++;
currSum += arr[j];
}
// when current sum is
// less than X increment j
// and add arr[j]
else if (currSum < X) {
j++;
currSum += arr[j];
}
// when current sum is
// greater than X increment j
// and subtract arr[i]
else {
currSum -= arr[i];
i++;
}
}}
// Driver code int main() { vector v = { 1, 4, 3, 5, 7 }; int X = 4; int N = v.size();
// replace all the array element into
// their set bit count value
countSetBit(v, N);
vector<int> ans;
PrintIndex(v, N, X, ans);
for (int i = 0; i < ans.size() - 1; i += 2)
cout << "(" << ans[i] << " "
<< ans[i + 1] << ")"
<< " ";
return 0;}
Java
// JAVA code to implement the above approach import java.util.*; class GFG {
// Function to replace elements // With their set bit count static void countSetBit(int[] arr, int n) { int c = 0, i;
for (i = 0; i < n; i++) {
int x = arr[i];
while (x > 0) {
int l = x % 10;
if ((x & 1) == 1)
c++;
x /= 2;
}
// Replace array element
// to set bit count
arr[i] = c;
c = 0;
}}
// Function to find range of subarrays // having set bit sum equal to X. static void PrintIndex(int[] arr, int N, int X, ArrayList v) {
int i = 0, j = 0, currSum = arr[0];
while (j < N && i < N) {
if (currSum == X) {
// push back index i start
// point ans end point j
// when sum == X
v.add(i + 1);
v.add(j + 1);
j++;
if (j < N)
currSum += arr[j];
}
// when current sum is
// less than X increment j
// and add arr[j]
else if (currSum < X) {
j++;
if (j < N)
currSum += arr[j];
}
// when current sum is
// greater than X increment j
// and subtract arr[i]
else {
currSum -= arr[i];
i++;
}
}}
// Driver Code public static void main(String[] args) { int[] v = { 1, 4, 3, 5, 7 }; int X = 4; int N = v.length;
// replace all the array element into
// their set bit count value
countSetBit(v, N);
ArrayList<Integer> ans = new ArrayList<Integer>();
PrintIndex(v, N, X, ans);
for (int i = 0; i < ans.size() - 1; i += 2)
System.out.print("(" + ans.get(i) + " " + ans.get(i + 1)
+ ")"
+ " ");} }
// This code is contributed by sanjoy_62.
Python3
Python program to Find all range
Having set bit sum X in array
Function to replace elements
With their set bit count
def countSetBit(arr, n): c = 0
for i in range(n):
x = arr[i]
while (x):
l = x % 10
if (x & 1):
c += 1
x = x // 2
# Replace array element
# to set bit count
arr[i] = c
c = 0Function to find range of subarrays
having set bit sum equal to X.
def PrintIndex(arr, N, X, v):
i,j,currSum = 0,0,arr[0]
while (j < N and i < N):
if (currSum == X):
# append back index i start
# point ans end point j
# when sum == X
v.append(i + 1)
v.append(j + 1)
j += 1
if(j<N):
currSum += arr[j]
# when current sum is
# less than X increment j
# and add arr[j]
elif (currSum < X):
j += 1
if(j<N):
currSum += arr[j]
# when current sum is
# greater than X increment j
# and subtract arr[i]
else:
currSum -= arr[i]
i += 1Driver code
v = [1, 4, 3, 5, 7] X = 4 N = len(v)
replace all the array element into
their set bit count value
countSetBit(v, N) ans = [] PrintIndex(v, N, X, ans)
for i in range(0,len(ans) - 1,2): print(f"({ans[i]} {ans[i + 1]})",end=" ")
This code is contributed by shinjanpatra
C#
// C# program to Find all range // Having set bit sum X in array using System; using System.Collections;
class GFG {
// Function to replace elements // With their set bit count static void countSetBit(int[] arr, int n) { int c = 0, i;
for (i = 0; i < n; i++) {
int x = arr[i];
while (x > 0) {
int l = x % 10;
if ((x & 1) == 1)
c++;
x /= 2;
}
// Replace array element
// to set bit count
arr[i] = c;
c = 0;
}}
// Function to find range of subarrays // having set bit sum equal to X. static void PrintIndex(int[] arr, int N, int X, ArrayList v) {
int i = 0, j = 0, currSum = arr[0];
while (j < N && i < N) {
if (currSum == X) {
// push back index i start
// point ans end point j
// when sum == X
v.Add(i + 1);
v.Add(j + 1);
j++;
if (j < N)
currSum += arr[j];
}
// when current sum is
// less than X increment j
// and add arr[j]
else if (currSum < X) {
j++;
if (j < N)
currSum += arr[j];
}
// when current sum is
// greater than X increment j
// and subtract arr[i]
else {
currSum -= arr[i];
i++;
}
}}
// Driver code public static void Main() { int[] v = { 1, 4, 3, 5, 7 }; int X = 4; int N = v.Length;
// replace all the array element into
// their set bit count value
countSetBit(v, N);
ArrayList ans = new ArrayList();
PrintIndex(v, N, X, ans);
for (int i = 0; i < ans.Count - 1; i += 2)
Console.Write("(" + ans[i] + " " + ans[i + 1]
+ ")"
+ " ");} }
// This code is contributed by Samim Hossain Mondal.
` JavaScript ``
<script>
// JavaScript program to Find all range
// Having set bit sum X in array
// Function to replace elements
// With their set bit count
const countSetBit = (arr, n) => {
let c = 0, i;
for (i = 0; i < n; i++) {
let x = arr[i];
while (x) {
let l = x % 10;
if (x & 1)
c++;
x = parseInt(x / 2);
}
// Replace array element
// to set bit count
arr[i] = c;
c = 0;
}
}
// Function to find range of subarrays
// having set bit sum equal to X.
const PrintIndex = (arr, N, X, v) => {
let i = 0, j = 0, currSum = arr[0];
while (j < N && i < N)
{
if (currSum == X)
{
// push back index i start
// point ans end point j
// when sum == X
v.push(i + 1);
v.push(j + 1);
j++;
currSum += arr[j];
}
// when current sum is
// less than X increment j
// and add arr[j]
else if (currSum < X) {
j++;
currSum += arr[j];
}
// when current sum is
// greater than X increment j
// and subtract arr[i]
else {
currSum -= arr[i];
i++;
}
}
}
// Driver code
let v = [1, 4, 3, 5, 7];
let X = 4;
let N = v.length;
// replace all the array element into
// their set bit count value
countSetBit(v, N);
let ans = [];
PrintIndex(v, N, X, ans);
for (let i = 0; i < ans.length - 1; i += 2)
document.write(`(${ans[i]} ${ans[i + 1]}) `);
// This code is contributed by rakeshsahni
</script>``
**Time Complexity: O(N * d) where d is the count of bits in an array element
**Auxiliary Space: O(N)
**Another Approach:
- The code defines a function called countSetBit that takes an integer x and returns the number of set bits in its binary representation.
- The code also defines another function called printSubarraysWithSetBitSumX that takes a vector of integers arr and an integer X. This function prints all the subarrays of arr whose sum of set bits is equal to X.
- Inside the printSubarraysWithSetBitSumX function, the code initializes some variables: n is the size of the input vector arr, i and j are two pointers initially set to 0, and currSum is the current sum of set bits.
- The code enters a while loop with a condition of j < n. This loop iterates through all the elements of the input vector arr.
- Inside the while loop, the code adds the count of set bits of the current element to the currSum variable and increments j by 1.
- The code then enters another while loop with a condition of currSum > X. This loop removes the set bit count of the element pointed by i from the currSum variable and increments i by 1 until the currSum becomes less than or equal to X.
- If the currSum is equal to X after the above while loop, the code prints the indices of the subarray whose sum of set bits is equal to X.
- The while loop in step 4 continues until j reaches the end of the input vector arr.
- Finally, the main function creates a vector arr containing integers {1, 4, 3, 5, 7} and sets X to 4. It then calls the printSubarraysWithSetBitSumX function with these arguments, which prints "(1, 3) (3, 4)" to the console.
Below is the implementation of the above approach:
C++ `
#include #include using namespace std;
int countSetBit(int x) { int count = 0; while (x > 0) { count += x & 1; x >>= 1; } return count; }
void printSubarraysWithSetBitSumX(vector& arr, int X) { int n = arr.size(); int i = 0, j = 0, currSum = 0; while (j < n) { currSum += countSetBit(arr[j]); j++; while (currSum > X) { currSum -= countSetBit(arr[i]); i++; } if (currSum == X) { cout << "(" << i + 1 << ", " << j << ") "; } } }
int main() { vector arr = {1, 4, 3, 5, 7}; int X = 4; printSubarraysWithSetBitSumX(arr, X); // prints (1, 3) (3, 4) return 0; }
Java
import java.util.*;
public class SubarraysWithSetBitSum { public static int countSetBit(int x) { int count = 0; while (x > 0) { count += x & 1; x >>= 1; } return count; }
public static void printSubarraysWithSetBitSumX(ArrayList<Integer> arr, int X) {
int n = arr.size();
int i = 0, j = 0, currSum = 0;
while (j < n) {
currSum += countSetBit(arr.get(j));
j++;
while (currSum > X) {
currSum -= countSetBit(arr.get(i));
i++;
}
if (currSum == X) {
System.out.print("(" + (i + 1) + ", " + j + ") ");
}
}
}
public static void main(String[] args) {
ArrayList<Integer> arr = new ArrayList<Integer>(Arrays.asList(1, 4, 3, 5, 7));
int X = 4;
printSubarraysWithSetBitSumX(arr, X); // prints (1, 3) (3, 4)
}}
Python3
def count_set_bits(x): # Function to count the number of set bits (1s) in a binary representation of 'x' count = 0 while x > 0: count += x & 1 # Add the least significant bit of 'x' to the count x >>= 1 # Right shift 'x' to check the next bit return count
def print_subarrays_with_set_bit_sum_x(arr, X): n = len(arr) # Get the length of the input array 'arr' i, j, curr_sum = 0, 0, 0 # Initialize variables for subarray tracking
while j < n: # Iterate through the array using a sliding window (j moves forward)
curr_sum += count_set_bits(arr[j]) # Add the count of set bits in 'arr[j]' to 'curr_sum'
j += 1
while curr_sum > X: # If 'curr_sum' exceeds the target 'X', move the window's left end (i) forward
curr_sum -= count_set_bits(arr[i]) # Subtract the count of set bits in 'arr[i]' from 'curr_sum'
i += 1
if curr_sum == X: # If 'curr_sum' matches the target 'X', print the subarray
print(f"({i + 1}, {j}) ", end='')Main function
if name == "main": arr = [1, 4, 3, 5, 7] # Input array X = 4 # Target sum of set bits print_subarrays_with_set_bit_sum_x(arr, X) # Call the function to find and print subarrays with the target sum
C#
using System; using System.Collections.Generic;
public class SubarraysWithSetBitSum { // Function to count the number of set bits in a number public static int CountSetBit(int x) { int count = 0; while (x > 0) { count += x & 1; // Increment count if the last bit is 1 x >>= 1; // Right shift the number to check the next bit } return count; }
// Function to find and print subarrays with a given set bit sum
public static void PrintSubarraysWithSetBitSumX(List<int> arr, int X) {
int n = arr.Count;
int i = 0, j = 0, currSum = 0;
while (j < n) {
currSum += CountSetBit(arr[j]); // Calculate set bit sum for the current element
j++;
// Slide the window to the right while current set bit sum is greater than X
while (currSum > X) {
currSum -= CountSetBit(arr[i]); // Remove set bit count of the left element
i++;
}
// If the current set bit sum matches X, print the subarray indices
if (currSum == X) {
Console.Write("(" + (i + 1) + ", " + j + ") ");
}
}
}
public static void Main(string[] args) {
List<int> arr = new List<int> { 1, 4, 3, 5, 7 };
int X = 4;
PrintSubarraysWithSetBitSumX(arr, X); // prints (1, 3) (3, 4)
}}
` JavaScript ``
function countSetBit(x) { let count = 0; while (x > 0) { count += x & 1; x >>= 1; } return count; }
function printSubarraysWithSetBitSumX(arr, X) {
const n = arr.length;
let i = 0, j = 0, currSum = 0;
while (j < n) {
currSum += countSetBit(arr[j]);
j++;
while (currSum > X) {
currSum -= countSetBit(arr[i]);
i++;
}
if (currSum === X) {
console.log((${i + 1}, ${j}));
}
}
}
const arr = [1, 4, 3, 5, 7]; const X = 4; printSubarraysWithSetBitSumX(arr, X); // prints (1, 3) (3, 4)
``
**Time complexity: O(n*logx)
**Auxiliary Space: O(n)
Similar Reads
- Find all subarrays with sum in the given range Given an unsorted array of size, N. Find subarrays that add to a sum in the given range L-R. Examples: Input: arr[] = {2, 3, 5, 8}, L = 4, R = 13Output: The indexes of subarrays are {0, 1}, {0, 2}, {1, 2}, {2, 2}, {2, 3}, {3, 3} Input: arr[] = {1, 4, 6}, L = 3, R = 8Output: The indexes of subarrays 4 min read
- Smallest subarray from a given Array with sum greater than or equal to K | Set 2 Given an array A[] consisting of N positive integers and an integer K, the task is to find the length of the smallest subarray with a sum greater than or equal to K. If no such subarray exists, print -1. Examples: Input: arr[] = {3, 1, 7, 1, 2}, K = 11Output: 3Explanation:The smallest subarray with 15+ min read
- Print all subarrays with sum in a given range Given an array arr[] of positive integers and two integers L and R defining the range [L, R]. The task is to print the subarrays having sum in the range L to R. Examples: Input: arr[] = {1, 4, 6}, L = 3, R = 8Output: {1, 4}, {4}, {6}.Explanation: All the possible subarrays are the following{1] with 5 min read
- Count of Subarrays with sum equals k in given Binary Array Given a binary array arr[] and an integer k, the task is to find the count of non-empty subarrays with a sum equal to k.Examples:Input: arr[] = {1, 0, 1, 1, 0, 1}, k = 2Output: 6Explanation: All valid subarrays are: {1, 0, 1}, {0, 1, 1}, {1, 1}, {1, 0, 1}, {0, 1, 1, 0}, {1, 1, 0}.Input: arr[] = {0, 10 min read
- Generate Array whose sum of all K-size subarrays divided by N leaves remainder X Given three integer N, K and X, the task is to create an array of length N such that sum of all its K-length subarrays modulo N is X.Examples: Input: N = 6, K = 3, X = 3 Output: 9 6 6 9 6 6 Explanation: All subarrays of length 3 and their respective sum%N values are as follows: [9, 6, 6] Sum = 21 % 4 min read
- Find maximum sum by replacing the Subarray in given range Given an array arr[], the task is to find the maximum sum possible such that any subarray of the indices from [l, r] i.e all subarray elements from arr[l] to arr[r] can be replaced with |arr[l] - arr[r]| any number of times. Examples: Input: arr[] = { 9, 1}Output: 16Explanation: The subarray [l, r] 9 min read
- Check if the sum of a subarray within a given range is a perfect square or not Given an array arr[] of size N and an array range[], the task is to check if the sum of the subarray {range[0], .. , range[1]} is a perfect square or not. If the sum is a perfect square, then print the square root of the sum. Otherwise, print -1. Example : Input: arr[] = {2, 19, 33, 48, 90, 100}, ra 7 min read
- Find a subarray whose sum is divisible by size of the array Given an array arr[] of length N. The task is to check if there exists any subarray whose sum is a multiple of N. If there exists such subarray, then print the starting and ending index of that subarray else print -1. If there are multiple such subarrays, print any of them. Examples: Input: arr[] = 13 min read
- Find a number with least sum of bit differences from given Array Given an array arr[] and an integer L which represents the number of bits to be considered in bit representation of an array element. The task is to find a positive integer X, such that the sum of the bit difference of all the elements in arr[] with X is minimum. Examples: Input: N = 3, L = 5, arr[] 8 min read
- Queries for bitwise AND in the index range [L, R] of the given array Given an array arr[] of N and Q queries consisting of a range [L, R]. the task is to find the bit-wise AND of all the elements of in that index range.Examples: Input: arr[] = {1, 3, 1, 2, 3, 4}, q[] = {{0, 1}, {3, 5}} Output: 1 0 1 AND 3 = 1 2 AND 3 AND 4 = 0Input: arr[] = {1, 2, 3, 4, 5}, q[] = {{0 8 min read