Two Pointer Method

In this approach we use two pointer to find if the target value exist in the array or not. We will use two pointer left and right initialized with the value of 0 and n-1 respectively. We will traverse until left pointer crosses the right pointer and find if the pair with sum value equal to target exist. If the pair exist then we will return true else return false.

Below steps to implement above approach

  • Sort the array.
  • Initialize the two pointers left and right , with left = 0 and right = n-1.
  • Traverse the loop until left crosses right.
  • If any pair with sum equal to target value exist , return true.
  • else return false.

Example: This example implements the above-mentioned approach.

Javascript




function twoSum(n, arr, target) {
    arr.sort((a, b) => a - b);
    let left = 0, right = n - 1;
    while (left < right) {
        const sum = arr[left] + arr[right];
        if (sum === target) {
            return "True";
        } else if (sum < target) {
            left++;
        } else {
            right--;
        }
    }
    return "False";
}
 
function main() {
    const n = 5;
    const arr = [3, 6, 4, 8, 7];
    const target = 10;
    const ans = twoSum(n, arr, target);
    console.log(ans);
}
 
main();


Output

True


Check if Pair with given Sum Exists in Array using JavaScript

We will check if a pair with a given Sum exists in an Array or not using JavaScript.

Similar Reads

2Sum Problem

The 2sum is a famous problem asked in most interviews. We have to check whether a pair of numbers exists whose sum is equal to the target value. We are given an array of integers and the target value. We have to return true if the pair whose sum is equal to the target value exists else we have to return false....

Following are the approaches

Table of Content Brute Force Method Hashing Method Two Pointer Method...

Approach 1: Brute Force Method

The Two Sum issue may be solved brute-force style by using nested loops to iteratively verify every possible pair of integers in the array. However, for big datasets, this strategy is inefficient due to its O(n2) time complexity, where n is the array’s size....

Approach 2: Hashing Method

...

Approach 3: Two Pointer Method

A more effective method stores the array’s items and their indexes in a hash table (or dictionary). This makes constant-time lookups possible. As the method loops across the array, it determines each element’s complement (goal sum minus the current element) and verifies that it is present in the hash table. If it is located, it provides the indices of the element that is now active as well as its complement; this has an O(n) time complexity....