В любом случае можно ли определить, увеличиваются ли элементы в списке, а затем уменьшается di git?

Question

Мне нужно найти список True или False, в котором числа располагаются в порядке возрастания, за которым следует убывающий порядок.

или числа в порядке убывания, за которым следует возрастающий порядок. Вы можете предположить, что последовательные числа во входной последовательности всегда отличаются друг от друга.

Я попробовал приведенный ниже код, но не смог получить соответствующее возвращаемое значение, т. Е. (Истина / Ложь) может кто-то дать какое-либо предложение о том, как улучшить мой код?

def hillvalley(A): 

    return (all(A[i] <= A[i + 1] for i in range(len(A) - 1)) or
        all(A[i] >= A[i + 1] for i in range(len(A) - 1))) 

hillvalley([1,2,3,5,4,3,2,1])

Answer 1

Работает путем нахождения индекса максимума и минимума.

Для увеличения с последующим уменьшением проверяет, что значения до индекса максимума увеличиваются, а затем уменьшаются.

Для уменьшения с последующим увеличение проверяет, что значения до индекса min уменьшается, а затем увеличивается.

Способен обрабатывать плато.

Код

def hillvalley(A):
  # Check increasing followed by decreasing
  index, _ = max(enumerate(A), key=lambda v: v[1])
  if all(A[i]<=A[i+1] for i in range(index)) and \
    all(A[i]>=A[i+1] for i in range(index, len(A)-1)):
    return True

  # Check decreasing followed by increasing
  index, _ = min(enumerate(A), key=lambda v: v[1])
  if all(A[i]>=A[i+1] for i in range(index)) and \
    all(A[i]<=A[i+1] for i in range(index, len(A)-1)):
    return True

  return False

Тест

for t in [[1,2,3,5,4,3,2,1], [4,3,2,1,1,2,3,5], [1,2,1,5,4,3,2,1]]:
  print(f'{t} -> {hillvalley(t)}')

Выход

[1, 2, 3, 5, 4, 3, 2, 1] -> True
[4, 3, 2, 1, 1, 2, 3, 5] -> True
[1, 2, 1, 5, 4, 3, 2, 1] -> False

Answer 2

Это предполагает, что нет никаких «плато» (или случаев, когда два последовательных элемента равны). Если вы хотите учесть это, я оставлю вам возможность изменить этот код соответствующим образом.

def hillvalley(A):
    # determine which direction we're going
    orig_direction = (A[1] > A[0])
    # make a flag for when we switch directions (hill-to-valley, or valley-to-hill)
    switched_direction = orig_direction
    # do comparisons to the last element:
    last = A[1]
    for e in A[2:]:
        # determine our current direction
        current_direction = (e > last)
        # are we still moving the same direction as we were last time?
        if current_direction != switched_direction:
            # if not, then determine how many times we're changing direction
            if switched_direction == orig_direction:
                # this is the first time we're changing direction, so it's fine
                switched_direction = current_direction
            else:
                # this is the second time, which means it fails the test
                return False
        last = e
    # if we don't return during any of that, then it passes the test
    return True

>>> hillvalley([1, 2, 3, 4, 5, 4, 3, 2, 1])
True
>>> hillvalley([1, 2, 3, 4, 5, 4, 3, 2, 3])
False