Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimum Possible value of |ai + aj – k| for given array and k.

  • Difficulty Level : Medium
  • Last Updated : 12 May, 2022

You are given an array of n integer and an integer K. Find the number of total unordered pairs {i, j} such that absolute value of (ai + aj – K), i.e., |ai + aj – k| is minimal possible where i != j.
Examples: 
 

Input : arr[] = {0, 4, 6, 2, 4}, 
            K = 7
Output : Minimal Value = 1
         Total  Pairs = 5 
Explanation : Pairs resulting minimal value are :
              {a1, a3}, {a2, a4}, {a2, a5}, {a3, a4}, {a4, a5} 

Input : arr[] = {4, 6, 2, 4}  , K = 9
Output : Minimal Value = 1
         Total Pairs = 4 
Explanation : Pairs resulting minimal value are :
              {a1, a2}, {a1, a4}, {a2, a3}, {a2, a4}

 

A simple solution is iterate over all possible pairs and for each pair we will check whether the value of (ai + aj – K) is smaller than our current smallest value of not. So as per result of above condition we have total of three cases : 
 

  1. abs( ai + aj – K) > smallest : do nothing as this pair will not count in minimal possible value.
  2. abs(ai + aj – K) = smallest : increment the count of pair resulting minimal possible value.
  3. abs( ai + aj – K) < smallest : update the smallest value and set count to 1.

 

C++




// CPP program to find number of pairs  and minimal
// possible value
#include<bits/stdc++.h>
using namespace std;
 
// function for finding pairs and min value
void pairs(int arr[], int n, int k)
{
    // initialize smallest and count
    int smallest = INT_MAX;
    int count=0;
 
    // iterate over all pairs
    for (int i=0; i<n; i++)
        for(int j=i+1; j<n; j++)
        {
            // is abs value is smaller than smallest
            // update smallest and reset count to 1
            if ( abs(arr[i] + arr[j] - k) < smallest )
            {
                smallest = abs(arr[i] + arr[j] - k);
                count = 1;
            }
 
            // if abs value is equal to smallest
            // increment count value
            else if (abs(arr[i] + arr[j] - k) == smallest)
                count++;
        }
 
        // print result
        cout << "Minimal Value = " << smallest << "\n";
        cout << "Total Pairs = " << count << "\n";   
}
 
// driver program
int main()
{
    int arr[] = {3, 5, 7, 5, 1, 9, 9};
    int k = 12;
    int n = sizeof(arr) / sizeof(arr[0]);
    pairs(arr, n, k);
    return 0;
}
Java



// Java program to find number of pairs
// and minimal possible value
import java.util.*;
 
class GFG {
     
    // function for finding pairs and min value
    static void pairs(int arr[], int n, int k)
    {
        // initialize smallest and count
        int smallest = Integer.MAX_VALUE;
        int count=0;
      
        // iterate over all pairs
        for (int i=0; i<n; i++)
            for(int j=i+1; j<n; j++)
            {
                // is abs value is smaller than
                // smallest update smallest and
                // reset count to 1
                if ( Math.abs(arr[i] + arr[j] - k) <
                                        smallest )
                {
                    smallest = Math.abs(arr[i] + arr[j]
                                             - k);
                    count = 1;
                }
      
                // if abs value is equal to smallest
                // increment count value
                else if (Math.abs(arr[i] + arr[j] - k)
                                    == smallest)
                    count++;
            }
      
            // print result
           System.out.println("Minimal Value = " +
                                    smallest);
           System.out.println("Total Pairs = " +
                                       count);   
    }
     
    /* Driver program to test above function */
    public static void main(String[] args)
    {
        int arr[] = {3, 5, 7, 5, 1, 9, 9};
        int k = 12;
        int n = arr.length;
        pairs(arr, n, k);
    }
}
// This code is contributed by Arnav Kr. Mandal.
Python3



# Python3 program to find number of pairs
# and minimal possible value
 
# function for finding pairs and min value
def pairs(arr, n, k):
     
    # initialize smallest and count
    smallest = 999999999999
    count = 0
 
    # iterate over all pairs
    for i in range(n):
        for j in range(i + 1, n):
             
            # is abs value is smaller than smallest
            # update smallest and reset count to 1
            if abs(arr[i] + arr[j] - k) < smallest:
                smallest = abs(arr[i] + arr[j] - k)
                count = 1
 
            # if abs value is equal to smallest
            # increment count value
            elif abs(arr[i] + arr[j] - k) == smallest:
                count += 1
 
    # print result
    print("Minimal Value = ", smallest)
    print("Total Pairs = ", count)
 
# Driver Code
if __name__ == '__main__':
    arr = [3, 5, 7, 5, 1, 9, 9]
    k = 12
    n = len(arr)
    pairs(arr, n, k)
     
# This code is contributed by PranchalK
C#



// C# program to find number
// of pairs and minimal
// possible value
using System;
 
class GFG
{
 
// function for finding
// pairs and min value
static void pairs(int []arr,
                  int n, int k)
{
    // initialize
    // smallest and count
    int smallest = 0;
    int count = 0;
 
    // iterate over all pairs
    for (int i = 0; i < n; i++)
        for(int j = i + 1; j < n; j++)
        {
            // is abs value is smaller
            // than smallest update
            // smallest and reset
            // count to 1
            if (Math.Abs(arr[i] +
                arr[j] - k) < smallest )
            {
                smallest = Math.Abs(arr[i] +
                                    arr[j] - k);
                count = 1;
            }
 
            // if abs value is equal
            // to smallest increment
            // count value
            else if (Math.Abs(arr[i] +
                              arr[j] - k) ==
                                smallest)
                count++;
        }
 
    // print result
    Console.WriteLine("Minimal Value = " +
                                smallest);
    Console.WriteLine("Total Pairs = " +
                                 count);
}
 
// Driver Code
public static void Main()
{
    int []arr = {3, 5, 7,
                 5, 1, 9, 9};
    int k = 12;
    int n = arr.Length;
    pairs(arr, n, k);
}
}
 
// This code is contributed
// by anuj_67.
PHP



<?php
// PHP program to find number of
// pairs and minimal possible value
 
// function for finding pairs
// and min value
function pairs($arr, $n, $k)
{
     
    // initialize smallest and count
    $smallest = PHP_INT_MAX;
    $count = 0;
 
    // iterate over all pairs
    for ($i = 0; $i < $n; $i++)
        for($j = $i + 1; $j < $n; $j++)
        {
             
            // is abs value is smaller than smallest
            // update smallest and reset count to 1
            if ( abs($arr[$i] + $arr[$j] - $k) < $smallest )
            {
                $smallest = abs($arr[$i] + $arr[$j] - $k);
                $count = 1;
            }
 
            // if abs value is equal to smallest
            // increment count value
            else if (abs($arr[$i] +
                     $arr[$j] - $k) == $smallest)
                $count++;
        }
 
        // print result
        echo "Minimal Value = " , $smallest , "\n";
        echo "Total Pairs = ", $count , "\n";
}
 
    // Driver Code
    $arr = array (3, 5, 7, 5, 1, 9, 9);
    $k = 12;
    $n = sizeof($arr);
    pairs($arr, $n, $k);
 
// This code is contributed by aj_36
?>
Javascript



<script>
 
// Javascript program to find number of pairs  and minimal
// possible value
 
// function for finding pairs and min value
function pairs(arr, n, k)
{
    // initialize smallest and count
    var smallest = 1000000000;
    var count=0;
 
    // iterate over all pairs
    for (var i=0; i<n; i++)
        for(var j=i+1; j<n; j++)
        {
            // is Math.abs value is smaller than smallest
            // update smallest and reset count to 1
            if ( Math.abs(arr[i] + arr[j] - k) < smallest )
            {
                smallest = Math.abs(arr[i] + arr[j] - k);
                count = 1;
            }
 
            // if Math.abs value is equal to smallest
            // increment count value
            else if (Math.abs(arr[i] + arr[j] - k) == smallest)
                count++;
        }
 
        // print result
        document.write( "Minimal Value = " + smallest + "<br>");
        document.write( "Total Pairs = " + count + "<br>");   
}
 
// driver program
var arr = [3, 5, 7, 5, 1, 9, 9];
var k = 12;
var n = arr.length;
pairs(arr, n, k);
 
</script>
Output: 
 
Minimal Value = 0
Total Pairs = 4
An efficient solution is to use a self balancing binary search tree (which is implemented in set in C++ and TreeSet in Java). We can find closest element in O(log n) time in map.
 
C++



// C++ program to find number of pairs
// and minimal possible value
#include<bits/stdc++.h>
using namespace std;
 
// function for finding pairs and min value
void pairs(int arr[], int n, int k)
{
    // initialize smallest and count
    int smallest = INT_MAX, count = 0;
    set<int> s;
 
    // iterate over all pairs
    s.insert(arr[0]);
    for (int i=1; i<n; i++)
    {
        // Find the closest elements to  k - arr[i]
        int lower = *lower_bound(s.begin(),
                                 s.end(),
                                 k - arr[i]);
 
        int upper = *upper_bound(s.begin(),
                                 s.end(),
                                 k - arr[i]);
 
        // Find absolute value of the pairs formed
        // with closest greater and smaller elements.
        int curr_min = min(abs(lower + arr[i] - k),
                           abs(upper + arr[i] - k));
 
        // is abs value is smaller than smallest
        // update smallest and reset count to 1
        if (curr_min < smallest)
        {
            smallest = curr_min;
            count = 1;
        }
 
        // if abs value is equal to smallest
        // increment count value
        else if (curr_min == smallest )
            count++;
        s.insert(arr[i]);
 
    }        // print result
 
    cout << "Minimal Value = " << smallest <<"\n";
    cout << "Total Pairs = " << count <<"\n";
}
 
// driver program
int main()
{
    int arr[] = {3, 5, 7, 5, 1, 9, 9};
    int k = 12;
    int n = sizeof(arr) / sizeof(arr[0]);
    pairs(arr, n, k);
    return 0;
}
Java



// Java program to find number of pairs
// and minimal possible value
import java.util.*;
 
class GFG {
 
  // function for finding pairs and min value
  static void pairs(int arr[], int n, int k)
  {
    // initialize smallest and count
    int smallest = Integer.MAX_VALUE;
    int count = 0;
 
    // iterate over all pairs
    for (int i = 0; i < n; i++)
      for(int j = i + 1; j < n; j++)
      {
        // is abs value is smaller than
        // smallest update smallest and
        // reset count to 1
        if ( Math.abs(arr[i] + arr[j] - k) <
            smallest )
        {
          smallest = Math.abs(arr[i] + arr[j]
                              - k);
          count = 1;
        }
 
        // if abs value is equal to smallest
        // increment count value
        else if (Math.abs(arr[i] + arr[j] - k)
                 == smallest)
          count++;
      }
 
    // print result
    System.out.println("Minimal Value = " +
                       smallest);
    System.out.println("Total Pairs = " +
                       count);   
  }
 
  /* Driver program to test above function */
  public static void main(String[] args)
  {
    int arr[] = {3, 5, 7, 5, 1, 9, 9};
    int k = 12;
    int n = arr.length;
    pairs(arr, n, k);
  }
}
 
// This code is contributed by Rajput-Ji
C#



// C# program to find number of pairs
// and minimal possible value
using System;
 
public class GFG {
 
    // function for finding pairs and min value
    static void pairs(int []arr, int n, int k)
    {
       
        // initialize smallest and count
        int smallest = int.MaxValue;
        int count = 0;
 
        // iterate over all pairs
        for (int i = 0; i < n; i++)
            for (int j = i + 1; j < n; j++)
            {
               
                // is abs value is smaller than
                // smallest update smallest and
                // reset count to 1
                if (Math.Abs(arr[i] + arr[j] - k) < smallest) {
                    smallest = Math.Abs(arr[i] + arr[j] - k);
                    count = 1;
                }
 
                // if abs value is equal to smallest
                // increment count value
                else if (Math.Abs(arr[i] + arr[j] - k) == smallest)
                    count++;
            }
 
        // print result
        Console.WriteLine("Minimal Value = " + smallest);
        Console.WriteLine("Total Pairs = " + count);
    }
 
    /* Driver program to test above function */
    public static void Main(String[] args)
    {
        int []arr = { 3, 5, 7, 5, 1, 9, 9 };
        int k = 12;
        int n = arr.Length;
        pairs(arr, n, k);
    }
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
// javascript program to find number of pairs
// and minimal possible value
 
    // function for finding pairs and min value
    function pairs(arr , n , k)
    {
     
        // initialize smallest and count
        var smallest = Number.MAX_VALUE;
        var count = 0;
 
        // iterate over all pairs
        for (i = 0; i < n; i++)
            for (j = i + 1; j < n; j++)
            {
             
                // is abs value is smaller than
                // smallest update smallest and
                // reset count to 1
                if (Math.abs(arr[i] + arr[j] - k) < smallest) {
                    smallest = Math.abs(arr[i] + arr[j] - k);
                    count = 1;
                }
 
                // if abs value is equal to smallest
                // increment count value
                else if (Math.abs(arr[i] + arr[j] - k) == smallest)
                    count++;
            }
 
        // print result
        document.write("Minimal Value = " + smallest);
        document.write("<br/>Total Pairs = " + count);
    }
 
    /* Driver program to test above function */
     
        var arr = [ 3, 5, 7, 5, 1, 9, 9 ];
        var k = 12;
        var n = arr.length;
        pairs(arr, n, k);
 
// This code is contributed by Rajput-Ji
</script>
Output: 
 
Minimal Value = 0
Total Pairs = 4
Time Complexity : O(n Log n)
This article is contributed by Shivam Pradhan (anuj_charm). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

My Personal Notes
arrow_drop_up
Previous
Check if URL is valid or not in Java
Next

Program for Fahrenheit to Celsius conversion
Recommended Articles
Page :
Minimum possible value T such that at most D Partitions of the Array having at most sum T is possible
21, Aug 20
Modify array by replacing every array element with minimum possible value of arr[j] + |j - i|
07, Jan 21
Minimize value of a given function for any possible value of X
11, Jun 21
Minimum LCM and GCD possible among all possible sub-arrays
25, Feb 19
Minimum possible value of D which when added to or subtracted from K repeatedly obtains every array element
26, Jun 21
Minimize value of x that minimizes value of |a1−x|^c+|a2−x|^c+···+|an−x|^c for value of c as 1 and 2
22, Nov 21
Minimize operations to make minimum value of one array greater than maximum value of the other
20, Jul 21
Minimum score possible for a player by selecting one or two consecutive array elements from given binary array
16, Nov 20
Flip minimum signs of array elements to get minimum sum of positive elements possible
27, Jun 19
Maximize Sum possible by subtracting same value from all elements of a Subarray of the given Array
15, Aug 20
Maximum possible value of array elements that can be made based on given capacity conditions
27, Sep 21
Largest value of K that a set of all possible subset-sum values of given Array contains numbers [0, K]
15, Oct 21
Minimum size of Array possible with given sum and product values
27, Sep 21
Minimum absolute value of (K – arr[i]) for all possible values of K over the range [0, N – 1]
07, Jul 21
Minimum product of maximum and minimum element over all possible subarrays
20, Aug 21
Minimize sum of minimum and second minimum elements from all possible triplets
29, Nov 21
Remove minimum numbers from the array to get minimum OR value
27, Dec 19
Check if it is possible to construct an Array of size N having sum as S and XOR value as X
20, Aug 21
Find the missing value from Array B formed by adding some value X to Array A
19, Oct 21
Reduce array to longest sorted array possible by removing either half of given array in each operation
17, Nov 20
Minimum possible sum of array elements after performing the given operation
19, Feb 19
Minimum possible sum of array elements after performing the given operation
14, Apr 20
Minimum possible sum of prices of a Triplet from the given Array
29, Jul 20
Maximise minimum element possible in Array after performing given operations
20, Jan 22
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





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!