Finding all pairs of elements in an array that sum to a target value

Question

Is there a shorter way and does not involve nested for loops?

const checkIfSumFromTwoNumbers = (arrayOfNum, targetValue) => {
    let found = [];
    let result = [];

    for (let value of arrayOfNum) {
        if (found[targetValue - value] === true ) {
            result.push({[arrayOfNum.indexOf(value)]: value, [arrayOfNum.indexOf(targetValue-value)]: targetValue - value});
        }
        found[value] = true;
    }
    return result;
};

Answer 1

No, each number requires a second pass to determine whether combined with an existing one it is a match - doesn't mean it can't be short though e.g.

const checkIfSumFromTwoNumbers = (arrayOfNums, targetValue) => 
  arrayOfNums.reduce((matches, val) => {
      const target = arrayOfNums.find(x => (val + x) === targetValue);
      target && matches.push([val, target]);
      return matches;
   }, [])

I was actually ignorant to the fact your code actually works which means it can be done in one pass :) here's a slightly neater / more concise version of what you already have:

const checkIfSumFromTwoNumbers = (arrayOfNum, targetValue) => {
  const seen = {};
  return arrayOfNum.reduce((matches, val) => {
    const delta = targetValue - val;
    seen[delta] && matches.push([delta, val]);
    seen[val] = true;
    return matches;
  }, []);
};

Answer 2

Since you mentioned shorter, the same array can be used for found and result:

const f = (a, t) => a.reduce((r, v) => (r[v - t] && r.push([t - v, v]), r[-v] = 1, r), [])

const f2 = (a, t) => a.reduce((r, v, i) => 
    (r[v - t] + 1 && r.push({ [r[v - t]]: t - v, [i]: v }), r[-v] = i, r), [])

const a = [3, 1, 2, 2, 3, 4], l = console.log, j = JSON.stringify
l(j( f(a, 6) ))
l(j( f2(a, 6) ))

// .slice() can be added to the result to make a copy without the "hidden" items:
l(j({ ...f(a, 6)         }))
l(j({ ...f(a, 6).slice() }))

Hacky code golfed answers like this are probably not very appropriate on Code Review, so hopefully it's not too much against the rules. A bit of explanation:

In JavaScript, Array is actually an object that uses positive integer properties. For Example:

a = []
a[1] = 1
a.b = 'c'
a[-1] = -1
a[0.1] = 0.1
a[/./g] = /./g

console.log(a)      // [undefined, 1] - only the positive integer properties

console.log({...a}) // { "1": 1, "b": "c", "-1": -1, "0.1": 0.1, "/./g": /./g }

So this part r[-v] = 1 adds a key -v to the array, and r[v - t] && checks if the array has entry with key -(target - value), and if the entry's value evaluates to true.

Another part is the Comma Operator. In JavaScript result = (expresion1, expresion2) evaluates both expressions and returns the result of the last one.