C# 获取整数列表中的最小可用数

如何使用LINQ获得整数列表中的最小可用数？数字不能小于10

List<int> numbers = new List<int>() { 10, 11, 12, 22, 23 };

List number=newlist（）{10,11,12,22,23}；

在这种情况下，我想返回13

List<int> numbers1 = new List<int>() { 11, 12, 22, 23 };

List numbers1=newlist（）{11,12,22,23}；

在这种情况下，我想返回10

我如何使用LINQ呢？

我会使用这个：

List<int> numbers = new List<int>() { 11, 12, 22, 23 };

int result = Enumerable.Range(10, numbers.Count + 1).First(x => !numbers.Contains(x));

List number=newlist（）{11,12,22,23}；
int result=Enumerable.Range（10，numbers.Count+1）.First（x=>！numbers.Contains（x））；

使用

numbers.Count+1

处理

List number=new List（）{10,11,12,13,14,15}的情况
我会用这个：

List<int> numbers = new List<int>() { 11, 12, 22, 23 };

int result = Enumerable.Range(10, numbers.Count + 1).First(x => !numbers.Contains(x));

List number=newlist（）{11,12,22,23}；
int result=Enumerable.Range（10，numbers.Count+1）.First（x=>！numbers.Contains（x））；

使用
numbers.Count+1
处理
List number=new List（）{10,11,12,13,14,15}的情况
如果输入列表总是排序的，您可以利用这一点进行简单的线性搜索：

List<int> numbers = new List<int>() { 11, 12, 13, 14 };
int result = numbers
    .Zip(
        numbers.Skip(1).Concat(new[] { int.MaxValue }),
        (a, b) => (next: a+1, b))
    .FirstOrDefault(x => x.next != x.b)
    .next;

List number=newlist（）{11,12,13,14}；
int结果=数字
Zip先生(
numbers.Skip（1）.Concat（新[]{int.MaxValue}），
（a，b）=>（下一步：a+1，b））
.FirstOrDefault（x=>x.next！=x.b）
下一个

这比@Enigmativity的解决方案更难看，但它具有线性而非二次的优点，如果数字列表很大，这将产生影响

就我个人而言，我只是把它写成一个廉价的线性for循环：

for (int i = 0; i < numbers.Count - 1; i++)
{
    int next = numbers[i] + 1;
    if (next != numbers[i + 1])
    {
        return next;
    }
}
return numbers[numbers.Count - 1] + 1;

for（int i=0；i
如果输入列表总是排序的，您可以利用这一点进行简单的线性搜索：

List<int> numbers = new List<int>() { 11, 12, 13, 14 };
int result = numbers
    .Zip(
        numbers.Skip(1).Concat(new[] { int.MaxValue }),
        (a, b) => (next: a+1, b))
    .FirstOrDefault(x => x.next != x.b)
    .next;

List number=newlist（）{11,12,13,14}；
int结果=数字
Zip先生(
numbers.Skip（1）.Concat（新[]{int.MaxValue}），
（a，b）=>（下一步：a+1，b））
.FirstOrDefault（x=>x.next！=x.b）
下一个

这比@Enigmativity的解决方案更难看，但它具有线性而非二次的优点，如果数字列表很大，这将产生影响

就我个人而言，我只是把它写成一个廉价的线性for循环：

for (int i = 0; i < numbers.Count - 1; i++)
{
    int next = numbers[i] + 1;
    if (next != numbers[i + 1])
    {
        return next;
    }
}
return numbers[numbers.Count - 1] + 1;

for（int i=0；i
请注意，这是二次曲线。如果代码>数字< /代码>很小，但如果大的话，你会注意到它的减速。@ Chanto7-我确实考虑过了，但是我觉得我们不太可能处理一个足够大的列表使它成为一个问题。我最初考虑过使用<代码>哈什集，但我觉得计算它的时间可能比单一的部分搜索更重要。既然OP的列表都在增加，那么简单的二进制搜索可能是最好的。我完全同意。我只是想强调一下，以防有人遇到类似的问题，但有更多的数字。注意，这是二次的。如果代码>数字< /代码>很小，但如果大的话，你会注意到它的减速。@ Chanto7-我确实考虑过了，但是我觉得我们不太可能处理一个足够大的列表使它成为一个问题。我最初考虑过使用<代码>哈什集，但我觉得计算它的时间可能比单一的部分搜索更重要。既然OP的列表都在增加，那么简单的二进制搜索可能是最好的。我完全同意。只是想强调一下，以防有人遇到类似的问题，但有更多的人遇到。