在 Python 整数列表中查找陨石坑 [降序/升序整数]

Question

我在 python 中有一个整数列表，我希望输出是序列中不同“陨石坑”的列表。我将陨石坑定义为一系列数字，这些数字以递减的整数开始，逐渐变大，直到它们达到等于陨石坑的第一个整数或大于陨石坑的第一个整数的数字。 如果最后一个数字等于或小于第一个数字 - 它应该在火山口末端的输出中。如果最后一个数字大于火山口中的第一个数字 - 它不应附加到输出列表的末尾。

例如，对于列表： 1,2,3,4,5,6,5,4,3,4,5,6,7,8,9 “陨石坑”将是： 6,5,4,3,4,5,6

我的代码：

def find_crater(my_list):
cur_crater = []
for i in range(len(my_list)-1):
    #check if the numbers are decreasing
    if (my_list[i] - my_list[i+1] > 0):
        cur_crater.append(my_list[i])
    #if increasing - check if we're in a crater 
    #and if current number is smaller than begining of crater
    elif len(cur_crater) > 1 and my_list[i] <= cur_crater[0]:
        cur_crater.append(my_list[i])
    #print crater and empty list 
    elif len(cur_crater) > 1 and my_list[i+1] > cur_crater[0]:
        print(cur_crater)
        cur_crater = []
    #continue if we're out of a crater
    else:
        continue
#catching the last crater in the list
if len(cur_crater) > 1:
    #include last int
    if my_list[i] - my_list[-1] < 0  and my_list[-1] <= cur_crater[0]:
        cur_crater.append(my_list[-1])
    print(cur_crater)
return

我已经在 2 个列表上调用了该函数。第一个输出符合预期：

ok_list = [12, 4, 7, 4, 2, 4, 5, 6, 5, 12, 21, 23, 
24, 26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14,
17, 27, 28, 19, 17, 19, 21, 19, 12, 23, 25, 27]

好的列表输出[编辑：不太好-它省略了第一个'4'所以结果不是那么好]：

[12, 7, 4, 2, 4, 5, 6, 5, 12]
[26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 17]
[28, 19, 17, 19, 21, 19, 12, 23, 25, 27]

但是，第二个列表在输出中将 2 个陨石坑列表合并为 1 个列表：

problematic = [12, 4, 7, 4, 2, 4, 5, 6, 5, 12, 21, 23, 
24, 26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 
17, 27, 19, 25, 19, 12, 23, 25, 27]

有问题的输出：

[12, 7, 4, 2, 4, 5, 6, 5, 12]
[26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 17, 27, 19, 25, 19, 12, 23, 25]

我期待：

[12, 4, 7, 4, 2, 4, 5, 6, 5, 12]
[26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 17]
[27, 19, 25, 19, 12, 23, 25, 27]

我试图通过以下方式解决这个问题： my_list[i+1] > cur_crater[0] 并因此检查列表中下一个 int 的大小 - 但这似乎并不能解决它[我将它留在代码中，即使它没有起到作用，希望有人解释为什么错误/不起作用？]。

总之，当火山口后面有一个火山口，中间只有一个 int 时，我的代码无法处理它。

如果输入是：

[12, 4, 7, 4, 2, 4, 5, 6, 5, 12, 21, 10, 9, 8, 6, 9, 10]

然后输出是一个长列表，但我想在列表项 12 之后和列表项 21 之前拆分它，但输出是一个长列表。

我很想获得有关任何库或方法的信息，这些信息可以为我提供更多关于更好和更有效解决方案的想法。

Answer 1

这是我带来的：

def find_crater(my_list):
    previous = None
    current_crater = []
    crater_list = []
    for elem in my_list:

        #For the first element
        if not previous:
            previous = elem
            continue

        if len(current_crater) == 0:
            if elem > previous:
                previous = elem
            else:
                current_crater.append(previous)
                previous = elem
        else:
            if elem > current_crater[0]:
                current_crater.append(previous)
                crater_list.append(current_crater)
                current_crater = []
                previous = elem
            else:
                current_crater.append(previous)
                previous = elem

    if len(current_crater) != 0:
        if elem > current_crater[0]:
            current_crater.append(previous)
            crater_list.append(current_crater)
        else:
            current_crater.append(previous)
            crater_list.append(current_crater)

    return crater_list

这给了我你想要的确切输出：

In [5]: ok_list = [12, 4, 7, 4, 2, 4, 5, 6, 5, 12, 21, 23, 
   ...: 24, 26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14,
   ...: 17, 27, 28, 19, 17, 19, 21, 19, 12, 23, 25, 27]

In [6]: find_crater(ok_list)
Out[6]: 
[[12, 4, 7, 4, 2, 4, 5, 6, 5, 12],
 [26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 17],
 [28, 19, 17, 19, 21, 19, 12, 23, 25, 27]]

In [7]: problematic = [12, 4, 7, 4, 2, 4, 5, 6, 5, 12, 21, 23, 
   ...: 24, 26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 
   ...: 17, 27, 19, 25, 19, 12, 23, 25, 27]

In [8]: find_crater(problematic)
Out[8]: 
[[12, 4, 7, 4, 2, 4, 5, 6, 5, 12],
 [26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 17],
 [27, 19, 25, 19, 12, 23, 25, 27]]

Answer 2

试试这个：

我们只是对列表进行切片，发现start_index:end_index 做了三个案例

• 当元素相等时
• 当元素更大时
• 最后一个元素即使更小也可能需要切片时的边界情况

---

def find_crater(l):    
    result = []
    start_index = 0
    for i in range( start_index +1,len(l)):
        start = l[start_index]
        if i==len(l)-1 and l[i]!=start:
            result = l[start_index:i+1]
            print result
        elif l[i]==start:
            end_index = i+1
            result = l[start_index:end_index]
            start_index = end_index +1
            if len(result)>1:
                print result
        elif l[i]>start:
            end_index = i
            result = l[start_index:end_index]
            start_index = end_index 
            if len(result)>1:
                print result

输入：

ok_list = [12, 4, 7, 4, 2, 4, 5, 6, 5, 12, 21, 23, 
24, 26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14,
17, 27, 28, 19, 17, 19, 21, 19, 12, 23, 25, 27]

problematic = [12, 4, 7, 4, 2, 4, 5, 6, 5, 12, 21, 23, 
24, 26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 
17, 27, 19, 25, 19, 12, 23, 25, 27]

输出：

find_crater(ok_list)
find_crater(problematic)

[12, 4, 7, 4, 2, 4, 5, 6, 5, 12]
[25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 17]
[28, 19, 17, 19, 21, 19, 12, 23, 25, 27]

[12, 4, 7, 4, 2, 4, 5, 6, 5, 12]
[25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 17]
[27, 19, 25, 19, 12, 23, 25, 27]

Answer 3

假设您的预期输出似乎是错误的，您要做的就是直到找到一个元素 >= 到链的开头并捕获仅包含单个元素的链：

def craters(lst):
    it = iter(lst)
    # get start of first chain
    first = next(it)
    tmp = [first]
    # iterate over the remaining
    for ele in it:
        # >= ends chain
        if ele >= first:
            # if equal, add it and call
            #  next(it) to set the next first element.
            if ele == first:
                tmp.append(ele)
                yield tmp
                first = next(it)
                tmp = [first]
            # else yield the group if it has > 1 element.
            # if it has 1 element it is not a descending start sequecne
            else:
                if len(tmp) > 1:
                    yield tmp
                tmp = [ele]
                first = ele
        else:
            tmp.append(ele)
     if len(tmp) > 1: # catch single element last
         yield tmp

输出：

In [5]: ok_list = [12, 4, 7, 4, 2, 4, 5, 6, 5, 12, 21, 23,
   ...:            24, 26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14,
   ...:            17, 27, 28, 19, 17, 19, 21, 19, 12, 23, 25, 27]

In [6]: problematic = [12, 4, 7, 4, 2, 4, 5, 6, 5, 12, 21, 23,
   ...: 24, 26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14,
   ...: 17, 27, 19, 25, 19, 12, 23, 25, 27]

In [7]: ex_ok = [[12, 4, 7, 4, 2, 4, 5, 6, 5, 12],
   ...: [26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 17],
   ...: [28, 19, 17, 19, 21, 19, 12, 23, 25, 27]]

In [8]: ex_p = [[12,4,  7, 4, 2, 4, 5, 6, 5, 12],
   ...: [26, 25, 22, 10, 9, 8, 6, 9, 10, 11, 13, 12, 14, 17],
   ...: [27, 19, 25, 19, 12, 23, 25, 27]]

In [9]: print(list(craters(problematic)) == ex_p)
True

In [10]: print(list(craters(ok_list)) == ex_ok)
True

In [11]: print(list(craters([12, 4, 7, 4, 2, 4, 5, 6, 5, 12, 21, 10, 9, 8, 6, 9, 10])))
[[12, 4, 7, 4, 2, 4, 5, 6, 5, 12], [21, 10, 9, 8, 6, 9, 10]]
In [12]: list(craters([1, 2, 3, 4, 5, 6, 5, 4, 3, 4, 5, 6, 7, 8, 9]))
Out[13]: [[6, 5, 4, 3, 4, 5, 6]]

这不涉及任何切片/索引，您可以懒惰地返回每个组。

为了简化您的算法，步骤如下：

• 从第一个元素开始，然后检查下一个元素是否>=，如果是并且相等，则将其添加到组中，如果是>将其设置为新的start 组。

• 如果新的第一个元素不大于下一个元素，则该组的长度将为 1，因为它不满足 以降序开头的数字序列。因此，我们不断消耗并将下一个元素设置为序列的 first 元素，直到我们找到一个 is > 下一个元素，这就是对 next(it) 的调用所做的事情，然后我们只需要洗涤并重复。