如何将我的 9 个 if 语句浓缩为一个 [关闭]

Question

我想看看能被所有一位数整除的最小数字是多少，我没有查找它，而是创建了这个。

public static void main(String[] args) {

    for (int i = 100; i < 10000; i++) {

        if (i % 2 ==0) {

            if (i % 3 ==0) {

                if (i % 4 ==0) {

                    if (i % 5 ==0) {

                        if (i % 6 ==0) {

                            if (i % 7 ==0) {

                                if (i % 8 ==0) {

                                    if (i % 9 ==0) {

                                        System.out.println(i);

                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

如您所见，我在 if 语句 x9 中有一个 if 语句。该代码有效，但我想使用数组压缩我的 if 语句以使我的 if 语句像这样，但它不起作用。

 if (i % x[1, 2, 3, 4, 5, 6, 7, 8]) {
 System.out.println(i);
 break;
 }

有什么建议吗？

Answer 1

更简单的方法：

    public static boolean isDivisible(int number) {
        for (int i = 2; i <= 9; i++) {
            if (num % i != 0) {
                return false;
            }
        }
        return true;
    }

并且使用相同类型的结构，main方法变成：

    public static void main(String[] args) {
        for (int i = 100; i <= 100000; i++) {
            if (isDivisible(i)) {
                System.out.println("Divisible by numbers 2...9: " + i);
                break;
            }
        }
    }

Answer 2

我想你可以使用LCM (Least Common Multiple) of (1, 2, 3, 4, 5, 6, 7, 8, 9) = 2520，像这样：

if (i % 2520 == 0) {
    System.out.println(i);
    break;
}

Answer 3

你为什么不..

反转 IF？

---

public static void main(String[] args) {

    for (int i = 100; i < 10000; i++) {

        //If value is not valid, continue to next value
        if (i % 2 != 0) continue;
        if (i % 3 != 0) continue;
        if (i % 4 != 0) continue;
        if (i % 5 != 0) continue;
        if (i % 6 != 0) continue;
        if (i % 7 != 0) continue;
        if (i % 8 != 0) continue;
        if (i % 9 != 0) continue;

        //Valid value found. Print and break out of the loop.
        System.out.println(i);
        break;
    }
}

---

或者，上面的代码可以进一步重构为：

public static void main(String[] args) {
    for (int i = 100; i < 10000; i++) {
        if (isPrintable(i)) {
            System.out.println(i);
            break;
        }
    }
}

private static boolean isPrintable(int value) {
    return value % 2 == 0
           && value % 3 == 0
           && value % 4 == 0
           && value % 5 == 0
           && value % 6 == 0
           && value % 7 == 0
           && value % 8 == 0
           && value % 9 == 0;
}

---

此外，根据@TeePeemm 的建议，isPrintable() 可以简化为：

private static boolean isPrintable(int value) {
    for (int divisor = 2; divisor < 10; divisor++) {
        if (value % divisor != 0) return false;
    }
    return true;
}

---

^{1.正如其他答案中所建议的那样，也有基于语言的快捷方式。我同意他们的看法。}

^{2.许多答案使用数字的 LCM 来使代码简洁，但这是一个等待咬人的休眠错误。循环执行完全改变，可以通过注释掉break; 看到。看似简单的解决方案引入了一个微妙的潜在错误。}

Answer 4

好吧，这可能不是最好的方法，但我想尝试使用任意一组数字。

public interface Divisor {
    boolean isDivisible(Long value);
}

public static main(String[] args) {
    LCMDivisor divisor = LCMDivisor.init()
            .addValue(2L)
            .addValue(3L)
            .addValue(4L)
            .addValue(5L)
            .addValue(6L)
            .addValue(7L)
            .addValue(8L)
            .addValue(9L);

    LongStream.range(1, 10000)
            .filter(divisor::isDivisible)
            .findFirst()
            .ifPresent(System.out::println);
}

所以我们创建了一个对象，Divisor，它有一个方法可以告诉你一个值是否可以被它自己整除。

代码通过创建从 1 到 N 的 Longs 流来运行，过滤掉所有不能被除数整除的值，然后取第一个值（根据您的“break”语句）。它返回一个可选项。如果存在值，则该值将打印到标准输出。

对于这个例子，根据上面的 cmets，我介绍了一个 Divisor 的实现，它存储所有添加的值的最小公倍数。初始化时，它的值为 1；但是每次添加一个新值时，它都会返回一个具有最小公倍数的除数的新实例。实现如下所示：

public class LCMDivisor implements Divisor {

    public final Long lcmValue;

    private LCMDivisor(Long lcmValue) {
        this.lcmValue = lcmValue;
    }

    public static LCMDivisor init() {

        return new LCMDivisor(1L);
    }

    public Boolean isDivisible(final Long value) {
        return value % lcmValue == 0;
    }

    public LCMDivisor addValue(final Long newValue) {

        return new LCMDivisor(lcm(newValue));
    }

    private Long lcm(final Long newValue) {
        return newValue * (lcmValue / gcd(newValue));
    }

    private Long gcd(final Long newValue) {

        Long greater = newValue < lcmValue ? lcmValue : newValue;
        Long lesser = newValue > lcmValue ? lcmValue : newValue;

        while (lesser > 0)
        {
            long temp = lesser;
            lesser = greater % lesser;
            greater = temp;
        }
        return greater;
    }
}

Answer 5

您基本上在做的是试图找到数字i，它是2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 的LCM。最初，您可能只想简单地写

if (i % (2 * 3 * 4 * 5 * 6 * 7 * 8 * 9) == 0) {
    System.out.println(i);
    break;
}

如果所有数字都是互质的，那将是真的。这意味着他们没有任何共同因素。但是在这种情况下，这些数字不是互质的并且具有公因数。就像8 = 2*2*2, 4 = 2*2, 6 = 2*3 都有 2。3 = 1 * 3 , 6 = 2*3, 9 = 3*9 都有 3。所以基本上我们必须取 LCM 的数字 2,3,4,5,6,7,8,9。请参阅以下编辑以更正上述公式。

数字2,3,4,5,6,7,8,9 的 LCM（最小公倍数）是 = 2520。 所以通过所有测试用例的正确公式如下

if ( i % 2520 == 0) { 
  System.out.println(i); 
  break;
}

另一个使用的解决方案是简单地检查所有条件，如下所示：

if(i % 9 == 0 && i % 8 ==0 && i % 7 == 0 && i % 5 == 0) {
   System.out.println(i);
   break;
}

Answer 6

试试这个。

for (int i = 100; i < 10000; ++i) {
    int x = i;
    if (IntStream.of(2, 3, 4, 5, 6, 7, 8, 9).allMatch(k -> x % k == 0)) {
        System.out.println(i);
        break;
    }
}

-> 2520

或者你可以把它写成一个语句。

int result = IntStream
    .range(100, 10000)
    .filter(i -> IntStream.of(2, 3, 4, 5, 6, 7, 8, 9).allMatch(k -> i % k == 0))
    .findFirst()
    .getAsInt();

System.out.println(result);

-> 2520

Answer 7

如果您尝试使用从 1 到 20 或 1 到 30 的数字，您的循环将花费很长时间。您可以直接计算 least common multiple：

package stackOverflow;
import java.util.stream.LongStream;

public class NumberTheory
{

    public static void main(String[] args) {
        System.out.println(gcd(15, 3) == 3);
        System.out.println(gcd(13, 11) == 1);
        System.out.println(gcd(60, 24) == 12);
        System.out.println(gcd(1071, 462) == 21);
        System.out.println(gcd(462, 1071) == 21);
        System.out.println(gcd(new long[] { 10, 12, 24, 60 }) == 2);
        long[] oneToNine = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        System.out.println(gcd(oneToNine) == 1);
        System.out.println(lcm(oneToNine));
        long[] oneToTwenty = LongStream.range(1, 21).toArray();
        System.out.println(lcm(oneToTwenty));
    }

    /**
     * Calculates the greatest common divisor of 2 numbers which are not all zero. (see
     * https://en.wikipedia.org/wiki/Greatest_common_divisor)
     * 
     * Recursive version of Euclidean algorithm (https://en.wikipedia.org/wiki/Euclidean_algorithm)
     * 
     * @param m
     * @param n
     * @return greatest common divisor of m and n
     */
    public static long gcd(long m, long n) {
        if (m == 0 || n == 0) {
            return m + n;
        } else {
            return gcd(n, m % n);
        }
    }

    /**
     * Calculates the greatest common divisor of n numbers. The array should have at least one number which isn't zero.
     * 
     * @param numbers
     * @return greatest common divisor of numbers
     */
    public static long gcd(long[] numbers) {
        long result = numbers[0];
        for (int i = 1; i < numbers.length; i++) {
            result = gcd(result, numbers[i]);
        }
        return result;
    }

    /**
     * Calculates the least common multiple of 2 numbers which are both non zero. see
     * https://en.wikipedia.org/wiki/Least_common_multiple
     * 
     * @param m
     * @param n
     * @return least common multiple of m and n
     */
    public static long lcm(long m, long n) {
        return m * (n / gcd(m, n));
    }

    /**
     * Calculates the least common multiple of n numbers. The array should have at least one number and shouldn't contain
     * any zero.
     * 
     * @param numbers
     * @return least common multiple of numbers
     */
    public static long lcm(long[] numbers) {
        long result = numbers[0];
        for (int i = 1; i < numbers.length; i++) {
            result = lcm(result, numbers[i]);
        }
        return result;
    }
}

它输出：

true
true
true
true
true
true
true
2520
232792560

Answer 8

虽然这可能不是最理想的，但它确实会浓缩您的陈述：

public static void main(String[] args)
{
    int remainder;
    for (int i = 100; i < 10000; i++) 
    { 
       remainder=0;
       for (int j=2; j<10; j++) 
           remainder+=i % j; 
       if (remainder == 0)
            System.out.println(i);
   }
}

对于每个 i，我们使用内部循环 j 将其与从 2 到 9 的每个数字取模。我们将每个取模结果添加到余数变量中。

在内循环结束时，只有当这个 i 的所有模数都为零时，余数仍然为零。

Answer 9

实际上有两个问题：第一部分是，如何将 9 个条件相似的 if 语句压缩成更易读的形式。另一个可能是无意的问题是，应该如何将“一位数的 LCM”之类的内容添加到代码中。让我们从后者开始，下面进入前者。

谷歌搜索结果

如果你的程序中需要这种数字（而不是程序计算它的唯一目的），你应该通过最简单的必要手段获得它（在这种情况下，@987654321 @)，并将其作为常量包含在您的程序中，可能还带有一些关于数字来自何处的注释。

如果您不能直接找到它，请尝试自己计算它（就像 rgettman 所做的那样），然后再次将其包含为常量。如果失败或花费太多时间，请编写一次性程序来计算数字，但不要使用常量将其作为更大程序的一部分。不过，将一次性代码存储在某处 是个好主意。评论可能是正确的地方。

遍历数组

现在是关于压缩 if 语句的内容。

有一些使用流的解决方案，但在您的情况下，一个简单的数组可能会更好。此代码也更通用，您可以轻松地将其移植到几乎任何语言，并且它与数字没有任何关联（您可以使用任何东西的数组）。奖励点 - 任何人都应该理解。

static boolean divisibleByAll(int n, int[] divisors) {
    for (int d : divisors) {
        if (n % d != 0) {
            return false;
        }
    }
    return true;
}

static int lcmOfSingleDigits() {
    int[] divisors = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    for (int i = 100; i < 10000; i++) {
        if (divisibleByAll(i, divisors)) {
            return i;
        }
    }
    return -1;  // Perhaps better to throw an exception
}

public static void main(String args[]) {
    System.out.println("Smallest number divisible by all one digit numbers: " +
                       lcmOfSingleDigits());
}

使用流

大多数 Java-ish 解决方案，这就是您应该在实践中使用的解决方案 - 除非您需要非 Java 程序员来阅读您的代码。 saka1029 和 pkpnd 的回答都涵盖了，不再赘述。

Answer 10

正如其他几个人所提到的，您正在尝试做的是计算数字 1、2、3、...、9 的 least common multiple。

但是您如何在计算机中做到这一点？首先，您需要知道如何计算两个数字的greatest common divisor：

function gcd2(a, b)
    while b ≠ 0
        t := b; 
        b := a mod b; 
        a := t; 
    return a;

现在，两个数的最小公倍数可以通过一个简单的公式从它们的最大公约数中计算出来：

function lcm2(a, b)
    if a = 0 and b = 0
        return 0;
    else
        return abs(a*b) / gcd2(a,b);

（a 和 b 都为零的特殊情况是避免被零除的必要条件。）

最后，LCM(a,b,c) = LCM(LCM(a,b),c)，所以要计算两个以上数字的 LCM，迭代一个列表：

function lcmN(ns)
    let rv := 1;
    for n in ns
        rv := lcm2(rv, n);
    return rv;

将伪代码翻译成 Java 留作练习。

Answer 11

从 Java 8 开始，您可以使用Stream 方法（特别是使用IntStream）。

首先，我们使用IntStream.rangeClosed(2, 9)（或等效的IntStream.range(2, 10)）来获取以2 开头并以9（含）结尾的连续Integers 流。我们可以通过使用.allMatch(...) 将此流转换为boolean，当且仅当每个流元素 匹配某些条件时，它才会返回true。所需标准以lambda expression、n -> i % n == 0 的形式提供。这可以写成(Integer n) -> (i % n == 0)，因此 lambda 表达式将来自名为n 的流中的Integer 作为输入，并返回i（循环计数器）是否可以被n 整除。因此，如果 i 可以被流中的每个 Integer 整除，.allMatch(n -> i % n == 0) 将返回 true。

我们需要再做一个修改：lambda 表达式中使用的变量（例如i）必须实际上是final：

一个变量或参数，其值在初始化后永远不会改变，它实际上是最终的。 (Oracle documentation)

但是，循环计数器i不是实际上是最终的，因为它每次迭代都会递增（因此重新分配）。解决方案是在循环内声明一个新变量int x = i;，这样x 在其范围内只分配一次（即循环的一次迭代）。因此，x实际上是最终的，可以在 lambda 表达式中使用。

这是最终的解决方案：

import java.util.stream.IntStream;

public static void main(String[] args) {
    for (int i = 100; i < 10000; i++) {
        int x = i; // x is effectively final
        if (IntStream.rangeClosed(2, 9).allMatch(n -> x % n == 0)) {
            System.out.println(i);
            break;
        }
    }
}

Answer 12

起初您会认为可以通过将 2 到 9 的乘积放在 % 运算符的右侧来一次测试所有这些。

if (i % (2 * 3 * 4 * 5 * 6 * 7 * 8 * 9) == 0)

但由于某些数字在其因式分解中包含先前的数字，因此您应该使用较小的数字，特别是最小公倍数。 8 是 2 和 4 的倍数，9 是 3 的倍数，如果乘积中有 8 和 9，那么 6 (2 * 3) 也包括在内。

if (i % (5 * 7 * 8 * 9) == 0)

结果是 2520，这是最小公倍数。使用2520 并在评论中解释为什么使用这个数字会更具可读性。

/**
 * The goal is to test if the number is a multiple of all integers
 * from 2 through 9.  Mathematically, the least common multiple to is a
 * multiple of all its input numbers.  Here, the LCM of 2, 3, ..., 9 is 2520.
 */
public static final int LCM_2_THRU_9 = 2520;

我已经声明了一个常量，我将在这里使用它：

if (i % LCM_2_THRU_9 == 0)

Answer 13

正如之前回答的那样，编写您正在尝试做的事情的最简洁的方法可能是检查 2 到 9 的乘积。

但是，要回答您关于如何压缩 if 语句的问题；嵌套的 if 语句等价于逻辑运算符 AND，因此您也可以按以下方式编写 if 语句：

if (i % 2 == 0 && i % 3 == 0 && i % 4 == 0 && i % 5 == 0 && i % 6 == 0 && i % 7 == 0 && i % 8 == 0 && i % 9 == 0) {
System.out.println(i);
}