这题目有毒之干不过codewars的OJ系统（一）

题目描述

给定一个整数数组和一个求和的数值，函数返回数组中第一对元素求和值等于给定求和值的数组元素，返回形式为数组。
案例：

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
# 第一对数组中10的索引为5，比第二对数组中的索引3/4要大，所以程序的结果是第二对数组。
== [3, 7]

负整数和重复的数字的情况可能会出现，测试中会有超过1000000（一千万）个元素的数组，确认不要超时。

失败的解决方案

失败原因：超时

第一种算法：

//超过10000000个元素的数组运行时间超过7000ms,失败
//思路：循环给定数组，判断求和值与当前循环数组元素之差是否存在
//处理找到多个求和结果下的情况，找到其索引最小的一组值。
var sum_pairs=function(ints, s){
  var flag = 0;
  var lastarr = [];
    for(var i = 0,len = ints.length;i<len;i++){
      var jia = s-ints[i];
      var jiaindex = ints.indexOf(jia,i+1);
  if(jiaindex!=-1){
  console.log(ints[i],jia);
  flag = 1;
  lastarr.push([i,jiaindex]);
    }
  }
  if(lastarr.length === 0){
    return undefined;
  }
  var tt = lastarr.map(function(v){
    return v[0]>v[1]?v[0]:v[1];
  }).reduce(function(p,c){
    return p<c?p:c;
  });
  var twoindex = ints.indexOf(s-ints[tt]);
  return tt<twoindex?[ints[tt],ints[twoindex]]:[ints[twoindex],ints[tt]];
  if(flag == 0) return undefined;
}

奈何第一个极长数组的测试都没通过。
第二种算法：

//同样的失败原因
//思路：找到求和值（有正有负）的绝对值的负数，然后从负数开始进行for循环，判断给定数组中是否存在当前循环值及求和值与当前循环值之差
//同样要找到多个结果中索引最小的结果。
var sum_pairs=function(ints, s){
  var flag = 0;
  var lastarr = [];
  for(var i = (-Math.abs(s));i<=Math.abs(s);i++){
    var index1 = ints.indexOf(i);
    //找到的一对值不能是同一个元素
    var index2 = ints.indexOf(s-i,index1+1)
    //改正第二个值可能漏掉的情况
    if(index1!=-1 && index2==-1 && i!=s-i){index2 = ints.indexOf(s-i);}
    if(index1!=-1 && index2!=-1){
      lastarr.push([index1,index2]);
      }
//结果数组为空数组则返回undefined
    if(lastarr.length == 0)return undefined;
    //找到最小索引
  var tt = lastarr.map(function(v){
    return v[0]>v[1]?v[0]:v[1];
  }).reduce(function(p,c){
    return p<c?p:c;
  });
   var twoindex = ints.indexOf(s-ints[tt]);
   console.log([ints[twoindex],ints[tt]]);
  return tt<twoindex?[ints[tt],ints[twoindex]]:[ints[twoindex],ints[tt]];
  //return [ints[tt],s-ints[tt]];
  if(flag == 0) return 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
  }
}
//似乎我对求最小索引的一对值理解有误，呵呵！

---