C# 两队在全场比赛中取得最大领先

我有一个

游戏

，涉及两支球队。

游戏

有一个

记分事件列表

。每一个得分项目对得分的球队来说是1分。我需要知道每个队的最大领先分数是多少（如果他们从未领先，则为0）。

ScoreEvents

列表按

TimesRunStart

排序

public class ScoreEvent
{
    public int TeamId { get; set; }
    public TimeSpan TimeSinceStart { get; set; }
}

public void GetMaxScoreLead()
{
    var ScoreEvents = new List<ScoreEvent>
    {
        new ScoreEvent { TeamId = 0, TimeSinceStart = new TimeSpan(100)},
        new ScoreEvent { TeamId = 0, TimeSinceStart = new TimeSpan(200)},
        new ScoreEvent { TeamId = 0, TimeSinceStart = new TimeSpan(300)},

        //Score at 300 ticks is 3-0 to TeamdId = 0

        new ScoreEvent { TeamId = 1, TimeSinceStart = new TimeSpan(400)},
        new ScoreEvent { TeamId = 1, TimeSinceStart = new TimeSpan(500)},
        new ScoreEvent { TeamId = 1, TimeSinceStart = new TimeSpan(600)},
        new ScoreEvent { TeamId = 1, TimeSinceStart = new TimeSpan(700)},

        //Score at 700 ticks is a 3-4 to TeamId = 1

        new ScoreEvent { TeamId = 0, TimeSinceStart = new TimeSpan(800)},
        new ScoreEvent { TeamId = 0, TimeSinceStart = new TimeSpan(900)},
        new ScoreEvent { TeamId = 0, TimeSinceStart = new TimeSpan(1000)},
        new ScoreEvent { TeamId = 0, TimeSinceStart = new TimeSpan(1100)}

        //Score at 1100 ticks is 7-4 to TeamId 0
    };
}

var leftTeamId=ScoreEvents.First（）.TeamId
var res=记分事件
.OrderBy（x=>x.TimesRunStart）
.合计(
（最大值为0，最小值为0，当前值为0），
（acc、currSE）=>{
var curr=currSE.TeamId==leftTeamId
？附件电流+1
：acc.curr-1；
如果（当前>附件最大值）
{
返回值（当前值、最小值、当前值）；
}
否则，如果（当前<附件最小值）
{
返回值（根据最大值、当前值、当前值）；
}
返回值（acc.max、acc.min、curr）；
});

对于id为

leftTeamId

的“左”团队，您使用

res.max

对于“右”团队，您使用

Math.Abs（res.min）

：

团队ID（0）=

res.max

最大领先优势

TeamId（1）=

Math.Abs（res.min）

最大领先优势

---

我没有得到rightTeamId，因为理论上只有一个团队可以得分（但假设至少有一个得分=）。

因为只有两个团队可以看到这种方法是否满足您的需要

        int team1Score = 0;
        int team2Score = 0;
        int maximumLead = 0;
        int maximumLeadTeamId = -1;
        for (int i = 0; i < ScoreEvents.Count; i++)
        {
            if (ScoreEvents[i].TeamId == 0)
            {
                team1Score++;
            }
            else
            {
                team2Score++;
            }
            int currentLead = Math.Abs(team1Score - team2Score);
            if (currentLead > maximumLead)
            {
                maximumLead = currentLead;
                maximumLeadTeamId = ScoreEvents[i].TeamId;
            }
        }

int team1Score=0；
int team2Score=0；
int-maximumLead=0；
int maximumLeadTeamId=-1；
for（int i=0；i最大领先）
{
最大引线=电流引线；
maximumLeadTeamId=ScoreEvents[i].TeamId；
}
}

---

maximumLeadTeamId是在整个比赛中领先优势最大的球队的Id，maximumLead是两支球队之间的最大进球差距。

您可以使用它来获取球队Id字典，以便在指定的时间跨度内得分：

public static Dictionary<int, int> GetMaxScoreLead(IEnumerable<ScoreEvent> scoreEvents, TimeSpan time)
{
    var scoreDictionary = new Dictionary<int, int>();
    var grouping = scoreEvents.Where(e => e.TimeSinceStart <= time).GroupBy(e => e.TeamId);

    foreach (var group in grouping)
    {
        scoreDictionary.Add(group.Key, group.Count());
    }

    return scoreDictionary;
}

---

我使用

foreach

循环稍微更新和简化了您的算法，现在它返回正确的结果-

teamZeroLead

是

3

，

teamOneLead

是

1

var teamZeroLead=0；
var teamOneLead=0；
var teamZeroScore=0；
var teamOneScore=0；
foreach（scoreEvents.OrderBy（x=>x.timesRunStart）中的var scoreEvent）
{
如果（scoreEvent.TeamId==0）
{
teamZeroScore++；
teamZeroLead=Math.Max（teamZeroLead，teamZeroScore-teamOneScore）；
}
其他的
{
teamOneScore++；
teamOneLead=Math.Max（teamOneLead，teamOneScore-teamZeroScore）；
}
}

在每次循环迭代中，您计算每个团队的当前得分，然后计算领先值并将其分配给结果值（如果领先值大于先前计算的值）

同样的逻辑可以使用

Aggregate

方法和值元组编写，您可以选择更可读、更方便的方法

var result=scoreEvents.Aggregate（（teamZeroLead:0，teamOneLead:0，teamZeroScore:0，teamOneScore:0），
（分数、分数事件）=>
{
如果（scoreEvent.TeamId==0）
{
分数。teamZeroScore++；
scores.teamZeroLead=Math.Max（scores.teamZeroLead，scores.teamZeroScore-scores.teamOneScore）；
}
其他的
{
分数。teamOneScore++；
scores.teamOneLead=Math.Max（scores.teamOneLead，scores.teamOneScore-scores.teamZeroScore）；
}
返回分数；
});

---

执行后，您可以使用

result.teamZeroLead

和

result.teamOneLead

获取结果值。请共享代码，您试图解决什么问题？2秒，现在添加它。滴答声是否总是有100个间隔？为什么时间跨度与您的问题相关？为什么不简单地数一数哪个队得分呢？基本上是按teamId分组，并获取每组的长度。teamId（0）=应为3？将其标记为答案，因为对于得分为自己目标的团队，很容易修改，即减去1的分数。还需要检查每个团队的第一个项目，以确保他们的第一个项目不是自己的目标，这将使他们的开始得分为-1而不是0

        int team1Score = 0;
        int team2Score = 0;
        int maximumLead = 0;
        int maximumLeadTeamId = -1;
        for (int i = 0; i < ScoreEvents.Count; i++)
        {
            if (ScoreEvents[i].TeamId == 0)
            {
                team1Score++;
            }
            else
            {
                team2Score++;
            }
            int currentLead = Math.Abs(team1Score - team2Score);
            if (currentLead > maximumLead)
            {
                maximumLead = currentLead;
                maximumLeadTeamId = ScoreEvents[i].TeamId;
            }
        }

public static Dictionary<int, int> GetMaxScoreLead(IEnumerable<ScoreEvent> scoreEvents, TimeSpan time)
{
    var scoreDictionary = new Dictionary<int, int>();
    var grouping = scoreEvents.Where(e => e.TimeSinceStart <= time).GroupBy(e => e.TeamId);

    foreach (var group in grouping)
    {
        scoreDictionary.Add(group.Key, group.Count());
    }

    return scoreDictionary;
}

var winningTeam = getScores.OrderByDescending(x => x.Value).FirstOrDefault();