根据编号拆分字符串列表

Question

I have several numbered lists stored in a List<string> :

List<string> all = new List<string>()
{
  "1. Apple",
  "2. Banana",
  "3. Coconut",
  "1. Ant",
  "2. Beaver",
  "3. Cat"
  ...
}

I want to split this list into a list of lists where each list contains 1-3.

List<List<string>> split = new List<List<string>>()
{
  new List<string>() { "1. Apple", "2. Banana", "3. Coconut"},
  new List<string>() { "1. Ant", "2. Beaver", "3. Cat"}
}

There will ALWAYS be "1." so I can use that as my delimiter. Is there a slick way to do this with LINQ without needing two nested for loops?

Update: I'd like this to be generalized for any length, not always 3.

Answer 1

Sounds like you could use the dictionary type instead. Rather than storing the number of the item and the item itself, you can set the item number as the key and the item itself as the value. Here is an example of how you might accomplish that:

newList = {'1':'Apple','2':'Banana','3':'Pear'}  
animalList = {'1':'Bear','2':'Cat','3':'Dog'}

You can iterate through each item, or use a method to call by keys or values.

Answer 2

List<List<string>> result = all.GroupAdjacent((g, x) => !x.StartsWith("1."))
                               .Select(g => g.ToList())
                               .ToList();

using the GroupAdjacent Extension Method from here .

Answer 3

Just another option to get desired result (assign group index to each item in sequence, then group by that index):

int groupIndex = 0;
List<List<string>> split = all.Select(s => {
                                   if (s.StartsWith("1."))
                                      groupIndex++;
                                   return new { groupIndex, s }; })
                              .GroupBy(x => x.groupIndex)
                              .Select(g => g.Select(x => x.s).ToList())
                              .ToList();

---

Another option - accumulate results (this will require one traverse over the list)

List<List<string>> split =
    all.Aggregate(new List<List<string>>(), (acc, s) =>
                    { 
                        if (s.StartsWith("1."))
                            acc.Add(new List<string>());
                        acc[acc.Count - 1].Add(s);
                        return acc; 
                    });  

Answer 4

There's not really a slick way of doing this using LINQ without making a bunch of assumptions about the list, and the only guaranteed bit of information that you've given us is "there will always be a 1." . Will there always be groups of 3 items, or will there sometimes be more or less?

Why not change the way the strings are stored to begin with - use a List<List<string>> instead, so you have a List of List<string> ?