Finding the smallest positive number evenly divisible by a range of numbers
There are two parts to my initial assessment of your code.

Firstly, often the 'best' way to solve a problem where you are tempted to have a found = true type situation is to call a seperate method for that part of the work, and to simply 'return value' when you find the value... for example, your code:

     for (int i = 1; i &lt;= n; i++) {
         //for 1 to int that was passed divide the current number and see if its divisible
            if (number % i != 0) {
             break;

         } else if (i == n)
             found = true;

     }


would be easily written as:

private static final boolean checkValue(final int value, int n) {
    while (n &gt; 1) {
        if (value % n != 0) {
            return false;
        }
        n--;
    }
    return true;
}


then your main loop becomes:

int number = n;

while (!checkValue(number, n)) {
     number++;
}
System.out.printf("Number %d is divisible by all positive values up to %d\n", number, n);


The second issue I have is for performance..... you should not be using number++, you will save a lot of time if you only check the multiples of the largest number, so:

number += n; // instead of number++;




EDIT

If you look at the math, you will see that, we can do much better than number += n, and can determine that if we find a value that is a multiple of both n and n - 1 that the final result will be a multiple of that value. If we can use that value as the 'step' then we will go faster than just using n. Similarly, if we can find a multiple of all n, n - 1, and n - 2 then that would be a good step too.

So, consider the following:

private static final int checkValue(final long value, int n) {
    while (n &gt; 1) {
        if (value % n != 0) {
            return n;
        }
        n--;
    }
    return 1;
}


This loop now returns the value at which the expression fails....

and we can use that in our main loop as follows:

    final int n = 23;

    long number = n;

    long step = n;
    int fact = n;
    int bestfact = fac;
    while (number &gt; 0 &amp;&amp; (fact = checkValue(number, n)) &gt; 1) {
        if (bestfac &gt; fact) {
            bestfac = fact;
            step = number;
        }
        number += step;
    }

    if (number &lt; 0) {
        System.out.println("No values were found (overflow) divisible by all " + n + " factors");
    }


On my computer, the difference between this optimization and a naieve step, is 0.022ms vs 4961.271ms  (or 225000 times faster!!!!!!!)