Python 在正整数的有序列表中查找最大的正增量

我正在编写一个python脚本来查看一个排名表，其中一支球队在几个赛季中的表现与其他球队的表现进行了比较，从最近的时间点开始，如

        Latest ->                                      <- Earliest
Team A: 10  10  12  12  13  13  13  14  15  14  16  13  11  15  14      
Team B: 14  14  15  16  15  7   14  14  15  10  22  15  15  11  16

尽管最大的三角洲有12个，但最大的上升幅度只有2个

在上面的A案例中，最大的增长是从16（7个季度前）到本季度的10，而对于B，最大的增长是从22到7，11到6个季度前

我想循环一个这样的列表，然后返回

Team A:  6
Team B: 15

我可以在每一季中弹出（）并将其从之前的所有季中减去，然后保存最大的正整数，但这感觉很马虎。OTOH，对列表进行排序并提取第一个和最后一个元素也会导致排名下降。（我只想衡量收益，而不是损失。）

---

有没有一种简单的方法可以在赛季表现数组中找到最近的、好的团队表现和更早的、更差的表现之间的最大差值，而不存在这种循环？

您需要循环列表，跟踪最小值和当前最大升幅（即

当前列表成员-min

）。每次处理列表成员时，请检查它是否为新的最小值，并根据需要更新当前最大上升

你不需要从之前所有的季节中减去，你只需要检查新元素是否是新的最小值，以及它是否有最大的增长

前

def find_max_pos_delta（我的分数）：
my_list=map（int，my_scores.strip（）.split（））
我的最小值=当前最大值=无
对于“我的大学”列表中的排名：
如果my_min为None或rank当前最大值：
当前最大值=新最大值
返回电流最大值
断言find_max_pos_delta（'30 18 20'）==2
断言find_max_pos_delta（'101012131313141414141515151515151515151514'）==6
断言find_max_pos_delta（'14 14 15 15 7 14 14 15 10 22 15 11 16'）==15

循环遍历所有元素时的时间复杂度O（n）

---

请注意，我选择了反转目标和列表，但结果是相同的。也就是说，我会从今年到过去，但也会从高级别到低级别。

不太漂亮，但我相信你可以通过以下方式确定最大的改进顺序：

def find_greatest_rise(rank_list):
    rank_list = rank_list[::-1] #reverse the rank list so we iterate moving forward in time
    i = 0
    if len(rank_list) > i + 1:
        bottom = 0
        top = 0
        delta = 0
        end_of_list = False

        while not end_of_list:
            curr_rank = rank_list[i]
            for j, r in enumerate(rank_list[i + 1:]):
                if curr_rank - r > 0:
                    if curr_rank - r >= delta:
                        delta = curr_rank - r
                        bottom = curr_rank
                        top = r
                else:
                    i += j + 1
                    break

                if j == len(rank_list[i + 1:]) - 1:
                    end_of_list = True

        print "bottom: {}, top: {}, delta: {}".format(bottom, top, delta)

---

是max（A）-min（A）是你想要的最大区别吗？粘土衬衫？抱歉，无法抗拒--配置文件看起来像是的，那个。我不想要最大的绝对值，我想要最大的正值。（球队往往很难在排名中上升，但很容易下降。）因此，我对从22到7的球队感兴趣，但对从7到22的球队不感兴趣。这不是最大的连续子序列问题吗？还有，@tripleee，是的，那就是我。没有两个人有这样的名字：）很好，非常感谢，当然就是这样——我忽略了一个事实，当我浏览列表时，随着当前最大范围的增长，我可以跳过越来越多的元素。再次感谢。

def find_max_pos_delta(my_scores):
    my_list = map(int, my_scores.strip().split())
    my_min = current_largest = None
    for rank in my_list:
        if my_min is None or rank < my_min:
            my_min = rank
        new_largest = rank - my_min
        if current_largest is None or new_largest > current_largest:
            current_largest = new_largest

    return current_largest

assert find_max_pos_delta('30 18 20') == 2
assert find_max_pos_delta('10  10  12  12  13  13  13  14  15  14  16  13  11  15  14  ') == 6
assert find_max_pos_delta('14  14  15  16  15  7   14  14  15  10  22  15  15  11  16') == 15

def find_greatest_rise(rank_list):
    rank_list = rank_list[::-1] #reverse the rank list so we iterate moving forward in time
    i = 0
    if len(rank_list) > i + 1:
        bottom = 0
        top = 0
        delta = 0
        end_of_list = False

        while not end_of_list:
            curr_rank = rank_list[i]
            for j, r in enumerate(rank_list[i + 1:]):
                if curr_rank - r > 0:
                    if curr_rank - r >= delta:
                        delta = curr_rank - r
                        bottom = curr_rank
                        top = r
                else:
                    i += j + 1
                    break

                if j == len(rank_list[i + 1:]) - 1:
                    end_of_list = True

        print "bottom: {}, top: {}, delta: {}".format(bottom, top, delta)