丑数I II

1.写一个程序来检测一个整数是不是丑数。

丑数的定义是，只包含质因子 2, 3, 5 的正整数。比如 6, 8 就是丑数，但是 14 不是丑数以为他包含了质因子 7

可以认为 1 是一个特殊的丑数。

public class Solution {
    /**
     * @param num an integer
     * @return true if num is an ugly number or false
     */
    public boolean isUgly(int num) {
        // Write your code here
        if (num <= 0){
            return false;
        }
        while (num % 2 == 0){
            num = num / 2;
        }
        while (num % 3 == 0){
            num = num / 3;
        }
        while (num % 5 == 0){
            num = num / 5;
        }
        if (num == 1){
            return true;
        }
        else {
            return false;
        }
    }
}

2.

设计一个算法，找出只含素因子2，3，5 的第 n 大的数。

符合条件的数如：1, 2, 3, 4, 5, 6, 8, 9, 10, 12...

 注意事项

我们可以认为1也是一个丑数

样例    如果n = 9， 返回 10

class Solution {
    /**
     * @param n an integer
     * @return the nth prime number as description.
     */
    public int nthUglyNumber(int n) {
        // Write your code here
        int[] uglyNum = new int[n];
        uglyNum[0] = 1;
        int num2 = 0;//用来标记*2/3/5的数的在数组中的下标
        int num3 = 0;
        int num5 = 0;
        for(int i=1; i<n; i++){
            uglyNum[i] = Math.min(uglyNum[num2]*2,Math.min(uglyNum[num3]*3,uglyNum[num5]*5));
            if(uglyNum[i] == uglyNum[num2]*2)//这里不能用if...else 因为可能有多个种子，eg 6=2*3，num2,num3都要++
              num2++;
            if(uglyNum[i] == uglyNum[num3]*3)
              num3++;
            if(uglyNum[i] == uglyNum[num5]*5)
              num5++;
        }
        return uglyNum[n-1];
    }
};


3.

写一个程序来找第 n 个超级丑数。

超级丑数的定义是正整数并且所有的质数因子都在所给定的一个大小为 k 的质数集合内。

比如给你 4 个质数的集合 [2, 7, 13, 19], 那么[1, 2, 4, 7, 8, 13, 14, 16, 19, 26, 28, 32] 是前 12 个超级丑数。

 注意事项

• 1 永远都是超级丑数不管给的质数集合是什么。
• 给你的质数集合已经按照升序排列。
• 0 < k ≤ 100, 0 < n ≤ 10^6, 0 < primes[i] < 1000

样例  给出 n = 6 和质数集合 [2, 7, 13, 19]。第 6 个超级丑数为 13，所以返回 13 作为结果。

public class Solution {
    /**
     * @param n a positive integer
     * @param primes the given prime list
     * @return the nth super ugly number
     */
    public int nthSuperUglyNumber(int n, int[] primes) {
        // Write your code here
        int[] uglyNumber = new int[n];
        uglyNumber[0] = 1;
        int[] factor = new int[primes.length];
        for(int m = 0;m<primes.length;m++){
            factor[m]=0;//保存与因子相乘的数的数组下标
        }
        int min;
        for(int i =1;i<n;i++){
            min = uglyNumber[factor[0]]*primes[0];
            for(int j =1;j<primes.length;j++){
                int temp  = Math.min(uglyNumber[factor[j]]*primes[j],min);
                min = temp;
            }
            uglyNumber[i] = min;
            for(int k =0;k<primes.length;k++){
                if(min == uglyNumber[factor[k]] * primes[k])
                   factor[k]++;
            }
        }
        return uglyNumber[n-1];
    }
}