创建递归 static 方法来查找数组中素数的乘积

Question

尽管 if(number % j == 0) 在 9/3 时返回 true 并且没有余数但为 0，但数字 9 一直从我的 Prime 方法返回 true。有人愿意帮助我吗？ 我也试图不使用 for 循环。 这是为了家庭作业。

编辑：我已经尝试了下面的答案，但我仍然使用 if 语句遇到同样的问题。

public class test {
    private static int product = 1;
    private static int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    private static boolean allowmultiply;
    public static void main(String args[]) {
        System.out.println("Product: " + findproduct(array, 0));
        }

    public static int findproduct(int[] list, int i) {
        int[] temp = list;
         if(i <= temp.length-1) {
            allowmultiply = Prime(temp[i], 2);
            if(allowmultiply != false) {
                product = product * temp[i];
            } 
            i++; 
            return findproduct(temp, i);
        }
        return product;
    }
    public static boolean Prime(int number, int j) {
        if(j <= number/j) {
            if(number % j == 0) {
                return false;
            }
            Prime(number, j+1);
        }
        return true;
    }
}

新代码：感谢 WJS 的帮助！

public class ProductPrimeNumber {
        private static int product = 1;
        private static boolean allowmultiply;
        private static int checker = 0;
        private static int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    public static void main(String args[]) {
        System.out.println("Product: " + findproduct(array, 0));
        }
    public static int findproduct(int[] list, int i) {
        int[] array = list;
        if(i <= array.length-1) {
            allowmultiply = isPrime(array[i], 2);
            if(allowmultiply != false) {
                product = product * array[i];
            } 
            checker = 0;
            i++;
            return findproduct(array , i);
        }
        return product;
    }
    public static boolean isPrime(int number, int i) {
        if(i < number) {
            if(number % i == 0 && i != number) {
                checker++;
            }
            isPrime(number, i+1);
        }
        if(checker > 0) {
            return false;
        }
        return true;
    }
}

Answer 1

这可能会有所帮助。 暂时忘掉素数，因为那是一个完全独立的问题。 考虑偶数的乘积。 该方法并不像帮助清晰度那样紧凑。

static Predicate<Integer> isEven = a -> a != 0 && a % 2 == 0;

int[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int prod = findProduct(data, 0);
System.out.println("prod = " + prod);

印刷

prod = 3840

• 定义一个 lambda 来测试偶校验和 >.= 0。这不是必需的，但有助于解释。
• 然后用数组和 0 开始调用方法。
• 继续调用该方法，直到i == v.length-1 （最后一个元素）。
• 然后通过首先测试v[i]的偶校验来"unwind"递归调用
• 如果为真，则返回prod * v[i] 。
• 否则，只返回prod 。

public static int findProduct(int[] v, int i) {
    int prod = 1;
    if (i < v.length-1) { 
       prod = findProduct(v, i+1);
    }
    if (isEven.test(v[i])) {
        return prod * v[i];
    }
    return prod;
}

这个和主要解决方案之间的唯一区别是您的测试目的。 所以用isEven替换isPrime 。 然后你只需要专注于你的isPrime代码。

更紧凑的findProduct版本在这里。

• 简单地测试偶数奇偶校验
• 乘以 v[i] 或 1 的返回乘积
• 当i == i.length时，返回1开始展开过程

public static int prodEven(int[] v, int i) {
    if (i < v.length) { 
        return (isEven.test(v[i]) ? v[i] : 1) * prodEven(v, i+1);
    }
    return 1;
}

Answer 2

要通过递归完成，您可以从一个索引开始（比如 i 指向数组的开头）。

基本条件：当i达到数组长度时，则返回1；

要做的工作：如果数字是素数，则将其乘以乘积和调用其他函数的返回值，如果不是，则将乘积乘以调用其他函数的返回值。

public class PrimeProduct {
    static int product = 1;

    public static void main(String[] args) {
        int list[] = { 3, 5, 9, 11 }; // 11*5*3
        int res = findProduct(list, 0);
        System.out.println(res);
    }

    public static int findProduct(int[] list, int i) {
        if (i == list.length) {
            return 1;
        }
        return isPrime(list[i], 2) ? product * list[i] * findProduct(list, i + 1) : product * findProduct(list, i + 1);

    }

    private static boolean isPrime(int num, int i) {
        if (i * i > num) {
            return true;
        }

        return (num % i != 0) ? isPrime(num, i + 1) : false;

    }

}

output 是

165