“Turning” an IEnumerable 90 degrees

问题

What I'm looking for is a basic operation (Which I'm sure have a name I'm just unaware of atm). I have a matrix like:

{1,2,3}

{A,N,F}

{7,8,9}

which I'd like to mutate into

{1,A,7}

{2,N,8}

{3,F,9}

(The above are only identifiers for objects not real values. The actual objects are of the same type and unordered)

I'd prefer a declarative solution to it but speed is a factor. I'm going to have to turn quite a few tables (100k cells a min) and a slow version would be on the critical path.

However I'm still more interested in a readable solution. I'm looking for alternative solutions to the below. (By alternative I do not mean variations but a different approach)

var  arrays = rows.Select(row => row.ToArray());
var cellCount = arrays.First().Length;
for(var i = 0;i<cellCount;i++){
  yield return GetRow(i,arrays);
}

IEnumerable<T> GetRow(int i,IEnumerable<T[]> rows){
  foreach(var row in rows}{
     yield return row[i]; 
  }
}

Amongst two almost equally readable solutions I'd go for the faster but readability goes before speed

EDIT It will always be a square matrix

回答1:

I'm a little iffy about this implementation. It has side-effects local to the iterator but looks logically clean to me. This assumes each sequence is the same length but should work for any. You can think of it as a variable length Zip() method. It should perform better than the other linked LINQ solutions found in the other answers as it only uses the minimum operations needed to work. Probably even better without the use of LINQ. Might even be considered optimal.

public static IEnumerable<IEnumerable<T>> Transpose<T>(this IEnumerable<IEnumerable<T>> source)
{
    if (source == null) throw new ArgumentNullException("source");
    var enumerators = source.Select(x => x.GetEnumerator()).ToArray();
    try
    {
        while (enumerators.All(x => x.MoveNext()))
        {
            yield return enumerators.Select(x => x.Current).ToArray();
        }
    }
    finally
    {
        foreach (var enumerator in enumerators)
            enumerator.Dispose();
    }
}

回答2:

Just a quick google search revealed these solutions:

LINQ Transpose Extension Method
Transpose or just rows as columns
http://www.extensionmethod.net/Details.aspx?ID=152

回答3:

Take a look at this extension method. Linq transpose. I'm not sure about performance but the code looks elegant.

回答4:

Your question seems to be implying that you want to modify the original matrix.

If that's the case, and if you are able to store the matrix as a IList<IList<T>> matrix, then this will work, however, only in the case of a square matrix.

for(int i = 0; i < matrix.Count; ++i)
{
    for(int j = 0; j < i; ++j)
    {
        T temp = matrix[i][j];
        matrix[i][j] = matrix[j][i];
        matrix[j][i] = temp
    }
}

回答5:

Well, what you are looking for here is a transformation T[][] -> T[][]. There are plenty of IEnumerabe<IEnumerable<T>>.Transpose() solutions around but they all boil down to looping enumerables using temporary lookups/keys and they leave a lot to be desired when it comes to performance on huge volume. Your example actually works faster (though you could loose the second foreach too).

First ask "do I need LINQ at all". You have not described what the purpose of the transposed matrix will be and if the speed is indeed your concern you might do well to just stay away from the LINQ/foreach and do it the old fashioned way (for inside for)

回答6:

Here's mine if anyone's interested. It performs in the same sort of manner as Jeff's, but seems to be slightly faster (assuming those ToArrays() are necessary). There's no visible loops or temporaries, and it's much more compact:

public static IEnumerable<IEnumerable<T>> Transpose<T>(
    this IEnumerable<IEnumerable<T>> source)
{
    return source
        .Select(a => a.Select(b => Enumerable.Repeat(b, 1)))
        .Aggregate((a, b) => a.Zip(b, Enumerable.Concat));
}

If you need it to handle empty lists too, then it becomes this:

public static IEnumerable<IEnumerable<T>> Transpose<T>(
    this IEnumerable<IEnumerable<T>> source)
{
    return source
        .Select(a => a.Select(b => Enumerable.Repeat(b, 1)))
        .DefaultIfEmpty(Enumerable.Empty<IEnumerable<T>>())
        .Aggregate((a, b) => a.Zip(b, Enumerable.Concat));
}

I noticed that the asker wrote that the matrix would always be square. This implementation (and jeffs) will evaluate an entire row at a time, but if we know that the matrix is square we can rewrite the zip function in a more suitable manner:

public static IEnumerable<IEnumerable<T>> Transpose<T>(
    this IEnumerable<IEnumerable<T>> source)
{
    return source
        .Select(a => a.Select(b => Enumerable.Repeat(b, 1)))
        .DefaultIfEmpty(Enumerable.Empty<IEnumerable<T>>())
        .Aggregate(Zip);
}

public static IEnumerable<IEnumerable<T>> Zip<T>(
    IEnumerable<IEnumerable<T>> first, 
    IEnumerable<IEnumerable<T>> second)
{
    var firstEnum = first.GetEnumerator();
    var secondEnum = second.GetEnumerator();

    while (firstEnum.MoveNext())
        yield return ZipHelper(firstEnum.Current, secondEnum);
}

private static IEnumerable<T> ZipHelper<T>(
    IEnumerable<T> firstEnumValue, 
    IEnumerator<IEnumerable<T>> secondEnum)
{
    foreach (var item in firstEnumValue)
        yield return item;

    secondEnum.MoveNext();

    foreach (var item in secondEnum.Current)
        yield return item;
}

This way, each element won't be evaluated until it's returned.

来源：https://stackoverflow.com/questions/5039617/turning-an-ienumerableienumerablet-90-degrees

标签

linq

algorithm

declarative

“Turning” an IEnumerable<IEnumerable<T>> 90 degrees