Count pairs from an array whose sum is equal to a given number?

Following solution will return the number of unique pairs

public static int numberOfPairs(Integer[] array, int sum) { Set<Integer> set = new HashSet<>(Arrays.asList(array)); // this set will keep track of the unique pairs. Set<String> uniquePairs = new HashSet<String>(); for (int i : array) { int x = sum - i; if (set.contains(x)) { int[] y = new int[] { x, i }; Arrays.sort(y); uniquePairs.add(Arrays.toString(y)); } } //System.out.println(uniquePairs.size()); return uniquePairs.size(); } 

The time complexity will be O(n).

Hope this helps.

You can use the HashMap<K,V> where K: a[i] and V: k-a[i] This may result in an incorrect answer if there are duplicates in an array.

Say for instances:

int a[] = {4, 4, 4, 4, 4, 4, 4, 4, 4} 

where k = 8 or:

int a[] = {1, 3, 3, 3, 3, 1, 2, 1, 2} 

where k = 4.

So in order to avoid that, we can have a List<List<Integer>> , which can check each pair and see if it is already in the list.

static int numberOfPairs(int[] a, int k) { List<List<Integer>> res = new ArrayList<>(); Map<Integer, Integer> map = new HashMap<>(); for(int element:a) { List<Integer> list = new ArrayList<>(); if(map.containsKey(element)) { list.add(element); list.add(map.get(element)); if(!res.contains(list)) res.add(list); } else map.put(k - element, element); } return res.size(); } 

Your solution is overly complex, you can do this exercise in a much easier manner:

public static int numberOfPairs(int[] a, int k ){ int count=0; List<Integer> dedup = new ArrayList<>(new HashSet<>(Arrays.asList(a))); for (int x=0 ; x < dedup.size() ; x++ ){ for (int y=x+1 ; y < dedup.size() ; y++ ){ if (dedup.get(x)+dedup.get(y) == k) count++; } } return count; } 

The trick here is to have a loop starting after the first loop's index to not count the same values twice, and not compare it with your own index. Also, you can deduplicate the array to avoid duplicate pairs, since they don't matter.

You can also sort the list, then break the loop as soon as your sum goes above k, but that's optimization.

This code will give you count of the pairs that equals to given sum and as well as the pair of elements that equals to sum

 private void pairofArrayElementsEqualstoGivenSum(int sum,Integer[] arr){ int count=0; List numList = Arrays.asList(arr); for (int i = 0; i < arr.length; i++) { int num = sum - arr[i]; if (numList.contains(num)) { count++; System.out.println("" + arr[i] + " " + num + " = "+sum); } } System.out.println("Total count of pairs "+count); } 

Given an array of integers and a target value, determine the number of pairs of array elements with a difference equal to a target value. The function has the following parameters:

k: an integer, the target difference

arr: an array of integers

Using LINQ this is nice solution:

 public static int CountNumberOfPairsWithDiff(int k, int[] arr) { var numbers = arr.Select((value) => new { value }); var pairs = from num1 in numbers join num2 in numbers on num1.value - k equals num2.value select new[] { num1.value, // first number in the pair num2.value, // second number in the pair }; foreach (var pair in pairs) { Console.WriteLine("Pair found: " + pair[0] + ", " + pair[1]); } return pairs.Count(); }