寻找素因子的C程序，编译不会停止

我用来计算最大素因子600851475143的程序在编译和执行期间被卡住了，而且从未停止过。有人知道为什么它没有完成执行吗

#include <stdio.h> //Edited the #includes(typo) to #include 
 int main (void)
{

    long long int num = 600851475143 ;
    long long int factorCount;
    long long int bigFactor;

    for ( long long int i=1 ; i <= num; i+=2 )// Iterating through all numbers from 2, smaller than or equal to num
    {
        if ( num % i == 0) // If the number "i" is a factor of num i.e. If "i" perfectly divides num
        {
            factorCount = 0;
            //checking whether a factor "i" , is a prime factor of num
            for ( long long int j=2; j <= i ; j++  ) // Iterating through all numbers from 2, smaller than or equal to "i"
            {
                if ( i % j == 0) // If the number "j" prefectly divides or is a factor of "i"
                {
                    factorCount++; //Add 1 to factorCount
                };
            };

            if ( factorCount == 1 ) // If factorCount has not exceeded 1 i.e., the number "i" is a prime number
            {
                bigFactor = i;
            };
        };

    };
    printf("The largets prime factor of %lli is %lli\n",num,bigFactor );

    return 0;
}

#include//将#include（打字）编辑为#include
内部主（空）
{
long-long-int-num=600851475143；
长整型因子计数；
长整型因子；
对于（long-long-int i=1；i它完成了它的执行，只需要花费很多时间。
您正在执行600851475143/2次循环或大约3000亿次循环。如果主循环需要1ms才能执行（但由于存在另一个内部循环，因此应该需要更多时间），则意味着所需时间大约为9.5年

耐心一点，你的循环就会结束。
试试这个：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 int main (void)
{

    long long int num = 600851475143 ;
    long long int factorCount;
    long long int bigFactor;
    for ( long long int i=1 ; i <= sqrt(num); i+=2 )// Iterating through all numbers from 2, smaller than or equal to num
    {
        if ( num % i == 0) // If the number "i" is a factor of num i.e. If "i" perfectly divides num
        {
            factorCount = 0;
            //checking whether a factor "i" , is a prime factor of num
            for ( long long int j=2; j <= i ; j++  ) // Iterating through all numbers from 2, smaller than or equal to "i"
            {
                if ( i % j == 0) // If the number "j" prefectly divides or is a factor of "i"
                {
                    factorCount++; //Add 1 to factorCount
                };
            };

            if ( factorCount == 1 ) // If factorCount has not exceeded 1 i.e., the number "i" is a prime number
            {
                bigFactor = i;
            };
        };

    };
    printf("The largets prime factor of %lli is %lli\n",num,bigFactor );

    return 0;
}

#包括
#包括
#包括
内部主（空）
{
long-long-int-num=600851475143；
长整型因子计数；
长整型因子；
对于（long-long-int i=1；i嗯，我最好的猜测是它运行得非常好，但需要太多时间。
所以你要做的就是优化你的算法。
以下是一些改进算法的提示：


你只需要迭代到一个数字的平方根，就可以知道它是否是素数
正如您在外部循环中所做的那样（但不是在内部循环中），您只需迭代奇数即可
既然你在寻找最高的素数因子，试着从头开始，一旦你找到了一个素数因子，就停止寻找

我认为这应该在合理的时间内完成

编辑：事实上，反射后的第三点并不那么明显。当然，这比通过所有因素要好，但对于大因素，计算速度要慢得多…
下午好24

这段代码的运行时间将非常长，非常长。但它应该可以工作，唯一真正的错误是中的's'

#includes <stdio.h> 

#包括

所以要有耐心，你要处理的是非常大的数字，通过奇数的迭代使它的长度大大减少了，唐

注意：如果您使用的是在线IDE，如cpp.sh或其他来源，则网站很可能会超时。请使用本地安装的IDE。
我不确定是否理解您的问题。因此，您只想获得某个数字的最大主因子？如果是这种情况，请执行以下操作：

#include <stdio.h>

#define NUMBER 600851475143

int main (void)
{
    long long int num = NUMBER;
    long long int factor;

    for (factor=2 ; num != 1; factor++) {
        if (num % factor == 0) {
            num = num / factor;
            factor = factor-1;
        }
    }
    printf("The largets prime factor of %lli is %lli\n",NUMBER, factor);
    return 0;
}

#包括
#定义编号600851475143
内部主（空）
{
long-long-int-num=数字；
长整型因子；
对于（系数=2；数值！=1；系数++）{
如果（num%因子==0）{
num=num/系数；
因子=因子-1；
}
}
printf（“%lli的最大素数因子是%lli\n”，数字，因子）；
返回0；
}

原因：你找到的第一个素数因子是这个数中最小的素数因子，最后一个素数因子是最大的。因此，一旦你找到了一个素数因子p，就不存在一个小于p的素数因子，因为否则你以前会发现更小的素数因子。因此你的下一个素数因子是更大的等式als p.
这是合理有效的：

#include <stdio.h>

#define NUMBER 600851475143

static unsigned long long int gpf(unsigned long long n)
{
    unsigned long long d, q;

    while (n > 2 && !(n & 1))
        n >>= 1;

    d = 3;
    while (d * d <= n) {
        q = n / d;
        if (q * d == n)
            n = q;
        else
            d += 2;
    }

    return n;
}

int main(void)
{
    printf("The largest prime factor of %llu is %llu\n",
           NUMBER, gpf(NUMBER));
    return 0;
}

#包括
#定义编号600851475143
静态无符号长整型gpf（无符号长整型n）
{
无符号长d，q；
而（n>2&！（n&1））
n>>=1；
d=3；
虽然（d*d在编译和执行过程中从不停止——这是两件截然不同的事情。如果它在编译过程中从不停止，你甚至永远也不会达到执行。至于在执行过程中从不停止……你要求了很多循环。从不是一个很长的时间，你没有等待足够长的时间来确定它永远不会停止。你的方法因为这个原因，确定一个数字是否为素数是不合理的。它甚至可以编译吗？#includes？正如你所知，600851475143是素数，所以这个程序将运行很长时间。（在进行强力因子分解时，首先要采取的捷径之一是尝试候选因子，其最大值为所分解数字的平方根。因此，您可以使用“仅”387573循环，而不是300425737571。）看起来你的程序大部分都在工作，但是它有一个bug：它会打印出4个和16个数字的错误答案，它们是2的幂。你也可以考虑使用素数筛选器来生成候选素数因子（从而避免事后的素性测试）。。您可以将其与因子分解相结合。将测试的最大因子限制为目标的平方根将使其更可行。“耐心等待，您的循环将完成”--哈哈。只要耐心一点，你的循环就会以一个有时是错误的结果结束……不过别担心，你永远也看不到它是否给了你正确的答案。除非你真的很耐心……也许是一个吸血鬼……无所事事……停在
sqrt（num）
是一个很好的改进，但它使程序打印出一个错误的素数答案（呃，一个更错误的答案）。我知道，但他需要的数字没问题。我想提供更多帮助，但我正在工作。
600851475143的Larget素数因子是6857
71*839*1471*6857=600851475143