Question

我有一个很大的连续数据列表，我试图找出数据在最小数量的条目和减少的位置增加的位置。例如，如果我有列表

[0, 1, 3, 8, 10, 13, 13, 8, 4, 11, 5, 1, 0]

我希望能够捕获0,1,3,8,10,13,13和11,5,1,0的运行，但不能捕获8,4的运行（因为它小于任意数量3）。

目前我正在使用升序和降序功能一次捕获一定数量的运行（例如，0,1,3和1,3,8），但它没有得到整个长度一个清单。

关于如何解决这个问题的任何想法？

Answer 1

没有重叠的单调：

此版本发现单调序列，不记录重叠;抱歉最初没有注意。

def find_sequences(lst, min_len=3):
    curr = []
    asc = None
    for i in lst:
        if not curr or len(curr) == 1 or asc and i >= curr[-1] or not asc and i <= curr[-1]:
            if len(curr) == 1:
                asc = curr[-1] < i
            curr.append(i)
        else:
            if len(curr) >= min_len:
                yield curr
            asc = None
            curr = [i]
    if len(curr) >= min_len:
        yield curr

的产率：

[[0, 1, 3, 8, 10, 13, 13], [11, 5, 1, 0]]

表现：

In [6]: timeit list(find_sequences(x))
100000 loops, best of 3: 8.44 µs per loop

单调/非单调与重叠：

此功能可发现单调＆amp;重叠序列;通过分别将>=和<=更改为>和<，甚至可以将其设置为可参数化，您可以轻松地将其更改为非单调工作。

def find_sequences(lst, min_len=3):
    asc, desc = [], []
    for i in lst:
        if not asc or i >= asc[-1]:
            asc.append(i)
        else:
            if len(asc) >= min_len:
                yield asc
            asc = [i]

        if not desc or i <= desc[-1]:
            desc.append(i)
        else:
            if len(desc) >= min_len:
                yield desc
            desc = [i]

    if len(desc) >= min_len:
        yield desc
    if len(asc) >= min_len:
        yield asc

的产率：

[[0, 1, 3, 8, 10, 13, 13], [13, 13, 8, 4], [11, 5, 1, 0]]

表现：

In [3]: timeit list(find_sequences(x))
100000 loops, best of 3: 10.5 µs per loop

Answer 2

以下内容应该有效......它会将数据分解为不相交的单调子序列，然后根据您的长度标准进行过滤。

def get_monotonic_subsequences(data, min_length):
    direction = data[1] - data[0] #determine direction of initial subsequence
    subsequences = []
    cur_seq = []
    for i in range(0, len(data) - 1):
        if direction > 0:
            if (data[i] >= data[i-1]):
                cur_seq.append(data[i])
            else:
                subsequences.append(cur_seq)
                cur_seq = [data[i]]
                direction = data[i+1] - data[i]
        else:
            if (data[i] <= data[i-1]):
                cur_seq.append(data[i])
            else:
                subsequences.append(cur_seq)
                cur_seq = [data[i]]
                direction = data[i+1] - data[i]

    if  (data[-1] - data[-2])*direction > 0:
        cur_seq.append(data[-1])
        subsequences.append(cur_seq)
    else:
        subsequences.append(cur_seq)
        subsequences.append([data[-1]])
    return [x for x in subsequences if len(x) >= min_length]

顺便说一下，你的问题并不清楚，但是你的输出表明你期望从左到右贪婪地收集子序列，这段代码假设。

确定列表中升序或降序的位置停止

2 个答案: