Fast Sequence checking in a List

Question

I am looking for a faster and more accurate way to check a Sequence:

List<int> sequence = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7 … 41}



private bool IsSequential(List<int> sequence)
{

    int S = sequence[0];
    int T = sequence[sequence.Count- 1];

    List<int> Possible = Enumerable.Range(S, T).ToList();
    List<int> Except = sequence.Except(Possible).ToList();

    if (Except.Count == 0)
        return true;
    else
        return false;
}

My code returns 1 if the list is the same, I have some sort of count issue?

I wonder if there is a better way to check an integer sequence: 200, 201, 202... and so on.

Some Sequences may be out of sequence: 200, 210, 203, 204... I need to identify this issue.

Thanks

How do you define "better"? Faster? Less memory-intensive? Easier to code? Less lines to write? — MakePeaceGreatAgain, Feb 04 '19 at 07:33
Is 202,201,200 also considered sequential? As in, do we need to work out the direction? — ProgrammingLlama, Feb 04 '19 at 07:34
@HimBromBeere - Perhaps a One-Liner in Linq, or a cleaner code implementation, how would you make this better? — Rusty Nail, Feb 04 '19 at 07:35
@John - No, https://www.merriam-webster.com/dictionary/sequential - In sequence, as the integers are counted. — Rusty Nail, Feb 04 '19 at 07:36
I'm not sure why you're pointing me at a dictionary. Is 202, 201, 200 not sequential in a descending order? — ProgrammingLlama, Feb 04 '19 at 07:37
@John - Ascending - See the code in the question for examples. — Rusty Nail, Feb 04 '19 at 07:39
If you want a one-liner, you may want to use `Enumerable.SequenceEqual` **and** `Enumerable.Range`. — mjwills, Feb 04 '19 at 07:39
Have you seen this: https://stackoverflow.com/questions/18225010/functional-way-to-check-if-array-of-numbers-is-sequential — Andreas Gustafsson, Feb 04 '19 at 07:41
Alternatively, use a `for` loop and compare the index (potentially added the initial value) vs the list entry. If they don't match, it isn't sequential. Be sure to test if there is `int.MaxValue` **then** `int.MinValue`. — mjwills, Feb 04 '19 at 07:41
int index = 0; for(int i = 1; i < sequence.Count ; i++, index++) { if(sequence[i] - sequence[index] != 1) return false; } return true; — magicalKhachapuri, Feb 04 '19 at 07:47

score 3 · Accepted Answer · answered Feb 04 '19 at 07:47

3

You can try like following using SequenceEqual.

  List<int> sequence = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7 };
  bool isInSequence = sequence.SequenceEqual(Enumerable.Range(sequence[0], sequence.Count()));

answered Feb 04 '19 at 07:47

PSK

17,547
5
32
43

Can you explain why the use of 'sequence.Count()' is used instead of 'sequence[sequence.Count - 1]' as the last number of the sequence is the last integer? – Rusty Nail Feb 04 '19 at 07:59
1

@RustyNail, it's not the last number, it is the count of numbers to be generated while generating the sequence. – PSK Feb 04 '19 at 08:02

Fast Sequence checking in a List

1 Answers1