❔ LINQ: Group and extract all consecutive elements from List that match predicate

TheHelpfulHelper · 2023-02-21T20:09:15.636Z

Example: ```cs List ints = new() {6,3,1,1,1,1,1,2,7,8,1,1,1,1,3,2,5,1,1,9,8,1,1,1,1,4,7,8,1} var output = ints.GroupConsecutive().Where((g) => g.Key == 1); // Not a real function foreach (var o in output) { Console.WriteLine(o.Count); } ``` Expected output: ``` 5 4 2 4 1 ``` Is there such functionality in LINQ?

T

TheHelpfulHelperOP•2/21/23, 8:15 PM

Any suggestions for a performant implementation?

E

ero•2/21/23, 8:16 PM

Just a for loop, right?

E

ero•2/21/23, 8:16 PM

Or i guess if you need it to work on any ienumerable, a foreach one

A

Angius•2/21/23, 8:17 PM

Or a

foreach

foreach

, will work with any

IEnumerable

IEnumerable

T

TheHelpfulHelperOP•2/21/23, 8:17 PM

I think I'd prefer a solution using LINQ expressions

E

ero•2/21/23, 8:17 PM

Hm?

A

Angius•2/21/23, 8:17 PM

Uh

T

TheHelpfulHelperOP•2/21/23, 8:17 PM

Unless a "manual" loop is unavoidable

A

Angius•2/21/23, 8:17 PM

Write your own, using a loop

T

TheHelpfulHelperOP•2/21/23, 8:17 PM

I was thinking about using GroupBy and somehow combining the value with its index, then working with that

E

ero•2/21/23, 8:18 PM

You mentioned performant

E

ero•2/21/23, 8:18 PM

That will be awful

T

TheHelpfulHelperOP•2/21/23, 8:18 PM

Yeah I suppose a manual foreach is the best then

T

TheHelpfulHelperOP•2/21/23, 8:18 PM

Weird/Sad that there isnt a GroupConsecutive method :/

T

TheHelpfulHelperOP•2/21/23, 8:20 PM

I adjusted my example to better reflect a general solution

T

TheHelpfulHelperOP•2/21/23, 8:22 PM

Yeah having multiple KVP is not good, since they all contain the same Key

T

TheHelpfulHelperOP•2/21/23, 8:22 PM

Would IGrouping be more appropiate?

T

TheHelpfulHelperOP•2/21/23, 8:22 PM

Or maybe a KeyValuePair<T, IReadOnlyList<T>>

T

TheHelpfulHelperOP•2/21/23, 8:23 PM

Yeah

E

ero•2/21/23, 8:24 PM

Wait huh?

E

ero•2/21/23, 8:24 PM

You want the values?

E

ero•2/21/23, 8:24 PM

How does that make sense?

E

ero•2/21/23, 8:24 PM

You already select the value in the call

T

TheHelpfulHelperOP•2/21/23, 8:25 PM

Look at my example.
My supposed "GroupConsecutive" method will give you a List which itself contains Groupings of all the consecutive elements in the given List.

T

TheHelpfulHelperOP•2/21/23, 8:26 PM

Essentially it (as the name implies) groups all the elements which are consecutively equal in the list.

T

TheHelpfulHelperOP•2/21/23, 8:26 PM

So 1,2,3,4 would give you 4 groupings, but 1,2,2,3 would only give you 3, while 1,2,2,3,2 would give you 4 again

E

ero•2/21/23, 8:27 PM

Hm

T

TheHelpfulHelperOP•2/21/23, 8:27 PM

I suppose for simple integers it does not make a lot of sense

T

TheHelpfulHelperOP•2/21/23, 8:27 PM

but I could also imagine needing a ConsecutiveGroupBy method, where the key is chosen from an object

T

TheHelpfulHelperOP•2/21/23, 8:27 PM

Then the grouping would only have that key as the key of the grouping, but the actual elements could be objects

T

TheHelpfulHelperOP•2/21/23, 8:32 PM

Uhh that doesnt compile for me

E

ero•2/21/23, 8:32 PM

Wouldn't it be

<TValue, int>

<TValue, int>

<TValue, int>

<TValue, int>

Original message was deleted

T

TheHelpfulHelperOP•2/21/23, 8:35 PM

Huh seems to be a weird bug with copy and paste...if I manually write the exact same thing out it works.

H

Henkypenky•2/21/23, 8:57 PM

https://stackoverflow.com/questions/20469416/linq-to-find-series-of-consecutive-numbers

H

Henkypenky•2/21/23, 8:58 PM

modify it for consecutive and equal

R

Rotor•2/22/23, 6:53 AM

I'd have called this a folding problem

R

Rotor•2/22/23, 6:54 AM

Presumably you don't actually want to group the values. You just want to see how many of each sequence there are

R

Rotor•2/22/23, 6:54 AM

So why store anything more than the keys and counts?

R

Rotor•2/22/23, 6:57 AM

So you'd use LINQ

Aggregate

Aggregate

Aggregate

Aggregate with a result value that holds a list of tuples representing the key and the count. For each iteration you'd compare the current key with the most recent key in the result value. If the keys are different, push a new tuple onto the result with the new key and a count of zero

R

Rotor•2/22/23, 7:28 AM

static List<T> WhoopsAddReturnsVoid<T>(this List<T> list, T val) {
    list.Add(val);
    return list;
}

var ints = new List<int>{6,3,1,1,1,1,1,2,7,8,1,1,1,1,3,2,5,1,1,9,8,1,1,1,1,4,7,8,1};

var keysAndCounts = ints.Aggregate( 
      (new List<(int, int)>(), (-1,-1)), 
      (carry, current) =>       
          carry switch {                          
              (var result, (-1, -1)) =>
                  (result, (current, 1)),
              (var result, var (key, count)) => 
                  current == key 
                      ? (result, (key, count + 1)) 
                      : (result.WhoopsAddReturnsVoid((key, count)), (current, 1)) 
          }, 
      carry => carry.Item1.WhoopsAddReturnsVoid(carry.Item2));

var all1Counts = keysAndCounts
    .Where(pair => pair.Item1 == 1)
    .Select(pair => pair.Item2);

foreach (var val in all1Counts) {
    Console.WriteLine(val);
}

static List<T> WhoopsAddReturnsVoid<T>(this List<T> list, T val) {
    list.Add(val);
    return list;
}

var ints = new List<int>{6,3,1,1,1,1,1,2,7,8,1,1,1,1,3,2,5,1,1,9,8,1,1,1,1,4,7,8,1};

var keysAndCounts = ints.Aggregate( 
      (new List<(int, int)>(), (-1,-1)), 
      (carry, current) =>       
          carry switch {                          
              (var result, (-1, -1)) =>
                  (result, (current, 1)),
              (var result, var (key, count)) => 
                  current == key 
                      ? (result, (key, count + 1)) 
                      : (result.WhoopsAddReturnsVoid((key, count)), (current, 1)) 
          }, 
      carry => carry.Item1.WhoopsAddReturnsVoid(carry.Item2));

var all1Counts = keysAndCounts
    .Where(pair => pair.Item1 == 1)
    .Select(pair => pair.Item2);

foreach (var val in all1Counts) {
    Console.WriteLine(val);
}

static List<T> WhoopsAddReturnsVoid<T>(this List<T> list, T val) {
    list.Add(val);
    return list;
}

var ints = new List<int>{6,3,1,1,1,1,1,2,7,8,1,1,1,1,3,2,5,1,1,9,8,1,1,1,1,4,7,8,1};

var keysAndCounts = ints.Aggregate( 
      (new List<(int, int)>(), (-1,-1)), 
      (carry, current) =>       
          carry switch {                          
              (var result, (-1, -1)) =>
                  (result, (current, 1)),
              (var result, var (key, count)) => 
                  current == key 
                      ? (result, (key, count + 1)) 
                      : (result.WhoopsAddReturnsVoid((key, count)), (current, 1)) 
          }, 
      carry => carry.Item1.WhoopsAddReturnsVoid(carry.Item2));

var all1Counts = keysAndCounts
    .Where(pair => pair.Item1 == 1)
    .Select(pair => pair.Item2);

foreach (var val in all1Counts) {
    Console.WriteLine(val);
}

static List<T> WhoopsAddReturnsVoid<T>(this List<T> list, T val) {
    list.Add(val);
    return list;
}

var ints = new List<int>{6,3,1,1,1,1,1,2,7,8,1,1,1,1,3,2,5,1,1,9,8,1,1,1,1,4,7,8,1};

var keysAndCounts = ints.Aggregate( 
      (new List<(int, int)>(), (-1,-1)), 
      (carry, current) =>       
          carry switch {                          
              (var result, (-1, -1)) =>
                  (result, (current, 1)),
              (var result, var (key, count)) => 
                  current == key 
                      ? (result, (key, count + 1)) 
                      : (result.WhoopsAddReturnsVoid((key, count)), (current, 1)) 
          }, 
      carry => carry.Item1.WhoopsAddReturnsVoid(carry.Item2));

var all1Counts = keysAndCounts
    .Where(pair => pair.Item1 == 1)
    .Select(pair => pair.Item2);

foreach (var val in all1Counts) {
    Console.WriteLine(val);
}

R

Rotor•2/22/23, 7:29 AM

@TheHelpfulHelper try this

E

ero•2/22/23, 8:34 AM

yeah but who would want to use that

E

ero•2/22/23, 8:34 AM

that's incredibly unreadable

E

ero•2/22/23, 8:39 AM

also what's with those

-1

-1

s?

R

Rotor•2/22/23, 9:17 AM

It's because C# isn't bundled with a

maybe

maybe

maybe

maybe type

R

Rotor•2/22/23, 9:17 AM

And everybody knows that readability is subjective

R

Rotor•2/22/23, 9:21 AM

The reason I like this solution is that it's performant and that any mistake you make will lead to a compiler error. I agree it should be pulled into its own declaration rather than as a big inline blob though

RRotor It's because C# isn't bundled with a `maybe` type