Linq - 每组的最高值

Question

如何使用 Linq 从每个组中选择最高值

当我有如下代码段时，

var teams = new Team[]
 { 
  new Team{PlayerName="Ricky",TeamName="Australia", PlayerScore=234},
  new Team{PlayerName="Hussy",TeamName="Australia", PlayerScore=134},
  new Team{PlayerName="Clark",TeamName="Australia", PlayerScore=334},

  new Team{PlayerName="Sankakara",TeamName="SriLanka", PlayerScore=34},
  new Team{PlayerName="Udana",TeamName="SriLanka", PlayerScore=56},
  new Team{PlayerName="Jayasurya",TeamName="SriLanka", PlayerScore=433},

 new Team{PlayerName="Flintop",TeamName="England", PlayerScore=111},
 new Team{PlayerName="Hamirson",TeamName="England", PlayerScore=13},
 new Team{PlayerName="Colingwood",TeamName="England", PlayerScore=421}
 };

：所需结果：

Team Name         Player Name     Score

Srilanka          Jayasurya        433

England           colingwood       421

Australia         Clark            334 

Answer 1

我的答案与 Yuriy 的类似，但使用 MaxBy 来自 MoreLINQ，这不需要比较由 ints 完成：

var query = from player in players
            group player by player.TeamName into team
            select team.MaxBy(p => p.PlayerScore);

foreach (Player player in query)
{
    Console.WriteLine("{0}: {1} ({2})",
        player.TeamName,
        player.PlayerName,
        player.PlayerScore);
}

请注意，我已将类型名称从“团队”更改为“玩家”，因为我认为这更有意义 - 您不是从一组团队开始，而是从一组玩家开始。

Answer 2

以下代码获取所需的值：

foreach (Team team in teams
    .GroupBy(t => t.TeamName)
    .Select(ig => ig.MaxValue(t => t.PlayerScore)))
{
    Console.WriteLine(team.TeamName + " " + 
        team.PlayerName + " " + 
        team.PlayerScore);
}

它需要我今天早些时候编写的以下扩展：

public static T MaxValue<T>(this IEnumerable<T> e, Func<T, int> f)
{
    if (e == null) throw new ArgumentException();
    using(var en = e.GetEnumerator())
    {
        if (!en.MoveNext()) throw new ArgumentException();
        int max = f(en.Current);
        T maxValue = en.Current;
        int possible = int.MaxValue;
        while (en.MoveNext())
        {
            possible = f(en.Current);
            if (max < possible)
            {
                max = possible;
                maxValue = en.Current;
            }
        }
        return maxValue;
    }
}

以下代码在没有扩展的情况下获取答案，但速度稍慢：

foreach (Team team in teams
    .GroupBy(t => t.TeamName)
    .Select(ig => ig.OrderByDescending(t => t.PlayerScore).First()))
{
    Console.WriteLine(team.TeamName + " " + 
        team.PlayerName + " " + 
        team.PlayerScore);
}

Answer 3

这将要求您按团队名称分组，然后选择最高分数。

唯一棘手的部分是找到相应的球员，但这还不错。只需选择得分最高的玩家即可。当然，如果可能有多个玩家具有相同的分数，请使用如下所示的 First() 函数而不是 Single() 函数来执行此操作。

var x =
    from t in teams
    group t by t.TeamName into groupedT
    select new
    {
        TeamName = groupedT.Key,
        MaxScore = groupedT.Max(gt => gt.PlayerScore),
        MaxPlayer = groupedT.First(gt2 => gt2.PlayerScore == 
                    groupedT.Max(gt => gt.PlayerScore)).PlayerName
    };

仅供参考 - 我确实针对您的数据运行了这段代码并且它起作用了（在我修复了那个之后，出现了一些数据错误）。

Answer 4

我会使用这个 Lambda 表达式：

IEnumerable<Team> topsScores = 
teams.GroupBy(x => x.TeamName).Select(t => t.OrderByDescending(c => c.PlayerScore).FirstOrDefault());

Answer 5

The Lame Duck 提出的实现很棒，但需要对分组集进行两次 O(n) 遍历才能找出最大值。计算一次 MaxScore 然后重复使用将会受益匪浅。这就是 SelectMany（C# 中的 let 关键字）派上用场的地方。这是优化后的查询：

var x = from t in teams 
        group t by t.TeamName into groupedT 
        let maxScore = groupedT.Max(gt => gt.PlayerScore)
        select new 
        { 
           TeamName = groupedT.Key,
           MaxScore = maxScore, 
           MaxPlayer = groupedT.First(gt2 => gt2.PlayerScore == maxScore).PlayerName 
        };

Answer 6

我建议您首先在 IEnumerbale 类上实现一个名为 Top 的扩展方法
例如：

IEnumerable<T,T1> Top(this IEnumerable<T> target, Func<T1> keySelector, int topCount)
{
    return target.OrderBy(i => keySelector(i)).Take(topCount);
}

那么你可以这样写：

teams.GroupBy(team => team.TeamName).Top(team => team.PlayerScore, 1)。

可能需要进行一些细微的修改才能编译。