Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimum and Maximum LCM among all pairs (i, j) in range [L, R]

  • Last Updated : 11 Nov, 2021

Given two positive integers L and R representing a range. The task is to find the minimum and maximum possible LCM of any pair (i, j) in the range [L, R] such that L ≤ i < j ≤ R.

Examples:

Input: L = 2, R = 6
Output: 4 30
Explanations: Following are the pairs with minimum and maximum LCM in range [2, 6].
Minimum LCM –> (2, 4) = 4
Maximum LCM –> (5, 6) = 30

Input: L = 5, R = 93
Output: 10 8556

 

Approach: This problem can be solved by using simple Mathematics. Follow the steps below to solve the given problem. 

For Minimum LCM,

  • One number would be for sure the minimum number in the range [L, R].
  • Choose numbers in such a way that one is a factor of the other.
  • The only number with L that gives the minimum LCM is 2*L.
  • Check if 2*L <= R
    • If Yes, the Minimum LCM would be 2*L
    • Otherwise, the Minimum LCM would be L*(L+1).

For Maximum LCM,  

  • One number would be for sure the maximum number in the range [L, R] that is R.
  • Choose a second number such that it is co-prime with R and the product of both is maximum.
  • R and R-1 will be always co-prime if R!=2.
  • Therefore, R*(R-1) will be giving the maximum LCM.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find minimum LCM in range [L, R]
int minLCM(int L, int R)
{
 
    // If 2*L is within the the range
    // then minimum LCM would be 2*L
    if (2 * L <= R)
        return 2 * L;
 
    // Otherwise L * (L+1) would give
    // the minimum LCM
    else
        return L * (L + 1);
}
 
// Function to find maximum LCM in range [L, R]
int maxLCM(int L, int R)
{
 
    // The only possible equation that will give
    // the maximum LCM is R * (R-1)
    return R * (R - 1);
}
 
// Driver Code
int main()
{
    int L = 2;
    int R = 6;
 
    cout << minLCM(L, R) << ' ';
    cout << maxLCM(L, R);
}
Java



// Java program for the above approach
 
class GFG {
 
    // Function to find minimum LCM in range [L, R]
    public static int minLCM(int L, int R) {
 
        // If 2*L is within the the range
        // then minimum LCM would be 2*L
        if (2 * L <= R)
            return 2 * L;
 
        // Otherwise L * (L+1) would give
        // the minimum LCM
        else
            return L * (L + 1);
    }
 
    // Function to find maximum LCM in range [L, R]
    public static int maxLCM(int L, int R) {
 
        // The only possible equation that will give
        // the maximum LCM is R * (R-1)
        return R * (R - 1);
    }
 
    // Driver Code
    public static void main(String args[]) {
        int L = 2;
        int R = 6;
 
        System.out.print(minLCM(L, R) + " ");
        System.out.print(maxLCM(L, R));
    }
}
Python3



# Python program for the above approach
 
# Function to find minimum LCM in range [L, R]
def minLCM(L, R):
 
  # If 2*L is within the the range
  # then minimum LCM would be 2*L
  if (2 * L <= R):
    return 2 * L
 
  # Otherwise L * (L+1) would give
  # the minimum LCM
  else:
    return L * (L + 1)
 
# Function to find maximum LCM in range [L, R]
def maxLCM(L, R):
 
  # The only possible equation that will give
  # the maximum LCM is R * (R-1)
  return R * (R - 1);
 
# Driver Code
if __name__=="__main__":
   
  L = 2;
  R = 6;
 
  print(minLCM(L, R),end=' ')
  print(maxLCM(L, R))
 
#This code is contributed by Akash Jha
C#



// C# program for the above approach
using System;
class GFG
{
 
    // Function to find minimum LCM in range [L, R]
    public static int minLCM(int L, int R)
    {
 
        // If 2*L is within the the range
        // then minimum LCM would be 2*L
        if (2 * L <= R)
            return 2 * L;
 
        // Otherwise L * (L+1) would give
        // the minimum LCM
        else
            return L * (L + 1);
    }
 
    // Function to find maximum LCM in range [L, R]
    public static int maxLCM(int L, int R)
    {
 
        // The only possible equation that will give
        // the maximum LCM is R * (R-1)
        return R * (R - 1);
    }
 
    // Driver Code
    public static void Main()
    {
        int L = 2;
        int R = 6;
 
        Console.Write(minLCM(L, R) + " ");
        Console.Write(maxLCM(L, R));
    }
}
Javascript



<script>
// Javascript program for the above approach
 
 
// Function to find minimum LCM in range [L, R]
function minLCM(L, R) {
 
  // If 2*L is within the the range
  // then minimum LCM would be 2*L
  if (2 * L <= R)
    return 2 * L;
 
  // Otherwise L * (L+1) would give
  // the minimum LCM
  else
    return L * (L + 1);
}
 
// Function to find maximum LCM in range [L, R]
function maxLCM(L, R) {
 
  // The only possible equation that will give
  // the maximum LCM is R * (R-1)
  return R * (R - 1);
}
 
// Driver Code
 
let L = 2;
let R = 6;
 
document.write(minLCM(L, R) + ' ');
document.write(maxLCM(L, R));
</script>
Output
4 30
Time Complexity: O(1) 
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Previous
Maximize the product of sum and least power by choosing at most K elements from given value and power Arrays
Next

How to create an unordered_map of tuples in C++?
Recommended Articles
Page :
Sum of LCM(1, n), LCM(2, n), LCM(3, n), ... , LCM(n, n)
28, Dec 18
Maximum LCM among all pairs (i, j) of first N natural numbers
23, Oct 19
Minimum replacement of pairs by their LCM required to reduce given array to its LCM
08, Sep 20
Minimum LCM and GCD possible among all possible sub-arrays
25, Feb 19
Maximum GCD among all pairs (i, j) of first N natural numbers
08, Sep 20
Minimum LCM of all pairs in a given array
31, May 20
Count distinct XOR values among pairs using numbers in range 1 to N
23, Dec 21
Generate a pair of integers from a range [L, R] whose LCM also lies within the range
04, Sep 20
Count of all possible pairs having sum of LCM and GCD equal to N
31, Jul 20
Pair of integers having least GCD among all given pairs having GCD exceeding K
16, Sep 20
Sum of bit differences among all pairs
06, Oct 15
Find the GCD of LCM of all unique pairs in an Array
14, May 20
Minimum and maximum number of N chocolates after distribution among K students
25, Oct 18
Distributed C candies among N boys such that difference between maximum and minimum candies received is K
08, Apr 21
Maximum range length such that A[i] is maximum in given range for all i from [1, N]
05, Jul 21
Maximum sum among all (a x b) submatrices for given Q queries
29, Jun 21
Maximum sum of segments among all segments formed in array after Q queries
20, Sep 21
Count of pairs having even and odd LCM from an array
14, Feb 21
Number of pairs such that their HCF and LCM is equal
25, Mar 20
Given GCD G and LCM L, find number of possible pairs (a, b)
20, Jun 17
Minimum LCM of all subarrays of length at least 2
15, Jul 20
Count ordered pairs of numbers with a given LCM
23, Sep 20
Count of pairs upto N such whose LCM is not equal to their product for Q queries
24, Apr 20
Java Program for Range LCM Queries
26, Nov 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
athakur42u
@athakur42u
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!