# Minimum substring reversals required to make given Binary String alternating

• Last Updated : 01 Jun, 2021

Given a binary string S of length N, the task is to count the minimum number substrings of S that is required to be reversed to make the string S alternating. If it is not possible to make string alternating, then print “-1”.

Examples:

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.

Input: S = “10001110”
Output: 2
Explanation:
In the first operation, reversing the substring {S, .., S} modifies the string to “10110010”.
In the second operation, reversing the substring {S, .. S}modifies the string to “10101010”, which is alternating.

Input: S = “100001”
Output: -1
Explanation: Not possible to obtain an alternating binary string.

Approach: The idea is based on the observation that when a substring s[L, R] is reversed, then no more than two pairs s[L – 1], s[L] and s[R], S[R + 1] are changed. Moreover, one pair should be a consecutive pair of 00 and the other 11. So, the minimum number of operations can be obtained by pairing 00 with 11 or with the left/right border of S. Thus, the required number of operations is half of the number of consecutive pairs of the same character. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count the minimum number``// of substrings required to be reversed``// to make the string S alternating``int` `minimumReverse(string s, ``int` `n)``{``    ``// Store count of consecutive pairs``    ``int` `k = 0 , l = 0 ;` `    ``// Stores the count of 1s and 0s``    ``int` `sum1 = 0, sum0 = 0;` `    ``// Traverse through the string``    ``for` `(``int` `i = 1; i < n; i++) {` `        ``if` `(s[i] == ``'1'``)` `            ``// Increment 1s count``            ``sum1++;``        ``else` `            ``// Increment 0s count``            ``sum0++;` `        ``// Increment K if consecutive``        ``// same elements are found``        ``if` `(s[i] == s[i - 1]&& s[i] == ``'0'``)``            ``k++;``      ``else` `if``( s[i] == s[i - 1]&& s[i] == ``'1'``)``        ``l++;``    ``}``  ` `    ``// Increment 1s count``    ``if``(s==``'1'``)    ``       ``sum1++;``    ``else`  `// Increment 0s count``       ``sum0++;` `    ``// Check if it is possible or not``    ``if` `(``abs``(sum1 - sum0) > 1)``        ``return` `-1;` `    ``// Otherwise, print the number``    ``// of required operations``    ``return` `max(k , l );``}` `// Driver Code``int` `main()``{``    ``string S = ``"10001"``;``    ``int` `N = S.size();` `    ``// Function Call``    ``cout << minimumReverse(S, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``import` `java.lang.*;` `class` `GFG``{` `  ``// Function to count the minimum number``  ``// of substrings required to be reversed``  ``// to make the string S alternating``  ``static` `int` `minimumReverse(String s, ``int` `n)``  ``{` `    ``// Store count of consecutive pairs``    ``int` `k = ``0` `, l = ``0` `;` `    ``// Stores the count of 1s and 0s``    ``int` `sum1 = ``0``, sum0 = ``0``;` `    ``// Traverse through the string``    ``for` `(``int` `i = ``1``; i < n; i++)``    ``{` `      ``if` `(s.charAt(i) == ``'1'``)` `        ``// Increment 1s count``        ``sum1++;``      ``else` `        ``// Increment 0s count``        ``sum0++;` `      ``// Increment K if consecutive``      ``// same elements are found``      ``if` `(s.charAt(i) == s.charAt(i - ``1``) && s.charAt(i) == ``'0'``)``        ``k++;``      ``else` `if``( s.charAt(i) == s.charAt(i - ``1``) && s.charAt(i) == ``'1'``)``        ``l++;``    ``}` `    ``// Increment 1s count``    ``if``(s.charAt(``0``)==``'1'``)    ``      ``sum1++;``    ``else`  `// Increment 0s count``      ``sum0++;` `    ``// Check if it is possible or not``    ``if` `(Math.abs(sum1 - sum0) > ``1``)``      ``return` `-``1``;` `    ``// Otherwise, print the number``    ``// of required operations``    ``return` `Math.max(k , l);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main (String[] args)``  ``{``    ``String S = ``"10001"``;``    ``int` `N = S.length();` `    ``// Function Call``    ``System.out.print(minimumReverse(S, N));` `  ``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python program for the above approach` `# Function to count the minimum number``# of substrings required to be reversed``# to make the string S alternating``def` `minimumReverse(s, n):``  ` `    ``# Store count of consecutive pairs``    ``k ``=` `0``;``    ``l ``=` `0``;` `    ``# Stores the count of 1s and 0s``    ``sum1 ``=` `0``;``    ``sum0 ``=` `0``;` `    ``# Traverse through the string``    ``for` `i ``in` `range``(``1``, n):``        ``if` `(s[i] ``=``=` `'1'``):` `            ``# Increment 1s count``            ``sum1 ``+``=` `1``;``        ``else``:` `            ``# Increment 0s count``            ``sum0 ``+``=` `1``;` `        ``# Increment K if consecutive``        ``# same elements are found``        ``if` `(s[i] ``=``=` `s[i ``-` `1``] ``and` `s[i] ``=``=` `'0'``):``            ``k ``+``=` `1``;``        ``elif` `(s[i] ``=``=` `s[i ``-` `1``] ``and` `s[i] ``=``=` `'1'``):``            ``l ``+``=` `1``;` `    ``# Increment 1s count``    ``if` `(s[``0``] ``=``=` `'1'``):``        ``sum1 ``+``=` `1``;``    ``else``:  ``# Increment 0s count``        ``sum0 ``+``=` `1``;` `    ``# Check if it is possible or not``    ``if` `(``abs``(sum1 ``-` `sum0) > ``1``):``        ``return` `-``1``;` `    ``# Otherwise, print the number``    ``# of required operations``    ``return` `max``(k, l);` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``S ``=` `"10001"``;``    ``N ``=` `len``(S);` `    ``# Function Call``    ``print``(minimumReverse(S, N));` `# This code is contributed by shikhasingrajput`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `GFG``{` `  ``// Function to count the minimum number``  ``// of substrings required to be reversed``  ``// to make the string S alternating``  ``static` `int` `minimumReverse(String s, ``int` `n)``  ``{` `    ``// Store count of consecutive pairs``    ``int` `k = 0 , l = 0 ;` `    ``// Stores the count of 1s and 0s``    ``int` `sum1 = 0, sum0 = 0;` `    ``// Traverse through the string``    ``for` `(``int` `i = 1; i < n; i++)``    ``{` `      ``if` `(s[i] == ``'1'``)` `        ``// Increment 1s count``        ``sum1++;``      ``else` `        ``// Increment 0s count``        ``sum0++;` `      ``// Increment K if consecutive``      ``// same elements are found``      ``if` `(s[i] == s[i-1] && s[i] == ``'0'``)``        ``k++;``      ``else` `if``( s[i] == s[i-1] && s[i] == ``'1'``)``        ``l++;``    ``}` `    ``// Increment 1s count``    ``if``(s == ``'1'``)    ``      ``sum1++;``    ``else`  `// Increment 0s count``      ``sum0++;` `    ``// Check if it is possible or not``    ``if` `(Math.Abs(sum1 - sum0) > 1)``      ``return` `-1;` `    ``// Otherwise, print the number``    ``// of required operations``    ``return` `Math.Max(k , l);``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``String S = ``"10001"``;``    ``int` `N = S.Length;` `    ``// Function Call``    ``Console.Write(minimumReverse(S, N));``  ``}``}`  `// This code is contributed by shikhasingrajput`

## Javascript

 ``
Output:
`2`

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

My Personal Notes arrow_drop_up