通过在多个标准中对集合进行排序来对集合进行排序

Question

这就是我要解决的任务。

我们有一个主阵列和几个像这样的仆从阵列：

var master = [3, 2, 2, 4, 15, 8];
var minions = [
  {
    id : "Minion1",
    imitation : [2, 1, 0, 3, 11, 5],
  },
  {
    id : "Minion2",
    imitation : [1, 3, 2, 1, 12, 7],
  },
  {
    id : "Minion3",
    imitation : [4, 3, 1, 1, 11, 6],
  }
];

让我们假设奴才试图模仿大师。我们需要通过给他们打分来知道谁做得更好。

限制： - 可以有任意数量的仆从 - 我们只比较数值 - 数组中的数字数量始终保持不变

---

所以我想出了这个逻辑：

1. 从master中对应的数字中减去minions数组中的每个数字，得到这个的绝对值。因为如果 Master 有第一个 3 号，Minion1 有 2 号，Minion3 有 4 号。Minion1 和 Minion3 距离 Master 一样远。

2. 将每个 minion 的绝对值推送到数组中。

3. 比较数组中的绝对值并对数组中的每个数字进行排序。 也许类似于 master[0]:

   • 小黄人1[0]
   • 小黄人3[0]
   • 小黄人2[0]

4. 根据它们的位置，为数组中的每个数字分配点，相互比较。 大师[0]：

   • 小黄人1[0] +3 分
   • Minion3[0] +2 分
   • 小黄人2[0] +1 分

5. 对 minions 数组中每个数字的点求和。比较 sums 和 console.log 是更好的模仿者

---

现在，我被困在第 3 步。将感谢我的代码或逻辑上的任何 cmets，谢谢 :)

这是我目前得到的：

var Master = [3, 2, 2, 4, 15, 8];
var minions = [
  {
    id : "minion1",
    mimic_result : [2, 1, 0, 3, 11, 5],
    abs_values : [],
    points : []
  },
  {
    id : "minion2",
    mimic_result : [1, 3, 2, 1, 12, 7],
    abs_values : [],
    points : []
  },
  {
    id : "minion3",
    mimic_result : [6, 0, 0, 0, 0, 1],
    abs_values : [],
    points : []
  }
];

for(i=0;i<Master.length;i++){
  for(j=0;j<minions.length;j++) {
  var result = Math.abs(Master[i]-minions[j].mimic_result[i]);
  minions[j].abs_values.push(result);
    }
}

for(k=0;k<minions.length;k++) {
  console.log(minions[k].result[0]);
  
}

console.log(minions[0].abs_values);
console.log(minions[1].abs_values);
console.log(minions[2].abs_values);

Answer 1

使用Lo-Dash：

var minionPoints = minions.map(function (minion, i) {
    return {
        minionIndex: i,
        points: 0
    };
});
master.forEach(function (masterValue, masterIndex) {
    var distances = [],
        buckets = [],
        points = 0;
    // calculate distances from master on one individual property
    minions.forEach(function (minion, minionIndex) {
        distances.push({
            minionIndex: minionIndex,
            distance: Math.abs(masterValue - minion.imitation[masterIndex])
        });
    });
    // divide into buckets containing items with same distance
    // (ordered from largest distance to smallest)
    _.sortBy(distances, 'distance').forEach(function (o) {
        if (buckets[0] && (o.distance === buckets[0][0].distance)) {
            buckets[0].push(o);
        } else {
            buckets.unshift([o]);
        }
    });
    // calculate point gain for each item in the bucket
    // (if there are 2 items in the last and second-last place, they should each get 1.5 points)
    buckets.forEach(function (bucket) {
        var totalGain = points + bucket.length + ((bucket.length * (bucket.length + 1)) / 2)
            individualGain = totalGain / bucket.length;
        bucket.forEach(function (o) {
            minionPoints[o.minionIndex].points += individualGain;
        });
        points += totalGain;
    });
});
_.sortBy(minionPoints, 'points').reverse().forEach(function (o, i) {
    console.log((i + 1) + '. ' + minions[o.minionIndex].id + ' (' + o.points +
            ' points, imitation [' + minions[o.minionIndex].imitation.join(', ') +
            '])');
});

它会按照您的建议计算距离和点。此外，当多个随从的距离相同时，它们的总点数增益在它们之间平均分配。 Working demo.

（出于懒惰，我自动包含了 Lo-Dash。我最终只将它用于排序，这可以像使用原生 Array.prototype.sort 一样轻松完成。）

Answer 2

您可以将数组视为 n 维空间中的点并计算它们之间的Euclidean distance：

function dist(a, b) {
    return Math.sqrt(a.reduce(function(sum, _, i) { return sum + Math.pow(a[i] - b[i], 2) }, 0));
}

然后

minions.sort(function(a, b) {
    return dist(master, a.imitation) - dist(master, b.imitation);
});

Answer 3

首先，在 : 中引发了一个异常 ts：

for(k=0;k<minions.length;k++) {
  console.log(minions[k].result[0]);
}

应该是：

for(k=0;k<minions.length;k++) {
  console.log(minions[k].mimic_result[0]);
}

或者据我了解，您想检查您必须执行的 abs_values 值：

for(k=0;k<minions.length;k++) {
  console.log(" the minions["+k+"] abs_values are:\n"); 
  for(l=0;l<minions.abs_values.length;l++) {
    console.log(minions[k].abs_values[l]);
  }
}