c# - 有没有办法对多个值进行排序，并只保留每个值中最大的一个？

Question

我有一些代码可以生成位置类型和最大数量的输出。

我只想保留这些值的每个组合中的最大值。但我不确定允许 n 个位置的最佳方法。

数据当前生成并存储为字符串列表，存储位置之间有空格。

var locationOutputDistinct = new List<string>
{
"PERSON:2 ",
"PERSON:1 SCOOTER:1 ",
"PERSON:1 BIKE:1 ",
"PERSON:2 BIKE:1 ",
"PERSON:1 BIKE:1 SCOOTER:1 ",
"PERSON:3 ",
"PERSON:3 BIKE:1 ",
"PERSON:4 ",
"PERSON:4 BIKE:1 ",
"PERSON:2 SCOOTER:1 ",
"PERSON:5 ",
"PERSON:3 SCOOTER:1 ",
"PERSON:6 "
};

理想的输出应该是这样的:

PERSON:1 BIKE:1 SCOOTER:1 
PERSON:4 BIKE:1 
PERSON:3 SCOOTER:1 
PERSON:6 

表示您可以有 6 个人，或者 3 个人和一辆踏板车，或者 4 个人和一辆自行车，或者 1 个人、1 辆自行车和 1 辆踏板车。每个都是各自类型的最大组合。

最好的方法是什么？

下面是一些其他的数据集和预期的结果。 https://justpaste.it/6cce5

这是一个可视化示例，并解释了我要生成的内容。 https://justpaste.it/4vqu2

Answer 1

基于 2 个类

public class Res{
    public string Key;
    public int Val;
}
public class Reduced
{
    public string Key;
    public IEnumerable<Res>[] invalid;
}

您可以使用此代码来聚合结果。

    var loc =
   locationOutputDistinct
   .Select(x => x.Trim().Split(' ').ToArray()
   .Select(
       y => {
           var kv = y.Split(':');
           return new Res()
           {
               Key = kv[0],
               Val = int.Parse
                (kv[1])
           };
       }).ToArray()).ToArray()

    .GroupBy(x =>
       String.Join(",",
       x.Select(y => y.Key))
       );

然后你必须应用你的减少规则

    var reduced = 
    loc.Select(x => new Reduced() {
    Key = x.Key,                 
            invalid =
                x.Where(y => loc.Any(ext => ext.Any(xsup =>
                   y.All(z => xsup.Any(xsupcell => xsupcell.Key == z.Key)) &&
                   y.All(z =>
                   z.Val <= xsup
                         .Where(xsupcell =>
                   xsupcell.Key == z.Key)
                         .First().Val) &&
                         ((xsup.Length > y.Length) ||
                   y.Any(z =>
                   z.Val < xsup
                         .Where(xsupcell =>
                   xsupcell.Key == z.Key)
                         .First().Val))

                    ))).ToArray()
                            });

    var remain = loc.Select(x => x.Where(y =>
    !reduced.Where(r => r.Key == x.Key).SelectMany(r2 => r2.invalid).Any(r3 => r3.All(r4 =>
    y.Any(y2 => y2.Key == r4.Key && y2.Val == r4.Val)))));

从你的最后一个例子，我看到你想要减少扩展的组合 y 和更多的扩展组合 (xsup.Length > y.L​​ength)，所以我在上面的代码中包含了最后一个功能。

此时您需要解包并打印结果。

    foreach (var x in remain)
        Console.WriteLine
        (//x.Key+": " +
          String.Join("\n",
          x.Select(y =>
          String.Join(" ",
          y.Select(z => z.Key + ":" + z.Val)
              ))));

从你问题中的原始序列你会得到

PERSON:6
PERSON:3 SCOOTER:1
PERSON:4 BIKE:1
PERSON:1 BIKE:1 SCOOTER:1

从

"AM:4 SC:1 ",
"AM:4 WC:1 ",
"AM:4 WC:1 SC:1 ",
"AM:4 WC:2 ",
"AM:4 WC:2 SC:1 ",
"AM:5 ",
"AM:5 WC:1 ",
"AM:6 ",
"AM:6 WC:1 ",
"AM:7 ",
"AM:8 "

你会得到

AM:6 WC:1
AM:4 WC:2 SC:1
AM:8

fiddle here .