Python 列表中两个切片的最小最大值/最大值

我有一个类似于

[3,10,4,3,9,15,6,13]

的列表，我想找到两个不重叠的序列，通过取最大值和最小值得到最大值。它们必须是连续的，所以不能从1中减去第3项。但是，您可以从3中减去索引1

在我的例子中，你会得到[3,10]和[3,15]对。你怎么能做到这一点呢。这是我到目前为止得到的

python:

l = [3,10,4,3,9,15,6,13]
pair1=[max(l), min(l)]
l.remove(max(l))
l.remove(min(l))
pair2=[max(l), min(l)]

---

这当然不是我想要的，但我不确定如何找到两对。找到一对以上代码很好，但不是两对，因为通常会出现重叠序列。

可能不是很优雅，但请尝试以下方法：

l = [3,10,4,3,9,15,6,13]

# list to store diffs
diff=[]
# calculate diffs
for i in range(0, len(l)-1):
    diff.append(l[i+1]-l[i])

# list to store diff sequences
results=[]

# Findinf the sequences
curr=0;
while curr<=(len(diff)-1):

    # list to store positive differences
    result=[]

    # llop while the difference is positive
    while diff[curr]>0 :

        # if it is a first element
        if len(result) == 0:
            # in 0th place store the diff sum
            result.append(diff[curr])
            # in 1st place store the sequence start index 
            result.append(curr)
            # in 2nd place store the sequence end index
            result.append(curr+1)
        else:
            # summ the sequnce diff
            result[0]+=diff[curr]
            # update sequence end index
            result[2]=curr+1
        # move to next element
        curr+=1
        # if reached end of array, break the loop 
        if curr>(len(diff)-1):
            break
    # if there was a sequence store it             
    if (len(result) > 0):
        results.append(result)
    else:
        # move to next element in case of there was no sequence
        curr+=1

# sort the results by sum in reverse order of the 0th element(sum) and normal order of 1st element(start index)
results.sort(key=lambda x: x[0]*10-x[1], reverse=True)
# print first 2 results
for i in range(0,2):
    print "[%d,%d]" % (l[results[i][1]],l[results[i][2]])

l=[3,10,4,3,9,15,6,13]
#用于存储差异的列表
差异=[]
#计算差异
对于范围（0，len（l）-1内的i：
差异附加（l[i+1]-l[i]）
#用于存储差异序列的列表
结果=[]
#查找序列
curr=0；
而curr0：
#如果它是第一个元素
如果len（结果）==0：
#在第0位存储差异总和
结果.追加（差异[当前]）
#首先存储序列开始索引
结果追加（curr）
#在第二位存储序列结束索引
结果追加（curr+1）
其他：
#总结以下差异
结果[0]+=diff[curr]
#更新序列结束索引
结果[2]=当前值+1
#移动到下一个元素
电流+=1
#如果到达数组的末尾，则中断循环
如果当前>（长度（差异）-1）：
打破
#如果有序列存储它
如果（len（结果）>0）：
results.append（结果）
其他：
#如果没有序列，则移动到下一个元素
电流+=1
#按第0个元素（总和）的倒序和第1个元素（开始索引）的正常顺序的总和对结果进行排序
results.sort（key=lambda x:x[0]*10-x[1]，reverse=True）
#打印前2个结果
对于范围（0,2）内的i：
打印“[%d，%d]”%（l[结果[i][1]、l[结果[i][2]）

---

至少对于您的输入，它会打印想要的结果：）

写这篇文章很有趣：

import itertools as it

l = [3,10,4,3,9,15,6,13]

r=sorted(
    map(lambda x: (x[0:2], x[2:4]),
        sorted(it.imap(
            lambda x: (min(x[0:2]), max(x[0:2]), min(x[2:4]), max(x[2:4])),
            it.imap(lambda x: (l[x[0]], l[x[1]], l[x[2]], l[x[3]]),
                    it.combinations(range(len(l)), 4))),
               key=lambda x: -(x[1]-x[0]+x[3]-x[2])))[0],
    key=lambda x: x[0]-x[1])

print(r)

---

所以基本上你想在所有可能的组合中找到差异最大的组合？这是正确的。谢谢你简单的解释。等等。。。两对，不重叠的，差异的顺序如何？是的，这是我不明白的。好的。呃,怎么解释呢,我想在组合上有最大的差异,但是组合不能重叠。因此，您在使用

[3,15,1]

时不会有差异，因此组合

[15,1]

无效。因为这将被计为

-14

。