Take groups of 5 strings from List

Question

I have a List<string> and I want to take groups of 5 items from it. There are no keys or anything simple to group by...but it WILL always be a multiple of 5.

e.g.

{"A","16","49","FRED","AD","17","17","17","FRED","8","B","22","22","107","64"}

Take groups of:

"A","16","49","FRED","AD"
"17","17","17","FRED","8"
"B","22","22","107","64"

but I can't work out a simple way to do it!

Pretty sure it can be done with enumeration and Take(5)...

You can indeed use Take(5) and on the next iteration Skip(5).Take(5) and so on. — Kevin D, Dec 11 '14 at 10:10
This works for small lists, but in general is a bad idea. It iterates over the collection once per group leading to quadratic running time [O(n^2)](http://stackoverflow.com/a/487300/141397). This applies to all the other answers here using `.Skip().Take()`. — 3dGrabber, Dec 11 '14 at 10:29
http://stackoverflow.com/questions/419019/split-list-into-sublists-with-linq — Andrew, Dec 11 '14 at 10:35
@3dGrabber: i have tested the `GroupBy` + the `Skip` approaches on a very large list(`for (int i = 0; i < 20; i++)list.AddRange(list);`. The `GroupBy` took 23 seconds whereas the `Skip` is still running after 10 minutes ;) — Tim Schmelter, Dec 11 '14 at 10:42
@3dGrabber: do you mean this version? `... .GroupBy(x => x.index / 5)` — BlueChippy, Dec 11 '14 at 10:45
I've stopped it after 20 minutes, i'm afraid that it would eat my PC otherwise. @BlueChippy: The morelinq `Batch` should be the most efficient apporach but the `GroupBy` is ok. 3dGrabbe was referring to the `Skip.Take` approaches which are really slow if the list is getting large. — Tim Schmelter, Dec 11 '14 at 10:55

score 10 · Accepted Answer · answered Dec 11 '14 at 10:14

10

You can use the integer division trick:

List<List<string>> groupsOf5 = list
    .Select((str, index) => new { str, index })
    .GroupBy(x => x.index / 5)
    .Select(g => g.Select(x => x.str).ToList())
    .ToList();

answered Dec 11 '14 at 10:14

Tim Schmelter

450,073
74
686
939

1

this will work but, 1) it will create unnecessary anon. objects, 2) it will iterate over the collection at least three times. – Selman Genç Dec 11 '14 at 10:30
1

http://stackoverflow.com/questions/419019/split-list-into-sublists-with-linq yeah, right – Andrew Dec 11 '14 at 10:35

score 8 · Answer 2 · answered Dec 11 '14 at 10:12

8

 List<List<string>> result = new List<List<string>>();
 for(int i = 0; i < source.Count; i += 5 )
      result.Add(source.Skip(i).Take(5).ToList());

Like this?

answered Dec 11 '14 at 10:12

Florian Schmidinger

4,682
2
16
28

6

This has terrible runtime performance, see my comment in the question. – 3dGrabber Dec 11 '14 at 10:32
you did not specify how long this list is nor what you want to do with this data. this solution is therefor a simple way how to do it. if you specify what you want to do with the data we can provide a more detailed and more performant solution – Florian Schmidinger Dec 11 '14 at 10:43
this is perfect – TDM Sep 08 '20 at 18:38

Andrew · Answer 3 · 2014-12-11T12:20:58.923

3

In common programming syntax:

     public List<List<string>> Split(List<string> items, int chunkSize = 5)
     {
         int chunkCount = items.Count/chunkSize;
         List<List<string>> result = new List<List<string>>(chunkCount);

         for (int i = 0; i < chunkCount; i++ )
         {
             result.Add(new List<string>(chunkSize));
             for (int j = i * chunkSize; j < (i + 1) * chunkSize; j++)
             {
                 result[i].Add(items[j]);
             }
         }

         return result;
     }

It's O((N/ChunkSize) x ChunkSize) = O(N), that is linear.

edited Dec 11 '14 at 12:20

answered Dec 11 '14 at 10:14

Andrew

3,648
1
15
29

throws index out of range exception – WhileTrueSleep Dec 11 '14 at 11:00
1

Best answer so far IMO. Since the chunk size is constant inside the loop you could use an array instead, which is faster and uses less memory. Or at least use the list constructor with 'initial capacity', so the list does not have to resize itself. – 3dGrabber Dec 11 '14 at 11:10
@3dGrabber, Unless you need something from the bench of functionalities that the List ships with, Array is faster. I'm not aware of the use cases, and List seams to be more universal in modern development. – Andrew Dec 11 '14 at 11:37
Always go for O(n), that trumps elegance every day, in every way. +1 for that! – code4life Dec 11 '14 at 12:04
Yeah, linear algorithms do scale. – Andrew Dec 11 '14 at 12:06
@Andrew: sure, array or list is debatable. But `result.Add(new List(chunkSize))` would still make sense. – 3dGrabber Dec 11 '14 at 12:20
Yes, there's internal array behind the scenes. Updated the answer. – Andrew Dec 11 '14 at 12:23

score 2 · Answer 4 · answered Dec 11 '14 at 10:24

2

I recommend Batch method from MoreLINQ library:

var result = list.Batch(5).ToList();

answered Dec 11 '14 at 10:24

Selman Genç

100,147
13
119
184

score 1 · Answer 5 · answered Dec 11 '14 at 10:10

1

Use Take() and Skip() to achieve this:

        List<string> list = new List<string>() { "A", "16", "49", "FRED", "AD", "17", "17", "17", "FRED", "8", "B", "22", "22", "107", "64" };

        List<List<string>> result = new List<List<string>>();
        for (int i = 0; i < list.Count / 5; i++)
        {
            result.Add(list.Skip(i * 5).Take(5).ToList());
        }

answered Dec 11 '14 at 10:10

Adrian Nasui

1,054
9
10

I don't know how many total sets of 5 there will be, just that they will be complete sets – BlueChippy Dec 11 '14 at 10:13
edited to work for yoy – Adrian Nasui Dec 11 '14 at 10:14

Hamid Pourjam · Answer 6 · 2015-11-28T06:59:38.527

1

You can use this function:

public IEnumerable<string[]> GetChunk(string[] input, int size)
{
    int i = 0;
    while (input.Length > size * i)
    {
        yield return input.Skip(size * i).Take(size).ToArray();
        i++;
    }
}

it returns you chunks from your list

you can check it like

var list = new[]
{
    "A", "16", "49", "FRED", "AD", "17", "17", "17", "FRED", "8", "B", "22", "22", "107", "64"
};

foreach (var strings in GetChunk(list, 5))
{
    Console.WriteLine(strings.Length); 
}

edited Nov 28 '15 at 06:59

answered Dec 11 '14 at 10:12

Hamid Pourjam

20,441
9
58
74

1

Like this answer because I can extend to set the "chunk" size... – BlueChippy Dec 11 '14 at 10:16
I've edited it to support different chunk sizes – Hamid Pourjam Dec 11 '14 at 10:18

WhileTrueSleep · Answer 7 · 2014-12-11T11:14:18.393

If you need performance or cannot use linq cause of your .net version here is a simple solution with O(n)

    private List<List<string>> SplitList(List<string> input, int size = 5)
    {
        var result = new List<List<string>>();
        for (int i = 0; i < input.Count; i++)
        {
            var partResult = new List<string>();
            while (true)
            {
                // save n items
                partResult.Add(input[i]);
                if ((i+1) % size == 0)
                {
                    break;
                }
                i++;
            }
            result.Add(partResult);
        }

        return result;
    }

Your name speaks for itself if i look at the inner loop ;) – Tim Schmelter Dec 11 '14 at 11:10 — Tim Schmelter, Dec 11 '14 at 11:10

Take groups of 5 strings from List

7 Answers7