Question

我想将部分列表分成，而不知道该列表中有多少项目。问题与那些想要将列表拆分为固定大小的块的人不同。

int[] a = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

我希望值垂直分割。

分成2：

-------------------
| item 1 | item 6 |
| item 2 | item 7 |
| item 3 | item 8 |
| item 4 | item 9 |
| item 5 |        |

分成3：

| item 1 | item 4 | item 7 |
| item 2 | item 5 | item 8 |
| item 3 | item 6 | item 9 |

分成4：

| item 1 | item 4 | item 6 | item 8 |
| item 2 | item 5 | item 7 | item 9 |
| item 3 |        |        |        |

我发现了一些可以做到这一点的c＃扩展，但它没有按照我想要的方式分配值。这是我发现的：

// this technic is an horizontal distribution
public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> list, int parts)
{
    int i = 0;
    var splits = from item in list
                    group item by i++ % parts into part
                    select part.AsEnumerable();
    return splits;
}

结果是这样但我的问题是值水平分布：

| item 1 | item 2 |
| item 3 | item 4 |
| item 5 | item 6 |
| item 7 | item 8 |
| item 9 |        |

或

| item 1 | item 2 | item 3 |
| item 4 | item 5 | item 6 |
| item 7 | item 8 | item 9 |

我知道如何垂直分配我的价值，并且有可能选择我想要的部分数量吗？

在现实生活中

对于那些想知道我想在哪种情况下垂直拆分列表的人，这里是我网站的一部分截图：

enter image description here

Answer 1

使用.Take()和.Skip()，您可以：

int[] a = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

int splitIndex = 4; // or (a.Length / 2) to split in the middle.

var list1 = a.Take(splitIndex).ToArray(); // Returns a specified number of contiguous elements from the start of a sequence.
var list2 = a.Skip(splitIndex).ToArray(); // Bypasses a specified number of elements in a sequence and then returns the remaining elements.

如果您需要.ToList()，则可以使用.ToArray()代替List<int>。

修改

在你改变了（或许澄清了）你的问题之后，我想这就是你所需要的：

public static class Extensions { public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> source, int parts) { var list = new List<T>(source); int defaultSize = (int)((double)list.Count / (double)parts); int offset = list.Count % parts; int position = 0; for (int i = 0; i < parts; i++) { int size = defaultSize; if (i < offset) size++; // Just add one to the size (it's enough). yield return list.GetRange(position, size); // Set the new position after creating a part list, so that it always start with position zero on the first yield return above. position += size; } } }

使用它：

int[] a = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; var lists = a.Split(2);

这会产生：

分为2：a.Split(2);

| item 1 | item 6 | | item 2 | item 7 | | item 3 | item 8 | | item 4 | item 9 | | item 5 | |

分为3：a.Split(3);

| item 1 | item 4 | item 7 | | item 2 | item 5 | item 8 | | item 3 | item 6 | item 9 |

分为4：a.Split(4);

| item 1 | item 4 | item 6 | item 8 | | item 2 | item 5 | item 7 | item 9 | | item 3 | | | |

另外，如果你有：

int[] b = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // 10 items

并拆分为4：b.Split(4);

| item 1 | item 4 | item 7 | item 9 | | item 2 | item 5 | item 8 | item 10| | item 3 | item 6 | | |

Answer 2

这似乎很好地解决了这个问题。它可能会更有效率，但这足够令人费解......这样做更容易：

1|4|7|10
2|5|8
3|6|9

比：

1|4|7|9
2|5|8|10
3|6|

我首先忽略了LINQ请求，因为我无法绕过它。使用正常数组操作的解决方案可能会产生如下结果：

    public static IEnumerable<IEnumerable<TListItem>> Split<TListItem>(this IEnumerable<TListItem> items, int parts)
        where TListItem : struct
    {
        var itemsArray = items.ToArray();
        int itemCount = itemsArray.Length;
        int itemsOnlastRow = itemCount - ((itemCount / parts) * parts);
        int numberOfRows = (int)(itemCount / (decimal)parts) + 1;

        for (int row = 0; row < numberOfRows; row++)
        {
            yield return SplitToRow(itemsArray, parts, itemsOnlastRow, numberOfRows, row);
        }
    }

    private static IEnumerable<TListItem> SplitToRow<TListItem>(TListItem[] items, int itemsOnFirstRows, int itemsOnlastRow,
                                                                int numberOfRows, int row)
    {
        for (int column = 0; column < itemsOnFirstRows; column++)
        {
            // Are we on the last row?
            if (row == numberOfRows - 1)
            {
                // Are we within the number of items on that row?
                if (column < itemsOnlastRow)
                {
                    yield return items[(column + 1) * numberOfRows -1];
                }
            }
            else
            {
                int firstblock = itemsOnlastRow * numberOfRows;
                int index;

                // are we in the first block?
                if (column < itemsOnlastRow)
                {
                    index = column*numberOfRows + ((row + 1)%numberOfRows) - 1;
                }
                else
                {
                    index = firstblock + (column - itemsOnlastRow)*(numberOfRows - 1) + ((row + 1)%numberOfRows) - 1;
                }

                yield return
                    items[index];
            }
        }
    }

LINQ伪代码将是：

//WARNING: DOES NOT WORK
public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> list, int parts)
{
    int itemOnIndex = 0;
    var splits = from item in list
                 group item by MethodToDefineRow(itemOnIndex++) into row
                 select row.AsEnumerable();
    return splits;
}

但是如果不知道物品的数量，就无法计算放置物品的位置。

所以通过做一些预先计算，你可以使用LINQ实现与上面相同的事情，这需要通过IEnumerable两次，似乎没有办法解决这个问题。诀窍是计算每个值将被分配给的行。

    //WARNING: Iterates the IEnumerable twice
    public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> list, int parts)
    {
        int itemOnIndex = 0;
        int itemCount = list.Count();
        int itemsOnlastRow = itemCount - ((itemCount / parts) * parts);
        int numberOfRows = (int)(itemCount / (decimal)parts) + 1;
        int firstblock = (numberOfRows*itemsOnlastRow);

        var splits = from item in list
                     group item by (itemOnIndex++ < firstblock) ? ((itemOnIndex -1) % numberOfRows) : ((itemOnIndex - 1 - firstblock) % (numberOfRows - 1)) into row
                     orderby row.Key
                     select row.AsEnumerable();
        return splits;
    }

Answer 3

使用.Take(#OfElements)指定要拍摄的元素数量。

您还可以使用.First和.Last

如何使用LINQ在n个部分中垂直拆分列表

在现实生活中

3 个答案: