Given two binary strings **A** and **B**, the task is to find the minimum number of times a substring starting from the first character of A needs to be flipped, i.e. convert **1**s to** 0**s and **0**s to **1**s, to convert **A** to **B**.

**Examples:**

Input:A = “0010”, B = “1011”Output;3Explanation:

Step 1: Flip the entire string A. Therefore, A becomes “1101” .

Step 2: Flip the substring {A[0], A[2]}. Therefore, A becomes “0011” .

Step 3: Flip A[0]. Therefore, A becomes “1011” which is equal to B.

Therefore, the minimum number of operations required is 3.

Input:A = “1010101”, B = “0011100”Output:5Explanation:

Step 1: Flip the entiThehrefore, A becomes “0101010″

Step 2: Flip substring {A[0], A[5]}. Therefore, A becomes “1010100″

Step 3: Flip the substring {A[0], A[3]}. Therefore, A becomes “0101100″

Step 4: Flip the substring {A[0], A[2]}. Therefore, A becomes “1011100″

Step 5: Flip A[0]. Therefore, A becomes “0011100” which is equal to B.

Therefore, the minimum number of operations required is 5.

**Approach:** The idea is to initialize a** variable** that holds the last index at which **character at A** is different from the **character at B**. Then negate **A** from the 1st index to the last index. Repeat until both strings become equal. Follow the steps below to solve the problem:

- Initialize a variable
**last_index**that holds the last index at which characters are different in**A**and**B**. - Negate string
**A**from the**1st index**to**last_index**and increment the count of steps. - Repeat the above steps until string
**A**becomes equal to string**B**. - Print the count of steps after both the strings are the same after performing the operations.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function that finds the minimum` `// number of operations required such` `// that string A and B are the same` `void` `findMinimumOperations(string a,` ` ` `string b)` `{` ` ` `// Stores the count of steps` ` ` `int` `step = 0;` ` ` `// Stores the last index whose` ` ` `// bits are not same` ` ` `int` `last_index;` ` ` `// Iterate until both string` ` ` `// are unequal` ` ` `while` `(a != b) {` ` ` `// Check till end of string to` ` ` `// find righmost unequals bit` ` ` `for` `(` `int` `i = 0;` ` ` `i < a.length(); i++) {` ` ` `// Update the last index` ` ` `if` `(a[i] != b[i]) {` ` ` `last_index = i;` ` ` `}` ` ` `}` ` ` `// Flipping characters up` ` ` `// to the last index` ` ` `for` `(` `int` `i = 0;` ` ` `i <= last_index; i++) {` ` ` `// Flip the bit` ` ` `a[i] = (a[i] == ` `'0'` `) ? ` `'1'` `: ` `'0'` `;` ` ` `}` ` ` `// Increasing steps by one` ` ` `step++;` ` ` `}` ` ` `// Print the count of steps` ` ` `cout << step;` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given strings A and B` ` ` `string A = ` `"101010"` `, B = ` `"110011"` `;` ` ` `// Function Call` ` ` `findMinimumOperations(A, B);` ` ` `return` `0;` `}` |

## Java

`// Java program for the` `// above approach` `import` `java.util.*;` `class` `GFG{` `// Function that finds the minimum` `// number of operations required such` `// that String A and B are the same` `static` `void` `findMinimumOperations(` `char` `[] a,` ` ` `char` `[] b)` `{` ` ` `// Stores the count of steps` ` ` `int` `step = ` `0` `;` ` ` `// Stores the last index whose` ` ` `// bits are not same` ` ` `int` `last_index = ` `0` `;` ` ` `// Iterate until both String` ` ` `// are unequal` ` ` `while` `(!Arrays.equals(a, b))` ` ` `{` ` ` `// Check till end of String to` ` ` `// find righmost unequals bit` ` ` `for` `(` `int` `i = ` `0` `;` ` ` `i < a.length; i++)` ` ` `{` ` ` `// Update the last index` ` ` `if` `(a[i] != b[i])` ` ` `{` ` ` `last_index = i;` ` ` `}` ` ` `}` ` ` `// Flipping characters up` ` ` `// to the last index` ` ` `for` `(` `int` `i = ` `0` `;` ` ` `i <= last_index; i++)` ` ` `{` ` ` `// Flip the bit` ` ` `a[i] = (a[i] == ` `'0'` `) ?` ` ` `'1'` `: ` `'0'` `;` ` ` `}` ` ` `// Increasing steps by one` ` ` `step++;` ` ` `}` ` ` `// Print the count of steps` ` ` `System.out.print(step);` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `// Given Strings A and B` ` ` `String A = ` `"101010"` `,` ` ` `B = ` `"110011"` `;` ` ` `// Function Call` ` ` `findMinimumOperations(A.toCharArray(),` ` ` `B.toCharArray());` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python3 program for the above approach` `# Function that finds the minimum` `# number of operations required such` `# that string A and B are the same` `def` `findMinimumOperations(a, b):` ` ` ` ` `# Stores the count of steps` ` ` `step ` `=` `0` ` ` `# Stores the last index whose` ` ` `# bits are not same` ` ` `last_index ` `=` `0` ` ` `# Iterate until both string` ` ` `# are unequal` ` ` `while` `(a !` `=` `b):` ` ` `a ` `=` `[i ` `for` `i ` `in` `a]` ` ` ` ` `# Check till end of string to` ` ` `# find righmost unequals bit` ` ` `for` `i ` `in` `range` `(` `len` `(a)):` ` ` ` ` `# Update the last index` ` ` `if` `(a[i] !` `=` `b[i]):` ` ` `last_index ` `=` `i` ` ` `# Flipping characters up` ` ` `# to the last index` ` ` `for` `i ` `in` `range` `(last_index ` `+` `1` `):` ` ` ` ` `# Flip the bit` ` ` `if` `(a[i] ` `=` `=` `'0'` `):` ` ` `a[i] ` `=` `'1'` ` ` `else` `:` ` ` `a[i] ` `=` `'0'` ` ` ` ` `a ` `=` `"".join(a) ` ` ` `# Increasing steps by one` ` ` `step ` `+` `=` `1` ` ` `# Print the count of steps` ` ` `print` `(step)` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `# Given strings A and B` ` ` `A ` `=` `"101010"` ` ` `B ` `=` `"110011"` ` ` `# Function Call` ` ` `findMinimumOperations(A, B)` `# This code is contributed by mohit kumar 29` |

## C#

`// C# program for the` `// above approach` `using` `System;` `class` `GFG{` `// Function that finds the minimum` `// number of operations required such` `// that string A and B are the same` `static` `void` `findMinimumOperations(` `string` `a,` ` ` `string` `b)` `{` ` ` ` ` `// Stores the count of steps` ` ` `int` `step = 0;` ` ` `// Stores the last index whose` ` ` `// bits are not same` ` ` `int` `last_index = 0;` ` ` `// Iterate until both string` ` ` `// are unequal` ` ` `while` `(a.Equals(b) == ` `false` `)` ` ` `{` ` ` ` ` `// Check till end of string to` ` ` `// find righmost unequals bit` ` ` `for` `(` `int` `i = 0; i < a.Length; i++)` ` ` `{` ` ` ` ` `// Update the last index` ` ` `if` `(a[i] != b[i])` ` ` `{` ` ` `last_index = i;` ` ` `}` ` ` `}` ` ` `// Flipping characters up` ` ` `// to the last index` ` ` `char` `[] ch = a.ToCharArray();` ` ` `for` `(` `int` `i = 0;` ` ` `i <= last_index; i++)` ` ` `{` ` ` ` ` `// Flip the bit` ` ` `if` `(ch[i] == ` `'0'` `)` ` ` `{` ` ` `ch[i] = ` `'1'` `;` ` ` `}` ` ` `else` ` ` `{` ` ` `ch[i] = ` `'0'` `;` ` ` `}` ` ` `}` ` ` `a = ` `new` `string` `(ch);` ` ` ` ` `// Increasing steps by one` ` ` `step++;` ` ` `}` ` ` `// Print the count of steps` ` ` `Console.WriteLine(step);` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` ` ` `// Given strings A and B` ` ` `string` `A = ` `"101010"` `;` ` ` `string` `B = ` `"110011"` `;` ` ` `// Function Call` ` ` `findMinimumOperations(A,B);` `}` `}` `// This code is contributed by SURENDRA_GANGWAR` |

**Output:**

4

**Time Complexity:** O(N^{2})**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.