数位之积

import java.util.*;


public class Solution {
    public int solution (int n) {
        String ans = "";
         for(int i = 9;i >= 2;i--){
                while(n!=1&&n%i==0){
                    ans = i+ans;
                    n/=i;
                }
                if(n==1) break;
        }
        if(n!=1) return -1;
        int res = Integer.parseInt(ans);
        return res;
    }
}

关键思想就是要从大到小遍历，因为要保证输出的位数越少越好，所以用越大的因子会用越少的位数除完，而相同的位数内，高位的数字越大，低位的就越小，倒序输出时的数就越小。
class Solution:
    def solution(self , n ):
        # write code here
        def search(n,temp):
            for i in range(9,1,-1):
                res = n/i
                if n%i==0:
                    temp = temp*10+i
                    if res==1:
                        b= 0
                        while temp !=0:
                            a = temp%10
                            b= b*10+a
                            temp = temp//10
                        return b

                    else:
                        return search(res,temp)
        temp=0
        return search(n,temp)

[编程题]数位之积
对于小于10的数n，输出1n。
对于大于10的数，需要分解为若干个个位数之积，数字的个数尽可能少。这个数字可以分解为以9，8，...，2的因子之积。然后从小到大输出即可。
我也写了第三题的答案，[编程题]vivo智能手机产能 只需两行 数学解法

class Solution {
public:
    /**
     * 输入一个整形数值，返回一个整形值
     * @param n int整型 n>9
     * @return int整型
     */
    int solution(int n) {
        // write code here
        if (n < 10) return 10 + n;
        int res = 0, base = 1;
        for (int i = 9; i > 1; i--) {
            while (n % i == 0) {
                res += i * base;
                base*=10;
                n /= i;
            }
        }
        if (n > 1) return -1;
        else return res;
    }
};

# 输入一个整形数值，返回一个整形值
(3783)# @param n int整型 n>9
# @return int整型
(3784)# 递归迭代 9-2 判断是否取余等于0，然后返回统计好的数 
class Solution:
    def solution(self , n ):
        # write code here
        r = self.Func(n)
        if r>0:
            return r
        return -1
    def Func(self,n):
        if n <10 :
            return n
        for i in range(9,1,-1):
            if n%i == 0 :
                return self.Func(n/i)*10+i;
        return -1

#评论里的大佬复刻版
class Solution:
    def solution(self,n):
        if n < 10:
            return 10 + n 
        else:
            res,base = 0,1
            for i in range(9,1,-1):#从9开始减，则个位肯定是最大的，后面逐渐递减，减到2（包括2）
                while(n % i == 0):
                    res = res + i * base
                    base = base *10
                    n = n / i
        
        if n > 1:#
            return -1
        else:
            return res
        
n = int(input())
s = Solution()
print(s.solution(n))   

function solution( n ) {
    // write code here
    let ans='';
    while(n!==1){
        let flag = false;
        for(let i=9; i>1; i--){
            if(n%i===0){
                ans = i+''+ans;
                n/=i;
                flag = true;
                break;
            }
        }
        if(!flag) return -1;
    }
    if(ans.length===0) return -1;
    else return Number(ans);
}

import java.util.*;
public class Solution {
    public int solution (int n) {
        int m = 0;
        for(int i=9,j=0;i>1;i--){ // 数值从9开始，从大到小
            if(n%i == 0){         // 找到其中一位商
                n /= i;
                m += (int)(i*Math.pow(10, j));
                i++;              // 有可能会有重复的数，继续判断
                j++;
            }
        }
        if(n == 1){
            return m;
        }else{
            return -1;
        }
    }
}

class Solution {
public:
    /**
     * 输入一个整形数值，返回一个整形值
     * @param n int整型 n>9
     * @return int整型
     */
    int solution(int n) {
        multiset<int,greater<int>> s;
        for(int i = 9; i >= 2; i--){
            while(n % i == 0){
                s.emplace(i);
                n /= i;
            }
        }
        if(n != 1)
            return -1;
        int res = 0;
        int tmp = 1;
        for(int x : s){
            res += x * tmp;
            tmp *= 10;
        }// write code here
        return res;
    }
};

import java.util.*;


    public class Solution {
        /**
         * 输入一个整形数值，返回一个整形值
         * @param n int整型 n>9
         * @return int整型
         */
        public static void main(String[] args) {
            Solution s = new Solution();
            System.out.println(s.solution(108));
        }
        //为什么要用long呢 因为按照从大到小搜索会得到例如9988776621
        //正确答案为1266778899,但是上面那个数已经大于integer表示范围了
        long res=Long.MAX_VALUE;
        long temp=0;
        public int solution (int n) {
            // write code here
            dfs(n,1l,9);
            //System.out.println(res);
            if(res==Long.MAX_VALUE)return -1;

            StringBuilder sb=new StringBuilder(Long.toString(res));
           // System.out.println(sb.toString());
            return Integer.parseInt(sb.reverse().toString());

        }
        private void  dfs(int n,long sum,int index){
            if(sum>=n){
                if(sum==n&&res>temp){
                    res=temp;
                }
                return;
            }
            if(res!=Long.MAX_VALUE)return;
            for(int i=index;i>=2;i--){

                temp=temp*10+i;
                dfs(n,sum*i,i);
                temp=(temp-i)/10;
            }
        }
    }

int solution(int n) {
		int sum = 0;
		int base = 1;  
		int tmp;    //存储被除数
		
		while (n > 1)
		{
			int flag = 0;  //一个数不能被2-9除, 直接return -1;
			for (int i = 9; i >= 2; i--)
			{
				if (n % i == 0) {
					tmp = i;
					sum = sum + base * tmp;
					base *= 10;
					flag = 1;   //该数可以被整除
					break;
				}
			}
			if (flag == 0) return -1;
			n = n / tmp;
		}
	
		return sum;
	}

n = int(input())
res = 0
base = 1
lis = [9,8,7,6,5,4,3,2]
if n < 10:
    res = 10 + n
else:
    for i in lis:
        while (n%i == 0):
            res += i*base
            base = base*10
            n = n/i
    if n > 1:
        res = -1
print(res)

import java.util.*;


public class Solution {
    /**
     * 输入一个整形数值，返回一个整形值
     * @param n int整型 n>9
     * @return int整型
     */
    public int solution (int n) {
        // write code here
        if(n<10)
            return 10+n;
        else{
            int m=0,base=1;
            while (n>9) {
                int i;
                for (i = 9; i > 1; i--) {
                    if (n % i == 0) {//能被整除
                        m=m+i*base;
                        base=base*10;
                        n=n/i;
                        break;
                    }
                }
                if(n>9&&i==1) //可能是一个不能被2-9整除的数 例如13
                    break;
            }
            if(n<=9){
                m=m+n*base;  //加上位数最高的那位
                return m;
            }else
                return -1;
        }
    }
}