Se dice que una lista de enteros es un valle si consiste en una secuencia de valores estrictamente decrecientes seguida de una secuencia de valores estrictamente crecientes. Las secuencias decrecientes y crecientes deben tener una longitud de al menos 2. El último valor de la secuencia decreciente es el primer valor de la secuencia ascendente.

Escriba una función Python valley (l) que tome una lista de enteros y devuelva True si l es un valle y False en caso contrario.

Aquí hay algunos ejemplos para mostrar cómo debería funcionar su función.

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

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

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

Llevo 2 días sin dormir y lo mejor que puedo escribir es este código

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
0
Raja 8 sep. 2018 a las 22:38

3 respuestas

La solución que encontré también funciona si los números no están en secuencia perfecta y no es necesario que el valor más bajo sea igual a 1, lo que estoy tratando de decir es si se supone que la lista [14,12,10, 5,3,6,7,32,41], aquí también se forma un valle, ya que los valores disminuyen hasta 3 (el más bajo) y luego aumenta nuevamente. Las listas como [4,3,2,1,2,3,4] son un valle perfecto.

Solución:

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)

No olvide aceptarlo si esto resuelve el problema y es de gran ayuda, gracias.

2
Souvikavi 18 feb. 2019 a las 10:44

En realidad, no quería enviar una solución completa, pero solo quería resolver y, por primera vez, y con suerte la última vez, estoy publicando una solución para una tarea.

Aquí está mi solución, por supuesto, puede haber otras soluciones, esta es la primera que escribieron mis dedos.

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])
1
cengineer 8 sep. 2018 a las 20:01

El resultado de la variable n en la función del valle, es la diferencia por pares de los números en la lista de entrada, entonces si

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

Ahora la siguiente variable h es, de nuevo, la diferencia en pares de la n, entonces h será

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

Entonces, cada vez que tenga un valle, solo tiene que verificar el patrón "020". Use el módulo re en python para hacerlo,

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

Por favor, hágamelo saber si es correcta o no.

1
Felix 8 sep. 2018 a las 22:46