# Smallest number possible by swapping adjacent even odd pairs

Given a numeric string str, the task is to find the smallest integer that can be formed by swapping adjacent digits of distinct parity.

Examples:

Input: 836360
Output: 338660
Explanation:
1st Swap: 836360 -> 386360
2nd Swap: 386360 -> 383660
3rd Swap: 383660 -> 338660

Input: 1003
Output: 13

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:
We can observe that on repeated swaps, we can split the even and odd digits of str into two separate blocks. The order of digits in their respective blocks will be the same as their order of appearance in the string as swapping within a block (same parity) is not allowed. Thus, after separating str into two separate blocks, we need to traverse these two blocks and append the minimum of the two values currently pointed, to the answer. The final string generated after this operation followed by the removal of leading 0’s, if any, is the required answer.

Example:
The even and odd blocks int the order of their appearance in 836360 are {8, 6, 6, 0} and {3, 3} respectively.
Hence the smallest number ans formed is as follows:

1. ans = ans + min(8, 3) => ans = 3
2. ans = ans + min(8, 3) => ans = 33
3. Since, all the odd digits are exhausted, the remaining even digits need to be added one by one.
4. Hence, the required answer is 338660

Below is the implementation of the above approach:

 `// C++ Program to find the ` `// smallest number possible ` `// by swapping adjacent digits ` `// of different parity ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to return the ` `// smallest number possible ` `string findAns(string s) ` `{ ` `    ``int` `digit; ` ` `  `    ``// Arrays to store odd and ` `    ``// even digits in the order ` `    ``// of their appearance in ` `    ``// the given string ` `    ``vector<``int``> odd; ` `    ``vector<``int``> even; ` ` `  `    ``// Insert the odd and ` `    ``// even digits ` `    ``for` `(``auto` `c : s) { ` `        ``digit = c - ``'0'``; ` `        ``if` `(digit & 1) ` `            ``odd.push_back(digit); ` `        ``else` `            ``even.push_back(digit); ` `    ``} ` ` `  `    ``// pointer to odd digit ` `    ``int` `i = 0; ` `    ``// pointer to even digit ` `    ``int` `j = 0; ` ` `  `    ``string ans = ``""``; ` ` `  `    ``while` `(i < odd.size() ` `           ``and j < even.size()) { ` ` `  `        ``if` `(odd[i] < even[j]) ` `            ``ans += (``char``)(odd[i++] + ``'0'``); ` `        ``else` `            ``ans += (``char``)(even[j++] + ``'0'``); ` `    ``} ` ` `  `    ``// In case number of even and ` `    ``// odd digits are not equal ` ` `  `    ``// If odd digits are remaining ` `    ``while` `(i < odd.size()) ` `        ``ans += (``char``)(odd[i++] + ``'0'``); ` ` `  `    ``// If even digits are remaining ` `    ``while` `(j < even.size()) ` `        ``ans += (``char``)(even[j++] + ``'0'``); ` ` `  `    ``// Removal of leading 0's ` `    ``while` `(ans[0] == ``'0'``) { ` `        ``ans.erase(ans.begin()); ` `    ``} ` ` `  `    ``return` `ans; ` `} ` `int` `main() ` `{ ` ` `  `    ``string s = ``"894687536"``; ` `    ``cout << findAns(s); ` `    ``return` `0; ` `} `

 `// Java program to find the smallest  ` `// number possible by swapping adjacent  ` `// digits of different parity ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `// Function to return the ` `// smallest number possible ` `static` `String findAns(String s) ` `{ ` `    ``int` `digit; ` ` `  `    ``// Arrays to store odd and even  ` `    ``// digits in the order their  ` `    ``// appearance in the given String ` `    ``Vector odd =``new` `Vector(); ` `    ``Vector even = ``new` `Vector(); ` ` `  `    ``// Insert the odd and ` `    ``// even digits ` `    ``for``(``char` `c : s.toCharArray()) ` `    ``{ ` `       ``digit = c - ``'0'``; ` `       ``if` `(digit % ``2` `== ``1``) ` `           ``odd.add(digit); ` `       ``else` `           ``even.add(digit); ` `    ``} ` ` `  `    ``// Pointer to odd digit ` `    ``int` `i = ``0``; ` `     `  `    ``// Pointer to even digit ` `    ``int` `j = ``0``; ` ` `  `    ``String ans = ``""``; ` ` `  `    ``while` `(i < odd.size() && j < even.size()) ` `    ``{ ` `        ``if` `(odd.get(i) < even.get(j)) ` `            ``ans += (``char``)(odd.get(i++) + ``'0'``); ` `        ``else` `            ``ans += (``char``)(even.get(j++) + ``'0'``); ` `    ``} ` ` `  `    ``// In case number of even and ` `    ``// odd digits are not equal ` `    ``// If odd digits are remaining ` `    ``while` `(i < odd.size()) ` `        ``ans += (``char``)(odd.get(i++) + ``'0'``); ` ` `  `    ``// If even digits are remaining ` `    ``while` `(j < even.size()) ` `        ``ans += (``char``)(even.get(j++) + ``'0'``); ` ` `  `    ``// Removal of leading 0's ` `    ``while` `(ans.charAt(``0``) == ``'0'``) ` `    ``{ ` `        ``ans = ans.substring(``1``); ` `    ``} ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``String s = ``"894687536"``; ` `     `  `    ``System.out.print(findAns(s)); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

 `# Python3 Program to find the  ` `# smallest number possible  ` `# by swapping adjacent digits  ` `# of different parity  ` ` `  `# Function to return the  ` `# smallest number possible  ` `def` `findAns(s): ` ` `  `    ``# Arrays to store odd and  ` `    ``# even digits in the order  ` `    ``# of their appearance in  ` `    ``# the given string  ` `    ``odd ``=` `[] ` `    ``even ``=` `[]  ` ` `  `    ``# Insert the odd and  ` `    ``# even digits  ` `         `  `    ``for` `c ``in` `s: ` `        ``digit ``=` `int``(c) ` `        ``if` `(digit & ``1``): ` `            ``odd.append(digit) ` `        ``else``: ` `            ``even.append(digit) ` ` `  `    ``# pointer to odd digit  ` `    ``i ``=` `0` `     `  `    ``# pointer to even digit  ` `    ``j ``=` `0` ` `  `    ``ans ``=` `"" ` ` `  `    ``while` `(i < ``len``(odd) ``and` `j < ``len``(even)): ` `         `  `        ``if` `(odd[i] < even[j]): ` `            ``ans ``+``=` `str``(odd[i]) ` `            ``i ``=` `i ``+` `1` `        ``else``: ` `            ``ans ``+``=` `str``(even[j]) ` `            ``j ``=` `j ``+` `1` ` `  `    ``# In case number of even and  ` `    ``# odd digits are not equal  ` ` `  `    ``# If odd digits are remaining  ` `    ``while` `(i < ``len``(odd)): ` `        ``ans ``+``=` `str``(odd[i]) ` `        ``i ``=` `i ``+` `1` ` `  `    ``# If even digits are remaining  ` `    ``while` `(j < ``len``(even)): ` `        ``ans ``+``=` `str``(even[j]) ` `        ``j ``=` `j ``+` `1` ` `  `    ``# Removal of leading 0's  ` `    ``while` `(ans[``0``] ``=``=` `'0'``): ` `        ``ans ``=` `ans[``1``:] ` ` `  `    ``return` `ans ` ` `  `# Driver Code ` `s ``=` `"894687536"` `print``(findAns(s)) ` ` `  `# This code is contributed by yatin `

 `// C# program to find the smallest  ` `// number possible by swapping adjacent  ` `// digits of different parity ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` ` `  `// Function to return the ` `// smallest number possible ` `static` `String findAns(String s) ` `{ ` `    ``int` `digit; ` ` `  `    ``// Arrays to store odd and even  ` `    ``// digits in the order their  ` `    ``// appearance in the given String ` `    ``List<``int``> odd = ``new` `List<``int``>(); ` `    ``List<``int``> even = ``new` `List<``int``>(); ` ` `  `    ``// Insert the odd and ` `    ``// even digits ` `    ``foreach``(``char` `c ``in` `s.ToCharArray()) ` `    ``{ ` `        ``digit = c - ``'0'``; ` `        ``if` `(digit % 2 == 1) ` `            ``odd.Add(digit); ` `        ``else` `            ``even.Add(digit); ` `    ``} ` ` `  `    ``// Pointer to odd digit ` `    ``int` `i = 0; ` `     `  `    ``// Pointer to even digit ` `    ``int` `j = 0; ` ` `  `    ``String ans = ``""``; ` ` `  `    ``while` `(i < odd.Count && j < even.Count) ` `    ``{ ` `        ``if` `(odd[i] < even[j]) ` `            ``ans += (``char``)(odd[i++] + ``'0'``); ` `        ``else` `            ``ans += (``char``)(even[j++] + ``'0'``); ` `    ``} ` ` `  `    ``// In case number of even and ` `    ``// odd digits are not equal ` `    ``// If odd digits are remaining ` `    ``while` `(i < odd.Count) ` `        ``ans += (``char``)(odd[i++] + ``'0'``); ` ` `  `    ``// If even digits are remaining ` `    ``while` `(j < even.Count) ` `        ``ans += (``char``)(even[j++] + ``'0'``); ` ` `  `    ``// Removal of leading 0's ` `    ``while` `(ans[0] == ``'0'``) ` `    ``{ ` `        ``ans = ans.Substring(1); ` `    ``} ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``String s = ``"894687536"``; ` `     `  `    ``Console.Write(findAns(s)); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:
```846869753
```

Time Complexity: O(N), where N is the size of the given string.

Check out this Author's contributed articles.

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.

Improved By : yatinagg, 29AjayKumar

Practice Tags :