Question

我有以下列表：

List<int> days = new List<int> { 1, 4, 5, 6, 7, 8, 20, 24, 25, 26, 30 };

我想获得最长序列的起始和结束编号。对于上面的例子，我应该得到（4,8）。如果两个序列的长度相同，我想要第一个。

注意：列表将始终按递增顺序排列数字。

到目前为止，我已经尝试过这个：

List<Tuple<int, int>> seqs = new List<Tuple<int, int>>();
int _start = 0;
for (int i = 0; i <= days.Count; i++)
{
    if (i == 0)
    {
        _start = days[i];
        continue;
    }

    if (i < days.Count)
    {
        if (days[i] == days[i - 1] + 1)
            continue;
        else
        {
            seqs.Add(new Tuple<int, int>(_start, days[i - 1]));
            _start = days[i];
        }
    }
    else
    {
        seqs.Add(new Tuple<int, int>(_start, days[i - 1]));
    }
}

var largestSeq = seqs
      .OrderByDescending(s => s.Item2 - s.Item1)
      .FirstOrDefault();

Answer 1

此解决方案较短但使用副作用，因此无法并行化：

var days = new List<int> { 1, 4, 5, 6, 7, 8, 20, 24, 25, 26, 30 };

var groupNumber = 0;
var longestGroup = days
    .Select((x, i) => new
                        {
                            Item = x,
                            Index = i
                        })
    .GroupBy(x => x.Index == 0 || x.Item - days[x.Index - 1] == 1
        ? groupNumber :
        ++groupNumber)
    .OrderByDescending(x => x.Count())
    .First()
    .Select(x => x.Item)
    .ToArray();

Console.WriteLine(longestGroup.First()+", "+longestGroup.Last());

输出：

4, 8

此版本不使用副作用：

var days = new List<int> { 1, 4, 5, 6, 7, 8, 20, 24, 25, 26, 30 };

var groupEnds = days
    .Select((x, i) => new
    {
        Item = x,
        Index = i
    })
    .Where(x => x.Index > 0)
    .Where(x => x.Item - days[x.Index - 1] > 1)
    .Select(x => x.Index)
    .Concat(new[]{days.Count})
    .ToArray();

var groupBounds =
    new[]{new{First=0,Last=groupEnds[0]-1}}
    .Concat(groupEnds
        .Select((x,i) => new{Item=x,Index=i})
        .Where(x => x.Index > 0)
        .Select(x => new{First=groupEnds[x.Index-1],Last=x.Item-1})
        )
    .ToArray();

var longestGroup = groupBounds
    .OrderByDescending(x => x.Last - x.First)
    .First();

Console.WriteLine(days[longestGroup.First] + ", " + days[longestGroup.Last]);

输出：

4, 8

Answer 2

我的版本，看起来与@ Gurgadurgen非常相似。

List<int> days = new List<int> { 1, 4, 5, 6, 7, 8, 20, 24, 25, 26, 30 };           

int longestSequenceLength = 0;
int startIndexOfLongestSequence = 0;
int currentSequenceLength = 0;
int currentStartSequenceIndex = 0;

for (int i = 0; i < days.Count; i++) {
    if (i == 0 || days[i] != days[i - 1] + 1) {
        currentSequenceLength = 1;
        currentStartSequenceIndex = i;
    }
    else {
        currentSequenceLength++;
    }

    if (currentSequenceLength > longestSequenceLength) {
        longestSequenceLength = currentSequenceLength;
        startIndexOfLongestSequence = currentStartSequenceIndex;
    }
}

Console.WriteLine(string.Join(",",days.Skip(startIndexOfLongestSequence)
   .Take(longestSequenceLength)));

Answer 3

int longestSeqStart = days[0];
int longestSeqEnd = days[0];
int curSeqStart = days[0];
int curSeqEnd = days[0];
int lastVal = days[0];
for(int i = 1; i < days.Count(); i++)
{
    if(days[i] == lastVal + 1)
    {
        curSeqEnd = days[i];
        if(curSeqEnd - curSeqStart > longestSeqEnd - longestSeqStart )
        {
            longestSeqStart = curSeqStart;
            longestSeqEnd = curSeqEnd;
        }
    }
    else
    {
        curSeqStart = curSeqEnd = days[i];
    }
    lastVal = days[i];
}

Haven没有对它进行过测试，但我已经盯着它看了五分钟，看起来很不错。我将在ideone中运行一些测试并返回编辑它们：P

[编辑]经过测试，确实有效。对于整数列表，＆＃34;天＆＃34;

{1,2,3,4,5,12,13,14,15,16,17,18,2,3,4,5}

它吐出12-18，这是正确的答案。我发布Ideone link here。

[编辑2]请注意，这几乎没有优化，并且可以（并且应该）在实际代码中使用之前进一步降低。例如，我只是在写完之后意识到＆＃34; lastVal＆＃34;实际上甚至不需要，因为我们可以检查＆＃34;天＆＃34;的价值。在最后一个索引（i-1）。

这应该只是解决问题的逻辑基础，在这里。不是最终解决方案。

在List <int> </int>中找到最长的序列

3 个答案: