feat: add articles to normal challenges

Author: IbatoLionDev

2-NORMAL/Python/1-binary-search-tree-operations/article.md

@@ -0,0 +1,107 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Implement a binary search tree (BST) that supports insertions, searches, and deletions. Test different traversals (in-order, pre-order, and post-order) to ensure the tree updates correctly.
+
+### Code Explanation
+The BST is implemented with a `Node` class representing each node and a `BinarySearchTree` class managing the tree. The tree supports:
+- `insert(key)`: Inserts a key into the BST.
+- `search(key)`: Searches for a key in the BST.
+- `delete(key)`: Deletes a key from the BST.
+- Traversal methods: `inorder()`, `preorder()`, and `postorder()` return lists of keys in respective traversal orders.
+
+The deletion handles three cases:
+- Node with no children.
+- Node with one child.
+- Node with two children (replaces with inorder successor).
+
+### Relevant Code Snippets
+
+```python
+class Node:
+    def __init__(self, key):
+        self.key = key
+        self.left = None
+        self.right = None
+
+class BinarySearchTree:
+    def __init__(self):
+        self.root = None
+
+    def insert(self, key):
+        if self.root is None:
+            self.root = Node(key)
+        else:
+            self._insert(self.root, key)
+
+    def _insert(self, root, key):
+        if key < root.key:
+            if root.left is None:
+                root.left = Node(key)
+            else:
+                self._insert(root.left, key)
+        else:
+            if root.right is None:
+                root.right = Node(key)
+            else:
+                self._insert(root.right, key)
+```
+
+### Historical Context
+Binary Search Trees are fundamental data structures in computer science, used to maintain sorted data and allow efficient insertion, deletion, and lookup operations. They form the basis for more advanced balanced trees like AVL and Red-Black trees.
+
+---
+
+## Versión en Español
+
+### Descripción del Reto
+Implementa un árbol binario de búsqueda (BST) que soporte inserciones, búsquedas y eliminaciones. Prueba diferentes recorridos (inorden, preorden y postorden) para asegurar que el árbol se actualice correctamente.
+
+### Explicación del Código
+El BST se implementa con una clase `Node` que representa cada nodo y una clase `BinarySearchTree` que maneja el árbol. El árbol soporta:
+- `insert(key)`: Inserta una clave en el BST.
+- `search(key)`: Busca una clave en el BST.
+- `delete(key)`: Elimina una clave del BST.
+- Métodos de recorrido: `inorder()`, `preorder()` y `postorder()` que retornan listas de claves en los respectivos órdenes de recorrido.
+
+La eliminación maneja tres casos:
+- Nodo sin hijos.
+- Nodo con un hijo.
+- Nodo con dos hijos (se reemplaza con el sucesor en inorden).
+
+### Fragmentos de Código Relevantes
+
+```python
+class Node:
+    def __init__(self, key):
+        self.key = key
+        self.left = None
+        self.right = None
+
+class BinarySearchTree:
+    def __init__(self):
+        self.root = None
+
+    def insert(self, key):
+        if self.root is None:
+            self.root = Node(key)
+        else:
+            self._insert(self.root, key)
+
+    def _insert(self, root, key):
+        if key < root.key:
+            if root.left is None:
+                root.left = Node(key)
+            else:
+                self._insert(root.left, key)
+        else:
+            if root.right is None:
+                root.right = Node(key)
+            else:
+                self._insert(root.right, key)
+```
+
+### Contexto Histórico
+Los árboles binarios de búsqueda son estructuras de datos fundamentales en la informática, utilizadas para mantener datos ordenados y permitir inserciones, eliminaciones y búsquedas eficientes. Forman la base para árboles balanceados más avanzados como AVL y Red-Black.

2-NORMAL/Python/10-top-k-frequent-elements/article.md

@@ -0,0 +1,87 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Given an array of numbers, create a function that returns the k elements that appear most frequently. Consider using data structures like hash maps and heaps to efficiently manage frequency. Provide two variants using OOP: one with hash map and sorting, and another with hash map and heap.
+
+### Code Explanation
+The solution provides two classes:
+
+- `TopKFrequentHashMap`: Uses a hash map (Counter) to count frequencies and sorts the items by frequency in descending order to return the top k elements.
+- `TopKFrequentHeap`: Uses a hash map (Counter) and a heap (priority queue) to efficiently retrieve the top k elements with the highest frequency.
+
+### Relevant Code Snippets
+
+```python
+from collections import Counter
+
+class TopKFrequentHashMap:
+    def __init__(self, nums):
+        self.nums = nums
+
+    def top_k_frequent(self, k):
+        count = Counter(self.nums)
+        sorted_items = sorted(count.items(), key=lambda x: x[1], reverse=True)
+        return [item[0] for item in sorted_items[:k]]
+```
+
+```python
+from collections import Counter
+import heapq
+
+class TopKFrequentHeap:
+    def __init__(self, nums):
+        self.nums = nums
+
+    def top_k_frequent(self, k):
+        count = Counter(self.nums)
+        return [item for item, freq in heapq.nlargest(k, count.items(), key=lambda x: x[1])]
+```
+
+### Historical Context
+Finding the top k frequent elements is a common problem in data analysis and information retrieval. Using hash maps for frequency counting and heaps for efficient retrieval are standard techniques in algorithm design.
+
+---
+
+## Versión en Español
+
+### Descripción del Reto
+Dado un arreglo de números, crea una función que devuelva los k elementos que aparecen con mayor frecuencia. Considera usar estructuras de datos como mapas hash y montículos para gestionar eficientemente la frecuencia. Proporciona dos variantes usando POO: una con mapa hash y ordenamiento, y otra con mapa hash y montículo.
+
+### Explicación del Código
+La solución proporciona dos clases:
+
+- `TopKFrequentHashMap`: Usa un mapa hash (Counter) para contar frecuencias y ordena los elementos por frecuencia en orden descendente para devolver los k elementos principales.
+- `TopKFrequentHeap`: Usa un mapa hash (Counter) y un montículo (cola de prioridad) para obtener eficientemente los k elementos con mayor frecuencia.
+
+### Fragmentos de Código Relevantes
+
+```python
+from collections import Counter
+
+class TopKFrequentHashMap:
+    def __init__(self, nums):
+        self.nums = nums
+
+    def top_k_frequent(self, k):
+        count = Counter(self.nums)
+        sorted_items = sorted(count.items(), key=lambda x: x[1], reverse=True)
+        return [item[0] for item in sorted_items[:k]]
+```
+
+```python
+from collections import Counter
+import heapq
+
+class TopKFrequentHeap:
+    def __init__(self, nums):
+        self.nums = nums
+
+    def top_k_frequent(self, k):
+        count = Counter(self.nums)
+        return [item for item, freq in heapq.nlargest(k, count.items(), key=lambda x: x[1])]
+```
+
+### Contexto Histórico
+Encontrar los k elementos más frecuentes es un problema común en análisis de datos y recuperación de información. Usar mapas hash para contar frecuencias y montículos para recuperación eficiente son técnicas estándar en el diseño de algoritmos.

2-NORMAL/Python/2-merge-sort-implementation/article.md

@@ -0,0 +1,89 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Develop a function that implements the Merge Sort algorithm to sort an array. Evaluate the efficiency of your implementation and consider cases with large arrays.
+
+### Code Explanation
+Merge Sort is a divide-and-conquer algorithm that divides the array into halves, recursively sorts each half, and then merges the sorted halves.
+
+The `merge_sort` function recursively splits the array until subarrays have one element. The `merge` function then combines two sorted arrays into one sorted array.
+
+### Relevant Code Snippets
+
+```python
+def merge_sort(arr):
+    if len(arr) <= 1:
+        return arr
+
+    mid = len(arr) // 2
+    left = merge_sort(arr[:mid])
+    right = merge_sort(arr[mid:])
+
+    return merge(left, right)
+
+def merge(left, right):
+    result = []
+    i = j = 0
+
+    while i < len(left) and j < len(right):
+        if left[i] < right[j]:
+            result.append(left[i])
+            i += 1
+        else:
+            result.append(right[j])
+            j += 1
+
+    result.extend(left[i:])
+    result.extend(right[j:])
+    return result
+```
+
+### Historical Context
+Merge Sort was invented by John von Neumann in 1945. It is one of the earliest sorting algorithms and is notable for its stable sorting and O(n log n) time complexity, making it efficient for large datasets.
+
+---
+
+## Versión en Español
+
+### Descripción del Reto
+Desarrolla una función que implemente el algoritmo Merge Sort para ordenar un arreglo. Evalúa la eficiencia de tu implementación y considera casos con arreglos grandes.
+
+### Explicación del Código
+Merge Sort es un algoritmo de divide y vencerás que divide el arreglo en mitades, ordena recursivamente cada mitad y luego combina las mitades ordenadas.
+
+La función `merge_sort` divide recursivamente el arreglo hasta que los subarreglos tienen un elemento. La función `merge` combina dos arreglos ordenados en uno solo ordenado.
+
+### Fragmentos de Código Relevantes
+
+```python
+def merge_sort(arr):
+    if len(arr) <= 1:
+        return arr
+
+    mid = len(arr) // 2
+    left = merge_sort(arr[:mid])
+    right = merge_sort(arr[mid:])
+
+    return merge(left, right)
+
+def merge(left, right):
+    result = []
+    i = j = 0
+
+    while i < len(left) and j < len(right):
+        if left[i] < right[j]:
+            result.append(left[i])
+            i += 1
+        else:
+            result.append(right[j])
+            j += 1
+
+    result.extend(left[i:])
+    result.extend(right[j:])
+    return result
+```
+
+### Contexto Histórico
+Merge Sort fue inventado por John von Neumann en 1945. Es uno de los algoritmos de ordenamiento más antiguos y es conocido por su ordenamiento estable y complejidad temporal O(n log n), lo que lo hace eficiente para grandes conjuntos de datos.

2-NORMAL/Python/3-longest-unique-substring/article.md

@@ -0,0 +1,69 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Given a string, find the length of the longest substring without repeating characters. Use sliding window techniques to optimize the solution's performance.
+
+### Code Explanation
+The solution uses a sliding window approach with two pointers (`left` and `right`) and a dictionary to track the last index of each character. When a repeated character is found within the current window, the left pointer moves to the right of the previous occurrence to maintain a substring without duplicates.
+
+The function returns both the length and the longest substring without repeating characters.
+
+### Relevant Code Snippet
+
+```python
+def length_of_longest_substring(s):
+    char_index_map = {}
+    left = 0
+    max_length = 0
+    max_substring = ""
+
+    for right in range(len(s)):
+        if s[right] in char_index_map and char_index_map[s[right]] >= left:
+            left = char_index_map[s[right]] + 1
+        char_index_map[s[right]] = right
+        if right - left + 1 > max_length:
+            max_length = right - left + 1
+            max_substring = s[left:right+1]
+
+    return max_length, max_substring
+```
+
+### Historical Context
+The sliding window technique is a common approach in algorithm design to solve problems involving contiguous sequences efficiently. This problem is a classic example often asked in coding interviews to test understanding of hash maps and two-pointer techniques.
+
+---
+
+## Versión en Español
+
+### Descripción del Reto
+Dada una cadena, encuentra la longitud de la subcadena más larga sin caracteres repetidos. Usa técnicas de ventana deslizante para optimizar el rendimiento de la solución.
+
+### Explicación del Código
+La solución utiliza un enfoque de ventana deslizante con dos punteros (`left` y `right`) y un diccionario para rastrear el último índice de cada carácter. Cuando se encuentra un carácter repetido dentro de la ventana actual, el puntero izquierdo se mueve a la derecha de la ocurrencia previa para mantener una subcadena sin duplicados.
+
+La función retorna tanto la longitud como la subcadena más larga sin caracteres repetidos.
+
+### Fragmento de Código Relevante
+
+```python
+def length_of_longest_substring(s):
+    char_index_map = {}
+    left = 0
+    max_length = 0
+    max_substring = ""
+
+    for right in range(len(s)):
+        if s[right] in char_index_map and char_index_map[s[right]] >= left:
+            left = char_index_map[s[right]] + 1
+        char_index_map[s[right]] = right
+        if right - left + 1 > max_length:
+            max_length = right - left + 1
+            max_substring = s[left:right+1]
+
+    return max_length, max_substring
+```
+
+### Contexto Histórico
+La técnica de ventana deslizante es un enfoque común en el diseño de algoritmos para resolver problemas que involucran secuencias contiguas de manera eficiente. Este problema es un ejemplo clásico que se pregunta frecuentemente en entrevistas técnicas para evaluar el entendimiento de mapas hash y técnicas de dos punteros.