Count Subsequence of 101 in binary form of a number

Given a number N, the task is to count the occurrences of 101 subsequences in the binary representation of that number.

Examples:

Input: N = 10
Output: 1
Explanation: The binary representation of the number 10 is 1010 and there is only one subsequence 101 which is starting from the left end of binary form is present.

Input: N = 21
Output: 4
Explanation: The binary representation of 21 is 10101 and there are total 4 subsequences of 101 are present.

Approach: To solve the problem follow the below observations:

Observations:

The key to this problem is observations. So if we have binary representation like 101, then the total contribution of a zero is multiplication of the number of 1's present at its left and number of 1's present at its right.

Illustration:

For example, 21 whose binary is 10101 if we talk about 0 present at index-1 there is one 1 at its left and two 1 at right so it can contribute total 1*2=2, and for another 0 present at index-3 there is two 1 at left and one 1 at right so it will contribute 2*1=2. So the answer will be 2+2 = 4.

Steps to implement the above approach:

• Call the totalCount function to return the count of 101 subsequences.
• Iterate over each bit in n
  • First, for every 0 bit, we push the number of 1s to its right in the right vector. Also, simultaneously increase the count of the number of 1 bit.
• Iterate over this vector, and update the ans with the multiplication of the number of 1s on left and right respectively for every 0.

Below is the code to implement the above steps:

#include <bits/stdc++.h>
using namespace std;
long long TotalCount(long long n)
{

    // To keep number of 1 at right
    vector<int> right;

    // Total answer
    long long ans = 0;

    // Total 1
    int one = 0;

    while (n != 0) {

        // If bit is set
        if (n & 1) {
            one++;
        }

        // Else the total number of one
        // till now is right for current 0
        else {
            right.push_back(one);
        }

        n >>= 1;
    }

    for (auto x : right) {

        // Number of one's at left =
        // total-right
        int left = one - x;

        // Adding to answer the
        // contribution of current 0
        ans += (left * x);
    }

    return ans;
}

// Drivers code
int main()
{

    // Given number
    long long n = 21;

    // Calling function
    cout << TotalCount(n) << endl;

    return 0;
}

import java.util.*;

public class Main {
    public static long TotalCount(long n)
    {

        // To keep number of 1 at right
        List<Integer> right = new ArrayList<>();

        // Total answer
        long ans = 0;

        // Total 1
        int one = 0;

        while (n != 0) {

            // If bit is set
            if ((n & 1) == 1) {
                one++;
            }

            // Else the total number of one
            // till now is right for current 0
            else {
                right.add(one);
            }

            n >>= 1;
        }

        for (int x : right) {

            // Number of one's at left =
            // total-right
            int left = one - x;

            // Adding to answer the
            // contribution of current 0
            ans += (left * x);
        }

        return ans;
    }

    // Drivers code
    public static void main(String[] args)
    {

        // Given number
        long n = 21;

        // Calling function
        System.out.println(TotalCount(n));
    }
}
// This code is contributed by Prajwal Kandekar

def total_count(n):
    # To keep number of 1 at right
    right = []

    # Total answer
    ans = 0

    # Total 1
    one = 0

    while n != 0:
        # If bit is set
        if n & 1:
            one += 1
        # Else the total number of one
        # till now is right for current 0
        else:
            right.append(one)
        n >>= 1

    for x in right:
        # Number of one's at left =
        # total-right
        left = one - x

        # Adding to answer the
        # contribution of current 0
        ans += left * x

    return ans

# Driver code
if __name__ == "__main__":
    # Given number
    n = 21

    # Calling function
    print(total_count(n))

using System;
using System.Collections.Generic;

public class GFG{
       public static long TotalCount(long n)
    {

        // To keep number of 1 at right
        List<int> right = new List<int>();

        // Total answer
        long ans = 0;

        // Total 1
        int one = 0;

        while (n != 0) {

            // If bit is set
            if ((n & 1) == 1) {
                one++;
            }

            // Else the total number of one
            // till now is right for current 0
            else {
                right.Add(one);
            }

            n >>= 1;
        }

        foreach (int x in right) {

            // Number of one's at left =
            // total-right
            int left = one - x;

            // Adding to answer the
            // contribution of current 0
            ans += (left * x);
        }

        return ans;
    }

    // Drivers code
    public static void Main(String[] args)
    {

        // Given number
        long n = 21;

        // Calling function
        Console.WriteLine(TotalCount(n));
    }
}

function TotalCount(n) {
//To keep number of 1 at right
let right = [];
//Total answer
let ans = 0;
//To keep number of 1 at right
let one = 0;

while (n != 0) {
    if (n & 1) {
        one++;
    }
    else {
        right.push(one);
    }

    n >>= 1;
}

for (let x of right) {
    let left = one - x;
    ans += (left * x);
}

return ans;
}

// Given number
let n = 21;
// Calling function
console.log(TotalCount(n));

4

Time Complexity: O(Log(N))
Auxiliary Space: O(Log(N))