查找主要因素，包括其总发生率（Java）

我试图构建一个Java程序来查找N个数字的LCM。但首先，我被困在寻找一个数字的总素因子，包括它们的出现。例如（6=2x3）和（8=2x2）。但是我得到的输出是（6）的'2'，而（8）只有两个'2'。另一个在哪里？我甚至在检查整数“s”是否为素数

package lcm;

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

public class LCM {
  public static boolean isPrime(int numero){
    for (int i = 2; i <= Math.sqrt(numero); i++) {
        if (numero % i == 0) {
            return false;
        }
    }
     return true;
  }
  public static  void factor(int x){    
      int s;
      int copy = x;
      ArrayList<Integer> al = new ArrayList<>();  
      for(s=2;s<copy;s++){
          if(copy%s==0){
              if (isPrime(s)){ 
                  al.add(s);
                  copy/=s;
                  //used for repetition
                  s--;
               }
          } 
       }
       for( int p : al){   
         System.out.println(p);    
       }
   }
public static void main(String[] args) {
    // TODO code application logic here
    int j,k;
    int temp=0;
    System.out.println("Enter no. of numbers");
    Scanner cin = new Scanner(System.in);
    int i = cin.nextInt();
    int []a = new int[i];
    int []b=new int[100];
    System.out.println("Enter numbers one by one");

    for(j=0;j<a.length;j++){ 
        a[j] = cin.nextInt();
    }
    for(j=0;j<a.length;j++){   
        temp=a[j];
        factor(temp);
    }
   }
}

封装lcm；
导入java.util.ArrayList；
导入java.util.Scanner；
公共类LCM{
公共静态布尔值iPrime（整数）{
对于（int i=2；i原因是当s=2，copy在一个案例中也变为2时，它跳过了循环，所以只显示了两个2。尝试放置原因是当s=2，copy在一个案例中也变为2时，它跳过了循环，所以只显示了两个2。尝试放置我认为解决这个问题的最佳方法之一是使用递归因为你必须不断地除以才能找到所有的素因子


package leastcommonmultiple;

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

public class Runner {

    private static LeastCommonMultiple lcm;

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

        System.out.println("Enter numbers and separate them with a comma: ");
        Scanner cin = new Scanner(System.in);
        String[] inputs;
        String lineInput;
        try {
            lineInput = cin.nextLine();
            while (lineInput.isEmpty()) {
                System.out.println("Enter at least 2 numbers separated by a comma ");
                lineInput = cin.nextLine();
            }
            inputs = lineInput.split(",");
            int length = inputs.length;
            int[] numbers = new int[length];
            int temp = 0;
            for (int i = 0; i < length; i++) {
                if (inputs[i] != null && !inputs[i].isEmpty()) {
                    if ((temp = Math.abs(Integer.valueOf(inputs[i].trim()))) == 0) {
                        throw new IllegalArgumentException("No number should be 0");
                    }
                    numbers[i] = temp;
                }
            }
            ArrayList<Integer> list = new ArrayList<>();
            lcm = new LeastCommonMultiple();
            System.out.println("The Least Common Multiple is: " + lcm.getLeastCommonMultipleOfListOfNumbers(numbers));
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
    }
}


package leastcommonmultiple;

import java.util.ArrayList;

public class LeastCommonMultiple {

    public LeastCommonMultiple() {
    }

    /**
     * @param numbers array of numbers whose LCM should be found.
     * @assure       numbers.length > 1
     * @return LCM of numbers contained in numbers array
     */
    public int getLeastCommonMultipleOfListOfNumbers(int[] numbers) throws IllegalArgumentException {
        int leastCommonMultiple;
        int length = numbers.length;
        if ( length <= 1) {
            throw new IllegalArgumentException("Please enter at least 2 numbers separated by a comma.");
        } else {
            leastCommonMultiple = getLeastCommonMultipleOfTwoNumbers(numbers[0], numbers[length-1]);
            length = length-1;
            for ( int i=1; i<length; i++ ) {
                leastCommonMultiple = getLeastCommonMultipleOfTwoNumbers(leastCommonMultiple, numbers[i]);
            }
        }
        return leastCommonMultiple;
    }

    private int getLeastCommonMultipleOfTwoNumbers(int number1, int number2) {
        int leastCommonMultiple = 0;
        int maxOfTheTwoNumbers = Math.max(number1, number2);
        int minOfTheTwoNumbers = Math.min(number1, number2);
        int quotient = 0;
        if (number1 % number2 == 0 || number2 % number1 == 0) {
            leastCommonMultiple = maxOfTheTwoNumbers;
        } else {
            ArrayList<Integer> primeFactors = getPrimeFactors(minOfTheTwoNumbers, new ArrayList<>());
            for (int primeFactor : primeFactors) {
                if (maxOfTheTwoNumbers % primeFactor == 0) {
                    maxOfTheTwoNumbers = (maxOfTheTwoNumbers / primeFactor);
                }
                leastCommonMultiple = minOfTheTwoNumbers * maxOfTheTwoNumbers;
            }
        }
        return leastCommonMultiple;
    }


    // recursive methods that finds all the prime factors for a given number
    /**
     * @param numero positive number whose prime factors has to be found
     * @param primeFactors an empty ArrayList where the prime factors will be
     * stored
     * @return the ArrayList containing the found prime factors
     */
    private static ArrayList<Integer> getPrimeFactors(int numero, ArrayList<Integer> primeFactors) {
        int sqrt = (int) Math.sqrt(numero);
        int quotient;
        if (isPrime(numero)) {
            primeFactors.add(numero);
        } else {
            if (numero % sqrt == 0) {
                quotient = numero / sqrt;
                if (isPrime(sqrt)) {
                    primeFactors.add(sqrt);
                } else {
                    primeFactors = getPrimeFactors(sqrt, primeFactors);
                }
            } else {
                quotient = numero / (sqrt - 1);
                if (isPrime(sqrt - 1)) {
                    primeFactors.add(sqrt - 1);
                } else {
                    primeFactors = getPrimeFactors((sqrt - 1), primeFactors);
                }
            }
            if (!isPrime(quotient)) {
                primeFactors = getPrimeFactors(quotient, primeFactors);
            } else {
                primeFactors.add(quotient);
            }
        }
        return primeFactors;
    }


    // Make sure a number is prime
    public static boolean isPrime(int numero) {
        int length = (int) Math.sqrt(numero);
        for (int i = 2; i <= length; i++) {
            if (numero % i == 0) {
                return false;
            }
        }
        return true;
    }
}

package-leastcommonmultiple；
导入java.util.ArrayList；
导入java.util.Scanner；
公开课跑者{
专用静态租赁公共多lcm；
/**
*@param指定命令行参数
*/
公共静态void main（字符串[]args）{
System.out.println（“输入数字并用逗号分隔：”）；
扫描仪cin=新扫描仪（System.in）；
字符串[]输入；
字符串行输入；
试一试{
lineInput=cin.nextLine（）；
while（lineInput.isEmpty（））{
System.out.println（“输入至少两个用逗号分隔的数字”）；
lineInput=cin.nextLine（）；
}
输入=lineInput.split（“，”）；
int length=inputs.length；
int[]数字=新的int[长度]；
内部温度=0；
for（int i=0；i1
*@返回数字数组中包含的数字的LCM
*/
public int getLeastCommonMultipleofListofNumber（int[]number）引发IllegalArgumentException{
int-leastCommonMultiple；
int length=number.length；
if（length我认为解决这个问题的最好方法之一是使用递归，因为为了找到所有的素因子，你必须不断地进行除法


package leastcommonmultiple;

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

public class Runner {

    private static LeastCommonMultiple lcm;

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

        System.out.println("Enter numbers and separate them with a comma: ");
        Scanner cin = new Scanner(System.in);
        String[] inputs;
        String lineInput;
        try {
            lineInput = cin.nextLine();
            while (lineInput.isEmpty()) {
                System.out.println("Enter at least 2 numbers separated by a comma ");
                lineInput = cin.nextLine();
            }
            inputs = lineInput.split(",");
            int length = inputs.length;
            int[] numbers = new int[length];
            int temp = 0;
            for (int i = 0; i < length; i++) {
                if (inputs[i] != null && !inputs[i].isEmpty()) {
                    if ((temp = Math.abs(Integer.valueOf(inputs[i].trim()))) == 0) {
                        throw new IllegalArgumentException("No number should be 0");
                    }
                    numbers[i] = temp;
                }
            }
            ArrayList<Integer> list = new ArrayList<>();
            lcm = new LeastCommonMultiple();
            System.out.println("The Least Common Multiple is: " + lcm.getLeastCommonMultipleOfListOfNumbers(numbers));
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
    }
}


package leastcommonmultiple;

import java.util.ArrayList;

public class LeastCommonMultiple {

    public LeastCommonMultiple() {
    }

    /**
     * @param numbers array of numbers whose LCM should be found.
     * @assure       numbers.length > 1
     * @return LCM of numbers contained in numbers array
     */
    public int getLeastCommonMultipleOfListOfNumbers(int[] numbers) throws IllegalArgumentException {
        int leastCommonMultiple;
        int length = numbers.length;
        if ( length <= 1) {
            throw new IllegalArgumentException("Please enter at least 2 numbers separated by a comma.");
        } else {
            leastCommonMultiple = getLeastCommonMultipleOfTwoNumbers(numbers[0], numbers[length-1]);
            length = length-1;
            for ( int i=1; i<length; i++ ) {
                leastCommonMultiple = getLeastCommonMultipleOfTwoNumbers(leastCommonMultiple, numbers[i]);
            }
        }
        return leastCommonMultiple;
    }

    private int getLeastCommonMultipleOfTwoNumbers(int number1, int number2) {
        int leastCommonMultiple = 0;
        int maxOfTheTwoNumbers = Math.max(number1, number2);
        int minOfTheTwoNumbers = Math.min(number1, number2);
        int quotient = 0;
        if (number1 % number2 == 0 || number2 % number1 == 0) {
            leastCommonMultiple = maxOfTheTwoNumbers;
        } else {
            ArrayList<Integer> primeFactors = getPrimeFactors(minOfTheTwoNumbers, new ArrayList<>());
            for (int primeFactor : primeFactors) {
                if (maxOfTheTwoNumbers % primeFactor == 0) {
                    maxOfTheTwoNumbers = (maxOfTheTwoNumbers / primeFactor);
                }
                leastCommonMultiple = minOfTheTwoNumbers * maxOfTheTwoNumbers;
            }
        }
        return leastCommonMultiple;
    }


    // recursive methods that finds all the prime factors for a given number
    /**
     * @param numero positive number whose prime factors has to be found
     * @param primeFactors an empty ArrayList where the prime factors will be
     * stored
     * @return the ArrayList containing the found prime factors
     */
    private static ArrayList<Integer> getPrimeFactors(int numero, ArrayList<Integer> primeFactors) {
        int sqrt = (int) Math.sqrt(numero);
        int quotient;
        if (isPrime(numero)) {
            primeFactors.add(numero);
        } else {
            if (numero % sqrt == 0) {
                quotient = numero / sqrt;
                if (isPrime(sqrt)) {
                    primeFactors.add(sqrt);
                } else {
                    primeFactors = getPrimeFactors(sqrt, primeFactors);
                }
            } else {
                quotient = numero / (sqrt - 1);
                if (isPrime(sqrt - 1)) {
                    primeFactors.add(sqrt - 1);
                } else {
                    primeFactors = getPrimeFactors((sqrt - 1), primeFactors);
                }
            }
            if (!isPrime(quotient)) {
                primeFactors = getPrimeFactors(quotient, primeFactors);
            } else {
                primeFactors.add(quotient);
            }
        }
        return primeFactors;
    }


    // Make sure a number is prime
    public static boolean isPrime(int numero) {
        int length = (int) Math.sqrt(numero);
        for (int i = 2; i <= length; i++) {
            if (numero % i == 0) {
                return false;
            }
        }
        return true;
    }
}

package-leastcommonmultiple；
导入java.util.ArrayList；
导入java.util.Scanner；
公开课跑者{
专用静态租赁公共多lcm；
/**
*@param指定命令行参数
*/
公共静态void main（字符串[]args）{
System.out.println（“输入数字并用逗号分隔：”）；
扫描仪cin=新扫描仪（System.in）；
字符串[]输入；
字符串行输入；
试一试{
lineInput=cin.nextLine（）；
while（lineInput.isEmpty（））{
System.out.println（“输入至少两个用逗号分隔的数字”）；
lineInput=cin.nextLine（）；
}
输入=lineInput.split（“，”）；
int length=inputs.length；
int[]数字=新的int[长度]；
内部温度=0；
for（int i=0；i1
*@返回数字数组中包含的数字的LCM
*/
public int getLeastCommonMultipleofListofNumber（int[]number）引发IllegalArgumentException{
int-leastCommonMultiple；
int length=number.length；
如果（length这里有一个在欧几里德算法上使用二进制分割更快的解决方案：

private static int gcd(int a, int b) {
  if (a == 0) return b;
  if (b == 0) return a;
  return gcd(b, a%b);
}

private static int lcm(int a, int b) {
  return a / gcd(a, b) * b;
}

public static int LCM(int[] numbers) {
  int len = numbers.length;
  if (len == 2) return lcm(numbers[0], numbers[1]);
  if (len == 1) return numbers[0];
  if (len == 0) return 1;
  int[] left = Arrays.copyOfRange(numbers, 0, len/2);
  int[] right = Arrays.copyOfRange(numbers, len/2+1, len);
  return lcm(LCM(left), LCM(right));
}

这是一个在欧几里德算法上使用二进制分割更快的解决方案：

private static int gcd(int a, int b) {
  if (a == 0) return b;
  if (b == 0) return a;
  return gcd(b, a%b);
}

private static int lcm(int a, int b) {
  return a / gcd(a, b) * b;
}

public static int LCM(int[] numbers) {
  int len = numbers.length;
  if (len == 2) return lcm(numbers[0], numbers[1]);
  if (len == 1) return numbers[0];
  if (len == 0) return 1;
  int[] left = Arrays.copyOfRange(numbers, 0, len/2);
  int[] right = Arrays.copyOfRange(numbers, len/2+1, len);
  return lcm(LCM(left), LCM(right));
}

原因是当s=2时，复制也变为2，此时它跳过循环，因此只显示两个2。尝试使用更好的方法：
LCM（a，b）=a.b |/GCD（a，b）
…并使用欧几里德算法计算GCD。原因是当s=2，复制也变成2时，它跳过循环，因此只显示两个2。尝试使用更好的方法：
LCM（a，b）=| a.b |/GCD（a，b）
…并使用欧几里德算法计算GCD。此外，我将更改
因子（）
当
copy
变量为1时停止的控件。此外，质数