Question

如果整数列表由一系列严格递减的值后跟一系列严格递增的值组成，则该整数列表被称为谷值。递减序列和递增序列的长度必须至少为2。递减序列的最后一个值是递增序列的第一个值。

编写一个Python函数valley（l），该函数接受一个整数列表，如果l是一个谷，则返回True，否则返回False。

这里有一些例子来说明您的功能应该如何工作。
>>> valley([3,2,1,2,3])
True

>>> valley([3,2,1])
False

>>> valley([3,3,2,1,2])
False

我已经失眠了2天了，我能写的最好的就是这段代码

def valley(list):
    first =False
    second=False
    midway=0
    if(len(list)<2):
        return False
    else:
        for i in range(0,len(list)):
            if(list[i]<list[i+1]):
                first=True
                midway=i
                break
        for j in range(midway,len(list)-1):
            if(list[j]<list[j+1] and j+1==len(list)):
                Second=True
                break
            if(list[j]>=list[j+1]):
                second=False
                break
    if(first==True and second==True):
        return True
    else:
        return False

Answer 1

我发现，如果数字不是按完美的顺序排列，并且没有必要最小值必须等于1，那么我想说的就是列表是否为假[14,12 ,, 10,5,3,6,7,32,41]，这里也会形成一个谷，因为这些值减小到3（最低），然后又增加。 List的[4,3,2,1,2,3,4]是一个完美的山谷。

解决方案：

def valley(lst):
if len(lst)<2:
    return False
else:
    p = lst.index(min(lst))
    for i in range (0,p):
        x = (lst[i] > lst[i+1])

    for q in range (p,len(lst)-1):
        y = (lst[q]< lst[q+1])

    return (x==y)

如果能解决问题并且最有帮助，请别忘了接受它，谢谢。

Answer 2

山谷函数中变量n的结果是输入列表中数字的成对差，因此

input = [3,2,1,2,3]
n = [-1, -1, 1, 1]

现在下一个变量h是n的成对差，所以h将是

h = ['0', '2', '0']

因此，每当您有一个山谷时，只需检查模式“ 020”。在python中使用re模块来实现，

import re
def valley(f):   
    n  = [j-i for i, j in zip(f[:-1], f[1:])]
    h = [str(j-i) for i, j in zip(n[:-1], n[1:])]
    result = "".join(h)
    m = re.search('020', result)
    if m:
        return True
    else:
        return False

请让我知道它是否正确。

Answer 3

似乎saurav击败了我，但如果您允许使用一些NumPy魔术：

import numpy as np


def valley(arr):
    diff = arr[:-1] - arr[1:]

    gt = np.where(diff > 0)[0]
    lt = np.where(diff < 0)[0]
    d = np.sum(diff == 0)

    if gt.size == 0 or lt.size == 0:
        # Doesn't have ascendings or decendings
        return False
    elif d > 0:
        # Has a flat
        return False
    elif gt[-1] > lt[0]:
        # Not strictly one descent into one ascent
        return False
    else:
        return True

a = np.array([3, 2, 1, 2, 3])
b = np.array([3, 3, 2, 1, 2])
c = np.array([3, 2, 1])
d = np.array([1, 2, 3, 2, 1])

print(valley(a), valley(b), valley(c), valley(d))
>>> True False False False

您还可以使用普通的旧Python内置插件来做到这一点：

def valley(arr):
    diff = [i1-i2 for i1, i2 in zip(arr, arr[1:])]

    gt = [i for i, item in enumerate(diff) if item > 0]
    lt = [i for i, item in enumerate(diff) if item < 0]
    d = sum([True for d in diff if d == 0])

    if len(gt) == 0 or len(lt) == 0:
        # Doesn't have ascendings or decendings
        return False
    elif d > 0:
        # Has a flat
        return False
    elif gt[-1] > lt[0]:
        # Not strictly one descent into one ascent
        return False
    else:
        return True

a = [3, 2, 1, 2, 3]
print(valley(a), ...)
>>> True False False False

Answer 4

实际上，我不想发送完整的解决方案，但我只是想解决，而且第一次（希望最后一次）是我为任务发布解决方案。

这是我的解决方案，当然还有其他解决方案，这是我用手指输入的第一个解决方案。

def valley(heights):
    directions = []

    # Check input
    if not heights:
        return False

    # Traverse array and compare current height with previous one
    # if we are going down or up.
    pre = heights[0]
    for h in heights[1:]:
        if h > pre:
            # If we are going upward add 1
            directions.append(1)
        elif h < pre:
            # If we are going downward add -1
            directions.append(-1)
        pre = h

    # We have many -1s and 1s in out directions list.
    # However, if it is a valley then it should first down and up
    # which is [-1, 1]. Return the comparison result with [-1, 1]
    return set(directions) == set([-1, 1])

查找在整数列表中是否存在谷

4 个答案: