Find maximum absolute difference with min sum of ratios in an Array
Given an array of positive integers arr[], the task is to find the maximum absolute difference between the pairs from the array such that the sum of their ratios is minimum.
Examples:
Input: arr[] = {2, 6, 3, 4, 8, 9}
Output: 4
Explanation: In the above example, the ratios of every pair are calculated likewise between 2 and 6 (1:3), 2 and 3 (2:3), 6 and 3 (2:1), 3 and 4 (3:4), 4 and 8 (1:2) and so on. Here the minimum ratio sum is 3 i.e., (1:2 or 2:1) where the pairs like [6, 3], [2, 4] and [4, 8] have the above ratio, and even in them the maximum absolute difference is 4 i.e.,
abs(4-8) = 4
Input: arr[] = {5, 9, 10, 18, 12};
Output: 9
Explanation: The pair [9, 18] is having minimum ratio sum of 3(1:2) and a maximum absolute difference of 9.
Approach: This can be solved with the following idea:
The approach is to choose two numbers from the array and calculate their ratio in the form of a:b (integer ratio numerator and denominator) by dividing them with their GCD. Add these two integers and check if it is less than the minimum ratio sum found so far. If yes, it updates the minimum ratio sum and calculates the absolute difference between the two numbers, and stores it as the maximum difference found so far.
Below are the steps involved in the implementation of the code:
- Initialize maxDiff to 0 and minRatioSum to Integer.MAX_VALUE.
- For each pair (a, b) in arr such that a < b:
- Compute the ratio of a and b as d1:d2 using the getRatio() function
- If ratioSum < minRatioSum, update minRatioSum to ratioSum and maxDiff to abs(a – b)
- Else if ratioSum is equal to minRatioSum, update maxDiff to max(maxDiff, abs(a – b))
- Return maxDiff.
Below is the implementation of the above approach:
C++
#include <cmath>
#include <iostream>
#include <limits.h>
using namespace std;
int getGCD( int i1, int i2)
{
if (i1 == i2) {
return i1;
}
if (i1 > i2) {
return getGCD(i1 - i2, i2);
}
return getGCD(i1, i2 - i1);
}
int * getRatio( int a, int b)
{
int gcd = getGCD(a, b);
int d1 = a / gcd;
int d2 = b / gcd;
int * ans = new int [2];
ans[0] = d1;
ans[1] = d2;
return ans;
}
int maxAbsDiff( int arr[], int n)
{
int maxDiff = 0;
int minRatioSum = INT_MAX;
for ( int i = 0; i < n; i++) {
for ( int j = i + 1; j < n; j++) {
int a = arr[i];
int b = arr[j];
int ratioSum = 0;
int * temp = getRatio(a, b);
ratioSum = temp[0] + temp[1];
if (ratioSum < minRatioSum) {
minRatioSum = ratioSum;
maxDiff = abs (a - b);
}
else if (ratioSum == minRatioSum) {
maxDiff = max(maxDiff, abs (a - b));
}
}
}
return maxDiff;
}
int main()
{
int arr[] = { 2, 6, 3, 4, 8, 9 };
int n = sizeof (arr) / sizeof (arr[0]);
int res = maxAbsDiff(arr, n);
cout << res << endl;
return 0;
}
|
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
int [] arr = { 2 , 6 , 3 , 4 , 8 , 9 };
int res = maxAbsDiff(arr);
System.out.println( "Maximum absolute difference : " + res);
}
public static int maxAbsDiff( int [] arr)
{
int n = arr.length;
int maxDiff = 0 ;
int minRatioSum = Integer.MAX_VALUE;
for ( int i = 0 ; i < n; i++) {
for ( int j = i + 1 ; j < n; j++) {
int a = arr[i];
int b = arr[j];
int ratioSum = 0 ;
int [] temp = getRatio(a, b);
ratioSum = temp[ 0 ] + temp[ 1 ];
if (ratioSum < minRatioSum) {
minRatioSum = ratioSum;
maxDiff = Math.abs(a - b);
}
else if (ratioSum == minRatioSum) {
maxDiff = Math.max(maxDiff,
Math.abs(a - b));
}
}
}
return maxDiff;
}
public static int [] getRatio( int a, int b)
{
int gcd = getGCD(a, b);
int d1 = a / gcd;
int d2 = b / gcd;
int [] ans = { d1, d2 };
return ans;
}
public static int getGCD( int i1, int i2)
{
if (i1 == i2)
return i1;
if (i1 > i2)
return getGCD(i1 - i2, i2);
return getGCD(i1, i2 - i1);
}
}
|
Python3
import math
def get_gcd(i1, i2):
if i1 = = i2:
return i1
if i1 > i2:
return get_gcd(i1 - i2, i2)
return get_gcd(i1, i2 - i1)
def get_ratio(a, b):
gcd = get_gcd(a, b)
d1 = a / / gcd
d2 = b / / gcd
return [d1, d2]
def max_abs_diff(arr, n):
max_diff = 0
min_ratio_sum = math.inf
for i in range (n):
for j in range (i + 1 , n):
a = arr[i]
b = arr[j]
ratio_sum = 0
temp = get_ratio(a, b)
ratio_sum = temp[ 0 ] + temp[ 1 ]
if ratio_sum < min_ratio_sum:
min_ratio_sum = ratio_sum
max_diff = abs (a - b)
elif ratio_sum = = min_ratio_sum:
max_diff = max (max_diff, abs (a - b))
return max_diff
if __name__ = = "__main__" :
arr = [ 2 , 6 , 3 , 4 , 8 , 9 ]
n = len (arr)
res = max_abs_diff(arr, n)
print (res)
|
C#
using System;
class GFG {
public static void Main()
{
int [] arr = { 2, 6, 3, 4, 8, 9 };
int res = maxAbsDiff(arr);
Console.WriteLine( "Maximum absolute difference : " + res);
}
public static int maxAbsDiff( int [] arr)
{
int n = arr.Length;
int maxDiff = 0;
int minRatioSum = int .MaxValue;
for ( int i = 0; i < n; i++) {
for ( int j = i + 1; j < n; j++) {
int a = arr[i];
int b = arr[j];
int ratioSum = 0;
int [] temp = getRatio(a, b);
ratioSum = temp[0] + temp[1];
if (ratioSum < minRatioSum) {
minRatioSum = ratioSum;
maxDiff = Math.Abs(a - b);
}
else if (ratioSum == minRatioSum) {
maxDiff = Math.Max(maxDiff,
Math.Abs(a - b));
}
}
}
return maxDiff;
}
public static int [] getRatio( int a, int b)
{
int gcd = getGCD(a, b);
int d1 = a / gcd;
int d2 = b / gcd;
int [] ans = { d1, d2 };
return ans;
}
public static int getGCD( int i1, int i2)
{
if (i1 == i2)
return i1;
if (i1 > i2)
return getGCD(i1 - i2, i2);
return getGCD(i1, i2 - i1);
}
}
|
Javascript
function get_gcd(i1, i2) {
if (i1 == i2) {
return i1;
}
if (i1 > i2) {
return get_gcd(i1 - i2, i2);
}
return get_gcd(i1, i2 - i1);
}
function get_ratio(a, b) {
gcd = get_gcd(a, b);
d1 = a / gcd;
d2 = b / gcd;
return [d1, d2];
}
function max_abs_diff(arr, n) {
max_diff = 0;
min_ratio_sum = Number.MAX_VALUE;
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
a = arr[i];
b = arr[j];
ratio_sum = 0;
temp = get_ratio(a, b);
ratio_sum = temp[0] + temp[1];
if (ratio_sum < min_ratio_sum) {
min_ratio_sum = ratio_sum;
max_diff = Math.abs(a - b);
} else if (ratio_sum == min_ratio_sum) {
max_diff = Math.max(max_diff, Math.abs(a - b));
}
}
}
return max_diff;
}
arr = [2, 6, 3, 4, 8, 9];
n = arr.length;
res = max_abs_diff(arr, n);
console.log(res);
|
Time Complexity: O(N2)
Auxiliary Space: O(1)
Last Updated :
24 Jul, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...