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

**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 <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to return the greatest number ` `// not gtreater than B that can be formed ` `// with the digits of A ` `string 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<` `char` `> 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 code ` `int` `main() ` `{ ` ` ` `string a = ` `"123"` `; ` ` ` `int` `b = 222; ` ` ` `cout << Permute_Digits(a, b); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python implementation of the approach ` ` ` `# Function to return the greatest number ` `# not gtreater than B that can be formed ` `# with the digits of A ` `def` `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 Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `a ` `=` `"123"` ` ` `b ` `=` `222` ` ` `print` `(permuteDigits(a, b)) ` ` ` `# This code is contributed by ` `# sanjeev2552 ` |

*chevron_right*

*filter_none*

**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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Greatest number that can be formed from a pair in a given Array
- Find the number of positive integers less than or equal to N that have an odd number of digits
- Find maximum product of digits among numbers less than or equal to N
- Highest and Smallest power of K less than and greater than equal to N respectively
- Print a number strictly less than a given number such that all its digits are distinct.
- Number formed by deleting digits such that sum of the digits becomes even and the number odd
- Find maximum number that can be formed using digits of a given number
- Smallest even digits number not less than N
- Smallest odd digits number not less than N
- Largest number with maximum trailing nines which is less than N and greater than N-D
- Largest number less than N with digit sum greater than the digit sum of N
- Find the largest number that can be formed by changing at most K digits
- Highest power of 2 less than or equal to given number
- Sum of largest prime factor of each number less than equal to n
- Find Largest Special Prime which is less than or equal to a given number
- Count number of integers less than or equal to N which has exactly 9 divisors
- Largest number less than or equal to N/2 which is coprime to N
- Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
- Largest number less than or equal to Z that leaves a remainder X when divided by Y
- Find all powers of 2 less than or equal to a given number

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.