Count of sub-strings with equal consecutive 0’s and 1’s

09 May, 2022
Given binary string str of 0’s and 1’s only. The task is to count the total numbers of substrings of string str such that each substring has an equal number of consecutive 0’s and 1’s in it.Examples  
Input: str = “010011” Output: 4 Explanation: The substrings with consecutive 0’s and 1’s are “01”, “10”, “0011”, “01”. Hence, the count is 4. Note: The two “01” are at different positions: [0, 1] and [3, 4]. “010011” has the same number of 0’s and 1’s but they are not consecutive.Input: str = “0001110010” Output: 7 Explanation: The substrings with consecutive 0’s and 1’s are “000111”, “0011”, “01”, “1100”, “10”, “01”, “10”. 
 
Approach:  
Count the number of consecutive 0’s (or 1’s) from start of the string.
Then count the number of consecutive 1’s (or 0’s) from the position in the string str where count of 0’s (or 1’s) ends.
The total number of substrings with consecutive 0’s and 1’s is the minimum of the count of consecutive 0’s and 1’s found in above two steps.
Repeat the above steps till the end of the string str.
Below is the implementation of the above approach:  
C++
C
Java
Python3
C#
Javascript
// C++ implementation of the above approach#include <bits/stdc++.h>using namespace std; // Function to find the count of substrings with equal no.// of consecutive 0's and 1'sint countSubstring(string& S, int& n){    // To store the total count of substrings    int ans = 0;     int i = 0;     // Traversing the string    while (i < n) {         // Count of consecutive 0's & 1's        int cnt0 = 0, cnt1 = 0;         // Counting subarrays of type "01"        if (S[i] == '0') {             // Count the consecutive 0's            while (i < n && S[i] == '0') {                cnt0++;                i++;            }             // If consecutive 0's ends then check for            // consecutive 1's            int j = i;             // Counting consecutive 1's            while (j < n && S[j] == '1') {                cnt1++;                j++;            }        }         // Counting subarrays of type "10"        else {             // Count consecutive 1's            while (i < n && S[i] == '1') {                cnt1++;                i++;            }             // If consecutive 1's ends then check for            // consecutive 0's            int j = i;             // Count consecutive 0's            while (j < n && S[j] == '0') {                cnt0++;                j++;            }        }         // Update the total count of substrings with minimum        // of (cnt0, cnt1)        ans += min(cnt0, cnt1);    }     // Return answer    return ans;} // Driver codeint main(){    string S = "0001110010";    int n = S.length();     // Function to print the count of substrings    cout << countSubstring(S, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// C implementation of the above approach#include <stdio.h>#include <string.h> // Find minimum between two numbers.int min(int num1, int num2){    return (num1 > num2) ? num2 : num1;} // Function to find the count of substrings with equal no.// of consecutive 0's and 1'sint countSubstring(char S[], int n){    // To store the total count of substrings    int ans = 0;     int i = 0;     // Traversing the string    while (i < n) {         // Count of consecutive 0's & 1's        int cnt0 = 0, cnt1 = 0;         // Counting subarrays of type "01"        if (S[i] == '0') {             // Count the consecutive 0's            while (i < n && S[i] == '0') {                cnt0++;                i++;            }             // If consecutive 0's ends then check for            // consecutive 1's            int j = i;             // Counting consecutive 1's            while (j < n && S[j] == '1') {                cnt1++;                j++;            }        }         // Counting subarrays of type "10"        else {             // Count consecutive 1's            while (i < n && S[i] == '1') {                cnt1++;                i++;            }             // If consecutive 1's ends then check for            // consecutive 0's            int j = i;             // Count consecutive 0's            while (j < n && S[j] == '0') {                cnt0++;                j++;            }        }         // Update the total count of substrings with minimum        // of (cnt0, cnt1)        ans += min(cnt0, cnt1);    }     // Return answer    return ans;} // Driver codeint main(){    char S[] = "0001110010";    int n = strlen(S);     // Function to print the count of substrings    printf("%d", countSubstring(S, n));    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// Java implementation of the above approachclass GFG {     // Function to find the count of substrings with equal    // no. of consecutive 0's and 1's    static int countSubstring(String S, int n)    {        // To store the total count of substrings        int ans = 0;         int i = 0;         // Traversing the string        while (i < n) {             // Count of consecutive 0's & 1's            int cnt0 = 0, cnt1 = 0;             // Counting subarrays of type "01"            if (S.charAt(i) == '0') {                 // Count the consecutive 0's                while (i < n && S.charAt(i) == '0') {                    cnt0++;                    i++;                }                 // If consecutive 0's ends then check for                // consecutive 1's                int j = i;                 // Counting consecutive 1's                while (j < n && S.charAt(j) == '1') {                    cnt1++;                    j++;                }            }             // Counting subarrays of type "10"            else {                 // Count consecutive 1's                while (i < n && S.charAt(i) == '1') {                    cnt1++;                    i++;                }                 // If consecutive 1's ends then check for                // consecutive 0's                int j = i;                 // Count consecutive 0's                while (j < n && S.charAt(j) == '0') {                    cnt0++;                    j++;                }            }             // Update the total count of substrings with            // minimum of (cnt0, cnt1)            ans += Math.min(cnt0, cnt1);        }         // Return answer        return ans;    }     // Driver code    static public void main(String args[])    {        String S = "0001110010";        int n = S.length();         // Function to print the count of substrings        System.out.println(countSubstring(S, n));    }} // This code is contributed by Aditya Kumar (adityakumar129)
# Python3 implementation of the# above approach # Function to find the count# of substrings with equal no.# of consecutive 0's and 1'sdef countSubstring(S, n) :     # To store the total count    # of substrings    ans = 0;     i = 0;     # Traversing the string    while (i < n) :         # Count of consecutive        # 0's & 1's        cnt0 = 0; cnt1 = 0;         # Counting subarrays of        # type "01"        if (S[i] == '0') :             # Count the consecutive            # 0's            while (i < n and S[i] == '0') :                cnt0 += 1;                i += 1;             # If consecutive 0's            # ends then check for            # consecutive 1's            j = i;             # Counting consecutive 1's            while (j < n and S[j] == '1') :                cnt1 += 1;                j += 1;         # Counting subarrays of        # type "10"        else :             # Count consecutive 1's            while (i < n and S[i] == '1') :                cnt1 += 1;                i += 1;             # If consecutive 1's            # ends then check for            # consecutive 0's            j = i;             # Count consecutive 0's            while (j < n and S[j] == '0') :                cnt0 += 1;                j += 1;         # Update the total count        # of substrings with        # minimum of (cnt0, cnt1)        ans += min(cnt0, cnt1);     # Return answer    return ans; # Driver codeif __name__ == "__main__" :    S = "0001110010";    n = len(S);     # Function to print the    # count of substrings    print(countSubstring(S, n));     # This code is contributed by Yash_R
// C# implementation of the// above approachusing System; class GFG{     // Function to find the count    // of substrings with equal no.    // of consecutive 0's and 1's    static int countSubstring(string S, int n)    {        // To store the total count        // of substrings        int ans = 0;             int i = 0;             // Traversing the string        while (i < n) {                 // Count of consecutive            // 0's & 1's            int cnt0 = 0, cnt1 = 0;                 // Counting subarrays of            // type "01"            if (S[i] == '0') {                     // Count the consecutive                // 0's                while (i < n && S[i] == '0') {                    cnt0++;                    i++;                }                     // If consecutive 0's                // ends then check for                // consecutive 1's                int j = i;                     // Counting consecutive 1's                while (j < n && S[j] == '1') {                    cnt1++;                    j++;                }            }                 // Counting subarrays of            // type "10"            else {                     // Count consecutive 1's                while (i < n && S[i] == '1') {                    cnt1++;                    i++;                }                     // If consecutive 1's                // ends then check for                // consecutive 0's                int j = i;                     // Count consecutive 0's                while (j < n && S[j] == '0') {                    cnt0++;                    j++;                }            }                 // Update the total count            // of substrings with            // minimum of (cnt0, cnt1)            ans += Math.Min(cnt0, cnt1);        }             // Return answer        return ans;    }         // Driver code    static public void Main ()    {        string S = "0001110010";        int n = S.Length;             // Function to print the        // count of substrings        Console.WriteLine(countSubstring(S, n));    }} // This code is contributed by Yash_R
<script> // Javascript implementation of the// above approach         // Function to find the count    // of substrings with equal no.    // of consecutive 0's and 1's    function countSubstring( S , n)    {        // To store the total count        // of substrings        var ans = 0;         var i = 0;         // Traversing the string        while (i < n) {             // Count of consecutive            // 0's & 1's            var cnt0 = 0, cnt1 = 0;             // Counting subarrays of            // type "01"            if (S.charAt(i) == '0') {                 // Count the consecutive                // 0's                while (i < n && S.charAt(i) == '0')                {                    cnt0++;                    i++;                }                 // If consecutive 0's                // ends then check for                // consecutive 1's                var j = i;                 // Counting consecutive 1's                while (j < n && S.charAt(j) == '1')                {                    cnt1++;                    j++;                }            }             // Counting subarrays of            // type "10"            else {                 // Count consecutive 1's                while (i < n && S.charAt(i) == '1')                {                    cnt1++;                    i++;                }                 // If consecutive 1's                // ends then check for                // consecutive 0's                var j = i;                 // Count consecutive 0's                while (j < n && S.charAt(j) == '0')                {                    cnt0++;                    j++;                }            }             // Update the total count            // of substrings with            // minimum of (cnt0, cnt1)            ans += Math.min(cnt0, cnt1);        }         // Return answer        return ans;    }     // Driver code        var S = "0001110010";        var n = S.length;         // Function to print the        // count of substrings        document.write(countSubstring(S, n)); // This code contributed by umadevi9616 </script>
7
 
Time Complexity: O(N), where N = length of string. 
Yash_R
umadevi9616
krisania804
binary-string
Pattern Searching
Strings
Strings
Pattern Searching
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.