def file_name_check(file_name):
    """Crea una función que tome una cadena que representa el nombre de un archivo, y devuelva
    'Yes' si el nombre del archivo es válido, y devuelva 'No' en caso contrario.
    Se considera que el nombre de un archivo es válido si y solo si se cumplen todas las siguientes condiciones:
    - No debe haber más de tres dígitos ('0'-'9') en el nombre del archivo.
    - El nombre del archivo contiene exactamente un punto '.'
    - La subcadena antes del punto no debe estar vacía, y debe comenzar con una letra del
    alfabeto latino ('a'-'z' y 'A'-'Z').
    - La subcadena después del punto debe ser una de estas: ['txt', 'exe', 'dll']
    Ejemplos:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (el nombre debe comenzar con una letra del alfabeto latino)
    """

def file_name_check(file_name):
    """Crea una función que tome una cadena que representa el nombre de un archivo, y devuelve
    'Yes' si el nombre del archivo es válido, y devuelve 'No' en caso contrario.
    Se considera que el nombre de un archivo es válido si y solo si se cumplen todas las siguientes condiciones:
    - No debe haber más de tres dígitos ('0'-'9') en el nombre del archivo.
    - El nombre del archivo contiene exactamente un punto '.'
    - La subcadena antes del punto no debe estar vacía, y debe comenzar con una letra del
    alfabeto latino ('a'-'z' y 'A'-'Z').
    - La subcadena después del punto debe ser una de estas: ['txt', 'exe', 'dll']
    Ejemplos:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (el nombre debe comenzar con una letra del alfabeto latino)
    """


def sum_squares(lst):
    """"
    Esta función tomará una lista de enteros. Para todas las entradas en la lista, la función elevará al cuadrado la entrada entera si su índice es un
    múltiplo de 3 y elevará al cubo la entrada entera si su índice es un múltiplo de 4 y no un múltiplo de 3. La función no
    cambiará las entradas en la lista cuyos índices no sean múltiplos de 3 o 4. La función luego devolverá la suma de todas las entradas.

    Ejemplos:
    Para lst = [1,2,3] la salida debería ser 6
    Para lst = [] la salida debería ser 0
    Para lst = [-1,-5,2,-1,-5] la salida debería ser -126
    """


def words_in_sentence(sentence):
    """
    Se te da una cadena que representa una oración,
    la oración contiene algunas palabras separadas por un espacio,
    y tienes que devolver una cadena que contenga las palabras de la oración original,
    cuyas longitudes son números primos,
    el orden de las palabras en la nueva cadena debe ser el mismo que el original.

    Ejemplo 1:
        Entrada: sentence = "This is a test"
        Salida: "is"

    Ejemplo 2:
        Entrada: sentence = "lets go for swimming"
        Salida: "go for"

    Restricciones:
        * 1 <= len(sentence) <= 100
        * la oración contiene solo letras
    """


def simplify(x, n):
    """Tu tarea es implementar una función que simplifique la expresión
    x * n. La función devuelve True si x * n evalúa a un número entero y False
    de lo contrario. Tanto x como n son representaciones en cadena de una fracción, y tienen el siguiente formato,
    <numerador>/<denominador> donde tanto el numerador como el denominador son números enteros positivos.

    Puedes asumir que x y n son fracciones válidas, y no tienen cero como denominador.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """Tu tarea es implementar una función que simplifique la expresión
    x * n. La función devuelve True si x * n evalúa a un número entero y False
    de lo contrario. Tanto x como n, son representaciones en cadena de una fracción, y tienen el siguiente formato,
    <numerador>/<denominador> donde tanto el numerador como el denominador son números enteros positivos.

    Puedes asumir que x y n son fracciones válidas, y no tienen cero como denominador.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """


def order_by_points(nums):
    """
    Escribe una función que ordene la lista dada de enteros
    en orden ascendente según la suma de sus dígitos.
    Nota: si hay varios elementos con suma similar de sus dígitos,
    ordénalos según su índice en la lista original.

    Por ejemplo:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """Escribe una función que tome un arreglo de números como entrada y
    devuelva el número de elementos en el arreglo que son mayores que 10 y
    tanto el primer como el último dígito de un número son impares (1, 3, 5, 7, 9).
    Por ejemplo:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    Se te da un entero positivo n. Tienes que crear un arreglo de enteros a de longitud n.
        Para cada i (1 ≤ i ≤ n), el valor de a[i] = i * i - i + 1.
        Devuelve el número de triples (a[i], a[j], a[k]) de a donde i < j < k,
    y a[i] + a[j] + a[k] es un múltiplo de 3.

    Ejemplo:
        Entrada: n = 5
        Salida: 1
        Explicación:
        a = [1, 3, 7, 13, 21]
        El único triple válido es (1, 7, 13).
    """

def get_max_triples(n):
    """
    Se te da un entero positivo n. Tienes que crear un array de enteros a de longitud n.
        Para cada i (1 ≤ i ≤ n), el valor de a[i] = i * i - i + 1.
        Devuelve el número de triples (a[i], a[j], a[k]) de a donde i < j < k,
    y a[i] + a[j] + a[k] es un múltiplo de 3.

    Ejemplo:
        Entrada: n = 5
        Salida: 1
        Explicación:
        a = [1, 3, 7, 13, 21]
        El único triple válido es (1, 7, 13).
    """


def bf(planet1, planet2):
    '''
    Hay ocho planetas en nuestro sistema solar: el más cercano al Sol
    es Mercurio, el siguiente es Venus, luego Tierra, Marte, Júpiter, Saturno,
    Urano, Neptuno.
    Escribe una función que tome dos nombres de planetas como cadenas planet1 y planet2.
    La función debe devolver una tupla que contenga todos los planetas cuyas órbitas están
    ubicadas entre la órbita de planet1 y la órbita de planet2, ordenados por
    la proximidad al sol.
    La función debe devolver una tupla vacía si planet1 o planet2
    no son nombres de planetas correctos.
    Ejemplos
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    Hay ocho planetas en nuestro sistema solar: el más cercano al Sol
    es Mercurio, el siguiente es Venus, luego la Tierra, Marte, Júpiter, Saturno,
    Urano, Neptuno.
    Escribe una función que toma dos nombres de planetas como cadenas planet1 y planet2.
    La función debe devolver una tupla que contenga todos los planetas cuyas órbitas están
    situadas entre la órbita del planeto1 y la órbita del planeto2, ordenados por
    la proximidad al sol.
    La función debe devolver una tupla vacía si planet1 o planet2
    no son nombres correctos de los planetas.
    Ejemplos
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """Escribe una función que acepte una lista de cadenas como parámetro,
    elimine las cadenas que tienen longitudes impares de ella,
    y devuelva la lista resultante en orden,
    La lista siempre es una lista de cadenas y nunca un arreglo de números,
    y puede contener duplicados.
    El orden de la lista debe ser ascendente por la longitud de cada palabra, y
    debes devolver la lista ordenada por esa regla.
    Si dos palabras tienen la misma longitud, ordena la lista alfabéticamente.
    La función debe devolver una lista en orden ascendiente.
    Puedes asumir que todas las palabras tendrán la misma longitud.
    Por ejemplo:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Escribe una función que acepte una lista de cadenas como parámetro,
    elimina las cadenas que tienen longitudes impares de ella,
    y devuelve la lista resultante en orden ordenado,
    La lista siempre es una lista de cadenas y nunca un arreglo de números,
    y puede contener duplicados.
    El orden de la lista debe ser ascendente por la longitud de cada palabra, y
    debes devolver la lista ordenada por esa regla.
    Si dos palabras tienen la misma longitud, ordena la lista alfabéticamente.
    La función debe devolver una lista de cadenas en orden ordenado.
    Puedes asumir que todas las palabras tendrán la misma longitud.
    Por ejemplo:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Escribe una función que acepte una lista de cadenas como parámetro,
    elimine las cadenas que tienen longitudes impares de ella,
    y devuelva la lista resultante en orden ordenado.
    La lista siempre es una lista de cadenas y nunca un arreglo de números,
    y puede contener duplicados.
    El orden de la lista debe ser ascendente por la longitud de cada palabra, y
    debes devolver la lista ordenada por esa regla.
    Si dos palabras tienen la misma longitud, ordena la lista alfabéticamente.
    La función debe devolver una lista de cadenas en orden ordenado.
    Puedes asumir que todas las palabras tendrán la misma longitud.
    Por ejemplo:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """Un programa simple que debería devolver el valor de x si n es
    un número primo y debería devolver el valor de y de lo contrario.

    Ejemplos:
    para x_or_y(7, 34, 12) == 34
    para x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    Dada una lista de números, devuelve la suma de los cuadrados de los números
    en la lista que son impares. Ignora los números que son negativos o no enteros.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Si la lista de entrada está vacía, devuelve 0.
    '''


def compare(game,guess):
    """Creo que todos recordamos esa sensación cuando finalmente se conoce el resultado de algún evento tan esperado.
    Los sentimientos y pensamientos que tienes en ese momento definitivamente valen la pena anotarlos y compararlos.
    Tu tarea es determinar si una persona adivinó correctamente los resultados de una serie de partidos.
    Se te dan dos arreglos de puntuaciones y conjeturas de igual longitud, donde cada índice muestra un partido.
    Devuelve un arreglo de la misma longitud que indica cuán lejos estuvo cada conjetura. Si han adivinado correctamente,
    el valor es 0, y si no, el valor es la diferencia absoluta entre la conjetura y la puntuación.

    ejemplo:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """


def Strongest_Extension(class_name, extensions):
    """Se te dará el nombre de una clase (una cadena) y una lista de extensiones.
    Las extensiones se utilizarán para cargar clases adicionales a la clase. La
    fuerza de la extensión es la siguiente: Sea CAP el número de letras mayúsculas
    en el nombre de la extensión, y sea SM el número de letras minúsculas
    en el nombre de la extensión, la fuerza se da por la fracción CAP - SM.
    Debes encontrar la extensión más fuerte y devolver una cadena en este
    formato: ClassName.StrongestExtensionName.
    Si hay dos o más extensiones con la misma fuerza, debes
    elegir la que aparece primero en la lista.
    Por ejemplo, si se te da "Slices" como la clase y una lista de las
    extensiones: ['SErviNGSliCes', 'Cheese', 'StuFfed'] entonces deberías
    devolver 'Slices.SErviNGSliCes' ya que 'SErviNGSliCes' es la extensión más fuerte
    (su fuerza es -1).
    Ejemplo:
    para Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a , b):
    """Se te dan 2 palabras. Necesitas devolver True si la segunda palabra o cualquiera de sus rotaciones es una subcadena en la primera palabra
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """Dado un número entero, devuelve una tupla que tiene el número de dígitos pares e impares respectivamente.

     Ejemplo:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    Dado un número entero positivo, obtener su equivalente en números romanos como una cadena,
    y devolverlo en minúsculas.
    Restricciones: 1 <= num <= 1000

    Ejemplos:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    Dados los largos de los tres lados de un triángulo. Devuelve True si los tres
    lados forman un triángulo rectángulo, False en caso contrario.
    Un triángulo rectángulo es un triángulo en el que un ángulo es recto o
    de 90 grados.
    Ejemplo:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """Escribe una función que acepte una lista de cadenas.
    La lista contiene diferentes palabras. Devuelve la palabra con el número máximo
    de caracteres únicos. Si múltiples cadenas tienen el número máximo de caracteres
    únicos, devuelve la que aparece primero en orden lexicográfico.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """


def eat(number, need, remaining):
    """
    Eres un conejo hambriento, y ya has comido un cierto número de zanahorias,
    pero ahora necesitas comer más zanahorias para completar las comidas del día.
    debes devolver un arreglo de [ número total de zanahorias comidas después de tus comidas,
                                   el número de zanahorias que quedan después de tus comidas ]
    si no hay suficientes zanahorias restantes, comerás todas las zanahorias restantes, pero aún tendrás hambre.

    Ejemplo:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Variables:
    @number : entero
        el número de zanahorias que has comido.
    @need : entero
        el número de zanahorias que necesitas comer.
    @remaining : entero
        el número de zanahorias restantes que hay en existencias

    Restricción:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Diviértete :)
    """

def eat(number, need, remaining):
    """
    Eres un conejo hambriento, y ya has comido un cierto número de zanahorias,
    pero ahora necesitas comer más zanahorias para completar las comidas del día.
    debes devolver un arreglo de [ número total de zanahorias comidas después de tus comidas,
                                   el número de zanahorias que quedan después de tus comidas ]
    si no hay suficientes zanahorias restantes, comerás todas las zanahorias restantes, pero aún tendrás hambre.

    Ejemplo:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Variables:
    @number : entero
        el número de zanahorias que has comido.
    @need : entero
        el número de zanahorias que necesitas comer.
    @remaining : entero
        el número de zanahorias restantes que existen en stock

    Restricción:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Diviértete :)
    """


def do_algebra(operator, operand):
    """
    Dadas dos listas operator y operand. La primera lista tiene operaciones algebraicas básicas, y
    la segunda lista es una lista de enteros. Usa las dos listas dadas para construir la expresión
    algebraica y devuelve la evaluación de esta expresión.

    Las operaciones algebraicas básicas:
    Suma ( + )
    Resta ( - )
    Multiplicación ( * )
    División entera ( // )
    Potenciación ( ** )

    Ejemplo:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Nota:
        La longitud de la lista operator es igual a la longitud de la lista operand menos uno.
        Operand es una lista de enteros no negativos.
        La lista operator tiene al menos un operador, y la lista operand tiene al menos dos operandos.

    """

def do_algebra(operator, operand):
    """
    Dadas dos listas operator, y operand. La primera lista tiene operaciones básicas de álgebra, y
    la segunda lista es de enteros. Utilice las dos listas dadas para construir la expresión
    algebraica y devolver la evaluación de esta expresión.

    Las operaciones básicas de álgebra:
    Adición ( +)
    Sustracción ( - )
    Multiplicación ( *)
    División entera ( // )
    Exponenciación ( **)

    Ejemplo:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    resultado = 2 + 3 * 4 - 5
    => resultado = 9

    Nota:
        La longitud de la lista de operadores es igual a la longitud de la lista de operandos menos uno.
        Los operandos son una lista de enteros no negativos.
        La lista de operadores tiene al menos un operador, y la lista de operandos tiene al menos dos operandos.

    """

def do_algebra(operator, operand):
    """
    Dadas dos listas operator y operand. La primera lista tiene operaciones algebraicas básicas, y
    la segunda lista es una lista de enteros. Usa las dos listas dadas para construir la expresión
    algebraica y devuelve la evaluación de esta expresión.

    Las operaciones algebraicas básicas:
    Suma ( + )
    Resta ( - )
    Multiplicación ( * )
    División entera ( // )
    Exponenciación ( ** )

    Ejemplo:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Nota:
        La longitud de la lista operator es igual a la longitud de la lista operand menos uno.
        Operand es una lista de enteros no negativos.
        La lista operator tiene al menos un operador, y la lista operando tiene al menos dos operandos.

    """


def solve(s):
    """Se te da una cadena s.
    si s[i] es una letra, invierte su caso de minúscula a mayúscula o viceversa,
    de lo contrario, mantenla como está.
    Si la cadena no contiene letras, invierte la cadena.
    La función debe devolver la cadena resultante.
    Ejemplos
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Se te da una cadena s.
    si s[i] es una letra, inviértela de minúscula a mayúscula o viceversa,
    de lo contrario, mantenla como está.
    Si la cadena no contiene letras, invierte la cadena.
    La función debe devolver la cadena resultante.
    Ejemplos
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    Dada una cadena 'text', devuelve su cadena equivalente de hash md5.
    Si 'text' es una cadena vacía, devuelve None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """


def generate_integers(a, b):
    """
    Dados dos enteros positivos a y b, devuelve los dígitos pares entre a
    y b, en orden ascendente.

    Por ejemplo:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """