from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Verifica si en la lista dada de números, hay dos números más cercanos entre sí que
    el umbral dado.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Verifica si en la lista dada de números, hay dos números más cercanos entre sí que
    el límite dado.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ La entrada de esta función es una cadena que contiene múltiples grupos de paréntesis anidados. Tu objetivo es
    separar esos grupos en cadenas separadas y devolver la lista de estas.
    Los grupos separados están balanceados (cada paréntesis abierto está correctamente cerrado) y no están anidados entre sí.
    Ignora cualquier espacio en la cadena de entrada.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ La entrada de esta función es una cadena que contiene múltiples grupos de paréntesis anidados. Tu objetivo es
    separar esos grupos en cadenas separadas y devolver la lista de estas.
    Los grupos separados están balanceados (cada paréntesis abierto está correctamente cerrado) y no están anidados entre sí
    Ignora cualquier espacio en la cadena de entrada.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    "" "La entrada a esta función es una cadena que contiene múltiples grupos de paréntesis anidados. Su objetivo es
    Separe esos grupos en cadenas individuales y devuelva la lista de ellas.
    Los grupos separados están balanceados (Cada paréntesis de apertura está cerrado correctamente) y no anidados entre sí
    Ignore cualquier espacio en la cadena de entrada.
    >>> separate_paren_groups ('() (()) (() ())')
    ['()', '(())', '(() ())']
    "" "


def truncate_number(number: float) -> float:
    """ Dado un número de punto flotante positivo, se puede descomponer en
    una parte entera (el entero más grande menor que el número dado) y decimales
    (parte sobrante siempre menor que 1).

    Devuelve la parte decimal del número.
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Se te da una lista de operaciones de depósito y retiro en una cuenta bancaria que comienza con
    saldo cero. Tu tarea es detectar si en algún momento el saldo de la cuenta cae por debajo de cero, y
    en ese momento la función debería devolver True. De lo contrario, debería devolver False.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Para una lista dada de números de entrada, calcular la Desviación Absoluta Media
    alrededor de la media de este conjunto de datos.
    La Desviación Absoluta Media es la diferencia absoluta promedio entre cada
    elemento y un punto central (media en este caso):
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Para una lista dada de números de entrada, calcular la Desviación Absoluta Media
    alrededor de la media de este conjunto de datos.
    La Desviación Absoluta Media es la diferencia absoluta promedio entre cada
    elemento y un punto central (media en este caso):
    DAM = promedio | x - x_media |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Inserta un número 'delimeter' entre cada dos elementos consecutivos de la lista de entrada `numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ La entrada de esta función es una cadena que representa múltiples grupos de paréntesis anidados separados por espacios.
    Para cada uno de los grupos, devuelve el nivel más profundo de anidamiento de paréntesis.
    Por ejemplo, (()()) tiene un máximo de dos niveles de anidamiento, mientras que ((())) tiene tres.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Filtra una lista de cadenas de entrada solo por aquellas que contienen la subcadena dada
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ Para una lista dada de enteros, devuelve una tupla que consiste en una suma y un producto de todos los enteros en una lista.
    La suma vacía debe ser igual a 0 y el producto vacío debe ser igual a 1.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ A partir de una lista dada de enteros, genera una lista del máximo elemento acumulado encontrado hasta el momento
    en la secuencia.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ Prueba si la cadena dada es un palíndromo """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Encuentra el palíndromo más corto que comienza con una cadena suministrada.
    La idea del algoritmo es simple:
    - Encuentra el sufijo más largo de la cadena suministrada que sea un palíndromo.
    - Añade al final de la cadena el reverso de un prefijo de cadena que viene antes del sufijo palindrómico.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ La entrada son dos cadenas a y b que consisten solo en 1s y 0s.
    Realiza XOR binario en estas entradas y devuelve el resultado también como una cadena.
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ De una lista de cadenas, devuelve la más larga. Devuelve la primera en caso de múltiples
    cadenas de la misma longitud. Devuelve None en caso de que la lista de entrada esté vacía.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """


def greatest_common_divisor(a: int, b: int) -> int:
    """ Devuelve el máximo común divisor de dos enteros a y b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Devuelve una lista de todos los prefijos desde el más corto hasta el más largo de la cadena de entrada
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ Devuelve una cadena que contiene números delimitados por espacios, comenzando desde 0 hasta n inclusive.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Devuelve una cadena que contiene números delimitados por espacios comenzando desde 0 hasta n inclusive.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ Dada una cadena, averigua cuántos caracteres distintos (sin importar mayúsculas o minúsculas) contiene
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ Dada una cadena, averigua de cuántos caracteres distintos (sin importar mayúsculas o minúsculas) consta
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ La entrada de esta función es una cadena que representa notas musicales en un formato ASCII especial.
    Tu tarea es analizar esta cadena y devolver una lista de enteros que corresponden a cuántos tiempos dura cada
    nota.

    Aquí está la leyenda:
    'o' - nota completa, dura cuatro tiempos
    'o|' - media nota, dura dos tiempos
    '.|' - cuarto de nota, dura un tiempo

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ La entrada de esta función es una cadena que representa notas musicales en un formato ASCII especial.
    Tu tarea es analizar esta cadena y devolver una lista de enteros que corresponden a cuántos tiempos dura cada
    nota.

    Aquí está la leyenda:
    'o' - nota completa, dura cuatro pulsos
    'o|' - media nota, dura dos pulsos
    '.|' - cuarto de nota, dura un pulso

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """


def how_many_times(string: str, substring: str) -> int:
    """ Encuentra cuántas veces una subcadena dada puede ser encontrada en la cadena original. Cuenta los casos superpuestos.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ Encuentra cuántas veces se puede encontrar una subcadena dada en la cadena original. Cuenta los casos superpuestos.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    """ La entrada es una cadena delimitada por espacios de números de 'zero' a 'nine'.
    Las opciones válidas son 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' y 'nine'.
    Devuelve la cadena con los números ordenados de menor a mayor
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ De una lista de números proporcionada (de longitud al menos dos), seleccione y devuelva dos que sean los más cercanos entre sí y devuélvalos en orden (número menor, número mayor).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ De una lista proporcionada de números (de longitud al menos dos) selecciona y devuelve dos que estén más
    cerca uno del otro y devuélvelos en orden (número menor, número mayor).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Dada una lista de números (de al menos dos elementos), aplica una transformación lineal a esa lista,
    de modo que el número más pequeño se convierta en 0 y el más grande se convierta en 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Filtrar la lista dada de cualquier valor de Python solo para enteros
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Filtrar la lista dada de cualquier valor de python solo para enteros
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ Devuelve la longitud de la cadena dada
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ Para un número dado n, encuentra el número más grande que divide a n exactamente, menor que n
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ Para un número dado n, encuentra el número más grande que divide a n de manera exacta, menor que n
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ Devuelve una lista de factores primos del entero dado en orden de menor a mayor.
    Cada uno de los factores debe aparecer tantas veces como aparezca en la factorización.
    El número de entrada debe ser igual al producto de todos los factores
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ De una lista de enteros, elimina todos los elementos que ocurren más de una vez.
    Mantén el orden de los elementos restantes igual que en la entrada.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ Para una cadena dada, cambia los caracteres en minúscula a mayúscula y los caracteres en mayúscula a minúscula.
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ Concatenar una lista de cadenas en una sola cadena
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ Filtrar una lista de cadenas de entrada solo por aquellas que comienzan con un prefijo dado.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """Devuelve solo los números positivos en la lista.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """Devuelve verdadero si un número dado es primo, y falso en caso contrario.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """Devuelve true si un número dado es primo, y false en caso contrario.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    Evalúa el polinomio con coeficientes xs en el punto x.
    retorna xs[0] + xs[1] * x + xs[2] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs son los coeficientes de un polinomio.
    find_zero encuentra x tal que poly(x) = 0.
    find_zero devuelve solo un punto cero, aunque pueda haber varios.
    Además, find_zero solo toma la lista xs con un número par de coeficientes
    y el coeficiente más grande no nulo ya que garantiza
    una solución.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Evalúa el polinomio con coeficientes xs en el punto x.
    devuelve xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs son los coeficientes de un polinomio.
    find_zero encuentra x tal que poly(x) = 0.
    find_zero devuelve solo un punto cero, incluso si hay muchos.
    Además, find_zero solo toma la lista xs con un número par de coeficientes
    y el coeficiente más grande no nulo ya que garantiza
    una solución.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Evalúa el polinomio con coeficientes xs en el punto x.
    devuelve xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs son los coeficientes de un polinomio.
    find_zero encuentra x tal que poly(x) = 0.
    find_zero devuelve solo un punto cero, incluso si hay muchos.
    Además, find_zero solo toma la lista xs con un número par de coeficientes
    y el coeficiente más grande no nulo, ya que garantiza
    una solución.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """Esta función toma una lista l y devuelve una lista l' tal que
    l' es idéntica a l en los índices que no son divisibles por tres, mientras que sus valores en los índices que son divisibles por tres son iguales
    a los valores de los índices correspondientes de l, pero ordenados.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """Devuelve elementos únicos ordenados en una lista
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """Devuelve el elemento máximo en la lista.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """Devuelve el número de veces que el dígito 7 aparece en enteros menores que n que son divisibles por 11 o 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """Esta función toma una lista l y devuelve una lista l' tal que
    l' es idéntica a l en los índices impares, mientras que sus valores en los índices pares son iguales
    a los valores de los índices pares de l, pero ordenados.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    devuelve una cadena codificada al ciclar grupos de tres caracteres.
    """
    # dividir la cadena en grupos. Cada uno de longitud 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # ciclar elementos en cada grupo. A menos que el grupo tenga menos de 3 elementos.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    toma como entrada una cadena codificada con la función encode_cyclic. Devuelve la cadena decodificada.
    """


def prime_fib(n: int):
    """
    prime_fib devuelve el n-ésimo número que es un número de Fibonacci y también es primo.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero toma una lista de enteros como entrada.
    devuelve True si hay tres elementos distintos en la lista que
    suman cero, y False en caso contrario.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """


def car_race_collision(n: int):
    """
    Imagina una carretera que es una línea perfectamente recta e infinitamente larga.
    n coches están conduciendo de izquierda a derecha; simultáneamente, un conjunto diferente de n coches
    están conduciendo de derecha a izquierda. Los dos conjuntos de coches comienzan estando muy lejos
    el uno del otro. Todos los coches se mueven a la misma velocidad. Se dice que dos coches colisionan
    cuando un coche que se mueve de izquierda a derecha choca con un coche que se mueve de derecha a izquierda.
    Sin embargo, los coches son infinitamente resistentes y fuertes; como resultado, continúan moviéndose
    en su trayectoria como si no hubieran colisionado.

    Esta función devuelve el número de tales colisiones.
    """


def incr_list(l: list):
    """Devuelve una lista con elementos incrementados en 1.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero toma una lista de enteros como entrada.
    devuelve True si hay dos elementos distintos en la lista que
    suman cero, y False en caso contrario.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """


def change_base(x: int, base: int):
    """Cambia la base numérica del número de entrada x a base.
    devuelve la representación en cadena después de la conversión.
    los números de base son menores que 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Cambia la base numérica del número de entrada x a la base.
    devuelve la representación en cadena después de la conversión.
    los números de base son menores que 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """Dado el largo de un lado y la altura, devuelve el área de un triángulo.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """Dado el largo de un lado y la altura devuelve el área de un triángulo.
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """La secuencia de números Fib4 es una secuencia similar a la secuencia de Fibonacci que se define de la siguiente manera:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Por favor, escriba una función para calcular eficientemente el n-ésimo elemento de la secuencia de números fib4. No use recursión.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """La secuencia de números Fib4 es una secuencia similar a la secuencia de Fibonacci que se define de la siguiente manera:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Por favor escriba una función para calcular eficientemente el n-ésimo elemento de la secuencia de números fib4. No use recursión.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """Devuelve la mediana de los elementos en la lista l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    Verifica si la cadena dada es un palíndromo
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """Devuelve 2^n módulo p (ten cuidado con los números).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    devuelve una cadena codificada desplazando cada carácter 5 posiciones en el alfabeto.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    toma como entrada una cadena codificada con la función encode_shift. Devuelve la cadena decodificada.
    """


def remove_vowels(text):
    """
    remove_vowels es una función que toma una cadena y devuelve la cadena sin vocales.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


def below_threshold(l: list, t: int):
    """Devuelve True si todos los números en la lista l están por debajo del umbral t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """Suma dos números x e y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    Verifica si dos palabras tienen los mismos caracteres.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """Devuelve el n-ésimo número de Fibonacci.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ brackets es una cadena de "<" y ">".
    devuelve True si cada paréntesis de apertura tiene un paréntesis de cierre correspondiente.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """


def monotonic(l: list):
    """Devuelve True si los elementos de la lista son monótonamente crecientes o decrecientes.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """Devuelve los elementos comunes únicos ordenados de dos listas.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """Devuelve los elementos comunes únicos ordenados para dos listas.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """Devuelve el mayor factor primo de n. Suponga que n > 1 y no es un primo.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n es una función que suma números del 1 al n.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_to_n es una función que suma números del 1 al n
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """ brackets es una cadena de "(" y ")".
    devuelve True si cada paréntesis de apertura tiene un paréntesis de cierre correspondiente.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """


def derivative(xs: list):
    """ xs representa los coeficientes de un polinomio.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     Devuelve la derivada de este polinomio en la misma forma.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """La secuencia de números FibFib es una secuencia similar a la secuencia de Fibonacci que se define de la siguiente manera:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Por favor, escriba una función para calcular eficientemente el n-ésimo elemento de la secuencia de números fibfib.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """La secuencia de números FibFib es una secuencia similar a la secuencia de Fibonacci que se define de la siguiente manera:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Por favor escriba una función para calcular eficientemente el n-ésimo elemento de la secuencia de números fibfib.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """La secuencia numérica FibFib es una secuencia similar a la secuencia de Fibbonacci que se define de la siguiente manera:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Escriba una función para calcular de manera eficiente el elemento n-ésimo de la secuencia numérica fibfib.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
Agregar más casos de prueba.
"""

def vowels_count(s):
    """Escribe una función vowels_count que tome una cadena que representa
    una palabra como entrada y devuelva el número de vocales en la cadena.
    Las vocales en este caso son 'a', 'e', 'i', 'o', 'u'. Aquí, 'y' también es
    una vocal, pero solo cuando está al final de la palabra dada.

    Ejemplo:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """Desplaza circularmente los dígitos del entero x, desplaza los dígitos a la derecha por shift
    y devuelve el resultado como una cadena.
    Si shift > número de dígitos, devuelve los dígitos invertidos.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """Desplazamiento circular de los dígitos del entero x, desplaza los dígitos a la derecha por shift
    y devuelve el resultado como una cadena.
    Si shift > número de dígitos, devuelve los dígitos invertidos.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """Tarea
    Escribe una función que tome una cadena como entrada y devuelva la suma de los códigos ASCII
    de solo los caracteres en mayúsculas.

    Ejemplos:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s,n):
    """
    En esta tarea, se te dará una cadena que representa un número de manzanas y naranjas
    que se distribuyen en una canasta de frutas. Esta canasta contiene
    manzanas, naranjas y mangos. Dada la cadena que representa el número total de
    naranjas y manzanas y un entero que representa el número total de frutas
    en la canasta, devuelve el número de mangos en la canasta.
    por ejemplo:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    En esta tarea, se te proporcionará una cadena que representa un número de manzanas y naranjas
    que se distribuyen en una canasta de frutas, la cuál contiene
    manzanas, naranjas y mangos. Dada la cadena que representa el número total de
    naranjas y manzanas y un entero que representa el número total de frutas
    en la canasta devuelve el número de mangos.
    por ejemplo:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    En esta tarea, se te proporcionará una cadena que representa un número de manzanas y naranjas
    que se distribuyen en una canasta de frutas, la cual contiene
    manzanas, naranjas y mangos. Dada la cadena que representa el número total de
    naranjas y manzanas y un entero que representa el número total de frutas
    en la canasta devuelve el número de mangos.
    por ejemplo:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


def pluck(arr):
    """
    "Dado un arreglo que representa una rama de un árbol que tiene nodos enteros no negativos
    su tarea es arrancar uno de los nodos y devolverlo.
    El nodo arrancado debe ser el nodo con el valor par más bajo.
    Si se encuentran varios nodos con el mismo valor par más bajo, devuelve el nodo que tiene el índice más pequeño.

    El nodo extraído debe ser devuelto en una lista, [ smallest_value, su índice ],
    Si no hay valores pares o el array dado está vacío, devuelve [].

    Ejemplo 1:
        Entrada: [4,2,3]
        Salida: [2, 1]
        Explicación: 2 tiene el valor par más pequeño, y 2 tiene el índice más pequeño.

    Ejemplo 2:
        Entrada: [1,2,3]
        Salida: [2, 1]
        Explicación: 2 tiene el valor par más pequeño, y 2 tiene el índice más pequeño.

    Ejemplo 3:
        Entrada: []
        Salida: []

    Ejemplo 4:
        Entrada: [5, 0, 3, 0, 4, 2]
        Salida: [0, 1]
        Explicación: 0 es el valor más pequeño, pero hay dos ceros,
                     por lo que vamos a elegir el primer cero, que tiene el índice más pequeño.

    Restricciones:
         * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    Dada una matriz que representa una rama de un árbol con nodos enteros no negativos,
    tu tarea es arrancar uno de los nodos y devolverlo.
    El nodo arrancado debe ser el nodo con el valor par más pequeño.
    Si se encuentran múltiples nodos con el mismo valor par más pequeño, devuelve el nodo que tiene el índice más pequeño.

    El nodo arrancado debe devolverse en una lista, [valor_más_pequeño, su índice],
    Si no hay valores pares o la matriz dada está vacía, return [].

    Ejemplo 1:
        Entrada: [4,2,3]
        Salida: [2, 1]
        Explicación: 2 tiene el valor par más pequeño y el índice más pequeño.

    Ejemplo 2:
        Entrada: [1,2,3]
        Salida: [2, 1]
        Explicación: 2 tiene el valor par más pequeño y el índice más pequeño.

    Ejemplo 3:
        Entrada: []
        Salida: []

    Ejemplo 4:
        Entrada: [5, 0, 3, 0, 4, 2]
        Salida: [0, 1]
        Explicación: 0 es el valor más pequeño, pero hay dos ceros,
                     así que elegiremos el primer cero, que tiene el índice más pequeño.

    Restricciones:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Dada una matriz que representa una rama de un árbol que tiene nodos enteros no negativos,
    tu tarea es arrancar uno de los nodos y devolverlo.
    El nodo arrancado debe ser el nodo con el valor par más pequeño.
    Si se encuentran múltiples nodos con el mismo valor par más pequeño, devuelve el nodo que tiene el índice más pequeño.

    El nodo arrancado debe devolverse en una lista, [ smalest_value, su índice ],
    Si no hay valores pares o la matriz dada está vacía, devuelve [].

    Ejemplo 1:
        Entrada: [4,2,3]
        Salida: [2, 1]
        Explicación: 2 tiene el valor par más pequeño, y 2 tiene el índice más pequeño.

    Ejemplo 2:
        Entrada: [1,2,3]
        Salida: [2, 1]
        Explicación: 2 tiene el valor par más pequeño, y 2 tiene el índice más pequeño.

    Ejemplo 3:
        Entrada: []
        Salida: []

    Ejemplo 4:
        Entrada: [5, 0, 3, 0, 4, 2]
        Salida: [0, 1]
        Explicación: 0 es el valor más pequeño, pero hay dos ceros,
                     así que elegiremos el primer cero, que tiene el índice más pequeño.

    Restricciones:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    Se te da una lista no vacía de enteros positivos. Devuelve el mayor entero que es mayor que
    cero, y tiene una frecuencia mayor o igual al valor del propio entero.
    La frecuencia de un entero es el número de veces que aparece en la lista.
    Si no existe tal valor, devuelve -1.
    Ejemplos:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''


def strange_sort_list(lst):
    '''
    Dada una lista de números enteros, devuelve la lista en orden extraño.
    El orden extraño es cuando se comienza con el valor mínimo,
    luego el máximo de los números enteros restantes, luego el mínimo y así sucesivamente.

    Ejemplos:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    Dada una lista de enteros, devuelve la lista en un orden extraño.
    Orden extraño, es cuando comienzas con el valor mínimo,
    luego el máximo de los enteros restantes, luego el mínimo y así sucesivamente.

    Ejemplos:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    Dados los largos de los tres lados de un triángulo. Devuelve el área del
    triángulo redondeado a 2 decimales si los tres lados forman un triángulo válido.
    De lo contrario, devuelve -1.
    Tres lados forman un triángulo válido cuando la suma de dos lados cualesquiera es mayor
    que el tercer lado.
    Ejemplo:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Dados los largos de los tres lados de un triángulo. Devuelve el área del
    triángulo redondeado a 2 decimales si los tres lados forman un triángulo válido.
    De lo contrario, devuelve -1.
    Tres lados forman un triángulo válido cuando la suma de cualquier dos lados es mayor
    que el tercer lado.
    Ejemplo:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Dados los largos de los tres lados de un triángulo. Devuelve el área del
    triángulo redondeado a 2 decimales si los tres lados forman un triángulo válido.
    De lo contrario, devuelve -1
    Tres lados forman un triángulo válido cuando la suma de cualesquiera dos lados es mayor
    que el tercer lado.
    Ejemplo:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q,w):
    '''
    Escribe una función que devuelva True si el objeto q volará, y False en caso contrario.
    El objeto q volará si está equilibrado (es una lista palindrómica) y la suma de sus elementos es menor o igual al peso máximo posible w.

    Ejemplo:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 es menor que el peso máximo posible, pero no está equilibrado.

    will_it_fly([3, 2, 3], 1) ➞ False
    # está equilibrado, pero 3+2+3 es más que el peso máximo posible.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 es menor que el peso máximo posible, y está equilibrado.

    will_it_fly([3], 5) ➞ True
    # 3 es menor que el peso máximo posible, y está equilibrado.
    '''


def smallest_change(ar):
    """
    Dado un array arr de enteros, encontrar el número mínimo de elementos que
    necesita ser cambiado para hacer que el array sea palindrómico. Un array palindrómico es un array que
    se lee igual hacia atrás y hacia adelante. En un cambio, puede cambiar un elemento a cualquier otro elemento.

    Por ejemplo:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    Dada una matriz arr de enteros, encuentra el número mínimo de elementos que
    necesitan ser cambiados para hacer que la matriz sea palíndroma. Una matriz palíndroma es una matriz que
    se lee igual hacia atrás y hacia adelante. En un cambio, puedes cambiar un elemento por cualquier otro elemento.

    Por ejemplo:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    Dada una matriz arr de enteros, encuentra el número mínimo de elementos que
    necesitan ser cambiados para hacer que la matriz sea palindrómica. Una matriz palindrómica es una matriz que
    se lee igual hacia atrás y hacia adelante. En un cambio, puedes cambiar un elemento por cualquier otro elemento.

    Por ejemplo:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


def total_match(lst1, lst2):
    '''
    Escribe una función que acepte dos listas de cadenas y devuelva la lista que tiene
    el número total de caracteres en todas las cadenas de la lista menor que la otra lista.

    si las dos listas tienen el mismo número de caracteres, devuelve la primera lista.

    Ejemplos
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''


def is_multiply_prime(a):
    """Escribe una función que devuelva verdadero si el número dado es la multiplicación de 3 números primos
    y falso en caso contrario.
    Sabiendo que (a) es menor que 100.
    Ejemplo:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Escribe una función que devuelva true si el número dado es la multiplicación de 3 números primos
    y false en caso contrario.
    Sabiendo que (a) es menor que 100.
    Ejemplo:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """Tu tarea es escribir una función que devuelva verdadero si un número x es una
    potencia simple de n y falso en otros casos.
    x es una potencia simple de n si n**int=x
    Por ejemplo:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """Tu tarea es escribir una función que devuelva true si un número x es una
    potencia simple de n y false en otros casos.
    x es una potencia simple de n si n**int=x
    Por ejemplo:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """


def iscube(a):
    '''
    Escribe una función que tome un entero a y devuelva True
    si este entero es un cubo de algún número entero.
    Nota: puedes asumir que la entrada siempre es válida.
    Ejemplos:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """Se te ha encargado escribir una función que reciba
    un número hexadecimal como una cadena y cuente el número de dígitos
    hexadecimales que son primos (un número primo, o primo, es un número
    natural mayor que 1 que no es producto de dos números naturales más pequeños).
    Los dígitos hexadecimales son 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Los números primos son 2, 3, 5, 7, 11, 13, 17,...
    Así que tienes que determinar un número de los siguientes dígitos: 2, 3, 5, 7,
    B (=decimal 11), D (=decimal 13).
    Nota: puedes asumir que la entrada siempre es correcta o una cadena vacía,
    y los símbolos A,B,C,D,E,F siempre están en mayúsculas.
    Ejemplos:
    Para num = "AB" la salida debería ser 1.
    Para num = "1077E" la salida debería ser 2.
    Para num = "ABED1A33" la salida debería ser 4.
    Para num = "123456789ABCDEF0" la salida debería ser 6.
    Para num = "2020" la salida debería ser 2.
    """


def decimal_to_binary(decimal):
    """Se te dará un número en forma decimal y tu tarea es convertirlo a
    formato binario. La función debe devolver una cadena, con cada carácter representando un número
    binario. Cada carácter en la cadena será '0' o '1'.

    Habrá un par extra de caracteres 'db' al principio y al final de la cadena.
    Los caracteres extra están ahí para ayudar con el formato.

    Ejemplos:
    decimal_to_binary(15)   # devuelve "db1111db"
    decimal_to_binary(32)   # devuelve "db100000db"
    """

def decimal_to_binary(decimal):
    """Se te dará un número en forma decimal y tu tarea es convertirlo a
    formato binario. La función debe devolver una cadena, con cada carácter representando un número
    binario. Cada carácter en la cadena será '0' o '1'.

    Habrá un par extra de caracteres 'db' al principio y al final de la cadena.
    Los caracteres extra están ahí para ayudar con el formato.

    Ejemplos:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """


def is_happy(s):
    """Se te da una cadena s.
    Tu tarea es verificar si la cadena es feliz o no.
    Una cadena es feliz si su longitud es al menos 3 y cada 3 letras consecutivas son distintas
    Por ejemplo:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """Se te da una cadena s.
    Tu tarea es verificar si la cadena es feliz o no.
    Una cadena es feliz si su longitud es al menos 3 y cada 3 letras consecutivas son distintas
    Por ejemplo:
    is_happy(a) => Falso
    is_happy(aa) => Falso
    is_happy(abcd) => Verdadero
    is_happy(aabb) => Falso
    is_happy(adb) => Verdadero
    is_happy(xyy) => Falso
    """


def numerical_letter_grade(grades):
    """Es la última semana del semestre y la profesora tiene que dar las calificaciones
    a los estudiantes. La profesora ha estado creando su propio algoritmo para calificar.
    El único problema es que ha perdido el código que usó para calificar.
    Te ha dado una lista de GPAs para algunos estudiantes y tienes que escribir
    una función que pueda devolver una lista de calificaciones en letras usando la siguiente tabla:
             GPA       |    Calificación en letra
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    Ejemplo:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """Es la última semana del semestre y el profesor tiene que dar las calificaciones
    a los estudiantes. El profesor ha estado creando su propio algoritmo para calificar.
    El único problema es que ha perdido el código que usó para calificar.
    Te ha dado una lista de GPAs para algunos estudiantes y tienes que escribir
    una función que pueda devolver una lista de calificaciones en letras usando la siguiente tabla:
             GPA       |    Calificación en letra
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    Ejemplo:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """


def prime_length(string):
    """Escribe una función que tome una cadena y devuelva True si la longitud
    de la cadena es un número primo o False en caso contrario
    Ejemplos
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    Dado un número entero positivo n, devuelve la cantidad de números de
    n dígitos que comienzan o terminan con 1.
    """


def solve(N):
    """Dado un entero positivo N, devuelve la suma total de sus dígitos en binario.

    Ejemplo
        Para N = 1000, la suma de los dígitos será 1 y la salida debe ser "1".
        Para N = 150, la suma de los dígitos será 6 y la salida debe ser "110".
        Para N = 147, la suma de los dígitos será 12 y la salida debe ser "1100".

    Variables:
        @N entero
             Restricciones: 0 ≤ N ≤ 10000.
    Salida:
         una cadena de número binario
    """


def add(lst):
    """Dada una lista no vacía de enteros lst. suma los elementos pares que están en índices impares.

    Ejemplos:
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    Escribe una función que tome una cadena y devuelva una versión ordenada de ella.
    La versión ordenada de la cadena es una cadena donde todas las palabras (separadas por espacio)
    son reemplazadas por una nueva palabra donde todos los caracteres están ordenados en
    orden ascendente basado en el valor ascii.
    Nota: Debes mantener el orden de las palabras y los espacios en blanco en la oración.

    Por ejemplo:
    anti_shuffle('Hi') devuelve 'Hi'
    anti_shuffle('hello') devuelve 'ehllo'
    anti_shuffle('Hello World!!!') devuelve 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    Escribe una función que tome una cadena y devuelva una versión ordenada de ella.
    La versión ordenada de la cadena, es una cadena donde todas las palabras (separadas por espacio)
    son reemplazadas por una nueva palabra donde todos los caracteres están ordenados en
    orden ascendente basado en el valor ascii.
    Nota: Debes mantener el orden de las palabras y los espacios en blanco en la oración.

    Por ejemplo:
    anti_shuffle('Hi') devuelve 'Hi'
    anti_shuffle('hello') devuelve 'ehllo'
    anti_shuffle('Hello World!!!') devuelve 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    Se te da un dato bidimensional, como listas anidadas,
    que es similar a una matriz, sin embargo, a diferencia de las matrices,
    cada fila puede contener un número diferente de columnas.
    Dada lst, y un entero x, encuentra enteros x en la lista,
    y devuelve una lista de tuplas, [(x1, y1), (x2, y2) ...] tal que
    cada tupla es una coordenada - (fila, columna), comenzando con 0.
    Ordena las coordenadas inicialmente por filas en orden ascendente.
    Además, ordena las coordenadas de la fila por columnas en orden descendente.

    Ejemplos:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """


def sort_array(array):
    """
    Dado un arreglo de enteros no negativos, devuelve una copia del arreglo dado después de ordenarlo,
    ordenarás el arreglo dado en orden ascendente si la suma (valor del primer índice, valor del último índice) es impar,
    o lo ordenarás en orden descendente si la suma (valor del primer índice, valor del último índice) es par.

    Nota:
    * no cambies el arreglo dado.

    Ejemplos:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    Dado un arreglo de enteros no negativos, devuelve una copia del arreglo dado después de ordenarlo,
    ordenarás el arreglo dado en orden ascendente si la suma( valor del primer índice, valor del último índice) es impar,
    o lo ordenarás en orden descendente si la suma( valor del primer índice, valor del último índice) es par.

    Nota:
    * no cambies el arreglo dado.

    Ejemplos:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """


def encrypt(s):
    """Crear una función encrypt que tome una cadena como argumento y
    devuelva una cadena encriptada con el alfabeto rotado.
    El alfabeto debe rotarse de manera que las letras
    se desplacen hacia abajo dos multiplicado por dos lugares.
    Por ejemplo:
    encrypt('hi') devuelve 'lm'
    encrypt('asdfghjkl') devuelve 'ewhjklnop'
    encrypt('gf') devuelve 'kj'
    encrypt('et') devuelve 'ix'
    """


def next_smallest(lst):
    """
    Se te da una lista de enteros.
    Escribe una función next_smallest() que devuelva el 2º elemento más pequeño de la lista.
    Devuelve None si no hay tal elemento.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """


def is_bored(S):
    """
    Se te dará una cadena de palabras, y tu tarea es contar el número
    de frases aburridas. Una frase aburrida es una oración que comienza con la palabra "I".
    Las oraciones están delimitadas por '.', '?' o '!'.

    Por ejemplo:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """


def any_int(x, y, z):
    '''
    Crear una función que tome 3 números.
    Devuelve verdadero si uno de los números es igual a la suma de los otros dos, y todos los números son enteros.
    Devuelve falso en cualquier otro caso.

    Ejemplos
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    Crear una función que tome 3 números.
    Devuelve true si uno de los números es igual a la suma de los otros dos, y todos los números son enteros.
    Devuelve false en cualquier otro caso.

    Ejemplos
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''


def encode(message):
    """
    Escribe una función que tome un mensaje y lo codifique de tal
    manera que cambie el caso de todas las letras, reemplace todas
    las vocales en el mensaje con la letra que aparece 2 lugares
    adelante de esa vocal en el alfabeto inglés.
    Asume solo letras.

    Ejemplos:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Escribe una función que tome un mensaje y lo codifique de tal
    manera que intercambie las mayúsculas y minúsculas de todas las letras, reemplace todas
    las vocales en el mensaje con la letra que aparece 2 lugares
    adelante de esa vocal en el alfabeto inglés.
    Asume solo letras.

    Ejemplos:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Escribe una función que tome un mensaje y lo codifique de tal
    manera que invierta mayúsculas y minúsculas de todas las letras,
    reemplace todas las vocales en el mensaje con la letra que aparece 2
    lugares adelante de esa vocal en el alfabeto inglés.
    Asume solo letras.

    Ejemplos:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """Se te da una lista de enteros.
    Necesitas encontrar el valor primo más grande y devolver la suma de sus dígitos.

    Ejemplos:
    Para lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] la salida debería ser 10
    Para lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] la salida debería ser 25
    Para lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] la salida debería ser 13
    Para lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] la salida debería ser 11
    Para lst = [0,81,12,3,1,21] la salida debería ser 3
    Para lst = [0,8,1,2,1,7] la salida debería ser 7
    """


def check_dict_case(dict):
    """
    Dado un diccionario, devuelve True si todas las claves son cadenas en minúsculas
    o todas las claves son cadenas en mayúsculas, de lo contrario devuelve False.
    La función debe devolver False si el diccionario dado está vacío.
    Ejemplos:
    check_dict_case({"a":"apple", "b":"banana"}) debería devolver True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) debería devolver False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) debería devolver False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) debería devolver False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) debería devolver True.
    """


def count_up_to(n):
    """Implementa una función que toma un entero no negativo y devuelve un arreglo de los primeros n
    enteros que son números primos y menores que n.
    por ejemplo:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """


def multiply(a, b):
    """Completa la función que toma dos enteros y devuelve
    el producto de sus dígitos de las unidades.
    Supón que la entrada siempre es válida.
    Ejemplos:
    multiply(148, 412) debería devolver 16.
    multiply(19, 28) debería devolver 72.
    multiply(2020, 1851) debería devolver 0.
    multiply(14,-15) debería devolver 20.
    """


def count_upper(s):
    """
    Dada una cadena s, cuenta el número de vocales mayúsculas en índices pares.

    Por ejemplo:
    count_upper('aBCdEf') devuelve 1
    count_upper('abcdefg') devuelve 0
    count_upper('dBBE') devuelve 0
    """


def closest_integer(value):
    '''
    Crea una función que tome un valor (cadena) que representa un número
    y devuelva el entero más cercano a él. Si el número está equidistante
    de dos enteros, redondea alejándolo de cero.

    Ejemplos
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Nota:
    Redondear alejándose de cero significa que si el número dado está equidistante
    de dos enteros, el que debes devolver es el que está más lejos de cero. Por ejemplo,
    closest_integer("14.5") debería devolver 15 y closest_integer("-14.5") debería devolver -15.
    '''


def make_a_pile(n):
    """
    Dado un número entero positivo n, tienes que hacer una pila de n niveles de piedras.
    El primer nivel tiene n piedras.
    El número de piedras en el siguiente nivel es:
        - el siguiente número impar si n es impar.
        - el siguiente número par si n es par.
    Devuelve el número de piedras en cada nivel en una lista, donde el elemento en el índice
    i representa el número de piedras en el nivel (i+1).

    Ejemplos:
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    Se le dará una cadena de palabras separadas por comas o espacios. Su tarea es
    dividir la cadena en palabras y devolver un array de las palabras.

    Por ejemplo:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    Se te dará una cadena de palabras separadas por comas o espacios. Tu tarea es
    dividir la cadena en palabras y devolver un arreglo de las palabras.

    Por ejemplo:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """


def choose_num(x, y):
    """Esta función toma dos números positivos x e y y devuelve el
    mayor número entero par que se encuentre en el rango [x, y] inclusive. Si
    no existe dicho número, entonces la función debe devolver -1.

    Por ejemplo:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Esta función toma dos números positivos x e y y devuelve el
    mayor número entero par que está en el rango [x, y] inclusive. Si
    no hay tal número, entonces la función debe devolver -1.

    Por ejemplo:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """Se te dan dos enteros positivos n y m, y tu tarea es calcular el
    promedio de los enteros desde n hasta m (incluyendo n y m).
    Redondea la respuesta al entero más cercano y conviértelo a binario.
    Si n es mayor que m, devuelve -1.
    Ejemplo:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """Dada una lista de enteros positivos x. devuelve una lista ordenada de todos
    los elementos que no tienen ningún dígito par.

    Nota: La lista devuelta debe estar ordenada en orden creciente.

    Por ejemplo:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    Dada una matriz de enteros, ordena los enteros que están entre 1 y 9 inclusive,
    invierte la matriz resultante, y luego reemplaza cada dígito por su nombre correspondiente de
    "Uno", "Dos", "Tres", "Cuatro", "Cinco", "Seis", "Siete", "Ocho", "Nueve".

    Por ejemplo:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Ocho", "Cinco", "Cuatro", "Tres", "Dos", "Dos", "Uno", "Uno"]

      Si la matriz está vacía, devuelve una matriz vacía:
      arr = []
      return []

      Si la matriz contiene algún número fuera del rango, ignóralo:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['Uno']
    """

def by_length(arr):
    """
    Dado un arreglo de enteros, ordena los enteros que están entre 1 y 9 inclusive,
    invierte el arreglo resultante, y luego reemplaza cada dígito por su nombre correspondiente de
    "Uno", "Dos", "Tres", "Cuatro", "Cinco", "Seis", "Siete", "Ocho", "Nueve".

    Por ejemplo:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> ordenar arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> invertir arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Ocho", "Cinco", "Cuatro", "Tres", "Dos", "Dos", "Uno", "Uno"]

      Si la matriz está vacía, devuelve una matriz vacía:
      arr = []
      return []

      Si la matriz contiene algún número fuera del rango, ignóralo:
      arr = [1, -1 , 55]
            -> ordenar arr -> [-1, 1, 55]
            -> invertir arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    Dada una matriz de enteros, ordena los enteros que están entre 1 y 9 inclusive,
    invierte la matriz resultante, y luego reemplaza cada dígito por su nombre correspondiente de
    "Uno", "Dos", "Tres", "Cuatro", "Cinco", "Seis", "Siete", "Ocho", "Nueve".

    Por ejemplo:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> ordenar arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> invertir arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Ocho", "Cinco", "Cuatro", "Tres", "Dos", "Dos", "Uno", "Uno"]

      Si la matriz está vacía, devuelve una matriz vacía:
      arr = []
      return []

      Si la matriz contiene algún número fuera del rango de 1 a 9, ignóralo.
      arr = [1, -1 , 55]
            -> ordenar arr -> [-1, 1, 55]
            -> invertir arr -> [55, 1, -1]
      return = ['One']
    ""


def f(n):
    """ Implementa la función f que toma n como parámetro,
    y devuelve una lista de tamaño n, tal que el valor del elemento en el índice i es el factorial de i si i es par
    o la suma de los números de 1 a i de lo contrario.
    i comienza desde 1.
    el factorial de i es la multiplicación de los números de 1 a i (1 * 2 * ... * i).
    Ejemplo:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ Implementa la función f que toma n como parámetro,
    y devuelve una lista de tamaño n, de modo que el valor del elemento en el índice i sea el factorial de i si i es par
    o la suma de los números del 1 al i en caso contrario.
    i comienza desde 1.
    el factorial de i es la multiplicación de los números del 1 al i (1 * 2 * ... * i).
    Example:
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    Dado un entero positivo n, devuelve una tupla que tiene el número de palíndromos
    enteros pares e impares que se encuentran dentro del rango(1, n), inclusivo.

    Ejemplo 1:

        Entrada: 3
        Salida: (1, 2)
        Explicación:
        Los palíndromos enteros son 1, 2, 3. uno de ellos es par, y dos de ellos son impares.

    Ejemplo 2:

        Entrada: 12
        Salida: (4, 6)
        Explicación:
        Los palíndromos enteros son 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. cuatro de ellos son pares, y 6 de ellos son impares.

    Nota:
        1. 1 <= n <= 10^3
        2. la tupla devuelta tiene el número de palíndromos enteros pares e impares respectivamente.
    """


def count_nums(arr):
    """
    Escribe una función count_nums que tome un arreglo de enteros y devuelva
    el número de elementos que tiene una suma de dígitos > 0.
    Si un número es negativo, entonces su primer dígito con signo será negativo:
    por ejemplo, -123 tiene dígitos con signo -1, 2 y 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """Tenemos un arreglo 'arr' de N enteros arr[1], arr[2], ..., arr[N]. Los
    números en el arreglo estarán ordenados aleatoriamente. Tu tarea es determinar si
    es posible obtener un arreglo ordenado en orden no decreciente realizando
    la siguiente operación en el arreglo dado:
        Se te permite realizar la operación de desplazamiento a la derecha cualquier número de veces.

    Una operación de desplazamiento a la derecha significa desplazar todos los elementos del arreglo
    una posición en la dirección derecha. El último elemento del arreglo se moverá a
    la posición inicial en el arreglo, es decir, al índice 0.

    Si es posible obtener el arreglo ordenado realizando la operación anterior,
    entonces devuelve True, de lo contrario devuelve False.
    Si el arreglo dado está vacío, devuelve True.

    Nota: Se garantiza que la lista dada tiene elementos únicos.

    Por ejemplo:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Explicación: Realizando 2 operaciones de desplazamiento a la derecha, se puede
                 lograr un orden no decreciente para el arreglo dado.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Explicación: No es posible obtener un orden no decreciente para el
                arreglo dado realizando cualquier número de operaciones de desplazamiento a la derecha.

    """

def move_one_ball(arr):
    """Tenemos un array 'arr' de N números enteros arr[1], arr[2], ..., arr[N]. Los
    números en el array se ordenarán aleatoriamente. Su tarea es determinar si
    es posible obtener un array ordenado en orden no decreciente mediante la realización de
    la siguiente operación en el array dado:
        Puedes realizar la operación de desplazamiento a la derecha cualquier número de veces.

    Una operación de desplazamiento a la derecha significa desplazar todos los elementos del arreglo por una
    posición en la dirección derecha. El último elemento del array se moverá a
    la posición inicial en el array, es decir, el índice 0.

    Si es posible obtener el array ordenado realizando la operación anterior
    entonces devuelve True sino devuelve False.
    Si el array dado está vacío, devuelve True.

    Nota: La lista dada tiene garantizado tener elementos únicos.

    Por ejemplo:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Explicación: Realizando 2 operaciones de desplazamiento a la derecha, se puede lograr un orden no decreciente para el array dado.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Explicación: No es posible obtener un orden no decreciente para el dado
                array mediante la realización de cualquier número de operaciones de desplazamiento a la derecha.

    """

def move_one_ball(arr):
    """Tenemos un array 'arr' de N enteros arr[1], arr[2], ..., arr[N]. Los
    números en el array estarán ordenados aleatoriamente. Tu tarea es determinar si
    es posible obtener un array ordenado en orden no decreciente realizando
    la siguiente operación en el array dado:
        Se te permite realizar la operación de desplazamiento a la derecha cualquier número de veces.

    Una operación de desplazamiento a la derecha significa desplazar todos los elementos del array
    una posición en la dirección derecha. El último elemento del array se moverá a
    la posición inicial en el array, es decir, al índice 0.

    Si es posible obtener el array ordenado realizando la operación anterior,
    entonces devuelve True, de lo contrario devuelve False.
    Si el array dado está vacío, devuelve True.

    Nota: Se garantiza que la lista dada tiene elementos únicos.

    Por ejemplo:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Explicación: Realizando 2 operaciones de desplazamiento a la derecha, se puede
                 lograr un orden no decreciente para el array dado.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Explicación: No es posible obtener un orden no decreciente para el
                array dado realizando cualquier número de operaciones de desplazamiento a la derecha.

    """


def exchange(lst1, lst2):
    """En este problema, implementarás una función que toma dos listas de números,
    y determina si es posible realizar un intercambio de elementos
    entre ellas para hacer que lst1 sea una lista de solo números pares.
    No hay límite en el número de elementos intercambiados entre lst1 y lst2.
    Si es posible intercambiar elementos entre lst1 y lst2 para que
    todos los elementos de lst1 sean pares, devuelve "YES".
    De lo contrario, devuelve "NO".
    Por ejemplo:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Se asume que las listas de entrada no estarán vacías.
    """


def histogram(test):
    """Dada una cadena que representa letras minúsculas separadas por espacios, devuelve un diccionario
    de la letra con más repeticiones y que contiene el conteo correspondiente.
    Si varias letras tienen la misma ocurrencia, devuelve todas ellas.

    Ejemplo:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """Dada una cadena que representa letras minúsculas separadas por espacios, devuelve un diccionario
    de la letra con más repeticiones y que contiene el conteo correspondiente.
    Si varias letras tienen la misma ocurrencia, devuélvelas todas.

    Ejemplo:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """


def reverse_delete(s,c):
    """Tarea
    Se nos dan dos cadenas s y c, tienes que eliminar todos los caracteres en s que sean iguales a cualquier carácter en c
    luego verificar si la cadena resultante es un palíndromo.
    Una cadena se llama palíndromo si se lee igual de adelante hacia atrás que de atrás hacia adelante.
    Debes devolver una tupla que contenga la cadena resultante y True/False para la verificación.
    Ejemplo
    Para s = "abcde", c = "ae", el resultado debería ser ('bcd',False)
    Para s = "abcdef", c = "b" el resultado debería ser ('acdef',False)
    Para s = "abcdedcba", c = "ab", el resultado debería ser ('cdedc',True)
    """


def odd_count(lst):
    """Dada una lista de cadenas, donde cada cadena consiste solo en dígitos, devuelve una lista.
    Cada elemento i de la salida debe ser "el número de elementos impares en la
    cadena i de la entrada." donde todos los i deben ser reemplazados por el número
    de dígitos impares en la i-ésima cadena de la entrada.

    >>> odd_count(['1234567'])
    ["el número de elementos impares 4n la str4ng 4 de la 4nput."]
    >>> odd_count(['3',"11111111"])
    ["el número de elementos impares en la cadena 1n la str1ng 1 de la 1nput.",
     "el número de elementos impares en la cadena 8n la str8ng 8 de la 8nput."]
    """

def odd_count(lst):
    """Dada una lista de cadenas, donde cada cadena consiste solo en dígitos, devuelve una lista.
    Cada elemento i de la salida debe ser "el número de elementos impares en la
    cadena i de la entrada." donde todos los i deben ser reemplazados por el número
    de dígitos impares en la i-ésima cadena de la entrada.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """

def odd_count(lst):
    """Dada una lista de cadenas, donde cada cadena consiste solo en dígitos, devuelve una lista.
    Cada elemento i de la salida debe ser "el número de elementos impares en la cadena i de la entrada." donde todas las i deben ser reemplazadas por el número
    de dígitos impares en la i-ésima cadena de la entrada.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """


def minSubArraySum(nums):
    """
    Dada una matriz de enteros nums, encuentra la suma mínima de cualquier subarreglo
    no vacío de nums.
    Ejemplo
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

def max_fill(grid, capacity):
    """
    Se te da una cuadrícula rectangular de pozos. Cada fila representa un solo pozo,
    y cada 1 en una fila representa una sola unidad de agua.
    Cada pozo tiene un cubo correspondiente que se puede usar para extraer agua de él,
    y todos los cubos tienen la misma capacidad.
    Tu tarea es usar los cubos para vaciar los pozos.
    Devuelve el número de veces que necesitas bajar los cubos.

    Ejemplo 1:
        Entrada:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Salida: 6

    Ejemplo 2:
        Entrada:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Salida: 5

    Ejemplo 3:
        Entrada:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Salida: 0

    Restricciones:
        * todos los pozos tienen la misma longitud
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Se te da una cuadrícula rectangular de pozos. Cada fila representa un solo pozo,
    y cada 1 en una fila representa una sola unidad de agua.
    Cada pozo tiene un cubo correspondiente que se puede usar para extraer agua de él,
    y todos los cubos tienen la misma capacidad.
    Tu tarea es usar los cubos para vaciar los pozos.
    Salida el número de veces que necesitas bajar los cubos.

    Ejemplo 1:
        Entrada:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Salida: 6

    Ejemplo 2:
        Entrada:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Salida: 5

    Ejemplo 3:
        Entrada:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Salida: 0

    Restricciones:
        * todos los pozos tienen la misma longitud
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    En este Kata, tienes que ordenar un arreglo de enteros no negativos según
    el número de unos en su representación binaria en orden ascendente.
    Para un número similar de unos, ordenar basado en el valor decimal.

    Debe implementarse así:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    En este Kata, tienes que ordenar un array de enteros no negativos según
    el número de unos en su representación binaria en orden ascendente.
    Para un número similar de unos, ordenar basado en el valor decimal.

    Debe implementarse así:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """


def select_words(s, n):
    """Dada una cadena s y un número natural n, se te ha encargado implementar
    una función que devuelva una lista de todas las palabras de la cadena s que contengan
    exactamente n consonantes, en el orden en que estas palabras aparecen en la cadena s.
    Si la cadena s está vacía, entonces la función debe devolver una lista vacía.
    Nota: puedes asumir que la cadena de entrada contiene solo letras y espacios.
    Ejemplos:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """


def get_closest_vowel(word):
    """Se te da una palabra. Tu tarea es encontrar la vocal más cercana que se encuentra entre
    dos consonantes desde el lado derecho de la palabra (sensible a mayúsculas).

    Las vocales al principio y al final no cuentan. Devuelve una cadena vacía si no encuentras
    ninguna vocal que cumpla con la condición anterior.

    Puedes asumir que la cadena dada contiene solo letras en inglés.

    Ejemplo:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    Se te da una lista de dos cadenas, ambas cadenas consisten solo en
    paréntesis abiertos '(' o paréntesis cerrados ')'.
    Tu tarea es verificar si es posible concatenar las dos cadenas en
    algún orden, de modo que la cadena resultante sea buena.
    Una cadena S se considera buena si y solo si todos los paréntesis en S
    están balanceados. Por ejemplo: la cadena '(())()' es buena, mientras que la cadena
    '())' no lo es.
    Devuelve 'Yes' si hay una manera de hacer una cadena buena, y devuelve 'No' de lo contrario.

    Ejemplos:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    Dado un arreglo arr de enteros y un entero positivo k, devuelve una lista ordenada
    de longitud k con los k números máximos en arr.

    Ejemplo 1:

        Entrada: arr = [-3, -4, 5], k = 3
        Salida: [-4, -3, 5]

    Ejemplo 2:

        Entrada: arr = [4, -4, 4], k = 2
        Salida: [4, 4]

    Ejemplo 3:

        Entrada: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Salida: [2]

    Nota:
        1. La longitud del arreglo estará en el rango de [1, 1000].
        2. Los elementos en el arreglo estarán en el rango de [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Dada una matriz arr de enteros y un entero positivo k, devuelve una lista ordenada
    de longitud k con los k números máximos en arr.

    Ejemplo 1:

        Entrada: arr = [-3, -4, 5], k = 3
        Salida: [-4, -3, 5]

    Ejemplo 2:

        Entrada: arr = [4, -4, 4], k = 2
        Salida: [4, 4]

    Ejemplo 3:

        Entrada: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Salida: [2]

    Nota:
        1. La longitud de la matriz estará en el rango de [1, 1000].
        2. Los elementos en la matriz estarán en el rango de [-1000, 1000].
        3. 0 <= k <= len(arr)
    """


def solution(lst):
    """Dada una lista no vacía de enteros, devuelve la suma de todos los elementos impares que están en posiciones pares.

    Ejemplos
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """


def add_elements(arr, k):
    """
    Dado un arreglo no vacío de enteros arr y un entero k, devuelve
    la suma de los elementos con como máximo dos dígitos de los primeros k elementos de arr.

    Ejemplo:

        Entrada: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Salida: 24 # suma de 21 + 3

    Restricciones:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Dada una matriz no vacía de enteros arr y un entero k, devuelve
    la suma de los elementos con como máximo dos dígitos de los primeros k elementos de arr.

    Ejemplo:

        Entrada: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Salida: 24 # suma de 21 + 3

    Restricciones:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    Dado un entero positivo n, devuelve una lista ordenada que contiene los números impares en la secuencia de Collatz.

    La conjetura de Collatz es una conjetura en matemáticas que se refiere a una secuencia definida
    de la siguiente manera: comienza con cualquier entero positivo n. Luego, cada término se obtiene del
    término anterior de la siguiente manera: si el término anterior es par, el siguiente término es la mitad del
    término anterior. Si el término anterior es impar, el siguiente término es 3 veces el término anterior
    más 1. La conjetura es que, sin importar el valor de n, la secuencia siempre llegará a 1.

    Nota:
        1. Collatz(1) es [1].
        2. la lista devuelta está ordenada en orden creciente.

    Por ejemplo:
    get_odd_collatz(5) devuelve [1, 5] # La secuencia de Collatz para 5 es [5, 16, 8, 4, 2, 1], por lo que los números impares son solo 1 y 5.
    """

def get_odd_collatz(n):
    """
    Dado un entero positivo n, devuelve una lista ordenada que contiene los números impares en la secuencia de Collatz.

    La conjetura de Collatz es una conjetura en matemáticas que se refiere a una secuencia definida
    de la siguiente manera: comienza con cualquier entero positivo n. Luego cada término se obtiene del
    término anterior de la siguiente manera: si el término anterior es par, el siguiente término es la mitad del
    término anterior. Si el término anterior es impar, el siguiente término es 3 veces el término anterior
    más 1. La conjetura es que, sin importar el valor de n, la secuencia siempre llegará a 1.

    Nota:
        1. Collatz(1) es [1].
        2. la lista devuelta está ordenada en orden creciente.

    Por ejemplo:
    get_odd_collatz(5) devuelve [1, 5] # La secuencia de Collatz para 5 es [5, 16, 8, 4, 2, 1], por lo que los números impares son solo 1 y 5.
    """


def valid_date(date):
    """Tienes que escribir una función que valide una cadena de fecha dada y
    devuelva True si la fecha es válida, de lo contrario False.
    La fecha es válida si se cumplen todas las siguientes reglas:
    1. La cadena de fecha no está vacía.
    2. El número de días no es menor que 1 ni mayor que 31 días para los meses 1,3,5,7,8,10,12. Y el número de días no es menor que 1 ni mayor que 30 días para los meses 4,6,9,11. Y, el número de días no es menor que 1 ni mayor que 29 para el mes 2.
    3. Los meses no deben ser menores que 1 ni mayores que 12.
    4. La fecha debe estar en el formato: mm-dd-yyyy

    por ejemplo:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """


def split_words(txt):
    '''
    Dada una cadena de palabras, devuelve una lista de palabras divididas por espacios en blanco, si no existen espacios en blanco en el texto
    debes dividir por comas ',' si no existen comas debes devolver el número de letras minúsculas con orden impar en el
    alfabeto, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Ejemplos
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    Dada una lista de números, devuelve si están o no ordenados
    en orden ascendente. Si la lista tiene más de 1 duplicado del mismo
    número, devuelve False. Asume que no hay números negativos y solo enteros.

    Ejemplos
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''


def intersection(interval1, interval2):
    """Se te dan dos intervalos,
    donde cada intervalo es un par de enteros. Por ejemplo, intervalo = (inicio, fin) = (1, 2).
    Los intervalos dados son cerrados, lo que significa que el intervalo (inicio, fin)
    incluye tanto el inicio como el fin.
    Para cada intervalo dado, se asume que su inicio es menor o igual a su fin.
    Tu tarea es determinar si la longitud de la intersección de estos dos
    intervalos es un número primo.
    Por ejemplo, la intersección de los intervalos (1, 3), (2, 4) es (2, 3)
    cuya longitud es 1, que no es un número primo.
    Si la longitud de la intersección es un número primo, devuelve "YES",
    de lo contrario, devuelve "NO".
    Si los dos intervalos no se intersectan, devuelve "NO".

    [ejemplos de entrada/salida]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Se le da dos intervalos,
    donde cada intervalo es un par de enteros. Por ejemplo, interval = (start, end) = (1, 2).
    Los intervalos dados son cerrados, lo que significa que el intervalo (start, end)
    incluye tanto el principio como el final.
    Para cada intervalo dado, se supone que su comienzo es menor o igual a su fin.
    Su tarea es determinar si la longitud de intersección de estos dos
    intervalos es un número primo.
    Por ejemplo, la intersección de los intervalos (1, 3), (2, 4) es (2, 3)
    cuya longitud es 1, que no es un número primo.
    Si la longitud de la intersección es un número primo, devolver "YES",
    de lo contrario, devolver "NO".
    Si los dos intervalos no se intersectan, devuelve "NO".

    muestras de [entrada/salida]:
      intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Se te dan dos intervalos,
    donde cada intervalo es un par de enteros. Por ejemplo, intervalo = (inicio, fin) = (1, 2).
    Los intervalos dados son cerrados, lo que significa que el intervalo (inicio, fin)
    incluye tanto el inicio como el fin.
    Para cada intervalo dado, se asume que su inicio es menor o igual a su fin.
    Tu tarea es determinar si la longitud de la intersección de estos dos
    intervalos es un número primo.
    Por ejemplo, la intersección de los intervalos (1, 3), (2, 4) es (2, 3)
    cuya longitud es 1, que no es un número primo.
    Si la longitud de la intersección es un número primo, devuelve "YES",
    de lo contrario, devuelve "NO".
    Si los dos intervalos no se intersecan, devuelve "NO".

    ejemplos [entrada/salida]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    Se te da un array arr de enteros y necesitas devolver
    la suma de las magnitudes de los enteros multiplicada por el producto de todos los signos
    de cada número en el array, representado por 1, -1 o 0.
    Nota: devuelve None para un arr vacío.

    Ejemplo:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Se te da un arreglo arr de enteros y necesitas devolver
    la suma de las magnitudes de los enteros multiplicada por el producto de todos los signos
    de cada número en el arreglo, representado por 1, -1 o 0.
    Nota: devuelve None para un arr vacío.

    Ejemplo:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    Dada una cuadrícula con N filas y N columnas (N >= 2) y un entero positivo k,
    cada celda de la cuadrícula contiene un valor. Cada entero en el rango [1, N * N]
    inclusive aparece exactamente una vez en las celdas de la cuadrícula.

    Tienes que encontrar el camino mínimo de longitud k en la cuadrícula. Puedes comenzar
    desde cualquier celda, y en cada paso puedes moverte a cualquiera de las celdas vecinas,
    en otras palabras, puedes ir a celdas que comparten un borde con tu celda actual.
    Ten en cuenta que un camino de longitud k significa visitar exactamente k celdas (no
    necesariamente distintas).
    NO puedes salir de la cuadrícula.
    Un camino A (de longitud k) se considera menor que un camino B (de longitud k) si
    después de hacer las listas ordenadas de los valores en las celdas por las que A y B pasan
    (llamémoslas lst_A y lst_B), lst_A es lexicográficamente menor que lst_B, en otras palabras,
    existe un índice entero i (1 <= i <= k) tal que lst_A[i] < lst_B[i] y para cualquier j (1 <= j < i) tenemos
    lst_A[j] = lst_B[j].
    Se garantiza que la respuesta es única.
    Devuelve una lista ordenada de los valores en las celdas por las que pasa el camino mínimo.

    Ejemplos:

        Entrada: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Salida: [1, 2, 1]

        Entrada: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Salida: [1]
    """


def tri(n):
    """Todo el mundo conoce la secuencia de Fibonacci, fue estudiada profundamente por matemáticos en
    los últimos siglos. Sin embargo, lo que la gente no sabe es la secuencia de Tribonacci.
    La secuencia de Tribonacci se define por la recurrencia:
    tri(1) = 3
    tri(n) = 1 + n / 2, si n es par.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), si n es impar.
    Por ejemplo:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Se te da un número entero no negativo n, tienes que devolver una lista de los
    primeros n + 1 números de la secuencia de Tribonacci.
    Ejemplos:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """Dado un número entero positivo n, devuelve el producto de los dígitos impares.
    Devuelve 0 si todos los dígitos son pares.
    Por ejemplo:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    Crea una función que tome una cadena como entrada que contenga solo corchetes.
    La función debe devolver True si y solo si hay una subsecuencia válida de corchetes
    donde al menos un corchete en la subsecuencia está anidado.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
    Crea una función que toma una cadena como entrada que contiene solo corchetes.
    La función debe devolver True si y solo si hay una subsecuencia válida de corchetes
    donde al menos un corchete en la subsecuencia está anidado.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''


def sum_squares(lst):
    """Se te da una lista de números.
    Necesitas devolver la suma de los números al cuadrado en la lista dada,
    redondeando cada elemento en la lista al entero superior (techo) primero.
    Ejemplos:
    Para lst = [1,2,3] la salida debería ser 14
    Para lst = [1,4,9] la salida debería ser 98
    Para lst = [1,3,5,7] la salida debería ser 84
    Para lst = [1.4,4.2,0] la salida debería ser 29
    Para lst = [-2.4,1,1] la salida debería ser 6
    """

def sum_squares(lst):
    """Se te da una lista de números.
    Necesitas devolver la suma de los números al cuadrado en la lista dada,
    redondeando cada elemento en la lista al primer int(Ceiling) superior.
    Ejemplos:
    Para lst = [1,2,3] la salida debería ser 14
    Para lst = [1,4,9] la salida debería ser 98
    Para lst = [1,3,5,7] la salida debería ser 84
    Para lst = [1.4,4.2,0] la salida debería ser 29
    Para lst = [-2.4,1,1] la salida debería ser 6
    """


def check_if_last_char_is_a_letter(txt):
    '''
    Crear una función que devuelva True si el último carácter
    de una cadena dada es un carácter alfabético y no es
    parte de una palabra, y False en caso contrario.
    Nota: "palabra" es un grupo de caracteres separados por espacio.

    Ejemplos:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


def can_arrange(arr):
    """Crea una función que devuelva el índice más grande de un elemento que
    no sea mayor o igual al elemento inmediatamente anterior. Si no existe
    tal elemento, devuelve -1. El arreglo dado no contendrá valores duplicados.

    Ejemplos:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    Crear una función que devuelva una tupla (a, b), donde 'a' es
    el mayor de los enteros negativos, y 'b' es el menor
    de los enteros positivos en una lista.
    Si no hay enteros negativos o positivos, devuélvelos como None.

    Ejemplos:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''


def compare_one(a, b):
    """
    Crear una función que tome enteros, flotantes o cadenas que representen
    números reales, y devuelva la variable más grande en su tipo de variable dado.
    Devuelve None si los valores son iguales.
    Nota: Si un número real está representado como una cadena, el punto flotante podría ser . o ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """


def is_equal_to_sum_even(n):
    """Evaluar si el número dado n se puede escribir como la suma de exactamente 4 números pares positivos
    Ejemplo
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """


def special_factorial(n):
    """El factorial brasileño se define como:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    donde n > 0

    Por ejemplo:
    >>> special_factorial(4)
    288

    La función recibirá un entero como entrada y debe devolver el factorial
    especial de este entero.
    """


def fix_spaces(text):
    """
    Dada una cadena de texto, reemplaza todos los espacios en ella con guiones bajos,
    y si una cadena tiene más de 2 espacios consecutivos,
    entonces reemplaza todos los espacios consecutivos con -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    Dada una cadena de texto, reemplace todos los espacios en ella con guiones bajos,
    y si una cadena tiene más de 2 espacios consecutivos,
    luego reemplace todos los espacios consecutivos con -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """