Bootstrap Python exercises repository with multi-level structure

.gitignore

@@ -0,0 +1,23 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+*.egg-info/
+dist/
+build/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE files
+.idea/
+.vscode/
+*.code-workspace
+
+# OS files
+.DS_Store
+Thumbs.db

README.md

@@ -1,2 +1,49 @@
-# ejercicios_python
-ejercicios de lógica y entrenamiento de python
+# Ejercicios Python
+
+Repositorio de ejercicios de Python para el entrenamiento de conceptos, lógica de programación y algoritmos, organizados por nivel de complejidad.
+
+## Estructura del repositorio
+
+```
+ejercicios_python/
+├── basico/          # Nivel 1 – Conceptos fundamentales
+├── intermedio/      # Nivel 2 – Estructuras de datos y funciones avanzadas
+├── avanzado/        # Nivel 3 – POO, decoradores, generadores
+└── algoritmos/      # Algoritmos clásicos y estructuras de datos
+```
+
+## Niveles
+
+### 🟢 Básico
+Ejercicios orientados a quienes están dando sus primeros pasos en Python.
+Temas: variables, tipos de datos, condicionales, bucles y funciones simples.
+
+### 🟡 Intermedio
+Ejercicios para quienes ya conocen lo básico y quieren profundizar.
+Temas: listas avanzadas, diccionarios, funciones de orden superior, manejo de archivos y excepciones.
+
+### 🔴 Avanzado
+Ejercicios que exploran características más potentes del lenguaje.
+Temas: programación orientada a objetos, decoradores, generadores y comprensiones.
+
+### ⚙️ Algoritmos
+Implementaciones de algoritmos y estructuras de datos clásicas.
+Temas: ordenamiento, búsqueda, recursión y estructuras lineales/no lineales.
+
+## Cómo usar este repositorio
+
+1. Clona el repositorio:
+   ```bash
+   git clone https://github.com/BrandonCabra/ejercicios_python.git
+   ```
+2. Navega al nivel que te corresponda y abre el archivo `.py` que quieras practicar.
+3. Lee el enunciado incluido como comentario al inicio de cada archivo.
+4. Escribe tu solución y ejecútala con:
+   ```bash
+   python nombre_del_archivo.py
+   ```
+
+## Requisitos
+
+- Python 3.8 o superior.
+- No se requieren librerías externas; todos los ejercicios usan la biblioteca estándar.

algoritmos/01_ordenamiento.py

@@ -0,0 +1,147 @@
+# =============================================================
+# Ejercicio: Algoritmos de ordenamiento
+# Nivel: Algoritmos
+# =============================================================
+# Descripción:
+#   Implementa los algoritmos de ordenamiento más conocidos
+#   y compara su comportamiento.
+# =============================================================
+
+# ------ Tarea 1: Bubble Sort ------
+# Implementa el algoritmo Bubble Sort.
+# Idea: compara pares adyacentes e intercambia si están
+# en el orden incorrecto; repite hasta que no haya cambios.
+def bubble_sort(lista):
+    arr = lista[:]  # No modificar la lista original
+    # Tu código aquí:
+    return arr
+
+datos = [64, 25, 12, 22, 11]
+print("Bubble Sort:", bubble_sort(datos))
+# Esperado: [11, 12, 22, 25, 64]
+
+
+# ------ Tarea 2: Selection Sort ------
+# Implementa Selection Sort.
+# Idea: busca el mínimo del subarreglo no ordenado y lo
+# coloca al inicio en cada iteración.
+def selection_sort(lista):
+    arr = lista[:]
+    # Tu código aquí:
+    return arr
+
+print("Selection Sort:", selection_sort(datos))
+# Esperado: [11, 12, 22, 25, 64]
+
+
+# ------ Tarea 3: Insertion Sort ------
+# Implementa Insertion Sort.
+# Idea: toma un elemento y lo inserta en su posición correcta
+# dentro del subarreglo ya ordenado.
+def insertion_sort(lista):
+    arr = lista[:]
+    # Tu código aquí:
+    return arr
+
+print("Insertion Sort:", insertion_sort(datos))
+# Esperado: [11, 12, 22, 25, 64]
+
+
+# ------ Tarea 4: Merge Sort ------
+# Implementa Merge Sort de forma recursiva.
+# Idea: divide la lista en mitades, ordena cada mitad y combina.
+def merge_sort(lista):
+    if len(lista) <= 1:
+        return lista
+    # Tu código aquí:
+    pass
+
+print("Merge Sort:", merge_sort(datos))
+# Esperado: [11, 12, 22, 25, 64]
+
+
+# ------ Tarea 5: Quick Sort ------
+# Implementa Quick Sort de forma recursiva.
+# Idea: elige un pivote, separa los menores y mayores, y ordena recursivamente.
+def quick_sort(lista):
+    if len(lista) <= 1:
+        return lista
+    # Tu código aquí (elige el primer elemento como pivote):
+    pass
+
+print("Quick Sort:", quick_sort(datos))
+# Esperado: [11, 12, 22, 25, 64]
+
+
+# ------ Tarea 6: Comparación de rendimiento ------
+# Usando el módulo timeit, mide cuánto tarda cada algoritmo
+# en ordenar una lista de 1000 elementos aleatorios.
+import timeit
+import random
+
+grande = random.sample(range(10000), 1000)
+
+# Tu código aquí: mide y compara tiempos
+
+
+# =============================================================
+# Ejemplos de solución
+# =============================================================
+# --- Tarea 1 ---
+# def bubble_sort(lista):
+#     arr = lista[:]
+#     n = len(arr)
+#     for i in range(n):
+#         for j in range(0, n - i - 1):
+#             if arr[j] > arr[j + 1]:
+#                 arr[j], arr[j + 1] = arr[j + 1], arr[j]
+#     return arr
+
+# --- Tarea 2 ---
+# def selection_sort(lista):
+#     arr = lista[:]
+#     n = len(arr)
+#     for i in range(n):
+#         idx_min = i
+#         for j in range(i + 1, n):
+#             if arr[j] < arr[idx_min]:
+#                 idx_min = j
+#         arr[i], arr[idx_min] = arr[idx_min], arr[i]
+#     return arr
+
+# --- Tarea 3 ---
+# def insertion_sort(lista):
+#     arr = lista[:]
+#     for i in range(1, len(arr)):
+#         clave = arr[i]
+#         j = i - 1
+#         while j >= 0 and arr[j] > clave:
+#             arr[j + 1] = arr[j]
+#             j -= 1
+#         arr[j + 1] = clave
+#     return arr
+
+# --- Tarea 4 ---
+# def merge_sort(lista):
+#     if len(lista) <= 1:
+#         return lista
+#     mid = len(lista) // 2
+#     izq = merge_sort(lista[:mid])
+#     der = merge_sort(lista[mid:])
+#     resultado = []
+#     i = j = 0
+#     while i < len(izq) and j < len(der):
+#         if izq[i] <= der[j]:
+#             resultado.append(izq[i]); i += 1
+#         else:
+#             resultado.append(der[j]); j += 1
+#     return resultado + izq[i:] + der[j:]
+
+# --- Tarea 5 ---
+# def quick_sort(lista):
+#     if len(lista) <= 1:
+#         return lista
+#     pivote = lista[0]
+#     menores = [x for x in lista[1:] if x <= pivote]
+#     mayores = [x for x in lista[1:] if x > pivote]
+#     return quick_sort(menores) + [pivote] + quick_sort(mayores)

algoritmos/02_busqueda.py

@@ -0,0 +1,121 @@
+# =============================================================
+# Ejercicio: Algoritmos de búsqueda
+# Nivel: Algoritmos
+# =============================================================
+# Descripción:
+#   Implementa los algoritmos de búsqueda más comunes y
+#   analiza su complejidad temporal.
+# =============================================================
+
+# ------ Tarea 1: Búsqueda lineal ------
+# Implementa la búsqueda lineal: recorre la lista elemento
+# a elemento hasta encontrar el objetivo.
+# Retorna el índice si lo encuentra, o -1 si no existe.
+def busqueda_lineal(lista, objetivo):
+    # Tu código aquí:
+    pass
+
+numeros = [5, 3, 8, 1, 9, 2, 7, 4, 6]
+print(busqueda_lineal(numeros, 9))   # 4
+print(busqueda_lineal(numeros, 10))  # -1
+
+
+# ------ Tarea 2: Búsqueda binaria (iterativa) ------
+# La lista DEBE estar ordenada. Divide el espacio de búsqueda
+# a la mitad en cada paso.
+# Complejidad: O(log n)
+def busqueda_binaria(lista, objetivo):
+    izquierda, derecha = 0, len(lista) - 1
+    # Tu código aquí:
+    pass
+
+ordenada = sorted(numeros)
+print("Lista ordenada:", ordenada)
+print(busqueda_binaria(ordenada, 7))   # índice de 7 en la lista ordenada
+print(busqueda_binaria(ordenada, 10))  # -1
+
+
+# ------ Tarea 3: Búsqueda binaria (recursiva) ------
+def busqueda_binaria_recursiva(lista, objetivo, izquierda=None, derecha=None):
+    if izquierda is None:
+        izquierda = 0
+    if derecha is None:
+        derecha = len(lista) - 1
+    # Tu código aquí:
+    pass
+
+print(busqueda_binaria_recursiva(ordenada, 7))
+print(busqueda_binaria_recursiva(ordenada, 10))
+
+
+# ------ Tarea 4: Búsqueda en matriz ------
+# Dada una matriz n×m de números enteros ordenados de forma
+# que cada fila está ordenada de izquierda a derecha y la
+# primera celda de cada fila es mayor que la última de la
+# fila anterior, determina si un objetivo existe en la matriz.
+def buscar_en_matriz(matriz, objetivo):
+    # Tu código aquí (pista: aplica búsqueda binaria):
+    pass
+
+matriz = [
+    [1,  3,  5,  7],
+    [10, 11, 16, 20],
+    [23, 30, 34, 60],
+]
+print(buscar_en_matriz(matriz, 3))   # True
+print(buscar_en_matriz(matriz, 13))  # False
+
+
+# =============================================================
+# Ejemplos de solución
+# =============================================================
+# --- Tarea 1 ---
+# def busqueda_lineal(lista, objetivo):
+#     for i, valor in enumerate(lista):
+#         if valor == objetivo:
+#             return i
+#     return -1
+
+# --- Tarea 2 ---
+# def busqueda_binaria(lista, objetivo):
+#     izquierda, derecha = 0, len(lista) - 1
+#     while izquierda <= derecha:
+#         medio = (izquierda + derecha) // 2
+#         if lista[medio] == objetivo:
+#             return medio
+#         elif lista[medio] < objetivo:
+#             izquierda = medio + 1
+#         else:
+#             derecha = medio - 1
+#     return -1
+
+# --- Tarea 3 ---
+# def busqueda_binaria_recursiva(lista, objetivo, izquierda=None, derecha=None):
+#     if izquierda is None: izquierda = 0
+#     if derecha is None: derecha = len(lista) - 1
+#     if izquierda > derecha:
+#         return -1
+#     medio = (izquierda + derecha) // 2
+#     if lista[medio] == objetivo:
+#         return medio
+#     elif lista[medio] < objetivo:
+#         return busqueda_binaria_recursiva(lista, objetivo, medio + 1, derecha)
+#     else:
+#         return busqueda_binaria_recursiva(lista, objetivo, izquierda, medio - 1)
+
+# --- Tarea 4 ---
+# def buscar_en_matriz(matriz, objetivo):
+#     if not matriz:
+#         return False
+#     filas, cols = len(matriz), len(matriz[0])
+#     izq, der = 0, filas * cols - 1
+#     while izq <= der:
+#         mid = (izq + der) // 2
+#         valor = matriz[mid // cols][mid % cols]
+#         if valor == objetivo:
+#             return True
+#         elif valor < objetivo:
+#             izq = mid + 1
+#         else:
+#             der = mid - 1
+#     return False