Encuentre el MCD máximo posible para algún par en un rango dado [L, R]

Dado un rango de L a R , la tarea es encontrar el valor máximo posible de GCD (X, Y) tal que X e Y pertenezcan al rango dado, es decir, L ≤ X < Y ≤ R.

Ejemplos:

Entrada: L = 101, R = 139
Salida:
34
Explicación:
Para X = 102 e Y = 136, el MCD de xey es 34, que es el máximo posible.

Entrada: L = 8, R = 14
Salida:
7 

Enfoque ingenuo: cada par que se puede formar de L a R , se puede iterar usando dos bucles anidados y se puede encontrar el GCD máximo.

Complejidad de tiempo: O((RL) ² Log(R))
Espacio auxiliar: O(1)

Enfoque eficiente: siga los pasos a continuación para resolver el problema:

• Sea Z el MCD máximo , por lo tanto, X e Y son múltiplos de Z. Por el contrario, si hay dos o más múltiplos de Z en el segmento [L, R], entonces (X, Y) se puede elegir de manera que MCD (x, y) sea máximo eligiendo múltiplos consecutivos de Z en [L, R] .
• Iterar de R a 1 y encontrar si alguno de ellos tiene al menos dos múltiplos en el rango [L, R]
• Los múltiplos de Z entre L y R se pueden calcular mediante la siguiente fórmula:
  • Número de múltiplos de Z en [L, R] = Número de múltiplos de Z en [1, R] – Número de múltiplos de Z en [1, L-1]
  • Esto se puede escribir como:
    • No. de múltiplos de Z en [L, R] = piso (R/Z) – piso ((L-1)/Z)
• Podemos optimizar aún más esto limitando la iteración de R/2 a 1 ya que el mayor GCD posible es R/2 (con múltiplos R/2 y R)

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 calculate GCD
int GCD(int a, int b)
{
    if (b == 0)
        return a;
    return GCD(b, a % b);
}
 
// Function to calculate
// maximum GCD in a range
int maxGCDInRange(int L, int R)
{
    // Variable to store the answer
    int ans = 1;
 
    for (int Z = R/2; Z >= 1; Z--) {
 
        // If Z has two multiples in [L, R]
        if ((R / Z) - ((L - 1) / Z) > 1) {
 
            // Update ans
            ans = Z;
            break;
        }
    }
 
    // Return the value
    return ans;
}
// Driver code
int main()
{
    // Input
    int L = 102;
    int R = 139;
 
    // Function Call
    cout << maxGCDInRange(L, R);
 
    return 0;
}

// Java program for the above approach
import java.io.*;
 
class GFG {
    // Function to calculate GCD
    public static int GCD(int a, int b)
    {
        if (b == 0)
            return a;
        return GCD(b, a % b);
    }
 
    // Function to calculate
    // maximum GCD in a range
    public static int maxGCDInRange(int L, int R)
    {
        // Variable to store the answer
        int ans = 1;
 
        for (int Z = R/2; Z >= 1; Z--) {
 
            // If Z has two multiples in [L, R]
            if ((R / Z) - ((L - 1) / Z) > 1) {
 
                // Update ans
                ans = Z;
                break;
            }
        }
 
        // Return the value
        return ans;
    }
   
  // Driver code
    public static void main(String[] args)
    {
        // Input
        int L = 102;
        int R = 139;
 
        // Function Call
        System.out.println(maxGCDInRange(L, R));
    }
 
   
   // This code is contributed by Potta Lokesh

# Python3 program for the above approach
 
# Function to calculate GCD
def GCD(a, b):
     
    if (b == 0):
        return a
         
    return GCD(b, a % b)
 
# Function to calculate
# maximum GCD in a range
def maxGCDInRange(L, R):
     
    # Variable to store the answer
    ans = 1
 
    for Z in range(R//2, 1, -1):
         
        # If Z has two multiples in [L, R]
        if (((R // Z) - ((L - 1) // Z )) > 1):
             
            # Update ans
            ans = Z
            break
         
    # Return the value
    return ans
 
# Driver code
 
# Input
L = 102
R = 139
 
# Function Call
print(maxGCDInRange(L, R))
 
# This code is contributed by SoumikMondal

// C# program for the above approach
using System;
 
class GFG{
     
// Function to calculate GCD
public static int GCD(int a, int b)
{
    if (b == 0)
        return a;
         
    return GCD(b, a % b);
}
 
// Function to calculate
// maximum GCD in a range
public static int maxGCDInRange(int L, int R)
{
     
    // Variable to store the answer
    int ans = 1;
 
    for(int Z = R/2; Z >= 1; Z--)
    {
         
        // If Z has two multiples in [L, R]
        if ((R / Z) - ((L - 1) / Z) > 1)
        {
             
            // Update ans
            ans = Z;
            break;
        }
    }
 
    // Return the value
    return ans;
}
 
// Driver code
public static void Main()
{
     
    // Input
    int L = 102;
    int R = 139;
 
    // Function Call
    Console.Write(maxGCDInRange(L, R));
}
}
 
// This code is contributed by rishavmahato348

<script>
 
// JavaScript program for the above approach
 
// Function to calculate GCD
function GCD( a, b)
{
    if (b == 0)
        return a;
    return GCD(b, a % b);
}
 
// Function to calculate
// maximum GCD in a range
function maxGCDInRange(L, R)
{
 
    // Variable to store the answer
    let ans = 1;
 
    for (let Z = parseInt((R / 2)); Z >= 1; Z--)
    {
     
        // If Z has two multiples in [L, R]
        if (parseInt((R / Z)) - parseInt((L - 1) / Z ) > 1)
        {
         
            // Update ans
            ans = Z;
            break;
        }
    }
 
    // Return the value
    return ans;
}
 
// Driver code
 
// Input
let L = 102;
let R = 139;
 
// Function Call
document.write(maxGCDInRange(L, R));
 
// This code is contributed by Potta Lokesh
 
</script>

34

Complejidad temporal: O(R)
Espacio auxiliar: O(1)