Question

I am currently using a normal looping to check if the list of numbers are in order.

I am currently learning LINQ and I want to know how can I implement in LINQ to check if the sequence of numbers are in correct order.

For example I have this list of sequence number:

1.0
1.1
1.2
1.4
2.0

The program needs to flag as error the line 1.4 because 1.3 is missing.

How can I achieve that using LINQ?

Thanks for all your help. 🙂

It’s like table of contents:

1.1 followed by 1.3 is invalid, 1 followed by 2 is valid. 1.4 followed by 2 is valid.

Here’s the code that I am using it still has a lot of lapses I think:

using (System.IO.StreamReader reader = new System.IO.StreamReader("D:\\test.txt"))
{
    double prevNumber = 0;

    while (reader.Peek() >= 0)
    {
        double curNumber = double.Parse(reader.ReadLine());
        double x = Math.Round(curNumber - prevNumber, 1);

        if (x == 0.1)
        {
            prevNumber = curNumber;
        }

        else
        {
            int prev = (int)Math.Floor(prevNumber);
            int cur = (int)Math.Floor(curNumber);

            if ((cur - prev) == 1)
            {
                prevNumber = curNumber;
            }
            else
            {
                //error found
            }
        }
    }
}

Answer 1

This method takes a filename and returns an array of line numbers of incorrect versions. For your example it returns { 4 }.

It only handles numbers of the form x.y, as that appears to be all you want it to handle.

static int[] IncorrectLines(string filename)
{
    // Parse the file into an array of ints, 10* each version number.
    var ints =  File.ReadLines(filename)
        .Select(s => (int)(10 * decimal.Parse(s))).ToArray();
    // Pair each number up with the previous one.
    var pairs = ints
        .Zip(ints.Skip(1), (p, c) => new { Current = c, Previous = p });
    // Include the line numbers
    var withLineNos = pairs
        .Select((pair, index) => new { Pair = pair, LineNo = index + 2 });
    // Only keep incorrect lines
    var incorrect = withLineNos.Where(o => ! (         // not one of either:
            o.Pair.Current - 1 == o.Pair.Previous ||   // simple increment
            (o.Pair.Current % 10 == 0 &&               // major increment
             (o.Pair.Current / 10) - 1 == o.Pair.Previous / 10)
        ));
    return incorrect.Select(o => o.LineNo).ToArray();
}

Honestly? I think you’re better off with a loop.