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++

`// 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*

## Python3

`# 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
- Check if a grid can become row-wise and column-wise sorted after adjacent swaps
- 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

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.