4

我有一个大的连续数据列表，我试图找出数据在哪里增加以实现最少的条目数量以及它在哪里减少。例如，如果我有列表

[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），但它不会在单个列表中获得整个长度.

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

4

2 回答 2

2

没有重叠的单调：

此版本查找单调序列并且不记录重叠；很抱歉最初没有注意。

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

有重叠的单调/非单调：

此函数查找单调和重叠的序列；>=您可以通过分别更改和<=来>轻松地将其更改为非单调工作<，甚至可以使其参数化。

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
于 2013-10-02T17:30:52.780 回答
1

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

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]

顺便说一句，您的问题并不清楚，但您的输出表明您希望从左到右贪婪地收集子序列，此代码假定。

于 2013-10-02T17:45:05.737 回答