1. 编程输入一个自然数m，在1~m之间寻找因子个数最多的数。
输入示范：
50
输出示范：
1-50之间，48的因子数为10，最多

#include <stdio.h>

int fun(int n)
{
    int c=0,i=1;
    for(;i<=n;i++)
    {
        if(n%i==0)  c++;
    }
    return c;
}

int main()
{
    int m=0,i=1,k=0,tmp=0,result=0;
    scanf("%d",&m);

    for(;i<=m;i++)
    {
        tmp=fun(i);
        if(k<tmp)
        {
            k=tmp;
            result=i;
        }
    }

    printf("%d\n",result);
    return 0;
}

#include <stdio.h>
main()
{
    int m, count=0, max=1;
    printf("Input m: ");
    scanf("%d", &m);
    for (int i=1; i<=m; i++)
    {
        count = 0;
        for (int j=1; j<=i; j++)
            if (i%j == 0) count++;
        if (count > max) max = count;
    }
    for (int i=1; i<=m; i++)
    {
        count = 0;
        for (int j=1; j<=i; j++)
            if (i%j == 0) count++;
        if (count == max)
            printf("%d %d\n", i, count);
    }
}

首先要找到原题，因为水平原因，转述者总喜欢将自己无法理解的部分省略掉，从而和原意相左。
找到几个类似的原题：
http://
http://www.

可见，这道题还是有那么一点儿难度了，时间换空间简单，空间换时间也简单，这道题难就难在优化手段上

1 000 000 000数据范围要在2秒内找出因数最多的那个，估计要用类似筛法找素数的算法建立因数计数表，然后查表完成。

期待分享优化经验
编程序不难，编得更好的程序不易。

试优化了一下，1,000,000 还可以，1,000,000,000就不敢试了。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

//#define PRINTF  1
#define PRINTF  0

typedef struct result
{
    int n;
    int count;
} RESULT, *PRESULT;

int _Factors(int n)
{
#if PRINTF == 1
    printf("因子数：%d ", 1);
#endif

    if (n == 1)
    {
        return 1;
    }

    int count = 2;
    int sqrt_n = (int)sqrt(n);

    for (int i = 2; i <= sqrt_n; i++)
    {
        if (n % i == 0)
        {
#if PRINTF == 1
            printf("%d ", i);
#endif

            if(i == sqrt_n)
            {
                if (n / i == i)
                {
                    count++;
                }
                else
                {
                    count += 2;

#if PRINTF == 1
                    printf("%d ", n / i);
#endif
                }
            }
            else
            {
                count += 2;

#if PRINTF == 1
                printf("%d ", n / i);
#endif
            }
        }
    }

#if PRINTF == 1
    printf("%d \n", n);
#endif

    return count;
}

main()
{
    int m;
    printf("输入一个正整数 m: ");
    scanf("%d", &m);
    printf("正整数 %d 的因子数个数为 %d\n", m, _Factors(m));

#if PRINTF == 0
    int count;
    PRESULT p;
    p = (PRESULT)malloc(2*sizeof(RESULT));
    p->n = 1;
    (p+1)->n = 1;
    (p+1)->count = 1;

    for (int i = 2; i <= m; i++)
    {
        count = _Factors(i);

        if (count > (p+1)->count)
        {
            p = (PRESULT)realloc(p, 2*sizeof(RESULT));
            p->n = 1;
            (p+1)->n = i;
            (p+1)->count = count;
        }
        else if (count == (p+1)->count)
        {
            p->n += 1;
            p = (PRESULT)realloc(p, (p->n + 1)*sizeof(RESULT));
            (p+p->n)->n = i;
            (p+p->n)->count = count;
        }
    }
    printf("1...%d 中因子数个数最多的为:\n", m);
    for (int i=1; i<=p->n; i++)
    {
        printf("%d 有%d个因子数\n", (p+i)->n, (p+i)->count);
    }
    free(p);
#endif
}

这肯定不是最优方法，下面是我的代码，经测试速度比你的快，在只判断偶数的情况下，我代码速度比你的快1倍，如果全部判断则比你的快300毫秒（1--1000000）：

#include "stdio.h"
#include <time.h>
int yinshu(int n)
{
    int i,j;
    for(i=1,j=0;i*i<n;i++)if(n%i==0)j++;;
    j*=2;           //通常因数个数为偶数个
    if(i*i==n)j++;  //能正好开平方的因数数量为奇数个
    return j;
}
void main()
{
    int l,u,j,k,m,t;
    while(1)
    {
        scanf("%d%d",&l,&u); //输入数据范围，有一个数为0即退出死循环
        if(!(l&&u))break;
        t=clock();
        for(m=l,k=0;l<=u;l++)
        {
            j=0;
            //j=yinshu(l);
            if(l%2==0)j=yinshu(l);  //只判断偶数，最多因数只存在于偶数
            //printf("%3d,%3d----",l,j);
            if(j>k)
            {
                m=l;
                k=j;
            }
        }
        t=clock()-t;
        printf("max---%d,%d,用时%d毫秒\n",m,k,t);
        l=u=0;
    }
}

实际上，这个还是要用数学的方法解决。查了下资料，一个数的因数个数是质因数的幂+1的乘积，如48=2*2*2*2*3=2^4+3^1，其因数数量为（4+1）*（1+1）=5*2=10个，由此得到以下一些规律：
1，在给定的数据范围内，能分解因数最多的是偶数。
2，分解质因数最多的数只包含质因数2、3、5，通常只包含2、3，因为5>2^2，前者只能让因数的数量增加一倍，而后者能让因数的数量增加3倍，但在一些特殊数据范围里，有包含质因数5的数因数最多，如85/90。
3，通常数据大的能分解的因数多，因此倒着查可能效率高些。
4，最大质因数不超过sqrt(数据范围内最大数）
5，不一定非要从最小的数开始爆破，如数据范围是1--1000000000，肯定不是从1开始，需要用数学的方法确定数据范围最小的数，我想到的是求最大质因数范围内所有质数的积，如范围为1--100，最大质因数不大于10，小于10的质数为7，因此质因数的乘积是2*3*5*7=210>100，则最小数应该是1、2*3*5=30，因数个数为2*2*2=8；2；（2*3）^2=36,因数个数为3*3=9，大于30的因数个数，因此最小数从36开始，即查1--100范围内的最多因数实际上只需要从36开始查，即查36--100即可。

[此贴子已经被作者于2016-6-5 08:12编辑过]

试了一下，你的是只求其中一个最多因子数的，我的是求所有最多因子数（如1..10有3个（6、8、10）都有4个因子数），不可比。