Minimum Difference Among Group Size Two in Java

An array containing various numbers is given. The task is to create different groups, each containing only two elements, such that the difference between the group containing the largest sum and the group containing the lowest sum should be minimum. Note that any element can only be part of only one group. Also, it is not allowed to leave any element. In other words, an element has to be part of a group.

Example 1:

Input:

int arr[] = {5, 0, 9, 7, 15, 11, 19, 17}

Output: 3

Explanation: Let's form a group of two-element for the given array.

G1 = {5, 17}, G2 = {0, 19}, G3 = {9, 11}, G4 = {7, 15}. If we find the sum of elements present in each group we get,

G1 = 5 + 17 = 22, G2 = 0 + 19 = 19, G3 = 9 + 11 = 20, G4 = 7 + 15 = 22

Thus, we see that the minimum sum is 19, and the maximum sum is 22. Hence, the difference is 22 - 19 = 3.

Example 2:

Input:

int arr[] = {4, 11, 5, 3, 7, 2}

Output: 4

Explanation: Let's form a group of two-element for the given array.

G1 = {4, 5}, G2 = {11, 2}, G3 = {3, 7}. If we find the sum of elements present in each group we get,

G1 = 4 + 5 = 9, G2 = 11 + 2 = 13, G3 = 3 + 7 = 10.

Thus, we see that the minimum sum is 9, and the maximum sum is 13. Hence, the difference is 13 - 9 = 4.

Example 3:

Input:

int arr[] = {4, 9, 3, 8, 2, 0, 5}

Output: It is not possible to find the minimum difference.

Explanation: Let's form a group of two-element for the given array.

G1 = {4, 9}, G2 = {3, 8}, G3 = {2, 0}. Thus, we see that we have left element 5, and as per the condition, it is not allowed to leave any element. It does not matter how hard we try to form different groups, one of the elements has to skip. Hence, the solution is not possible.

Approach

The approach is simple. One has to keep the maximum to the lowest value and the minimum to the highest value so that the gap between the maximum and the minimum is the lowest. In order to do so, we have to combine the numbers of the array in such a way that the maximum element gets mapped with the lowest element, and the second maximum element gets mapped with the second largest element. In order to achieve the same, it is required to sort the array, then combine (make a group) the last element with the first element, the second last element with the second element, and so on. The illustration of the same is mentioned in the following program.

FileName: LeastDiff.java

// important import statement
import java.util.Arrays;
import java.util.ArrayList;

// Main class
public class LeastDiff
{

// method for computing the minimum between a and b
private int findMin(int a, int b)
{
if(a > b)
{
    return b;
}

return a;
}

// method for computing the maximum between a and b
private int findMax(int a, int b)
{
if(a > b)
{
    return a;
}

return b;
}

// a method that finds the minium difference 
// between the group of two elements
public int findMinDiff(int arr[], int s)
{
    if(s % 2 != 0)
    {
        return -1;
    }
    Arrays.sort(arr);
    int diff = Integer.MAX_VALUE;
    ArrayList<Integer> al = new ArrayList<Integer>();
    for(int i = 0, j = s - 1; i < j; j--, i++)
    {
        // find the sum of the two elements and 
        // add it in to the array list
        al.add(arr[i] + arr[j]);
    }
    
    // for storing the minimum value
    int min = Integer.MAX_VALUE;
    
    // for storing the maximum value
    int max = Integer.MIN_VALUE;
    
    // computing the size
    int size = al.size();
    
    for(int i = 0; i < size; i++)
    {
        // finding the maximum and the minimum
        // among the group of two elements
        min = findMin(min, al.get(i));
        max = findMax(max, al.get(i));
    }
    
    return (max - min);
}
    
// Main method
public static void main(String[] argvs) 
{
// creating an object of the class LeastDiff
LeastDiff obj = new LeastDiff();

// input 1
int arr[] = {5, 0, 9, 7, 15, 11, 19, 17};
int size = arr.length;

System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
    System.out.print(arr[i] + " ");
}
System.out.println();

int ans = obj.findMinDiff(arr, size);

if(ans != -1)
{
System.out.println("The minimum difference is: " + ans);
}
else
{
System.out.println("It is not possible to find the minimum difference.");
}

System.out.println("\n");

// input 2
int arr1[] = {4, 11, 5, 3, 7, 2};
size = arr1.length;

System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
    System.out.print(arr1[i] + " ");
}
System.out.println();

ans = obj.findMinDiff(arr1, size);


if(ans != -1)
{
System.out.println("The minimum difference is: " + ans);
}
else
{
System.out.println("It is not possible to find the minimum difference.");
}
System.out.println("\n");

// input 3
int arr2[] = {4, 9, 3, 8, 2, 0, 5};
size = arr2.length;

System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
    System.out.print(arr2[i] + " ");
}
System.out.println();

ans = obj.findMinDiff(arr2, size);


if(ans != -1)
{
System.out.println("The minimum difference is: " + ans);
}
else
{
System.out.println("It is not possible to find the minimum difference.");
}
System.out.println("\n");

}
}

Output:

For the input array: 
5 0 9 7 15 11 19 17 
The minimum difference is: 3


For the input array: 
4 11 5 3 7 2 
The minimum difference is: 4


For the input array: 
4 9 3 8 2 0 5 
It is not possible to find the minimum difference.

Complexity Analysis: Since the program is using sorting, the time complexity of the program is O(n * log(n)). Also, the program is using an array list for storing the sum. Thus, the space complexity of the program is O(n), where n is the total number of elements present in the input array.

Next TopicMissing Number in An Arithmetic Progression in Java

← prev next →