Smallest number k such that the product of digits of k is equal to n

Given a non-negative number n. The problem is to find the smallest number k such that the product of digits of k is equal to n. If no such number k can be formed then print “-1”.
Examples:

Input : 100
Output : 455
Explanation: 4*5*5 = 100 and 455 is the
smallest possible number.

Input : 26
Output : -1

Source: Asked in Amazon Interview

Approach: For each i = 9 to 2, repeatedly divide n by i until it cannot be further divided or the list of numbers from 9 to 2 gets finished. Also, in the process of division push each digit i onto the stack which divides n completely. After the above process gets completed check whether n == 1 or not. If not, then print “-1”, else form the number k using the digits from the stack containing the digits in the same sequence as popped from the stack. 

C++

// C++ implementation to find smallest number k such that
// the product of digits of k is equal to n
#include <bits/stdc++.h>

using namespace std;

// function to find smallest number k such that
// the product of digits of k is equal to n
long long int smallestNumber(int n)
{
    // if 'n' is a single digit number, then
    // it is the required number
    if (n >= 0 && n <= 9)
        return n;

    // stack the store the digits
    stack<int> digits;

    // repeatedly divide 'n' by the numbers
    // from 9 to 2 until all the numbers are
    // used or 'n' > 1
    for (int i=9; i>=2 && n > 1; i--)
    {
        while (n % i == 0)
        {
            // save the digit 'i' that divides 'n'
            // onto the stack
            digits.push(i);
            n = n / i;
        }
    }

    // if true, then no number 'k' can be formed
    if (n != 1)
        return -1;

    // pop digits from the stack 'digits'
    // and add them to 'k'
    long long int k = 0;
    while (!digits.empty())
    {
        k = k*10 + digits.top();
        digits.pop();
    }

    // required smallest number
    return k;
}

// Driver program to test above
int main()
{
    int n = 100;
    cout << smallestNumber(n);
    return 0;
}

Java

//Java implementation to find smallest number k such that
// the product of digits of k is equal to n
import java.util.Stack;

public class GFG {

// function to find smallest number k such that
// the product of digits of k is equal to n
    static long smallestNumber(int n) {
        // if 'n' is a single digit number, then
        // it is the required number
        if (n >= 0 && n <= 9) {
            return n;
        }

        // stack the store the digits
        Stack<Integer> digits = new Stack<>();

        // repeatedly divide 'n' by the numbers
        // from 9 to 2 until all the numbers are
        // used or 'n' > 1
        for (int i = 9; i >= 2 && n > 1; i--) {
            while (n % i == 0) {
                // save the digit 'i' that divides 'n'
                // onto the stack
                digits.push(i);
                n = n / i;
            }
        }

        // if true, then no number 'k' can be formed
        if (n != 1) {
            return -1;
        }

        // pop digits from the stack 'digits'
        // and add them to 'k'
        long k = 0;
        while (!digits.empty()) {
            k = k * 10 + digits.peek();
            digits.pop();
        }

        // required smallest number
        return k;
    }

// Driver program to test above
    static public void main(String[] args) {
        int n = 100;
        System.out.println(smallestNumber(n));
    }
}

/*This code is contributed by PrinciRaj1992*/

Python3

# Python3 implementation to find smallest
# number k such that the product of digits
# of k is equal to n
import math as mt

# function to find smallest number k such that
# the product of digits of k is equal to n
def smallestNumber(n):

    # if 'n' is a single digit number, then
    # it is the required number
    if (n >= 0 and n <= 9):
        return n

    # stack the store the digits
    digits = list()

    # repeatedly divide 'n' by the numbers
    # from 9 to 2 until all the numbers are
    # used or 'n' > 1
    for i in range(9,1, -1):

        while (n % i == 0):

            # save the digit 'i' that
            # divides 'n' onto the stack
            digits.append(i)
            n = n //i

    # if true, then no number 'k'
    # can be formed
    if (n != 1):
        return -1

    # pop digits from the stack 'digits'
    # and add them to 'k'
    k = 0
    while (len(digits) != 0):

        k = k * 10 + digits[-1]
        digits.pop()

    # required smallest number
    return k

# Driver Code
n = 100
print(smallestNumber(n))

# This code is contributed by
# Mohit kumar 29

C#

// C# implementation to find smallest number k such that
// the product of digits of k is equal to n
using System;
using System.Collections.Generic;
public class GFG {

// function to find smallest number k such that
// the product of digits of k is equal to n
    static long smallestNumber(int n) {
        // if 'n' is a single digit number, then
        // it is the required number
        if (n >= 0 && n <= 9) {
            return n;
        }

        // stack the store the digits
        Stack<int> digits = new Stack<int>();

        // repeatedly divide 'n' by the numbers
        // from 9 to 2 until all the numbers are
        // used or 'n' > 1
        for (int i = 9; i >= 2 && n > 1; i--) {
            while (n % i == 0) {
                // save the digit 'i' that divides 'n'
                // onto the stack
                digits.Push(i);
                n = n / i;
            }
        }

        // if true, then no number 'k' can be formed
        if (n != 1) {
            return -1;
        }

        // pop digits from the stack 'digits'
        // and add them to 'k'
        long k = 0;
        while (digits.Count!=0) {
            k = k * 10 + digits.Peek();
            digits.Pop();
        }

        // required smallest number
        return k;
    }

// Driver program to test above
    static public void Main() {
        int n = 100;
        Console.Write(smallestNumber(n));
    }
}

/*This code is contributed by Rajput-Ji*/

PHP

<?php
// PHP implementation to find smallest number k such that
// the product of digits of k is equal to n

// function to find smallest number k such that
// the product of digits of k is equal to n
function smallestNumber($n)
{
    // if 'n' is a single digit number, then
    // it is the required number
    if ($n >= 0 && $n <= 9)
        return $n;

    // stack the store the digits
    $digits = array();

    // repeatedly divide 'n' by the numbers
    // from 9 to 2 until all the numbers are
    // used or 'n' > 1
    for ($i = 9; $i >= 2 && $n > 1; $i--)
    {
        while ($n % $i == 0)
        {
            // save the digit 'i' that divides 'n'
            // onto the stack
            array_push($digits,$i);
            $n =(int)( $n / $i);
        }
    }

    // if true, then no number 'k' can be formed
    if ($n != 1)
        return -1;

    // pop digits from the stack 'digits'
    // and add them to 'k'
    $k = 0;
    while (!empty($digits))
        $k = $k * 10 + array_pop($digits);

    // required smallest number
    return $k;
}

    // Driver code
    $n = 100;
    echo smallestNumber($n);

// This code is contributed by mits
?>

Javascript

<script>

// Javascript implementation to find
// smallest number k such that
// the product of digits of k is equal to n

    // function to find smallest number k such that
// the product of digits of k is equal to n
    function smallestNumber(n)
    {
        // if 'n' is a single digit number, then
        // it is the required number
        if (n >= 0 && n <= 9) {
            return n;
        }

        // stack the store the digits
        let digits = [];

        // repeatedly divide 'n' by the numbers
        // from 9 to 2 until all the numbers are
        // used or 'n' > 1
        for (let i = 9; i >= 2 && n > 1; i--) {
            while (n % i == 0) {
                // save the digit 'i' that divides 'n'
                // onto the stack
                digits.push(i);
                n = Math.floor(n / i);
            }
        }

        // if true, then no number 'k' can be formed
        if (n != 1) {
            return -1;
        }

        // pop digits from the stack 'digits'
        // and add them to 'k'
        let k = 0;
        while (digits.length!=0) {
            k = k * 10 + digits[digits.length-1];
            digits.pop();
        }

        // required smallest number
        return k;
    }

    // Driver program to test above
    let n = 100;
    document.write(smallestNumber(n));


// This code is contributed by patel2127

</script>

Output

455

Time Complexity: O(log N)
Space Complexity: O(log N)

We can store the required number k in string for large numbers as shown below.

Also, the above approach can be space optimized if we store our answer directly in a string and return the reverse of it as the final answer.

C++

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

string getSmallest(ll N) {

    string ans;

    for(int i=9;i>=2 && N>1;i--)
    {
        while(N%i==0)
        {
            ans.push_back(i+48);
            N/=i;
        }
    }

    if(N!=1)
    return "-1";
    else if(ans.length()==0)
    return "1";

    reverse(ans.begin(),ans.end());

    return ans;
    }

// driver's code
int main()
{
    ll N=100;
    cout<<getSmallest(N);
    return 0;
}
// this code is contributed by prophet1999

Java

import java.util.*;

public class Main {
    public static String getSmallest(long N) {
        String ans = "";
        for (int i = 9; i >= 2 && N > 1; i--) {
            while (N % i == 0) {
                ans += (char)(i + '0');
                N /= i;
            }
        }
        if (N != 1) {
            return "-1";
        } else if (ans.length() == 0) {
            return "1";
        }
        return new StringBuilder(ans).reverse().toString();
    }

    public static void main(String[] args) {
        long N = 100;
        System.out.println(getSmallest(N));
    }
}

Python3

def getSmallest(N):
    ans = ""

    for i in range(9, 1, -1):
        while N > 1 and N % i == 0:
            ans += str(i)
            N //= i

    if N != 1:
        return "-1"
    elif len(ans) == 0:
        return "1"

    return ans[::-1]

# driver's code
if __name__ == '__main__':
    N = 100
    print(getSmallest(N))

C#

using System;

public class Program
{
  static string GetSmallest(int N)
  {
    string ans = "";

    for (int i = 9; i > 1; i--)
    {
      while (N > 1 && N % i == 0)
      {
        ans += i.ToString();
        N /= i;
      }
    }

    if (N != 1)
    {
      return "-1";
    }
    else if (ans.Length == 0)
    {
      return "1";
    }

    char[] charArray = ans.ToCharArray();
    Array.Reverse(charArray);
    return new string(charArray);
  }

  // driver's code
  public static void Main()
  {
    int N = 100;
    Console.WriteLine(GetSmallest(N));
  }
}

// this code is contributed by shivhack999

Javascript

function getSmallest(N) {
  let ans = "";

  for (let i = 9; i > 1; i--) {
    while (N > 1 && N % i === 0) {
      ans += i.toString();
      N /= i;
    }
  }

  if (N !== 1) {
    return "-1";
  } else if (ans.length === 0) {
    return "1";
  }

  return ans.split("").reverse().join("");
}

// driver's code
const N = 100;
console.log(getSmallest(N));

Output

455

Time Complexity: O(log N)

Auxiliary Space: O(1)

This article is contributed by Ayush Jauhari and improved by @prophet1999. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.