Given binary string **str** of **0’s** and **1’s** only. The task is to count the total number 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:4Explanation:

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:7Explanation:

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++ 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's` `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 += min(cnt0, cnt1);` ` ` `}` ` ` `// Return answer` ` ` `return` `ans;` `}` `// Driver code` `int` `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

`// 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's` `int` `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 code` `int` `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

`// Java implementation of the above approach` `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.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

`# Python3 implementation of the` `# above approach` `# Function to find the count` `# of substrings with equal no.` `# of consecutive 0's and 1's` `def` `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 code` `if` `__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#

`// C# implementation of the ` `// above approach ` `using` `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` |

## Javascript

`<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>` |

**Output:**

7

**Time Complexity:** O(N), where N = length of string.**Auxiliary Space:** O(1), no extra space is required, so it is a constant.