Count 1s present in a range of indices [L, R] in a given array
Given an array arr[] consisting of a single element N (1 ≤ N ≤ 106) and two integers L and R, ( 1 ≤ L ≤ R ≤ 105), the task is to make all array elements either 0 or 1 using the following operations :
- Select an element P such that P > 1 from the array arr[].
- Replace P with three elements at the same position, floor(P/2), P%2, floor(P/2) sequentially. Therefore, the size of the array arr[] increases by 2 after each operation.
Print the count of a total number of 1s in the range of indices [L, R] in the array arr[] after performing all the operations.
Note: It is guaranteed that R is not greater than the length of the final array Arr.
Examples:
Input: N = 7, L = 2, R = 5
Output: 4
Explanation:
Step 1: arr[] = [7]. Selecting 7 modifies arr[] to {3, 1, 3}.
Step 2: arr[] = [3, 1, 3]. Selecting 3 modifies arr[] to {1, 1, 1, 1, 3}.
Step 3: arr[] = [1, 1, 1, 1, 3]. Selecting 3 modifies arr[] to {1, 1, 1, 1, 1, 1, 1}
Therefore, all the indices in the range [2, 5] are filled with 1s. Therefore, count is 4.
Input: N = 7, L = 2, R = 2
Output: 1
Approach: Follow the steps below to solve the problem using Recursion:
- Traverse the array.
- Declare a function FindSize(N) to find the size of the modified array when the given array initially consists only of one element, i.e N.
- Declare a function CountOnes(N) to calculate CountOnes(N / 2), N % 2 and CountOnes(N / 2) recursively.
Below is the implementation of the given approach :
C++14
#include <bits/stdc++.h>
using namespace std;
int findSize( int N)
{
if (N == 0)
return 1;
if (N == 1)
return 1;
int Size = 2 * findSize(N / 2) + 1;
return Size;
}
int CountOnes( int N, int L, int R)
{
if (L > R) {
return 0;
}
if (N <= 1) {
return N;
}
int ret = 0;
int M = N / 2;
int Siz_M = findSize(M);
if (L <= Siz_M) {
ret += CountOnes(
N / 2, L, min(Siz_M, R));
}
if (L <= Siz_M + 1 && Siz_M + 1 <= R) {
ret += N % 2;
}
if (Siz_M + 1 < R) {
ret += CountOnes(N / 2,
max(1, L - Siz_M - 1),
R - Siz_M - 1);
}
return ret;
}
int main()
{
int N = 7, L = 2, R = 5;
cout << CountOnes(N, L, R) << endl;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int findSize( int N)
{
if (N == 0 )
return 1 ;
if (N == 1 )
return 1 ;
int Size = 2 * findSize(N / 2 ) + 1 ;
return Size;
}
static int CountOnes( int N, int L, int R)
{
if (L > R)
{
return 0 ;
}
if (N <= 1 )
{
return N;
}
int ret = 0 ;
int M = N / 2 ;
int Siz_M = findSize(M);
if (L <= Siz_M)
{
ret += CountOnes(N / 2 , L,
Math.min(Siz_M, R));
}
if (L <= Siz_M + 1 && Siz_M + 1 <= R)
{
ret += N % 2 ;
}
if (Siz_M + 1 < R)
{
ret += CountOnes(N / 2 ,
Math.max( 1 , L - Siz_M - 1 ),
R - Siz_M - 1 );
}
return ret;
}
public static void main(String[] args)
{
int N = 7 , L = 2 , R = 5 ;
System.out.println(CountOnes(N, L, R));
}
}
|
Python3
def findSize(N):
if (N = = 0 ):
return 1
if (N = = 1 ):
return 1
Size = 2 * findSize(N / / 2 ) + 1
return Size
def CountOnes(N, L, R):
if (L > R):
return 0
if (N < = 1 ):
return N
ret = 0
M = N / / 2
Siz_M = findSize(M)
if (L < = Siz_M):
ret + = CountOnes(
N / / 2 , L, min (Siz_M, R))
if (L < = Siz_M + 1 and Siz_M + 1 < = R):
ret + = N % 2
if (Siz_M + 1 < R):
ret + = CountOnes(N / / 2 ,
max ( 1 , L - Siz_M - 1 ),
R - Siz_M - 1 )
return ret
if __name__ = = "__main__" :
N = 7
L = 2
R = 5
print (CountOnes(N, L, R))
|
C#
using System;
class GFG{
static int findSize( int N)
{
if (N == 0)
return 1;
if (N == 1)
return 1;
int Size = 2 * findSize(N / 2) + 1;
return Size;
}
static int CountOnes( int N, int L, int R)
{
if (L > R)
{
return 0;
}
if (N <= 1)
{
return N;
}
int ret = 0;
int M = N / 2;
int Siz_M = findSize(M);
if (L <= Siz_M)
{
ret += CountOnes(N / 2, L,
Math.Min(Siz_M, R));
}
if (L <= Siz_M + 1 && Siz_M + 1 <= R)
{
ret += N % 2;
}
if (Siz_M + 1 < R)
{
ret += CountOnes(N / 2,
Math.Max(1, L - Siz_M - 1),
R - Siz_M - 1);
}
return ret;
}
static void Main()
{
int N = 7, L = 2, R = 5;
Console.WriteLine(CountOnes(N, L, R));
}
}
|
Javascript
<script>
function findSize(N)
{
if (N == 0)
return 1;
if (N == 1)
return 1;
let Size = 2 *
findSize(parseInt(N / 2, 10)) + 1;
return Size;
}
function CountOnes(N, L, R)
{
if (L > R)
{
return 0;
}
if (N <= 1)
{
return N;
}
let ret = 0;
let M = parseInt(N / 2, 10);
let Siz_M = findSize(M);
if (L <= Siz_M)
{
ret += CountOnes(parseInt(N / 2, 10), L,
Math.min(Siz_M, R));
}
if (L <= Siz_M + 1 && Siz_M + 1 <= R)
{
ret += N % 2;
}
if (Siz_M + 1 < R)
{
ret += CountOnes(parseInt(N / 2, 10),
Math.max(1, L - Siz_M - 1), R - Siz_M - 1);
}
return ret;
}
let N = 7, L = 2, R = 5;
document.write(CountOnes(N, L, R));
</script>
|
Time Complexity: O(N) ( Using Master’s Theorem, T(N) = 2 * T(N / 2) + 1 => T(N) = O(N))
Auxiliary Space: O(N)
Last Updated :
23 Apr, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...