# Minimum flips or swapping of adjacent characters required to make a string equal to another

• Last Updated : 18 Jun, 2021

Given two binary strings A and B of length N, the task is to convert the string A to B by either flipping any character of A or swapping adjacent characters of A minimum number of times. If it is not possible to make both the strings equal, print -1.

Examples:

Input: A = “10010010”, B = “00001000”
Output: 3
Explanation:
Operation 1: Flipping A modifies A to “00010010”.
Operation 2: Flipping A modifies A to “00010000”.
Operation 3: Swapping A and A modifies A to “00001000”
Therefore, the total number of operations is 3.

Input: A = “11”, B = “00”
Output: 3

Approach: The idea is to traverse the string A and try to make the same-indexed characters equal by first checking for the condition of swapping the adjacent characters. If the characters can not be made equal by this operation, then flip the character. Follow the steps below to solve the problem:

• Initialize a variable, say ans, to store the required result.
• Traverse the string A using a variable, say i, and perform the following operations:
• Print the value of ans as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find minimum operations``// required to convert string A to B``int` `minimumOperation(string a, string b)``{` `    ``// Store the size of the string``    ``int` `n = a.length();``    ``int` `i = 0;` `    ``// Store the required result``    ``int` `minoperation = 0;` `    ``// Traverse the string, a``    ``while` `(i < n) {` `        ``// If a[i] is equal to b[i]``        ``if` `(a[i] == b[i]) {``            ``i = i + 1;``            ``continue``;``        ``}` `        ``// Check if swapping adjacent``        ``// characters make the same-indexed``        ``// characters equal or not``        ``else` `if` `(a[i] == b[i + 1]``                 ``&& a[i + 1] == b[i]``                 ``&& i < n - 1) {` `            ``minoperation++;``            ``i = i + 2;``        ``}` `        ``// Otherwise, flip the current bit``        ``else` `if` `(a[i] != b[i]) {``            ``minoperation++;``            ``i = i + 1;``        ``}``        ``else` `{``            ``++i;``        ``}``    ``}` `    ``// Print the minimum number of operations``    ``cout << minoperation;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``string a = ``"10010010"``, b = ``"00001000"``;` `    ``// Function Call``    ``minimumOperation(a, b);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``public` `class` `GFG``{``    ` `// Function to find minimum operations``// required to convert string A to B``static` `void` `minimumOperation(String a, String b)``{``    ` `    ``// Store the size of the string``    ``int` `n = a.length();``    ``int` `i = ``0``;` `    ``// Store the required result``    ``int` `minoperation = ``0``;` `    ``// Traverse the string, a``    ``while` `(i < n)``    ``{``        ` `        ``// If a[i] is equal to b[i]``        ``if` `(a.charAt(i) == b.charAt(i))``        ``{``            ``i = i + ``1``;``            ``continue``;``        ``}` `        ``// Check if swapping adjacent``        ``// characters make the same-indexed``        ``// characters equal or not``        ``else` `if` `(a.charAt(i) == b.charAt(i + ``1``) && ``                 ``a.charAt(i + ``1``) == b.charAt(i) &&``                   ``i < n - ``1``)``        ``{``            ``minoperation++;``            ``i = i + ``2``;``        ``}` `        ``// Otherwise, flip the current bit``        ``else` `if` `(a.charAt(i) != b.charAt(i))``        ``{``            ``minoperation++;``            ``i = i + ``1``;``        ``}``        ``else``        ``{``            ``++i;``        ``}``    ``}` `    ``// Print the minimum number of operations``    ``System.out.println(minoperation);``}` `// Driver Code``public` `static` `void` `main(String []args)``{``    ` `    ``// Given Input``    ``String a = ``"10010010"``, b = ``"00001000"``;` `    ``// Function Call``    ``minimumOperation(a, b);``}``}` `// This code is contributed by AnkThon`

## Python3

 `# Python3 program for the above approach` `# Function to find minimum operations``# required to convert A to B``def` `minimumOperation(a, b):` `    ``# Store the size of the string``    ``n ``=` `len``(a)``    ``i ``=` `0` `    ``# Store the required result``    ``minoperation ``=` `0` `    ``# Traverse the string, a``    ``while` `(i < n):` `        ``# If a[i] is equal to b[i]``        ``if` `(a[i] ``=``=` `b[i]):``            ``i ``=` `i ``+` `1``            ``continue` `        ``# Check if swapping adjacent``        ``# characters make the same-indexed``        ``# characters equal or not``        ``elif` `(a[i] ``=``=` `b[i ``+` `1``] ``and``              ``a[i ``+` `1``] ``=``=` `b[i] ``and` `i < n ``-` `1``):``            ``minoperation ``+``=` `1``            ``i ``=` `i ``+` `2` `        ``# Otherwise, flip the current bit``        ``elif` `(a[i] !``=` `b[i]):``            ``minoperation ``+``=` `1``            ``i ``=` `i ``+` `1``        ``else``:``            ``i``+``=``1` `    ``# Print the minimum number of operations``    ``print` `(minoperation)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given Input``    ``a ``=` `"10010010"``    ``b ``=` `"00001000"` `    ``# Function Call``    ``minimumOperation(a, b)``    ` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `// Function to find minimum operations``// required to convert string A to B``static` `void` `minimumOperation(``string` `a, ``string` `b)``{``    ` `    ``// Store the size of the string``    ``int` `n = a.Length;``    ``int` `i = 0;` `    ``// Store the required result``    ``int` `minoperation = 0;` `    ``// Traverse the string, a``    ``while` `(i < n)``    ``{``        ` `        ``// If a[i] is equal to b[i]``        ``if` `(a[i] == b[i])``        ``{``            ``i = i + 1;``            ``continue``;``        ``}` `        ``// Check if swapping adjacent``        ``// characters make the same-indexed``        ``// characters equal or not``        ``else` `if` `(a[i] == b[i + 1] && ``                 ``a[i + 1] == b[i] &&``                   ``i < n - 1)``        ``{``            ``minoperation++;``            ``i = i + 2;``        ``}` `        ``// Otherwise, flip the current bit``        ``else` `if` `(a[i] != b[i])``        ``{``            ``minoperation++;``            ``i = i + 1;``        ``}``        ``else``        ``{``            ``++i;``        ``}``    ``}` `    ``// Print the minimum number of operations``    ``Console.WriteLine(minoperation);``}` `// Driver Code``public` `static` `void` `Main()``{``    ` `    ``// Given Input``    ``string` `a = ``"10010010"``, b = ``"00001000"``;` `    ``// Function Call``    ``minimumOperation(a, b);``}``}` `// This code is contributed by ankThon`

## Javascript

 ``

Output:

`3`

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

My Personal Notes arrow_drop_up