在整个比赛中获得两支球队最大的领先优势

Question

我有一个包含两个团队的Game。Game有一个ScoreEvents列表。每个ScoreEvent对得分的球队来说是1分。我需要知道每支球队的最高领先得分是多少(如果他们从来没有领先)。ScoreEvents列表由TimeSinceStart排序。

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
    };
}

因此，对于上面的例子，每个团队最大领导的答案应该是：

1. TeamId (0) =3大引线
2. TeamId (1) =1大引线

编辑:我必须要做的代码。我知道我需要在某个地方跟踪目前的比分。

var teamZeroLargestLead = 0;
var teamOneLargestLead = 0;

var internalTeamZeroLargestLead = 0;
var internalTeamOneLargestLead = 0;

foreach (var scoreEvent in scoreEvents.OrderBy(x => x.TimeSinceStart))
{
    if (scoreEvent.TeamId == 0)
    {
        if (internalTeamOneLargestLead > teamOneLargestLead)
        {
             teamOneLargestLead = internalTeamOneLargestLead;
             internalTeamOneLargestLead = 0;
        }

        internalTeamZeroLargestLead += 1;
     }
     else
     {
        if(internalTeamZeroLargestLead > teamZeroLargestLead)
        {
            teamZeroLargestLead = internalTeamZeroLargestLead;
            internalTeamZeroLargestLead = 0;
        }

        internalTeamOneLargestLead += 1;
    }
}

Answer 1

我用foreach循环稍微更新和简化了您的算法，现在它返回正确的结果-- teamZeroLead是3，teamOneLead是1。

var teamZeroLead = 0;
var teamOneLead = 0;
var teamZeroScore = 0;
var teamOneScore = 0;

foreach (var scoreEvent in scoreEvents.OrderBy(x => x.TimeSinceStart))
{
    if (scoreEvent.TeamId == 0)
    {
        teamZeroScore++;
        teamZeroLead = Math.Max(teamZeroLead, teamZeroScore - teamOneScore);
    }
    else
    {
         teamOneScore++;
         teamOneLead = Math.Max(teamOneLead, teamOneScore - teamZeroScore);
    }
}

在每一个循环迭代中，您正在计算每个团队的当前分数，然后计算领先值并将其分配给结果值，如果它大于以前计算的值。

使用Aggregate方法和值元组可以编写相同的逻辑，您可以选择更易读、更方便的逻辑。

var result = scoreEvents.Aggregate((teamZeroLead: 0, teamOneLead: 0, teamZeroScore: 0, teamOneScore: 0),
    (scores, scoreEvent) =>
    {
        if (scoreEvent.TeamId == 0)
        {
            scores.teamZeroScore++;
            scores.teamZeroLead = Math.Max(scores.teamZeroLead, scores.teamZeroScore - scores.teamOneScore);
        }
        else
        {
            scores.teamOneScore++;
            scores.teamOneLead = Math.Max(scores.teamOneLead, scores.teamOneScore - scores.teamZeroScore);
        }

        return scores;
    });

执行后，可以使用result.teamZeroLead和result.teamOneLead获得结果值。

Answer 2

var leftTeamId = ScoreEvents.First().TeamId
var res = ScoreEvents
  .OrderBy(x => x.TimeSinceStart)
  .Aggregate(
    (max: 0, min: 0, curr: 0), 
    (acc, currSE)  => {
        var  curr = currSE.TeamId == leftTeamId
            ? acc.curr +1
            : acc.curr - 1;
        if(curr > acc.max)
        {
            return (curr, acc.min, curr);
        }
        else if (curr < acc.min)
        {
            return (acc.max, curr, curr);
        }
        return (acc.max, acc.min, curr);
    });

对于id leftTeamId的“左”团队，使用res.max表示“右”，使用Math.Abs(res.min)

1. TeamId (0) = res.max最大引线
2. TeamId (1) = Math.Abs(res.min)最大引线

我没有得到rightTeamId，因为理论上只有一支球队可以得分(但假设至少有一支球队得分)。

Answer 3

因为只有两个团队，所以看看这种方法是否能满足您的需求。

        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;
            }
        }

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