Проверьте, соответствуют ли значения List <Int32>

List<Int32> dansConList = new List<Int32>();
dansConList[0] = 1;
dansConList[1] = 2;
dansConList[2] = 3;

List<Int32> dansRandomList = new List<Int32>();
dansRandomList[0] = 1;
dansRandomList[1] = 2;
dansRandomList[2] = 4;

Мне нужен метод, который при оценке приведенных выше списков вернет false для dansRandomList и true для dansConList на основе того факта, что dansConList имеет последовательные порядковые номера в нем значения и dansRandomList (отсутствует значение 3).

Использование LINQ является предпочтительным, если это возможно.

Что я пробовал:

Для достижения конечного результата я использовал цикл for и сравнивал с "i" (счетчик циклов) для оценки значений, но, как упоминалось выше, я хотел бы использовать LINQ для этого.

Ответы

Ответ 1

Однострочный, только итерации до первого непоследовательного элемента:

bool isConsecutive = !myIntList.Select((i,j) => i-j).Distinct().Skip(1).Any();

Обновление: несколько примеров того, как это работает:

Input is { 5, 6, 7, 8 }
Select yields { (5-0=)5, (6-1=)5, (7-2=)5, (8-3=)5 }
Distinct yields { 5, (5 not distinct, 5 not distinct, 5 not distinct) }
Skip yields { (5 skipped, nothing left) }
Any returns false

Input is { 1, 2, 6, 7 }
Select yields { (1-0=)1, (2-1=)1, (6-2=)4, (7-3=)4 } *
Distinct yields { 1, (1 not distinct,) 4, (4 not distinct) } *
Skip yields { (1 skipped,) 4 }
Any returns true

* Выбор не даст второй 4, а Distinct не проверяет его, так как Any остановится после поиска первых 4.

Ответ 2

var result = list
    .Zip(list.Skip(1), (l, r) => l + 1 == r)
    .All(t => t);

Ответ 3

var min = list.Min();
var max = list.Max();
var all = Enumerable.Range(min, max - min + 1);
return list.SequenceEqual(all);

Ответ 4

Вы можете использовать этот метод расширения:

public static bool IsConsecutive(this IEnumerable<int> ints )
{
    //if (!ints.Any())
    //    return true; //Is empty consecutive?
    // I think I prefer exception for empty list but I guess it depends
    int start = ints.First();
    return !ints.Where((x, i) => x != i+start).Any();
}

Используйте его следующим образом:

[Test]
public void ConsecutiveTest()
{
    var ints = new List<int> {1, 2, 4};
    bool isConsecutive = ints.IsConsecutive();
}

Ответ 5

Метод расширения:

public static bool IsConsecutive(this IEnumerable<int> myList)
{
    return myList.SequenceEqual(Enumerable.Range(myList.First(), myList.Last()));
}

Useage:

bool isConsecutive = dansRandomList.IsConsecutive();

Ответ 6

Вот еще один. Он поддерживает {1,2,3,4} и {4,3,2,1} оба. Он проверяет разницу в последовательностях, равную 1 или -1.

Function IsConsecutive(ints As IEnumerable(Of Integer)) As Boolean
    If ints.Count > 1 Then
        Return Enumerable.Range(0, ints.Count - 1).
            All(Function(r) ints(r) + 1 = ints(r + 1) OrElse ints(r) - 1 = ints(r + 1))
    End If

    Return False
End Function

Ответ 7

Вот метод расширения, который использует функцию Aggregate.

public static bool IsConsecutive(this List<Int32> value){
    return value.OrderByDescending(c => c)
                .Select(c => c.ToString())
                .Aggregate((current, item) => 
                            (item.ToInt() - current.ToInt() == -1) ? item : ""
                            )
                .Any();
}

Использование:

var consecutive = new List<Int32>(){1,2,3,4}.IsConsecutive(); //true
var unorderedConsecutive = new List<Int32>(){1,4,3,2}.IsConsecutive(); //true
var notConsecutive = new List<Int32>(){1,5,3,4}.IsConsecutive(); //false

Ответ 8

Работает только для уникального списка.

List<Int32> dansConList = new List<Int32>();
dansConList.Add(7);
dansConList.Add(8);
dansConList.Add(9);

bool b = (dansConList.Min() + dansConList.Max())*((decimal)dansConList.Count())/2.0m == dansConList.Sum();

Ответ 9

Caveat: возвращает true, если пусто.

var list = new int[] {-1,0,1,2,3};
var isConsecutive = list.Select((n,index) => n == index+list.ElementAt(0)).All (n => n);

Ответ 10

Вот код версии C, я думаю, что легко переписать его на другом языке на основе логического.

int isConsecutive(int *array, int length) {
     int i = 1;
     for (; i < length; i++) {
          if (array[i] != array[i - 1] + 1)
              return 0; //which means false and it not a consecutive list
     }

     return 1;
}