# 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)

My Personal Notes arrow_drop_up
Recommended Articles
Page :