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:
- Calculate the LCM of all the elements of given arr[]
- Now, check the LCM for these conditions:
- If (LCM < L and LCM*2 > R), then print -1.
- If (LCM > R), then print -1.
- Now, take the nearest value of L (between L to R) which is divisible by the LCM, say i.
- 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++ program for the above approach #include <bits/stdc++.h> 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[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) {
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[0]);
solve(arr, N, L, R);
return 0;
} |
// 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 |
# 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# 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[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)
{
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 |
<script>
// JavaScript code for the above approach
// Recursive function to return gcd of a and b
function __gcd(a, b) {
// Everything divides 0
if (b == 0) {
return a;
}
return __gcd(b, a % b);
}
// Function to return Kth smallest
// prime number if it exists
function solve(arr, N, L, R)
{
// For storing the LCM
let LCM = arr[0];
// Loop to iterate the array
for (let i = 1; i < N; i++)
{
// Taking LCM of numbers
LCM = Math.floor((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) {
document.write( "-1" );
return ;
}
// Taking nearest value of L which is
// divisible by whole array
let k = Math.floor((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 (let i = k; i <= R; i = i + LCM) {
document.write(i + " " );
}
}
// Driver Code
let L = 90;
let R = 280;
let arr = [3, 5, 12];
let N = arr.length;
solve(arr, N, L, R);
// This code is contributed by Potta Lokesh </script>
|
120 180 240
Time Complexity: O(N)
Auxiliary Space: O(1)