Skip to content
Related Articles

Related Articles

Improve Article
Minimum number of adjacent swaps to convert a string into its given anagram
  • Difficulty Level : Medium
  • Last Updated : 08 Jun, 2021

Given two strings s1 and s2, the task is to find the minimum number of steps required to convert s1 into s2. The only operation allowed is to swap adjacent elements in the first string. Every swap is counted as a single step.
Examples: 
 

Input: s1 = “abcd”, s2 = “cdab” 
Output:
Swap 2nd and 3rd element, abcd => acbd 
Swap 1st and 2nd element, acbd => cabd 
Swap 3rd and 4th element, cabd => cadb 
Swap 2nd and 3rd element, cadb => cdab 
Minimum 4 swaps are required.
Input: s1 = “abcfdegji”, s2 = “fjiacbdge” 
Output:17 
 

 

Approach: Use two pointers i and j for first and second strings respectively. Initialise i and j to 0
Iterate over the first string and find the position j such that s1[j] = s2[i] by incrementing the value to j. Keep on swapping the adjacent elements j and j – 1 and decrement j until it is greater than i
Now the ith element of the first string is equal to the second string, hence increment the value of i
This technique will give the minimum number of steps as there are zero unnecessary swaps.
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function that returns true if s1
// and s2 are anagrams of each other
bool isAnagram(string s1, string s2)
{
    sort(s1.begin(), s1.end());
    sort(s2.begin(), s2.end());
    if (s1 == s2)
        return 1;
    return 0;
}
 
// Function to return the minimum swaps required
int CountSteps(string s1, string s2, int size)
{
    int i = 0, j = 0;
    int result = 0;
 
    // Iterate over the first string and convert
    // every element equal to the second string
    while (i < size) {
        j = i;
 
        // Find index element of first string which
        // is equal to the ith element of second string
        while (s1[j] != s2[i]) {
            j += 1;
        }
 
        // Swap adjacent elements in first string so
        // that element at ith position becomes equal
        while (i < j) {
 
            // Swap elements using temporary variable
            char temp = s1[j];
            s1[j] = s1[j - 1];
            s1[j - 1] = temp;
            j -= 1;
            result += 1;
        }
        i += 1;
    }
    return result;
}
 
// Driver code
int main()
{
    string s1 = "abcd";
    string s2 = "cdab";
 
    int size = s2.size();
 
    // If both the strings are anagrams
    // of each other then only they
    // can be made equal
    if (isAnagram(s1, s2))
        cout << CountSteps(s1, s2, size);
    else
        cout << -1;
 
    return 0;
}

Java




// Java implementation of the above approach
import java.util.*;
 
class GFG
{
 
// Function that returns true if s1
// and s2 are anagrams of each other
static boolean isAnagram(String s1, String s2)
{
    s1 = sortString(s1);
    s2 = sortString(s2);
    return (s1.equals(s2));
}
 
// Method to sort a string alphabetically
public static String sortString(String inputString)
{
    // convert input string to char array
    char tempArray[] = inputString.toCharArray();
     
    // sort tempArray
    Arrays.sort(tempArray);
     
    // return new sorted string
    return new String(tempArray);
}
 
// Function to return the minimum swaps required
static int CountSteps(char []s1, char[] s2, int size)
{
    int i = 0, j = 0;
    int result = 0;
 
    // Iterate over the first string and convert
    // every element equal to the second string
    while (i < size)
    {
        j = i;
 
        // Find index element of first string which
        // is equal to the ith element of second string
        while (s1[j] != s2[i])
        {
            j += 1;
        }
 
        // Swap adjacent elements in first string so
        // that element at ith position becomes equal
        while (i < j)
        {
 
            // Swap elements using temporary variable
            char temp = s1[j];
            s1[j] = s1[j - 1];
            s1[j - 1] = temp;
            j -= 1;
            result += 1;
        }
        i += 1;
    }
    return result;
}
 
// Driver code
public static void main(String[] args)
{
    String s1 = "abcd";
    String s2 = "cdab";
 
    int size = s2.length();
 
    // If both the strings are anagrams
    // of each other then only they
    // can be made equal
    if (isAnagram(s1, s2))
        System.out.println(CountSteps(s1.toCharArray(), s2.toCharArray(), size));
    else
        System.out.println(-1);
}
}
 
// This code is contributed by Rajput-Ji

Python3




# Python3 implementation of the above approach
 
# Function that returns true if s1
# and s2 are anagrams of each other
def isAnagram(s1, s2) :
    s1 = list(s1);
    s2 = list(s2);
    s1 = s1.sort();
    s2 = s2.sort();
     
    if (s1 == s2) :
        return 1;
         
    return 0;
 
# Function to return the minimum swaps required
def CountSteps(s1, s2, size) :
    s1 = list(s1);
    s2 = list(s2);
     
    i = 0;
    j = 0;
    result = 0;
     
    # Iterate over the first string and convert
    # every element equal to the second string
    while (i < size) :
        j = i;
         
        # Find index element of first string which
        # is equal to the ith element of second string
        while (s1[j] != s2[i]) :
            j += 1;
             
        # Swap adjacent elements in first string so
        # that element at ith position becomes equal
        while (i < j) :
             
            # Swap elements using temporary variable
            temp = s1[j];
            s1[j] = s1[j - 1];
            s1[j - 1] = temp;
            j -= 1;
            result += 1;
             
        i += 1;
         
    return result;
 
# Driver code
if __name__ == "__main__":
 
    s1 = "abcd";
    s2 = "cdab";
 
    size = len(s2);
 
    # If both the strings are anagrams
    # of each other then only they
    # can be made equal
    if (isAnagram(s1, s2)) :
        print(CountSteps(s1, s2, size));
    else :
        print(-1);
 
# This code is contributed by AnkitRai01

C#




// C# implementation of the above approach
using System;
using System.Linq;
 
class GFG
{
 
// Function that returns true if s1
// and s2 are anagrams of each other
static Boolean isAnagram(String s1, String s2)
{
    s1 = sortString(s1);
    s2 = sortString(s2);
    return (s1.Equals(s2));
}
 
// Method to sort a string alphabetically
public static String sortString(String inputString)
{
    // convert input string to char array
    char []tempArray = inputString.ToCharArray();
     
    // sort tempArray
    Array.Sort(tempArray);
     
    // return new sorted string
    return new String(tempArray);
}
 
// Function to return the minimum swaps required
static int CountSteps(char []s1, char[] s2, int size)
{
    int i = 0, j = 0;
    int result = 0;
 
    // Iterate over the first string and convert
    // every element equal to the second string
    while (i < size)
    {
        j = i;
 
        // Find index element of first string which
        // is equal to the ith element of second string
        while (s1[j] != s2[i])
        {
            j += 1;
        }
 
        // Swap adjacent elements in first string so
        // that element at ith position becomes equal
        while (i < j)
        {
 
            // Swap elements using temporary variable
            char temp = s1[j];
            s1[j] = s1[j - 1];
            s1[j - 1] = temp;
            j -= 1;
            result += 1;
        }
        i += 1;
    }
    return result;
}
 
// Driver code
public static void Main(String[] args)
{
    String s1 = "abcd";
    String s2 = "cdab";
 
    int size = s2.Length;
 
    // If both the strings are anagrams
    // of each other then only they
    // can be made equal
    if (isAnagram(s1, s2))
        Console.WriteLine(CountSteps(s1.ToCharArray(), s2.ToCharArray(), size));
    else
        Console.WriteLine(-1);
}
}
 
/* This code is contributed by PrinciRaj1992 */

Javascript




<script>
    // Javascript implementation of the above approach
     
    // Function that returns true if s1
    // and s2 are anagrams of each other
    function isAnagram(s1, s2)
    {
        s1 = sortString(s1);
        s2 = sortString(s2);
        return (s1 == s2);
    }
 
    // Method to sort a string alphabetically
    function sortString(inputString)
    {
        // convert input string to char array
        let tempArray = inputString.split('');
 
        // sort tempArray
        tempArray.sort();
 
        // return new sorted string
        return tempArray.join("");
    }
 
    // Function to return the minimum swaps required
    function CountSteps(s1, s2, size)
    {
        let i = 0, j = 0;
        let result = 0;
 
        // Iterate over the first string and convert
        // every element equal to the second string
        while (i < size)
        {
            j = i;
 
            // Find index element of first string which
            // is equal to the ith element of second string
            while (s1[j] != s2[i])
            {
                j += 1;
            }
 
            // Swap adjacent elements in first string so
            // that element at ith position becomes equal
            while (i < j)
            {
 
                // Swap elements using temporary variable
                let temp = s1[j];
                s1[j] = s1[j - 1];
                s1[j - 1] = temp;
                j -= 1;
                result += 1;
            }
            i += 1;
        }
        return result;
    }
     
    let s1 = "abcd";
    let s2 = "cdab";
   
    let size = s2.length;
   
    // If both the strings are anagrams
    // of each other then only they
    // can be made equal
    if (isAnagram(s1, s2))
        document.write(CountSteps(s1.split(''), s2.split(''), size) + "</br>");
    else
        document.write(-1 + "</br>");
     
</script>
Output: 
4

 

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 industry experts, please refer DSA Live Classes 




My Personal Notes arrow_drop_up
Recommended Articles
Page :