Skip to content
Related Articles

Related Articles

Improve Article
Minimum difference possible between two given numbers by rearranging their digits in the same order
  • Last Updated : 17 May, 2021

Given two N-digit positive integers X and Y, the task is to find the minimum absolute difference between both the integers possible by rearranging the digits of both the integers in the same order.

Examples:

Input: X = 5181, Y = 3663
Output: 1482
Explanation:
Rearranging the digits of both the given integers in the order of (3, 2, 4, 1) modifies the value of X and Y as 8115 and 6633 respectively.
Therefore, the absolute difference between the two is (8115 – 6633) = 1482, which is the minimum possible difference.

Input: X = 37198, Y = 44911
Output: 1278

Approach: The given problem can be solved by finding the absolute difference between every permutation of X and Y having the same order of rearrangements of digits. Follow the steps below to solve the problem:

  • Initialize a 2D array arr[2][N], that stores the digits of numbers X and Y respectively.
  • Initialize an array, say P[], that stores the permutation of the numbers [0, N – 1].
  • Initialize a variable, say minDIff that stores the minimized difference between X and Y.
  • Traverse the all possible permutation of P[] and perform the following steps:
    • Rearrange the digits of X and Y according to the permutation and store the absolute difference between them in a variable say difference.
    • After the above steps, update the value of minDIff as the minimum of minDiff and difference.
  • After completing the above steps, print the value of minDIff as the minimum difference.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find minimum difference
// between X and Y after rearranging
// their digits in the same order
int minDifference(int X, int Y)
{
    // Stores the minimum difference
    int minDiff = INT_MAX;
 
    // Stores the number X as string
    string x = to_string(X);
 
    // Stores the number Y as string
    string y = to_string(Y);
 
    // Stores number of digits
    int n = x.size();
 
    // Store the digits
    int a[2][n];
 
    // Traverse the range [0, 1]
    for (int i = 0; i < 2; i++) {
 
        // Traverse the range [0, N - 1]
        for (int j = 0; j < n; j++) {
 
            // If the value of i is 0
            if (i == 0)
                a[i][j] = x[j] - '0';
 
            // Otherwise
            else
                a[i][j] = y[j] - '0';
        }
    }
 
    // Stores the permutation of [1, N]
    int p[n];
 
    // Initialize the permutation array
    for (int i = 0; i < n; i++)
        p[i] = i;
 
    // Generate all possible permutation
    do {
 
        // Stores the maximum of X and Y
        int xx = INT_MIN;
 
        // Stores the minimum of X and Y
        int yy = INT_MAX;
 
        // Traverse the range [0, 1]
        for (int i = 0; i < 2; i++) {
 
            // Stores the number
            // after rearranging
            int num = 0;
 
            // Traverse the range [0, N - 1]
            for (int j = 0; j < n; j++)
 
                // Update the value of num
                num = num * 10 + a[i][p[j]];
 
            // Update the value of xx
            xx = max(xx, num);
 
            // Update the value of yy
            yy = min(yy, num);
        }
 
        // Update the value of minDiff
        minDiff = min(minDiff, xx - yy);
 
    } while (next_permutation(p, p + n));
 
    // Return the minimum difference
    return minDiff;
}
 
// Driver Code
int main()
{
    int X = 37198, Y = 44911;
    cout << minDifference(X, Y);
 
    return 0;
}

Java




// Java program for the above approach
 
import java.util.*;
 
class GFG{
 
// Function to find minimum difference
// between X and Y after rearranging
// their digits in the same order
static int minDifference(int X, int Y)
{
    // Stores the minimum difference
    int minDiff = Integer.MAX_VALUE;
 
    // Stores the number X as String
    String x = String.valueOf(X);
 
    // Stores the number Y as String
    String y = String.valueOf(Y);
 
    // Stores number of digits
    int n = x.length();
 
    // Store the digits
    int [][]a = new int[2][n];
 
    // Traverse the range [0, 1]
    for (int i = 0; i < 2; i++) {
 
        // Traverse the range [0, N - 1]
        for (int j = 0; j < n; j++) {
 
            // If the value of i is 0
            if (i == 0)
                a[i][j] = x.charAt(j) - '0';
 
            // Otherwise
            else
                a[i][j] = y.charAt(j) - '0';
        }
    }
 
    // Stores the permutation of [1, N]
    int []p = new int[n];
 
    // Initialize the permutation array
    for (int i = 0; i < n; i++)
        p[i] = i;
 
    // Generate all possible permutation
    do {
 
        // Stores the maximum of X and Y
        int xx = Integer.MIN_VALUE;
 
        // Stores the minimum of X and Y
        int yy = Integer.MAX_VALUE;
 
        // Traverse the range [0, 1]
        for (int i = 0; i < 2; i++) {
 
            // Stores the number
            // after rearranging
            int num = 0;
 
            // Traverse the range [0, N - 1]
            for (int j = 0; j < n; j++)
 
                // Update the value of num
                num = num * 10 + a[i][p[j]];
 
            // Update the value of xx
            xx = Math.max(xx, num);
 
            // Update the value of yy
            yy = Math.min(yy, num);
        }
 
        // Update the value of minDiff
        minDiff = Math.min(minDiff, xx - yy);
 
    } while (next_permutation(p));
 
    // Return the minimum difference
    return minDiff;
}
static boolean next_permutation(int[] p) {
      for (int a = p.length - 2; a >= 0; --a)
        if (p[a] < p[a + 1])
          for (int b = p.length - 1;; --b)
            if (p[b] > p[a]) {
              int t = p[a];
              p[a] = p[b];
              p[b] = t;
              for (++a, b = p.length - 1; a < b; ++a, --b) {
                t = p[a];
                p[a] = p[b];
                p[b] = t;
              }
              return true;
            }
      return false;
    }
// Driver Code
public static void main(String[] args)
{
    int X = 37198, Y = 44911;
    System.out.print(minDifference(X, Y));
 
}
}
 
// This code is contributed by 29AjayKumar

C#




// C# program for the above approach
using System;
class GFG {
 
    // Function to find minimum difference
    // between X and Y after rearranging
    // their digits in the same order
    static int minDifference(int X, int Y)
    {
        // Stores the minimum difference
        int minDiff = Int32.MaxValue;
 
        // Stores the number X as String
        string x = X.ToString();
 
        // Stores the number Y as String
        string y = Y.ToString();
 
        // Stores number of digits
        int n = x.Length;
 
        // Store the digits
        int[, ] a = new int[2, n];
 
        // Traverse the range [0, 1]
        for (int i = 0; i < 2; i++) {
 
            // Traverse the range [0, N - 1]
            for (int j = 0; j < n; j++) {
 
                // If the value of i is 0
                if (i == 0)
                    a[i, j] = x[j] - '0';
 
                // Otherwise
                else
                    a[i, j] = y[j] - '0';
            }
        }
 
        // Stores the permutation of [1, N]
        int[] p = new int[n];
 
        // Initialize the permutation array
        for (int i = 0; i < n; i++)
            p[i] = i;
 
        // Generate all possible permutation
        do {
 
            // Stores the maximum of X and Y
            int xx = Int32.MinValue;
 
            // Stores the minimum of X and Y
            int yy = Int32.MaxValue;
 
            // Traverse the range [0, 1]
            for (int i = 0; i < 2; i++) {
 
                // Stores the number
                // after rearranging
                int num = 0;
 
                // Traverse the range [0, N - 1]
                for (int j = 0; j < n; j++)
 
                    // Update the value of num
                    num = num * 10 + a[i, p[j]];
 
                // Update the value of xx
                xx = Math.Max(xx, num);
 
                // Update the value of yy
                yy = Math.Min(yy, num);
            }
 
            // Update the value of minDiff
            minDiff = Math.Min(minDiff, xx - yy);
 
        } while (next_permutation(p));
 
        // Return the minimum difference
        return minDiff;
    }
    static bool next_permutation(int[] p)
    {
        for (int a = p.Length - 2; a >= 0; --a)
            if (p[a] < p[a + 1])
                for (int b = p.Length - 1;; --b)
                    if (p[b] > p[a]) {
                        int t = p[a];
                        p[a] = p[b];
                        p[b] = t;
                        for (++a, b = p.Length - 1; a < b;
                             ++a, --b) {
                            t = p[a];
                            p[a] = p[b];
                            p[b] = t;
                        }
                        return true;
                    }
        return false;
    }
   
    // Driver Code
    public static void Main(string[] args)
    {
        int X = 37198, Y = 44911;
        Console.WriteLine(minDifference(X, Y));
    }
}
 
// This code is contributed by ukasp.

Javascript




<script>
       // Javascript program for
       // the above approach
 
       // Function to find minimum difference
       // between X and Y after rearranging
       // their digits in the same order
        
       function minDifference(X, Y)
       {
           // Stores the minimum difference
           let minDiff = Number.MAX_SAFE_INTEGER;
 
           // Stores the number X as String
           let x = X.toString();
 
           // Stores the number Y as String
           let y = Y.toString();
 
           // Stores number of digits
           let n = x.length;
 
           // Store the digits
           let a = [];
           for (let i = 0; i < 2; i++) {
               a[i] = new Array(n);
           }
           //Traverse the range [0, 1]
           for (let i = 0; i < 2; i++) {
 
               // Traverse the range [0, N - 1]
               for (let j = 0; j < n; j++) {
 
                   // If the value of i is 0
                   if (i == 0)
                       a[i][j] = x.charAt(j) - '0';
 
                   // Otherwise
                   else
                       a[i][j] = y.charAt(j) - '0';
               }
           }
            
           // Stores the permutation of [1, N]
           let p = [];
 
           // Initialize the permutation array
           for (let i = 0; i < n; i++)
               p[i] = i;
 
           // Generate all possible permutation
           do {
 
               // Stores the maximum of X and Y
               let xx = Number.MIN_SAFE_INTEGER;
 
               // Stores the minimum of X and Y
               let yy = Number.MAX_SAFE_INTEGER;
 
               // Traverse the range [0, 1]
               for (let i = 0; i < 2; i++) {
 
                   // Stores the number
                   // after rearranging
                   let num = 0;
 
                   // Traverse the range [0, N - 1]
                   for (let j = 0; j < n; j++)
 
                       // Update the value of num
                       num = num * 10 + a[i][p[j]];
 
                   // Update the value of xx
                   xx = Math.max(xx, num);
 
                   // Update the value of yy
                   yy = Math.min(yy, num);
               }
 
               // Update the value of minDiff
               minDiff = Math.min(minDiff, xx - yy);
 
           } while (next_permutation(p));
 
           // Return the minimum difference
           return minDiff;
       }
       function next_permutation(p) {
           for (let a = p.length - 2; a >= 0; --a)
               if (p[a] < p[a + 1])
                   for (let b = p.length - 1; ; --b)
                       if (p[b] > p[a]) {
                           let t = p[a];
                           p[a] = p[b];
                           p[b] = t;
                           for (++a, b = p.length - 1;
                           a < b; ++a, --b)
                           {
                               t = p[a];
                               p[a] = p[b];
                               p[b] = t;
                           }
                           return true;
                       }
           return false;
       }
       // Driver Code
 
       let X = 37198, Y = 44911;
       document.write(minDifference(X, Y));
 
       // This code is contributed by Hritik
        
   </script>
Output: 
1278

 

Time Complexity: O(N!)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :