Question

给出一个整数列表和一个和值，返回前两个值（请从左边开始解析），按相加顺序出现形成总和。示例：

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]

您认为整个配对更早是什么意思？如果其索引的总和最小，则为IMO。现在，基于此假设，我提出了解决方案，但一项测试失败了：

    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))

测试返回预期为[1, 7]的错误。

Answer 1

我很确定这意味着他们希望第二个元素在列表中尽可能向左。例如，对于

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

当试图求和10时，所需的输出是

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

代替

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

因为[3, 7]中的最后一个元素7排在第二个5之前。

此代码似乎通过了所有测试用例-以三角方式迭代，从索引[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 2

这意味着您从左到右移动并获得第一个匹配对，并且由于7是创建对的第一个元素（从左边开始），而3是第一个对。

我会更轻松地解决它：

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);

编辑：说明。我遍历数组中的所有元素以查找匹配的所有元素。如果找到匹配项，我会记住它并返回“真实”值来退出循环。（这就是.some（）的工作方式。）最后，如果找不到匹配项，则将该元素添加到旧元素列表中，然后继续进行下一个操作。

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)

Codewars JavaScript任务-帮助理解

3 个答案: