Merge pull request mouredev#4834 from hectorio23/hectorio23

#27 - C++

Author: kontroldev

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/hectorio23.py

@@ -0,0 +1,77 @@
+# Autor: Héctor Adán
+# GitHub: https://github.com/hectorio23
+
+from abc import ABC, abstractmethod
+import math
+
+"""
+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(ABC):
+    @abstractmethod
+    def calcular(self, a, b):
+        pass
+
+class Suma(Operacion):
+    def calcular(self, a, b):
+        return a + b
+
+class Resta(Operacion):
+    def calcular(self, a, b):
+        return a - b
+
+class Multiplicacion(Operacion):
+    def calcular(self, a, b):
+        return a * b
+
+class Division(Operacion):
+    def calcular(self, a, b):
+        if b == 0:
+            raise ValueError("División por cero")
+        return a / b
+
+class Potencia(Operacion):
+    def calcular(self, a, b):
+        return math.pow(a, b)
+
+class Calculadora:
+    def __init__(self):
+        self.operaciones = {}
+
+    def agregar_operacion(self, nombre, operacion):
+        self.operaciones[nombre] = operacion
+
+    def calcular(self, nombre, a, b):
+        if nombre in self.operaciones:
+            return self.operaciones[nombre].calcular(a, b)
+        else:
+            raise ValueError("Operación no soportada")
+
+
+if __name__ == "__main__":
+    calc = Calculadora()
+    calc.agregar_operacion('+', Suma())
+    calc.agregar_operacion('-', Resta())
+    calc.agregar_operacion('*', Multiplicacion())
+    calc.agregar_operacion('/', Division())
+    calc.agregar_operacion('^', Potencia())
+
+    print("[+] - Suma:", calc.calcular('+', 5, 3))
+    print("[+] - Resta:", calc.calcular('-', 5, 3))
+    print("[+] - Multiplicación:", calc.calcular('*', 5, 3))
+    print("[+] - División:", calc.calcular('/', 5, 3))
+    print("[+] - Potencia:", calc.calcular('^', 5, 3))