Skip to content
Related Articles

Related Articles

Smallest n digit number divisible by given three numbers
  • Difficulty Level : Easy
  • Last Updated : 13 Apr, 2021

Given x, y, z and n, find smallest n digit number which is divisible by x, y and z. 
Examples: 
 

Input : x = 2, y = 3, z = 5
        n = 4
Output : 1020

Input : x = 3, y = 5, z = 7
        n = 2
Output : Not possible

 

1) Find smallest n digit number is pow(10, n-1). 
2) Find LCM of given 3 numbers x, y and z. 
3) Find remainder of the LCM when divided by pow(10, n-1). 
4) Add the “LCM – remainder” to pow(10, n-1). If this addition is still a n digit number, we return the result. Else we return Not possible.
Illustration : 
Suppose n = 4 and x, y, z are 2, 3, 5 respectively. 
1) First find the least four digit number i.e. 1000, 
2) LCM of 2, 3, 5 so the LCM is 30. 
3) Find the reminder of 1000 % 30 = 10 
4) Subtract the remainder from LCM, 30 – 10 = 20. Result is 1000 + 20 = 1020.
Below is the implementation of above approach: 
 

C++




// C++ program to find smallest n digit number
// which is divisible by x, y and z.
#include <bits/stdc++.h>
using namespace std;
 
// LCM for x, y, z
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
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 = 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 < pow(10, n))
        return ndigitnumber;
    else
        return 0;
}
 
// driver code
int main()
{
    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)
        cout << res;
    else
        cout << "Not possible";
 
    return 0;
}

Java




// 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.

Python3




# Python3 code to find smallest n digit
# number which is divisible by x, y and z.
from fractions import gcd
import math
 
# LCM for x, y, z
def LCM( x , y , z ):
    ans = int((x * y) / (gcd(x, y)))
    return int((z * ans) / (gcd(ans, z)))
     
# returns smallest n digit number
# divisible by x, y and z
def findDivisible (n, x, y, z):
     
    # find the LCM
    lcm = LCM(x, y, z)
     
    # find power of 10 for least number
    ndigitnumber = math.pow(10, n-1)
     
    # reminder after
    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 int(ndigitnumber)
    else:
        return 0
 
# driver code
n = 4
x = 2
y = 3
z = 5
res = findDivisible(n, x, y, z)
 
# if number is possible then
# it print the number
if res != 0:
    print( res)
else:
    print("Not possible")
     
# This code is contributed by "Sharad_Bhardwaj".

C#




// C# program to find smallest n digit number
// which is divisible by x, y and z.
using System;
 
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 ()
    {
        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)
            Console.WriteLine(res);
        else
            Console.WriteLine("Not possible");
             
    }
}
// This code is contributed by vt_m.

PHP




<?php
// php program to find smallest n digit number
// which is divisible by x, y and z.
 
// gcd function
function gcd($a, $b) {
    return ($a % $b) ? gcd($b, $a % $b) : $b;
}
 
// LCM for x, y, z
function LCM($x, $y, $z)
{
    $ans = floor(($x * $y) / (gcd($x, $y)));
    return floor(($z * $ans) / (gcd($ans, $z)));
}
 
// returns smallest n digit number divisible
// by x, y and z
function findDivisible($n, $x, $y, $z)
{
     
    // find the LCM
    $lcm = LCM($x, $y, $z);
 
    // find power of 10 for least number
    $ndigitnumber = pow(10, $n-1);
     
    // reminder after
    $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 < pow(10, $n))
        return $ndigitnumber;
    else
        return 0;
}
 
// driver code
    $n = 4;
    $x = 2;
    $y = 3;
    $z = 5;
    $res = findDivisible($n, $x, $y, $z);
 
    // if number is possible then
    // it print the number
    if ($res != 0)
        echo $res;
    else
        echo "Not possible";
 
// This code is contributed by mits.
?>

Javascript




<script>
 
// JavaScript program to find smallest n digit number
// which is divisible by x, y and z.
   function __gcd(a, b)
        {
           
            if(b == 0)
            {
                return a;
            }
            else
            {
                return __gcd(b, a % b);
            }
        }
       
    // LCM for x, y, z
    function LCM(x, y, z)
    {
        let ans = ((x * y) / (__gcd(x, y)));
        return ((z * ans) / (__gcd(ans, z)));
    }
       
    // returns smallest n digit number divisible
    // by x, y and z
    function findDivisible(n, x, y, z)
    {
     
        // find the LCM
        let lcm = LCM(x, y, z);
       
        // find power of 10 for least number
        let ndigitnumber = Math.pow(10, n - 1);
           
        // reminder after
        let 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
 
        let n = 4, x = 2, y = 3, z = 5;
        let res = findDivisible(n, x, y, z);
       
        // if number is possible then
        // it prlet the number
        if (res != 0)
            document.write(res);
        else
            document.write("Not possible");
       
      // This code is contributed by chinmoy1997pal.
</script>

Output: 
 

1020

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :