Merge pull request #6818 from Maanghel/main

Reto #28-#29-#30 - Python

Author: kontroldev

Retos/Reto #28 - EXPRESIÓN MATEMÁTICA [Media]/python/Maanghel.py

@@ -0,0 +1,87 @@
+"""
+Crea una función que reciba una expresión matemática (String)
+    y compruebe si es correcta. Retornará true o false.
+- Para que una expresión matemática sea correcta debe poseer
+    un número, una operación y otro número separados por espacios.
+Tantos números y operaciones como queramos.
+- Números positivos, negativos, enteros o decimales.
+- Operaciones soportadas: + - * / %
+
+Ejemplos:
+"5 + 6 / 7 - 4" -> true
+"5 a 6" -> false
+"""
+
+def is_number(number: str) -> bool:
+    """
+    Verifica si la cadena es un numero.
+
+    Args:
+        number (str): Cadena que se validara como numero.
+
+    Returns:
+        bool: True si es un numero, False en caso contrario.
+    """
+    if number.count("+") + number.count("-") > 1:
+        return False
+    if number.startswith(("+", "-")):
+        number = number[1:]
+    if number.count(".") > 1:
+        return False
+    return number.replace(".", "").isdigit()
+
+def is_mathematical_expression(expression: str) -> bool:
+    """
+    Verifica si una cadena representa una expresión matemática válida.
+
+    Para que la expresión se considere correcta debe cumplir:
+        - Estar compuesta por números y operadores separados por espacios.
+        - Alternar correctamente entre número y operador.
+        - Permitir números enteros, decimales, positivos y negativos.
+        - Permitir los operadores: +, -, *, /, %
+        - Tener al menos un patrón número-operador-número.
+        - No terminar con un operador.
+
+    Args:
+        expression (str): Cadena que representa la expresión matemática a validar.
+
+    Returns:
+        bool: True si la expresión es válida, False en caso contrario.
+
+    Raises:
+        TypeError: Si el argumento proporcionado no es una cadena.
+        ValueError: Si la cadena proporcionada está vacía o solo contiene espacios.
+    """
+    if not isinstance(expression, str):
+        raise TypeError("Error. Solo se aceptan cadenas de texto como valor.")
+    if not expression:
+        raise ValueError("Error. La expresion no puede estar vacia")
+
+    data = expression.strip().split()
+
+    if len(data) < 3 or len(data) % 2 == 0:
+        return False
+
+    expecting_number = True
+    for value in data:
+        if expecting_number:
+            if not is_number(value):
+                return False
+        else:
+            if value not in ["+", "-", "*", "/", "%"]:
+                return False
+        expecting_number = not expecting_number
+
+    return not expecting_number
+
+
+if __name__ == "__main__":
+    print(is_mathematical_expression("5 + 6 / 7 - 4"))
+    print(is_mathematical_expression("5 a 6"))
+    print(is_mathematical_expression("3 + 5"))
+    print(is_mathematical_expression("3 a 5"))
+    print(is_mathematical_expression("-3 + 5"))
+    print(is_mathematical_expression("- 3 + 5"))
+    print(is_mathematical_expression("-3 a 5"))
+    print(is_mathematical_expression("-3+5"))
+    print(is_mathematical_expression("3 + 5 - 1 / 4 % 8"))

Retos/Reto #29 - EL CARÁCTER INFILTRADO [Fácil]/python/Maanghel.py

@@ -0,0 +1,51 @@
+"""
+Crea una función que reciba dos cadenas de texto casi iguales,
+    a excepción de uno o varios caracteres.
+La función debe encontrarlos y retornarlos en formato lista/array.
+- Ambas cadenas de texto deben ser iguales en longitud.
+- Las cadenas de texto son iguales elemento a elemento.
+- No se pueden utilizar operaciones propias del lenguaje
+    que lo resuelvan directamente.
+
+Ejemplos:
+- Me llamo mouredev / Me llemo mouredov -> ["e", "o"]
+- Me llamo.Brais Moure / Me llamo brais moure -> [" ", "b", "m"]
+"""
+
+def different_characters(text1: str, text2: str) -> list[str]:
+    """
+    Compara dos cadenas de texto con la misma longitud y retorna
+    una lista con los caracteres que son distintos entre ambas.
+
+    La comparación se realiza carácter a carácter y solo se guardan
+    los caracteres diferentes que aparecen en la segunda cadena.
+
+    Args:
+        text1 (str): Primera cadena de texto a comparar.
+        text2 (str): Segunda cadena de texto a comparar.
+
+    Returns:
+        list[str]: Lista con los caracteres distintos encontrados.
+
+    Raises:
+        TypeError: Si alguno de los argumentos no es una cadena.
+        ValueError: Si las cadenas tienen longitudes diferentes o están vacías.
+    """
+    if not isinstance(text1, str) or not isinstance(text2, str):
+        raise TypeError("Error. Se aceptan solo cadenas de texto como valores.")
+    if len(text1) != len(text2):
+        raise ValueError("Error. Las cadenas deben tener la misma cantidad de elementos.")
+    if not text1 or not text2:
+        raise ValueError("Error. Los textos no pueden estar vacios.")
+
+    differences = []
+    for char1, char2 in zip(text1, text2):
+        if char1 != char2:
+            differences.append(char2)
+
+    return differences
+
+
+if __name__ == "__main__":
+    print(different_characters("Me llamo mouredev", "Me llemo mouredov"))
+    print(different_characters("Me llamo.Brais Moure", "Me llamo brais moure"))

Retos/Reto #30 - EL TECLADO T9 [Media]/python/Maanghel.py

@@ -0,0 +1,75 @@
+"""
+Los primeros dispositivos móviles tenían un teclado llamado T9
+    con el que se podía escribir texto utilizando únicamente su
+    teclado numérico (del 0 al 9).
+
+Crea una función que transforme las pulsaciones del T9 a su
+    representación con letras.
+- Debes buscar cuál era su correspondencia original
+- Cada bloque de pulsaciones va separado por un guión.
+- Si un bloque tiene más de un número, debe ser siempre el mismo.
+- Ejemplo:
+    Entrada: 6-666-88-777-33-3-33-888
+    Salida: MOUREDEV
+"""
+
+def keyboard_t9(code: str) -> str:
+    """
+    Decodifica una secuencia de pulsaciones del teclado T9 y devuelve
+    su representación en texto.
+
+
+    Reglas:
+      * Cada bloque representa una letra.
+      * Si un bloque tiene más de un dígito, todos deben ser iguales.
+      * El dígito "0" representa un espacio.
+      * La cantidad de repeticiones determina la letra seleccionada.
+
+    Ejemplo:
+        >>> keyboard_t9("6-666-88-777-33-3-33-888")
+        'MOUREDEV'
+
+    Args:
+        code (str): Cadena con las pulsaciones separadas por guiones.
+
+    Returns:
+        str: Texto decodificado utilizando la correspondencia T9.
+
+    Raises:
+        TypeError: Si `code` no es una cadena de texto.
+        ValueError: Si la cadena está vacía o algún bloque contiene
+            más de un número diferente.
+    """
+
+    alphabet = {
+        "2": ["A", "B", "C"],
+        "3": ["D", "E", "F"],
+        "4": ["G", "H", "I"],
+        "5": ["J", "K", "L"],
+        "6": ["M", "N", "O"],
+        "7": ["P", "Q", "R", "S"],
+        "8": ["T", "U", "V"],
+        "9": ["W", "X", "Y", "Z"],
+        "0": " "
+    }
+
+    if not isinstance(code, str):
+        raise TypeError("Error. Ingrese los digitos separados por guiones.")
+    if not code:
+        raise ValueError("Error. Intentelo nuevamente.")
+
+    pulsations = code.strip().split("-")
+    if any( len(set(element)) > 1 for element in pulsations):
+        raise ValueError("Error. Si son varias pulsaciones, solo pueden ser del mismo numero.")
+
+    sentence = ""
+    for element in pulsations:
+        sentence += alphabet[element[0]][len(element) - 1]
+
+    return sentence
+
+if __name__ == "__main__":
+    print(keyboard_t9("6-666-88-777-33-3-33-888"))
+    print(keyboard_t9("44-666-555-2"))
+    print(keyboard_t9("6-88-66-3-666"))
+    print(keyboard_t9("44-666-555-2-0-6-88-66-3-666"))

Retos/Reto #31 - EL ÁBACO [Fácil]/python/Maanghel.py

@@ -0,0 +1,82 @@
+"""
+Crea una función que sea capaz de leer el número representado por el ábaco.
+- El ábaco se representa por un array con 7 elementos.
+- Cada elemento tendrá 9 "O" (aunque habitualmente tiene 10 para realizar
+    operaciones) para las cuentas y una secuencia de "---" para el alambre.
+- El primer elemento del array representa los millones, y el último las unidades.
+- El número en cada elemento se representa por las cuentas que están a
+    la izquierda del alambre.
+
+Ejemplo de array y resultado:
+["O---OOOOOOOO",
+"OOO---OOOOOO",
+"---OOOOOOOOO",
+"OO---OOOOOOO",
+"OOOOOOO---OO",
+"OOOOOOOOO---",
+"---OOOOOOOOO"]
+
+Resultado: 1.302.790
+"""
+
+def abacus(sequence: list[str]) -> int:
+    """
+    Interpreta el valor numérico representado por un ábaco japonés (soroban simplificado).
+
+    args:
+    sequence : list[str]
+        Lista de 7 cadenas, donde cada cadena representa una fila del ábaco.
+        Cada fila contiene una secuencia de "O" (cuentas) y "---" (el alambre separador).
+        Las cuentas situadas a la izquierda del alambre representan el valor de la posición.
+        - La primera fila corresponde a los millones.
+        - La última fila corresponde a las unidades.
+
+    Ejemplo
+    -------
+    >>> abacus([
+    ... "O---OOOOOOOO",
+    ... "OOO---OOOOOO",
+    ... "---OOOOOOOOO",
+    ... "OO---OOOOOOO",
+    ... "OOOOOOO---OO",
+    ... "OOOOOOOOO---",
+    ... "---OOOOOOOOO"])
+
+    returns:
+    int: El número entero correspondiente al valor indicado por el ábaco.
+
+    Excepciones
+    -----------
+    TypeError
+        Si el argumento no es una lista.
+    ValueError
+        Si la lista no contiene exactamente 7 elementos o si alguno no es una cadena.
+
+    Notas
+    -----
+    - Cada línea debe tener 9 cuentas "O" en total, divididas por el alambre "---".
+    - Este tipo de representación se usa comúnmente en ejercicios de lógica y programación.
+    """
+    if not isinstance(sequence, list):
+        raise TypeError("Error. Solo se acepta una lista para representar el abaco.")
+    if not sequence or len(sequence) < 7:
+        raise ValueError("Error. La lista debe contener 7 elementos.")
+    if not all(isinstance(value, str) for value in sequence):
+        raise ValueError("Error. La lista solo puede contener cadenas de texto.")
+
+    result = 0
+    for index, line in enumerate(sequence, 1):
+        digit = line.split("---")[0].count("O")
+        result += digit * (10 ** (7 - index))
+    return int(result)
+
+if __name__ == "__main__":
+    value = ["O---OOOOOOOO",
+            "OOO---OOOOOO",
+            "---OOOOOOOOO",
+            "OO---OOOOOOO",
+            "OOOOOOO---OO",
+            "OOOOOOOOO---",
+            "---OOOOOOOOO"]
+
+    print(abacus(value))