【编程题目】寻找丑数

题目：我们把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。例如 6、8 都是丑数，
但 14 不是，因为它包含因子 7。习惯上我们把 1 当做是第一个丑数。
求按从小到大的顺序的第 1500 个丑数。

 

思路：

1.  数字从1递增，判断是不是丑数

2. 用2、3、5分别乘以已有的丑数，用大于当前的丑数的结果中最小的作为当前的丑数 快！

/* 
64.  寻找丑数（运算）。
题目：我们把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。例如 6、8 都是丑数，
但 14 不是，因为它包含因子 7。习惯上我们把 1 当做是第一个丑数。
求按从小到大的顺序的第 1500 个丑数。
*/
#include <stdio.h>
#include <stdlib.h>

int uglynum(int n) //输入要找第几个丑数
{
    long int i;
    int num = 1;
    for (i = 2; num < n; i++)
    {
        int flag = 0;
        int d = i;
        while (d != 1 && 0 == flag)
        {
            if (d % 2 == 0)
            {
                d = d/2;
            }
            else if (d % 3 == 0)
            {
                d = d/3;
            }
            else if (d % 5 == 0)
            {
                d = d/5;
            }
            else
            {
                flag = 1;
            }
        }
        if (0 == flag)
        {
            num++;
        }
    }
    return (i - 1);
}

int uglynum2(int n) //输入要找第几个丑数
{
    if (n == 1)
    {
        return 1;
    }
    int* data = (int *)malloc(n * sizeof(n));
    data[0] = 1;
    int b[3] = {2, 3, 5};
    for (int i = 1; i < n; i++)
    {
        int mintmp = 2 * data[i - 1]; //存储比上一个数字大的数中最小的那个 初始化这个数
        for(int m = 0; m < 3; m++)
        {    
            for (int j = 0; j < i; j++)
            {
                if (data[j] * b[m] > data[i - 1])
                {
                    if (data[j] * b[m] < mintmp)
                    {
                        mintmp = data[j] * b[m];
                    }
                    break;
                }
            }
        }
        data[i] = mintmp;
    }

    int ans = data[n - 1];
    free(data);
    return ans;
}
int main()
{
    //long int d = uglynum(1500);
    //d = uglynum2(1500);
    for (int i = 2; i <= 1500; i++)
    {
        int d = uglynum2(i);
        printf("第%d个丑数为：%d\n", i, d);
    }
    return 0;
}

 

网上看答案，发现自己写的不好，虽然思路一样，但是我写的看起来很乱。而且在方法二中我对 2 3 5都是从第一个数字开始乘，实际上可以用三个指针记录上一次乘到哪里了，下一次从记录位开始找就好了。

还有，有些子功能可以写成子函数，可以让整个代码看起来更清晰。

http://www.cnblogs.com/mingzi/archive/2009/08/04/1538491.html 里的代码就看起来很舒服。

方法一：

bool IsUgly(int number)
{
    while(number % 2 == 0)
        number /= 2;
    while(number % 3 == 0)
        number /= 3;
    while(number % 5 == 0)
        number /= 5;

    return (number == 1) ? true : false;
}

int GetUglyNumber_Solution1(int index)
{
    if(index <= 0)
        return 0;

    int number = 0;
    int uglyFound = 0;
    while(uglyFound < index)
    {
        ++number;

        if(IsUgly(number))
        {
           ++uglyFound;
        }
    }
    return number;
}

方法二：

int GetUglyNumber_Solution2(int index)
{
    if(index <= 0)
        return 0;

    int *pUglyNumbers = new int[index];
    pUglyNumbers[0] = 1;
    int nextUglyIndex = 1;

    int *pMultiply2 = pUglyNumbers;
    int *pMultiply3 = pUglyNumbers;
    int *pMultiply5 = pUglyNumbers;

    while(nextUglyIndex < index)
    {
        int min = Min(*pMultiply2 * 2, *pMultiply3 * 3, *pMultiply5 * 5);
        pUglyNumbers[nextUglyIndex] = min;
        while(*pMultiply2 * 2 <= pUglyNumbers[nextUglyIndex])
            ++pMultiply2;
        while(*pMultiply3 * 3 <= pUglyNumbers[nextUglyIndex])
            ++pMultiply3;
        while(*pMultiply5 * 5 <= pUglyNumbers[nextUglyIndex])
            ++pMultiply5;
        ++nextUglyIndex;
    }

    int ugly = pUglyNumbers[nextUglyIndex - 1];
    delete[] pUglyNumbers;
    return ugly;
}

int Min(int number1, int number2, int number3)
{
    int min = (number1 < number2) ? number1 : number2;
    min = (min < number3) ? min : number3;

    return min;
}