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

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’ at 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 index 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 by 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`

Output:

```2
```

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

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.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.