Merge branch 'main' of github.com:mouredev/roadmap-retos-programacion into JesusAEE

Author: JesusAntonioEEscamilla

Roadmap/04 - CADENAS DE CARACTERES/python/eamartin96.py

@@ -0,0 +1,81 @@
+# #04 CADENAS DE CARACTERES
+'''
+Muestra ejemplos de todas las operacines que puedes realizar con cadenas de caracteres:
+Acceso a caracteres especificos, subcadenas, longitud, concatenacion, repeticion, recorrido,
+conversion a mayusculas y minusculas, reemplazo, division, union, interpolacion, verificacion.
+'''
+
+cadena = "HolaMundo"
+print(f"String: {cadena}")
+
+# Acceso a caracteres especificos
+print("Access to specyfic characters")
+print(f"First character: {cadena[0]}")
+print(f"Sixth character: {cadena[5]}")
+print(f"Last character: {cadena[-1]}")
+
+# Subcadenas
+print()
+
+# Longitud
+print("\nString Lenght")
+print(f"String lenght is: {len(cadena)}")
+
+# Concatenacion
+print("\nString Concatenation")
+cadena2 = "HolaPython!"
+print(cadena + cadena2)
+
+# Repeticion
+print("\nString Lenght")
+print(cadena * 3)
+
+# Mayusculas
+print("\nConvert to uppercase")
+print(cadena.upper())
+
+# Minusculas
+print("\nConvert to lowercase")
+print(cadena.lower())
+
+# Union
+print("\nConvert to lowercase")
+list_cadena = ["Hola", "mundo", "python"]
+join_cadena = " - ".join(cadena)
+print(f"Joint String: {cadena}")
+
+# Verificacion
+print(f"String is alphanumberic?: {cadena.isalpha()}")
+
+# DIFICULTAD EXTRA
+print("\n----------------------------------------------------")
+print("EXTRA DIFFICULT")
+'''
+Crea un programa que analice dos palabras diferentes y realice comprobaciones
+para descubrir si son:
+- Palindromos
+- Anagramas
+- Isogramas
+'''
+def check(string1, string2):
+    # Palindromo
+    print(f"{string1} is a palyndrome" if string1 == string1[::-1] else f"{string1} is not a palyndrome")
+    print(f"{string2} is a palyndrome" if string2 == string2[::-1] else f"{string2} is not a palyndrome")
+
+    # Anagram
+    print(f"{string1} is anagram of {string2}" if sorted(string1) == sorted(string2) else f"{string1} is not anagram of {string2}")
+
+    # Isogram
+    print(f"{string1} is an isogram" if len(string1) == len(set(string1)) else f"{string1} is not an isogram")
+    print(f"{string2} is an isogram" if len(string2) == len(set(string2)) else f"{string2} is not an isogram")
+
+    print()
+
+def main():
+    check("radar", "ana")
+    check("amor", "roma")
+    check("roma", "python")
+
+if __name__ == "__main__":
+    main()
+

Roadmap/21 - CALLBACKS/python/rigo93acosta.py

@@ -0,0 +1,61 @@
+'''
+/*
+ * EJERCICIO:
+ * Explora el concepto de callback en tu lenguaje creando un ejemplo
+ * simple (a tu elección) que muestre su funcionamiento.
+ *
+ * DIFICULTAD EXTRA (opcional):
+ * Crea un simulador de pedidos de un restaurante utilizando callbacks.
+ * Estará formado por una función que procesa pedidos.
+ * Debe aceptar el nombre del plato, una callback de confirmación, una
+ * de listo y otra de entrega.
+ * - Debe imprimir un confirmación cuando empiece el procesamiento.
+ * - Debe simular un tiempo aleatorio entre 1 a 10 segundos entre
+ *   procesos.
+ * - Debe invocar a cada callback siguiendo un orden de procesado.
+ * - Debe notificar que el plato está listo o ha sido entregado.
+ */
+'''
+
+## Programación Asíncrona principal saludo.
+
+def greeting_process(name: str, callback):
+    print('Ejecutando el proceso de saludo...')
+    callback(name)
+
+def greet_callback(names: str):
+    print(f'Hola, {names}!')
+
+greeting_process('Rigo', greet_callback)
+
+'''
+Extra
+'''
+import random
+import time
+import threading
+
+def order_process(dish_name: str, confirm_callbackm, ready_callback, delivered_callback):
+    def process():   
+        confirm_callbackm(dish_name)
+        time.sleep(random.randint(1, 10))    
+        ready_callback(dish_name)
+        time.sleep(random.randint(1, 10))
+        delivered_callback(dish_name)
+    
+    threading.Thread(target=process).start()
+
+
+def confirm_order(dish_name: str):
+    print(f"Tu pedido {dish_name} ha sido confirmado.")
+
+def order_ready(dish_name: str):
+    print(f"Tu pedido {dish_name} está listo.")
+
+def order_delivered(dish_name: str):
+    print(f"Tu pedido {dish_name} ha sido entregado.")
+
+order_process("Pizza Barbacoa", confirm_order, order_ready, order_delivered)
+order_process("Pizza 4 Quesos", confirm_order, order_ready, order_delivered)
+order_process("Pizza Margarita", confirm_order, order_ready, order_delivered)
+order_process("Pizza con Piña", confirm_order, order_ready, order_delivered)

Roadmap/27 - SOLID OCP/c++/hectorio23.cpp

@@ -0,0 +1,104 @@
+// Autor: Héctor Adán
+// GitHub: https://github.com/hectorio23
+
+#include <iostream>
+#include <unordered_map>
+#include <memory>
+#include <cmath>
+
+/*
+ * EJERCICIO:
+ * Explora el "Principio SOLID Abierto-Cerrado (Open-Close Principle, OCP)" 
+ * y crea un ejemplo simple donde se muestre su funcionamiento
+ * de forma correcta e incorrecta.
+ *
+ * DIFICULTAD EXTRA:
+ * Desarrolla una calculadora que necesita realizar diversas operaciones matemáticas. 
+ * Requisitos:
+ * - Debes diseñar un sistema que permita agregar nuevas operaciones utilizando el OCP.
+ * Instrucciones:
+ * 1. Implementa las operaciones de suma, resta, multiplicación y división.
+ * 2. Comprueba que el sistema funciona.
+ * 3. Agrega una quinta operación para calcular potencias.
+ * 4. Comprueba que se cumple el OCP.
+*/
+
+class Operacion {
+public:
+    virtual double calcular(double a, double b) const = 0;
+    virtual ~Operacion() = default;
+};
+
+class Suma : public Operacion {
+public:
+    double calcular(double a, double b) const override {
+        return a + b;
+    }
+};
+
+class Resta : public Operacion {
+public:
+    double calcular(double a, double b) const override {
+        return a - b;
+    }
+};
+
+class Multiplicacion : public Operacion {
+public:
+    double calcular(double a, double b) const override {
+        return a * b;
+    }
+};
+
+class Division : public Operacion {
+public:
+    double calcular(double a, double b) const override {
+        if (b == 0) {
+            throw std::invalid_argument("División por cero");
+        }
+        return a / b;
+    }
+};
+
+class Potencia : public Operacion {
+public:
+    double calcular(double a, double b) const override {
+        return std::pow(a, b);
+    }
+};
+
+class Calculadora {
+private:
+    std::unordered_map<char, std::unique_ptr<Operacion>> operaciones;
+
+public:
+    void agregarOperacion(char simbolo, std::unique_ptr<Operacion> operacion) {
+        operaciones[simbolo] = std::move(operacion);
+    }
+
+    double calcular(char operacion, double a, double b) const {
+        auto it = operaciones.find(operacion);
+        if (it != operaciones.end()) {
+            return it->second->calcular(a, b);
+        } else {
+            throw std::invalid_argument("Operación no soportada");
+        }
+    }
+};
+
+int main() {
+    Calculadora calc;
+    calc.agregarOperacion('+', std::make_unique<Suma>());
+    calc.agregarOperacion('-', std::make_unique<Resta>());
+    calc.agregarOperacion('*', std::make_unique<Multiplicacion>());
+    calc.agregarOperacion('/', std::make_unique<Division>());
+    calc.agregarOperacion('^', std::make_unique<Potencia>());
+
+    std::cout << "[+] - Suma: " << calc.calcular('+', 5, 3) << std::endl;
+    std::cout << "[+] - Resta: " << calc.calcular('-', 5, 3) << std::endl;
+    std::cout << "[+] - Multiplicación: " << calc.calcular('*', 5, 3) << std::endl;
+    std::cout << "[+] - División: " << calc.calcular('/', 5, 3) << std::endl;
+    std::cout << "[+] - Potencia: " << calc.calcular('^', 5, 3) << std::endl;
+
+    return 0;
+}

Roadmap/27 - SOLID OCP/javascript/hectorio23.js

@@ -0,0 +1,91 @@
+// Autor: Héctor Adán
+// GitHub: https://github.com/hectorio23
+
+"use strict";
+
+/*
+ * EJERCICIO:
+ * Explora el "Principio SOLID Abierto-Cerrado (Open-Close Principle, OCP)" 
+ * y crea un ejemplo simple donde se muestre su funcionamiento
+ * de forma correcta e incorrecta.
+ *
+ * DIFICULTAD EXTRA:
+ * Desarrolla una calculadora que necesita realizar diversas operaciones matemáticas. 
+ * Requisitos:
+ * - Debes diseñar un sistema que permita agregar nuevas operaciones utilizando el OCP.
+ * Instrucciones:
+ * 1. Implementa las operaciones de suma, resta, multiplicación y división.
+ * 2. Comprueba que el sistema funciona.
+ * 3. Agrega una quinta operación para calcular potencias.
+ * 4. Comprueba que se cumple el OCP.
+*/
+
+class Operacion {
+    calcular(a, b) {
+        throw new Error('Método calcular debe ser implementado');
+    }
+}
+
+class Suma extends Operacion {
+    calcular(a, b) {
+        return a + b;
+    }
+}
+
+class Resta extends Operacion {
+    calcular(a, b) {
+        return a - b;
+    }
+}
+
+class Multiplicacion extends Operacion {
+    calcular(a, b) {
+        return a * b;
+    }
+}
+
+class Division extends Operacion {
+    calcular(a, b) {
+        if (b === 0) {
+            throw new Error('División por cero');
+        }
+        return a / b;
+    }
+}
+
+class Potencia extends Operacion {
+    calcular(a, b) {
+        return Math.pow(a, b);
+    }
+}
+
+class Calculadora {
+    constructor() {
+        this.operaciones = {};
+    }
+
+    agregarOperacion(nombre, operacion) {
+        this.operaciones[nombre] = operacion;
+    }
+
+    calcular(nombre, a, b) {
+        const operacion = this.operaciones[nombre];
+        if (!operacion) {
+            throw new Error('Operación no soportada');
+        }
+        return operacion.calcular(a, b);
+    }
+}
+
+const calc = new Calculadora();
+calc.agregarOperacion('+', new Suma());
+calc.agregarOperacion('-', new Resta());
+calc.agregarOperacion('*', new Multiplicacion());
+calc.agregarOperacion('/', new Division());
+calc.agregarOperacion('^', new Potencia());
+
+console.log("[+] - Suma:", calc.calcular('+', 5, 3));
+console.log("[+] - Resta:", calc.calcular('-', 5, 3));
+console.log("[+] - Multiplicación:", calc.calcular('*', 5, 3));
+console.log("[+] - División:", calc.calcular('/', 5, 3));
+console.log("[+] - Potencia:", calc.calcular('^', 5, 3));

Roadmap/27 - SOLID OCP/python/agusrosero.py

@@ -0,0 +1,51 @@
+"""
+/*
+ * EJERCICIO:
+ * Explora el "Principio SOLID Abierto-Cerrado (Open-Close Principle, OCP)" 
+ * y crea un ejemplo simple donde se muestre su funcionamiento
+ * de forma correcta e incorrecta.
+ *
+"""
+
+
+class Animal:
+    def __init__(self, name):
+        self.name = name
+
+
+class Sonido(Animal):
+    def sonido(self):
+        print(f"{self.name} hace ruidos!")
+
+
+class Comer(Animal):
+    def comer(self):
+        print(f"{self.name} come su comida...")
+
+
+class Saludar(Animal):
+    def saludar(self):
+        print(f"{self.name} saluda!!!")
+
+
+animal1 = Animal("Leon")
+print(animal1.name)
+sonido1 = Sonido("Leon")
+sonido1.sonido()
+comer1 = Comer("Elefante")
+comer1.comer()
+saludar1 = Saludar("Tigre")
+saludar1.saludar()
+
+"""
+ * DIFICULTAD EXTRA (opcional):
+ * Desarrolla una calculadora que necesita realizar diversas operaciones matemáticas. 
+ * Requisitos:
+ * - Debes diseñar un sistema que permita agregar nuevas operaciones utilizando el OCP.
+ * Instrucciones:
+ * 1. Implementa las operaciones de suma, resta, multiplicación y división.
+ * 2. Comprueba que el sistema funciona.
+ * 3. Agrega una quinta operación para calcular potencias.
+ * 4. Comprueba que se cumple el OCP.
+ */
+"""