编写一个程序，找出数组中连续相等元素的最大序列。c#

提示是查找数组中连续相等元素的最大序列。我不知道我做错了什么，但我无法得到正确的结果也许问题在于我对第二个循环的迭代方式

class Class2
{
    static void Main(string[] args)
    {
        int pos=0, bestpos=0, bestlen = 0;
        int len = 1;
        int[] vargu = { 2, 2, 3, 4, 5, 5, 5, 6, 9, 9, 9, 9 };

        for(int i = 0; i < vargu.Length-1; i++)
        {
            if (vargu[i] == vargu[i++])
            {
                len++;
                if (len > bestlen)
                {
                    bestlen = len;
                    bestpos = pos;
                }
            }
            else
            {
                len = 1;
                pos = i++;
            }
        }

        for(int k = bestpos; k <= bestlen; k++)
        {
            Console.Write("{0}", vargu[k]);
        }
        Console.ReadLine();
    }
}

类2
{
静态void Main（字符串[]参数）
{
int pos=0，bestpos=0，bestlen=0；
int len=1；
int[]vargu={2,2,3,4,5,5,5,6,9,9}；
对于（int i=0；ibestlen）
{
bestlen=len；
bestpos=pos；
}
}
其他的
{
len=1；
pos=i++；
}
}
对于（int k=bestpos；k您在循环体中使用的是
i++
，意思是
i+1

请注意，
i++
具有将
i
增加1的副作用。将
i
的增量仅保留在
中（int i=0；i
您在循环体中使用的
i++
是指
i+1

请注意，
i++
的副作用是将
i
增加1。将
i
的增量仅保留在
中（int i=0；i
您的问题是2倍的

首先，
i++
增加变量
i
，该变量将索引向前移动。这是您不想要的。如果要访问连续元素，需要使用
i+1

第二，当您在第二个循环中打印数组时，结束索引是错误的。您从
bestpos
开始，但希望在
bestpos+bestlen
结束！因为您测量序列的长度，而不保存最终索引

这将为您提供预期的结果：

int pos = 0, bestpos = 0, bestlen = 0;
int len = 1;
int[] vargu = { 2, 2, 3, 4, 5, 5, 5, 6, 9, 9, 9, 9 };
for (int i = 0; i < vargu.Length - 1; i++)
{
    if (vargu[i] == vargu[i+1])
    {
        len++;
        if (len > bestlen)
        {
            bestlen = len;
            bestpos = pos;
        }
    }
    else
    {
        len = 1;
        pos = i+1;
    }
}
for (int k = bestpos; k <= bestpos+bestlen; k++)
{
    Console.Write("{0}", vargu[k]);
}
Console.ReadLine();

int pos=0，bestpos=0，bestlen=0；
int len=1；
int[]vargu={2,2,3,4,5,5,5,6,9,9}；
for（int i=0；ibestlen）
{
bestlen=len；
bestpos=pos；
}
}
其他的
{
len=1；
pos=i+1；
}
}
对于（int k=bestpos；k而言，您的问题是两方面的

首先，
i++
增加变量
i
，该变量将索引向前移动。这是您不想要的。如果要访问连续元素，需要使用
i+1

第二，当您在第二个循环中打印数组时，结束索引是错误的。您从
bestpos
开始，但希望在
bestpos+bestlen
结束！因为您测量序列的长度，而不保存最终索引

这将为您提供预期的结果：

int pos = 0, bestpos = 0, bestlen = 0;
int len = 1;
int[] vargu = { 2, 2, 3, 4, 5, 5, 5, 6, 9, 9, 9, 9 };
for (int i = 0; i < vargu.Length - 1; i++)
{
    if (vargu[i] == vargu[i+1])
    {
        len++;
        if (len > bestlen)
        {
            bestlen = len;
            bestpos = pos;
        }
    }
    else
    {
        len = 1;
        pos = i+1;
    }
}
for (int k = bestpos; k <= bestpos+bestlen; k++)
{
    Console.Write("{0}", vargu[k]);
}
Console.ReadLine();

int pos=0，bestpos=0，bestlen=0；
int len=1；
int[]vargu={2,2,3,4,5,5,5,6,9,9}；
for（int i=0；ibestlen）
{
bestlen=len；
bestpos=pos；
}
}
其他的
{
len=1；
pos=i+1；
}
}
对于（int k=bestpos；k3个问题

if（vargu[i]==vargu[i++]）
不要将++与i一起使用，这意味着增加i的实际值，而您正在循环i。请使用“i+1”

pos=i++

这里也有同样的问题。由于这一行，数组不会被每个索引遍历

用于（int k=bestpos；k bestlen）
{
bestlen=len；
bestpos=pos；
}
}
其他的
{
len=1；
pos=i+1；
}
}
对于（int k=bestpos；k
3个问题

if（vargu[i]==vargu[i++]）
不要将++与i一起使用，这意味着增加i的实际值，而您正在循环i。请使用“i+1”

pos=i++

这里也有同样的问题。由于这一行，数组不会被每个索引遍历

用于（int k=bestpos；k bestlen）
{
bestlen=len；
bestpos=pos；
}
}
其他的
{
len=1；
pos=i+1；
}
}
对于（int k=bestpos；k
我建议建立一个保存结果的结构：

struct ResultItem
{
    public int start;
    public int end;
    public int value;
}

然后在符号发生变化时进行迭代和比较：

int[] vargu = { 2, 2, 3, 4, 5, 5, 5, 6, 9, 9, 9, 9 };
List<ResultItem> _result = new List<ResultItem>();
ResultItem current = new ResultItem{ value = vargu[0], start = 0, end = 1 };
for (int i = 1; i < vargu.Length; i++)
{
     if (vargu [i] != current.value)
     {
         current.end = i;
        _result.Add( current );   
         current = new ResultItem { value = vargu[i], start = i, end = i };
     }
    Console.WriteLine(current.value + "  " + current.start + "   " + current.end);
}
current.end = vargu.Length;
_result.Add(current);

这将导致如下结果：

integer 2 was placed 2 times in a row
integer 3 was placed 1 times in a row
integer 4 was placed 1 times in a row
integer 5 was placed 3 times in a row
integer 6 was placed 1 times in a row
integer 9 was placed 4 times in a row

然后，要找到最长的序列，可以使用Linq:
\u result.Max（r=>r.end-r.start）；
我建议创建一个保存结果的结构：

struct ResultItem
{
    public int start;
    public int end;
    public int value;
}

然后在符号发生变化时进行迭代和比较：

int[] vargu = { 2, 2, 3, 4, 5, 5, 5, 6, 9, 9, 9, 9 };
List<ResultItem> _result = new List<ResultItem>();
ResultItem current = new ResultItem{ value = vargu[0], start = 0, end = 1 };
for (int i = 1; i < vargu.Length; i++)
{
     if (vargu [i] != current.value)
     {
         current.end = i;
        _result.Add( current );   
         current = new ResultItem { value = vargu[i], start = i, end = i };
     }
    Console.WriteLine(current.value + "  " + current.start + "   " + current.end);
}
current.end = vargu.Length;
_result.Add(current);

这将导致如下结果：

integer 2 was placed 2 times in a row
integer 3 was placed 1 times in a row
integer 4 was placed 1 times in a row
integer 5 was placed 3 times in a row
integer 6 was placed 1 times in a row
integer 9 was placed 4 times in a row

然后，为了找到最长的序列，您可以使用Linq:
\u result.Max（r=>r.end-r.start）；
我自己也在处理同一个问题。我尝试使用上面的Mong Zhu的代码，它几乎奏效了，所以我调整了两件事，似乎奏效了。

将（vargu[i]==vargu[i+1]）更改为（vargu[i]+1==vargu[i+1]）
和pos=i+1；到pos=i；，这似乎很有效。我的第一篇文章。我希望没问题

    int[] arr = { 1, 2, 3, 5, 4, 3, 3, 4, 5, 6, 5, 4, 5, 6, 7, 8, 7, 5, 6, 9, 8, 7, 0 };
        int pos = 0, bestPos = 0, bestLen = 0;
        int len = 1; 

        for(int i = 0; i < arr.Length -1; i++)
        {
            if(arr[i] + 1 == arr[i + 1])
            {
                len++;
                if(len > bestLen)
                {
                    bestLen = len;
                    bestPos = pos; 
                }
            }
            else
            {
                len = 1;
                pos = i ;
            }
        }

        for( int k = bestPos; k <= bestLen + bestPos; k++)
        {
            Console.Write("{0}", arr[k]);
        }

int[]arr={1,2,3,5,4,3,3,4,5,6,5,4,5,6,7,8,7,5,6,9,8,7,0}；
int pos=0，bestPos=0，bestLen=0；