Python 给定列表中最长的递减子列表

我想找到给定列表中最长的递减子序列，例如L=[1,2,1,2,1,1,1,2,1]，结果应该是[2,1]，但我似乎无法生成该结果。有人能告诉我为什么它不起作用吗？输出为[0,2,1,2,1,2,1,2,1]，与第一个零无关，但结果应产生[2,1]

这是我试过的代码

L = [1, 2, 1, 2, 1, 2, 1, 2, 1]

current = [0]
smallest = []

for i in  range(len(L)):
    if i < (len(L)-1):
        if L[i] >= L[i+1]:
            current.append(L[i])

        else :    
            if L[i] < current[-1]:
                current.append(L[i])

    elif i>= (len(L)-1):
        if L[-1]<L[i-1]:
            current.append(L[i])
    else:
        current = [i]
    if len(current) > len(smallest):
            smallest = current

L=[1,2,1,2,1,2,1,2,1]
当前=[0]
最小的=[]
对于范围内的i（len（L））：
如果i<（len（L）-1）：
如果L[i]>=L[i+1]：
当前.append（L[i]）
其他：
如果L[i]<当前[-1]：
当前.append（L[i]）
elif i>=（len（L）-1）：
如果L[-1]长度（最小）：
最小=电流

结果：[0,2,1,2,1,2,1,2,1]

---

期望的结果：[2,1]

当你说

current=[0]

时，它实际上会将

0

添加到列表中，也许你想要

current=[L[0]]

见此：

def longest_decreasing_sublist(a):
  lds, current = [], [a[0]]
  for val in a[1:]:
    if val < current[-1]: current.append(val)
    else:
      lds = current[:] if len(current) > len(lds) else lds
      current = [val]
  lds = current[:] if len(current) > len(lds) else lds
  return lds

L = [1, 2, 1, 2, 1, 2, 1, 2, 1]
print (longest_decreasing_sublist(L))
# [2, 1]

def最长递减子列表（a）：
lds，当前=[]，[a[0]]
对于[1:]中的val：
如果vallen（lds）else lds
当前=[val]
lds=当前[：]如果len（当前）>len（lds）else lds
返回lds
L=[1,2,1,2,1,2,1,2,1]
打印（最长的子列表（L））
# [2, 1]

当你说

current=[0]

时，它实际上会将

0

添加到列表中，也许你想要

current=[L[0]]

见此：

def longest_decreasing_sublist(a):
  lds, current = [], [a[0]]
  for val in a[1:]:
    if val < current[-1]: current.append(val)
    else:
      lds = current[:] if len(current) > len(lds) else lds
      current = [val]
  lds = current[:] if len(current) > len(lds) else lds
  return lds

L = [1, 2, 1, 2, 1, 2, 1, 2, 1]
print (longest_decreasing_sublist(L))
# [2, 1]

def最长递减子列表（a）：
lds，当前=[]，[a[0]]
对于[1:]中的val：
如果vallen（lds）else lds
当前=[val]
lds=当前[：]如果len（当前）>len（lds）else lds
返回lds
L=[1,2,1,2,1,2,1,2,1]
打印（最长的子列表（L））
# [2, 1]

您最好先设计代码以提高可维护性和可读性，这样您就可以轻松地单独测试软件的组件，而不是一次解决整个问题。这就是所谓的功能分解

在最高层思考你需要什么

首先，您需要一种方法来获取数组中给定点的最长递减子集，以便能够智能地比较各种序列

您可以使用以下代码来执行此操作：

def getNextSequence(myList, index):
    # Beyond list end, return empty list.

    if index > len(myList):
        return []

    # Construct initial list, keep adding until either
    # an increase is found or no elements left.

    sequence = [ myList[index] ]
    addIdx = index + 1
    while addIdx < len(myList) and myList[addIdx] <= myList[addIdx - 1]:
        sequence.append(myList[addIdx])
        addIdx += 1

    # And there you have it, the sequence at a given point.

    return sequence

def getNextSequence（myList，index）：
#在列表结束之后，返回空列表。
如果索引>长度（myList）：
返回[]
#构造初始列表，继续添加，直到
#发现增加或没有剩余元素。
序列=[myList[索引]]
addIdx=索引+1
虽然addIdx
在最高层思考你需要什么

首先，您需要一种方法来获取数组中给定点的最长递减子集，以便能够智能地比较各种序列

您可以使用以下代码来执行此操作：

def getNextSequence(myList, index):
    # Beyond list end, return empty list.

    if index > len(myList):
        return []

    # Construct initial list, keep adding until either
    # an increase is found or no elements left.

    sequence = [ myList[index] ]
    addIdx = index + 1
    while addIdx < len(myList) and myList[addIdx] <= myList[addIdx - 1]:
        sequence.append(myList[addIdx])
        addIdx += 1

    # And there you have it, the sequence at a given point.

    return sequence

def getNextSequence（myList，index）：
#在列表结束之后，返回空列表。
如果索引>长度（myList）：
返回[]
#构造初始列表，继续添加，直到
#发现增加或没有剩余元素。
序列=[myList[索引]]
addIdx=索引+1
虽然adddxitertools.accumulate
进行动态编程：

>>> import operator as op
>>> import itertools as it
>>> L = [1, 2, 1, 2, 1, 2, 1, 2, 1]
>>> dyn = it.accumulate(it.chain([0], zip(L, L[1:])), lambda x, y: (x+1)*(y[0]>y[1]))
>>> i, l = max(enumerate(dyn), key=op.itemgetter(1))
>>> L[i-l:i+1]
[2, 1]

有很多方法可以解决这个问题。在Py3中-使用
itertools.accumulate
进行动态编程：

>>> import operator as op
>>> import itertools as it
>>> L = [1, 2, 1, 2, 1, 2, 1, 2, 1]
>>> dyn = it.accumulate(it.chain([0], zip(L, L[1:])), lambda x, y: (x+1)*(y[0]>y[1]))
>>> i, l = max(enumerate(dyn), key=op.itemgetter(1))
>>> L[i-l:i+1]
[2, 1]

如果此处的len（当前）>len（最小）
则此时未定义最小值。它甚至可以编译吗？对不起，代码是一个更大的ode的一部分，但是其他的一切都很好，所以我没有看到发布整个程序的必要，在这个过程中，我错过了将最小的程序声明为空列表的部分。谢谢你指出。应该只减少1，或者任何减少的序列都是好的？任何减少的子序列都是好的，例如，如果L=[7,8,1,2,3,4,77,78,58,2]，那么结果应该是[77,78,58,2]，因为它是连续减少的最大序列
77,78
是增加吗
[78,58,2]
如果此处的len（当前）>len（最小）
则此时未定义最小值。它甚至可以编译吗？对不起，代码是一个更大的ode的一部分，但是其他的一切都很好，所以我没有看到发布整个程序的必要，在这个过程中，我错过了将最小的程序声明为空列表的部分。谢谢你指出。应该只减少1，或者任何减少的序列都是好的？任何减少的子序列都是好的，例如，如果L=[7,8,1,2,3,4,77,78,58,2]，那么结果应该是[77,78,58,2]，因为它是连续减少的最大序列
77,78
是增加吗
[78,58,2]
。你能用一些注释向我解释一下你的代码是如何工作的，并告诉我我的代码哪里错了吗？建议编辑我的代码？那将非常有用。谢谢。你能用一些注释向我解释一下你的代码是如何工作的，并告诉我我的代码哪里错了吗？建议编辑我的代码？那将非常有用。谢谢。谢谢你，这真的帮了我很多。谢谢你，这真的帮了我很多。