Merge pull request #6804 from Maanghel/main

#13/14 - Python

Author: Roswell468

Retos/Reto #12 - VIERNES 13 [Fácil]/python/Maanghel.py

@@ -0,0 +1,33 @@
+"""
+Crea una función que sea capaz de detectar si existe un viernes 13
+en el mes y el año indicados.
+- La función recibirá el mes y el año y retornará verdadero o falso.
+"""
+
+from datetime import date
+
+def have_friday_13(year: int, month: int) -> bool:
+    """Check if the 13th of a given month/year falls on a Friday.
+
+    Args:
+        year (int): Year to check.
+        month (int): Month to check (1-12).
+
+    Returns:
+        bool: True if the 13th is Friday, False otherwise.
+
+    Raises:
+        TypeError: If arguments are not integers.
+        ValueError: If month is not in 1-12.
+    """
+    if not isinstance(year, int) or not isinstance(month, int):
+        raise TypeError("El año y el mes deben ser enteros.")
+    if not 1 <= month <= 12:
+        raise ValueError("El mes debe estar entre 1 y 12.")
+
+    return date(year, month, 13).weekday() == 4
+
+
+if __name__ == "__main__":
+    print(have_friday_13(1900, 5)) # False
+    print(have_friday_13(2023, 10)) # True

Retos/Reto #13 - ADIVINA LA PALABRA [Media]/python/Maanghel.py

@@ -0,0 +1,132 @@
+"""
+Crea un pequeño juego que consista en adivinar palabras en un número máximo de intentos:
+- El juego comienza proponiendo una palabra aleatoria incompleta
+    - Por ejemplo "m_ur_d_v", y el número de intentos que le quedan
+- El usuario puede introducir únicamente una letra o una palabra (de la misma longitud que
+    la palabra a adivinar)
+    - Si escribe una letra y acierta, se muestra esa letra en la palabra. Si falla, se resta
+        uno al número de intentos
+    - Si escribe una resolución y acierta, finaliza el juego, en caso contrario, se resta uno
+        al número de intentos
+    - Si el contador de intentos llega a 0, el jugador pierde
+- La palabra debe ocultar de forma aleatoria letras, y nunca puede comenzar
+    ocultando más del 60%
+- Puedes utilizar las palabras que quieras y el número de intentos que consideres
+"""
+
+import random
+
+class Game:
+    """
+    A simple word guessing game where the player has to guess
+    a randomly chosen word by suggesting letters or the full word.
+
+    Attributes:
+        words (list[str]): List of possible words for the game.
+        replace_probabilities (float): Maximum percentage of letters that can be hidden.
+        max_attempts (int): Maximum number of attempts allowed.
+        random_word (str): The randomly chosen word for the game.
+        current_lyrics (list[str]): The current state of the word with hidden/revealed letters.
+        attempts_left (int): Number of attempts the player has left.
+    """
+
+    words = [
+        "murcielago", "python", "programacion", "desarrollo", "reto", "palabra", "adivina", "juego",
+        "computadora", "teclado", "raton", "pantalla", "internet", "variable", "funcion", "bucle",
+        "condicional", "lista", "diccionario", "conjunto", "tupla"
+    ]
+    replace_probabilities = 0.6
+
+    def __init__(self, max_attempts: int = 6) -> None:
+        """
+        Initialize the game with a random word and hidden letters.
+
+        Args:
+            max_attempts (int): Maximum number of attempts allowed. Default is 6.
+        """
+        self.max_attempts = max_attempts
+        self.random_word = random.choice(self.words)
+        self.current_lyrics = self._generate_incomplete_word()
+        self.attempts_left = self.max_attempts
+
+    def _generate_incomplete_word(self) -> list[str]:
+        """
+        Generate the word with randomly hidden letters, ensuring no more
+        than 60% of the word is hidden.
+
+        Returns:
+            list[str]: The word represented as a list with some letters replaced by '_'.
+        """
+        max_hidden = int(len(self.random_word) * self.replace_probabilities)
+        num_letters_to_hide = random.randint(1, max_hidden)
+        hidden_positions = random.sample(range(len(self.random_word)), num_letters_to_hide)
+
+        return [
+            "_" if i in hidden_positions else char
+            for i, char in enumerate(self.random_word)
+        ]
+
+    def main(self) -> None:
+        """
+        Run the main game loop until the player wins or runs out of attempts.
+        """
+        while self.attempts_left > 0:
+            self._display_round()
+            user_input = input("Ingresa una letra o la palabra completa: ").lower()
+
+            if len(user_input) == 1 and user_input.isalpha():
+                self._guess_letter(user_input)
+            elif len(user_input) == len(self.random_word):
+                self._guess_word(user_input)
+            else:
+                print("Entrada invalida. Intente de nuevo.")
+
+            if "_" not in self.current_lyrics:
+                print(f"Felicidades!! Completaste la palabra: {self.random_word}")
+                return
+
+        print(f"Te quedaste sin intentos! La palabra era: '{self.random_word}'.")
+
+    def _guess_letter(self, letter: str) -> None:
+        """
+        Check if the guessed letter is in the word.
+
+        Args:
+            letter (str): The guessed letter.
+        """
+        if letter in self.random_word:
+            for i, char in enumerate(self.random_word):
+                if char == letter:
+                    self.current_lyrics[i] = letter
+            print(f"Correcto! La palabra ahora es: {''.join(self.current_lyrics)}")
+        else:
+            self.attempts_left -= 1
+            print(f"Respuesta incorrecta. Intentos restantes: {self.attempts_left}")
+
+    def _guess_word(self, word: str) -> None:
+        """
+        Check if the guessed word matches the random word.
+
+        Args:
+            word (str): The guessed word.
+        """
+        if word == self.random_word:
+            print(f"Ganaste! La palabra es: '{self.random_word}'.")
+            self.current_lyrics = list(self.random_word)
+            return
+        else:
+            self.attempts_left -= 1
+            print(f"Respuesta incorrecta. Intentos restantes: {self.attempts_left}")
+
+    def _display_round(self) -> None:
+        """
+        Display the current round number, attempts left, and the incomplete word.
+        """
+        print(f"\nRonda: {(self.max_attempts - self.attempts_left) + 1} de {self.max_attempts}")
+        print(f"Palabra incompleta: {''.join(self.current_lyrics)}")
+        print("-" * 50)
+
+
+if __name__ == "__main__":
+    game = Game()
+    game.main()

Retos/Reto #14 - OCTAL Y HEXADECIMAL [Fácil]/python/Maanghel.py

@@ -0,0 +1,85 @@
+"""
+Crea una función que reciba un número decimal y lo trasforme a Octal
+    y Hexadecimal.
+- No está permitido usar funciones propias del lenguaje de programación que
+    realicen esas operaciones directamente.
+"""
+
+def _validate_data(decimal: int) -> None:
+    """
+    Validate the input data for conversion.
+
+    Ensures the value is a positive integer greater than zero.
+    Raises an appropriate exception if the input is invalid.
+
+    Args:
+        decimal (int): The number to validate.
+
+    Raises:
+        TypeError: If the input is not an integer.
+        ValueError: If the input is zero or a negative integer.
+    """
+    if not isinstance(decimal, int):
+        raise TypeError("Solo se admiten enteros positivos como datos.")
+    if not decimal:
+        raise ValueError("tiene que ingresar un valor positivo.")
+    if decimal < 0:
+        raise ValueError("Solo se admiten enteros positivos como datos.")
+
+def _to_base(decimal: int, base: int) -> str:
+    """
+    Convert a decimal integer into a string representation in the specified base.
+
+    This function uses successive integer division and remainders to transform
+    a decimal number into another base (e.g., binary, octal, hexadecimal).
+    It supports bases up to 16, using digits 0/9 and letters A/F for values >= 10.
+
+    Args:
+        decimal (int): The number in decimal format to be converted.
+        base (int): The target base (e.g., 2 for binary, 8 for octal, 16 for hex).
+
+    Returns:
+        str: The string representation of the number in the target base.
+    """
+    symbols = "0123456789ABCDEF"
+    digits = []
+
+    if decimal == 0:
+        return "0"
+
+    while decimal > 0:
+        remainder = decimal % base
+        digits.append(symbols[remainder])
+        decimal //= base
+
+    return ''.join(reversed(digits))
+
+def to_octal_and_hex(decimal: int) -> str:
+    """
+    Convert a decimal number into its Octal and Hexadecimal string representations.
+
+    This function internally calls `to_base` with base 8 (Octal) and base 16 (Hexadecimal).
+    It avoids using Python's built-in conversion functions such as `oct()` or `hex()`.
+
+    Args:
+        decimal (int): The number in decimal format to be converted.
+
+    Returns:
+        str: A descriptive message containing the decimal number and its octal
+            and hexadecimal equivalents.
+    """
+    try:
+        _validate_data(decimal)
+    except (ValueError, TypeError) as e:
+        return f"Error: {e}"
+
+    octal = _to_base(decimal, 8)
+    hexa = _to_base(decimal, 16)
+
+    return f"El número {decimal} en octal es {octal} y en hexadecimal es {hexa}"
+
+
+if __name__ == "__main__":
+    print(to_octal_and_hex(1))
+    print(to_octal_and_hex(255))
+    print(to_octal_and_hex(-1))