Greatest number less than equal to B that can be formed from the digits of A

• Last Updated : 24 Jan, 2020

Given two integers A and B, the task is to find the greatest number ≤ B that can be formed using all the digits of A.

Examples:

Input: A = 123, B = 222
Output: 213
123, 132 and 213 are the only valid numbers which are ≤ 222.
213 is the maximum among them.

Input: A = 3921, B = 10000
Output: 9321

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

Approach: Let’s construct the answer digit by digit starting from the leftmost. We need to build a lexicographically maximal answer so we should choose the greatest digit in each step.

Iterate over all possible digits starting from the greatest. For each digit check if it’s possible to put it in this position. For this, construct minimal suffix (greedily put the lowest digit) and compare the resulting number with B. If it is less than or equal to B then proceed to the next digit.

Below is the implementation of the above approach:

C++

 // C++ implementation of the approach#include using namespace std;  // Function to return the greatest number// not gtreater than B that can be formed// with the digits of Astring Permute_Digits(string a, long long b){    // To store size of A    int n = a.size();      // To store the required answer    string ans = "";      // Traverse from leftmost digit and     // place a smaller digit for every    // position.    for (int i = 0; i < n; i++) {          // Keep all digits in A        set temp(a.begin(), a.end());          // To avoid leading zeros        if (i == 0)            temp.erase(0);          // For all possible values at ith position from        // largest value to smallest        for (auto j = temp.rbegin(); j != temp.rend(); ++j) {              // Take largest possible digit            string s1 = ans + *j;              // Keep duplicate of string a            string s2 = a;              // Remove the taken digit from s2            s2.erase(s2.find(*j), 1);              // Sort all the remaining digits of s2            sort(s2.begin(), s2.end());              // Add s2 to current s1            s1 += s2;              // If s1 is less than B then it can be            // included in the answer. Note that             // stoll() converts a string to lomg            // long int.            if (stoll(s1) <= b) {                ans += *j;                  // change A to s2                a = s2;                break;            }        }    }      // Return the required answer    return ans;}  // Driver codeint main(){    string a = "123";    int b = 222;    cout << Permute_Digits(a, b);      return 0;}

Python3

 # Python implementation of the approach  # Function to return the greatest number# not gtreater than B that can be formed# with the digits of Adef permuteDigits(a: str, b: int) -> str:      # To store size of A    n = len(a)      # To store the required answer    ans = ""      # Traverse from leftmost digit and    # place a smaller digit for every    # position.    for i in range(n):          # Keep all digits in A        temp = set(list(a))          # To avoid leading zeros        if i == 0:            temp.discard(0)          # For all possible values at ith position from        # largest value to smallest        for j in reversed(list(temp)):              # Take largest possible digit            s1 = ans + j              # Keep duplicate of string a            s2 = list(a).copy()              # Remove the taken digit from s2            s2.remove(j)              # Sort all the remaining digits of s2            s2 = ''.join(sorted(list(s2)))              # Add s2 to current s1            s1 += s2              # If s1 is less than B then it can be            # included in the answer. Note that            # int() converts a string to integer            if int(s1) <= b:                ans += j                  # change A to s2                a = ''.join(list(s2))                break      # Return the required answer    return ans  # Driver Codeif __name__ == "__main__":      a = "123"    b = 222    print(permuteDigits(a, b))  # This code is contributed by# sanjeev2552
Output:
213

Optimizations : We can use multiset to keep all occurrences of a digit in set. We can also do binary search using lower_bound() in C++ to quickly find the digit to be placed.

My Personal Notes arrow_drop_up