Minimum number of adjacent swaps to convert a string into its given anagram
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: 4
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; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 */ |
chevron_right
filter_none
Output:
4
Recommended Posts:
- Convert string X to an anagram of string Y with minimum replacements
- Minimum swaps required to convert one binary string to another
- Minimum adjacent swaps to move maximum and minimum to corners
- Generate lexicographically smallest string of 0, 1 and 2 with adjacent swaps allowed
- Minimum number of given operations required to convert a string to another string
- Minimum swaps required to make a binary string alternating
- Remove minimum number of characters so that two strings become anagram
- Number of sub-strings which are anagram of any sub-string of another string
- Minimum number of swaps required to sort an array | Set 2
- Minimum Number of Manipulations required to make two Strings Anagram Without Deletion of Character
- Generate permutations with only adjacent swaps allowed
- Minimum replacements to make adjacent characters unequal in a ternary string | Set-2
- Minimum replacements to make adjacent characters unequal in a ternary string
- Minimum cost to convert string into palindrome
- Minimum steps to convert one binary string to other only using negation
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.
- Longest sub string of 0's in a binary string which is repeated K times
- Count of strings in the first array which are smaller than every string in the second array
- Count of non-overlapping sub-strings "101" and "010" in the given binary string
- Strings from an array which are not prefix of any other string
- Generate all possible strings such that char at index i is either str1[i] or str2[i]
- Distinct strings such that they contains given strings as sub-sequences
- Case-specific sorting of Strings in O(n) time and O(1) space
- Map every character of one string to another such that all occurrences are mapped to the same character
- Find the number of occurrences of a character upto preceding position
- Swap all occurrences of two characters to get lexicographically smallest string
