# Flip all 0s in given Binary Strings K times with different neighbours

Given a binary string **S** of size **N** and a positive integer **K**, the task is to repeatedly modify the given string **K** number of times by flipping all the **0s** having different adjacent characters in each iteration.

Note:For the character0present at0index then it will change to^{th}1only when1index character is^{st}1and if the last index character is0then it changes to‘1’if the second last index character is‘1’.

**Examples:**

Input:S = “01001”, K = 2Output:11111Explanation:Below are the operation performed K(= 2) number of times:|Operation 1:After flipping the string at indices 0, 2, 3, the string modifies to “11111”.Operation 2:There is no such possible flipping for the modified string S = “11111”.After the above operations, the modified string is “11111”.

Input:S = “10010001”, K = 3Output:11111011

**Approach:** The given problem can be solved by performing the given operation **K** number of times and then print the resultant string formed. Follow the steps below to solve this problem:

- Iterate over the range
**[0, K – 1]**using the variable**i**and perform the following steps:- Traverse the given string
**S**over the range**[0, N – 1]**using the variable**j**and perform the following steps:- If the character at
**0**index is^{th}**0**, then replace this value with the first - Otherwise, if character
**0**is present at the last index then replace this value with the**second last index**character. - Otherwise, convert all the
**0s**to**1**if the adjacent characters are different.

- If the character at
- After the above steps, if the string remains the same before the modification, then break out of the loop.

- Traverse the given string
- After completing the above steps, print the string
**S**as the resultant modified string.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to modify the given string` `// K number of times by flipping 0s` `// having different adjacent characters` `void` `convertString(string S, ` `int` `k)` `{` ` ` `// Size of the string` ` ` `int` `n = S.length();` ` ` `// Stores modified string after` ` ` `// each iteration` ` ` `string temp = S;` ` ` `// Iterate over the range [0 k]` ` ` `for` `(` `int` `i = 0; i < k; i++) {` ` ` `// Traverse the string S` ` ` `for` `(` `int` `j = 0; j < n; j++) {` ` ` `// If '0' is present at` ` ` `// 0th index then replace` ` ` `// it with 1st index` ` ` `if` `(j == 0 && S[j] == ` `'0'` `) {` ` ` `temp[j] = S[j + 1];` ` ` `}` ` ` `// If '0' is present at the` ` ` `// last index then replace` ` ` `// it with last index - 1` ` ` `// character` ` ` `else` `if` `(j == n - 1` ` ` `&& S[j] == ` `'0'` `) {` ` ` `temp[j] = S[j - 1];` ` ` `}` ` ` `// Otherwise, convert 0s` ` ` `// to 1 if the adjacent` ` ` `// characters are different` ` ` `else` `if` `(S[j - 1] != S[j + 1]` ` ` `&& S[j] == ` `'0'` `) {` ` ` `temp[j] = ` `'1'` `;` ` ` `}` ` ` `}` ` ` `// If during this iteration` ` ` `// there is no change in the` ` ` `// string then break this loop` ` ` `if` `(S == temp) {` ` ` `break` `;` ` ` `}` ` ` `// Update the string S` ` ` `S = temp;` ` ` `}` ` ` `// Print the updated string` ` ` `cout << S;` `}` `// Driver Code` `int` `main()` `{` ` ` `string S = ` `"10010001"` `;` ` ` `int` `K = 1;` ` ` `convertString(S, K);` ` ` `return` `0;` `}` |

## Python3

`# python 3 program for the above approach` `# Function to modify the given string` `# K number of times by flipping 0s` `# having different adjacent characters` `def` `convertString(S, k):` ` ` `# Size of the string` ` ` `n ` `=` `len` `(S)` ` ` `# Stores modified string after` ` ` `# each iteration` ` ` `temp ` `=` `S` ` ` `temp ` `=` `list` `(temp)` ` ` `# Iterate over the range [0 k]` ` ` `for` `i ` `in` `range` `(k):` ` ` `# Traverse the string S` ` ` `for` `j ` `in` `range` `(n` `-` `1` `):` ` ` `# If '0' is present at` ` ` `# 0th index then replace` ` ` `# it with 1st index` ` ` `if` `(j ` `=` `=` `0` `and` `S[j] ` `=` `=` `'0'` `):` ` ` `temp[j] ` `=` `S[j ` `+` `1` `]` ` ` `# If '0' is present at the` ` ` `# last index then replace` ` ` `# it with last index - 1` ` ` `# character` ` ` `elif` `(j ` `=` `=` `n ` `-` `1` `and` `S[j] ` `=` `=` `'0'` `):` ` ` `temp[j] ` `=` `S[j ` `-` `1` `]` ` ` `# Otherwise, convert 0s` ` ` `# to 1 if the adjacent` ` ` `# characters are different` ` ` `elif` `(S[j ` `-` `1` `] !` `=` `S[j ` `+` `1` `] ` `and` `S[j] ` `=` `=` `'0'` `):` ` ` `temp[j] ` `=` `'1'` ` ` `# If during this iteration` ` ` `# there is no change in the` ` ` `# string then break this loop` ` ` `if` `(S ` `=` `=` `temp):` ` ` `break` ` ` `temp ` `=` `''.join(temp)` ` ` `# Update the string S` ` ` `S ` `=` `temp` ` ` ` ` `# Print the updated string` ` ` `print` `(S)` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `S ` `=` `"10010001"` ` ` `K ` `=` `1` ` ` `convertString(S, K)` ` ` ` ` `# This code s contributed by ipg2016107.` |

**Time Complexity:** O(N*K)**Auxiliary Space:** O(N)

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**.