Question

所以我在我的大学里设置了一个任务，我想要检查一个列表是否实际上是排序的（升序或降序）。但我必须使用＆＃39;。（我们最近刚刚了解了并列出了，我们必须练习它）

这是我到目前为止，我能够确认一个列表是下降，但不是下降或升序：

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

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

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

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

试试这个：

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

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

Answer 2

这可能会有所帮助：

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]，其中所有字符代表数字，并假设此序列按升序排列即a <= b <= c <= d <= e <= f并且如果我们考虑所有连续的数字对，即{{1}}，并计算每个对的差异，即(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循环，那么请使用：

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))

Answer 3

如果True为list 或 ascending，您希望返回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小于下一个ascending。如果是，我们可以将variable False设置为lst（因为ascending). Else, if the next index is greater than the current现在不再是, we set索引to降序{ {1}}错误。

最后，如果return是lst ascending 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

这是一种返回列表是升序还是降序的简单方法。

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 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

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

5 个答案: