Codewars javascript task - help to understand

Question

I am taking an excercise on codewars:

Given a list of integers and a single sum value, return the first two values (parse from the left please) in order of appearance that add up to form the sum. Example:

sum_pairs([10, 5, 2, 3, 7, 5],         10)
#              ^-----------^   5 + 5 = 10, indices: 1, 5
#                    ^--^      3 + 7 = 10, indices: 3, 4 *
#  * entire pair is earlier, and therefore is the correct answer
== [3, 7]

What do you think entire pair is earlier means? IMO if the sum of it's indexes is smallest. Now based on this assumption I made my solution and one test fails:

    var sum_pairs=function(ints, s){
      let i = 0;
      let pair = [0, 0];
      let ind = [100, 100]
      let found = false;
      
      function loop(i) {
    	if (i > ints.length) return pair;
        ints.slice(i).forEach((curr, idx) => {
          ints.slice(i+1).some((num, i) => {
            let sum = curr + num;
            let prevIndicies = ind[0] + ind[1];
            if(sum === s && prevIndicies > idx + i) {
              ind = [idx, i];
              pair = [curr, num];
              found = true;
              return true;
            }
          })
        })
        i += 1;
        loop(i)
      }
      loop(0)
      if (found) {
    	 return pair  
      }
      return undefined;
    }
    console.log(sum_pairs([1,4,8,7,3,15], 8))

Test returns error that [1, 7] is expected.

Answer 1

It means that you go from left to right and take the first matching pair, and since 7 is the first element that creats a pair (going from the left) 3 and 7 is the first pair.

I would solve it a bit easier:

function sum_pairs(arr, target) {
    let old = [];
    let result = [];
    arr.some((el) => {
        let found = old.find((oldEl) => oldEl + el === target);
        if (found) return result = [found, el];
        old.push(el);
    })
    return result;
}

sum_pairs([10, 5, 2, 3, 7, 5], 10);

Edit: an explaination. I loop over all elements in the array searching for a match i all the elements I have passed. If I find a match I remember it and break out of the loop by returning a "truthy" value. (That is just how .some() works.) Finally if I have not found a match I add the element to my list of old elements and go on to the next.

Answer 2

I'm pretty sure what it means is they want the second element to be as leftward in the list as possible. For example, for

l5= [10, 5, 2, 3, 7, 5];

when trying to find a sum of 10, the desired output is

[3, 7]
[10, 5, 2, 3, 7, 5];
           ^  ^

instead of

[5, 5]
[10, 5, 2, 3, 7, 5];
     ^           ^

because the last element in [3, 7], the 7, came before the second 5.

This code seems to pass all test cases - iterate in a triangular fashion, starting at indicies [0, 1], [0, 2], [1, 2], [0, 3], [1, 3], [2, 3], ...:

const sum_pairs = function(ints, s){
  const { length } = ints;
  for (let i = 1; i < length; i++) {
    for (let j = 0; j < i; j++) {
      if (ints[i] + ints[j] === s) return [ints[j], ints[i]];
    }
  }
}

const sum_pairs=function(ints, s){
  const { length } = ints;
  for (let i = 1; i < length; i++) {
    for (let j = 0; j < i; j++) {
      if (ints[i] + ints[j] === s) return [ints[j], ints[i]];
    }
  }
}

l1= [1, 4, 8, 7, 3, 15];
l2= [1, -2, 3, 0, -6, 1];
l3= [20, -13, 40];
l4= [1, 2, 3, 4, 1, 0];
l5= [10, 5, 2, 3, 7, 5];
l6= [4, -2, 3, 3, 4];
l7= [0, 2, 0];
l8= [5, 9, 13, -3];


console.log(sum_pairs(l1, 8))
console.log(sum_pairs(l2, -6))
console.log(sum_pairs(l3, -7))
console.log(sum_pairs(l4, 2))
console.log(sum_pairs(l5, 10))
console.log(sum_pairs(l6, 8))
console.log(sum_pairs(l7, 0))
console.log(sum_pairs(l8, 10))

Answer 3

function sum_pair(arr,sum){
    let result = [];
    arr.forEach((i, j)=>{
    if(i+arr[j+1]===sum){
        console.log(i,arr[j+1], i+arr[j+1])
    }
  })
}

sum_pair([0, 3, 7, 0, 5, 5],10)