Java中的素因子分解程序

我正在开发一个用Java实现的素因子分解程序。 目标是找到最大的素因子600851475143（）。 我想我已经完成了大部分工作，但我也犯了一些错误。 而且我的逻辑似乎不正确，特别是我设置的检查数字是否为素数的方法

public class PrimeFactor {

    public static void main(String[] args) {
        int count = 0;
        for (int i = 0; i < Math.sqrt(600851475143L); i++) {
            if (Prime(i) && i % Math.sqrt(600851475143L) == 0) {
                count = i;
                System.out.println(count);
            }
        }
    }

    public static boolean Prime(int n) {
        boolean isPrime = false;
        // A number is prime iff it is divisible by 1 and itself only
        if (n % n == 0 && n % 1 == 0) {
            isPrime = true;
        }
        return isPrime;
    }
}

公共类PrimeFactor{
公共静态void main（字符串[]args）{
整数计数=0；
对于（int i=0；i

编辑

public class PrimeFactor {

    public static void main(String[] args) {
        for (int i = 2; i <= 600851475143L; i++) {
            if (isPrime(i) == true) {
                System.out.println(i);
            }
        }
    }

    public static boolean isPrime(int number) {
        if (number == 1) return false;
        if (number == 2) return true;
        if (number % 2 == 0) return false;
        for (int i = 3; i <= number; i++) {
            if (number % i == 0) return false;
        }
        return true;
    }
}

公共类PrimeFactor{
公共静态void main（字符串[]args）{
对于（int i=2；i您希望从2->n-1进行迭代，并确保n%i！=0。这是检查素性的最简单的方法。如上所述，如果数字很大，这非常慢。
我认为您感到困惑，因为没有iff[if and only if]操作符

求整数的平方根是一条很好的捷径。剩下的就是检查循环中的数字是否等分。这就是[big number]%i==0。没有理由使用素数函数

因为你在寻找最大的除数，另一个技巧是从小于平方根的最大整数开始，然后进入i--

正如其他人所说，最终，这是极其缓慢的。
要找到因素，您需要以下内容：

long limit = sqrt(number);
for (long i=3; i<limit; i+=2)
    if (number % i == 0)
        print "factor = " , i;

long limit=sqrt（编号）；
对于（long i=3；i编辑：我希望这听起来不是一个令人难以置信的居高临下的答案。我只是想说明，从计算机的角度来看，你必须检查所有可能是X的因子的数字，以确保它是素数。计算机不知道它是复合的，所以你必须检查它迭代

例子：X是质数吗

对于X=67的情况：

你怎么检查这个

I divide it by 2... it has a remainder of 1 (this also tells us that 67 is an odd number)
I divide it by 3... it has a remainder of 1
I divide it by 4... it has a remainder of 3
I divide it by 5... it has a remainder of 2
I divide it by 6... it has a remainder of 1

事实上，如果该数字不是素数，则只能得到0的余数

你必须检查每一个小于X的数字以确保它是素数吗？不，不再是了，多亏了数学（！）

让我们看一个较小的数字，比如16

16不是质数

为什么？因为

2*8 = 16
4*4 = 16

所以16可以被1和它本身平均整除。（虽然“1”在技术上不是质数，但这是技术上的问题，我离题了）

所以我们把16除以1…当然这对每个数字都有效

Divide 16 by 2... we get a remainder of 0  (8*2)
Divide 16 by 3... we get a remainder of 1  
Divide 16 by 4... we get a remainder of 0  (4*4)
Divide 16 by 5... we get a remainder of 1
Divide 16 by 6... we get a remainder of 4
Divide 16 by 7... we get a remainder of 2
Divide 16 by 8... we get a remainder of 0  (8*2)

我们实际上只需要0的一个余数就可以告诉我们它是复合的（与“prime”相反的是“composite”）

检查16是否可以被2整除与检查它是否可以被8整除是一样的，因为2和8相乘得到16

我们只需要检查光谱的一部分（从2到X的平方根），因为我们可以乘以的最大数字是sqrt（X），否则我们使用较小的数字来得到多余的答案

17号是prime吗

17 % 2 = 1
17 % 3 = 2
17 % 4 = 1 <--| approximately the square root of 17 [4.123...]
17 % 5 = 2 <--|
17 % 6 = 5
17 % 7 = 3

17%2=1
17 % 3 = 2
17%4=1您需要对分解大数的算法进行一些研究；看起来是一个很好的起点。在第一段中，它指出：

当数字非常大时，没有有效的整数分解算法是众所周知的

但它确实列出了一些特殊和通用的算法。你需要选择一个能够很好地处理12位十进制数字的算法。这些数字对于最简单的方法来说太大了，但是足够小，以至于（例如）基于从2开始枚举素数的方法可以工作。（提示-从Erasthones的筛子开始）
为什么要把它弄得这么复杂？你不需要做类似于isPrime（）的事情。把它的最小除数（prime）除以，然后从这个prime开始循环。下面是我的简单代码：

public class PrimeFactor {

    public static int largestPrimeFactor(long number) {
        int i;

        for (i = 2; i <= number; i++) {
            if (number % i == 0) {
                number /= i;
                i--;
            }
        }

        return i;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(largestPrimeFactor(13195));
        System.out.println(largestPrimeFactor(600851475143L));
    }
}

公共类PrimeFactor{
公共静态int largestPrimeFactor（长数字）{
int i；
对于（i=2；i，这里有一个非常优雅的答案——它使用蛮力（不是一些花哨的算法），但以一种巧妙的方式——通过降低极限，我们发现素数，并通过这些素数进行合成

它也只打印素数，而且只打印素数，如果一个素数在产品中不止一次，它将打印该素数的次数与该素数在产品中的次数相同

    public class Factorization {
    public static void main(String[] args) {
    long composite = 600851475143L;
    int limit = (int)Math.sqrt(composite)+1;
    for (int i=3; i<limit; i+=2)
    {
        if (composite%i==0)
        {
            System.out.println(i);
            composite = composite/i;
            limit = (int)Math.sqrt(composite)+1;
            i-=2;   //this is so it could check same prime again
        }
    }
    System.out.println(composite);
    }
}

公共类分解{
公共静态void main（字符串[]args）{
长复合材料=600851475143L；
int limit=（int）Math.sqrt（composite）+1；
对于（int i=3；i
private静态布尔值isPrime（int k）抛出IllegalArgumentException
{
int j；
如果（k<2）抛出新的IllegalArgumentException（“所有素数都大于1”）；
否则{
对于（j=2；j
对于那些使用isPrime（int）：boolean方法的答案，有一种比以前实现的算法更快的算法（类似于）

求全部素因子分解

import java.math.BigInteger;
import java.util.Scanner;


public class BigIntegerTest {


     public static void main(String[] args) {


            BigInteger myBigInteger = new BigInteger("65328734260653234260");//653234254
            BigInteger originalBigInteger;
            BigInteger oneAddedOriginalBigInteger;
            originalBigInteger=myBigInteger;
            oneAddedOriginalBigInteger=originalBigInteger.add(BigInteger.ONE);
            BigInteger index;
            BigInteger countBig;


            for (index=new BigInteger("2");  index.compareTo(myBigInteger.add(BigInteger.ONE)) <0; index = index.add(BigInteger.ONE)){

                countBig=BigInteger.ZERO;
                while(myBigInteger.remainder(index) == BigInteger.ZERO ){
                    myBigInteger=myBigInteger.divide(index);
                    countBig=countBig.add(BigInteger.ONE);
                }

                if(countBig.equals(BigInteger.ZERO)) continue;
                System.out.println(index+ "**" + countBig);

            }
            System.out.println("Program is ended!");
     }
}

import java.math.biginger；
导入java.util.Scann
private static boolean isPrime(long n) { //when n >= 2
    for (int k = 2; k < n; k++)
        if (n % k == 0) return false;

    return true;
}

private static boolean isPrime(long n) { //when n >= 2
    if (n == 2 || n == 3) return true;

    if (n % 2  == 0 || n % 3 == 0) return false;

    for (int k = 1; k <= (Math.floor(Math.sqrt(n)) + 1) / 6; k++)
        if (n % (6 * k + 1) == 0 || n % (6 * k - 1) == 0) return false;

    return true;
}

public class Euler3 {

    public static void main(String[] args) {
        long[] nums = {13195, 600851475143L};

        for (num : nums)
            System.out.println("Largest prime factor of " + num + ": " + lpf(num));

    }

    private static lpf(long n) {
        long largestPrimeFactor = 1;
        long maxPossibleFactor = n / 2;

        for (long i = 2; i <= maxPossibleFactor; i++)
            if (n % i == 0) {
                n /= i;
                largestPrimeFactor = i;

                i--;
            }

            return largestPrimeFactor;

    }

}

import java.math.BigInteger;
import java.util.Scanner;


public class BigIntegerTest {


     public static void main(String[] args) {


            BigInteger myBigInteger = new BigInteger("65328734260653234260");//653234254
            BigInteger originalBigInteger;
            BigInteger oneAddedOriginalBigInteger;
            originalBigInteger=myBigInteger;
            oneAddedOriginalBigInteger=originalBigInteger.add(BigInteger.ONE);
            BigInteger index;
            BigInteger countBig;


            for (index=new BigInteger("2");  index.compareTo(myBigInteger.add(BigInteger.ONE)) <0; index = index.add(BigInteger.ONE)){

                countBig=BigInteger.ZERO;
                while(myBigInteger.remainder(index) == BigInteger.ZERO ){
                    myBigInteger=myBigInteger.divide(index);
                    countBig=countBig.add(BigInteger.ONE);
                }

                if(countBig.equals(BigInteger.ZERO)) continue;
                System.out.println(index+ "**" + countBig);

            }
            System.out.println("Program is ended!");
     }
}

public class LargestPrimeFactor
{
    public static void main (String[] args){
        long number=600851475143L, factoredNumber=number, factor, factorLimit, maxPrimeFactor;
        while(factoredNumber%2==0)
            factoredNumber/=2;
        factorLimit=(long)Math.sqrt(factoredNumber);
        for(factor=3;factor<=factorLimit;factor+=2){
            if(factoredNumber%factor==0){
                do  factoredNumber/=factor;
                while(factoredNumber%factor==0);
                factorLimit=(long)Math.sqrt(factoredNumber);
            }
        }
        if(factoredNumber==1)
            if(factor==3)
                maxPrimeFactor=2;
            else
                maxPrimeFactor=factor-2;
        else
            maxPrimeFactor=factoredNumber;
        if(maxPrimeFactor==number)
            System.out.println("Number is prime.");
        else
            System.out.println("The largest prime factor is "+maxPrimeFactor);
    }
}

public class Prime
{
 int i;   

 public Prime( )
 {
    i = 2;
 }

 public boolean isPrime( int test ) 
 {
    int k;

    if( test < 2 )
        return false;
    else if( test == 2 )  
        return true;
    else if( ( test > 2 ) && ( test % 2 == 0 ) )
        return false;
    else
    {
        for( k = 3; k < ( test/2 ); k += 2 )
        {
            if( test % k == 0 ) 
                return false;
        }

    }

    return true;

 }

 public void primeFactors( int factorize )
 {
    if( isPrime( factorize ) )
    {
        System.out.println( factorize );
        i = 2;
    }
    else
    {
        if( isPrime( i ) && ( factorize % i == 0 ) )
        {
            System.out.print( i+", " );
            primeFactors( factorize / i );
        }
        else
        {
            i++;
            primeFactors( factorize );
        }
   }

   public static void main( String[ ] args )
   {
       Prime p = new Prime( );

       p.primeFactors( 649 );
       p.primeFactors( 144 );
       p.primeFactors( 1001 );
   }
}