Módulo de producto mínimo N posible para cualquier par de un rango dado

Dados tres números enteros L , R y N , la tarea es encontrar el valor mínimo posible de (i * j) % N , donde L ≤ i < j ≤ R .

Ejemplos:

Entrada: L = 2020, R = 2040, N = 2019
Salida: 2
Explicación: (2020 * 2021) % 2019 = 2

Entrada: L = 15, R = 30, N = 15
Salida: 0
Explicación: Si uno de los elementos del par es 15, entonces el producto de todos esos pares será divisible por 15. Por lo tanto, el resto será 0, que es el mínimo posible.

Enfoque: El problema dado se puede resolver encontrando la diferencia entre L y R . Si la diferencia es al menos N , entonces el resultado será 0 . De lo contrario, itere sobre el rango [L, R] y encuentre el producto mínimo.

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

// C++ program for the above approach
 
#include <bits/stdc++.h>
#define ll long long
using namespace std;
 
// Function to return the minimum
// possible value of (i * j) % N
void minModulo(int L, int R, int N)
{
    if (R - L < N) {
 
        // Stores the minimum remainder
        int ans = INT_MAX;
 
        // Iterate from L to R
        for (ll i = L; i <= R; i++)
 
            // Iterate from L to R
            for (ll j = L; j <= R; j++)
                if (i != j)
                    ans = min(0ll + ans,
                              (i * j) % N);
 
        // Print the minimum value
        // of remainder
        cout << ans;
    }
 
    // If R - L >= N
    else {
        cout << 0;
    }
}
 
// Driver Code
int main()
{
    int L = 6, R = 10, N = 2019;
    minModulo(L, R, N);
 
    return 0;
}

// java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
public class GFG
{
 
    // Function to return the minimum
    // possible value of (i * j) % N
    static void minModulo(int L, int R, int N)
    {
        if (R - L < N)
        {
 
            // Stores the minimum remainder
            int ans = Integer.MAX_VALUE;
 
            // Iterate from L to R
            for (int i = L; i <= R; i++)
 
                // Iterate from L to R
                for (int j = L; j <= R; j++)
                    if (i != j)
                        ans = Math.min(ans, (i * j) % N);
 
            // Print the minimum value
            // of remainder
            System.out.println(ans);
        }
 
        // If R - L >= N
        else {
            System.out.println(0);
        }
    }
   
    // Driver Code
    public static void main(String[] args)
    {
 
        int L = 6, R = 10, N = 2019;
        minModulo(L, R, N);
    }
}
 
// This code is contributed by Kingash.

# Python3 program for the above approach
 
# Function to return the minimum
# possible value of (i * j) % N
def minModulo(L, R, N):
     
    if (R - L < N):
         
        # Stores the minimum remainder
        ans = 10**9
 
        # Iterate from L to R
        for i in range(L, R + 1):
             
            # Iterate from L to R
            for j in range(L, R + 1):
                if (i != j):
                    ans = min(ans, (i * j) % N)
 
        # Print the minimum value
        # of remainder
        print (ans)
 
    # If R - L >= N
    else:
        print (0)
 
# Driver Code
if __name__ == '__main__':
     
    L, R, N = 6, 10, 2019
    minModulo(L, R, N)
 
# This code is contributed by mohit kumar 29

// C# program for the above approach
using System;
 
class GFG{
 
// Function to return the minimum
// possible value of (i * j) % N
static void minModulo(int L, int R, int N)
{
    if (R - L < N)
    {
         
        // Stores the minimum remainder
        int ans = Int32.MaxValue;
 
        // Iterate from L to R
        for(int i = L; i <= R; i++)
 
            // Iterate from L to R
            for(int j = L; j <= R; j++)
                if (i != j)
                    ans = Math.Min(ans, (i * j) % N);
 
        // Print the minimum value
        // of remainder
        Console.WriteLine(ans);
    }
 
    // If R - L >= N
    else
    {
        Console.WriteLine(0);
    }
}
 
// Driver Code
public static void Main(string[] args)
{
    int L = 6, R = 10, N = 2019;
    minModulo(L, R, N);
}
}
 
// This code is contributed by ukasp

<script>
 
// Javascript implementation
// for the above approach
 
    // Function to return the minimum
    // possible value of (i * j) % N
    function minModulo(L, R, N)
    {
        if (R - L < N)
        {
  
            // Stores the minimum remainder
            let ans = Number.MAX_VALUE;
  
            // Iterate from L to R
            for (let i = L; i <= R; i++)
  
                // Iterate from L to R
                for (let j = L; j <= R; j++)
                    if (i != j)
                        ans = Math.min(ans, (i * j) % N);
  
            // Print the minimum value
            // of remainder
            document.write(ans);
        }
  
        // If R - L >= N
        else {
            document.write(0);
        }
    }
  
 
// Driver Code
     
    let L = 6, R = 10, N = 2019;
        minModulo(L, R, N);
       
    // This code is contributed by susmitakundugoaldanga.
</script>

42

Complejidad de Tiempo: O((R – L) ² )
Espacio Auxiliar: O(1), ya que no se ha tomado espacio extra.