Related Articles

# Minimum swaps required between two strings to make one string strictly greater than the other

• Last Updated : 24 May, 2021

Given two strings A and B of length M and N respectively, the task is to find the minimum swapping of two characters required to make string A lexicographically greater than the string B.

Examples:

Input: A = “1432”, B = “789”, M = 4, N = 3
Output: 1
Explanation:
One possible way is to swap characters at index 0 of both the strings. Therefore, A modifies to “7432” and B modifies to “189”.

Input: A = “3733”, B = “3333”, M = 4, N = 4
Output: 2
Explanation:
Step 1:Swap character at index 1 of string A with character at index 0 of string B. The strings A and B are modified to “3333” and “7333”.
Step 2: Swap the character at index 0 of string A with a character at index 0 of string B. The strings A and B are modified to “7333” and “3333”.

Approach: It can be observed that if M ≤ N and all the characters are the same, including both strings, then it is not possible to make string A strictly greater than string B. Otherwise, string A can be made strictly greater than string B by placing the two different characters at the 0th index of both strings in a maximum of two moves.

Follow the steps below to solve the problem:

1. First, check if the first character of string A is greater than the first character of string B then print 0.
2. Otherwise, check if B > A then 1 swap is needed, so swap A with B and print 1.
3. Otherwise, check if all the characters are the same in both strings and M ≤ N then it is not possible, so print -1.
4. Otherwise, check if there lies any character in A which is smaller than A or a character in B which is greater than B then print 1.
5. Otherwise, check if there exists any character in A which is less than A or any character in B which is greater than B then print 2.
6. Otherwise, return 0 if none of the above conditions satisfies.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum``// number of steps to make A > B``int` `minSteps(string A, string B, ``int` `M, ``int` `N)``{` `    ``if` `(A > B)``        ``return` `0;` `    ``if` `(B > A) {``        ``return` `1;``    ``}` `    ``// If all character are same and M <= N``    ``if` `(M <= N && A == B``        ``&& count(A.begin(), A.end(), A) == M``        ``&& count(B.begin(), B.end(), B) == N)``        ``return` `-1;` `    ``// If there lies any character``    ``// in B which is greater than B``    ``for` `(``int` `i = 1; i < N; i++) {` `        ``if` `(B[i] > B)``            ``return` `1;``    ``}` `    ``// If there lies any character``    ``// in A which is smaller than A``    ``for` `(``int` `i = 1; i < M; i++) {` `        ``if` `(A[i] < A)``            ``return` `1;``    ``}` `    ``// If there lies a character which``    ``// is in A and greater than A``    ``for` `(``int` `i = 1; i < M; i++) {` `        ``if` `(A[i] > A) {` `            ``swap(A[i], B);``            ``swap(A, B);``            ``return` `2;``        ``}``    ``}` `    ``// If there lies a character which``    ``// is in B and less than B``    ``for` `(``int` `i = 1; i < N; i++) {` `        ``if` `(B[i] < B) {` `            ``swap(A, B[i]);``            ``swap(A, B);``            ``return` `2;``        ``}``    ``}` `    ``// Otherwise``    ``return` `0;``}` `// Driver Code``int` `main()``{``    ``string A = ``"adsfd"``;``    ``string B = ``"dffff"``;` `    ``int` `M = A.length();``    ``int` `N = B.length();` `    ``cout << minSteps(A, B, M, N);` `    ``return` `0;``}`

## Java

 `// Java program for above approach``import` `java.util.*;``import` `java.lang.*;``class` `GFG``{` `  ``// Function to find the minimum``  ``// number of steps to make A > B``  ``static` `int` `minSteps(StringBuilder A,``                      ``StringBuilder B,``                      ``int` `M, ``int` `N)``  ``{` `    ``if` `(A.charAt(``0``) > B.charAt(``0``))``      ``return` `0``;` `    ``if` `(B.charAt(``0``) > A.charAt(``0``))``    ``{``      ``return` `1``;``    ``}` `    ``// If all character are same and M <= N``    ``if` `(M <= N && A.charAt(``0``) == B.charAt(``0``)``        ``&& count(A, A.charAt(``0``)) == M``        ``&& count(B, B.charAt(``0``)) == N)``      ``return` `-``1``;` `    ``// If there lies any character``    ``// in B which is greater than B``    ``for` `(``int` `i = ``1``; i < N; i++)``    ``{` `      ``if` `(B.charAt(i) > B.charAt(``0``))``        ``return` `1``;``    ``}` `    ``// If there lies any character``    ``// in A which is smaller than A``    ``for` `(``int` `i = ``1``; i < M; i++)``    ``{` `      ``if` `(A.charAt(i) < A.charAt(``0``))``        ``return` `1``;``    ``}` `    ``// If there lies a character which``    ``// is in A and greater than A``    ``for` `(``int` `i = ``1``; i < M; i++)``    ``{``      ``if` `(A.charAt(i) > A.charAt(``0``))``      ``{``        ``swap(A, i, B, ``0``);``        ``swap(A, ``0``, B, ``0``);``        ``return` `2``;``      ``}``    ``}` `    ``// If there lies a character which``    ``// is in B and less than B``    ``for` `(``int` `i = ``1``; i < N; i++)``    ``{``      ``if` `(B.charAt(i) < B.charAt(``0``))``      ``{``        ``swap(A, ``0``, B, i);``        ``swap(A, ``0``, B, ``0``);``        ``return` `2``;``      ``}``    ``}` `    ``// Otherwise``    ``return` `0``;``  ``}` `  ``static` `int` `count(StringBuilder a,``                   ``char` `c)``  ``{``    ``int` `count = ``0``;``    ``for``(``int` `i = ``0``; i < a.length(); i++)``      ``if``(a.charAt(i) == c)``        ``count++; ``    ``return` `count;  ``  ``}` `  ``static` `void` `swap(StringBuilder s1,``                   ``int` `index1,``                   ``StringBuilder s2,``                   ``int` `index2)``  ``{``    ``char` `c = s1.charAt(index1);``    ``s1.setCharAt(index1,s2.charAt(index2));``    ``s2.setCharAt(index2,c);` `  ``}``  ``// Driver function``  ``public` `static` `void` `main (String[] args)``  ``{``    ``StringBuilder A = ``new` `StringBuilder(``"adsfd"``);``    ``StringBuilder B = ``new` `StringBuilder(``"dffff"``);``    ``int` `M = A.length();``    ``int` `N = B.length();``    ``System.out.println(minSteps(A, B, M, N));``  ``}``}` `// This code is contributed by offbeat.`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum``# number of steps to make A > B``def` `minSteps(A, B, M, N):``    ` `    ``if` `(A[``0``] > B[``0``]):``        ``return` `0` `    ``if` `(B[``0``] > A[``0``]):``        ``return` `1` `    ``# If all character are same and M <= N``    ``if` `(M <``=` `N ``and` `A[``0``] ``=``=` `B[``0``] ``and``           ``A.count(A[``0``]) ``=``=` `M ``and``           ``B.count(B[``0``]) ``=``=` `N):``        ``return` `-``1` `    ``# If there lies any character``    ``# in B which is greater than B``    ``for` `i ``in` `range``(``1``, N):``        ``if` `(B[i] > B[``0``]):``            ``return` `1` `    ``# If there lies any character``    ``# in A which is smaller than A``    ``for` `i ``in` `range``(``1``, M):``        ``if` `(A[i] < A[``0``]):``            ``return` `1` `    ``# If there lies a character which``    ``# is in A and greater than A``    ``for` `i ``in` `range``(``1``, M):``        ``if` `(A[i] > A[``0``]):``            ``A[``0``], B[i] ``=` `B[i], A[``0``]``            ``A[``0``], B[``0``] ``=` `B[``0``], A[``0``]``            ``return` `2` `    ``# If there lies a character which``    ``# is in B and less than B``    ``for` `i ``in` `range``(``1``, N):``        ``if` `(B[i] < B[``0``]):``            ``A[``0``], B[i] ``=` `B[i], A[``0``]``            ``A[``0``], B[``0``] ``=` `B[``0``], A[``0``]``            ``return` `2` `    ``# Otherwise``    ``return` `0` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``A ``=` `"adsfd"``    ``B ``=` `"dffff"` `    ``M ``=` `len``(A)``    ``N ``=` `len``(B)` `    ``print``(minSteps(A, B, M, N))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for above approach``using` `System;``using` `System.Text;` `public` `class` `GFG``{` `  ``// Function to find the minimum``  ``// number of steps to make A > B``  ``static` `int` `minSteps(StringBuilder A, StringBuilder B,  ``int` `M, ``int` `N)``  ``{``    ``if` `(A > B)``      ``return` `0;` `    ``if` `(B > A)``    ``{``      ``return` `1;``    ``}` `    ``// If all character are same and M <= N``    ``if` `(M <= N && A == B``        ``&& count(A, A) == M``        ``&& count(B, B) == N)``      ``return` `-1;` `    ``// If there lies any character``    ``// in B which is greater than B``    ``for` `(``int` `i = 1; i < N; i++)``    ``{` `      ``if` `(B[i] > B)``        ``return` `1;``    ``}` `    ``// If there lies any character``    ``// in A which is smaller than A``    ``for` `(``int` `i = 1; i < M; i++)``    ``{` `      ``if` `(A[i] < A)``        ``return` `1;``    ``}` `    ``// If there lies a character which``    ``// is in A and greater than A``    ``for` `(``int` `i = 1; i < M; i++)``    ``{``      ``if` `(A[i] > A)``      ``{``        ``swap(A, i, B, 0);``        ``swap(A, 0, B, 0);``        ``return` `2;``      ``}``    ``}` `    ``// If there lies a character which``    ``// is in B and less than B``    ``for` `(``int` `i = 1; i < N; i++)``    ``{``      ``if` `(B[i] < B)``      ``{``        ``swap(A, 0, B, i);``        ``swap(A, 0, B, 0);``        ``return` `2;``      ``}``    ``}` `    ``// Otherwise``    ``return` `0;` `  ``}` `  ``static` `int` `count(StringBuilder a,``                   ``char` `c)``  ``{``    ``int` `count = 0;``    ``for``(``int` `i = 0; i < a.Length; i++)``      ``if``(a[i] == c)``        ``count++; ``    ``return` `count;  ``  ``}` `  ``static` `void` `swap(StringBuilder s1,``                   ``int` `index1,``                   ``StringBuilder s2,``                   ``int` `index2)``  ``{` `    ``char` `c = s1[index1];``    ``s1[index1] = s2[index2];``    ``s2[index2] = c;``  ``}` `  ``// Driver function``  ``static` `public` `void` `Main ()``  ``{``    ``StringBuilder A = ``new` `StringBuilder(``"adsfd"``);``    ``StringBuilder B = ``new` `StringBuilder(``"dffff"``);``    ``int` `M=A.Length;``    ``int` `N=B.Length;``    ``Console.WriteLine(minSteps(A, B, M, N));``  ``}``}` `// This code is contributed by avanitrachhadiya2155`

## Javascript

 ``
Output:
`1`

Time Complexity: O(N)
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.  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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up