求整数因子算法

[baidu01]

对于一个整数，求出它的所有因子，如12=2*2*3

[光宇广贞]

好办，求出质数表，然后一个一个去除！

[ameyume]

关注ing

[Walf_ghoul]

实现了个，附上代码，以供参考：

/*
author:Walf_GHOUL
实现功能：1.输入一个整数base，获得获得小于等于base的所有质数
2.将base分解成若干个质数相乘并输出
*/
#include <iostream>
#include <math.h>

using namespace std;

int* GetDivisor(int base);            //获得小于等于base的所有质数

int GetFirstTrue(int i,bool* a ,int base);      //获得第一个值为true的下表

int main()
{
    int base = 2;
    cout << "输入一个整数：";
    cin >> base;
    int* a = GetDivisor(base);   //a存储质数表
    cout << "分解结果为：";
    if(base == a[base-1])          //如果输入的数是质数，输出
    {
        cout << base <<"="<<1<<'*'<<base<<endl;
    }
    else             //如果不是质数，寻找质数因子
    {
        bool check = true;
        int i = 1;
        int temp = base;
        cout << base << " = ";
        for( int j = 0 ;j<base;j++)
        {
            if(a[i] > 0 && (temp % a[i]) == 0)    //如果该质数是因子输出
            {
                cout << a[i];
                if(a[i] != temp)
                {
                    cout<<"*";
                }
                temp = temp / a[i];      //改变被除数，从2开始重新寻找因子
                i = 1;
            }

            else
            {
                i++;
            }
        }
    }

    delete[] a;
	return 0;
}

int GetFirstTrue(int i,bool* a ,int base)
{
    for(int j = i+1;j<base;j++)
    {
        if(a[j] == true)
        return j;
    }
    return 0;
}

int* GetDivisor(int base)
{
    int* a = new int[base];
    bool* flag = new bool[base];
    int i,j;
    for(i = 0 ; i < base ; i++)
    {
        a[i] = i+1;
        flag[i] = true;
    }
    for( i = 0; i< base;i++)
    {
        j = GetFirstTrue(i,flag,base);
        if(j!=0)
        {
            for( int k = j+1; k < base ; k++)
            {
                if(a[k] % a[j] == 0)
                {
                    flag[k] = false;
                    a[k] = 0;
                }
            }
        }
    }
    delete[] flag;
    return a;
}

结果：
输入一个整数：12
分解结果为：12 = 2*2*3
Process returned 0 (0x0) execution time : 2.453 s
Press any key to continue.

[Walf_ghoul]

修改一下循环结束条件，使效率提高

/*
author:Walf_GHOUL
实现功能：1.输入一个整数base，获得获得小于等于base的所有质数
2.将base分解成若干个质数相乘并输出
*/
#include <iostream>
#include <math.h>

using namespace std;

int* GetDivisor(int base);            //获得小于等于base的所有质数

int GetFirstTrue(int i,bool* a ,int base);      //获得第一个值为true的下表

int main()
{
    int base = 2;
    cout << "输入一个整数：";
    cin >> base;
    int* a = GetDivisor(base);   //a存储质数表
    cout << "分解结果为：";
    if(base == a[base-1])          //如果输入的数是质数，输出
    {
        cout << base <<"="<<1<<'*'<<base<<endl;
    }
    else             //如果不是质数，寻找质数因子
    {
        bool check = true;
        int i = 1;
        int temp = base;
        cout << base << " = ";
        while( temp > 1)         // 若被除数为1，说明已经完全分解了        {
            if(a[i] > 0 && (temp % a[i]) == 0)    //如果该质数是因子输出
            {
                cout << a[i];
                if(a[i] != temp)
                {
                    cout<<"*";
                }
                temp = temp / a[i];      //改变被除数，从2开始重新寻找因子
                i = 1;
            }

            else
            {
                i++;
            }
        }
    }

    delete[] a;
	return 0;
}

int GetFirstTrue(int i,bool* a ,int base)
{
    for(int j = i+1;j<base;j++)
    {
        if(a[j] == true)
        return j;
    }
    return 0;
}

int* GetDivisor(int base)
{
    int* a = new int[base];
    bool* flag = new bool[base];
    int i,j;
    for(i = 0 ; i < base ; i++)
    {
        a[i] = i+1;
        flag[i] = true;
    }
    for( i = 0; i< base;i++)
    {
        j = GetFirstTrue(i,flag,base);
        if(j!=0)
        {
            for( int k = j+1; k < base ; k++)
            {
                if(a[k] % a[j] == 0)
                {
                    flag[k] = false;
                    a[k] = 0;
                }
            }
        }
    }
    delete[] flag;
    return a;
}

[Walf_ghoul]

本来想加个下划线的-_-||

[guocai_yao]

mark

[adventurelw]

其实只需要获得小于等于给定数的1/2的素数就可以了。

[子瓜个个]

实际上，更有效的方法，只需要循环到小于等于给定数的开方的素数就可以了。一次记下两个因子——除数和商。

[棋盗]

#include<iostream.h>
#include <math.h>
int main()
{
void qiuyinzi(int a,int*p);
int a,s[100];
cout << "输入一个整数：";
cin>>a;
cout<<a<<"=";
qiuyinzi(a,s);
return 0;
}

void qiuyinzi(int a,int*p)
{int b,c; double t;
c=a; t=sqrt(a);
for(b=2;b<=a;b++)
{if((a%b)==0)
{a=a/b;*p=b;cout<<*p<<"*";p++;qiuyinzi(a,p);}

if(a!=c) break;
}

}





速度就不知道了，写得简单了点，能实现。

[adventurelw]

[Quote=引用 8 楼 jqzwin 的回复:]
实际上，更有效的方法，只需要循环到小于等于给定数的开方的素数就可以了。一次记下两个因子——除数和商。
[/Quote]

但你仍然需要判断两个因子是否都是素数啊。。。。。而一个数，除去其本身，是不会出现大于其1/2的因子的。
所以，对素数的判断，至少需要进行到数的1/2处。

[mu_yang]

素数 = 2 ;
while(整数>=素数)
{
if( 整数 % 素数 == 0)
{
输出 素数;
整数 /= 素数 ;
if (整数==1)break;
输出 '*';
}
else
素数 ++ ;
}

[mu_yang]

题目有些不严谨
对于一个正整数，将它分解为质数因子的积

[UpdateEveryday]

easy

#include <stdio.h>

void main(void)
{
	int num = 1024; /* sample # */
	int count = 2;

	printf("\n %d = ",num);
	
	while(num >= count)
	{

		if (!(num % count))
		{
			printf(" %d * ",count);
			num = num / count;
		}
		else 
		{
			count++;
		}
	}
	printf("\b\b \n\n");
}