# Check if the first and last digit of the smallest number forms a prime

Given an array arr[] containing numbers from 0 to 9 only, the task is to form the minimum possible number from the given digits and then check if the first and last digit of the number thus created can be rearranged to form a prime number or not.

Examples:

Input: arr[]={2, 6, 4, 9}
Output: Minimum number: 2469
Prime number combinations: 29
The first and last digits are 2 and 9 respectively. The combinations are 29 and 92. Only 29 is prime.

Input: arr[]={2, 6, 4, 3, 1, 7}
Output: Minimum number: 123467
Prime number combinations: 17 71
The first and last digits are 1 and 7 respectively. The combinations are 17 and 71, and both are primes

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

Approach:

1. Create a hash of size 10 to store the number of occurrences of the digits in the given array into the hash table.
2. Print the digits the number of times they occur in descending order starting from the digit 0. It is similar to Smallest number by rearranging digits of a given number.
3. For the prime checking, check if the number formed using the first and last digits is prime or not. Do the same for its reverse.

Below is the implementation of above approach:

## C++

 `// C++ implementation of above approach ` `#include ` `using` `namespace` `std; ` ` `  `// function to check prime ` `int` `isPrime(``int` `n) ` `{ ` `    ``int` `i, c = 0; ` `    ``for` `(i = 1; i < n / 2; i++) { ` `        ``if` `(n % i == 0) ` `            ``c++; ` `    ``} ` `    ``if` `(c == 1) ` `        ``return` `1; ` `    ``else` `        ``return` `0; ` `} ` ` `  `// Function to generate smallest possible ` `// number with given digits ` `void` `findMinNum(``int` `arr[], ``int` `n) ` `{ ` `    ``// Declare a hash array of size 10 ` `    ``// and initialize all the elements to zero ` `    ``int` `first = 0, last = 0, num, rev, i; ` `    ``int` `hash = { 0 }; ` ` `  `    ``// store the number of occurrences of the digits ` `    ``// in the given array into the hash table ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``hash[arr[i]]++; ` `    ``} ` ` `  `    ``// Traverse the hash in ascending order ` `    ``// to print the required number ` `    ``cout << ``"Minimum number: "``; ` `    ``for` `(``int` `i = 0; i <= 9; i++) { ` ` `  `        ``// Print the number of times a digits occurs ` `        ``for` `(``int` `j = 0; j < hash[i]; j++) ` `            ``cout << i; ` `    ``} ` ` `  `    ``cout << endl; ` ` `  `    ``// extracting the first digit ` `    ``for` `(i = 0; i <= 9; i++) { ` `        ``if` `(hash[i] != 0) { ` `            ``first = i; ` `            ``break``; ` `        ``} ` `    ``} ` `    ``// extracting the last digit ` `    ``for` `(i = 9; i >= 0; i--) { ` `        ``if` `(hash[i] != 0) { ` `            ``last = i; ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``num = first * 10 + last; ` `    ``rev = last * 10 + first; ` ` `  `    ``// printing the prime combinations ` `    ``cout << ``"Prime combinations: "``; ` `    ``if` `(isPrime(num) && isPrime(rev)) ` `        ``cout << num << ``" "` `<< rev; ` ` `  `    ``else` `if` `(isPrime(num)) ` `        ``cout << num; ` ` `  `    ``else` `if` `(isPrime(rev)) ` `        ``cout << rev; ` ` `  `    ``else` `        ``cout << ``"No combinations exist"``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 2, 4, 7, 8}; ` `    ``findMinNum(arr, 5); ` ` `  `    ``return` `0; ` `} `

## Java

 `   `  `// Java implementation of above approach ` ` `  `import` `java.io.*; ` ` `  `class` `SmallPrime  ` `{ ` ` `  `// function to check prime ` `static` `boolean` `isPrime(``int` `n) ` `{ ` `    ``int` `i, c = ``0``; ` `    ``for` `(i = ``1``; i < n / ``2``; i++)  ` `    ``{ ` `        ``if` `(n % i == ``0``) ` `            ``c++; ` `    ``} ` `    ``if` `(c == ``1``) ` `    ``{ ` `        ``return` `true``; ` `    ``} ` `    ``else` `    ``{ ` `        ``return` `false``; ` `    ``} ` `} ` ` `  `// Function to generate smallest possible ` `// number with given digits ` `static` `void` `findMinNum(``int` `arr[], ``int` `n) ` `{ ` `    ``// Declare a hash array of size 10 ` `    ``// and initialize all the elements to zero ` `    ``int` `first = ``0``, last = ``0``, num, rev, i; ` `    ``int` `hash[] = ``new` `int``[``10``]; ` ` `  `    ``// store the number of occurrences of the digits ` `    ``// in the given array into the hash table ` `    ``for` `( i = ``0``; i < n; i++) ` `    ``{ ` `        ``hash[arr[i]]++; ` `    ``} ` ` `  `    ``// Traverse the hash in ascending order ` `    ``// to print the required number ` `    ``System.out.print(``"Minimum number: "``); ` `    ``for` `( i = ``0``; i <= ``9``; i++) ` `    ``{ ` ` `  `        ``// Print the number of times a digits occurs ` `        ``for` `(``int` `j = ``0``; j < hash[i]; j++) ` `            ``System.out.print(i); ` `             `  `    ``} ` `    ``System.out.println(); ` ` `  `    ``System.out.println(); ` `    ``// extracting the first digit ` `    ``for` `(i = ``0``; i <= ``9``; i++) ` `    ``{ ` `        ``if` `(hash[i] != ``0``)  ` `        ``{ ` `            ``first = i; ` `            ``break``; ` `        ``} ` `    ``} ` `    ``// extracting the last digit ` `    ``for` `(i = ``9``; i >= ``0``; i--)  ` `    ``{ ` `        ``if` `(hash[i] != ``0``) ` `        ``{ ` `            ``last = i; ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``num = first * ``10` `+ last; ` `    ``rev = last * ``10` `+ first; ` ` `  `    ``// printing the prime combinations ` `    ``System.out.print( ``"Prime combinations: "``); ` `    ``if` `(isPrime(num) && isPrime(rev)) ` `    ``{ ` `        ``System.out.println(num + ``" "` `+ rev); ` `    ``}     ` `    ``else` `if` `(isPrime(num)) ` `    ``{ ` `        ``System.out.println(num); ` `    ``}     ` `    ``else` `if` `(isPrime(rev)) ` `    ``{ ` `        ``System.out.println(rev); ` `    ``}     ` ` `  `    ``else` `    ``{ ` `        ``System.out.println(``"No combinations exist"``); ` `    ``} ` `} ` ` `  `// Driver code ` ` `  `    ``public` `static` `void` `main (String[] args)  ` `    ``{ ` `       ``SmallPrime smallprime = ``new` `SmallPrime();  ` `       ``int` `arr[] = {``1``, ``2``, ``4``, ``7``, ``8``}; ` `       ``smallprime.findMinNum(arr, ``5``); ` `    ``} ` `} ` ` `  `// This code has been contributed by inder_verma. `

## Python3

 `# Python3 implementation of above  ` `# approach ` `import` `math as mt  ` ` `  `# function to check prime ` `def` `isPrime(n): ` `    ``i, c ``=` `0``, ``0` `    ``for` `i ``in` `range``(``1``, n ``/``/` `2``): ` `        ``if` `(n ``%` `i ``=``=` `0``): ` `            ``c ``+``=` `1` `     `  `    ``if` `(c ``=``=` `1``): ` `        ``return` `1` `    ``else``: ` `        ``return` `0` ` `  `# Function to generate smallest possible ` `# number with given digits ` `def` `findMinNum(arr, n): ` `     `  `    ``# Declare a Hash array of size 10 ` `    ``# and initialize all the elements to zero ` `    ``first, last ``=` `0``, ``0` `    ``Hash` `=` `[``0` `for` `i ``in` `range``(``10``)] ` ` `  `    ``# store the number of occurrences of ` `    ``# the digits in the given array into  ` `    ``# the Hash table ` `    ``for` `i ``in` `range``(n): ` `        ``Hash``[arr[i]] ``+``=` `1` ` `  `    ``# Traverse the Hash in ascending order ` `    ``# to print the required number ` `    ``print``(``"Minimum number: "``, end ``=` `"") ` `    ``for` `i ``in` `range``(``0``, ``10``): ` `         `  `        ``# Print the number of times  ` `        ``# a digits occurs ` `        ``for` `j ``in` `range``(``Hash``[i]): ` `            ``print``(i, end ``=` `"") ` `             `  `    ``print``() ` `     `  `    ``# extracting the first digit ` `    ``for` `i ``in` `range``(``10``): ` `        ``if` `(``Hash``[i] !``=` `0``): ` `            ``first ``=` `i ` `            ``break` `         `  `    ``# extracting the last digit ` `    ``for` `i ``in` `range``(``9``, ``-``1``, ``-``1``): ` `        ``if` `(``Hash``[i] !``=` `0``): ` `            ``last ``=` `i ` `            ``break` `         `  `    ``num ``=` `first ``*` `10` `+` `last ` `    ``rev ``=` `last ``*` `10` `+` `first ` ` `  `    ``# printing the prime combinations ` `    ``print``(``"Prime combinations: "``, end ``=` `"") ` `    ``if` `(isPrime(num) ``and` `isPrime(rev)): ` `        ``print``(num, ``" "``, rev) ` `    ``elif` `(isPrime(num)): ` `        ``print``(num) ` `    ``elif` `(isPrime(rev)): ` `        ``print``(rev) ` `    ``else``: ` `        ``print``(``"No combinations exist"``) ` ` `  `# Driver code ` `arr ``=` `[ ``1``, ``2``, ``4``, ``7``, ``8``] ` `findMinNum(arr, ``5``) ` ` `  `# This code is contributed by ` `# Mohit kumar 29 `

## C#

 `// C# implementation of above approach ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `// function to check prime ` `static` `bool` `isPrime(``int` `n)  ` `{ ` `    ``int` `i, c = 0; ` `    ``for` `(i = 1; i < n / 2; i++) ` `    ``{ ` `        ``if` `(n % i == 0)  ` `        ``{ ` `            ``c++; ` `        ``} ` `    ``} ` `    ``if` `(c == 1)  ` `    ``{ ` `        ``return` `true``; ` `    ``} ` `    ``else` `    ``{ ` `        ``return` `false``; ` `    ``} ` `} ` ` `  `// Function to generate smallest  ` `// possible number with given digits ` `static` `void` `findMinNum(``int``[] arr, ``int` `n)  ` `{ ` `    ``// Declare a hash array of  ` `    ``// size 10 and initialize  ` `    ``// all the elements to zero ` `    ``int` `first = 0, last = 0, num, rev, i; ` `    ``int``[] hash = ``new` `int``; ` ` `  `    ``// store the number of occurrences  ` `    ``// of the digits in the given array  ` `    ``// into the hash table ` `    ``for` `(i = 0; i < n; i++)  ` `    ``{ ` `        ``hash[arr[i]]++; ` `    ``} ` ` `  `    ``// Traverse the hash in ascending order ` `    ``// to print the required number ` `    ``Console.Write(``"Minimum number: "``); ` `    ``for` `(i = 0; i <= 9; i++)  ` `    ``{ ` ` `  `        ``// Print the number of times  ` `        ``// a digits occurs ` `        ``for` `(``int` `j = 0; j < hash[i]; j++) ` `        ``{ ` `            ``Console.Write(i); ` `        ``} ` ` `  `    ``} ` `    ``Console.WriteLine(); ` ` `  `    ``Console.WriteLine(); ` `     `  `    ``// extracting the first digit ` `    ``for` `(i = 0; i <= 9; i++)  ` `    ``{ ` `        ``if` `(hash[i] != 0)  ` `        ``{ ` `            ``first = i; ` `            ``break``; ` `        ``} ` `    ``} ` `     `  `    ``// extracting the last digit ` `    ``for` `(i = 9; i >= 0; i--)  ` `    ``{ ` `        ``if` `(hash[i] != 0) ` `        ``{ ` `            ``last = i; ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``num = first * 10 + last; ` `    ``rev = last * 10 + first; ` ` `  `    ``// printing the prime combinations ` `    ``Console.Write(``"Prime combinations: "``); ` `    ``if` `(isPrime(num) && isPrime(rev))  ` `    ``{ ` `        ``Console.WriteLine(num + ``" "` `+ rev); ` `    ``} ` `    ``else` `if` `(isPrime(num))  ` `    ``{ ` `        ``Console.WriteLine(num); ` `    ``}  ` `    ``else` `if` `(isPrime(rev))  ` `    ``{ ` `        ``Console.WriteLine(rev); ` `    ``}  ` `    ``else`  `    ``{ ` `        ``Console.WriteLine(``"No combinations exist"``); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main()  ` `{ ` `    ``int``[] arr = {1, 2, 4, 7, 8}; ` `    ``findMinNum(arr, 5); ` `} ` `} ` ` `  `// This code is contributed  ` `// by PrinciRaj1992 `

## PHP

 `= 0; ``\$i``--)  ` `    ``{ ` `        ``if` `(``\$hash``[``\$i``] != 0)  ` `        ``{ ` `            ``\$last` `= ``\$i``; ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``\$num` `= ``\$first` `* 10 + ``\$last``; ` `    ``\$rev` `= ``\$last` `* 10 + ``\$first``; ` ` `  `    ``// printing the prime combinations ` `    ``echo` `"\nPrime combinations: "``; ` `    ``if` `(isPrime(``\$num``) && isPrime(``\$rev``)) ` `        ``echo` `\$num``. ``" "` `. ``\$rev``; ` ` `  `    ``else` `if` `(isPrime(``\$num``)) ` `        ``echo` `\$num``; ` ` `  `    ``else` `if` `(isPrime(``\$rev``)) ` `        ``echo` `\$rev``; ` ` `  `    ``else` `        ``echo` `"No combinations exist"``; ` `} ` ` `  `// Driver Code ` `\$arr` `= ``array``(1, 2, 4, 7, 8); ` `findMinNum(``\$arr``, 5); ` ` `  `// This code is contributed  ` `// by Rajput-Ji ` `?> `

Output:

```Minimum number: 12478
Prime combinations: No combinations exist
```

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Article Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.