C# Linq Union/UnionAll/Concat

我正在尝试将一个简单的数学转换成Linq

我想把几个数的素因子组合成一个集合。 考虑下面的整数。< /P>

8 = 2 * 2 * 2
12 = 2 * 2 * 3

可被8和12整除的最小数字是24，所以我希望结果组包含

{ 2, 2, 2, 3 }

如果我使用

Concat

结果是{2,2,2,2,2,3}-不正确 如果我使用

Union

则结果为{2,3}-不正确

---

是否有一个内置的Linq集合操作功能，它可以识别出它需要保持一个项目的最大出现次数（即，如果已经有足够的项目来满足if&如果没有，则不添加另一个项目）

嗯，它不是任何现有的功能，因为我认为不存在这样的功能，但是非常简单的代码能够处理这个问题：

        var listA = new List<int> {2, 2, 2};
        var listB = new List<int> {2, 2, 3};

        var grouppedA = listA.GroupBy(i => i).Select(g => new { key = g.Key, count = g.Count()});
        var grouppedB = listB.GroupBy(i => i).Select(g => new { key = g.Key, count = g.Count()});
        var result = grouppedA
            .Union(grouppedB)
            .GroupBy(g => g.key)
            .SelectMany(g => Enumerable.Repeat(g.Key, g.Max(h => h.count)));

        foreach (int i in result)
        {
            Console.Write(i + " ");
        }
        Console.ReadKey();

var listA=新列表{2,2,2}；
var listB=新列表{2,2,3}；
var grouppedA=listA.GroupBy（i=>i）.Select（g=>new{key=g.key，count=g.count（）}）；
var grouppedB=listB.GroupBy（i=>i）.Select（g=>new{key=g.key，count=g.count（）}）；
var结果=grouppedA
.工会（B组）
.GroupBy（g=>g.key）
.SelectMany（g=>Enumerable.Repeat（g.Key，g.Max（h=>h.count））；
foreach（结果中的int i）
{
控制台。写入（i+“”）；
}
Console.ReadKey（）；

输出：

---

2 2 3

好吧，它不是任何现有的函数，因为我认为不存在这样的函数，但是非常简单的代码能够处理这个问题：

        var listA = new List<int> {2, 2, 2};
        var listB = new List<int> {2, 2, 3};

        var grouppedA = listA.GroupBy(i => i).Select(g => new { key = g.Key, count = g.Count()});
        var grouppedB = listB.GroupBy(i => i).Select(g => new { key = g.Key, count = g.Count()});
        var result = grouppedA
            .Union(grouppedB)
            .GroupBy(g => g.key)
            .SelectMany(g => Enumerable.Repeat(g.Key, g.Max(h => h.count)));

        foreach (int i in result)
        {
            Console.Write(i + " ");
        }
        Console.ReadKey();

var listA=新列表{2,2,2}；
var listB=新列表{2,2,3}；
var grouppedA=listA.GroupBy（i=>i）.Select（g=>new{key=g.key，count=g.count（）}）；
var grouppedB=listB.GroupBy（i=>i）.Select（g=>new{key=g.key，count=g.count（）}）；
var结果=grouppedA
.工会（B组）
.GroupBy（g=>g.key）
.SelectMany（g=>Enumerable.Repeat（g.Key，g.Max（h=>h.count））；
foreach（结果中的int i）
{
控制台。写入（i+“”）；
}
Console.ReadKey（）；

输出： 2 3使用系统； 使用System.Collections.Generic； 公共类样本{ 公共静态void Main（字符串[]args）{ var n8=因子（8）； var n12=因子（12）； var uf=联合因子（n8，n12）；//LCM 打印因子（uf）； } 公共静态无效打印因子（字典因子）{ 控制台。写（“{”）； foreach（factors.Keys中的var因子）{ 对于（int i=0；i uf[kv.Key]）//max uf[kv.键]=kv.值； }否则{ uf.添加（千伏键，千伏值）； } } 返回uf； } 公共静态字典toFactors（long num）{ var factors=新字典（）； 长n=num，i=2，sqi=4； 而（sqi

使用系统；
使用System.Collections.Generic；
公共类样本{
公共静态void Main（字符串[]args）{
var n8=因子（8）；
var n12=因子（12）；
var uf=联合因子（n8，n12）；//LCM
打印因子（uf）；
}
公共静态无效打印因子（字典因子）{
控制台。写（“{”）；
foreach（factors.Keys中的var因子）{
对于（int i=0；i uf[kv.Key]）//max
uf[kv.键]=kv.值；
}否则{
uf.添加（千伏键，千伏值）；
}
}
返回uf；
}
公共静态字典toFactors（long num）{
var factors=新字典（）；
长n=num，i=2，sqi=4；
虽然（sqi是的，这与我提出的非常相似，但仍然非常详细。为帮助干杯。如果没有其他人回复，将给你+10。是的，很不幸。它应该在一些帮助方法中关闭以便于阅读。我不认为有任何更高级别的linq解决方案，因为你的问题不是很常见。代码可能会可能会写得更好，可读性更强。是的，这与我的想法非常相似，但仍然非常冗长。为帮助干杯。如果没有其他人回复，将给你+10。是的，不幸的是，它是。它应该在一些帮助器方法中关闭以便于阅读。我认为没有任何更高级别的linq解决方案，因为你的这个问题并不常见。代码可能写得更好，可读性更好，但我认为作为LINQ是多余的。我认为作为LINQ是多余的。