Question

我解决了这个问题

问题：

给定一个整数数组，找到最接近的两个元素 0

我的NativeJS解决方案：

＆＃13;

@if

＆＃13;

我使用原生实现获得了正确的结果，但我无法使用reduce解决问题。

有人可以用我的逻辑来帮助我吗？

Answer 1

以下是Javascript中一个天真的二次时，恒定空间解决方案。我假设数组包含至少两个元素，并且为了清楚起见，避免各种健全性检查。这些边缘情况很容易处理。

function diff(arr, p) {
    return Math.abs(arr[p[0]] + arr[p[1]]);
}

function isBetter(arr, p1, p2) {
    return diff(arr, p1) < diff(arr, p2);
}

function sumZero(arr){
    let bestPair = [0, 1];
    for (let i = 0; i < arr.length; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (isBetter(arr, [i, j], bestPair)) {
                bestPair = [i, j];
            }
        }
    }
    return bestPair;
}

算法是正确的，因为它搜索数组中的所有{n选择2}对元素，并且当搜索对的空间时，跟踪最佳算法。循环终止后，bestPair是数组arr的索引对，它们最接近于一个（在arr的所有元素对中）。

Answer 2

如果我理解正确的话。

function closestZeroPairFirstIndex(a) {
  var idxResult = null;
  var temp = Infinity;

  a.forEach(function(i, idx, arr) {
    var sum = Math.abs(i + (arr[idx + 1] || 0));
    if (sum < temp) {
      temp = sum;
      idxResult = idx;
    }
  });

  return idxResult;
}

console.log(closestZeroPairFirstIndex([10,2,7,-4,5,6,7]))
console.log(closestZeroPairFirstIndex([10,2,7,-4,5,-7,7])) 
console.log(closestZeroPairFirstIndex([10,2,-7,-4,5,-5,-7]))

Answer 3

您可以执行以下操作;

＆＃13;

function getAbsoluteMinSum(arr){
  return arr.map((e,i,a) => a.slice(i+1)
                             .reduce((r,c) => Math.abs(e + c) < r.sum ? (r.sum = e + c, r.summand = c, r)
                                                                      : r, {val: e, sum: Infinity, summand: void 0}))
            .reduce((p,c) => Math.abs(p.sum) < Math.abs(c.sum) ? p : c);
}

var a = [1,3,4,-1,-2,4,5,-9];
  res = getAbsoluteMinSum(a);
console.log(res);

＆＃13;

如果有多对提供相同的最小金额，此代码将仅为您提供最后一个满意的项目。如果您想要一个总和达到可用最小总和的所有对的列表，那么您必须将最后一个reduce更改为累积的一个。

另一种方法是;

＆＃13;

function getAbsoluteMinSum(a){
  var hash = {},
         i = 0,
         j = 0,
         c,d;
  while(i < a.length){
    j = i+1;
    c = a[i++];
    while(j < a.length){
      d = a[j++];
      hash[c+d] = hash[c+d] ? hash[c+d].concat([[c,d]])
                            : [[c,d]];
    }
  }
  return hash[Math.min(...Object.keys(hash).map(Math.abs))];
}

var a = [1,3,4,-1,-2,4,5,-9,2,-4];
  res = getAbsoluteMinSum(a);
console.log(res);

＆＃13;

Answer 4

一个简单的算法：

创建一个已处理的数组以保存2个值的总和。
现在只需对其进行排序并获得必要的价值。

次要优化将从父循环的索引开始内循环。

＆＃13;

var a = [1,3,4,-1,-2,4,5,-9];
var sumArray = [];
var len = a.length;

for(var i = 0; i< len; i++){
  for(var j = i+1; j< len; j++){
    sumArray.push({
      o1: a[i],
      o2: a[j],
      sum: a[i] + a[j]
    })
  }
}

sumArray.sort(function(a,b){  
  return Math.abs(a.sum) - Math.abs(b.sum)
})

console.log(sumArray)

＆＃13;

给定一个整数数组，找到最接近0的两个元素。

4 个答案: