Question

所以这是我试图解决的任务。

我们有一个主数组和几个类似的minions数组：

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],
  }
];

让我们假设小兵试图模仿大师。我们需要通过给他们一点来了解谁做得更好。

限制： - 可以有任意数量的奴才 - 我们只比较数值 - 数组中的数字总是保持不变

所以我提出了这个逻辑：

从主要数据中的相应数字中减去minions数组中的每个数字，并获得其绝对值。因为如果Master有第一个数字3，Minion1有第2个，Minion3有第4个.Minion1和Minion3同样远离主人。
将绝对值推送到每个minion的数组。
比较数组中的绝对值，并为数组中的每个数字排序minions。也许像master [0]：
- Minion1 [0]
- Minion3 [0]
- Minion2 [0]
根据阵列中每个数字的位置为每个数字指定minions，相互比较。主[0]：
- Minion1 [0] +3分
- Minion3 [0] +2分
- Minion2 [0] +1分
汇总minions数组中每个数字的点数。比较sums和console.log是更好的模仿者

现在，我已经坚持第3步了。对于我的代码或逻辑的任何评论都会感激不尽，谢谢：）

这是我到目前为止所得到的：

＆＃13;

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

＆＃13;

Answer 1

您可以将数组视为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 2

使用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 3

首先，提出了一个例外：

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

通过在多个条件中对它们进行排

3 个答案: