Checking whether there are any two numbers that will sum up to a given number

In this article I'll discuss the solution for a common JavaScript interview algorithm:

// In an unsorted array, check whether 
// there are any two numbers that will 
// sum up to a given number. Example:

// sumFinder([6, 4, 3, 2], 9) = true 
// (because 6 + 3 equals 9.)

// sumFinder([6, 4, 3, 2], 2) = false 
// (because nothing in the array plus 
// another number in the array equals 2.) 

JavaScript Implementation

function sumFinder(arr, num) {
  let obj = {}
  let diff

  for (let i = 0; i < arr.length; i++) {
    diff = num - arr[i]

    if (obj[diff]) {
      return true
    } else {
      obj[arr[i]] = true
    }
  }
  return false
}

let sumFinderResult = sumFinder([6, 4, 3, 2], 7)
// returns true

let anotherSumFinderResult = sumFinder([6, 4, 3, 2], 1)
// returns false

Short Explanation of the Solution

If the difference between the function's given target number (the number provided by itself in the arguments list) and an element in the array is equal to another element in the array, return true. Else, return false.

Longer Explanation of the Solution

• For each element in the array, get the difference between the given number (the number provided by itself in the arguments list) and the current element in the array.
• Put the current element into an object as a key.
• If any element in the array (if any key in our object) matches the difference between the given number and the new current element, return true.
• Else, return false.

An example of the solution using concrete numbers

Let's say sumFinder was called with two parameters: an array of [6, 4, 3, 2], and a given number of 7:

sumFinder([6, 4, 3, 2], 7)

First, according to the above code implementation, an empty object is created, and a diff variable is declared. Then, a for loop is created that loops through each index of the array. The first index points to 6. The line:

diff = num - arr[i]

now translates to:

diff = 7 - 6
// diff is now assigned 1

Since a key of 1 doesn't yet exist in our object, we will insert arr[i], or 6 as a key in our object.

Now on the second loop iteration, our num is 7 (the num never changes). The arr[i] is 4, and the diff is therefore 3. Since 3 is not yet a key in our object, we will add arr[i], or 4 as a key in our object.

On the third loop iteration, our num is 7, the arr[i] is 3, and the diff is therefore 4. This time, 4 is a key in our object, so we return true. We return true because we have successfully figured out that there are two numbers in our array (3 and 4) that will sum up to our given number (7).