Question

我有一个大小为85160的动态列表（但它可以改变）。我想将它分成3个相同大小的列表。

我在考虑获取列表的大小。所以那只是：

int count = rawData.count;

然后我可以把它除以3;但我不确定我是如何将第一组放入一个列表，然后是下一个等等。

最佳方式吗？

Answer 1

这应该有用。

var items = rawData.Count / 3;
var first = rawData.Take(items).ToList();
var second = rawData.Skip(items).Take(items).ToList();
var third = rawDate.Skip(2 * items).ToList();

Answer 2

如果您不关心集合中物品的订购，请尝试使用此代码。

static IEnumerable<IEnumerable<int>> Split(IList<int> source, int count)
    {
        return source
            .Select((value, index) => new { Index = index % count, Value = value })
            .GroupBy(pair => pair.Index)
            .Select(grp => grp.Select(g => g.Value));
    }

使用示例

static void Main()
{
   var arrays = Split(new[]{1,2,3,4,5,6,7,8,9,0}, 3);

   foreach(var array in arrays)
   {
        foreach(var item in array)
            Console.WriteLine(item);
        Console.WriteLine("---------------");
   }
}

将给你

1 4 7 0

2 五 8

3 6 9

Answer 3

可能，List.GetRange(int index, int count)会有帮助吗？

Answer 4

var lists = new List<List<YourObject>>();
int chunkCount = 3;
int chunk = rawData / chunkCount;
for (int i = 0; i < chunkCount; i++)
{
    var data = rawData.Skip(i * chunk);

    if (i < chunkCount - 1)
        data = data.Take(chunk);

    lists.Add(data.ToList());
}

当i == chunkCount - 1（最后一次迭代）时，我没有使用Take来确保我把所有东西都拿到最后。

Answer 5

嗯，你可以通常为所有IEnumerables做这样的扩展。

public static IEnumerable<IEnumerable<T>> Chop<T>(
    this IEnumerable<T> source,
    int chopCount)
{
    var chops = new IList<T>[chopCount];

    for (i = 0; i < chops.Length; i++)
    {
        chops[i] = new List<T>();
    }

    var nextChop = 0;
    foreach (T item in source)
    {
        chop[nextChop].Add(item);
        nextChop = nextChop == chopCount - 1 ? 0 : nextChop + 1;
    }

    for (i = 0; i < chops.Length; i++)
    {
        yield return chops[i];
    }   
}

你可以像这样使用

var chops = rawData.Chop(3);

Answer 6

这是一个使用IEnumerable扩展的解决方案，它将一个序列分成多个子序列：

using System;
using System.Collections.Generic;
using System.Linq;

namespace Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            int count = 85160;
            var someNumbers = Enumerable.Range(0, count).ToList();
            var lists = PartitionToEqualSizedLists(someNumbers, 3);

            foreach (var list in lists)
            {
                Console.WriteLine("List length = " + list.Count);
            }

            Console.WriteLine("\nDone.");
            Console.ReadLine();
        }

        public static List<List<T>> PartitionToEqualSizedLists<T>(List<T> input, int numPartitions)
        {
            int blockSize = (input.Count + numPartitions - 1)/numPartitions;
            return input.Partition(blockSize).Select(partition => partition.ToList()).ToList();
        }
    }

    public static class EnumerableExt
    {
        public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> input, int blockSize)
        {
            var enumerator = input.GetEnumerator();

            while (enumerator.MoveNext())
            {
                yield return nextPartition(enumerator, blockSize);
            }
        }

        private static IEnumerable<T> nextPartition<T>(IEnumerator<T> enumerator, int blockSize)
        {
            do
            {
                yield return enumerator.Current;
            }
            while (--blockSize > 0 && enumerator.MoveNext());
        }
    }
}

c＃将1个列表分成3个？

6 个答案: