Smallest n digit number divisible by given three numbers

public class SmallestNDigitNumber {

    // Function to check if a number is divisible by x, y, and z
    static boolean isDivisibleByXYZ(int number, int x, int y, int z) {
        return number % x == 0 && number % y == 0 && number % z == 0;
    }

    // Function to find the smallest n-digit number which is divisible by x, y, and z
    static int smallestNDigitNumber(int x, int y, int z, int n) {
        // Setting the lower and upper limits for n-digit numbers
        int lowerLimit = (int) Math.pow(10, n - 1);
        int upperLimit = (int) Math.pow(10, n) - 1;

        // Iterating through all n-digit numbers and checking if 
        // they are divisible by x, y, and z
        for (int number = lowerLimit; number <= upperLimit; number++) {
            if (isDivisibleByXYZ(number, x, y, z)) {
                return number;
            }
        }

        // If no n-digit number divisible by x, y, and z is found, return -1
        return -1;
    }

    // Driver code
    public static void main(String[] args) {
        int x = 2;
        int y = 3;
        int z = 5;
        int n = 4;
        System.out.println(smallestNDigitNumber(x, y, z, n)); // Output: 1020
    }
}

// Java program to find smallest n digit number
// which is divisible by x, y and z.
import java.io.*;

public class GFG {

    static int __gcd(int a, int b)
    {

        if (b == 0) {
            return a;
        }
        else {
            return __gcd(b, a % b);
        }
    }

    // LCM for x, y, z
    static int LCM(int x, int y, int z)
    {
        int ans = ((x * y) / (__gcd(x, y)));
        return ((z * ans) / (__gcd(ans, z)));
    }

    // returns smallest n digit number 
    // divisible by x, y and z
    static int findDivisible(int n, int x, 
                                  int y, int z)
    {
        
        // find the LCM
        int lcm = LCM(x, y, z);

        // find power of 10 for least number
        int ndigitnumber = (int)Math.pow(10, n - 1);

        // reminder after
        int reminder = ndigitnumber % lcm;

        // If smallest number itself divides
        // lcm.
        if (reminder == 0)
            return ndigitnumber;

        // add lcm- reminder number for
        // next n digit number
        ndigitnumber += lcm - reminder;

        // this condition check the n digit
        // number is possible or not
        // if it is possible it return
        // the number else return 0
        if (ndigitnumber < Math.pow(10, n))
            return ndigitnumber;
        else
            return 0;
    }

    // driver code
    static public void main(String[] args)
    {

        int n = 4, x = 2, y = 3, z = 5;
        int res = findDivisible(n, x, y, z);

        // if number is possible then
        // it print the number
        if (res != 0)
            System.out.println(res);
        else
            System.out.println("Not possible");
    }
}

// This code is contributed by vt_m.

public class SmallestDivisibleNumber {
    // This function returns the smallest multiple of x with
    // n digits that is divisible by y and z.
    static String smallestDivisibleNumber(int x, int y,
                                          int z, int n)
    {
        // smallest multiple of x with n digits
        int multiple
            = x * (int)Math.floor(Math.pow(10, n - 1) / x);
        while (String.valueOf(multiple).length() == n) {
            if (multiple % y == 0 && multiple % z == 0) {
                return String.valueOf(multiple);
            }
            multiple += x;
        }
        return "Not possible";
    }

    public static void main(String[] args)
    {
        // example usage
        System.out.println(smallestDivisibleNumber(
            2, 3, 5, 4)); // output: 1020
        System.out.println(smallestDivisibleNumber(
            3, 5, 7, 2)); // output: Not possible
    }
}