codewars sum of pairs

Sum of Pairs

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.

sum_pairs([11, 3, 7, 5],         10)
#              ^--^      3 + 7 = 10
== [3, 7]

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

sum_pairs([0, 0, -2, 3], 2)
#  there are no pairs of values that can be added to produce 2.
== None/nil/undefined (Based on the language)

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]

Negative numbers and duplicate numbers can and will appear.

NOTE: There will also be lists tested of lengths upwards of 10,000,000 elements. Be sure your code doesn't time out.

这道题目的意思是说：给出一个数组，然后给出一个number，需要从数组中找到两个元素的和等于目标值得number，如果有多对组合的，需要对多对组合进行下标比对，下标整体靠前的就是目标选项，将该组合返回即可，如果没有找到，返回undefined。

特别注意的是，它的测试中会有一个特别长的数组，长度可能会超过10,000,000个元素，如果你的算法不够高效，很有可能会超时，它设置的超时时间是12s。

我思考了半天，第一个办法是按照常规，双重for循环找到所有组合，然后再对找到的所有组合比对下标，整体靠前的返回。

没错，你想到了，方法没错，返回超时。

方法二：这回学聪明了，先找到一组组合，然后再循环时从比它下标小的范围内寻找，如果没有找到，就把第一组组合返回，如果找到了就替换，然后继续在更小的范围内寻找。最坏的情况是都找完，找不到的话，返回undefined。

以为优化了不少了，但是依然timeout。

/your code here
      let result = [];
      let pos = 0;
      for (let i = 0; i < ints.length - 1; i++) {
        if (result[1]) {
          if(i>pos){
            break;
          }
          for (let j = i + 1; j < pos; j++) {
            if (ints[i] + ints[j] == s) {
                result = [ints[i], ints[j]];
            }
          }
        } else {
          for (let j = i + 1; j < ints.length; j++) {
            if (ints[i] + ints[j] == s) {
              if (!result[1] || (result[1] && result[1] > j)) {
                result = [ints[i], ints[j]];
                pos = j;
              }
            }
          }
        }
      }
      return result.length > 0 ? result : undefined;

没错，我就是这么菜，水平到这里了，江郎才尽了。。。

不过别失望，带你去看看大神的代码吧，吸收一点经验也是好的。

大神代码：

var sum_pairs=function(ints, s){
  var seen = {}
  for (var i = 0; i < ints.length; ++i) {
    if (seen[s - ints[i]]) return [s - ints[i], ints[i]];
    seen[ints[i]] = true
  }
}

什么，代码居然可以这么简练？没错，就是这么简练，然后细细品味一番，它巧妙的把对比过的数字变成一个对象的属性并且设置为true，然后用seen(s-ints[i])是否为true来判定是否找到了组合，一旦找到了，它们的下标必定是最小的。因为该方法的重点就是找到最小的下标值，控制好了最小下标值，你就赢了！！！