如何将 1 个数组中的 2 个数据组合成不同的值？

Question

目前，我有一个函数，可以在 1 个数组中加入 2 个具有相同权重的数据。我的目标是如何以不同的价值加入他们？我有一个等于 15 的默认值作为差异。 附加：我需要限制。数组中应该只有小于或大于 15 个重量差异。如果超过，那么它不应该在同一个数组中。

例如：

entryID:1 weight:1900 和 entryID:2 1915 将在数组 1 中... entryID:3 weight:1915 和 entryID:4 1920 将在数组 2 中。

//当前sn-p如果权重相同，则将2个数据加入1个数组中。我的目标是将 2 个数据也加入 1 个数组中，但权重不同。

const source = [{
    entryID: 1,
    entryName: 'player1',
    weight: 1900,
    
  },
  {
    entryID: 2,
    entryName: 'player2',
    weight: 1915,
   
  },
  {
    entryID: 3,
    entryName: 'player3',
    weight: 1915,
  
  },
  {
    entryID: 4,
    entryName: 'player4',
    weight: 1920,
  
  },
  {
    entryID: 5,
    entryName: 'player5',
    weight: 1950,
    
  },
  {
    entryID: 6,
    entryName: 'player6',
    weight: 1965,
   
  },




  ]


  const combine = (source) => {
    return source.reduce((acc, curr) => {
      if (acc[curr.weight]) {
        const levelArr = acc[curr.weight];
        const last = levelArr[levelArr.length - 1];
        if (last.length === 2) {
          levelArr.push([curr])
        } else {
          last.push(curr)
        }
      } else {
        acc[curr.weight] = [
          [curr]
        ];
      }
      return acc;
    }, {})
  };


  var result = combine(source)
  var html = ""
  var keys = Object.keys(result) //if there are more than one keys i.e : 2..

  for (var i = 0; i < keys.length; i++) {
  result[keys[i]].forEach(function(val) {

    val.forEach(function(value, index) {

     
        var entryIDs = index == 0 ? "entryIDM[]" : "entryIDW[]"
        var handlers = index == 0 ? "handlerM[]" : "handlerW[]"
        var weights = index == 0 ? "weightM[]" : "weightW[]"
        html += `<input type="text" name="${entryIDs}" value="${value.entryID}"> 
                 <input type="text" name="${handlers}" value="${value.entryName}">
                 <input type="text" name="${weights}" value="${value.weight}">
                 `
    })
    })
    
    
  }
  document.getElementById("result").innerHTML = html 

console.log(result);

<div id="result">
</div>

我的预期输出：

{
  1900_1915: [[{
  entryID: 1,
  entryName: "player1",
  weight: 1900
}, {
  entryID: 2,
  entryName: "player2",
  weight: 1915
{
  1915_1920: [[{
  entryID: 3,
  entryName: "player3",
  weight: 1915
}, {
  entryID: 4,
  entryName: "player4",
  weight: 1920
}

Answer 1

这是一种方法。您可以调整用于合并数据的difference 值。

const source = [
  { entryID: 1,entryName: 'player1', weight: 1900 },
  { entryID: 2, entryName: 'player2', weight: 1915 },
  { entryID: 3, entryName: 'player3', weight: 1915 },
  { entryID: 4, entryName: 'player4', weight: 1920 },
  { entryID: 5, entryName: 'player5', weight: 1950 },
  { entryID: 6, entryName: 'player6', weight: 1965 },
]

function newCombine(data, difference) {
  let nonMatched = [...data]
  const groups = {}

  for (let i = 0; i < nonMatched.length - 1; i++) {
    const first = nonMatched[i]

    inner: for (let j = nonMatched.length - 1; j > i; j--) {
      const second = nonMatched[j]
      const delta = Math.abs(first.weight - second.weight)

      if (delta <= difference) {
        const groupKey = `${first.weight}_${second.weight}`
        groups[groupKey] = [first, second]
        nonMatched = nonMatched.filter(
          obj => obj.entryID != first.entryID && obj.entryID != second.entryID
        )
        i = -1
        break inner
      }
    }
  }
  return { ...groups, ...nonMatched }
}

const a = newCombine(source, 15)
console.log(a)

编辑：

在上面的 sn-p 中，权重值被用于为分组数据设置一个键。如果有多个具有相同权重值的玩家，这将导致问题。以下输入：

const source = [
  { entryID: 1, entryName: 'player1', weight: 1900 },
  { entryID: 2, entryName: 'player2', weight: 1915 },
  { entryID: 3, entryName: 'player3', weight: 1915 },
  { entryID: 4, entryName: 'player4', weight: 1915 },
  { entryID: 5, entryName: 'player5', weight: 1915 },
]

将输出：

{
  '0': { entryID: 1, entryName: 'player1', weight: 1900 },
  '1915_1915': [
    { entryID: 3, entryName: 'player3', weight: 1915 },
    { entryID: 4, entryName: 'player4', weight: 1915 }
  ]
}

这导致一些条目被删除。所以最好为键使用更唯一的值，例如entryID：

const groupKey = `${first.entryID}_${second.entryID}`

编辑 2：

如果不匹配具有相同entryName的玩家，则条件可以更改为：

if (delta <= difference && first.entryName !== second.entryName) { 
...
}

const source = [
  { entryID: 1, entryName: 'player1', weight: 1915 },
  { entryID: 3, entryName: 'player2', weight: 1910 },
  { entryID: 2, entryName: 'player1', weight: 1920 },
  { entryID: 5, entryName: 'player1', weight: 1910 },
  { entryID: 4, entryName: 'player2', weight: 1920 },
  { entryID: 6, entryName: 'player1', weight: 1915 },
]

function newCombine(data, difference) {
  let nonMatched = [...data]
  const groups = {}

  for (let i = 0; i < nonMatched.length - 1; i++) {
    const first = nonMatched[i]

    inner: for (let j = nonMatched.length - 1; j > i; j--) {
      const second = nonMatched[j]
      const delta = Math.abs(first.weight - second.weight)

      if (delta <= difference && first.entryName !== second.entryName) {
        const groupKey = `${first.weight}_${second.weight}`
        groups[groupKey] = [first, second]
        nonMatched = nonMatched.filter(
          obj => obj.entryID != first.entryID && obj.entryID != second.entryID
        )
        i = -1
        break inner
      }
    }
  }
  return { ...groups, ...nonMatched }
}


const a = newCombine(source, 15)
console.log(a)

Answer 2

如果我正确理解您的问题，您希望按重量对它们进行分组。然后你可以在检查列表是否具有相同的权重时使用相同的逻辑。

您不需要检查它们是否具有相同的权重，因为字典会将它们的权重作为键。

const combine = (source) => {
    return source.reduce((acc, curr) => {
      const wList = acc[curr.weight] || [];
      wList.push(curr);
      acc[curr.weight] = wList;

      return acc;
    }, {})
  };

如果您需要输入验证：

const combine = (source) => {
    return source.reduce((acc, curr) => {
      // If not greater or less than 15, means not 15
      if (curr.weight != 15) {
         return acc;
      }

      // values here are valid
      const wList = acc[curr.weight] || [];
      wList.push(curr);
      acc[curr.weight] = wList;

      return acc;
    }, {})
  };