# Problem Statement
Given an array of integers and a value, determine if there are any two integers in the array whose sum is equal to the given value. Return true if the sum exists and return false if it does not.

Consider this array and the target sums:

# Hints
* Use hashing
* Use comparison between elements

<br>

# Try it yourself

bool find_sum_of_two(vector<int>& A, int val) {
  //TODO: Write - Your - Code
  return false;
}

#include <iostream>
#include <unordered_set>
#include <vector>
#include <assert.h>

using namespace std;

string convertbool(bool a){
  if(a) return "true";
  
  return "false";
}

class FindSum{
  static boolean findSumOfTwo(int[] A, int val) {
    //TODO: Write - Your - Code
    return false;
  }
} 

Java

def find_sum_of_two(A, val):
 #TODO: Write - Your - Code
  return False;

Python

let findSumOfTwo = function(A, val) {
 //TODO: Write - Your - Code
  return false;
};

JavaScript

def find_sum_of_two(arr, val)
  #TODO: Write - Your - Code
  return false 
end

Ruby

bool find_sum_of_two(vector<int>& A, int val) {
  unordered_set<int> found_values;
  for (int& a : A) {
    if (found_values.find(val - a) != found_values.end()) {
      return true;
    }
    found_values.insert(a);
  }
  return false;
}

int main() {
  vector<int> v = {5, 7, 1, 2, 8, 4, 3};
  vector<int> test = {3, 20, 1, 2, 7};

  for(int i=0; i<test.size(); i++){
    bool output = find_sum_of_two(v, test[i]);
    cout << "find_sum_of_two(v, " << test[i] << ") = " << (output ? "true" : "false") << endl;
  }
  return 0;
}

class FindSum{
  static boolean findSumOfTwo(int[] A, int val) {
    Set<Integer> foundValues = new HashSet<Integer>();
    for (int a : A) {
      if (foundValues.contains(val - a)) {
        return true;
      }

      foundValues.add(a);
    }
    return false;
  }

  public static void main(String[] args) {
    int[] v = new int[] {5, 7, 1, 2, 8, 4, 3};
    int[] test = new int[] {3, 20, 1, 2, 7};
    
    for(int i = 0; i < test.length; i++){
    boolean output = findSumOfTwo(v, test[i]);
    System.out.println("findSumOfTwo(v, " + test[i] + ") = " + (output ? "true" : "false"));
    }
  }
}

def find_sum_of_two(A, val):
  found_values = set()
  for a in A:
    if val - a in found_values:
      return True

    found_values.add(a)
    
  return False

v = [5, 7, 1, 2, 8, 4, 3]
test = [3, 20, 1, 2, 7]

for i in range(len(test)):
  output = find_sum_of_two(v, test[i])
  print("find_sum_of_two(v, " + str(test[i]) + ") = " + str(output))

def find_sum_of_two(arr, val)
  found_values = Set.new
  arr.each do |elt|
    if (found_values.include?(val - elt))
      return true
    end
    found_values.add(elt)
  end
  return false
end

v = [5, 7, 1, 2, 8, 4, 3]
test = [3, 20, 1, 2, 5]
for i in 0 .. test.length-1
  output = find_sum_of_two(v, test[i]) 
  puts "find_sum_of_two(v, " + test[i].to_s + ") = " + output.to_s 
end

# Solution Explanation

## Runtime Complexity
The runtime complexity of this solution is linear, O(n).

## Memory Complexity
The memory complexity of this solution is linear, O(n).

<br>

## Solution Breakdown

In this solution, you can use the following algorithm to find a pair that add up to the target (say `val`).

* Scan the whole array once and store visited elements in a hash set.
* During scan, for every element `e` in the array, we check if `val` - `e` is present in the hash set i.e. `val` - `e` is already visited.
  * If `val` - `e` is found in the hash set, it means there is a pair (`e`, `val` - `e`) in array whose sum is equal to the given `val`.
  * If we have exhausted all elements in the array and didn’t find any such pair, the function will return `false`.


> Practice problems like this and many more by checking out our [Grokking the Coding Interview: Patterns for Coding Questions](https://www.educative.io/courses/grokking-the-coding-interview) course!

Given an array of integers and a value, determine if there are any two integers in the array whose sum is equal to the given value.

Sum of Two Values

Problem Statement

Hints

Try it yourself

Solution

Solution Explanation

Runtime Complexity

Memory Complexity

Solution Breakdown