Java中的程序素數分解

Question

素因數分解-讓用戶輸入一個數字並找到所有素因數（如果有）並顯示它們。

我創建了一種方法來驗證數字是否為質數，另一種方法是檢查用戶輸入的數字是否可以除以質數。

我不明白為什么程序無法運行以及for循環有什么問題（可以使用功能性操作）。 請幫我！
我是一個初學者，如果您給我一些建議來改進此代碼，我將非常感謝。

import java.util.ArrayList;
import java.util.Scanner;


public class PrimeFactors {
    int count, input, num;
    Scanner sc = new Scanner(System.in);
    ArrayList<Integer> factors = new ArrayList();

    public static void main(String[] args) {
        PrimeFactors pfo = new PrimeFactors();
        pfo.primeFactor();


    }

    public void primeFactor(){
        input = sc.nextInt();
        for(num = input; num <= 1; num--){
            System.out.println(input);
            if(isPrime(num)){
                if (divide(num)) {
                    System.out.println("Adding a new int...");
                    factors.add(num);
                    num = input;
                }
            }
        }
        for(int element : factors){
            System.out.println(factors.get(element));
        }
    }

    public boolean isPrime(int number){
        for(int i = 2; i < number; i++){
            if(number % i == 0){
                count++;
            }
        }
        return (count == 0);
    }

    public boolean divide(int number){
        return (input % number == 0);
    } 

}

Answer 1

本應使用實例變量時使用的是全局變量。 像Johnny指出的那樣，還有其他一些錯別字。 我最大的改變是我使該程序遞歸進行。 嘗試盡可能遠離全局變量，這會使事情更加混亂（例如，primeFactor方法應該使用變量，而不是使用全局變量）。

public class PrimeFactors {
    int count;
    static int input;
    int num;
    static Scanner sc = new Scanner(System.in);
    static ArrayList<Integer> factors = new ArrayList();

    public static void main(String[] args) {
        PrimeFactors pfo = new PrimeFactors();
        input = sc.nextInt();
        pfo.primeFactor();
        for(int element : factors){
            System.out.println(element);
        }
    }

    public void primeFactor(){
        if (input > 1) {

            for(int i = input; i >= 1; i--){
                if(isPrime(i)){
                    if (divide(i)) {
                        System.out.println("Adding a new int...");

                        factors.add(i);
                        input = input / i;
                        primeFactor();
                    }
                }
            }

        }
    }

    public boolean isPrime(int number){
        int count = 0;
        for(int i = 2; i < number; i++){
            if(number % i == 0){
                count++;
            }
        }
        return (count == 0);
    }

    public boolean divide(int number){
        return (input % number == 0);
    } 
}

這是我對primeFactors的解決方案。 我省去了計算素數列表部分的工作。 流非常棒，在解決項目Euler問題時，我很喜歡嘗試使用它們。

private static ArrayList<Integer> primeFactors(int number) {
        return primeFactors(new ArrayList<Integer>(), number);
    }

    private static ArrayList<Integer> primeFactors(ArrayList<Integer> primeFactors, int number) {
        if (number == 1) {
            return primeFactors;
        }

        int newPrime=primeDividor(number);
        primeFactors.add(newPrime);
        return primeFactors(primeFactors, number/newPrime);
    }

    private static int primeDividor(int input) {
        return primes.stream()
                     .filter(e -> input % e == 0)
                     .findFirst()
                     .orElse(input);
    }

Answer 2

您的代碼有多個問題。 首先，您的primeFactor循環永遠不會運行大於1的數字。您可以通過將for循環更改為for(num = 1; num <= input; num++)來測試從1到輸入的所有值來解決此問題。 但是您稍后會用輸入覆蓋num，因此它會自動跳出循環。

其次，您永遠不要將isPrime函數開始處的count設置為零，並且不要將其設置為isPrime函數的本地變量（在其他地方則未使用）。

第三，當在迭代器中使用for循環時，不需要調用factor.get，聲明的變量包含該值。 因此，您應該刪除對factors.get(element)的調用，而只需使用element 。

這些更改使您的代碼具有適當的行為。 您還有其他優化方法。

• 正確命名您的功能。 除法應稱為isDivisible並接受兩個參數，即數字和除數。
• 當可以使成員變量成為函數局部變量時，請避免使用它們。 這消除了副作用。 當前類中的所有變量都應為本地變量。

• 您應該先構造一個Eratosthenes篩網，然后驗證您的電話號碼是否可以被篩網中的號碼整除。 這將比除以每個小於其自身的數字快得多。

   import java.util.ArrayList; import java.util.Scanner; public class PrimeFactors { int count, input, num; Scanner sc = new Scanner(System.in); ArrayList<Integer> factors = new ArrayList(); public static void main(String[] args) { PrimeFactors pfo = new PrimeFactors(); pfo.primeFactor(); } public void primeFactor(){ input = sc.nextInt(); for(num = 1; num <= input; num++){ if(isPrime(num)){ if (divide(num)) { System.out.println("Adding a new int..."); factors.add(num); } } } for(int element : factors){ System.out.println(element); } } public boolean isPrime(int number){ int count = 0; for(int i = 2; i < number; i++){ if(number % i == 0){ count++; } } return (count == 0); } public boolean divide(int number){ return (input % number == 0); } } 

Answer 3

我聽了您的所有建議，並使用Eratosthenes篩子改進了我的程序，如果您能給我更多建議，我也將如何做得更好，我也將不勝感激。

    public class PrimeFactors {
    static int input;
    static Scanner sc = new Scanner(System.in);
    static ArrayList<Integer> factors = new ArrayList();

    public static void main(String[] args) {
        PrimeFactors pfo = new PrimeFactors();
        SieveOfEratosthenes sieveObj = new SieveOfEratosthenes();

        input = sc.nextInt();

        sieveObj.findAllPrimeFactors(input);
        pfo.divisiblePrimeFactors(sieveObj.allPrimeFactors);

        for(int element : factors){
            System.out.println(element);
        }
    }

    public void divisiblePrimeFactors(ArrayList<Integer> allPrimeFactors){    
        if(input > 1){

            for(int element : allPrimeFactors){
                if(isDivisible(element, input)){
                    factors.add(element);
                    input = input/element;
                    divisiblePrimeFactors(allPrimeFactors);
                }    
            }
        }    
    }

    public boolean isDivisible(int number, int divisor){
        return (divisor % number == 0);
    } 
}

public class SieveOfEratosthenes {

    ArrayList<Integer> allPrimeFactors= new ArrayList();

    public void findAllPrimeFactors(int limit){
        boolean[] isPrime = new boolean[limit];
        isPrime[0] = false;
        isPrime[1] = false;

        for(int i = 1; i < limit; i++){
            isPrime[i] = true;
        }

        for(int i = 2; i < limit; i++){
            if(isPrime[i]){
                allPrimeFactors.add(i);
            }
            for(int j = i*i; j < limit; j+=i){
                isPrime[j] = false;
            }
        }
    }
}

Answer 4

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( 1001 );
      p.primeFactors( 649 );
      p.primeFactors( 144 );

   }

}//end Prime.java