Javascript 计算完成位置1、2、2等

我试图为给定的一组结果有效地生成一个终点位置，在这个结果中，我要考虑重复的分数，然后在一大组联合分数之后增加终点位置。例如，三个排在第五位的终点将下一个位置的终点排在第八位：

我试图为一组有序的点准确地分配正确的结束位置，但是我的代码没有正确地递增

---

您可以检查

结果

是否已包含在

位置

中，如果已包含，请跳过。但老实说，这也可以通过一个非常简单的for循环来实现：

排名=[{
“姓名”：“A队”，
“分数”：10分
},
{
“姓名”：“B队”，
“点数”：9
},
{
“姓名”：“C队”，
“点数”：9
},
{
“姓名”：“D队”，
“点数”：8
},
{
“姓名”：“E队”，
“点数”：7
}, {
“姓名”：“F队”，
“点数”：7
}, {
“姓名”：“G队”，
“点数”：7
}, {
“姓名”：“H队”，
“点数”：4
}
];
设位置=0；
for（standings.ENTRKS（）的常数[索引，等级]）{
常数eqPrev=index>0&&standings[index-1]。点数===standing.points；
const eqNext=索引console.log（'standings:'，JSON.stringify（standings，null，2））

您可以检查

结果是否已包含在
位置中，如果是，则跳过。但老实说，这也可以通过一个非常简单的for循环来实现：


排名=[{
“姓名”：“A队”，
“分数”：10分
},
{
“姓名”：“B队”，
“点数”：9
},
{
“姓名”：“C队”，
“点数”：9
},
{
“姓名”：“D队”，
“点数”：8
},
{
“姓名”：“E队”，
“点数”：7
}, {
“姓名”：“F队”，
“点数”：7
}, {
“姓名”：“G队”，
“点数”：7
}, {
“姓名”：“H队”，
“点数”：4
}
];
设位置=0；
for（standings.ENTRKS（）的常数[索引，等级]）{
常数eqPrev=index>0&&standings[index-1]。点数===standing.points；
const eqNext=索引console.log（'standings:'，JSON.stringify（standings，null，2））
假设您的
站已预先排序（如果未排序，则使用
standings.sort（（a，b）=>b.points-a.points）在调用者中对其排序
，只需将当前索引与上一个索引进行比较，并应用所需的排序逻辑。具体来说，保持一个运行的累加器，如
currentRank
，并且仅在当前元素与上一个元素不匹配时增加它


const toOrdinal=n=>{
常量=[，“st”，“nd”，“rd”[（“”+n）.slice（-1）]；
return！ord | n>10&&n<20？n+“th”：n+ord；
};
常数秩=排名=>{
设currentRank=1；
返回排名。地图（（e，i）=>{
const prev=排名[i-1]；
如果（！i|e.点<上一点）{
currentRank=i+1；
}
e、 秩=toOrdinal（当前秩）；
如果（i&e点===上一点）{
prev.rank=prev.rank.replace（/=*$/，“=”）；
e、 排名+=“=”；
}
返回e；
});
};
常数表=[{
“姓名”：“A队”，
“分数”：10分
},
{
“姓名”：“B队”，
“点数”：9
},
{
“姓名”：“C队”，
“点数”：9
},
{
“姓名”：“D队”，
“点数”：8
},
{
“姓名”：“E队”，
“点数”：7
}, 
{
“姓名”：“F队”，
“点数”：7
}, 
{
“姓名”：“G队”，
“点数”：7
}, 
{
“姓名”：“H队”，
“点数”：4
}
];
console.log（排名（standings））；
假设您的
排名
是预先排序的（如果不是，则在调用者中使用
standings.sort对它们进行排序（（a，b）=>b.points-a.points）
，只需将当前索引与上一个索引进行比较，并应用所需的排序逻辑。具体来说，保持一个运行的累加器，如
currentRank
，并且仅在当前元素与上一个元素不匹配时增加它


const toOrdinal=n=>{
常量=[，“st”，“nd”，“rd”[（“”+n）.slice（-1）]；
return！ord | n>10&&n<20？n+“th”：n+ord；
};
常数秩=排名=>{
设currentRank=1；
返回排名。地图（（e，i）=>{
const prev=排名[i-1]；
如果（！i|e.点<上一点）{
currentRank=i+1；
}
e、 秩=toOrdinal（当前秩）；
如果（i&e点===上一点）{
prev.rank=prev.rank.replace（/=*$/，“=”）；
e、 排名+=“=”；
}
返回e；
});
};
常数表=[{
“姓名”：“A队”，
“分数”：10分
},
{
“姓名”：“B队”，
“点数”：9
},
{
“姓名”：“C队”，
“点数”：9
},
{
“姓名”：“D队”，
“点数”：8
},
{
“姓名”：“E队”，
“点数”：7
}, 
{
“姓名”：“F队”，
“点数”：7
}, 
{
“姓名”：“G队”，
“点数”：7
}, 
{
“姓名”：“H队”，
“点数”：4
}
];
console.log（rank（standings））；
为您的代码添加了一个线性修复程序为您的代码添加了一个线性修复程序，这样我们就可以自动运行，如果您认为错误就可以自由恢复只添加了代码段，这样我们就可以自动运行，如果您认为错误就可以自由恢复
const position = (place, equals) => {
  const joint = equals ? '=' : '';
  if (place.toString().endsWith(1) && !place.toString().endsWith(11)) return `${place}st${joint}`;
  if (place.toString().endsWith(2)) return `${place}nd${joint}`;
  if (place.toString().endsWith(3)) return `${place}rd${joint}`;
  return `${place}th${joint}`
}

const standings = [{
    "name": "Team A",
    "points": 10
  },
  {
    "name": "Team B",
    "points": 9
  },
  {
    "name": "Team C",
    "points": 9
  },
  {
    "name": "Team D",
    "points": 8
  },
  {
    "name": "Team E",
    "points": 7
  }, {
    "name": "Team F",
    "points": 7
  }, {
    "name": "Team G",
    "points": 7
  }, {
    "name": "Team H",
    "points": 4
  }
];

standings.reduce((positions, result, index) => {
  const jointPoints = standings.filter(r => r.points === result.points);
  if (jointPoints.length > 1) {
    // somewhere here I should check if the .position has been set, rather than override it
    // hence the bug in the output.
    return [...positions, ...jointPoints.map(r => {
      r.position = position(index + 1, true);
      return r;
    })]
  } else {
    result.position = position(index + 1, false);
    return [...positions, result];
  }
}, []);