LCM mínimo y máximo entre todos los pares (i, j) en el rango [L, R]

Dados dos enteros positivos L y R que representan un rango. La tarea es encontrar el LCM mínimo y máximo posible de cualquier par (i, j) en el rango [L, R] tal que L ≤ i < j ≤ R .

Ejemplos:

Entrada: L = 2, R = 6
Salida: 4 30
Explicaciones: Los siguientes son los pares con LCM mínimo y máximo en el rango [2, 6].
MCM mínimo –> (2, 4) = 4
MCM máximo –> (5, 6) = 30

Entrada: L = 5, R = 93
Salida: 10 8556

Enfoque: Este problema se puede resolver usando Matemáticas simples. Siga los pasos a continuación para resolver el problema dado. 

Para MCM mínimo ,

• Un número sería con seguridad el número mínimo en el rango [L, R] .
• Escoge números de tal manera que uno sea factor del otro.
• El único número con L que da el MCM mínimo es 2*L .
• Comprobar si 2*L <= R
  • En caso afirmativo, el LCM mínimo sería 2*L
  • De lo contrario, el MCM mínimo sería L*(L+1) .

Para MCM máximo ,  

• Un número sería con seguridad el número máximo en el rango [L, R] que es R .
• Elige un segundo número tal que sea coprimo con R y el producto de ambos sea máximo.
• R y R-1 siempre serán coprimos si R!=2 .
• Por lo tanto, R*(R-1) estará dando el MCM máximo.

A continuación se muestra la implementación del enfoque anterior:

// 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 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 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 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));
    }
}

# 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 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# 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 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));
    }
}

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

4 30

Tiempo Complejidad: O(1) 
Espacio Auxiliar: O(1)