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;
};
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;
}, []);
};
seen object for a Set. When adding to the set use seen.add(x) and when checking seen.has(x).
\$\endgroup\$
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.
