How to condense my 9 if statements into one

Question

I wanted to see what the smallest number divisible by all one digit numbers was and instead of looking it up I created this.

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;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

As you can see, I have an if statement in an if statement x9. The code worked but I wanted to condense my if statements using an array to make my if statement like this but it didn't work.

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

Any suggestions?

Answer 1

At first you would think you can test all of them at once by placing the product of 2 through 9 on the right side of the % operator.

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

But because certain numbers include previous numbers in their factorization, you should use a lower number, specifically, the least common multiple. 8 is a multiple of 2 and 4, 9 is a multiple of 3, and if 8 and 9 are in the product, then 6 (2 * 3) is covered too.

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

That turns out to be 2520, which is the least common multiple. It would much more readable to use 2520 and explain in a comment why this number is used.

/**
 * 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;

I've declared a constant and I'll use it here:

if (i % LCM_2_THRU_9 == 0)

Answer 2

Try this.

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

Or you can write this as one statement.

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 3

As previously answered probably the neatest way to write what you are trying to do is to check for the product of 2 through 9.

However, to answer your question on how you can condense if statements; nested if statements are equivalent to the logical operator AND, hence you could also write your if statements in the following manner:

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);
}

Answer 4

Why don't you..

Invert the IFs?

---

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;
    }
}

---

Alternatively, the above code can be refactored further to:

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;
}

---

Further, per @TeePeemm's suggestion, isPrintable() can be reduced to:

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

---

^{1. There are language based shortcuts too, as suggested in other answers. I agree with them.}

^{2. A lot of answers used the LCM of the numbers for making the code concise, but that is a dormant bug waiting to bite. The loop execution completely changes which can be seen by commenting out the break;. The seemingly simple solution introduces a subtle, potential bug.}

Answer 5

In Java 8 onwards, you can use a Stream approach (specifically using IntStream).

First, we use IntStream.rangeClosed(2, 9) (or equivalently, IntStream.range(2, 10)) to obtain a stream of consecutive Integers starting with 2 and ending with 9 (inclusive). We can turn this stream into a boolean by using .allMatch(...), which returns true if and only if every stream element matches some criteria. The desired criteria is provided in the form of a lambda expression, n -> i % n == 0. This can be written verbosely as (Integer n) -> (i % n == 0), so the lambda expression takes as input an Integer from the stream called n, and returns whether i (the loop counter) is divisible by n. Hence, .allMatch(n -> i % n == 0) returns true if i is divisible by every Integer in the stream.

We need to make one more modification: variables used in lambda expressions (such as i) must be effectively final:

A variable or parameter whose value is never changed after it is initialized is effectively final. (Oracle documentation)

However, the loop counter i is not effectively final, since it gets incremented (thus reassigned) every iteration. The solution is to declare a new variable int x = i; inside the loop, so that x is only assigned once within its scope (that is, one iteration of the loop). Hence, x is effectively final and can be used in the lambda expression.

Here's the final solution:

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 6

Much simpler way:

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

And using the same type of structure, main method becomes:

    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 7

What you are basically doing is trying to find the number i which is the LCM of 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9. Initially, you may be intended simply write

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

It would be true if all the numbers were coprime. That means they didn't have any common factor. But In this case, the numbers are not coprime and have common factors. Like 8 = 2*2*2, 4 = 2*2, 6 = 2*3 all have 2. 3 = 1 * 3 , 6 = 2*3, 9 = 3*9 all have 3. So basically we have to take the LCM of the numbers 2,3,4,5,6,7,8,9. See the following edit for correction of the above formula.

The LCM (Least Common Multiple) of the numbers 2,3,4,5,6,7,8,9 is = 2520. So the correct formula passing all the test cases is following

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

Another solution to use would be simply to check all the conditions like following:

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

Answer 8

The question in actually two-fold: first part is, how to compress 9 if statements with similar condition to some more readable form. The other, perhaps unintended question is, how should things like "LCM of single-digit numbers" be added to the code. Let's start with the latter , and go to former below.

Google for the result

If you need this kind of number in your program (instead of the sole purpose of program being computing it), you should just obtain it by the simplest means necessary (in this case, googling for "smallest number divisible by all one digit numbers"), and include in your program as a constant, perhaps with some comment about where the number came from.

If you can't just find it, try computing it yourself (like rgettman did), and again include it as constant. If that fails or takes too much time, write one-off program to compute the number, but don't make it a part of the bigger program using the constant. It's a good idea to store the one-off code somewhere, though. A comment may be the right place.

Iterate over an array

Now that's about compressing the if statement.

There were solutions using streams, though in your case a simple array may be better. This code is also more generic, you can port it to almost any language with minimal effort, and it's not tied in iny way to numbers (you can use an array of anything). Bonus point - anyone should understand it.

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());
}

Use Streams

Most Java-ish solution, that's what you should use in practice - unless you need non-Java programmers to read your code. Covered by saka1029's and pkpnd's answers, so I won't repeat it.

Answer 9

I think you can use LCM (Least Common Multiple) of (1, 2, 3, 4, 5, 6, 7, 8, 9) = 2520, like this:

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

Answer 10

Your loop will take a very long time if you ever try it with the numbers from 1 to 20 or 1 to 30. You could calculate the least common multiple directly :

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;
    }
}

It outputs:

true
true
true
true
true
true
true
2520
232792560

Answer 11

While this might be suboptimal, it would really condense your statements:

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);
   }
}

For each i we use inner loop j to modulo it with each digit from 2 to 9. We add each modulo result to remainder variable.

At the end of inner loop, only if all modulos for this i were zero, the remainder will still be zero.

Answer 12

What you are trying to do, as several other people have mentioned, is compute the least common multiple of the numbers 1, 2, 3, ..., 9.

But how do you do that in a computer? First, you need to know how to compute the greatest common divisor of two numbers:

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

Now, the least common multiple of two numbers can be computed from their greatest common divisor with a simple formula:

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

(The special case for a and b both being zero is necessary to avoid division by zero.)

And finally, LCM(a,b,c) = LCM(LCM(a,b),c), so to compute the LCM of more than two numbers, iterate over a list:

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

Translation of pseudocode to Java is left as an exercise.

Answer 13

Alright, this may not be the best approach, but I wanted to give it a try with an arbitrary set of numbers.

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);
}

So we create an object, Divisor, which has a method that tells you whether a value is divisible by itself or not.

The code is run by creating Stream of Longs from 1 to N, filtering out all values that are not divisible by the divisor, and then taking the first one (per your 'break' statement). It returns an Optional. If a value is present, that value will be printed to the stdout.

For this example, per comments made above, I introduced an implementation of Divisor which store the least common multiple of all values added in. When initialized, it has a value of one; but everytime a new value is added, it returns a new instance of the Divisor with the least common multiple. The implementation looks like this:

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;
    }
}