3

これを行う方法が頭に浮かびません。

私はオブジェクトのコレクションを持っています

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

3 に答える 3

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

source1回だけ反復するソリューションは次のとおりです。

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

結果：

ここに画像の説明を入力

于 2012-08-01T06:46:52.510 に答える
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));
于 2012-08-01T06:50:56.093 に答える
2

これは他のソリューションほど簡潔ではないかもしれませんが、反復sourceは 1 回だけです。

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;
    }
}
于 2012-08-01T19:16:51.897 に答える