如何在二维 numpy 数组中找到最长连续出现的非零元素

Question

I am simulating protein folding on a 2D grid where every angle is either ±90° or 0°, and have the following problem:

I have an n-by-n numpy array filled with zeros, except for certain places where the value is any integer from 1 to n. Every integer appears just once. Integer k is always a nearest neighbour to k-1 and k + 1, except for the endpoints. The array is saved as an object in the class Grid which I have created for doing energy calculations and folding the protein. Example array, with n=5:

>>> from Grid import Grid
>>> a = Grid(5)
>>> a.show()
[[0 0 0 0 0]
 [0 0 0 0 0]
 [1 2 3 4 5]
 [0 0 0 0 0]
 [0 0 0 0 0]]

My goal is to find the longest consecutive line of non-zero elements withouth any bends. In the above case, the result should be 5.

My idea so far are something like this:

def getDiameter(self):
    indexes = np.zeros((self.n, 2))
    for i in range(1, self.n + 1):
        indexes[i - 1] = np.argwhere(self.array == i)[0]

    for i in range(self.n):
         j = 1
        currentDiameter = 1
            while indexes[0][i] == indexes[0][i + j] and i + j <= self.n:
                currentDiameter += 1
                j += 1

        while indexes[i][0] == indexes[i + j][0] and i + j <= self.n:
            currentDiameter += 1
            j += 1

        if currentDiameter > diameter:
            diameter = currentDiameter

     return diameter

This has two problems: (1) it doesn't work, and (2) it is horribly inefficient if I get it to work. I am wondering if anybody has a better way of doing this. If anything is unclear, please let me know.

Edit: Less trivial example

[[ 0  0  0  0  0  0  0  0  0  0]
[ 0  0  0  0  0  0  0  0  0  0]
[ 0  0  0  0  0  0 10  0  0  0]
[ 0  0  0  0  0  0  9  0  0  0]
[ 0  0  0  0  0  0  8  0  0  0]
[ 0  0  0  4  5  6  7  0  0  0]
[ 0  0  0  3  0  0  0  0  0  0]
[ 0  0  0  2  1  0  0  0  0  0]
[ 0  0  0  0  0  0  0  0  0  0]
[ 0  0  0  0  0  0  0  0  0  0]] 

The correct answer here is 4 (both the longest column and the longest row have four non-zero elements).

Answer 1

What I understood from your question is you need to find the length of longest occurance of consecutive elements in numpy array (row by row).

So for this below one, the output should be 5 :

[[1 2 3 4 0]
 [0 0 0 0 0]
 [10 11 12 13 14]
 [0 1 2 3 0]
 [1 0 0 0 0]]

Because [10 11 12 13 14] are consecutive elements and they have the longest length comparing to any consecutive elements in any other row.

If this is what you are expecting, consider this:

import numpy as np
from itertools import groupby

a = np.array([[1, 2, 3, 4, 0],
 [0, 0, 0, 0, 0],
 [10, 11, 12, 13, 14],
 [0, 1, 2, 3, 0],
 [1, 0, 0, 0, 0]])

a = a.astype(float)
a[a == 0] = np.nan
b = np.diff(a)      # Calculate the n-th discrete difference. Consecutive numbers will have a difference of 1.
counter = []
for line in b:       # for each row.
    if 1 in line:    # consecutive elements differ by 1.
        counter.append(max(sum(1 for _ in g) for k, g in groupby(line) if k == 1) + 1)  # find the longest length of consecutive 1's for each row.
print(max(counter))  # find the max of list holding the longest length of consecutive 1's for each row.
# 5

For your particular example:

[[0 0 0 0 0] 
[0 0 0 0 0] 
[1 2 3 4 5] 
[0 0 0 0 0] 
[0 0 0 0 0]]
# 5

Answer 2

Start by finding the longest consecutive occurrence in a list:

def find_longest(l):
    counter = 0
    counters =[]
    for i in l:
        if i == 0:
            counters.append(counter)
            counter = 0
        else:
            counter += 1
    counters.append(counter)
    return max(counters)

now you can apply this function to each row and each column of the array, and find the maximum:

longest_occurrences = [find_longest(row) for row in a] + [find_longest(col) for col in a.T]
longest_occurrence = max(longest_occurrences)