Given a number N, the task is to find the largest number less than or equal to the given number N such that on rearranging its digits it can become prime.

**Examples:**

Input :N = 99Output :98Explanation :We can rearrange the digits of 98 to 89 and 89 is a prime number.Input :N = 84896Output :84896Explanation :We can rearrange the digits of 84896 to 46889 which is a prime number.

Below is the algorithm to find such a largest number **num <= N **such that digits of num can be rearranged to get a prime number:

**Preprocessing Step**: Generate a list of all the prime numbers less than or equal to given number N. This can be done efficiently using the sieve of Eratosthenes.

**Main Steps**: The main idea is to check all numbers from N to 1, if any of the number can be reshuffled to form a prime. The first such number found will be the answer.

To do this, run a loop from N to 1 and for every number:

- Extract the digits of the given number and store it in a vector.
- Sort this vector to get the smallest number which can be formed using these digits.
- For each permutation of this vector, we would form a number and check whether the formed number is prime or not. Here we make use of the Preprocessing step.
- If it is prime then we stop the loop and this is our answer.

Below is the implementation of the above approach:

`// C++ Program to find a number less than ` `// or equal to N such that rearranging ` `// the digits gets a prime number ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; `
` ` `// Preprocessed vector to store primes ` `vector<` `bool` `> prime(1000001, ` `true` `); `
` ` `// Function to generate primes using ` `// sieve of eratosthenese ` `void` `sieve() `
`{ ` ` ` `// Applying sieve of Eratosthenes `
` ` `prime[0] = prime[1] = ` `false` `; `
` ` ` ` `for` `(` `long` `long` `i = 2; i * i <= 1000000; i++) { `
` ` ` ` `if` `(prime[i]) { `
` ` `for` `(` `long` `long` `j = i * i; j <= 1000000; j += i) `
` ` `prime[j] = ` `false` `; `
` ` `} `
` ` `} `
`} ` ` ` `// Function to find a number less than ` `// or equal to N such that rearranging ` `// the digits gets a prime number ` `int` `findNumber(` `int` `n) `
`{ ` ` ` `vector<` `int` `> v; `
` ` `bool` `flag = ` `false` `; `
` ` ` ` `int` `num; `
` ` ` ` `// Run loop from n to 1 `
` ` `for` `(num = n; num >= 1; num--) { `
` ` ` ` `int` `x = num; `
` ` ` ` `// Clearing the vector `
` ` `v.clear(); `
` ` ` ` `// Extracting the digits `
` ` `while` `(x != 0) { `
` ` `v.push_back(x % 10); `
` ` ` ` `x /= 10; `
` ` `} `
` ` ` ` `// Sorting the vector to make smallest `
` ` `// number using digits `
` ` `sort(v.begin(), v.end()); `
` ` ` ` `// Check all permutation of current number `
` ` `// for primality `
` ` `while` `(1) { `
` ` `long` `long` `w = 0; `
` ` ` ` `// Traverse vector to for number `
` ` `for` `(` `auto` `u : v) `
` ` `w = w * 10 + u; `
` ` ` ` `// If prime exists `
` ` `if` `(prime[w]) { `
` ` ` ` `flag = ` `true` `; `
` ` `break` `; `
` ` `} `
` ` ` ` `if` `(flag) `
` ` `break` `; `
` ` ` ` `// generating next permutation of vector `
` ` `if` `(!next_permutation(v.begin(), v.end())) `
` ` `break` `; `
` ` `} `
` ` ` ` `if` `(flag) `
` ` `break` `; `
` ` `} `
` ` ` ` `// Required number `
` ` `return` `num; `
`} ` ` ` `// Driver Code ` `int` `main() `
`{ ` ` ` `sieve(); `
` ` ` ` `int` `n = 99; `
` ` `cout << findNumber(n) << endl; `
` ` ` ` `n = 84896; `
` ` `cout << findNumber(n) << endl; `
` ` ` ` `return` `0; `
`} ` |

*chevron_right*

*filter_none*

`# Python 3 Program to find a number less than ` `# or equal to N such that rearranging ` `# the digits gets a prime number ` `from` `math ` `import` `sqrt `
` ` `def` `next_permutation(a): `
` ` ` ` `# Generate the lexicographically `
` ` `# next permutation inplace. `
` ` ` ` `# Generation_in_lexicographic_order `
` ` `# Return false if there is no next permutation. `
` ` ` ` `# Find the largest index i such that `
` ` `# a[i] < a[i + 1]. If no such index exists, `
` ` `# the permutation is the last permutation `
` ` `for` `i ` `in` `reversed` `(` `range` `(` `len` `(a) ` `-` `1` `)): `
` ` `if` `a[i] < a[i ` `+` `1` `]: `
` ` `break` `# found `
` ` `else` `: ` `# no break: not found `
` ` `return` `False` `# no next permutation `
` ` ` ` `# Find the largest index j greater than i `
` ` `# such that a[i] < a[j] `
` ` `j ` `=` `next` `(j ` `for` `j ` `in` `reversed` `(` `range` `(i ` `+` `1` `, ` `len` `(a))) `
` ` `if` `a[i] < a[j]) `
` ` ` ` `# Swap the value of a[i] with that of a[j] `
` ` `a[i], a[j] ` `=` `a[j], a[i] `
` ` ` ` `# Reverse sequence from a[i + 1] up to and `
` ` `# including the final element a[n] `
` ` `a[i ` `+` `1` `:] ` `=` `reversed` `(a[i ` `+` `1` `:]) `
` ` `return` `True`
` ` `# Preprocessed vector to store primes ` `prime ` `=` `[` `True` `for` `i ` `in` `range` `(` `1000001` `)] `
` ` `# Function to generate primes using ` `# sieve of eratosthenese ` `def` `sieve(): `
` ` ` ` `# Applying sieve of Eratosthenes `
` ` `prime[` `0` `] ` `=` `False`
` ` `prime[` `1` `] ` `=` `False`
` ` ` ` `for` `i ` `in` `range` `(` `2` `,` `int` `(sqrt(` `1000000` `)) ` `+` `1` `, ` `1` `): `
` ` `if` `(prime[i]): `
` ` `for` `j ` `in` `range` `(i ` `*` `i, ` `1000001` `, i): `
` ` `prime[j] ` `=` `False`
` ` `# Function to find a number less than ` `# or equal to N such that rearranging ` `# the digits gets a prime number ` `def` `findNumber(n): `
` ` `v ` `=` `[] `
` ` `flag ` `=` `False`
` ` ` ` `# Run loop from n to 1 `
` ` `num ` `=` `n `
` ` `while` `(num >` `=` `1` `): `
` ` `x ` `=` `num `
` ` ` ` `v.clear() `
` ` ` ` `# Extracting the digits `
` ` `while` `(x !` `=` `0` `): `
` ` `v.append(x ` `%` `10` `) `
` ` ` ` `x ` `=` `int` `(x ` `/` `10` `) `
` ` ` ` `# Sorting the vector to make smallest `
` ` `# number using digits `
` ` `v.sort(reverse ` `=` `False` `) `
` ` ` ` `# Check all permutation of current number `
` ` `# for primality `
` ` `while` `(` `1` `): `
` ` `w ` `=` `0`
` ` ` ` `# Traverse vector to for number `
` ` `for` `u ` `in` `v: `
` ` `w ` `=` `w ` `*` `10` `+` `u `
` ` ` ` `# If prime exists `
` ` `if` `(prime[w]): `
` ` `flag ` `=` `True`
` ` `break`
` ` ` ` `if` `(flag): `
` ` `break`
` ` ` ` `# generating next permutation of vector `
` ` `if` `(next_permutation(v) ` `=` `=` `False` `): `
` ` `break`
` ` ` ` `if` `(flag): `
` ` `break`
` ` ` ` `num ` `-` `=` `1`
` ` ` ` `# Required number `
` ` `return` `num `
` ` `# Driver Code ` `if` `__name__ ` `=` `=` `'__main__'` `: `
` ` `sieve() `
` ` ` ` `n ` `=` `99`
` ` `print` `(findNumber(n)) `
` ` ` ` `n ` `=` `84896`
` ` `print` `(findNumber(n)) `
` ` `# This code is contributed by ` `# Surendra_Gangwar ` |

*chevron_right*

*filter_none*

**Output:**

98 84896

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:

- Length of longest subarray in which elements greater than K are more than elements not greater than K
- Largest number not greater than N all the digits of which are odd
- Largest number with maximum trailing nines which is less than N and greater than N-D
- Find the element before which all the elements are smaller than it, and after which all are greater
- Largest number less than N with digit sum greater than the digit sum of N
- Smallest number by rearranging digits of a given number
- Count of Array elements greater than all elements on its left and next K elements on its right
- Count of Array elements greater than all elements on its left and at least K elements on its right
- Smallest subarray of size greater than K with sum greater than a given value
- Smallest Special Prime which is greater than or equal to a given number
- Sum of the digits of square of the given number which has only 1's as its digits
- Largest even digit number not greater than N
- Smallest number greater than or equal to N having sum of digits not exceeding S
- Count of array elements which are greater than all elements on its left
- Reduce the array by deleting elements which are greater than all elements to its left
- Delete array elements which are smaller than next or become smaller
- Maximize number of groups formed with size not smaller than its largest element
- Find Largest Special Prime which is less than or equal to a given number
- Count numbers in given range such that sum of even digits is greater than sum of odd digits
- Check if a grid can become row-wise and column-wise sorted after adjacent swaps

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.