Minimum integer that can be obtained by swapping adjacent digits of different parity

Given an integer N, the task is to find the minimum integer that can be obtained from the given integer such that the adjacent digits of different parity can be swapped any no of times.
Two digits of different parity means that they will have different remainders when divided by two.

Examples:

Input: N = 64432
Output: 36442
Explanation:
Swap the 4th and 3rd digit; N = 64342
Swap the 3rd and 2nd digit; N = 63442
Swap the 2nd and 1st digit; N = 36442



Input :
3137
Output :
3137

Approach: The idea of the approach is to use two stacks to keep the digits of the number.

Below is the implementation of the above approach.

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the above approach.
#include <bits/stdc++.h>
using namespace std;
// Function to return the minimum number
int minimumNo(int n)
{
    int ans = 0;
    stack<int> stack1;
    stack<int> stack2;
    while (n != 0) {
        int r = n % 10;
  
        // Store the elements which are
        // divisible by two in stack1
        if (r % 2 == 0) {
            stack1.push(r);
        }
  
        // Store the elements which are
        // not divisible by two in stack2.
        else {
            stack2.push(r);
        }
        n = n / 10;
    }
  
    while (!stack1.empty() && !stack2.empty()) {
  
        // Concatenate the answer with smaller value
        // of the topmost elements of both the
        // stacks and then pop that element
        if (stack1.top() < stack2.top()) {
            ans = ans * 10 + stack1.top();
            stack1.pop();
        }
        else {
            ans = ans * 10 + stack2.top();
            stack2.pop();
        }
    }
  
    // Concatenate the answer with remaining 
    // values of stack1.
    while (!stack1.empty()) {
        ans = ans * 10 + stack1.top();
        stack1.pop();
    }
  
    // Concatenate the answer with remaining 
    // values of stack2.
    while (!stack2.empty()) {
        ans = ans * 10 + stack2.top();
        stack2.pop();
    }
    return ans;
}
  
// Driver code
int main()
{
    int n1 = 64432;
  
    // Function calling
    cout << minimumNo(n1) << endl;
  
    int n2 = 3137;
    cout << minimumNo(n2) << endl;
  
    return 0;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the above approach.
import java.util.*;
  
class GFG
{
      
// Function to return the minimum number
static int minimumNo(int n)
{
    int ans = 0;
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    while (n != 0)
    {
        int r = n % 10;
  
        // Store the elements which are
        // divisible by two in stack1
        if (r % 2 == 0)
        {
            stack1.add(r);
        }
  
        // Store the elements which are
        // not divisible by two in stack2.
        else 
        {
            stack2.add(r);
        }
        n = n / 10;
    }
  
    while (!stack1.isEmpty() && !stack2.isEmpty())
    {
  
        // Concatenate the answer with smaller value
        // of the topmost elements of both the
        // stacks and then pop that element
        if (stack1.peek() < stack2.peek())
        {
            ans = ans * 10 + stack1.peek();
            stack1.pop();
        }
        else 
        {
            ans = ans * 10 + stack2.peek();
            stack2.pop();
        }
    }
  
    // Concatenate the answer with remaining 
    // values of stack1.
    while (!stack1.isEmpty())
    {
        ans = ans * 10 + stack1.peek();
        stack1.pop();
    }
  
    // Concatenate the answer with remaining 
    // values of stack2.
    while (!stack2.isEmpty())
    {
        ans = ans * 10 + stack2.peek();
        stack2.pop();
    }
    return ans;
}
  
// Driver code
public static void main(String[] args)
{
    int n1 = 64432;
  
    // Function calling
    System.out.print(minimumNo(n1) + "\n");
  
    int n2 = 3137;
    System.out.print(minimumNo(n2) + "\n");
}
}
  
// This code is contributed by 29AjayKumar
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the above approach.
  
# Function to return the minimum number
def minimumNo(n):
    ans = 0
    stack1 = []
    stack2 = []
    while (n != 0):
        r = n % 10
  
        # Store the elements which are
        # divisible by two in stack1
        if (r % 2 == 0):
            stack1.append(r)
  
        # Store the elements which are
        # not divisible by two in stack2.
        else :
            stack2.append(r)
  
        n = n // 10
    while (len(stack1) > 0 and len(stack2) > 0):
  
        # Concatenate the answer with smaller value
        # of the topmost elements of both the
        # stacks and then pop that element
        if (stack1[-1] < stack2[-1]):
            ans = ans * 10 + stack1[-1]
            del stack1[-1]
  
        else:
            ans = ans * 10 + stack2[-1]
            del stack2[-1]
  
    # Concatenate the answer with remaining
    # values of stack1.
    while (len(stack1) > 0):
        ans = ans * 10 + stack1[-1]
        del stack1[-1]
  
    # Concatenate the answer with remaining
    # values of stack2.
    while (len(stack2) > 0):
        ans = ans * 10 + stack2[-1]
        del stack2[-1]
  
    return ans
  
# Driver code
n1 = 64432
  
# Function calling
print(minimumNo(n1))
  
n2 = 3137
print(minimumNo(n2))
  
# This code is contributed by mohit kumar 29
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the above approach.
using System;
using System.Collections.Generic;
  
class GFG
{
      
// Function to return the minimum number
static int minimumNo(int n)
{
    int ans = 0;
    Stack<int> stack1 = new Stack<int>();
    Stack<int> stack2 = new Stack<int>();
    while (n != 0)
    {
        int r = n % 10;
  
        // Store the elements which are
        // divisible by two in stack1
        if (r % 2 == 0)
        {
            stack1.Push(r);
        }
  
        // Store the elements which are
        // not divisible by two in stack2.
        else
        {
            stack2.Push(r);
        }
        n = n / 10;
    }
  
    while (stack1.Count != 0 && stack2.Count != 0)
    {
  
        // Concatenate the answer with smaller value
        // of the topmost elements of both the
        // stacks and then pop that element
        if (stack1.Peek() < stack2.Peek())
        {
            ans = ans * 10 + stack1.Peek();
            stack1.Pop();
        }
        else
        {
            ans = ans * 10 + stack2.Peek();
            stack2.Pop();
        }
    }
  
    // Concatenate the answer with remaining 
    // values of stack1.
    while (stack1.Count != 0)
    {
        ans = ans * 10 + stack1.Peek();
        stack1.Pop();
    }
  
    // Concatenate the answer with remaining 
    // values of stack2.
    while (stack2.Count != 0)
    {
        ans = ans * 10 + stack2.Peek();
        stack2.Pop();
    }
    return ans;
}
  
// Driver code
public static void Main(String[] args)
{
    int n1 = 64432;
  
    // Function calling
    Console.Write(minimumNo(n1) + "\n");
  
    int n2 = 3137;
    Console.Write(minimumNo(n2) + "\n");
}
}
  
// This code is contributed by PrinciRaj1992
chevron_right

Output:
36442
3137

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details





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.



Article Tags :