# Count 1s present in a range of indices [L, R] in a given array

• Last Updated : 23 Apr, 2021

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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:

Input: N = 7, L = 2, R = 5
Output: 4
Explanation:
Step 1: arr[] = . 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

 `// C++ Program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to find the size of the``// array if the array initially``// contains a single element``int` `findSize(``int` `N)``{``    ``// Base case``    ``if` `(N == 0)``        ``return` `1;``    ``if` `(N == 1)``        ``return` `1;` `    ``int` `Size = 2 * findSize(N / 2) + 1;` `    ``// P / 2 -> findSize(N / 2)``    ``// P % 2 -> 1``    ``// P / 2 -> findSize(N / 2)``    ``return` `Size;``}` `// Function to return the count``// of 1s in the range [L, R]``int` `CountOnes(``int` `N, ``int` `L, ``int` `R)``{``    ``if` `(L > R) {``        ``return` `0;``    ``}` `    ``// Base Case``    ``if` `(N <= 1) {` `        ``return` `N;``    ``}` `    ``int` `ret = 0;``    ``int` `M = N / 2;``    ``int` `Siz_M = findSize(M);` `    ``// PART 1 -> N / 2``    ``// [1, Siz_M]``    ``if` `(L <= Siz_M) {` `        ``// Update the right end point``        ``// of the range to min(Siz_M, R)``        ``ret += CountOnes(``            ``N / 2, L, min(Siz_M, R));``    ``}` `    ``// PART 2 -> N % 2``    ``// [SizM + 1, Siz_M + 1]``    ``if` `(L <= Siz_M + 1 && Siz_M + 1 <= R) {``        ``ret += N % 2;``    ``}` `    ``// PART 3 -> N / 2``    ``// [SizM + 2, 2 * Siz_M - 1]``    ``// Same as PART 1``    ``// Property of Symmetricity``    ``// Shift the coordinates according to PART 1``    ``// Subtract (Siz_M + 1) from both L, R` `    ``if` `(Siz_M + 1 < R) {``        ``ret += CountOnes(N / 2,``                         ``max(1, L - Siz_M - 1),``                         ``R - Siz_M - 1);``    ``}` `    ``return` `ret;``}` `// Driver Code``int` `main()``{``    ``// Input``    ``int` `N = 7, L = 2, R = 5;` `    ``// Counts the number of 1's in``    ``// the range [L, R]``    ``cout << CountOnes(N, L, R) << endl;` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;``class` `GFG``{`` ` `// Function to find the size of the``// array if the array initially``// contains a single element``static` `int` `findSize(``int` `N)``{``    ` `    ``// Base case``    ``if` `(N == ``0``)``        ``return` `1``;``    ``if` `(N == ``1``)``        ``return` `1``;``    ``int` `Size = ``2` `* findSize(N / ``2``) + ``1``;``    ` `    ``// P / 2 -> findSize(N / 2)``    ``// P % 2 -> 1``    ``// P / 2 -> findSize(N / 2)``    ``return` `Size;``}``  ` `// Function to return the count``// of 1s in the range [L, R]``static` `int` `CountOnes(``int` `N, ``int` `L, ``int` `R)``{``    ``if` `(L > R)``    ``{``        ``return` `0``;``    ``}``    ` `    ``// Base Case``    ``if` `(N <= ``1``)``    ``{``        ``return` `N;``    ``}  ``    ``int` `ret = ``0``;``    ``int` `M = N / ``2``;``    ``int` `Siz_M = findSize(M);``  ` `    ``// PART 1 -> N / 2``    ``// [1, Siz_M]``    ``if` `(L <= Siz_M)``    ``{``        ` `        ``// Update the right end point``        ``// of the range to min(Siz_M, R)``        ``ret += CountOnes(N / ``2``, L,``                         ``Math.min(Siz_M, R));``    ``}``  ` `    ``// PART 2 -> N % 2``    ``// [SizM + 1, Siz_M + 1]``    ``if` `(L <= Siz_M + ``1` `&& Siz_M + ``1` `<= R)``    ``{``        ``ret += N % ``2``;``    ``}``  ` `    ``// PART 3 -> N / 2``    ``// [SizM + 2, 2 * Siz_M - 1]``    ``// Same as PART 1``    ``// Property of Symmetricity``    ``// Shift the coordinates according to PART 1``    ``// Subtract (Siz_M + 1) from both L, R``    ``if` `(Siz_M + ``1` `< R)``    ``{``        ``ret += CountOnes(N / ``2``,``                         ``Math.max(``1``, L - Siz_M - ``1``),``                         ``R - Siz_M - ``1``);``    ``}``    ``return` `ret;``}`` ` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ` `    ``// Input``    ``int` `N = ``7``, L = ``2``, R = ``5``;``    ` `    ``// Counts the number of 1's in``    ``// the range [L, R]``    ``System.out.println(CountOnes(N, L, R));``}``}` `// This code is contributed by code_hunt.`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to find the size of the``# array if the array initially``# contains a single element``def` `findSize(N):` `    ``# Base case``    ``if` `(N ``=``=` `0``):``        ``return` `1``    ``if` `(N ``=``=` `1``):``        ``return` `1` `    ``Size ``=` `2` `*` `findSize(N ``/``/` `2``) ``+` `1` `    ``# P / 2 -> findSize(N // 2)``    ``# P % 2 -> 1``    ``# P / 2 -> findSize(N / 2)``    ``return` `Size` `# Function to return the count``# of 1s in the range [L, R]``def` `CountOnes(N, L, R):` `    ``if` `(L > R):``        ``return` `0` `    ``# Base Case``    ``if` `(N <``=` `1``):``        ``return` `N` `    ``ret ``=` `0``    ``M ``=` `N ``/``/` `2``    ``Siz_M ``=` `findSize(M)` `    ``# PART 1 -> N / 2``    ``# [1, Siz_M]``    ``if` `(L <``=` `Siz_M):` `        ``# Update the right end point``        ``# of the range to min(Siz_M, R)``        ``ret ``+``=` `CountOnes(``            ``N ``/``/` `2``, L, ``min``(Siz_M, R))` `    ``# PART 2 -> N % 2``    ``# [SizM + 1, Siz_M + 1]``    ``if` `(L <``=` `Siz_M ``+` `1` `and` `Siz_M ``+` `1` `<``=` `R):``        ``ret ``+``=` `N ``%` `2` `    ``# PART 3 -> N / 2``    ``# [SizM + 2, 2 * Siz_M - 1]``    ``# Same as PART 1``    ``# Property of Symmetricity``    ``# Shift the coordinates according to PART 1``    ``# Subtract (Siz_M + 1) from both L, R` `    ``if` `(Siz_M ``+` `1` `< R):``        ``ret ``+``=` `CountOnes(N ``/``/` `2``,``                         ``max``(``1``, L ``-` `Siz_M ``-` `1``),``                         ``R ``-` `Siz_M ``-` `1``)` `    ``return` `ret` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Input``    ``N ``=` `7``    ``L ``=` `2``    ``R ``=` `5` `    ``# Counts the number of 1's in``    ``# the range [L, R]``    ``print``(CountOnes(N, L, R))` `# This code is contributed by chitranayal`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{` `// Function to find the size of the``// array if the array initially``// contains a single element``static` `int` `findSize(``int` `N)``{``    ` `    ``// Base case``    ``if` `(N == 0)``        ``return` `1;``    ``if` `(N == 1)``        ``return` `1;``  ` `    ``int` `Size = 2 * findSize(N / 2) + 1;``    ` `    ``// P / 2 -> findSize(N / 2)``    ``// P % 2 -> 1``    ``// P / 2 -> findSize(N / 2)``    ``return` `Size;``}``  ` `// Function to return the count``// of 1s in the range [L, R]``static` `int` `CountOnes(``int` `N, ``int` `L, ``int` `R)``{``    ``if` `(L > R)``    ``{``        ``return` `0;``    ``}``    ` `    ``// Base Case``    ``if` `(N <= 1)``    ``{``        ``return` `N;``    ``}``  ` `    ``int` `ret = 0;``    ``int` `M = N / 2;``    ``int` `Siz_M = findSize(M);``  ` `    ``// PART 1 -> N / 2``    ``// [1, Siz_M]``    ``if` `(L <= Siz_M)``    ``{``        ` `        ``// Update the right end point``        ``// of the range to min(Siz_M, R)``        ``ret += CountOnes(N / 2, L,``                         ``Math.Min(Siz_M, R));``    ``}``  ` `    ``// PART 2 -> N % 2``    ``// [SizM + 1, Siz_M + 1]``    ``if` `(L <= Siz_M + 1 && Siz_M + 1 <= R)``    ``{``        ``ret += N % 2;``    ``}``  ` `    ``// PART 3 -> N / 2``    ``// [SizM + 2, 2 * Siz_M - 1]``    ``// Same as PART 1``    ``// Property of Symmetricity``    ``// Shift the coordinates according to PART 1``    ``// Subtract (Siz_M + 1) from both L, R``    ``if` `(Siz_M + 1 < R)``    ``{``        ``ret += CountOnes(N / 2,``                         ``Math.Max(1, L - Siz_M - 1),``                         ``R - Siz_M - 1);``    ``}``    ``return` `ret;``}` `// Driver code``static` `void` `Main()``{``    ` `    ``// Input``    ``int` `N = 7, L = 2, R = 5;``    ` `    ``// Counts the number of 1's in``    ``// the range [L, R]``    ``Console.WriteLine(CountOnes(N, L, R));``}``}` `// This code is contributed by divyesh072019`

## Javascript

 ``
Output:
`4`

Time Complexity: O(N) ( Using Master’s Theorem, T(N) = 2 * T(N / 2) + 1 => T(N) = O(N))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up