Javascript如何比较两个数组并获取彼此最接近的值

Question

我有两个数组：

let arr1 = [6, 10, 7, 7] 
let arr2 = [6, 16, 20, 9]

arr1中的每个值代表问题的分数，其中arr2中的每个值代表问题的最大分数。所以这些值是相互关联的。例如，问题1得分为6分，最高分为6分，问题2给出最高得分为16分的10分。

现在，我想比较这些值，得到最接近彼此的3个值。所以在这种情况下，问题1: 6，6 (0差)，问题2: 10，16 (差6)，问题4: 7，9(差2)，也许是按差异分类？

我怎样才能做到这一点？

Answer 1

我将创建一个包含arr1、arr2和差异信息的新数组。如果这样做，排序和选择前3个元素变得非常简单：

let arr1 = [6, 10, 7, 7] 
let arr2 = [6, 16, 20, 9]

// create a new array with an object for each pair in arr1 and arr2
let zipped = []
for (let i = 0; i < arr1.length; i++) {
    zipped.push({
        score: arr1[i],
        max: arr2[i],
        diff: arr2[i] - arr1[i]
    })
}

// sort the array by diff
zipped.sort((a, b) => a.diff - b.diff)

// print out the first 3 elements
console.log(zipped.slice(0, 3))

Answer 2

从上面的评论..。

“最接近的项目不是由最小差决定的，而是由最近/等于最大值1的商数决定的。

..。因此，我们可以选择一种基于reduce的方法，通过从每个数组的相应值中创建和收集评分项目，创建一个评分表，该方法具有取得的分数和可实现的分数。

排序就成了小菜一碟，因为每个评分项目都有以下特性. achieved、achievable、scoreDelta和rating。建议按降序rating进行排序。但是，当然，OP总是可以按升序scoreDelta排序。

​

function createAndCollectRatedScoreItem({ achievables, result }, achieved, idx) {
  const achievable = achievables[idx];
  result.push({
    rating: achieved / achievable,
    achieved,
    achievable,
    scoreDelta: achievable - achieved,
  });
  return { achievables, result };
}
const achievedScoreList = [6, 10, 7, 7, 1];
const achievableScoreList = [6, 16, 20, 9, 2];

const ratedScoreList = achievedScoreList
  .reduce(
    createAndCollectRatedScoreItem,
    { achievables: achievableScoreList, result: [] }
  )
  .result
  .sort((a, b) => b.rating - a.rating);
 
const bestRatedScoreTripple = ratedScoreList.slice(0, 3);

console.log({ ratedScoreList, bestRatedScoreTripple });
console.log(
  'rated score list sorted by ascending score delta ...',
  ratedScoreList.sort((a, b) => a.scoreDelta - b.scoreDelta)
);

.as-console-wrapper { min-height: 100%!important; top: 0; }

​

另一种使代码可重用的方法是将map与其第二个thisArg parameter结合使用。

然后，上述代码示例的实现将稍微更改为..。

​

function createRatedScoreItemFromBoundAchievableScores(achieved, idx) {
  const achievable = this[idx];
  return {
    rating: achieved / achievable,
    achieved,
    achievable,
    scoreDelta: achievable - achieved,
  }
}
const achievedScoreList = [6, 10, 7, 7, 1];
const achievableScoreList = [6, 16, 20, 9, 2];

const ratedScoreList = achievedScoreList
  .map(
    createRatedScoreItemFromBoundAchievableScores,
    achievableScoreList
  )
  .sort((a, b) => b.rating - a.rating);
 
const bestRatedScoreTripple = ratedScoreList.slice(0, 3);

console.log({ ratedScoreList, bestRatedScoreTripple });
console.log(
  'rated score list sorted by ascending score delta ...',
  ratedScoreList.sort((a, b) => a.scoreDelta - b.scoreDelta)
);

.as-console-wrapper { min-height: 100%!important; top: 0; }

​

Answer 3

首先，我要把每个问题的所有相关数据合并到一个对象中。我们可以使用一个组合数组，而不是两个单独的数组。根据操作后需要的信息，您可能希望在此对象中包含/省略某些信息。

如果您在操作后需要问题的索引，您可能需要提前存储它。如果您想根据最大分数和实际分数之间的差异进行排序，提前计算这个值会更快。

收集数据的一个非常简单的方法是使用map()

const combined = arr1.map((score, index) => {
  const max   = arr2[index];
  const diff  = max - score;
  const ratio = score / max;
  return { score, max, index, diff, ratio };
});

在收集了必要的数据之后，您可以根据您的标准对数组进行sort()。例如：

combined.sort((a, b) => a.diff - b.diff);

在对数据进行排序之后，您可以使用以下方法获取前3个元素。slice()。

// Takes element 0 up to but not including 3 and put them in a new array.
const result = combined.slice(0, 3);
console.log(result);

或者，您也可以使用splice()来变异combined，删除所有不需要的元素。

// Removes all elements starting at element 3.
combined.splice(3);
console.log(combined);

​

const actualScores = [6, 10,  7, 7];
const maxScores    = [6, 16, 20, 9];

const scores = actualScores.map((score, index) => {
  const max   = maxScores[index];
  const diff  = max - score;
  const ratio = score / max;
  return { score, max, index, diff, ratio };
});

// sort by ratio descending
scores.sort((a, b) => b.ratio - a.ratio);
// take elements 0-3 (excluding) from `scores`
const scoresA = scores.slice(0, 3);

// sort by diff ascending
scores.sort((a, b) => a.diff - b.diff);
// take elements 0-3 (excluding) from `scores`
const scoresB = scores.slice(0, 3);

// remove all elements with index 3 or higher
scores.splice(3)

console.log("first 3 scores ordered by ratio descending",        scoresA);
console.log("first 3 scores ordered by diff ascending (slice)",  scoresB);
console.log("first 3 scores ordered by diff ascending (splice)", scores);

​