Question

我想知道数组中有多少值是按顺序排列的。

对于实例，如果我有。

int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 9 } //0, 1, 2, 3, 4, 5, 6 are in sequence
int value = HighestSequence(arr);
//value prints 7

int[] arr = new int[] { 0, 4, 1, 2, 3, 4, 7, 9 } //1, 2, 3, 4 are in sequence
int value = HighestSequence(arr);
//value prints 4

int[] arr = new int[] { 0, 1, 2 } //0, 1, 2 is in sequence
int value = HighestSequence(arr);
//value prints 3

Answer 1

如果订单中有多个子序列，您没有说明会发生什么，但我认为只会有一个。

试试这个：

int length = 1;
int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 9 }; //0, 1, 2, 3, 4, 5, 6 are in sequence
//value prints 7
List<int> temp = arr.Zip(arr.Skip(1), (i1, i2) => length += (i2 - i1 == 1 ? 1 : 0)).ToList();

Length将包含序列中的整数数，其中arr [n] == arr [n + 1] - 1

干杯

编辑：

如果有多个子序列被排序，使得arr [n] == arr [n + 1] - 1，我们需要决定如何处理它。

当我们找到一个不符合标准的值时，一种方法是重置长度：

arr = new int[] { 0, 1, 2, 5, 4, 5, 6, 9 }; //Possible bug ?
length = 1;
temp = arr.Zip(arr.Skip(1), (i1, i2) =>
{
    if(i2 - i1 == 1)
    {
        length++;
    }
    else
    {
        length = 1;
    }
    return i1;
}).ToList();

然而，这不会考虑最长的＆＃34;子序列，它将返回＆＃34; last＆＃34;的长度。序列中的后续序列。

OP应该在这种情况下指定他想要的行动。

编辑＃2：

如果我们想要最长的子序列，那么可以使用它：

arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 5, 4, 5, 6, 7, 9 }; //Possible bug ?
length = 1;
int longest = length;
temp = arr.Zip(arr.Skip(1), (i1, i2) =>
{
    if (i2 - i1 == 1)
    {
        if (++length > longest)
            longest = length;
    }
    else
    {
        length = 1;
    }
    return i1;
}).ToList();

缓存最长的有序子序列长度。然后使用longest代替length作为结果。

编辑＃3：

编辑＃1＆amp; 2现在应该包含适当的解决方案。我显然试图用太快的方式提出用户评论的解决方案而且我没有意识到我的VS解决方案中的当前代码与我在此处发布的代码不同。

值得一提的是，OP并没有那些额外的限制，而且我确实提到了我的解决方案并没有解决这些额外的限制。

尽管如此，这是一个有趣的问题需要解决; - ）

干杯

Answer 2

试一试。我得到了（7,4,3）的结果。虽然彼得对StackOverflow是正确的，但您应该尝试并说出您的问题而不仅仅是要求答案。我只是提供它，因为这是一个很好的挑战。

var set1 = new [] { 0, 1, 2, 3, 4, 5, 6, 9 }; 
var result1 = HighestSequence(set1);

var set2 = new[] { 0, 4, 1, 2, 3, 4, 7, 9 };
var result2 = HighestSequence(set2);

var set3 = new [] { 0, 1, 2 };
var result3 = HighestSequence(set3);

public int HighestSequence(int[] values)
{
    IList<int> sequenceCounts = new List<int>();

    var currentSequence = 0;
    for (var i = 0; i < values.Length; i++)
    {
        if (i == (values.Length - 1)) //End edge case
        {
            if (values[i] - values[i - 1] == 1)
            {
                currentSequence++;
                sequenceCounts.Add(currentSequence);
            }
        }
        else if ((values[i] + 1) == values[i + 1])
        {
            currentSequence++;
        }
        else
        {
            currentSequence++;
            sequenceCounts.Add(currentSequence);
            currentSequence = 0;
            continue;
        }
        sequenceCounts.Add(currentSequence);
    }
    return sequenceCounts.Max();
}

数组中依次有多少个值

2 个答案: