Algoritmia de Programación del Software

Pista: La fórmula del interés compuesto es $A = P (1 + r/n)^{nt}$, donde $P$ es el capital principal, $r$ la tasa de interés anual, $n$ el número de veces que el interés se compone por año, y $t$ el número de años. Para simplificar, puedes asumir que $n=1$ (composición anual).

def calcular_interes_compuesto(capital, tasa_anual, tiempo_anios, composiciones_anuales=1):
    # Validaciones similares al anterior
    if not all(isinstance(arg, (int, float)) for arg in [capital, tasa_anual, tiempo_anios, composiciones_anuales]):
        raise TypeError("Todos los argumentos deben ser numéricos.")
    if capital < 0 or tasa_anual < 0 or tiempo_anios < 0 or composiciones_anuales <= 0:
        raise ValueError("Los valores no pueden ser negativos y el número de composiciones debe ser positivo.")
    
    tasa_decimal = tasa_anual / 100
    monto_total = capital * (1 + tasa_decimal / composiciones_anuales)**(composiciones_anuales * tiempo_anios)
    interes_generado = monto_total - capital
    return interes_generado, monto_total

# Ejemplo de uso
cap = 1000.0  # Capital inicial
tasa = 5.0    # Tasa de interés anual (%)
tiempo = 2    # Tiempo en años
composiciones = 12  # Mensual

interes, total = calcular_interes_compuesto(cap, tasa, tiempo, composiciones)
print(f"Capital Inicial: ${cap:,.2f}")
print(f"Tasa Anual: {tasa}%")
print(f"Tiempo: {tiempo} años")
print(f"Composiciones anuales: {composiciones}")
print(f"Interés Generado: ${interes:,.2f}")
print(f"Monto Total: ${total:,.2f}")
                            

import csv
import json

def convertir_csv_a_json(archivo_csv, archivo_json, precio_maximo=50):
    """
    Lee un archivo CSV de productos y crea un JSON con productos en oferta.
    Solo incluye productos con precio < precio_maximo y stock > 0.
    """
    productos_oferta = []
    
    try:
        # Leer el archivo CSV
        with open(archivo_csv, 'r', encoding='utf-8') as f:
            lector_csv = csv.DictReader(f)
            for fila in lector_csv:
                # Convertir valores a tipos adecuados
                producto = {
                    'id': int(fila['ID']),
                    'nombre': fila['Nombre'],
                    'precio': float(fila['Precio']),
                    'stock': int(fila['Stock'])
                }
                
                # Filtrar productos
                if producto['precio'] < precio_maximo and producto['stock'] > 0:
                    productos_oferta.append(producto)
        
        # Escribir el archivo JSON
        with open(archivo_json, 'w', encoding='utf-8') as f:
            json.dump({'productos_oferta': productos_oferta}, f, indent=4, ensure_ascii=False)
        
        print(f"Archivo '{archivo_json}' creado exitosamente con {len(productos_oferta)} productos en oferta.")
        return True
    
    except FileNotFoundError:
        print(f"Error: No se encontró el archivo '{archivo_csv}'.")
    except (KeyError, ValueError) as e:
        print(f"Error en el formato del archivo CSV: {e}")
    except Exception as e:
        print(f"Error inesperado: {e}")
    
    return False

# Programa principal
if __name__ == "__main__":
    archivo_entrada = "productos.csv"
    archivo_salida = "productos_oferta.json"
    precio_limite = 50
    
    convertir_csv_a_json(archivo_entrada, archivo_salida, precio_limite)
                            

Ejemplo de contenido para productos.csv:

ID,Nombre,Precio,Stock
1,Teclado Mecánico,89.99,15
2,Mouse Inalámbrico,45.50,8
3,Auriculares Bluetooth,65.75,0
4,Cable USB 2m,12.99,42
5,Adaptador HDMI,19.50,12
                            

import re

def extraer_telefonos(texto):
    """
    Extrae todos los números de teléfono con formato (XXX) XXX-XXXX o XXX-XXX-XXXX de un texto.
    """
    # Patrón para ambos formatos de teléfono
    patron = r'(\(\d{3}\)\s\d{3}-\d{4}|\d{3}-\d{3}-\d{4})'
    
    # Buscar todas las coincidencias
    telefonos = re.findall(patron, texto)
    
    return telefonos

# Texto de prueba
texto_ejemplo = """
Contactos:
- Juan Pérez: (555) 123-4567
- María García: 789-456-1230
- Carlos López: carlos@example.com
- Ana Martínez: (999) 888-7777
- Teléfono de la oficina: 555-123-4567
- Formato incorrecto: 5551234567
"""

# Extraer y mostrar teléfonos
telefonos_encontrados = extraer_telefonos(texto_ejemplo)
print("Números de teléfono encontrados:")
for telefono in telefonos_encontrados:
    print(f"- {telefono}")
                            

# gestor_empleados_gui.py
import tkinter as tk
from tkinter import messagebox, ttk
import sqlite3
import re

class GestorEmpleadosApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Gestor de Empleados - MoriDevEdu")
        self.root.geometry("500x400")
        self.root.configure(padx=20, pady=20)
        
        # Conectar a la BD
        self.conn = sqlite3.connect("empresa.db")
        self.cursor = self.conn.cursor()
        self.crear_tabla_empleados()
        
        # Variables
        self.var_nombre = tk.StringVar()
        self.var_puesto = tk.StringVar()
        self.var_salario = tk.StringVar()
        
        # Marco principal
        main_frame = ttk.Frame(root)
        main_frame.pack(fill="both", expand=True)
        
        # Formulario
        form_frame = ttk.LabelFrame(main_frame, text="Datos del Empleado")
        form_frame.pack(fill="x", padx=10, pady=10)
        
        # Campos del formulario
        ttk.Label(form_frame, text="Nombre:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
        ttk.Entry(form_frame, textvariable=self.var_nombre, width=30).grid(row=0, column=1, padx=5, pady=5)
        
        ttk.Label(form_frame, text="Puesto:").grid(row=1, column=0, padx=5, pady=5, sticky="w")
        ttk.Entry(form_frame, textvariable=self.var_puesto, width=30).grid(row=1, column=1, padx=5, pady=5)
        
        ttk.Label(form_frame, text="Salario:").grid(row=2, column=0, padx=5, pady=5, sticky="w")
        ttk.Entry(form_frame, textvariable=self.var_salario, width=30).grid(row=2, column=1, padx=5, pady=5)
        
        # Botones
        btn_frame = ttk.Frame(main_frame)
        btn_frame.pack(fill="x", padx=10, pady=10)
        
        ttk.Button(btn_frame, text="Guardar Empleado", command=self.guardar_empleado).pack(side="left", padx=5)
        ttk.Button(btn_frame, text="Limpiar Campos", command=self.limpiar_campos).pack(side="left", padx=5)
        ttk.Button(btn_frame, text="Ver Empleados", command=self.mostrar_empleados).pack(side="left", padx=5)
        
        # Tabla de empleados
        self.tree = ttk.Treeview(main_frame, columns=("ID", "Nombre", "Puesto", "Salario"), show="headings")
        self.tree.pack(fill="both", expand=True, padx=10, pady=10)
        
        # Configurar columnas
        self.tree.heading("ID", text="ID")
        self.tree.heading("Nombre", text="Nombre")
        self.tree.heading("Puesto", text="Puesto")
        self.tree.heading("Salario", text="Salario")
        
        self.tree.column("ID", width=50)
        self.tree.column("Nombre", width=150)
        self.tree.column("Puesto", width=150)
        self.tree.column("Salario", width=100)
        
        # Cargar datos iniciales
        self.cargar_empleados()
    
    def crear_tabla_empleados(self):
        self.cursor.execute("""
        CREATE TABLE IF NOT EXISTS empleados (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            nombre TEXT NOT NULL,
            puesto TEXT,
            salario REAL
        )
        """)
        self.conn.commit()
    
    def validar_datos(self):
        nombre = self.var_nombre.get().strip()
        puesto = self.var_puesto.get().strip()
        salario = self.var_salario.get().strip()
        
        if not nombre:
            messagebox.showerror("Error", "El nombre es obligatorio.")
            return False
        
        if not puesto:
            messagebox.showerror("Error", "El puesto es obligatorio.")
            return False
        
        if not salario:
            messagebox.showerror("Error", "El salario es obligatorio.")
            return False
        
        # Validar que salario sea un número
        if not re.match(r'^\d+(\.\d+)?$', salario):
            messagebox.showerror("Error", "El salario debe ser un número válido.")
            return False
        
        return True
    
    def guardar_empleado(self):
        if not self.validar_datos():
            return
        
        nombre = self.var_nombre.get().strip()
        puesto = self.var_puesto.get().strip()
        salario = float(self.var_salario.get().strip())
        
        try:
            self.cursor.execute("INSERT INTO empleados (nombre, puesto, salario) VALUES (?, ?, ?)", 
                               (nombre, puesto, salario))
            self.conn.commit()
            
            messagebox.showinfo("Éxito", f"Empleado '{nombre}' guardado correctamente.")
            self.limpiar_campos()
            self.cargar_empleados()
        except sqlite3.Error as e:
            messagebox.showerror("Error en la Base de Datos", f"No se pudo guardar el empleado: {e}")
    
    def limpiar_campos(self):
        self.var_nombre.set("")
        self.var_puesto.set("")
        self.var_salario.set("")
    
    def cargar_empleados(self):
        # Limpiar tabla
        for item in self.tree.get_children():
            self.tree.delete(item)
        
        # Cargar datos de la BD
        self.cursor.execute("SELECT id, nombre, puesto, salario FROM empleados ORDER BY id DESC")
        for row in self.cursor.fetchall():
            self.tree.insert("", "end", values=(row[0], row[1], row[2], f"${row[3]:,.2f}"))
    
    def mostrar_empleados(self):
        self.cargar_empleados()
    
    def __del__(self):
        if hasattr(self, 'conn') and self.conn:
            self.conn.close()

# Iniciar aplicación
if __name__ == "__main__":
    root = tk.Tk()
    app = GestorEmpleadosApp(root)
    root.mainloop()