Minimum number of adjacent swaps to convert a string into its given anagram
Last Updated :
22 Jun, 2022
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++
#include <bits/stdc++.h>
using namespace std;
bool isAnagram(string s1, string s2)
{
sort(s1.begin(), s1.end());
sort(s2.begin(), s2.end());
if (s1 == s2)
return 1;
return 0;
}
int CountSteps(string s1, string s2, int size)
{
int i = 0, j = 0;
int result = 0;
while (i < size) {
j = i;
while (s1[j] != s2[i]) {
j += 1;
}
while (i < j) {
char temp = s1[j];
s1[j] = s1[j - 1];
s1[j - 1] = temp;
j -= 1;
result += 1;
}
i += 1;
}
return result;
}
int main()
{
string s1 = "abcd" ;
string s2 = "cdab" ;
int size = s2.size();
if (isAnagram(s1, s2))
cout << CountSteps(s1, s2, size);
else
cout << -1;
return 0;
}
|
Java
import java.util.*;
class GFG
{
static boolean isAnagram(String s1, String s2)
{
s1 = sortString(s1);
s2 = sortString(s2);
return (s1.equals(s2));
}
public static String sortString(String inputString)
{
char tempArray[] = inputString.toCharArray();
Arrays.sort(tempArray);
return new String(tempArray);
}
static int CountSteps( char []s1, char [] s2, int size)
{
int i = 0 , j = 0 ;
int result = 0 ;
while (i < size)
{
j = i;
while (s1[j] != s2[i])
{
j += 1 ;
}
while (i < j)
{
char temp = s1[j];
s1[j] = s1[j - 1 ];
s1[j - 1 ] = temp;
j -= 1 ;
result += 1 ;
}
i += 1 ;
}
return result;
}
public static void main(String[] args)
{
String s1 = "abcd" ;
String s2 = "cdab" ;
int size = s2.length();
if (isAnagram(s1, s2))
System.out.println(CountSteps(s1.toCharArray(), s2.toCharArray(), size));
else
System.out.println(- 1 );
}
}
|
Python3
def isAnagram(s1, s2) :
s1 = list (s1);
s2 = list (s2);
s1 = s1.sort();
s2 = s2.sort();
if (s1 = = s2) :
return 1 ;
return 0 ;
def CountSteps(s1, s2, size) :
s1 = list (s1);
s2 = list (s2);
i = 0 ;
j = 0 ;
result = 0 ;
while (i < size) :
j = i;
while (s1[j] ! = s2[i]) :
j + = 1 ;
while (i < j) :
temp = s1[j];
s1[j] = s1[j - 1 ];
s1[j - 1 ] = temp;
j - = 1 ;
result + = 1 ;
i + = 1 ;
return result;
if __name__ = = "__main__" :
s1 = "abcd" ;
s2 = "cdab" ;
size = len (s2);
if (isAnagram(s1, s2)) :
print (CountSteps(s1, s2, size));
else :
print ( - 1 );
|
C#
using System;
using System.Linq;
class GFG
{
static Boolean isAnagram(String s1, String s2)
{
s1 = sortString(s1);
s2 = sortString(s2);
return (s1.Equals(s2));
}
public static String sortString(String inputString)
{
char []tempArray = inputString.ToCharArray();
Array.Sort(tempArray);
return new String(tempArray);
}
static int CountSteps( char []s1, char [] s2, int size)
{
int i = 0, j = 0;
int result = 0;
while (i < size)
{
j = i;
while (s1[j] != s2[i])
{
j += 1;
}
while (i < j)
{
char temp = s1[j];
s1[j] = s1[j - 1];
s1[j - 1] = temp;
j -= 1;
result += 1;
}
i += 1;
}
return result;
}
public static void Main(String[] args)
{
String s1 = "abcd" ;
String s2 = "cdab" ;
int size = s2.Length;
if (isAnagram(s1, s2))
Console.WriteLine(CountSteps(s1.ToCharArray(), s2.ToCharArray(), size));
else
Console.WriteLine(-1);
}
}
|
Javascript
<script>
function isAnagram(s1, s2)
{
s1 = sortString(s1);
s2 = sortString(s2);
return (s1 == s2);
}
function sortString(inputString)
{
let tempArray = inputString.split( '' );
tempArray.sort();
return tempArray.join( "" );
}
function CountSteps(s1, s2, size)
{
let i = 0, j = 0;
let result = 0;
while (i < size)
{
j = i;
while (s1[j] != s2[i])
{
j += 1;
}
while (i < j)
{
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 (isAnagram(s1, s2))
document.write(CountSteps(s1.split( '' ), s2.split( '' ), size) + "</br>" );
else
document.write(-1 + "</br>" );
</script>
|
Time Complexity: O(N*N), as we are using nested loops for traversing N*N times. Where N is the length of the string.
Auxiliary Space: O(1), as we are not using any extra space.
Share your thoughts in the comments
Please Login to comment...