Question

我想创建一个像这样的扩展方法

public static bool AllConsecutives(this IEnumerable<int> intValues )

如果列表中的所有项目都是连续的（没有间隙），则此方法应返回true

一些测试用例

(new List<int>() {2, 3, 4, 5, 6}).AllConsecutives() == true
(new List<int>() {3, 7, 4, 5, 6}).AllConsecutives() == true //as it is not sensitive to list order
(new List<int>() {2, 3, 4, 7, 6}).AllConsecutives() == false //as the five is missing

Answer 1

int expected = intValues.Min();
foreach(int actual in intValues.OrderBy(x => x))
{
    if (actual != expected++)
       return false;
}

return true;

您还可以在执行Min之前验证该集合是否至少包含一个项目。或者您可以在取得min之前对项目进行排序（在这种情况下，如果集合为空，它将是第一个，或者不是任何一个）。同样在这种情况下，您将保存一次迭代以找到最小值：

var sortedValues = intValues.OrderBy(x => x);
int expected = sortedValues.FirstOrDefault();

foreach (int actual in sortedValues)
{
    if (actual != expected++)
        return false;
}

return true;

Answer 2

如果列表不包含重复项并且最大值之间存在差异，则该列表是连续的。和分钟。值等于列表中的项目数减1，所以：

public static bool AllConsecutives(this IEnumerable<int> intValues) 
{
   int minValue = Int32.MaxValue;
   int maxValue = Int32.MinValue;
   int count = 0;
   HashSet<int> values = new HashSet<int>();
   foreach (int intValue in intValues) {
     if (values.Contains(intValue))         
       return false;
     values.Add(intValue);
     if (intValue > maxValue)
       maxValue = intValue;
     if (intValue < minValue)
       minValue = intValue;
     count++;
   }
   return (count == 0) || (maxValue-minValue+1 == count);
}

Answer 3

尝试并且似乎使用给定的示例

public static bool AllConsecutives(this IEnumerable<int> intValues ) 
{
    var ord = intValues.OrderBy(i => i);
    int curV = ord.Min();
    foreach(int x in ord)
    {
        if(x != curV)
           return false;
        curV++;
    }
    return true;
}

Answer 4

这样的事情：

if (intValues.Count() <= 1)
                return true;

var ordered = intValues.OrderBy(i => i).ToList();

return (ordered.First() + ordered.Count() - 1) == ordered.Last();

Answer 5

检查并使用Linq时出错：

 public static class myExtension
{

   public static bool AllConsecutives(this IEnumerable<int> targetList)
   {
      bool result = false;

      if ((targetList != null) && (targetList.Any ()))
      {
         var ordered = targetList.OrderBy (l => l);

         int first = ordered.First ();

         result = ordered.All (item => item == first++);

      }

      return result;

   }

}

// tested with

void Main()
{
 Console.WriteLine ( (new List<int>() {2, 3, 4, 5, 6}).AllConsecutives() ); // true
 Console.WriteLine ( (new List<int>() {3, 7, 4, 5, 6}).AllConsecutives() ); // true //as it is not sensitive to list order
 Console.WriteLine ( (new List<int>() {2, 3, 4, 7, 6}).AllConsecutives() ); // false //as the five is missing
}

Answer 6

list.Sort();
return !list.Skip(1).Where((i, j) => (i != (list[j] + 1))).Any();

Answer 7

另一种不需要排序的可能解决方案是使用hashset，并且在构建hashset时可以保存min值。这样运行时间将为O（n）。这不会处理重复值，您可以在构建hashset时添加一个检查，并查看hashset是否已包含该值。

HashSet<int> hash = new HashSet<int>();
int minValue = int.MaxValue;
foreach(int i in list)
{
    if(minValue > i)
        minValue = i;
        hash.Add(i);
}

for(int count = 1; count < list.Count; ++count)
{
    if(!hash.Contains(++minValue))
        return false;

}
return true;

List <int> </int>中的所有连续

7 个答案: