Linq expression to validate if list is ordered ascending or descending

Question

I have a IEnumerable<DateTime> var that I need to validate if it is sorted ascendingly or descendingly.

I can do this using a for loop but is there a way to do this using LINQ expression?

Answer 1

Ascending:

myEnumerable.Zip(myEnumerable.Skip(1), (curr, next) => curr <= next).All(x => x);

Descending:

myEnumerable.Zip(myEnumerable.Skip(1), (curr, next) => curr >= next).All(x => x);

But use a loop, LINQ is not a magic solution to everything.

Answer 2

var orderedByAsc = input.OrderBy(d => d);
if (input.SequenceEqual(orderedByAsc))
{
    Console.WriteLine("Ordered by Asc");
    return;
}

var orderedByDsc = input.OrderByDescending(d => d);
if (input.SequenceEqual(orderedByDsc))
{
    Console.WriteLine("Ordered by Dsc");
    return;
}

Console.WriteLine("not sorted");

Answer 3

LINQ extensions. Good candidates to MoreLinq library:

public static bool IsOrdered<T>(this IEnumerable<T> source, IComparer<T> comparer = null)
{
    return source.IsOrdered(OrderByDirection.Ascending, comparer);
}

public static bool IsOrdered<T>(this IEnumerable<T> source, OrderByDirection direction, IComparer<T> comparer = null)
{
    if (source == null)
    {
        throw new ArgumentNullException(nameof(source));
    }

    if (comparer == null)
    {
        comparer = Comparer<T>.Default;
    }

    int d = direction == OrderByDirection.Ascending ? 1 : -1;

    Func<T, T, int> compareFunc= (i1, i2) => d * comparer.Compare(i1, i2);
    return IsOrderedImpl(source, compareFunc);
}

public static bool IsOrdered<T>(this IEnumerable<T> source, Func<T, T, int> compareFunc)
{
    if (source == null)
    {
        throw new ArgumentNullException(nameof(source));
    }
    if (compareFunc == null)
    {
        throw new ArgumentNullException(nameof(compareFunc));
    }

    return IsOrderedImpl(source, compareFunc);
}

private static bool IsOrderedImpl<T>(this IEnumerable<T> source, Func<T, T, int> compareFunc)
{
    T prevItem = default(T);
    int i = 0;
    foreach (T item in source)
    {
        if (i == 0)
        {
            prevItem = item;
        }
        else
        {
            if (compareFunc(prevItem, item) > 0)
            {
                return false;
            }

            prevItem = item;
        }

        ++i;
    }

    return true;
}

[TestMethod]
public void TestIsOrdered01()
{
    Assert.IsTrue(Enumerable.Range(1, 10).IsOrdered());
    Assert.IsFalse(Enumerable.Range(1, 10).Reverse().IsOrdered());
    Assert.IsTrue(Enumerable.Range(1, 10).IsOrdered(OrderByDirection.Ascending));
    Assert.IsFalse(Enumerable.Range(1, 10).IsOrdered(OrderByDirection.Descending));
    Assert.IsFalse(Enumerable.Range(1, 10).Reverse().IsOrdered(OrderByDirection.Ascending));
    Assert.IsTrue(Enumerable.Range(1, 10).Reverse().IsOrdered(OrderByDirection.Descending));
}