C# 可数但它必须是IEnumerableCorrect me如果我错了,但对IEnumerable进行分组不是吗?在这些示例中,它似乎希望“parts”是每个集合中项目的数量。在我的示例中,我希望“parts”是要创建的子集合的数量。这个算法是否存在错误。。有
C# 可数但它必须是IEnumerableCorrect me如果我错了,但对IEnumerable进行分组不是吗?在这些示例中,它似乎希望“parts”是每个集合中项目的数量。在我的示例中,我希望“parts”是要创建的子集合的数量。这个算法是否存在错误。。有,c#,asp.net,collections,extension-methods,ienumerable,C#,Asp.net,Collections,Extension Methods,Ienumerable,可数但它必须是IEnumerableCorrect me如果我错了,但对IEnumerable进行分组不是吗?在这些示例中,它似乎希望“parts”是每个集合中项目的数量。在我的示例中,我希望“parts”是要创建的子集合的数量。这个算法是否存在错误。。有人试过核实吗?在我看来,行int maxSize=(int)Math.天花(list.Count/(double)totalPartitions)可能导致无效的maxSize计数。。例如;21个元素的列表,将被分成所述期望的10组;实际上,将只
可数但它必须是IEnumerableCorrect me如果我错了,但对IEnumerable进行分组不是吗?在这些示例中,它似乎希望“parts”是每个集合中项目的数量。在我的示例中,我希望“parts”是要创建的子集合的数量。这个算法是否存在错误。。有人试过核实吗?在我看来,行int maxSize=(int)Math.天花(list.Count/(double)totalPartitions)可能导致无效的maxSize计数。。例如;21个元素的列表,将被分成所述期望的10组;实际上,将只创建7组3个元素和3个空组。。原因是尺寸计算将从2.1增加到3是的,我想是的。如果我有一个字母表列表,并将其拆分为100个分区,我将返回一个对象,该对象的前0-25个分区各填充1个项目,26-99个分区将为空。LINQ在3.5版本可能会纠正这个问题,我只是在几年内没有研究过这个问题。它做了我需要它做的事情,当然也做了OP需要的事情。这将创建大小不尽相同的分区。对于7个值,分区的计数将分别为3、3和1。我需要分区计数为3、2和2。
public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> list, int parts)
{
int i = 0;
var splits = from name in list
group name by i++ % parts into part
select part.AsEnumerable();
return splits;
}
double partLength = list.Count() / (double)parts;
int i = 0;
var splits = from name in list
group name by Math.Floor((double)(i++ / partLength)) into part
select part;
var items = list.Batch(parts); // gives you IEnumerable<IEnumerable<T>>
var items = list.Batch(parts, seq => seq.ToList()); // gives you IEnumerable<List<T>>
// etc...
public class Program
{
static void Main(string[] args)
{
var list = new List<int>();
for (int i = 1; i < 10000; i++)
{
list.Add(i);
}
var batched = list.Batch(681);
// will print 15. The 15th element has 465 items...
Console.WriteLine(batched.Count().ToString());
Console.WriteLine(batched.ElementAt(14).Count().ToString());
Console.WriteLine();
Console.WriteLine("Press enter to exit.");
Console.ReadLine();
}
}
/// <summary>
/// Partition a list of elements into a smaller group of elements
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
/// <param name="totalPartitions"></param>
/// <returns></returns>
public static List<T>[] Partition<T>(List<T> list, int totalPartitions)
{
if (list == null)
throw new ArgumentNullException("list");
if (totalPartitions < 1)
throw new ArgumentOutOfRangeException("totalPartitions");
List<T>[] partitions = new List<T>[totalPartitions];
int maxSize = (int)Math.Ceiling(list.Count / (double)totalPartitions);
int k = 0;
for (int i = 0; i < partitions.Length; i++)
{
partitions[i] = new List<T>();
for (int j = k; j < k + maxSize; j++)
{
if (j >= list.Count)
break;
partitions[i].Add(list[j]);
}
k += maxSize;
}
return partitions;
}
public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> list, int parts)
{
int nGroups = (int)Math.Ceiling(list.Count() / (double)parts);
var groups = Enumerable.Range(0, nGroups);
return groups.Select(g => list.Skip(g * parts).Take(parts));
}
public static IEnumerable<IEnumerable<T>> SplitMaintainingOrder<T>(this IEnumerable<T> list, int parts)
{
if (list.Count() == 0) return Enumerable.Empty<IEnumerable<T>>();
var toreturn = new List<IEnumerable<T>>();
var splitFactor = Decimal.Divide((decimal)list.Count(), parts);
int currentIndex = 0;
for (var i = 0; i < parts; i++)
{
var toTake = Convert.ToInt32(
i == 0 ? Math.Ceiling(splitFactor) : (
(Decimal.Compare(Decimal.Divide(Convert.ToDecimal(currentIndex), Convert.ToDecimal(i)), splitFactor) > 0) ?
Math.Floor(splitFactor) : Math.Ceiling(splitFactor)));
toreturn.Add(list.Skip(currentIndex).Take(toTake));
currentIndex += toTake;
}
return toreturn;
}
[TestMethod]
public void splitlist()
{
var list = new decimal[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 };
var splitlists = list.SplitMaintainingOrder(10);
int i = 1;
foreach (var group in splitlists)
{
Console.WriteLine("Group {0} elements {1}", i++, String.Join(",", group));
}
}
Test Name: splitlist
Test Outcome: Passed
Result StandardOutput:
Group 1 elements 1,2,3
Group 2 elements 4,5
Group 3 elements 6,7,8
Group 4 elements 9,10,11
Group 5 elements 12,13
Group 6 elements 14,15,16
Group 7 elements 17,18,19
Group 8 elements 20,21
Group 9 elements 22,23,24
Group 10 elements 25,26,27
public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> source, int n)
{
var count = source.Count();
return source.Select((x, i) => new { value = x, index = i })
.GroupBy(x => x.index / (int)Math.Ceiling(count / (double)n))
.Select(x => x.Select(z => z.value));
}