Skip to content
Related Articles

Related Articles

Table of Contents

Minimize length of an array consisting of difference between all possible pairs

Improve Article
Save Article
Like Article
  • Last Updated : 11 Feb, 2022

Given an array arr[] of size N, the task is to find the minimum count of elements required to be inserted into the array such that the absolute difference of all possible pairs exists in the array.

Examples:

Input: arr[] = { 3, 5 } 
Output: 3 
Explanation: 
Inserting 2 into the array modifies arr[] to { 2, 3, 5 } 
Inserting 1 into the array modifies arr[] to { 1, 2, 3, 5 } 
Inserting 4 into the array modifies arr[] to { 1, 2, 3, 4, 5 } 
Since absolute difference of all possible pairs from the array are present in the array, the required output is 3.

Input: arr[] = { 2, 4 } 
Output: 0 
Explanation: 
Since absolute difference of all possible pairs array are already present in the array, the required output is 0.

Naive Approach: The simplest approach to solve this problem is to find the absolute difference of every possible pair from the array and check if the difference obtained is present in the array or not. If it is not present, then insert the obtained difference. Otherwise, print the count of elements inserted into the array. 

Time Complexity:O(N * X), where X is the maximum element in the array.
Auxiliary Space: O(X)

Efficient Approach: The above approach can be optimized based on the following observations:

Since the absolute difference of all possible pairs of final array must be present in the array. 
Therefore, the final array must be in the form of X, 2 * X, 3 * X, 4 * X, …

From the above sequence of the final array, it can be observed the value of X must be the GCD of the given array.

Follow the steps below to solve the problem:

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the GCD of an array
int findGcd(int arr[], int N)
{
 
    // Stores GCD of an array
    int gcd = arr[0];
 
    // Traverse the array
    for (int i = 1; i < N; i++) {
 
        // Update gcd
        gcd = __gcd(gcd, arr[i]);
    }
    return gcd;
}
 
// Function to find minimum count of elements
// inserted into the array such that absolute
// difference of pairs present in the array
void findMax(int arr[], int N)
{
 
    // Stores gcd of the array
    int gcd = findGcd(arr, N);
 
    // Stores the largest element
    // in the array
    int Max = INT_MIN;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Update Max
        Max = max(Max, arr[i]);
    }
 
    // Stores minimum count of elements inserted
    // into the array such that absolute difference
    // of pairs present in the array
    int ans = (Max / gcd) - N;
 
    cout << ans;
}
 
// Driver Code
int main()
{
 
    // Given array
    int arr[] = { 3, 5 };
 
    // Size of the array
    int N = (sizeof(arr) / (sizeof(arr[0])));
 
    // Function Call
    findMax(arr, N);
}
Java



// Java program for the above approach
import java.util.*;
class GFG
{
     
// Recursive function to return gcd of a and b
static int gcdd(int a, int b)
{
    // Everything divides 0
    if (a == 0)
       return b;
    if (b == 0)
       return a;
   
    // base case
    if (a == b)
        return a;
   
    // a is greater
    if (a > b)
        return gcdd(a - b, b);
    return gcdd(a, b - a);
}
       
// Function to find the GCD of an array
static int findGcd(int arr[], int N)
{
 
    // Stores GCD of an array
    int gcd = arr[0];
 
    // Traverse the array
    for (int i = 1; i < N; i++)
    {
 
        // Update gcd
        gcd = gcdd(gcd, arr[i]);
    }
    return gcd;
}
 
// Function to find minimum count of elements
// inserted into the array such that absolute
// difference of pairs present in the array
static void findMax(int arr[], int N)
{
 
    // Stores gcd of the array
    int gcd = findGcd(arr, N);
 
    // Stores the largest element
    // in the array
    int Max = Integer.MIN_VALUE;
 
    // Traverse the array
    for (int i = 0; i < N; i++)
    {
 
        // Update Max
        Max = Math.max(Max, arr[i]);
    }
 
    // Stores minimum count of elements inserted
    // into the array such that absolute difference
    // of pairs present in the array
    int ans = (Max / gcd) - N;
    System.out.println(ans);
}
   
// Driver code
public static void main(String[] args)
{
   
    // Given array
    int arr[] = { 3, 5 };
 
    // Size of the array
    int N = arr.length;
 
    // Function Call
    findMax(arr, N);
}
}
 
// This code is contributed by susmitakundugoaldanga.
Python3



# Python3 program for the above approach
import math
import sys
 
# Function to find the GCD of an array
def findGcd(arr, N):
     
    # Stores GCD of an array
    gcd = arr[0]
     
    # Traverse the array
    for i in range(1, N):
         
        # Update gcd
        gcd = math.gcd(gcd, arr[i])
 
    return gcd
 
# Function to find minimum count of elements
# inserted into the array such that absolute
# difference of pairs present in the array
def findMax(arr, N):
     
    # Stores gcd of the array
    gcd = findGcd(arr, N)
     
    # Stores the largest element
    # in the array
    Max = -sys.maxsize - 1
     
    # Traverse the array
    for i in range(N):
         
        # Update Max
        Max = max(Max, arr[i])
 
    # Stores minimum count of elements inserted
    # into the array such that absolute difference
    # of pairs present in the array
    ans = (Max // gcd) - N
 
    print(ans)
 
# Driver Code
if __name__ == "__main__":
     
    # Given array
    arr = [3, 5]
     
    # Size of the array
    N = len(arr)
 
    # Function Call
    findMax(arr, N)
 
# This code is contributed by chitranayal
C#



// C# program for the above approach
using System;
 
class GFG
{
 
    // Recursive function to return gcd of a and b
    static int gcdd(int a, int b)
    {
       
        // Everything divides 0
        if (a == 0)
            return b;
        if (b == 0)
            return a;
 
        // base case
        if (a == b)
            return a;
 
        // a is greater
        if (a > b)
            return gcdd(a - b, b);
        return gcdd(a, b - a);
    }
 
    // Function to find the GCD of an array
    static int findGcd(int[] arr, int N)
    {
 
        // Stores GCD of an array
        int gcd = arr[0];
 
        // Traverse the array
        for (int i = 1; i < N; i++)
        {
 
            // Update gcd
            gcd = gcdd(gcd, arr[i]);
        }
        return gcd;
    }
 
    // Function to find minimum count of elements
    // inserted into the array such that absolute
    // difference of pairs present in the array
    static void findMax(int[] arr, int N)
    {
 
        // Stores gcd of the array
        int gcd = findGcd(arr, N);
 
        // Stores the largest element
        // in the array
        int Max = Int32.MinValue;
 
        // Traverse the array
        for (int i = 0; i < N; i++)
        {
 
            // Update Max
            Max = Math.Max(Max, arr[i]);
        }
 
        // Stores minimum count of elements inserted
        // into the array such that absolute difference
        // of pairs present in the array
        int ans = (Max / gcd) - N;
        Console.WriteLine(ans);
    }
 
    // Driver code
    static public void Main()
    {
 
        // Given array
        int[] arr = new int[] { 3, 5 };
 
        // Size of the array
        int N = arr.Length;
 
        // Function Call
        findMax(arr, N);
    }
}
 
// This code is contributed by Dharanendra L V.
Javascript



<script>
 
// Javascript program for the above approach
 
// Recursive function to return gcd of a and b
function gcdd(a, b)
{
     
    // Everything divides 0
    if (a == 0)
        return b;
    if (b == 0)
        return a;
 
    // Base case
    if (a == b)
        return a;
 
    // a is greater
    if (a > b)
        return gcdd(a - b, b);
         
    return gcdd(a, b - a);
}
 
// Function to find the GCD of an array
function findGcd(arr, N)
{
     
    // Stores GCD of an array
    var gcd = arr[0];
 
    // Traverse the array
    for(i = 1; i < N; i++)
    {
         
        // Update gcd
        gcd = gcdd(gcd, arr[i]);
    }
    return gcd;
}
 
// Function to find minimum count of elements
// inserted into the array such that absolute
// difference of pairs present in the array
function findMax(arr, N)
{
     
    // Stores gcd of the array
    var gcd = findGcd(arr, N);
 
    // Stores the largest element
    // in the array
    var Max = Number.MIN_VALUE;
 
    // Traverse the array
    for(i = 0; i < N; i++)
    {
         
        // Update Max
        Max = Math.max(Max, arr[i]);
    }
 
    // Stores minimum count of elements inserted
    // into the array such that absolute difference
    // of pairs present in the array
    var ans = (Max / gcd) - N;
    document.write(ans);
}
 
// Driver code
 
// Given array
var arr = [ 3, 5 ];
 
// Size of the array
var N = arr.length;
 
// Function Call
findMax(arr, N);
 
// This code is contributed by umadevi9616
 
</script>
Output: 
3
 
Time Complexity:O(N * Log(X)), where X is the largest element in the array. 
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Previous
Print prime factors of a given integer in decreasing order using Stack
Next

Count non-equidistant triplets of distinct array elements having indices in increasing order
Recommended Articles
Page :
Minimize sum of absolute difference between all pairs of array elements by decrementing and incrementing pairs by 1
30, Jul 21
Reduce given array by replacing subarrays of length at least K consisting of even numbers with their length
19, Jan 22
Length of smallest subarray consisting of all occurrences of all maximum occurring elements
26, Dec 21
Maximize length of subsequence consisting of single distinct character possible by K increments in a string
13, May 21
Check if an array can be sorted by swapping pairs from indices consisting of unequal elements in another array
03, Feb 21
Minimize array length by repeatedly replacing pairs of unequal adjacent array elements by their sum
04, Sep 20
Count Non-Repeating array elements after inserting absolute difference between all possible pairs
17, Jan 21
Minimize difference between maximum and minimum element of all possible subarrays
06, Sep 21
Generate an N-length array A[] from an array arr[] such that arr[i] is the last index consisting of a multiple of A[i]
16, Feb 21
Generate Linked List consisting of maximum difference of squares of pairs of nodes from given Linked List
29, Oct 20
Minimize increments required to make differences between all pairs of array elements even
19, Feb 21
Minimize maximum difference between adjacent elements possible by removing a single array element
08, Apr 21
Count pairs made up of an element divisible by the other from an array consisting of powers of 2
01, Feb 21
Minimize Array length by repeatedly replacing co-prime pairs with 1
25, Aug 20
Minimize difference between maximum and minimum array elements by removing a K-length subarray
17, Feb 21
Maximum length of subarray consisting of same type of element on both halves of sub-array
25, Jul 20
Maximum sum of K-length subarray consisting of same number of distinct elements as the given array
02, Mar 21
Partition array into minimum number of equal length subsets consisting of a single distinct value
23, Nov 20
Check if an array can be split into K consecutive non-overlapping subarrays of length M consisting of single distinct element
12, Feb 21
Split an array into equal length subsequences consisting of equal elements only
13, Jan 21
Length of longest subset consisting of A 0s and B 1s from an array of strings
08, Apr 21
Length of longest subset consisting of A 0s and B 1s from an array of strings | Set 2
19, Apr 21
Generate an N-length array having length of non-decreasing subarrays maximized and minimum difference between first and last array elements
23, Jul 21
Maximum length of all possible K equal length ropes generated by cutting N ropes
29, Apr 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
prasann7676
@prasann7676
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!