Open In App

Count of groups of consecutive 1s in a given Binary String

Last Updated : 23 Jul, 2025
Comments
Improve
Suggest changes
4 Likes
Like
Report

Given a binary string S of size N, the task is to find the number of groups of 1s only in the string S.

Examples:

Input: S = "100110111", N = 9
Output: 3
Explanation: 
The following groups are of 1s only:

  1. Group over the range [0, 0] which is equal to "1".
  2. Group over the range [3, 4] which is equal to "11".
  3. Group over the range [6, 8] which is equal to "111".

Therefore, there are a total of 3 groups of 1s only.

Input: S = "0101"
Output: 2

 

Approach: The problem can be solved by iterating over the characters of the string. Follow the steps below to solve the problem:

  • Initialize a variable, say count as 0, which stores the number of substrings of 1s in S.
  • Initialize a stack say st to store the substring before an index of 1s only.
  • Iterate over the characters of the string S, using the variable i and do the following:
    • If the current character is 1, push 1 into stack st.
    • Otherwise, If st is not empty, increment count by 1. Else Clear st.
  • If st is not empty, increment count by 1, i.e If there is a suffix of 1s.
  • Finally, print the total count obtained.

Below is the implementation of the above approach:

C++ 
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the number of the
// groups of 1s only in the binary
// string
int groupsOfOnes(string S, int N)
{
    // Stores number of groups of 1s
    int count = 0;

    // Initialization of the stack
    stack<int> st;

    // Traverse the string S
    for (int i = 0; i < N; i++) {

        // If S[i] is '1'
        if (S[i] == '1')
            st.push(1);
        // Otherwise
        else {
            // If st is empty
            if (!st.empty()) {
                count++;
                while (!st.empty()) {
                    st.pop();
                }
            }
        }
    }
    // If st is not empty
    if (!st.empty())
        count++;

    // Return answer
    return count;
}
// Driver code
int main()
{
    // Input
    string S = "100110111";
    int N = S.length();

    // Function call
    cout << groupsOfOnes(S, N) << endl;
    return 0;
}
Java 
// Java program for the above approach
import java.util.Stack;

class GFG{

// Function to find the number of the
// groups of 1s only in the binary
// string
static int groupsOfOnes(String S, int N)
{
    
    // Stores number of groups of 1s
    int count = 0;

    // Initialization of the stack
    Stack<Integer> st = new Stack<>();

    // Traverse the string S
    for(int i = 0; i < N; i++) 
    {
        
        // If S[i] is '1'
        if (S.charAt(i) == '1')
            st.push(1);
            
        // Otherwise
        else 
        {
            
            // If st is empty
            if (!st.empty())
            {
                count++;
                while (!st.empty()) 
                {
                    st.pop();
                }
            }
        }
    }
    
    // If st is not empty
    if (!st.empty())
        count++;

    // Return answer
    return count;
}

// Driver code
public static void main(String[] args)
{
    
    // Input
    String S = "100110111";
    int N = S.length();

    // Function call
    System.out.println(groupsOfOnes(S, N));
}
}

// This code is contributed by abhinavjain194
Python3 
# Python3 program for the above approach

# Function to find the number of the
# groups of 1s only in the binary
# string
def groupsOfOnes(S, N):
    
    # Stores number of groups of 1s
    count = 0

    # Initialization of the stack
    st = []

    # Traverse the string S
    for i in range(N):
        
        # If S[i] is '1'
        if (S[i] == '1'):
            st.append(1)
            
        # Otherwise
        else:
            
            # If st is empty
            if (len(st) > 0):
                count += 1
                while (len(st) > 0):
                    del st[-1]
                    
    # If st is not empty
    if (len(st)):
        count += 1

    # Return answer
    return count
    
# Driver code
if __name__ == '__main__':
    
    # Input
    S = "100110111"
    N = len(S)
    
    # Function call
    print(groupsOfOnes(S, N))
    
# This code is contributed by mohit kumar 29
C# 
// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG{

// Function to find the number of the
// groups of 1s only in the binary
// string
static int groupsOfOnes(string S, int N)
{
  
    // Stores number of groups of 1s
    int count = 0;

    // Initialization of the stack
    Stack<int> st = new Stack<int>();

    // Traverse the string S
    for (int i = 0; i < N; i++) {

        // If S[i] is '1'
        if (S[i] == '1')
            st.Push(1);
        // Otherwise
        else {
            // If st is empty
            if (st.Count > 0) {
                count++;
                while (st.Count > 0) {
                    st.Pop();
                }
            }
        }
    }
  
    // If st is not empty
    if (st.Count > 0)
        count++;

    // Return answer
    return count;
}
  
// Driver code
public static void Main()
{
    // Input
    string S = "100110111";
    int N = S.Length;

    // Function call
    Console.Write(groupsOfOnes(S, N));
}
}

// This code is contributed by SURENDRA_GANGWAR.
JavaScript 
<script>

        // JavaScript program for the above approach

        // Function to find the number of the
        // groups of 1s only in the binary
        // string
        function groupsOfOnes(S, N) {
            // Stores number of groups of 1s
            let count = 0;

            // Initialization of the stack
            var st = [];

            // Traverse the string S
            for (let i = 0; i < N; i++) {

                // If S[i] is '1'
                if (S[i] == '1')
                    st.push(1);
                // Otherwise
                else {
                    // If st is empty
                    if (st.length != 0) {
                        count++;
                        while (st.length != 0) {
                            st.pop();
                        }
                    }
                }
            }
            // If st is not empty
            if (st.length != 0)
                count++;

            // Return answer
            return count;
        }
        // Driver code

        // Input
        var S = "100110111";
        let N = S.length;

        // Function call
        document.write(groupsOfOnes(S, N));

// This code is contributed by Potta Lokesh

</script>

Output
3

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


 


A

AakashSingh_17
Improve
Article Tags :

Explore

Lightbox