检查列表是升序还是降序（使用 FOR）

Question

所以我在我的大学里设置了一项任务，我想检查一个列表是否实际上是排序的（升序或降序）。但我必须使用'for'。 （我们最近才学习了for和lists，一定要实践一下）

这是我目前所拥有的，我可以确认列表是降序，但不是降序或升序：

A=[10,9,8,3,1,0]

def order(A):
    for i in range(len(A) - 1): 
        if ((A[i]>A[i+1])) :
            return False
    return True

Answer 1

这是返回列表是升序、降序还是两者都不是的简单方法。

def order(A):
if A == sorted(A,reverse=False):
    return 'Ascending'
elif A == sorted(A,reverse=True):
    return 'Descending'
else:
    return 'Neither'

这是一个简单输入的示例输出。

>> a = [2,5,4,7,1]
>> b = [1,3,5,7,9]
>> c = [9,6,3,1,0]
>> print(order(a), order(b), order(c))
out: Neither Ascending Descending

这个函数的好处是我们不必分析单个元素，我们只需要使用内置函数来分析整个列表。

Answer 2

您需要以这样的方式创建一个算法，以便其他参数之前的结果是唯一的！

对于升序，检查当前项与下一次的减法是否大于0，如果是，则不升序排序。

降序，检查当前项与下一次的减法是否小于0，如果是，则不降序排序。

试试这个：

def order(A) # Ascending order
    for i in range(len(A) - 1):
        if A[i] - A[i+1] > 0:
            return False
    return True

def order(A) # Descending order
    for i in range(len(A) - 1):
        if A[i] - A[i+1] < 0:
            return False
    return True

Answer 3

如果list 是ascending，您想返回True 或 descending。

这使得code 真的*可读**：

def order(lst):
    ascending = descending = True
    for i in range(len(lst) - 1): 
        if lst[i] > lst[i+1] :
            ascending = False
        elif lst[i] < lst[i+1] :
            descending = False
    return ascending or descending

我们首先定义 2 boolean variables 设置为 True - ascending 和 descending。然后我们循环遍历lst（我给function 起了一个更合理的param 名称）并检查if 这个index 小于下一个。如果是，我们可以将ascendingvariable设置为False（因为lst现在不能再是ascending). Else, if the next index is greater than the currentindex, we setdescendingtoFalse`。

最后，如果lst 是ascending，那么最后我们return or descending。

---

一些例子：

>>> order([1,2,3,4])
True
>>> order([1,2,3,2])
False
>>> order([3,2,1,0])
True
>>> order([3,2,1,4])
False

希望这会有所帮助！ （顺便说一句，如果您有兴趣，您可以在 function 中执行相同的操作 one-line）：

def order(lst):
    return lst == sorted(lst) or lst == sorted(lst)[::-1]

Answer 4

这可能会有所帮助：

A=[10,9,8,3,1,0]
B=[1,9,18,33,41,50]
C=[1, 1, 1, 1, 1]
D= [1]
E=[1, 2, 3, 2, 1]
F =[]

def order(someList):
    asc = True
    desc = True

    for idx in range(1, len(someList)):
        if someList[idx] - someList[idx - 1] >= 0:
            asc = asc & True
            desc = desc & False
        else:
            desc = desc & True
            asc = asc & False

    if asc and not desc:
        return "list is in ascending order"
    elif desc and not asc:
        return "list is in descending order"
    else:
        return "list is in no order"

print(order(A))
print(order(B))
print(order(C))
print(order(D))
print(order(E))
print(order(F))

当执行时，这段代码的输出是：

list is in descending order
list is in ascending order
list is in ascending order
list is in no order
list is in no order
list is in no order

我们正在做的是维护两个布尔标志asc 和desc，这将表示传递的列表是升序还是降序。

然后，对于列表中的每一对连续数字，我们计算它们的差异 if someList[idx] - someList[idx - 1] >= 0: 然后我们将 desc 标记为 False，反之亦然 else 情况。

直观地说，这段代码所做的事情如下： 如果一个序列是升序的，那么每对连续的数字的差值都将大于零，例如：考虑这个序列[a, b, c, d, e, f]，其中所有字符都代表数字并假设这个序列是升序的情况，即@ 987654330@，如果我们考虑所有连续的数字对，即(a, b), (b, c), (c, d), and so on..，并计算每对数字的差异，即b-a, c-b, d-c and so on..，那么every difference will be >= 0，即b-a >= 0 and c-b >= 0 and d-c >= 0 and e-d >= 0 and f-e >= 0，这就是asc所代表的条件上面代码中的布尔标志。 desc boolean flag 可以考虑类似的解释。

如果你想要更小的版本上面的代码仍然使用for循环，那么使用这个：

A=[10,9,8,3,1,0]
B=[1,9,18,33,41,50]
C=[1, 1, 1, 1, 1]
D= [1]
E=[1, 2, 3, 2, 1]
F = []

def order(someList):

    results = [True if second >= first else False for first, second in zip(someList, someList[1:])]

    if any(results) and all(results):
        return "ascending order"
    elif not any(results) and not all(results):
        return "descending order"
    else:
        return "no order"

print(order(A))
print(order(B))
print(order(C))
print(order(D))
print(order(E))
print(order(F))

并为此输出

descending order
ascending order
ascending order
no order
no order
no order

Answer 5

def descending(l):
  x=0
  if len(l)<= 1 or (len(l) == 2 and l[0] >= l[1]):
    return True
  else:
    if l[0]<=l[1]:
      return descending(l[1:])
    else:
      return False