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>
Output
120 180 240
Time Complexity: O(N)
Auxiliary Space: O(1)
