C# 如何在迭代时将列表一分为二，并使用LINQ将结果放入元组中？

如果我有一个可枚举的

Input :[1,2,3,4]
Output :([1,3],[2,4])

在它上面迭代一次，开始在序列/列表/任何东西中放入奇数，在另一个序列中放入偶数，最后将这两个序列放入一个元组

我试过这样的方法：

class Elem
{
int x;
}
(rez1,rez2)=from value in Generator()
            let odds=Enumerable.Empty<Elem>()
            let evens=Enumerable.Empty<Elem>()
            select(value%2==0?odds.**append**(value):odds.**append**(value))

---

0（n）中的所有内容创建如下元组。对奇数和偶数值运行两个查询

Tuple.Create(input.Where(c => c % 2 == 1).ToArray(), input.Where(c => c % 2 == 0).ToArray());

---

如果你想在哈斯凯尔那样做，那就在哈斯凯尔那样做。Haskell不迭代序列，它将元组元素定义为具有特定属性的集合。你也应该这样做：

var values = Generator();
Tuple.Create(
    values.Where(    /* define what you want for the first set */  ),
    values.Where(    /* define what you want for the second set */  ));

---

这里是一种只有2个

列表

和一次迭代的方法

List<int> input = new List<int>() { 1, 2, 3, 4 };
List<List<int>> result = new List<List<int>>() { new List<int>(), new List<int>() };
input.ForEach(x => result[x % 2 == 0 ? 0 : 1].Add(x));

---

非常复杂的事情：

        var list = new[] { 1, 2, 3, 4 };

        var result = list.Select(
                o => new
                {
                    A = o % 2 == 1 ? o : (int?)null,
                    B = o % 2 == 0 ? o : (int?)null
                })
            .GroupBy(o => o.A != null)
            .Select(o => o.Select(t => t.A ?? t.B ?? 0).ToList())
            .ToArray();

        Console.WriteLine(result[0]);
        Console.WriteLine(result[1]);

对于列表输入（不是

list>

），我们可以使用

GroupBy

按谓词函数对其进行分组，并

选择

将

i分组

投影到

列表

：

List<List<int>> buckets = input.GroupBy(func).Select(g => g.ToList()).ToList();

这种方法：

var tuple = Tuple.Create(new List<int>(), new List<int>());
var func = new Func<int, bool>(x => x % 2 == 0);
List<List<int>> buckets = input.Select(e => 
{
   func(e)? tuple.Item1.Add(e) : tuple.Item2.Add(e);
   return e;
}).ToList();

---

是的，我知道我可以用两个查询来完成。但是我想知道我是否可以动态创建元组作为查询的最终结果。是否可以使用LINQ来完成？而不是定义列表？只是结果？@Bercovicadrian添加了一个非常简洁的方式。是的，这与我所寻找的类似。我不想定义辅助变量。谢谢你的回答。groupby子句基本上解决了这个问题，但它创建了一个组的枚举，我无法将其转储到元组中。@Bercovicadrian在最后创建Tuple并将结果放在那里。整个事情几乎是

O（n）

List<List<int>> buckets = input.GroupBy(func).Select(g => g.ToList()).ToList();

var func = new Func<int, bool>(x => x % 2 == 0);
List<List<int>> buckets = input.SelectMany(e => e).GroupBy(func).Select(g => g.ToList()).ToList();

var tuple = Tuple.Create(new List<int>(), new List<int>());
var func = new Func<int, bool>(x => x % 2 == 0);
List<List<int>> buckets = input.Select(e => 
{
   func(e)? tuple.Item1.Add(e) : tuple.Item2.Add(e);
   return e;
}).ToList();

var tuple = Tuple.Create(buckets[0], buckets[1]);