Question

我想找到一个特定数字的最长序列，即1出现在数组中。假设数组是{1,0,0,0,1,1,1,1,0,0,1,1};答案应为4，因为连续出现最多四次。

Answer 1

在R中，它只是

max(rle(x)$lengths)

Answer 2

从一组数字A开始，找到最长的数字在A中连续运行一些N.

伪C ......

MaxRun = 0 /* Longest run so far */
for (i = 0; i < length(A);) {
  if A[i] = N {
    /* Potential run of N's... */

    /* Scan backward for first N in run */
    for (j = i; j > 0 & A[j-1] = N; j--);

    /* Scan forward to last N in run */
    for (k = i; k < length(A)-1 & A[k+1] = N; k++);

    /* Check to see if longer run found... */
    if (k-j+1 > MaxRun) then MaxRun = k-j+1;

    i = k /* jump i to last N found */
  }
  i = i + MaxRun + 1 /* Jump by longest run plus 1 */
}

MaxRun就是答案

这个想法是，一旦你发现N的连续运行，你就可以在检查之前至少向前跳到阵列中的那个远处另一位候选人。

由于跳跃因子，该算法具有可能的次线性运行时间。最糟糕的情况是每个A [i]都会被检查。

Answer 3

会有更有效的方法，但这就是我现在所获得的（C#）：

            int count = 0;
            int maxCount = 0;

            for (int i = 0; i < someArray.Count(); i++)
            {
                if (someArray[i] == 1)
                {
                    count++;
                }
                else
                {
                    if(count > maxCount)
                    {
                        maxCount = count;
                    }

                    count = 0;
                }
            }

Answer 4

A =数组，L =长度

cnt = 0
max = 0
for i = 0 .. L - 1
  if A[i] == 0
    if (cnt > max) max = cnt
    cnt = 0
  else
    cnt = cnt + 1
if (cnt > max) max = cnt

Answer 5

这是另一个线性解决方案，想法是维持两个跑步者。在1的起始边界处，第1个跑步者等到第2个跑步者到达终点（即0）。

int i = 0, j= 0, max = 0, n = A.length;

while ( j < n ) {

  if (j == (n-1)) { // reached boundary

    j = ( A[j] == 1) ? j++ : j;
    int k = j-i;
    if ( k > max ) { max = k;} 
  }

  else if ( A[j] == 1 ) { j++; }// increment 2nd runner

  else { 

    int k = j-i;
    if ( k > max ) { max = k;}
    j++; i = j;
  }
}

max是答案。

找到特定值的最长序列

5 个答案: