Minimum flips required to convert given string into concatenation of equal substrings of length K

Last Updated : 28 May, 2021

Given a binary string S and an integer K, the task is to find the minimum number of flips required to convert the given string into a concatenation of K-length equal sub-strings. It is given that the given string can be split into K-length substrings.

Examples:

Input: S = “101100101”, K = 3
Output:
Explanation:
Flip the ‘0’ from index 5 to ‘1’.
The resultant string is S = “101101101”.
It is the concatenation of substring “101”.
Hence, the minimum number of flips required is 1.

Input: S = “10110111”, K = 4
Output:
Explanation:
Flip the ‘0’ and ‘1’ at indexes 4 and 5 respectively.
The resultant string is S = “10111011”.
It is the concatenation of the substring “1011”.
Hence, the minimum number of flips required is 2.

Approach:
The problem can be solved using Greedy Approach

• Iterate the given string with increments of K indices from each index and keep a count of the 0s and 1s.
• The character which occurs the minimum number of times must be flipped and keep incrementing that count.
• Perform the above steps for all the indices from 0 to K-1 to obtain the minimum number of flips required.

Below is the implementation of the above approach:

C++

 `// C++ Program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function that returns the minimum` `// number of flips to convert` `// the s into a concatenation` `// of K-length sub-string` `int` `minOperations(string S, ``int` `K)` `{` `    ``// Stores the result` `    ``int` `ans = 0;`   `    ``// Iterate through string index` `    ``for` `(``int` `i = 0; i < K; i++) {`   `        ``// Stores count of 0s & 1s` `        ``int` `zero = 0, one = 0;`   `        ``// Iterate making K jumps` `        ``for` `(``int` `j = i;` `             ``j < S.size(); j += K) {`   `            ``// Count 0's` `            ``if` `(S[j] == ``'0'``)` `                ``zero++;`   `            ``// Count 1's` `            ``else` `                ``one++;` `        ``}`   `        ``// Add minimum flips` `        ``// for index i` `        ``ans += min(zero, one);` `    ``}`   `    ``// Return minimum number` `    ``// of flips` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``string S = ``"110100101"``;`   `    ``int` `K = 3;`   `    ``cout << minOperations(S, K);`   `    ``return` `0;` `}`

Java

 `// Java program to implement ` `// the above approach ` `import` `java.io.*;`   `class` `GFG{`   `// Function that returns the minimum` `// number of flips to convert` `// the s into a concatenation` `// of K-length sub-string` `public` `static` `int` `minOperations(String S, ``int` `K)` `{` `    `  `    ``// Stores the result` `    ``int` `ans = ``0``;`   `    ``// Iterate through string index` `    ``for``(``int` `i = ``0``; i < K; i++)` `    ``{`   `        ``// Stores count of 0s & 1s` `        ``int` `zero = ``0``, one = ``0``;`   `        ``// Iterate making K jumps` `        ``for``(``int` `j = i; j < S.length(); j += K)` `        ``{` `            `  `            ``// Count 0's` `            ``if` `(S.charAt(j) == ``'0'``)` `                ``zero++;`   `            ``// Count 1's` `            ``else` `                ``one++;` `        ``}`   `        ``// Add minimum flips` `        ``// for index i` `        ``ans += Math.min(zero, one);` `    ``}`   `    ``// Return minimum number` `    ``// of flips` `    ``return` `ans;` `}`   `// Driver Code` `public` `static` `void` `main(String args[])` `{` `    ``String S = ``"110100101"``;`   `    ``int` `K = ``3``;`   `    ``System.out.println(minOperations(S, K));` `}` `}`   `// This code is contributed by grand_master`

Python3

 `# Python3 program to implement` `# the above approach`   `# Function that returns the minimum` `# number of flips to convert the s` `# into a concatenation of K-length` `# sub-string` `def` `minOperations(S, K):`   `    ``# Stores the result` `    ``ans ``=` `0`   `    ``# Iterate through string index` `    ``for` `i ``in` `range``(K):`   `        ``# Stores count of 0s & 1s` `        ``zero, one ``=` `0``, ``0`   `        ``# Iterate making K jumps` `        ``for` `j ``in` `range``(i, ``len``(S), K):`   `            ``# Count 0's` `            ``if``(S[j] ``=``=` `'0'``):` `                ``zero ``+``=` `1`   `            ``# Count 1's` `            ``else``:` `                ``one ``+``=` `1`   `        ``# Add minimum flips` `        ``# for index i` `        ``ans ``+``=` `min``(zero, one)`   `    ``# Return minimum number` `    ``# of flips ` `    ``return` `ans`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``s ``=` `"110100101"` `    ``K ``=` `3`   `    ``print``(minOperations(s, K))`   `# This code is contributed by Shivam Singh`

C#

 `// C# program to implement ` `// the above approach ` `using` `System;`   `class` `GFG{`   `// Function that returns the minimum` `// number of flips to convert` `// the s into a concatenation` `// of K-length sub-string` `public` `static` `int` `minOperations(String S, ``int` `K)` `{` `    `  `    ``// Stores the result` `    ``int` `ans = 0;`   `    ``// Iterate through string index` `    ``for``(``int` `i = 0; i < K; i++)` `    ``{`   `        ``// Stores count of 0s & 1s` `        ``int` `zero = 0, one = 0;`   `        ``// Iterate making K jumps` `        ``for``(``int` `j = i; j < S.Length; j += K)` `        ``{` `            `  `            ``// Count 0's` `            ``if` `(S[j] == ``'0'``)` `                ``zero++;`   `            ``// Count 1's` `            ``else` `                ``one++;` `        ``}`   `        ``// Add minimum flips` `        ``// for index i` `        ``ans += Math.Min(zero, one);` `    ``}`   `    ``// Return minimum number` `    ``// of flips` `    ``return` `ans;` `}`   `// Driver Code` `public` `static` `void` `Main(String []args)` `{` `    ``String S = ``"110100101"``;`   `    ``int` `K = 3;`   `    ``Console.WriteLine(minOperations(S, K));` `}` `}`   `// This code is contributed by 29AjayKumar`

Javascript

 ``

Output:

`2`

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

Previous
Next