15

如果我有一个包含任意数量列表的列表，如下所示：

var myList = new List<List<string>>()
{
    new List<string>() { "a", "b", "c", "d" },
    new List<string>() { "1", "2", "3", "4" },
    new List<string>() { "w", "x", "y", "z" },
    // ...etc...
};

...有没有办法以某种方式将列表“压缩”或“旋转”成这样的东西？

{ 
    { "a", "1", "w", ... },
    { "b", "2", "x", ... },
    { "c", "3", "y", ... },
    { "d", "4", "z", ... }
}

显而易见的解决方案是执行以下操作：

public static IEnumerable<IEnumerable<T>> Rotate<T>(this IEnumerable<IEnumerable<T>> list)
{
    for (int i = 0; i < list.Min(x => x.Count()); i++)
    {
        yield return list.Select(x => x.ElementAt(i));
    }
}

// snip

var newList = myList.Rotate();

...但我想知道是否有更清洁的方法，使用 linq 或其他方式？

4

8 回答 8

18

您可以滚动您自己的 ZipMany 实例，该实例手动迭代每个枚举。GroupBy与投影每个序列后使用的序列相比，这可能会在更大的序列上表现得更好：

public static IEnumerable<TResult> ZipMany<TSource, TResult>(
    IEnumerable<IEnumerable<TSource>> source,
    Func<IEnumerable<TSource>, TResult> selector)
{
   // ToList is necessary to avoid deferred execution
   var enumerators = source.Select(seq => seq.GetEnumerator()).ToList();
   try
   {
     while (true)
     {
       foreach (var e in enumerators)
       {
           bool b = e.MoveNext();
           if (!b) yield break;
       }
       // Again, ToList (or ToArray) is necessary to avoid deferred execution
       yield return selector(enumerators.Select(e => e.Current).ToList());
     }
   }
   finally
   {
       foreach (var e in enumerators) 
         e.Dispose();
   }
}
于 2013-07-31T17:47:33.230 回答
12

您可以通过使用Select扩展名来做到这一点Func<T, int, TOut>：

var rotatedList = myList.Select(inner => inner.Select((s, i) => new {s, i}))
                        .SelectMany(a => a)
                        .GroupBy(a => a.i, a => a.s)
                        .Select(a => a.ToList()).ToList();

这会给你另一个List<List<string>>。

分解

.Select(inner => inner.Select((s, i) => new {s, i}))

对于每个内部列表，我们将列表的内容投影到具有两个属性的新匿名对象：s字符串值和i该值在原始列表中的索引。

.SelectMany(a => a)

我们将结果展平为单个列表

.GroupBy(a => a.i, a => a.s)

我们按i匿名对象的属性进行分组（记住这是索引）并选择该s属性作为我们的值（仅限字符串）。

.Select(a => a.ToList()).ToList();

对于每个组，我们将可枚举更改为一个列表，并为所有组更改另一个列表。

于 2013-07-31T17:29:17.383 回答
5

使用SelectMany和GroupBy一些索引怎么样？

// 1. Project inner lists to a single list (SelectMany)
// 2. Use "GroupBy" to aggregate the item's based on order in the lists
// 3. Strip away any ordering key in the final answer
var query = myList.SelectMany(
    xl => xl.Select((vv,ii) => new { Idx = ii, Value = vv }))
       .GroupBy(xx => xx.Idx)
       .OrderBy(gg => gg.Key)
       .Select(gg => gg.Select(xx => xx.Value));

来自 LinqPad：

我们对项目进行分组

于 2013-07-31T17:32:18.913 回答
3

这是一个基于矩阵转置的低效变体：

public static class Ext
{
    public static IEnumerable<IEnumerable<T>> Rotate<T>(
        this IEnumerable<IEnumerable<T>> src)
    {
        var matrix = src.Select(subset => subset.ToArray()).ToArray();
        var height = matrix.Length;
        var width = matrix.Max(arr => arr.Length);

        T[][] transpose = Enumerable
            .Range(0, width)
            .Select(_ => new T[height]).ToArray();
        for(int i=0; i<height; i++)
        {        
            for(int j=0; j<width; j++)
            {            
                transpose[j][i] = matrix[i][j];            
            }
        }

        return transpose;
    }
}
于 2013-07-31T17:46:03.227 回答
2

看看codeplex 上的 linqlib 项目，它有一个可以完全满足您需要的旋转功能。

于 2013-07-31T18:58:44.700 回答
1

您可以使用Range压缩for循环：

var result = Enumerable.Range(0, myList.Min(l => l.Count))
    .Select(i => myList.Select(l => l[i]).ToList()).ToList();
于 2013-07-31T17:36:17.870 回答
0 
(from count in Range(myList[0].Count)
select new List<string>(
    from count2 in Range(myList.Count)
    select myList[count2][count])
    ).ToList();

它不漂亮，但我认为它会工作。

于 2013-07-31T17:32:47.690 回答
0

这是一个递归ZipMany实现，灵感来自@Enigmativity对另一个问题的回答。

public static IEnumerable<IEnumerable<T>> ZipMany<T>(params IEnumerable<T>[] sources)
{
    return ZipRecursive(sources);
    IEnumerable<IEnumerable<T>> ZipRecursive(IEnumerable<IEnumerable<T>> ss)
    {
        if (!ss.Skip(1).Any())
        {
            return ss.First().Select(i => Enumerable.Repeat(i, 1));
        }
        else
        {
            return ZipRecursive(ss.Skip(1).ToArray()).Zip(ss.First(), (x, y) => x.Prepend(y));
        }
    }
}

优点：避免与普查员的处置有关的问题。
缺点：扩展性差。递归开销在大约 3000 个可枚举时变得明显，之后呈指数增长。

于 2019-05-26T08:49:01.453 回答