c# - 名单上的所有接班人

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

如果列表不包含重复项和最大值之间的差异，则该列表是连续的。和分钟。values 等于列表中的项目数减一，因此：

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

错误检查和使用 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 5

像这样的东西：

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

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

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

Answer 6

另一种不需要排序的可能解决方案是使用哈希集，在构建哈希集时，您可以保存最小值。这样，运行时间将为 O(n)。这不会处理重复值，您可以在构建哈希集时添加检查并查看哈希集是否已经包含该值。

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;

Answer 7

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