 Open in App
Not now

# Find the smallest number whose digits multiply to a given number n

• Difficulty Level : Medium
• Last Updated : 17 Jan, 2022

Given a number ‘n’, find the smallest number ‘p’ such that if we multiply all digits of ‘p’, we get ‘n’. The result ‘p’ should have minimum two digits.
Examples:

```Input:  n = 36
Output: p = 49
// Note that 4*9 = 36 and 49 is the smallest such number

Input:  n = 100
Output: p = 455
// Note that 4*5*5 = 100 and 455 is the smallest such number

Input: n = 1
Output:p = 11
// Note that 1*1 = 1

Input: n = 13
Output: Not Possible```

For a given n, following are the two cases to be considered.
Case 1: n < 10 When n is smaller than 10, the output is always n+10. For example for n = 7, the output is 17. For n = 9, output is 19.
Case 2: n >= 10 Find all factors of n which are between 2 and 9 (both inclusive). The idea is to start searching from 9 so that the number of digits in the result is minimized. For example, 9 is preferred over 33 and 8 is preferred over 24.
Store all found factors in an array. The array would contain digits in non-increasing order, so finally print the array in reverse order.
Following is the implementation of above concept.

## C++

 `#include` `using` `namespace` `std;`   `// Maximum number of digits in output` `#define MAX 50`   `// prints the smallest number ` `// whose digits multiply to n` `void` `findSmallest(``int` `n)` `{` `    ``int` `i, j = 0;` `    `  `    ``// To store digits of result` `    ``// in reverse order` `    ``int` `res[MAX]; `   `    ``// Case 1: If number is smaller than 10` `    ``if` `(n < 10)` `    ``{` `        ``cout << n + 10;` `        ``return``;` `    ``}`   `    ``// Case 2: Start with 9 and` `    ``// try every possible digit` `    ``for` `(i = 9; i > 1; i--)` `    ``{` `        ``// If current digit divides n, then store all` `        ``// occurrences of current digit in res` `        ``while` `(n % i == 0)` `        ``{` `            ``n = n / i;` `            ``res[j] = i;` `            ``j++;` `        ``}` `    ``}`   `    ``// If n could not be broken ` `    ``// in form of digits (prime factors ` `    ``// of n are greater than 9)` `    ``if` `(n > 10)` `    ``{` `        ``cout << ``"Not possible"``;` `        ``return``;` `    ``}`   `    ``// Print the result array in reverse order` `    ``for` `(i = j - 1; i >= 0; i--)` `        ``cout << res[i];` `}`   `// Driver Code` `int` `main()` `{` `    ``findSmallest(7);` `    ``cout << ``"\n"``;`   `    ``findSmallest(36);` `    ``cout << ``"\n"``;`   `    ``findSmallest(13);` `    ``cout << ``"\n"``;`   `    ``findSmallest(100);` `    ``return` `0;` `}`   `// This code is contributed by Code_Mech`

## C

 `#include`   `// Maximum number of digits in output` `#define MAX 50`   `// prints the smallest number whose digits multiply to n` `void` `findSmallest(``int` `n)` `{` `    ``int` `i, j=0;` `    ``int` `res[MAX]; ``// To store digits of result in reverse order`   `    ``// Case 1: If number is smaller than 10` `    ``if` `(n < 10)` `    ``{` `        ``printf``(``"%d"``, n+10);` `        ``return``;` `    ``}`   `    ``// Case 2: Start with 9 and try every possible digit` `    ``for` `(i=9; i>1; i--)` `    ``{` `        ``// If current digit divides n, then store all` `        ``// occurrences of current digit in res` `        ``while` `(n%i == 0)` `        ``{` `            ``n = n/i;` `            ``res[j] = i;` `            ``j++;` `        ``}` `    ``}`   `    ``// If n could not be broken in form of digits (prime factors of n` `    ``// are greater than 9)` `    ``if` `(n > 10)` `    ``{` `        ``printf``(``"Not possible"``);` `        ``return``;` `    ``}`   `    ``// Print the result array in reverse order` `    ``for` `(i=j-1; i>=0; i--)` `        ``printf``(``"%d"``, res[i]);` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``findSmallest(7);` `    ``printf``(``"\n"``);`   `    ``findSmallest(36);` `    ``printf``(``"\n"``);`   `    ``findSmallest(13);` `    ``printf``(``"\n"``);`   `    ``findSmallest(100);` `    ``return` `0;` `}`

## Java

 `// Java program to find the smallest number whose ` `// digits multiply to a given number n`   `import` `java.io.*;`   `class` `Smallest` `{` `    ``// Function to prints the smallest number whose ` `    ``// digits multiply to n` `    ``static` `void` `findSmallest(``int` `n)` `    ``{` `        ``int` `i, j=``0``;` `        ``int` `MAX = ``50``;` `        ``// To store digits of result in reverse order` `        ``int``[] res = ``new` `int``[MAX]; ` ` `  `        ``// Case 1: If number is smaller than 10` `        ``if` `(n < ``10``)` `        ``{` `            ``System.out.println(n+``10``);` `            ``return``;` `        ``}` ` `  `        ``// Case 2: Start with 9 and try every possible digit` `        ``for` `(i=``9``; i>``1``; i--)` `        ``{` `            ``// If current digit divides n, then store all` `            ``// occurrences of current digit in res` `            ``while` `(n%i == ``0``)` `            ``{` `                ``n = n/i;` `                ``res[j] = i;` `                ``j++;` `            ``}` `        ``}` ` `  `        ``// If n could not be broken in form of digits (prime factors of n` `        ``// are greater than 9)` `        ``if` `(n > ``10``)` `        ``{` `            ``System.out.println(``"Not possible"``);` `            ``return``;` `        ``}` ` `  `        ``// Print the result array in reverse order` `        ``for` `(i=j-``1``; i>=``0``; i--)` `            ``System.out.print(res[i]);` `        ``System.out.println();` `    ``}` `    `  `    ``// Driver program` `    ``public` `static` `void` `main (String[] args) ` `    ``{` `        ``findSmallest(``7``);` `        ``findSmallest(``36``);` `        ``findSmallest(``13``);` `        ``findSmallest(``100``);` `    ``}` `}`   `// Contributed by Pramod Kumar`

## Python3

 `# Python code to find the smallest number ` `# whose digits multiply to give n`   `# function to print the smallest number whose ` `# digits multiply to n` `def` `findSmallest(n):` `    ``# Case 1 - If the number is smaller than 10` `    ``if` `n < ``10``:` `        ``print` `(n``+``10``)` `        ``return` `    `  `    ``# Case 2 - Start with 9 and try every possible digit` `    ``res ``=` `[] ``# to sort digits` `    ``for` `i ``in` `range``(``9``,``1``,``-``1``):` `        ``# If current digit divides n, then store all` `        ``# occurrences of current digit in res` `        ``while` `n ``%` `i ``=``=` `0``:` `            ``n ``=` `n ``/` `i` `            ``res.append(i)` `    `  `    ``# If n could not be broken in the form of digits` `    ``# prime factors of  n are greater than 9` `    `  `    ``if` `n > ``10``:` `        ``print` `(``"Not Possible"``)` `        ``return` `        `  `    ``# Print the number from result array in reverse order` `    ``n ``=` `res[``len``(res)``-``1``]` `    ``for` `i ``in` `range``(``len``(res)``-``2``,``-``1``,``-``1``):` `        ``n ``=` `10` `*` `n ``+` `res[i]` `    ``print` `(n)` `    `  `# Driver Code` `findSmallest(``7``)`   `findSmallest(``36``)`   `findSmallest(``13``)`   `findSmallest(``100``)`   `# This code is contributed by Harshit Agrawal`

## C#

 `// C# program to find the smallest number whose ` `// digits multiply to a given number n` `using` `System;`   `class` `GFG {` `    `  `    ``// Function to prints the smallest number` `    ``// whose digits multiply to n` `    ``static` `void` `findSmallest(``int` `n)` `    ``{` `        `  `        ``int` `i, j=0;` `        ``int` `MAX = 50;` `        `  `        ``// To store digits of result in` `        ``// reverse order` `        ``int` `[]res = ``new` `int``[MAX]; `   `        ``// Case 1: If number is smaller than 10` `        ``if` `(n < 10)` `        ``{` `            ``Console.WriteLine(n + 10);` `            ``return``;` `        ``}`   `        ``// Case 2: Start with 9 and try every` `        ``// possible digit` `        ``for` `(i = 9; i > 1; i--)` `        ``{` `            `  `            ``// If current digit divides n, then` `            ``// store all occurrences of current` `            ``// digit in res` `            ``while` `(n % i == 0)` `            ``{` `                ``n = n / i;` `                ``res[j] = i;` `                ``j++;` `            ``}` `        ``}`   `        ``// If n could not be broken in form of` `        ``// digits (prime factors of n` `        ``// are greater than 9)` `        ``if` `(n > 10)` `        ``{` `            ``Console.WriteLine(``"Not possible"``);` `            ``return``;` `        ``}`   `        ``// Print the result array in reverse order` `        ``for` `(i = j-1; i >= 0; i--)` `            ``Console.Write(res[i]);` `            `  `        ``Console.WriteLine();` `    ``}` `    `  `    ``// Driver program` `    ``public` `static` `void` `Main () ` `    ``{` `        ``findSmallest(7);` `        ``findSmallest(36);` `        ``findSmallest(13);` `        ``findSmallest(100);` `    ``}` `}`   `// This code is contributed by nitin mittal.`

## PHP

 ` 1; ``\$i``--)` `    ``{` `        `  `        ``// If current digit divides ` `        ``// n, then store all` `        ``// occurrences of current ` `        ``// digit in res` `        ``while` `(``\$n` `% ``\$i` `== 0)` `        ``{` `            ``\$n` `= ``\$n` `/ ``\$i``;` `            ``\$res``[``\$j``] = ``\$i``;` `            ``\$j``++;` `        ``}` `    ``}`   `    ``// If n could not be broken ` `    ``// in form of digits ` `    ``// (prime factors of n` `    ``// are greater than 9)` `    ``if` `(``\$n` `> 10)` `    ``{` `        ``echo` `"Not possible"``;` `        ``return``;` `    ``}`   `    ``// Print the result ` `    ``// array in reverse order` `    ``for` `(``\$i` `= ``\$j` `- 1; ``\$i` `>= 0; ``\$i``--)` `        ``echo` `\$res``[``\$i``];` `}`   `    ``// Driver Code` `    ``findSmallest(7);` `    ``echo` `"\n"``;`   `    ``findSmallest(36);` `    `  `    ``echo` `"\n"``;`   `    ``findSmallest(13);` `    ``echo` `"\n"``;`   `    ``findSmallest(100);`   `// This code is contributed by ajit` `?>`

## Javascript

 ``

Output:

```17
49
Not possible
455 ```

Time Complexity: O(log2n * 10)

Auxiliary Space: O(MAX)