Question

I have an array like this:

0011011100011111001

I’d like to find the longest sequence of 1’s in this array, keeping note of the length and position of the starting point, here the length would be 5 and the starting point is 12.

Any ideas for how to go about this?

Answer 1

You can set a starting position and length initially to zero, then go through the array elements one by one, keeping track of the transitions between 1 and 0 with a simple state machine.

The state table looks like this:

              +----------------------------------------+
              |               lastNum                  |
              +------------------+---------------------+
              |         0        |          1          |
+---------+---+------------------+---------------------+
|         | 0 | Just get next    | Check/update runLen |
|         |   |  character       |  against previous   |
| thisNum +---+------------------+---------------------+
|         | 1 | Store runPos  ,  | Increment runLen    |
|         |   |  set runLen to 0 |                     |
+---------+---+------------------+---------------------+

Since you’re only interested in 1 sequences, the initial state has lastNum set to zero to ensure a 1 at the start correctly begins a run. We also set up the initial “largest run to date” to have a size and position of zero to ensure it gets overwritten by the first real run.

There’s a special edge case to this method because we have to detect if the final number in the list is 1 – if so, it means there will have been no 1 -> 0 transition at the end of the list for checking the final run of 1 numbers.

Since we will have exited the loop without checking that final run, we do a final check as if we were transitioning from 1 to 0.

The pseudo-code goes something like this. First, the initialisation of all variables:

# Store the current maximum run of '1' characters (none) and initial state.

var maxLen = 0, maxPos = 0, lastNum = 0

# runLen and runPos will be set in a 0->1 transition before we use them.

var rnLen, runPos

Then we can simply iterate over each number in the list and detect transitions as per the diagram above:

# Iterate over entire list, one by one.

for curPos = 0 to len(list) - 1:
    # 0 -> 0: do nothing.

    # 0 -> 1: store position, set run length to 1.

    if lastNum == 0 and list[curPos] == 1:
        runPos = curPos
        runLen = 1
    endif

    # 1 -> 1: increment the current run length.

    if lastNum == 1 and list[curPos] == 1:
        runLen = runLen + 1
    endif

    # 1 -> 0: check current run against greatest to date.

    if lastNum == 1 and list[curPos] == 0:
        if runLen > maxLen:
            maxPos = runPos
            maxLen = runLen
        endif
    endif

    # Save current number into lastNum for next iteration.

    lastNum = list[curPos]
endfor

Then, finally, handling of the afore-mentioned edge case:

# If we finished with a `1`, need to check final run.

if lastNum = 1:
    if runLen > maxLen:
        maxPos = runPos
        maxLen = runLen
    endif
endif