# Find numbers in between [L, R] which are divisible by all Array elements

• Last Updated : 10 Jan, 2022

Given an array arr[] containing N positive integers and two variables L and R indicating a range of integers from L to R (inclusive). The task is to print all the numbers between L to R which are divisible by all array elements. If no such value exists print -1.

Input: arr[] = {3, 5, 12}, L = 90, R = 280
Output: 120 180 240
Explanation: 120, 180, 240 are the numbers which are divisible by all the arr[] elements.

Input: arr[] = {4, 7, 13, 16}, L = 200, R = 600
Output: -1

Naive Approach: In this approach for every element in range [L, R] check if it is divisible by all the elements of the array.

Time Complexity: O((R-L)*N)
Auxiliary Space: O(1)

Efficient Approach: The given problem can be solved using basic math. Any element divisible by all the elements of the array is a multiple of the LCM of all the array elements. Find the multiples of LCM in the range [L, R] and store in an array. At last print the numbers stored in the array.

Time Complexity: O(N)
Auxiliary Space: O(R – L)

Space Optimized Approach: Below steps can be used to solve the problem:

1. Calculate the LCM of all the elements of given arr[]
2. Now, check the LCM for these conditions:
1. If (LCM < L and LCM*2 > R), then print -1.
2. If (LCM > R), then print -1.
3. Now, take the nearest value of L (between L to R) which is divisible by the LCM, say i.
4. Now, start printing i and increment it by LCM every time after printing, until it becomes greater than R.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to return Kth smallest``// prime number if it exists``void` `solve(``int``* arr, ``int` `N, ``int` `L, ``int` `R)``{``    ``// For storing the LCM``    ``int` `LCM = arr;` `    ``// Loop to iterate the array``    ``for` `(``int` `i = 1; i < N; i++) {``        ``// Taking LCM of numbers``        ``LCM = (LCM * arr[i]) /``            ``(__gcd(LCM, arr[i]));``    ``}` `    ``// Checking if no elements is divisible``    ``// by all elements of given array of given``    ``// range, print -1``    ``if` `((LCM < L && LCM * 2 > R) || LCM > R) {``        ``cout << ``"-1"``;``        ``return``;``    ``}` `    ``// Taking nearest value of L which is``    ``// divisible by whole array``    ``int` `k = (L / LCM) * LCM;` `    ``// If k is less than L, make it in the``    ``// range between L to R``    ``if` `(k < L)``        ``k = k + LCM;` `    ``// Loop to iterate the from L to R``    ``// and printing the numbers which``    ``// are divisible by all array elements``    ``for` `(``int` `i = k; i <= R; i = i + LCM) {``        ``cout << i << ``' '``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `L = 90;``    ``int` `R = 280;``    ``int` `arr[] = { 3, 5, 12 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``solve(arr, N, L, R);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Recursive function to return gcd of a and b``static` `int` `__gcd(``int` `a, ``int` `b)``{``    ` `    ``// Everything divides 0``    ``if` `(a == ``0``)``        ``return` `b;``    ``if` `(b == ``0``)``        ``return` `a;``  ` `    ``// Base case``    ``if` `(a == b)``        ``return` `a;``  ` `    ``// a is greater``    ``if` `(a > b)``        ``return` `__gcd(a - b, b);``        ` `    ``return` `__gcd(a, b - a);``}` `// Function to return Kth smallest``// prime number if it exists``static` `void` `solve(``int``[] arr, ``int` `N, ``int` `L, ``int` `R)``{``    ` `    ``// For storing the LCM``    ``int` `LCM = arr[``0``];` `    ``// Loop to iterate the array``    ``for``(``int` `i = ``1``; i < N; i++)``    ``{``        ` `        ``// Taking LCM of numbers``        ``LCM = (LCM * arr[i]) /``        ``(__gcd(LCM, arr[i]));``    ``}` `    ``// Checking if no elements is divisible``    ``// by all elements of given array of given``    ``// range, print -1``    ``if` `((LCM < L && LCM * ``2` `> R) || LCM > R)``    ``{``        ``System.out.println(``"-1"``);``        ``return``;``    ``}` `    ``// Taking nearest value of L which is``    ``// divisible by whole array``    ``int` `k = (L / LCM) * LCM;` `    ``// If k is less than L, make it in the``    ``// range between L to R``    ``if` `(k < L)``        ``k = k + LCM;` `    ``// Loop to iterate the from L to R``    ``// and printing the numbers which``    ``// are divisible by all array elements``    ``for``(``int` `i = k; i <= R; i = i + LCM)``    ``{``        ``System.out.print(i + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``int` `L = ``90``;``    ``int` `R = ``280``;``    ``int` `arr[] = { ``3``, ``5``, ``12` `};``    ``int` `N = arr.length;``    ` `    ``solve(arr, N, L, R);``}``}` `// This code is contributed by sanjoy_62`

## Python3

 `# Python program for the above approach` `# Recursive function to return gcd of a and b``def` `__gcd(a, b):``    ``# Everything divides 0``    ``if` `(a ``=``=` `0``):``        ``return` `b;``    ``if` `(b ``=``=` `0``):``        ``return` `a;` `    ``# Base case``    ``if` `(a ``=``=` `b):``        ``return` `a;` `    ``# a is greater``    ``if` `(a > b):``        ``return` `__gcd(a ``-` `b, b);` `    ``return` `__gcd(a, b ``-` `a);`  `# Function to return Kth smallest``# prime number if it exists``def` `solve(arr, N, L, R):``  ` `    ``# For storing the LCM``    ``LCM ``=` `arr[``0``];` `    ``# Loop to iterate the array``    ``for` `i ``in` `range``(``1``, N):``      ` `        ``# Taking LCM of numbers``        ``LCM ``=` `(LCM ``*` `arr[i]) ``/``/` `(__gcd(LCM, arr[i]));` `    ``# Checking if no elements is divisible``    ``# by all elements of given array of given``    ``# range, pr-1``    ``if` `((LCM < L ``and` `LCM ``*` `2` `> R) ``or` `LCM > R):``        ``print``(``"-1"``);``        ``return``;` `    ``# Taking nearest value of L which is``    ``# divisible by whole array``    ``k ``=` `(L ``/``/` `LCM) ``*` `LCM;` `    ``# If k is less than L, make it in the``    ``# range between L to R``    ``if` `(k < L):``        ``k ``=` `k ``+` `LCM;` `    ``# Loop to iterate the from L to R``    ``# and printing the numbers which``    ``# are divisible by all array elements``    ``for` `i ``in` `range``(k,R``+``1``,LCM):``        ``print``(i, end``=``" "``);` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``L ``=` `90``;``    ``R ``=` `280``;``    ``arr ``=` `[``3``, ``5``, ``12``];``    ``N ``=` `len``(arr);` `    ``solve(arr, N, L, R);` `# This code is contributed by 29AjayKumar`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `GFG{` `  ``// Recursive function to return gcd of a and b``  ``static` `int` `__gcd(``int` `a, ``int` `b)``  ``{` `    ``// Everything divides 0``    ``if` `(a == 0)``      ``return` `b;``    ``if` `(b == 0)``      ``return` `a;` `    ``// Base case``    ``if` `(a == b)``      ``return` `a;` `    ``// a is greater``    ``if` `(a > b)``      ``return` `__gcd(a - b, b);` `    ``return` `__gcd(a, b - a);``  ``}` `  ``// Function to return Kth smallest``  ``// prime number if it exists``  ``static` `void` `solve(``int``[] arr, ``int` `N, ``int` `L, ``int` `R)``  ``{` `    ``// For storing the LCM``    ``int` `LCM = arr;` `    ``// Loop to iterate the array``    ``for``(``int` `i = 1; i < N; i++)``    ``{` `      ``// Taking LCM of numbers``      ``LCM = (LCM * arr[i]) /``        ``(__gcd(LCM, arr[i]));``    ``}` `    ``// Checking if no elements is divisible``    ``// by all elements of given array of given``    ``// range, print -1``    ``if` `((LCM < L && LCM * 2 > R) || LCM > R)``    ``{``      ``Console.WriteLine(``"-1"``);``      ``return``;``    ``}` `    ``// Taking nearest value of L which is``    ``// divisible by whole array``    ``int` `k = (L / LCM) * LCM;` `    ``// If k is less than L, make it in the``    ``// range between L to R``    ``if` `(k < L)``      ``k = k + LCM;` `    ``// Loop to iterate the from L to R``    ``// and printing the numbers which``    ``// are divisible by all array elements``    ``for``(``int` `i = k; i <= R; i = i + LCM)``    ``{``      ``Console.Write(i + ``" "``);``    ``}``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String []args)``  ``{``    ``int` `L = 90;``    ``int` `R = 280;``    ``int` `[]arr = { 3, 5, 12 };``    ``int` `N = arr.Length;` `    ``solve(arr, N, L, R);``  ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 `  ```
Output
`120 180 240 `

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up