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

Last Updated : 19 Sep, 2023

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)

Previous
Next