将集合分成较小的集合,但重复项目

时间:2012-08-01 06:18:22

标签: c# linq

我无法理解如何做到这一点。

我有一组对象

{ object1, object2, object3, object4 }

我想把这个集合分解成一个集合集合,这样我最终会得到一些看起来像

的东西。
{ { object1, object2}, {object2, object3}, {object3, object4} }

我已经找到了如何将集合分成较小的集合,但它是每个集合中前一个项目的重复,正在我的脑袋里。

任何帮助都非常感谢!

我当前的块方法(取自此处的另一个问题)是

    public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int size)
    {
            return source.Select((x, i) => new { Index = i, Value = x })
                        .GroupBy(x => x.Index / size)
                        .Select(x => x.Select(v => v.Value));
    }

修改 这有效,但还有更好的方法吗?

    public static ICollection<ICollection<T>> BreakUp<T>(this IEnumerable<T> polylines, int size)
    {
        var results = new Collection<ICollection<T>>();
        results.Add(new Collection<T>());

        var x = 0;
        for (var i = 0; i < polylines.Count(); i++)
        {
            results[x].Add(polylines.ElementAt(i));

            if (results[x].Count() % size == 0 && i != polylines.Count() - 1)
            {
                x++;
                results.Add(new Collection<T>());
                results[x].Add(polylines.ElementAt(i));
            }
        }

        return results;
    }

3 个答案:

答案 0 :(得分:8)

您可以像这样简化代码:

public static IEnumerable<IEnumerable<T>> BreakUp<T>(IEnumerable<T> this source, int size)
{
    var max = source.Count();
    int i = 0;
    while (i < max)
    {
        var current = source.Skip(i).Take(size);
        if (current.Count() > 1)
            yield return current;
        i += size -1;
    }
}

<强>测试

void Main()
{
    Console.WriteLine("Example 1");
    var source = new Int32[] {1, 2, 3, 4, 5};

    foreach (var i in BreakUp(source, 2))
        Console.WriteLine(i);

    Console.WriteLine("Example 2");

    foreach (var i in BreakUp(source, 4))
        Console.WriteLine(i);
}

这是一个只迭代source一次的解决方案:

public static IEnumerable<IEnumerable<T>> BreakUp<T>(IEnumerable<T> this source, int size)
{
    using(var e = source.GetEnumerator())
    {
        T last = default(T);
        bool has_last = false;
        while(e.MoveNext())
        {
            var current = new List<T>(size);
            if(has_last)
                current.Add(last);

            last = (T)e.Current;
            current.Add(last);

            while(current.Count < size && e.MoveNext())
            {
                last = (T)e.Current;
                current.Add(last);
                has_last = true;
            }

            yield return current;
        }
    }
}

<强>结果:

enter image description here

答案 1 :(得分:2)

如果您只需要像这样分组

{{object1,object2},{object2,object3},{object3,object4}}

然后下面的代码就足够了

return source.Zip(source.Skip(1), (o1, o2) => new List<T> { o1, o2 });

编辑:

可变数量元素的解决方案:

{{object1,object2,object3},{object2,object3,object4},{object3,object4,object5}}

source.TakeWhile((o,i) => i <= source.Count() - size)
      .Select((o,i) => source.Where((lo,li) => li >= i && li < i + size));

答案 2 :(得分:2)

这可能不像其他解决方案那样简洁,但它只遍历source一次。

public static IEnumerable<List<T>> BreakUp<T>(this IEnumerable<T> source, int size)
{
    var max = source.Count();
    int start = 0;
    var enumerator = source.GetEnumerator();
    enumerator.MoveNext();
    // We use "max - 1" instead of "max" to avoid adding a list of length 1
    while (start < max - 1)
    {
        int current = 0;
        List<T> list = new List<T>();
        list.Add(enumerator.Current);
        current++;

        while(current < size && enumerator.MoveNext())
        {
            list.Add(enumerator.Current);
            current++;
        }
        yield return list;
        start += size - 1;
    }
}