# Lexicographically smaller string by swapping at most one character pair

• Last Updated : 07 Jul, 2021

Given two strings A and B of all uppercase letters, the task is to find whether is it possible to make string A strictly lexicographically smaller than string B by swapping at most one pair of characters in A.
Examples:

Input: A = “AGAIN”, B = “ACTION”
Output: Yes
Explanation:
We can make string A strictly lexicographically smaller than string B by swapping G and A (AAGIN)
AAGIN is lexicographically smaller than ACTION
Input: A = “APPLE” B = “AAAAAPPPLLE”
Output: No

Approach:

1. Sort string A.
2. We can find the first position where A and sorted(A) doesn’t match.
3. We then find the letter that should be in that position and swap it with the letter in the sorted(A).
4. If there are multiple choices, it is better to take the one that occurs last, since it makes the resulting string smallest.
5. Now, compare string A and string B.

Below is the implementation of the above approach.

## C++

 `// C++ program check whether is``// it possible to make string A``// lexicographically smaller than string B` `#include ``using` `namespace` `std;` `// Swap function``void` `swap(``char``& x, ``char``& y)``{``    ``char` `temp = x;``    ``x = y;``    ``y = temp;``}` `// Function that finds whether is``// it possible to make string A``// lexicographically smaller than string B``bool` `IsLexicographicallySmaller(``    ``string A, string B)``{``    ``// Condition if string A``    ``// is already smaller than B``    ``if` `(A < B) {``        ``return` `true``;``    ``}``    ``string temp = A;` `    ``// Sorting temp string``    ``sort(temp.begin(), temp.end());` `    ``int` `index = -1;` `    ``for` `(``int` `i = 0; i < A.length(); i++) {``        ``// Condition for first changed``        ``// character of string A and temp``        ``if` `(A[i] != temp[i]) {``            ``index = i;``            ``break``;``        ``}``    ``}` `    ``// Condition if string A``    ``// is already  sorted``    ``if` `(index == -1) {``        ``return` `false``;``    ``}` `    ``int` `j;` `    ``// Finding first changed character``    ``// from  last of string A``    ``for` `(``int` `i = 0; i < A.length(); i++) {``        ``if` `(A[i] == temp[index])``            ``j = i;``    ``}` `    ``// Swap the two characters``    ``swap(A[index], A[j]);` `    ``// Condition if string A``    ``// is smaller   than B``    ``if` `(A < B) {``        ``return` `true``;``    ``}` `    ``else` `{``        ``return` `false``;``    ``}``}` `// Driver Code``int` `main()``{``    ``string A = ``"AGAIN"``;``    ``string B = ``"ACTION"``;` `    ``if` `(IsLexicographicallySmaller(A, B)) {``        ``cout << ``"Yes"``             ``<< ``"\n"``;``    ``}``    ``else` `{``        ``cout << ``"No"``             ``<< ``"\n"``;``    ``}` `    ``return` `0;``}`

## Java

 `// Java program check whether is``// it possible to make String A``// lexicographically smaller than String B``import` `java.util.*;` `class` `GFG{``    ` `    ` `    ``// Swap function``    ``static` `String swap(String str, ``int` `i, ``int` `j)``    ``{``        ``char``[] tempArr = str.toCharArray();``        ``char` `temp = tempArr[i];``        ``tempArr[i] = tempArr[j];``        ``tempArr[j] = temp;``        ``return` `String.valueOf(tempArr);``    ``}``    ` `    ``// Function that finds whether is``    ``// it possible to make String A``    ``// lexicographically smaller than String B``    ``static` `boolean` `IsLexicographicallySmaller(String A, String B)``    ``{``        ``// Condition if String A``        ``// is already smaller than B``        ``if` `(A.compareTo(B) < ``0``) {``            ``return` `true``;``        ``}``        ``String temp = A;``        ``char` `p[] = temp.toCharArray();` `        ``// Sorting temp String``        ``Arrays.sort(p);``        ``temp=String.valueOf(p);``        ``int` `index = -``1``;``    ` `        ``for` `(``int` `i = ``0``; i < A.length(); i++) {` `            ``// Condition for first changed``            ``// character of String A and temp``            ``if` `(A.charAt(i) != temp.charAt(i)) {``                ``index = i;``                ``break``;``            ``}``        ``}``    ` `        ``// Condition if String A``        ``// is already sorted``        ``if` `(index == -``1``) {``            ``return` `false``;``        ``}``    ` `        ``int` `j = ``0``;``    ` `        ``// Finding first changed character``        ``// from last of String A``        ``for` `(``int` `i = ``0``; i < A.length(); i++) {``            ``if` `(A.charAt(i) == temp.charAt(index))``                ``j = i;``        ``}``    ` `        ``// Swap the two characters``        ``A = swap(A, index, j);``    ` `        ``// Condition if String A``        ``// is smaller than B``        ``if` `(A.compareTo(B) < ``0``) {``            ``return` `true``;``        ``}``    ` `        ``else` `{``            ``return` `false``;``        ``}``    ``}``    ` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``String A = ``"AGAIN"``;``        ``String B = ``"ACTION"``;``    ` `        ``if` `(IsLexicographicallySmaller(A, B)) {``            ``System.out.println(``"Yes"``);``        ``}``        ``else` `{``            ``System.out.println(``"No"``);``        ``}``    ` `    ``}``}` `// This code is contributed by AbhiThakur`

## Python3

 `# Python3 program check``# it possible to make string``# A lexicographically smaller``# than string B` `# Function that finds whether is``# it possible to make string A``# lexicographically smaller than``# string B``def` `IsLexicographicallySmaller(A, B):` `    ``# Condition if string A``    ``# is already smaller``    ``# than B``    ``if``(A < B):``        ``return` `True``    ``temp ``=` `A` `    ``# Sorting temp string``    ``temp ``=` `''.join(``sorted``(temp))``    ``index ``=``-` `1` `    ``for` `i ``in` `range``(``len``(A)):` `        ``# Condition for first``        ``# changed character of``        ``# string A and temp``        ``if``(A[i] !``=` `temp[i]):``            ``index ``=` `i``            ``break` `    ``# Condition if string A``    ``# is already  sorted``    ``if``(index ``=``=` `-``1``):``        ``return` `False``      ` `    ``j ``=` `0` `    ``# Finding first changed``    ``# character from last``    ``# of string A``    ``for` `i ``in` `range``(``len``(A)):``        ``if``(A[i] ``=``=` `temp[index]):``            ``j ``=` `i``            ` `    ``A ``=` `list``(A)` `    ``# Swap the two characters``    ``A[index], A[j] ``=` `A[j], A[index]``    ``A ``=` `''.join(A)` `    ``# Condition if string A``    ``# is smaller than B``    ``if``(A < B):``        ``return` `True``    ``else``:``        ``return` `False` `# Driver Code``A ``=` `"AGAIN"``B ``=` `"ACTION"` `if``(IsLexicographicallySmaller(A, B)):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program check whether is``// it possible to make String A``// lexicographically smaller``// than String B``using` `System;``class` `GFG{``     ` `// Swap function``static` `string` `swap(``string` `str,``                   ``int` `i, ``int` `j)``{``  ``char``[] tempArr = str.ToCharArray();``  ``char` `temp = tempArr[i];``  ``tempArr[i] = tempArr[j];``  ``tempArr[j] = temp;``  ``return` `new` `string``(tempArr);``}``     ` `// Function that finds whether is``// it possible to make String A``// lexicographically smaller than String B``static` `bool` `IsLexicographicallySmaller(``string` `A,``                                       ``string` `B)``{``  ``// Condition if String A``  ``// is already smaller than B``  ``if` `(A.CompareTo(B) < 0)``  ``{``    ``return` `true``;``  ``}``  ``string` `temp = A;``  ``char` `[]p = temp.ToCharArray();` `  ``// Sorting temp String``  ``Array.Sort(p);``  ``temp=``new` `string``(p);``  ``int` `index = -1;` `  ``for` `(``int` `i = 0; i < A.Length; i++)``  ``{``    ``// Condition for first changed``    ``// character of String A and temp``    ``if` `(A[i] != temp[i])``    ``{``      ``index = i;``      ``break``;``    ``}``  ``}` `  ``// Condition if String A``  ``// is already sorted``  ``if` `(index == -1)``  ``{``    ``return` `false``;``  ``}` `  ``int` `j = 0;` `  ``// Finding first changed character``  ``// from last of String A``  ``for` `(``int` `i = 0; i < A.Length; i++)``  ``{``    ``if` `(A[i] == temp[index])``      ``j = i;``  ``}` `  ``// Swap the two characters``  ``A = swap(A, index, j);` `  ``// Condition if String A``  ``// is smaller than B``  ``if` `(A.CompareTo(B) < 0)``  ``{``    ``return` `true``;``  ``}``  ``else``  ``{``    ``return` `false``;``  ``}``}``     ` `// Driver Code``public` `static` `void` `Main(``string` `[]args)``{``  ``string` `A = ``"AGAIN"``;``  ``string` `B = ``"ACTION"``;``  ``if` `(IsLexicographicallySmaller(A, B))``  ``{``    ``Console.Write(``"Yes"``);``  ``}``  ``else``  ``{``    ``Console.Write(``"No"``);``  ``}``}``}` `// This code is contributed by Rutvik_56`

## Javascript

 ``
Output:
`Yes`

My Personal Notes arrow_drop_up