可以使用 LINQ 查找排序列表中的空白吗？

Question

我是否有可能以一种允许我确定“9”的方式使用 LINQ 是排序列表中的第一个缺失值，而不使用 for 循环并将每个值与其相邻的值进行比较？

var listStringVals = new [] { "7", "13", "8", "12", "10", "11", "14" };
// sort list to "7","8","10","11","12","13","14"
var sortedList = listStringVals.OrderBy(c => int.Parse(c)).ToList();
// need some magic here to get the first gap in the sorted list

Answer 1

让

var strings = new string[] { "7", "13", "8", "12", "10", "11", "14" };

然后

var list = Array.ConvertAll(strings, s => Int32.Parse(s)).OrderBy(i => i);
// or
var list = strings.Select(s => int.Parse(s)).OrderBy(i => i);
// or
var list = strings.OrderBy(s => int.Parse(s));

（注意this问题）

然后

var result = Enumerable.Range(list.Min(), list.Count).Except(list).First(); // 9
// or
int min = list.Min(), max = list.Max();
var result = Enumerable.Range(min, max - min + 1).Except(list).First();

Answer 2

这是一种让您入门的方法（我在这里使用了int 值）：

List<int> listStringVals = (new int[] { 7, 13, 8, 12, 10, 11, 14 }).ToList();
List<int> SortedList = listStringVals.OrderBy(c => c).ToList();
List<int> Gaps = Enumerable.Range(SortedList.First(), 
                                  SortedList.Last() - SortedList.First() + 1)
                           .Except(SortedList).ToList();

Answer 3

var listStringVals = new string[] {"7", "13", "8", "12", "10", "11", "14"};
var sortedInts = listStringVals.Select(c => int.Parse(c)).OrderBy(x => x);
var noGaps = Enumerable.Range(sortedInts.First(), 
                              sortedInts.Last() - sortedInts.First() + 1);
var missing = noGaps.Except(sortedInts).Select(x => x.ToString()).First();

编辑：通过BeemerGuy's answer 生成固定范围。仍然离开我的，因为它不会忽略 string 表示 ints 的列表的丑陋 :)

Answer 4

（abatishchev 击败了我，但他的答案还是更好。但是，由于同一问题的替代解决方案可能很有趣，所以我仍然发布此内容。）

Hackity 黑客攻击。但是工作，如果你真的想要这样做。性能会很糟糕，因为这种技术在找到答案时不会停止——它总是会遍历每个数字！但它会起作用：

public static int FindFirstMissing(IEnumerable<int> sequence)
{
    bool found = false;

    int agg = sequence.Aggregate((aggregate, next) => {
        if (found)
            return aggregate;

        if (next - aggregate != 1) {
            found = true;
            return aggregate + 1;
        }

        return next;
    });

    if (!found)
        throw new ArgumentException("sequence", "Contains no missing numbers.");

    return agg;
}

Answer 5

string firstGap = sortedList
    .Zip(sortedList.Skip(1), (f, s) => Tuple.Create(f, s))
    .First(tup => (int.Parse(tup.Item1) + 1) != int.Parse(tup.Item2)).Item1;

应该给你第一个gap之前的第一个item，所以第一个缺失的元素是：

string gap = (int.Parse(firstGap) + 1).ToString();

Answer 6

有点晚了，但我认为这是一种很酷的方式：

List<int> listStringVals = (new int[] { 7, 13, 8, 12, 10, 11, 14 }).ToList();
            listStringVals.Sort();
            return listStringVals.Skip(1).Select((x, i) => x - listStringVals[i] == 1).Any(x => !x);

Answer 7

为什么不直接使用All，因为集合中的所有成员都需要符合标准...

例子

someVar.All(v => someVar.Contains(v + 1) || v == someVar.Last())

那么您不必订购，而且更好。

如果需要，您可以在此步骤之后或什至在此期间进行排序，但我个人只会使用排序后的集合并让它为我完成这项工作。

如果需要，您可以在检查后获取值，然后返回检查结果，或者如果您出于某种原因想要通过上面的多行修改以及存储值的列表来隐藏它。

例如

someVar.All((v) => { 
    bool result = someVar.Contains(v + 1) || v == someVar.Last();
    if(!result) someList.Add(v);
    return true;
});

检查列表（可以排序）的计数是否为非零值，以指示它是否满足。