循环中的求和对不能按预期工作[重复]

Question

下面是任务描述和我写函数的两次尝试（都输出错误的结果，例如用这些参数检查我的第二个函数：

sumPairs([10, 5, 2, 3, 7, 5], 10); 
*outputs [5, 5], should be [3, 7]*
sumPairs([1, 2, 3, 4, 5, 8, 6, 13, 9], 10);
*outputs [1, 9], should be [2, 8]*

请指出我解决此问题的方式有什么问题。 下面我解释一下我尝试做的事情。

.......................

任务描述：

对的总和。

给定一个整数列表和一个总和值，返回前两个 值（请从左侧解析）按出现的顺序加起来 形成总和。

sum_pairs([11, 3, 7, 5], 10)。

结果：3 + 7 = 10

sum_pairs([4, 3, 2, 3, 4], 6).

结果：4 + 2 = 6，因为最早的索引：0、2，因为整个 对更早。

sum_pairs([0, 0, -2, 3], 2).

结果：未定义。

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

结果：3 + 7 = 10，索引：3、4，因为整对更早， 因此是正确答案。

负数和重复数可以并且将会出现。

注意：还将测试长度超过 10,000,000 的列表 元素。确保您的代码不会超时。 ......................................

我的计划是：循环遍历 ints 数组的每个元素，将每个元素添加到 ints 数组的其他元素（除了将相同的元素添加到自身），直到找到 1 或 2 对元素加起来 s总和：*

function sumPairs(ints, s) {
  let arrResults = [];
  let sumOfTwo;
  for (i = 0; i < ints.length; i++) {
    for (j = 0; j < ints.length; j++) {
      if (j !== i) {
        sumOfTwo = ints[i] + ints[j];
        if (sumOfTwo === s) {
          return [ints[i], ints[j]];
        }
      }
    }
  }
  return undefined;
}

console.log(
sumPairs([10, 5, 2, 3, 7, 5], 10),
// *outputs [5, 5], should be [3, 7]*
sumPairs([1, 2, 3, 4, 5, 8, 6, 13, 9], 10)
// *outputs [1, 9], should be [2, 8]*

)

一旦找到前 1 或 2 对，我就使用 break 语句停止循环。找到 2 对元素后，选择 ints 数组中“较早”（具有较早索引）的对。当然 indexOf 重复的问题再次出现。所以我尝试在每个循环中创建一个单独的计数器。然后将结果推送到单独的 arrResults 中并选择最佳对：

function sumPairs(ints, s) {
  let arrResults = [];
  let sumOfTwo;
  let iIndexCount = 0;
  let jIndexCount = 0;

  for (i = 0; i < ints.length; i++) {
    for (j = 0; j < ints.length; j++) {
      if (j !== i) {
        sumOfTwo = ints[i] + ints[j];
        if (sumOfTwo === s) {
          arrResults.push(ints[i], ints[j], jIndexCount - iIndexCount);
        }
      }
      jIndexCount++;
      if (arrResults.length === 9) {
        break;
      }
    }
    iIndexCount++;
    if (arrResults.length === 9) {
      break;
    }
  }

  if (arrResults.length === 9) {
    if (arrResults[2] <= arrResults[8]) {
      return [arrResults[0], arrResults[1]];
    } else {
      return [arrResults[6], arrResults[7]];
    }
  } else if (arrResults.length === 6) {
    return [arrResults[0], arrResults[1]];
  } else {
    return undefined;
  }
}

console.log(
sumPairs([10, 5, 2, 3, 7, 5], 10), 
// *outputs [5, 5], should be [3, 7]*
sumPairs([1, 2, 3, 4, 5, 8, 6, 13, 9], 10)
// *outputs [1, 9], should be [2, 8]*
)

Answer 1

这很有趣 - 有点过度设计，但提供了标记和距离

按距离排序（如果需要，还可以使用 idx1）

function sumPair(list, s) {
  var pairs = []
  for (var i = 0; i < list.length; i++) {
    for (var j = i + 1; j < list.length; j++) {
      const sum = list[i] + list[j]
      if (sum === s) pairs.push({
        idx1: i,
        first: list[i],
        idx2: j,
        second: list[j],
        distance: j - i
      });
    }
  }
  if (pairs.length) return pairs.sort((a,b) => a.distance - b.distance)[0]
  return undefined;
};

let { first, second } = sumPair([1, 2, 3, 4, 5, 8, 6, 13, 9], 10)
console.log(first,second)

// similar for the rest
console.log(sumPair([10, 5, 2, 3, 7, 5], 10));
console.log(sumPair([1, 2, 3, 4, 5, 8, 6, 13, 9], 10))
console.log(sumPair([3, 1, 4, 1, 2, 6, 5], 8))
console.log(sumPair([1, 2, 3, 4, 5, 8, 6, 13, 9], 21))

Answer 2

按照 cmets 到上一个（错误）答案，在这里您可以看到一个修改（和评论）的版本：

function sumPairs(arr, sum) {
  const pairs = [];
  for (let i = 0; i < arr.length; i++) {
    let first = arr[i];
    if (first < sum) { // no point in checking anything, if the number itself is already equal to or bigger than the expected sum
      /*
       * As a + b === b + a, it is pointless to compare the sum of an item
       * with any preceding item because that would have been already checked
       * therefore each number will be compared only with the following ones,
       * in order to avoid unnecessary iterations
       */
      const rest = arr.slice(i + 1);
      for (let j = 0; j < rest.length; j++) {
        const second = rest[j];
        if (second < sum && first + second === sum) pairs.push({
          pair: [first, second],
          lastIndex: j // storing the last index will make easier to sort the pairs later
        });
      }
    }
  }

  return pairs.length === 0
    // no pair found
    ?
    undefined :
    pairs.length === 1
    // only one pair found
    ?
    pairs[0].pair
    // more then one pair found: order pairs by the index  (lowest to highest index)
    // of the second number and pick the first one
    :
    pairs.sort((a, b) => a.lastIndex - b.lastIndex)[0].pair
}

// test
console.log('#testing sumPairs([11, 3, 7, 5], 10):');
console.log(sumPairs([11, 3, 7, 5], 10));
console.log('#testing sumPairs([4, 3, 2, 3, 4], 6):');
console.log(sumPairs([4, 3, 2, 3, 4], 6));
console.log('#testing sumPairs([0, 0, -2, 3], 2):');
console.log(sumPairs([0, 0, -2, 3], 2));
console.log('#testing sumPairs([10, 5, 2, 3, 7, 5], 10):');
console.log(sumPairs([10, 5, 2, 3, 7, 5], 10));

Answer 3

这种方法使用Set() 来存储数字，因此只需要一个循环。

灵感来自 NinaScholz 对您之前的 question 的回答：

    
function sumPairs(ints, s) {
    const set = new Set();
    for(let n of ints) {
        if (set.has(s - n)) {
          return ([s - n, n]);
        } else {
          set.add(n);
        }
    }
}


console.log(sumPairs([10, 5, 2, 3, 7, 5], 10))
console.log(sumPairs([1, 2, 3, 4, 5, 8, 6, 13, 9], 10))
console.log(sumPairs([11, 3, 7, 5], 10))
console.log(sumPairs([4, 3, 2, 3, 4], 6))
console.log(sumPairs([11, 1, 7, 5], 10));