Valor máximo de división de dos números en un Array

Dada una array A de tamaño N (> 2) . La tarea es encontrar el valor máximo de A[i] / A[j]
Nota: A[i] ≠ 0.

Ejemplos: 

Entrada: A[] = {1, 2, 3, 4} 
Salida: 4 
4 / 1 = 4 es el valor máximo posible.

Entrada: A[] = {3, 7, 9, 3, 11} 
Salida: 3 
 

Enfoque ingenuo: un enfoque ingenuo es ejecutar bucles anidados y encontrar la máxima respuesta posible.
Complejidad temporal : O(N ² ).

Enfoque eficiente : un enfoque eficiente es encontrar el elemento máximo y mínimo en la array e imprimir máximo / mínimo

Prueba: 

Tomemos una array A[] = {a, b, c, d} donde a < b < c < d . 
Ahora: 
(b/a) < (c/a) < (d/a) (ya que b < c < d, y el denominador es constante) 
y como a es mínimo, entonces 
d/a es máximo 
 

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

// CPP program to maximum value of
// division of two numbers in an array
#include <bits/stdc++.h>
using namespace std;
 
// Function to maximum value of
// division of two numbers in an array
int Division(int a[], int n)
{
    int maxi = INT_MIN, mini = INT_MAX;
     
    // Traverse through the array
    for (int i = 0; i < n; i++)
    {
        maxi = max(a[i], maxi);
        mini = min(a[i], mini);
    }
     
    // Return the required answer
    return maxi / mini;
}
 
// Driver code
int main()
{
    int a[] = {3, 7, 9, 3, 11};
     
    int n = sizeof(a) / sizeof(a[0]);
     
    cout << Division(a, n);
    return 0;
}

// Java program to maximum value of
// division of two numbers in an array
import java.util.*;
import java.lang.*;
import java.io.*;
 
class GFG
{
 
// Function to maximum value of
// division of two numbers in an array
static int Division(int a[], int n)
{
    int maxi = Integer.MIN_VALUE,
        mini = Integer.MAX_VALUE;
     
    // Traverse through the array
    for (int i = 0; i < n; i++)
    {
        maxi = Math.max(a[i], maxi);
        mini = Math.min(a[i], mini);
    }
     
    // Return the required answer
    return maxi / mini;
}
 
// Driver code
public static void main (String[] args)
              throws java.lang.Exception
{
    int a[] = {3, 7, 9, 3, 11};
     
    int n = a.length;
     
    System.out.print(Division(a, n));
}
}
 
// This code is contributed by Nidhiva

#  Python3 program to maximum value of
# division of two numbers in an array
 
# Function to maximum value of
# division of two numbers in an array
def Division(a, n):
 
    maxi = -10**9
    mini = 10**9
 
    # Traverse through the array
    for i in a:
        maxi = max(i, maxi)
        mini = min(i, mini)
 
    # Return the required answer
    return maxi // mini
 
# Driver code
a = [3, 7, 9, 3, 11]
 
n = len(a)
 
print(Division(a, n))
 
# This code is contributed by Mohit Kumar

// C# program to maximum value of
// division of two numbers in an array
using System;
     
class GFG
{
 
// Function to maximum value of
// division of two numbers in an array
static int Division(int []a, int n)
{
    int maxi = int.MinValue,
        mini = int.MaxValue;
     
    // Traverse through the array
    for (int i = 0; i < n; i++)
    {
        maxi = Math.Max(a[i], maxi);
        mini = Math.Min(a[i], mini);
    }
     
    // Return the required answer
    return maxi / mini;
}
 
// Driver code
public static void Main (String[] args)
{
    int []a = {3, 7, 9, 3, 11};
     
    int n = a.Length;
     
    Console.WriteLine(Division(a, n));
}
}
 
// This code is contributed by Rajput-Ji

<script>
// Javascript program to maximum value of
// division of two numbers in an array
 
// Function to maximum value of
// division of two numbers in an array
function Division(a, n)
{
    let maxi = Number.MIN_VALUE, mini = Number.MAX_VALUE;
     
    // Traverse through the array
    for (let i = 0; i < n; i++)
    {
        maxi = Math.max(a[i], maxi);
        mini = Math.min(a[i], mini);
    }
     
    // Return the required answer
    return parseInt(maxi / mini);
}
 
// Driver code
    let a = [3, 7, 9, 3, 11];
     
    let n = a.length;
     
    document.write(Division(a, n));
 
</script>

Producción : 

3

Complejidad temporal : O(N), ya que el bucle se ejecuta una sola vez de 0 a (n – 1).
Espacio auxiliar : O(1), ya que no se ha tomado ningún espacio extra.

Nota: la solución anterior solo funciona para números enteros positivos