创建一个根据竞争对手字段的出现情况确定优先级的堆

Question

这是我用来测试的一个模型变量：

[
    { competitor: 1 },
    { competitor: 1 },
    { competitor: 1 },
    { competitor: 1 },
    { competitor: 2 },
    { competitor: 3 },
    { competitor: 4 },
    { competitor: 4 },
    { competitor: 4 },
    { competitor: 5 },
    { competitor: 6 },
    { competitor: 6 },
    { competitor: 7 },
    { competitor: 7 },
    { competitor: 7 },
    { competitor: 8 },
    { competitor: 9 },
    { competitor: 10 },
    { competitor: 11 },
    { competitor: 12 },
  ]

这是对重复项进行分组的代码：

const splitRepeated = (array) => {
  let obj = array.reduce((res, curr) => {
    if (res[curr.competitor]) res[curr.competitor].push(curr);
    else Object.assign(res, { [curr.competitor]: [curr] });

    return res;
  }, {});
  return obj;
};

这就是结果：

{
  '1': [
    { competitor: 1 },
    { competitor: 1 },
    { competitor: 1 },
    { competitor: 1 }
  ],
  '2': [ { competitor: 2 } ],
  '3': [ { competitor: 3 } ],
  '4': [ { competitor: 4 }, { competitor: 4 }, { competitor: 4 } ],
  '5': [ { competitor: 5 } ],
  '6': [ { competitor: 6 }, { competitor: 6 } ],
  '7': [ { competitor: 7 }, { competitor: 7 }, { competitor: 7 } ],
  '8': [ { competitor: 8 } ],
  '9': [ { competitor: 9 } ],
  '10': [ { competitor: 10 } ],
  '11': [ { competitor: 11 } ],
  '12': [ { competitor: 12 } ]
}

现在我需要均匀地分配这个数组中重复的元素；

均匀示例：

[{ competitor: 1 },{ competitor: 2 },{ competitor: 3 },{ competitor: 1 },{ competitor: 4 },{ competitor: 5 },{ competitor: 1 }]

这是我最大的努力：

const spreadOrder3 = (array) => {
  let obj = splitRepeated(array);
  let objEntities = Object.entries(obj);
  console.log(obj);
  let newArray = objEntities.map((x) => x[1][0]).flat();
  let oldIndex = newArray.length;
  for (let e = 0; e < oldIndex; e++) {
    let each = Math.floor(oldIndex / objEntities[e][1].length);

    let counter = 0;
    for (let i = 0; i < objEntities[e][1].length; i++) {
      console.log(objEntities[e][1][i]);
      console.log((counter + 1) * each);
      newArray.splice((counter + 1) * each, 0, objEntities[e][1][i]);
      // newArray[(counter + 1) * each] = objEntities[e][1][i];
      counter++;
    }
  }
  return newArray;
};

结果不好，我需要帮助，我永远不能把重复的元素组合在一起谢谢

预期结果：

数组长度唯一元素: 12

竞争对手:1 //有4个重复然后: 12/4 = 3，然后每3个元素插入竞争对手1

竞争对手:4 //有3重复然后: 12/3 = 4，然后每4个元素插入竞争对手4

竞争对手:6 //重复2然后: 12/2 = 6，然后每6个元素插入竞争对手6

竞争对手:7 //有3个重复然后: 12/3 = 4，然后每4个元素插入竞争对手7

结果需要如下所示：

[{ competitor: 1 },{ competitor: 2},{ competitor: 3 },{ competitor: 1 }, { competitor: 4 },{ competitor: 5 },{ competitor: 1 }]

Answer 1

您可以对这些值进行分组，并按相同值的长度对分组后的值进行排序。

获取结果数组的索引数组，并将同一组的值以相同的距离进行分散

Math.floor((indices.length - 1) / (a.length - 1))

通过使用索引数组将其转换为结果数组。从indices数组中删除已使用的索引，直到不再有要分配的值。

0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  indices at start

1  1  1  1  2  3  4  4  4  5  6  6  7  7  7  8  9 10 11 12  values
1                 1                 1                 1     d = 6
   4                       4                       4
      7                       7                          7
         6                                      6
            2  3     5  8        9    10 11 12              solitary values

​

const
    data = [1, 1, 1, 1, 2, 3, 4, 4, 4, 5, 6, 6, 7, 7, 7, 8, 9, 10, 11, 12],
    indices = [...data.keys()],
    groups = data.reduce((r, v) => ((r[v] ??= []).push(v), r), {}),
    result = Object
        .values(groups)
        .sort((a, b) => b.length - a.length)
        .reduce((r, a) => {
            const d = a.length === 1 ? 1 : Math.floor((indices.length - 1) / (a.length - 1));
            a.forEach((v, i) => r[indices.splice(i * d - i, 1)[0]] = v);
            return r;
        }, []);

console.log(...result);

​