Open In App

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

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.

Below is the implementation of the above approach:

## C++

 `// CPP program to find number of pairs  and minimal``// possible value``#include ``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

 ``

## Javascript

 ``

Output

```Minimal Value = 0
Total Pairs = 4```

Time Complexity: O(n2) where n is the number of elements in the array.
Auxiliary Space : O(1)

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 ``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;``}`

## Python3

 `# Python program to find number of pairs``# and minimal possible value`` ` `from` `sys ``import` `maxsize``from` `bisect ``import` `bisect_left, bisect_right`` ` `# function for finding pairs and min value``def` `pairs(arr, n, k):``    ``# initialize smallest and count``    ``smallest ``=` `maxsize``    ``count ``=` `0``    ``s ``=` `set``()`` ` `    ``# iterate over all pairs``    ``s.add(arr[``0``])``    ``for` `i ``in` `range``(``1``, n):``        ``# Find the closest elements to k - arr[i]``        ``sorted_s ``=` `sorted``(s)``        ``index ``=` `bisect_left(sorted_s, k ``-` `arr[i])``        ``if` `index ``=``=` `len``(sorted_s):``            ``lower ``=` `sorted_s[index ``-` `1``]``        ``else``:``            ``lower ``=` `sorted_s[index]``        ``index ``=` `bisect_right(sorted_s, k ``-` `arr[i])``        ``if` `index ``=``=` `len``(sorted_s):``            ``upper ``=` `sorted_s[index ``-` `1``]``        ``else``:``            ``upper ``=` `sorted_s[index]`` ` `        ``# Find absolute value of the pairs formed``        ``# with closest greater and smaller elements.``        ``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``        ``elif` `curr_min ``=``=` `smallest:``            ``count ``+``=` `1``        ``s.add(arr[i])`` ` `    ``# print result``    ``print``(``"Minimal Value = "``, smallest)``    ``print``(``"Total Pairs = "``, count)`` ` `# driver program``arr ``=` `[``3``, ``5``, ``7``, ``5``, ``1``, ``9``, ``9``]``k ``=` `12``n ``=` `len``(arr)``pairs(arr, n, k)`` ` `# This code is contributed by vikramshirsath177.`

## Java

 `import` `java.util.*;`` ` `class` `Main {``    ``// function for finding pairs and min value``    ``static` `void` `pairs(``final` `int``[] arr,``final` `int` `n,``final` `int` `k) {``        ``// initialize smallest and count``        ``int` `smallest = Integer.MAX_VALUE, count = ``0``;``        ``Set s = ``new` `TreeSet<>();`` ` `        ``// iterate over all pairs``        ``s.add(arr[``0``]);``        ``for` `(``int` `i = ``1``; i < n; i++) {``            ``// Find the closest elements to  k - arr[i]``            ``int` `lower = Integer.MIN_VALUE;``            ``int` `upper = Integer.MAX_VALUE;``            ``for` `(Integer x : s) {``                ``if` `(x <= (k - arr[i]) && x >= lower) {``                   ``lower = x;``                 ``}``                ``if` `(x >= (k - arr[i]) && x <= upper) {``                    ``upper = x;``                 ``}``             ``}`` ` `            ``// Find absolute value of the pairs formed``            ``// with closest greater and smaller elements.``            ``int` `curr_min = Math.min(Math.abs(lower + arr[i] - k), Math.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.add(arr[i]);`` ` `        ``} ``// print result`` ` `        ``System.out.println(``"Minimal Value = "` `+ smallest);``        ``System.out.println(``"Total Pairs = "` `+ count);``    ``}`` ` `    ``// driver program``    ``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);``    ``}``}`

## Javascript

 `function` `pairs(arr, n, k) {``    ``// initialize smallest and count``    ``let smallest = Number.MAX_SAFE_INTEGER;``    ``let count = 0;``    ``let s = ``new` `Set();``  ` `    ``// iterate over all pairs``    ``s.add(arr[0]);``    ``for` `(let i = 1; i < n; i++) {``        ``// Find the closest elements to  k - arr[i]``        ``let lower = [...s].find((element) => element >= k - arr[i]);``        ``let upper = [...s].find((element) => element >= k - arr[i]);``  ` `        ``// Find absolute value of the pairs formed``        ``// with closest greater and smaller elements.``        ``let curr_min = Math.min(Math.abs(lower + arr[i] - k), Math.abs(upper + arr[i] - k));``  ` `        ``// if 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.add(arr[i]);``    ``}``  ` `    ``// print result``    ``console.log(`Minimal Value = \${smallest}`);``    ``console.log(`Total Pairs = \${count}`);``}``  ` `// driver program``let arr = [3, 5, 7, 5, 1, 9, 9];``let k = 12;``let n = arr.length;``pairs(arr, n, k);`

## C#

 `using` `System;``using` `System.Collections.Generic;``using` `System.Linq;`` ` `class` `Program``{``    ``// function for finding pairs and min value``    ``static` `void` `pairs(``int``[] arr, ``int` `n, ``int` `k)``    ``{``        ``// initialize smallest and count``        ``int` `smallest = ``int``.MaxValue, count = 0;``        ``SortedSet<``int``> s = ``new` `SortedSet<``int``>();`` ` `        ``// iterate over all pairs``        ``s.Add(arr[0]);``        ``for` `(``int` `i = 1; i < n; i++)``        ``{``            ``// Find the closest elements to k - arr[i]``            ``int` `lower = s.Where(e => e >= k - arr[i]).DefaultIfEmpty(``int``.MinValue).First();``            ``int` `upper = s.Where(e => e > k - arr[i]).DefaultIfEmpty(``int``.MaxValue).First();`` ` `            ``// Find absolute value of the pairs formed``            ``// with closest greater and smaller elements.``            ``int` `curr_min = Math.Min(Math.Abs(lower + arr[i] - k), Math.Abs(upper + arr[i] - k));`` ` `            ``// if 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.Add(arr[i]);``        ``}`` ` `        ``// print result``        ``Console.WriteLine(``"Minimal Value = "` `+ smallest);``        ``Console.WriteLine(``"Total Pairs = "` `+ count);``    ``}`` ` `    ``// driver program``    ``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);``    ``}``}`

Output

```Minimal Value = 0
Total Pairs = 4```

Time Complexity : O(n Log n)
Auxiliary Space: O(n)

This article is contributed by Shivam Pradhan . 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.