I'm interested if there is a way, in LINQ, to check if all numbers in a list are increasing monotonically?
Example
List<double> list1 = new List<double>() { 1, 2, 3, 4 };
Debug.Assert(list1.IsIncreasingMonotonically() == true);
List<double> list2 = new List<double>() { 1, 2, 100, -5 };
Debug.Assert(list2.IsIncreasingMonotonically() == false);
The reason I ask is that I would like to know the technique to compare an element in a list against its previous element, which is something I've never understood when using LINQ.
Finished Example Class in C#
As per official answer from @Servy
below, here is the complete class I am now using. It adds extension methods to your project to check if a list is increasing/decreasing either monotonically, or strictly monotonically. I'm trying to get used to a functional programming style, and this is a good way to learn.
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MyHelper
{
/// <summary>
/// Classes to check if a list is increasing or decreasing monotonically. See:
/// http://stackoverflow.com/questions/14815356/is-it-possible-to-use-linq-to-check-if-all-numbers-in-a-list-are-increasing-mono#14815511
/// Note the difference between strictly monotonic and monotonic, see:
/// http://en.wikipedia.org/wiki/Monotonic_function
/// </summary>
public static class IsMonotonic
{
/// <summary>
/// Returns true if the elements in the are increasing monotonically.
/// </summary>
/// <typeparam name="T">Type of elements in the list.</typeparam>
/// <param name="list">List we are interested in.</param>
/// <returns>True if all of the the elements in the list are increasing monotonically.</returns>
public static bool IsIncreasingMonotonically<T>(this List<T> list) where T : IComparable
{
return list.Zip(list.Skip(1), (a, b) => a.CompareTo(b) <= 0).All(b => b);
}
/// <summary>
/// Returns true if the elements in the are increasing strictly monotonically.
/// </summary>
/// <typeparam name="T">Type of elements in the list.</typeparam>
/// <param name="list">List we are interested in.</param>
/// <returns>True if all of the the elements in the list are increasing monotonically.</returns>
public static bool IsIncreasingStrictlyMonotonically<T>(this List<T> list) where T : IComparable
{
return list.Zip(list.Skip(1), (a, b) => a.CompareTo(b) < 0).All(b => b);
}
/// <summary>
/// Returns true if the elements in the are decreasing monotonically.
/// </summary>
/// <typeparam name="T">Type of elements in the list.</typeparam>
/// <param name="list">List we are interested in.</param>
/// <returns>True if all of the the elements in the list are decreasing monotonically.</returns>
public static bool IsDecreasingMonotonically<T>(this List<T> list) where T : IComparable
{
return list.Zip(list.Skip(1), (a, b) => a.CompareTo(b) >= 0).All(b => b);
}
/// <summary>
/// Returns true if the elements in the are decreasing strictly monotonically.
/// </summary>
/// <typeparam name="T">Type of elements in the list.</typeparam>
/// <param name="list">List we are interested in.</param>
/// <returns>True if all of the the elements in the list are decreasing strictly monotonically.</returns>
public static bool IsDecreasingStrictlyMonotonically<T>(this List<T> list) where T : IComparable
{
return list.Zip(list.Skip(1), (a, b) => a.CompareTo(b) > 0).All(b => b);
}
/// <summary>
/// Returns true if the elements in the are increasing monotonically.
/// </summary>
/// <typeparam name="T">Type of elements in the list.</typeparam>
/// <param name="list">List we are interested in.</param>
/// <returns>True if all of the the elements in the list are increasing monotonically.</returns>
public static bool IsIncreasingMonotonicallyBy<T>(this List<T> list, Func<T> x) where T : IComparable
{
return list.Zip(list.Skip(1), (a, b) => a.CompareTo(b) <= 0).All(b => b);
}
public static void UnitTest()
{
{
List<double> list = new List<double>() { 1, 2, 3, 4 };
Debug.Assert(list.IsIncreasingMonotonically<double>() == true);
Debug.Assert(list.IsIncreasingStrictlyMonotonically<double>() == true);
Debug.Assert(list.IsDecreasingMonotonically<double>() == false);
Debug.Assert(list.IsDecreasingStrictlyMonotonically<double>() == false);
}
{
List<double> list = new List<double>() { 1, 2, 100, -5 };
Debug.Assert(list.IsIncreasingMonotonically() == false);
Debug.Assert(list.IsIncreasingStrictlyMonotonically() == false);
Debug.Assert(list.IsDecreasingMonotonically() == false);
Debug.Assert(list.IsDecreasingStrictlyMonotonically() == false);
}
{
List<double> list = new List<double>() {1, 1, 2, 2, 3, 3, 4, 4};
Debug.Assert(list.IsIncreasingMonotonically() == true);
Debug.Assert(list.IsIncreasingStrictlyMonotonically<double>() == false);
Debug.Assert(list.IsDecreasingMonotonically() == false);
Debug.Assert(list.IsDecreasingStrictlyMonotonically() == false);
}
{
List<double> list = new List<double>() { 4, 3, 2, 1 };
Debug.Assert(list.IsIncreasingMonotonically() == false);
Debug.Assert(list.IsIncreasingStrictlyMonotonically<double>() == false);
Debug.Assert(list.IsDecreasingMonotonically() == true);
Debug.Assert(list.IsDecreasingStrictlyMonotonically() == true);
}
{
List<double> list = new List<double>() { 4, 4, 3, 3, 2, 2, 1, 1 };
Debug.Assert(list.IsIncreasingMonotonically() == false);
Debug.Assert(list.IsIncreasingStrictlyMonotonically<double>() == false);
Debug.Assert(list.IsDecreasingMonotonically() == true);
Debug.Assert(list.IsDecreasingStrictlyMonotonically() == false);
}
}
}
}
Would you not order the list using OrderBy()
and compare them against the original? If they are the same then it will give your your answer pseudo speaking:
var increasing = orignalList.OrderBy(m=>m.value1).ToList();
var decreasing = orignalList.OrderByDescending(m=>m.value1).ToList();
var mono = (originalList == increasing || originalList == decreasing)
Here is a one-liner that will work:
var isIncreasing = list.OrderBy(x => x).SequenceEqual(list);
Or if you're going for performance, here is a one-liner that will only traverse the list once, and quits as soon as it reaches an element out of sequence:
var isIncreasing = !list.SkipWhile((x, i) => i == 0 || list[i - 1] <= x).Any();
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With