添加将2个数据连接到1个数组中的另一个条件

Question

我正在创建一个匹配函数，其中两个具有相同权重的玩家将配对。

它目前基于相同的重量工作。现在，我添加了另一个条件，玩家有自己的水平。我的第一个条件是基于相同的体重。这是有效的。我的第二个条件是水平。因此，如果玩家的等级相同，它会优先考虑等级。

我的问题是，在确定级别的优先级后，有没有办法让我也能匹配不在同一级别的球员？

我当前的函数只在同一个级别上工作，但如果它不在同一级别上，它将不再成对。

const source = [
{
entryID: 1,
entryName: "player1",
weight: 1900,
noFight: [], // changed these to arrays
level: 1,
},
{
entryID: 2,
entryName: "player2",
weight: 1900,
noFight: [],
level: 2,
},
{
entryID: 3,
entryName: "player3",
weight: 1900,
noFight: [],
level: 1,
},
{
entryID: 4,
entryName: "player4",
weight: 1900,
noFight: [],
level: 2,
},
{ 
entryID: 5,
entryName: "player5",
weight: 1900,
noFight: [],
level: 4,
},
{ 
entryID: 6,
entryName: "player6",
weight: 1900,
noFight: [],
level: 5,
},
];
console.log ( combine(source) )
function combine( data = [], different = 0, maxGroupSize = 2 ) 
{
const 
groups        = []
, related       = []
, sortedData    = [...data].sort((a, b) => a.weight - b.weight)
, alreadyInRela = (setX,eName) =>
{
let list = [...setX, eName] 
return related.some(rela=>list.every(l=>rela.has(l)))
};
sortedData.forEach((el,indx)=>
{
let place = groups.findIndex( // find a place in a group forEach element, use indx as track
g => g.names.size < maxGroupSize              // is the group incomplete ?
&& !g.names.has(el.entryName)             // is entryName not in the group list (names Set) ?
&& (el.weight - g.weight) <= different 
&& el.level == g.level  // this is what i added for level.
&& !alreadyInRela(g.names, el.entryName ) // is (entryName + group list) does not already used ?
&& !el.noFight.some(noFightEl => g.indxs.map(gi => sortedData[gi].entryID).includes(noFightEl))  // is el.noFight having any of group item
)
if (place < 0) // not found -> create new group
{
let names = new Set().add(el.entryName)                      // create new group
groups.push( { names, indxs: [indx], weight: el.weight, level: el.level } )  // group constitutive info 
related.push( names )                                      // keep track of group list
}
else // find a place in a group
{
groups[place].names.add(el.entryName)  // related list is also updated
groups[place].indxs.push(indx)        // add indx to retreive element in sortedData 
}
})
return groups.reduce((r,g,i)=> // build result
{
if (g.indxs.length > 1) {
let key = `${i}_` + g.indxs.map(x=>sortedData[x].weight).join('_')
r[key] = []
g.indxs.forEach(x=> r[key].push( sortedData[x]) )
}
return r
}, {} )
}

当前输出(正如我们在这里看到的，玩家5和6没有配对，因为他们没有相同的等级(：

{
0_1900_1900: [{
entryID: 1,
entryName: "player1",
level: 1,
noFight: [],
weight: 1900
}, {
entryID: 3,
entryName: "player3",
level: 1,
noFight: [],
weight: 1900
}],
1_1900_1900: [{
entryID: 2,
entryName: "player2",
level: 2,
noFight: [],
weight: 1900
}, {
entryID: 4,
entryName: "player4",
level: 2,
noFight: [],
weight: 1900
}]
}

目标输出(正如我们所看到的，玩家5和6配对，这是我的目标，它首先优先考虑有等级的玩家，如果没有更多相同的等级可配对，它将与具有相同重量或接近等级的玩家配对(：

{
0_1900_1900: [{
entryID: 1,
entryName: "player1",
level: 1,
noFight: [],
weight: 1900
}, {
entryID: 3,
entryName: "player3",
level: 1,
noFight: [],
weight: 1900
}],
1_1900_1900: [{
entryID: 2,
entryName: "player2",
level: 2,
noFight: [],
weight: 1900
}, {
entryID: 4,
entryName: "player4",
level: 2,
noFight: [],
weight: 1900
}],
2_1900_1900: [{
entryID: 5,
entryName: "player5",
level: 4,
noFight: [],
weight: 1900
}, {
entryID: 6,
entryName: "player6",
level: 5,
noFight: [],
weight: 1900
}

Answer 1

这种两步耦合应该会给您带来所需的结果：

const source = [
{
entryID: 1,
entryName: "player1",
weight: 1900,
noFight: [], // changed these to arrays
level: 1,
},
{
entryID: 2,
entryName: "player2",
weight: 1900,
noFight: [],
level: 2,
},
{
entryID: 3,
entryName: "player3",
weight: 1900,
noFight: [],
level: 1,
},
{
entryID: 4,
entryName: "player4",
weight: 1900,
noFight: [],
level: 2,
},
{ 
entryID: 5,
entryName: "player5",
weight: 1900,
noFight: [],
level: 4,
},
{ 
entryID: 6,
entryName: "player6",
weight: 1900,
noFight: [],
level: 5,
},
{ 
entryID: 7,
entryName: "player7",
weight: 1900,
noFight: [],
level: 8,
}
];
function couples(da,a=[],ignlvl=false){
da.forEach((one,i,ar)=>
ar.slice(i+1).some(two=>{
if(!two.paired && !one.paired &&(ignlvl||one.level==two.level) && one.weight==two.weight) {
one.paired=two.paired=1;
a.push([one,two]);
}})
)
return a;
}
const res=couples(source,couples(source),1);
source.forEach(e=>delete e.paired); // clear the paired flag ...
console.log(res);

我在样本数据中添加了第七个权重相似的玩家，以证明多余的条目实际上会被留下，不耦合。