Question

演习是：

设计一个程序，查找从1到1000的所有数字，其素数因子加在一起时，总和为素数（例如，12的素数因子为2,2和3，总和为7，其中是素数）。实现该算法的代码。

我应该使用非常基础的C ++，包括else/if, while and for loops，当然还要声明一些函数。

无论像2,3,5这样的小案例，我仍然没有得到正确的输出。输出是：

6 (sum of factors is 5 : OK)
8 (sum of factors is 6 : WRONG)
10 (sum of factors is 7: OK)
12 (sum of factors is 7: OK)
14 (sum of factors is 9: WRONG)
15 (sum of factors is 8: SO WRONG..)

等。

#include <iostream>
#include <math.h>

using namespace std;

bool CheckPrime (int x)
{
    int count=0;
    for(int i=1; i<=x; i++)
    {
        if( x%i==0 )
        {count++;}
    }
    if ( count==2 )
    {return true;}
    else
    {return false;}

}

int MakeSum (int x)
{
    int Sum = 0;
    for (double i=2; i<sqrt(x); i++)
    {
        if (CheckPrime(i))
        {
            for (double j=1; j<1000; j++)
            {
                int k = pow( i, j);
                if ( (x % k) == 0 )
                {
                    Sum = Sum + i;
                }
            }
        }
    }
    return Sum;
}

int main() // Output cac so tim dc.
{
    int SUM = 0;
    for (int i=0; i < 1001; i++)
    {
        SUM = MakeSum(i);
        if (CheckPrime(SUM))
        {
            cout << i << '\n';
            SUM = 0;
        }
    }
}

Answer 1

makeum功能如何？

makesum(int k)
{
int i;
if(checkprime(k))
{
    return k;
}
for(i=2;i<=(k/2);i++)
{
    if(k%i==0 && checkprime(i))
    {
        int y=k/i;
        sum=i+makesum(y);
    }
}
return sum;
}

Answer 2

这是一个确定数字是否为素数的简单函数：

function isPrime(n)
    d := 2
    while d * d <= n
        if n % d == 0
            return False
        d := d + 1
    return True

这里有一个类似的函数来确定数字的素因子：

function factors(n)
    f, fs := 2, []
    while f * f <= n
        if n % f == 0
            append f to fs
            n := n / f
        else f := f + 1
    append n to fs
    return fs

我会留给你翻译成C ++并编写循环和逻辑来完成练习。

Answer 3

这是一些伪代码。首先，我将定义一个函数，该函数返回除1之外的数字的最小因子，如果数字为素数，则返回0。

def FindFactor(x)
  for i from 2 to sqrt(x)
    if x%i==0
      return i
  return 0

现在，我们可以非常轻松地检查数字是否为素数。这在您的主要方法中很有用。

def CheckPrime(x)
  return !FindFactor(x)

最后，我们进行总和计算。递归执行它的优点是通过缓存较小的结果很容易获得一些速度优势：

def MakeSum(x)
  factor1 = FindFactor(x)
  if !factor1
    return x
  factor2 = x / factor1
  return factor1 + MakeSum(factor2)

在MakeSum的每次通话中，我们都会找到该数字的最小因子。如果是素数，则返回数字本身。否则，递归最小因子和原始数除以最小因子。

实际上，既然我们知道最小的因素已经是素数，我就不用费心了。这会将其转换为尾调用递归，因此假设合理的编译器，我们不必担心堆栈深度。

对数字进行因式分解并检查总和的素数

3 个答案: