Question

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

我有一组对象

{ 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;
    }

Answer 1

您可以像这样简化代码：

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

Answer 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));

Answer 3

这可能不像其他解决方案那样简洁，但它只遍历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;
    }
}

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

3 个答案: