🚀 Plan Maestro de Maestría Algorítmica y Arquitectura de Memoria (70 Días / 10 Semanas: Rust & Python)#

Objetivo de Alto Rendimiento: Desarrollar conexiones neuronales profundas, comprensión física y matemática de las estructuras de datos, y alcanzar autonomía técnica (seniority L5/L6+) para resolver problemas Easy, Medium y Hard de LeetCode y diseñar sistemas de baja latencia en Rust y Python sin depender de la IA ni de memorizaciones superficiales.

🧭 Índice Rápido del Repositorio (Navegador General)#

• 📖 Glosario Maestro de Conceptos (Raíz) y Glosario Maestro (Carpeta glossary): Enciclopedia técnica visual con 106 conceptos desglosados en 4 capas cognitivas (Intuición, Técnica, Código Rust/Python y Error Típico).
• 📊 Suite Visual de Arquitectura de Memoria y Algoritmos: 80 diagramas vectoriales SVG (10 panorámicas de arquitectura y 70 diagramas de sesión diaria) con diccionario visual de hardware.
• 🧪 Suite de 141 Pruebas Unitarias: Suite automatizada que cubre el 100% de los algoritmos y estructuras de datos de todo el programa.
• 💻 Módulos de Código en Python: Implementaciones de referencia limpias, modulares y tipadas de los 70 días.
• 📚 Sesiones de Estudio Diario en Markdown: Las 70 lecciones estructuradas con el protocolo Paper-First y trazas de hardware.

⚡ Acceso Directo por Semanas:#

• 0. Guía de Supervivencia desde Cero para Junior / Trainee: De Python a Rust Visual
• Preguntas de Autodiagnóstico Inicial para Junior / Trainee
• Semana 1: Búsqueda Binaria, Big O y Arreglos/Strings (Días 01 al 07)
• Semana 2: Memoria, Recursión y Listas Enlazadas (Días 08 al 14)
• Semana 3: Quicksort, Hash Tables, Stacks & Queues y Pila Monótona (Días 15 al 21)
• Semana 4: Árboles, BST, Grafos, TopoSort y Dijkstra (Días 22 al 28)
• Semana 5: Síntesis Compuesta, Heaps y Simulacro FAANG (Días 29 al 35)
• Semana 6: Greedy, Backtracking y Programación Dinámica (Días 36 al 42)
• Semana 7: Bits, Búsqueda Avanzada, Tries y DSU (Días 43 al 49)
• Semana 8: Trapping Rain Water, Fenwick/Segment Trees y LFU Cache (Días 50 al 56)
• Semana 9: KNN, Bloom Filters, HLL, Simhash, Knuth y Consistent Hashing (Días 57 al 63)
• Semana 10: Tests Diagnósticos, Gran Simulacro Staff y Graduación L6 (Días 64 al 70)

0. Guía de Supervivencia desde Cero para Junior / Trainee: De Python a Rust Visual#

🎨 Cómo Interpretar los Diagramas Visuales SVG y Trazas de Memoria#

Cada lección del programa incluye un diagrama arquitectónico en diagrams/sesiones/ diseñado bajo principios de codificación cognitiva. Para leerlos con la precisión de un ingeniero de sistemas:

1. El Stack (Cajas Sólidas a la Izquierda): Representa la memoria fija de ejecución directa de la CPU. Observarás descriptores con tres campos de 8 bytes para Vec<T>: ptr (dirección hexadecimal hacia el Heap), len (elementos activos) y cap (capacidad total asignada).
2. El Heap (Búferes Horizontales a la Derecha): Muestra bloques de celdas contiguas con sus direcciones físicas (0x5000: [10 | 20 | 30 | _ ]). Las celdas con números contienen datos vivos; las celdas con _ representan capacidad reservada pero no inicializada.
3. Fat Pointers (&[T] y &str, Cajas Moradas de 16 Bytes): Observa cómo una referencia de slice no copia ningún dato: simplemente almacena un puntero al inicio del segmento deseado y la longitud visible. ¡Tiempo O(1) y 0 bytes de Heap!
4. Diferenciación de Flechas: - Flecha sólida continua: Puntero dueño exclusivo (Ownership, por ejemplo un Box<Node> o Vec<T>). Si el origen desaparece, el destino se destruye. - Flecha punteada: Referencia prestada (Borrowing &T). El dueño reside en otra parte; esta flecha solo observa o muta temporalmente sin poder destruir la memoria.

🛡️ Las 5 Reglas de Oro de Rust para Algoritmos (Que Todo Junior Debe Saber el Día 1)#

1. Índices usize sin signo y la trampa del underflow en Búsqueda Binaria#

En Rust, los índices de arreglos tienen obligatoriamente el tipo usize (entero sin signo de 64 bits en x86_64). Como nunca puede ser negativo:

• Si calculas let mut high = arr.len() - 1; con un arreglo vacío (len == 0), 0usize - 1 desborda a 18,446,744,073,709,551,615 provocando un pánico en depuración.
• Si en búsqueda binaria calculas high = mid - 1; cuando mid == 0, ocurre exactamente el mismo pánico.
• La solución canónica y elegante: Trabajar con intervalos semiabiertos [low, high) donde high = arr.len() y cuando se busca a la izquierda se hace high = mid; (¡cero restas a cero!). O bien utilizar el método seguro mid.checked_sub(1).

2. Slices &[i32] y &mut [i32] en lugar de clonar Vec<i32>#

En Python, hacer arr[1:4] clona los datos en el Heap en O(K). Muchos programadores novatos en Rust escriben fn solve(arr: Vec<i32>) y clonan con .clone() para calmar al compilador.

• Clonar un vector de N elementos en cada nivel de recursión degrada un algoritmo de O(N) a un desastre de O(N²) en tiempo y memoria.
• La regla de oro: Pasa siempre referencias prestadas &[i32] (para lectura) o &mut [i32] (para mutación in-place). Pesa solo 16 bytes en el Stack y tiene costo O(1) absoluto.

3. Option<usize> (Some(idx) / None) en lugar del número mágico -1#

En Python o C, las funciones de búsqueda suelen retornar -1 cuando un elemento no existe.

• En Rust, como los índices son usize, -1 no existe conceptualmente. Si intentas retornar -1i32 y convertirlo a usize, obtendrás un índice astronómico que violará los límites de memoria.
• Rust modela la ausencia de valor con el enum algebraico Option<usize> (Some(index) si fue encontrado, None si no existe). El compilador te obliga a desarmar el Option con match o if let Some, erradicando fallos en producción.

4. HashMap::entry(), VecDeque y BinaryHeap con std::cmp::Reverse#

• Mapas de Frecuencia: En lugar de consultar if map.contains_key(...) y luego insertar (dos búsquedas lentas), usa la API de un solo paso: *map.entry(x).or_insert(0) += 1;.
• Colas FIFO: Jamás uses vec.remove(0) (O(N)). Usa VecDeque::new() con push_back y pop_front en O(1) estricto amortizado.
• Min-Heap vs Max-Heap: En Python, heapq es un Min-Heap por defecto. En Rust, BinaryHeap es un Max-Heap por defecto. Para obtener un Min-Heap en Rust, envuelve los valores en std::cmp::Reverse(val).

5. Listas y Árboles con Option<Box<Node>> o Arena Indexing (Vec<Node>)#

En Rust no existen punteros nulos crudos (NULL).

• Para estructuras jerárquicas simples (árboles binarios o listas simples), se utiliza Option<Box<Node>> donde cada nodo es el dueño único de sus descendientes.
• Para grafos complejos o estructuras con punteros dobles y ciclos, la solución suprema de la industria no es usar punteros complicados (Rc<RefCell<Node>>), sino el Arena Indexing: almacenar todos los nodos en un Vec<Node> contiguo y usar enteros usize como identificadores. Esto maximiza la memoria caché L1 y simplifica el Borrow Checker al 100%.

🧪 Starter Code Inicial Compilable y Verificado (rustc --test)#

El siguiente código fuente en Rust demuestra en acción las 5 Reglas de Oro. Puedes compilarlo y ejecutarlo directamente con el compilador oficial de Rust:

use std::collections::{HashMap, VecDeque, BinaryHeap};
use std::cmp::Reverse;

// Regla 1 y 3: Búsqueda binaria segura con intervalos semiabiertos [low, high) y Option<usize>
pub fn safe_binary_search(nums: &[i32], target: i32) -> Option<usize> {
    if nums.is_empty() {
        return None;
    }
    let mut low: usize = 0;
    let mut high: usize = nums.len(); // Half-open interval prevents underflow!

    while low < high {
        let mid = low + (high - low) / 2; // Prevents integer overflow
        if nums[mid] == target {
            return Some(mid); // Found!
        } else if nums[mid] < target {
            low = mid + 1;
        } else {
            high = mid; // Safe! No `mid - 1` underflow when mid == 0
        }
    }
    None
}

// Regla 2: Inversión in-place sobre un mutable slice &mut [i32] sin clonar memoria
pub fn reverse_slice(arr: &mut [i32]) {
    if arr.is_empty() { return; }
    let mut left = 0;
    let mut right = arr.len() - 1;
    while left < right {
        arr.swap(left, right);
        left += 1;
        right = right.saturating_sub(1);
    }
}

// Regla 4: Conteo de frecuencias en 1 sola búsqueda con entry().or_insert()
pub fn frequency_map(items: &[i32]) -> HashMap<i32, usize> {
    let mut map = HashMap::new();
    for &x in items {
        *map.entry(x).or_insert(0) += 1; // Single hash lookup!
    }
    map
}

// Regla 4: Cola FIFO O(1) con VecDeque
pub fn bfs_level_order_simulation(root_val: i32) -> Vec<i32> {
    let mut queue = VecDeque::new();
    let mut visited = Vec::new();
    queue.push_back(root_val);

    while let Some(current) = queue.pop_front() { // O(1) front extraction
        visited.push(current);
        if current < 3 {
            queue.push_back(current + 1);
        }
    }
    visited
}

// Regla 4: Min-Heap en Rust usando Reverse(T)
pub fn min_heap_k_smallest(nums: &[i32], k: usize) -> Vec<i32> {
    let mut min_heap = BinaryHeap::new();
    for &x in nums {
        min_heap.push(Reverse(x)); // Reverse converts Max-Heap into Min-Heap
    }
    let mut result = Vec::new();
    for _ in 0..k.min(nums.len()) {
        if let Some(Reverse(val)) = min_heap.pop() {
            result.push(val);
        }
    }
    result
}

// Regla 5: Arena Indexing para Árboles y Grafos continuos en memoria
#[derive(Debug, Clone)]
pub struct ArenaTreeNode {
    pub val: i32,
    pub left: Option<usize>,  // Index into arena vector
    pub right: Option<usize>, // Index into arena vector
}

pub struct ArenaTree {
    pub nodes: Vec<ArenaTreeNode>, // Contiguous buffer in Heap
}

impl ArenaTree {
    pub fn new() -> Self {
        Self { nodes: Vec::new() }
    }
    pub fn add_node(&mut self, val: i32) -> usize {
        let idx = self.nodes.len();
        self.nodes.push(ArenaTreeNode { val, left: None, right: None });
        idx
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_binary_search_found_and_not_found() {
        let data = [10, 20, 30, 40, 50];
        assert_eq!(safe_binary_search(&data, 30), Some(2));
        assert_eq!(safe_binary_search(&data, 10), Some(0));
        assert_eq!(safe_binary_search(&data, 50), Some(4));
        assert_eq!(safe_binary_search(&data, 99), None);
        assert_eq!(safe_binary_search(&[], 5), None);
    }

    #[test]
    fn test_reverse_slice() {
        let mut data = [1, 2, 3, 4, 5];
        reverse_slice(&mut data);
        assert_eq!(data, [5, 4, 3, 2, 1]);
    }

    #[test]
    fn test_frequency_map() {
        let nums = [4, 2, 4, 1, 2, 4];
        let freq = frequency_map(&nums);
        assert_eq!(freq.get(&4), Some(&3));
        assert_eq!(freq.get(&2), Some(&2));
        assert_eq!(freq.get(&1), Some(&1));
    }

    #[test]
    fn test_vec_deque_bfs() {
        let visited = bfs_level_order_simulation(1);
        assert_eq!(visited, vec![1, 2, 3]);
    }

    #[test]
    fn test_min_heap() {
        let nums = [40, 10, 30, 20, 50];
        let smallest3 = min_heap_k_smallest(&nums, 3);
        assert_eq!(smallest3, vec![10, 20, 30]);
    }

    #[test]
    fn test_arena_tree() {
        let mut tree = ArenaTree::new();
        let root = tree.add_node(100);
        let left = tree.add_node(50);
        let right = tree.add_node(150);
        tree.nodes[root].left = Some(left);
        tree.nodes[root].right = Some(right);

        assert_eq!(tree.nodes[root].val, 100);
        assert_eq!(tree.nodes[tree.nodes[root].left.unwrap()].val, 50);
        assert_eq!(tree.nodes[tree.nodes[root].right.unwrap()].val, 150);
    }
}

# Para ejecutar las pruebas en tu consola local:
rustc --test starter_algorithms.rs -o starter_test.exe
.\starter_test.exe

❓ Preguntas de Autodiagnóstico Inicial para Junior / Trainee#

Antes de iniciar tu estudio diario, responde honestamente a estas 5 preguntas diagnósticas para evaluar la solidez de tus modelos mentales:

let mut low: usize = 0;
let mut high: usize = arr.len() - 1; // Línea A
while low <= high {                 // Línea B
    let mid = (low + high) / 2;     // Línea C
    if arr[mid] == target { return Some(mid); }
    else if arr[mid] < target { low = mid + 1; }
    else { high = mid - 1; }        // Línea D
}

🧠 La Metodología de Aprendizaje Funcional (Paper-First)#

Muchos desarrolladores caen en la "ilusión de competencia": leen una solución, la entienden superficialmente, le piden a la IA que genere el código, y creen que lo dominan. Cuando llega la entrevista técnica o la pizarra en blanco, la mente se queda bloqueada.

Para construir seniority real, este plan utiliza 4 métodos cognitivos basados en neurociencia:

1. Protocolo Paper-First (Traza en Papel Obligatoria): - Antes de escribir una sola línea de código en el editor, debes ejecutar el algoritmo en papel. - Dibujarás la memoria, los índices y una tabla con el estado de cada variable en cada iteración. - Si no puedes simularlo a mano con lápiz en una lista de 5 elementos, no lo entiendes y la computadora solo ejecutará tus confusiones más rápido.

1. Técnica de Feynman: - Cada lección te exige explicar el concepto fundamental con palabras cotidianas y modelos mecánicos (por ejemplo: la memoria RAM como casilleros numerados contiguos, el logaritmo como doblar una hoja de papel, el puntero como una cuerda hacia otra caja).

1. Recuperación Activa (Active Recall): - Cada sesión incluye preguntas de verificación antes de mostrar la solución. Intenta responderlas mentalmente o por escrito antes de desplegar las respuestas.

1. Repetición Espaciada (Spaced Repetition): - Al inicio de cada día repasarás 5 minutos los conceptos del día anterior. Al final de cada ciclo semanal tendrás un examen de consolidación global.

🗺️ Hoja de Ruta Completa de 70 Días / 10 Semanas (Grokking + CTCI + Knuth TAOCP + DP + Tries + DSU + BIT + Segment Trees + LFU + Consistent Hashing + Bloom Filters + Staff Mock)#

Semana 1: Fundamentos de Búsqueda, Complejidad y Arreglos/Strings (Días 01 al 07)#

Semana 2: Memoria Dinámica, Recursión y Listas Enlazadas (Días 08 al 14)#

Semana 3: Divide & Conquer, Hash Tables Avanzadas, Stacks & Queues y Monotonic Stack (Días 15 al 21)#

Semana 4: Grafos, Árboles Binarios, BST, Orden Topológico y Dijkstra (Días 22 al 28)#

Semana 5: Refuerzo, Evaluación y Consolidación Global (Días 29 al 35)#

Semana 6: Algoritmos Voraces (Greedy), Backtracking y Programación Dinámica (Días 36 al 42)#

Semana 7: Manipulación de Bits, Búsqueda Avanzada, Tries y DSU (Días 43 al 49)#

Semana 8: FAANG Hard, Estructuras de Rango y Sistemas de Alto Rendimiento (Días 50 al 56)#

Semana 9: Algoritmos Avanzados, Probabilísticos y Sistemas Distribuidos (Días 57 al 63)#

Semana 10: Evaluación Diagnóstica, Tests Compuestos y Simulacros Staff (Días 64 al 70)#

💡 Conexión de Bajo Nivel para Desarrolladores JavaScript / TypeScript#

Como desarrollador con experiencia en JS/TS, tu intuición sobre arrays dinámicos y objetos es valiosa, pero en Rust, Python y en entrevistas de algoritmos aplican reglas de bajo nivel indispensables:

1. Arrays en el motor V8 vs Python Lists vs Rust Vectors: En JS, los arreglos inicializan como bloques contiguos en C++ (Fast Packed Elements), pero mutaciones arbitrarias los degradan a tablas hash lentas (Dictionary Mode). En Python, list es un arreglo dinámico de punteros de 64 bits. En Rust, Vec<T> es un búfer de memoria contigua pura sin intermediarios, optimizado para instrucciones vectoriales SIMD de CPU.
2. Punteros y Referencias en el Heap: En JS todos los objetos se asignan por referencia en el Heap. Al pasar un nodo: - node = node.next solo reasigna la variable local en el stack frame (sin mutar la estructura). - node.next = node.next.next o node.val = ... muta la memoria física en el Heap para todos los que observen la lista.
3. Identidad de Referencia vs Comparación de Valor: En JS nodeA === nodeB compara direcciones de memoria física en el Heap de V8, exactamente igual que nodeA is nodeB en Python o la comparación de punteros crudos en Rust. Comparar nodeA.val === nodeB.val solo verifica igualdad numérica.
4. El Call Stack y Stack Overflow: En Node.js o el navegador, la recursión profunda satura la pila asignada con RangeError: Maximum call stack size exceeded (~10,000 marcos). En Python el límite es 1,000. En Rust, un desbordamiento del hilo (2 MB - 8 MB) provoca una terminación abrupta protegida por páginas de guarda.
5. Estructuras Circulares y Serialización: Si una lista tiene ciclo, intentar imprimirla con JSON.stringify(head) en JS lanzará TypeError: Converting circular structure to JSON. En V8, los ciclos huérfanos se recolectan por Mark-and-Sweep. En Rust seguro, el sistema de Ownership prohíbe ciclos directos sin Arena Indexing.
6. Números Gigantes: En JS los números mayores que Number.MAX_SAFE_INTEGER (2⁵³ - 1) pierden precisión por el estándar IEEE 754. Operar dígito por dígito con linked lists (CTCI 2.5) es el modelo fundacional de BigInt.
7. LIFO y FIFO en el Event Loop: El Call Stack síncrono opera como una pila LIFO, mientras que el Microtask Queue (Promise.then) y el Macrotask Queue (setTimeout) operan como colas FIFO. El uso de shift() para desencolar es O(N) en V8; en Rust se usa VecDeque en O(1) estricto amortizado.
8. El DOM como Árbol N-ario y Reconciliación en React: El DOM es un árbol jerárquico. Los motores como React utilizan recorridos DFS sobre el árbol de componentes (Fiber Tree) para reconciliar cambios de forma óptima.
9. El Garbage Collector como Grafo de Conectividad: Node.js rastrea objetos mediante Mark-and-Sweep desde las GC Roots (variables globales y Call Stack). Todo nodo o ciclo no alcanzable es recolectado. En Rust, el compilador inserta drop en tiempo de compilación con costo cero en ejecución.
10. Event Bubbling y Lowest Common Ancestor (LCA): Al despachar un evento en el DOM, este asciende (bubbles up) por los ancestros hasta la raíz. El ancestro común más cercano a dos elementos hermanos (LCA) es el contenedor exacto para ubicar un event listener centralizado (Event Delegation).
11. Ausencia de Priority Queue en ECMAScript: JavaScript carece de un Min-Heap nativo en su librería estándar. Ordenar arreglos con arr.sort() en cada paso de Dijkstra dispara la complejidad a O(V² log V). Un Senior Developer implementa un Min-Heap binario sobre un array plano usando aritmética de índices (2*i + 1, 2*i + 2).
12. La Trampa de los Map con Claves Compuestas en JS: En Python, una tupla de coordenadas (r, c) es inmutable y hashable. En JS, Map compara objetos por referencia física ([0, 1] !== [0, 1]), obligando a serializar claves o aplanar índices (r * cols + c).
13. Ordenamiento Lexicográfico en Array.prototype.sort(): En JS, [10, 2].sort() produce [10, 2] por conversión a strings. En problemas voraces (Greedy Interval Scheduling), olvidar (a, b) => a[1] - b[1] destruye la garantía de optimalidad asintótica.
14. Aritmética en Punto Flotante vs Monedas Enteras: En algoritmos de Coin Change o pasarelas de pago (Stripe API), operar con decimales flotantes produce errores de redondeo IEEE 754 (0.1 + 0.2 !== 0.3). Siempre se opera en enteros base (centavos).
15. Diffing de Git y Virtual DOM como Longest Common Subsequence (LCS): La alineación óptima de secuencias mediante DP es el fundamento matemático que utilizan git diff y el reconciliador de React (Fiber) para calcular el número mínimo de mutaciones en el DOM.
16. Operadores Bitwise y Coerción ToInt32 en V8: En JS los números comunes son Number (flotante de 64 bits IEEE 754). Al aplicar operadores bitwise (|, &, ^, ~, <<, >>), V8 trunca el operando a un entero de 32 bits con signo (ToInt32) antes de ejecutar la instrucción de CPU.
17. TypedArray y ArrayBuffer como Vectores de Bits Compactos: Crear arreglos normales [] de booleanos consume hasta 8 bytes por elemento en Heap. Un Senior Developer utiliza new Uint32Array(1000) para empaquetar 32,000 banderas binarias en exactamente 4 KB de memoria contigua en C++.
18. Radix Trees en Enrutadores Web vs Tries: Motores web de altísimo rendimiento como Fastify, Hono y el enrutador de Next.js (/api/users/:id) no usan expresiones regulares para hacer match de URLs: implementan Radix Trees (Tries comprimidos) que resuelven rutas dinámicas en sub-microsegundos.
19. Conectividad Dinámica en Aplicaciones Colaborativas: En herramientas como Figma, Miro o Google Docs, la agrupación de elementos en el canvas y la resolución de componentes conexas en tiempo real se modela mediante estructuras de conjuntos disjuntos (DSU / Union-Find) para sincronización con latencia cero.
20. Evicción de Caché en V8 y Service Workers (LFU vs LRU): En el Cache Storage API de los navegadores y capas de edge computing (Cloudflare Workers, Fastly VCL), los proxies inversos no usan heurísticas ingenuas: combinan contadores de frecuencia y listas temporales para mitigar escaneos masivos que desalojarían assets calientes.
21. TypedArrays Contiguos para Segment Trees y Fenwick Trees: En JS/TS, crear árboles basados en objetos { left, right, value } causa fragmentación severa del Heap. Un Senior Staff Engineer asigna un único Int32Array(4 * n) para Segment Trees o Int32Array(n + 1) para Fenwick Trees.
22. BigInt y Aritmética Modular en Criptografía: En JavaScript, cualquier número mayor a Number.MAX_SAFE_INTEGER (2⁵³ - 1) pierde precisión. Algoritmos de exponenciación modular y primalidad en Node.js exigen BigInt para evitar corrupciones en firmas criptográficas.
23. Monotonic Deques sobre Buffers Circulares: En V8, Array.prototype.shift() es O(N) porque reorganiza la memoria interna. Para mantener ventanas deslizantes de telemetría a 60 FPS sin GC pauses, se implementa un buffer circular con máscara de potencia de 2 (index & (capacity - 1)) sobre Int32Array.
24. Búsqueda Vectorial y Embeddings en TypeScript: Cosine Similarity y distancia euclidiana implementadas sobre Float64Array para vector stores (pgvector, ChromaDB, Pinecone) en Node.js sin sobrecargar el recolector de basura de V8.
25. Filtros Probabilísticos en Redis: HyperLogLog (PFADD/PFCOUNT con 12 KB fijos) para conteo de DAUs masivos y Bloom Filters (BF.ADD/BF.EXISTS con RedisBloom) para evitar lecturas innecesarias en bases de datos relacionales.
26. Compresión Delta y Posting Lists en Motores Full-Text: Índices invertidos con dos punteros convergentes y compresión gap (deltas) en librerías de búsqueda como FlexSearch o MiniSearch en Node.js.
27. Consistent Hashing y Token Bucket en Microservicios: Consistent Hash Ring con réplicas virtuales para balanceo sin fallas en cascada y control de ráfagas con Token Bucket de evaluación perezosa en middlewares de Express/NestJS.

📝 El Protocolo de 5 Pasos para Resolver en Papel#

Frente a cualquier problema de LeetCode o entrevista, sigue esta disciplina estricta:

[1. Entender] --> [2. Casos Borde] --> [3. Traza en Papel] --> [4. Pseudocódigo] --> [5. Código Rust/Python]

1. Entender el problema: Reescribe el enunciado en 1 oración con tus propias palabras. Define entradas y salidas.
2. Definir Casos Borde en Papel: - ¿Qué pasa si la lista o estructura está vacía None o []? - ¿Qué pasa si tiene un solo elemento [x]? - ¿Qué pasa si hay elementos duplicados o negativos? - ¿Qué pasa si hay ciclos o no existe intersección?
3. Traza Manual (Dry Run): - Dibuja un ejemplo concreto pequeño (4 a 6 nodos). - Escribe una tabla de variables: columnas para cada puntero y variable de control. - Simula paso a paso qué cambia en cada iteración.
4. Pseudocódigo: - Escribe en español o pseudocódigo la lógica antes de preocuparte por la sintaxis.
5. Código Limpio y Verificación: - Implementa la solución con tipos estrictos. - Ejecuta las pruebas automatizadas.

🧪 Ejecución de Pruebas Automatizadas#

El proyecto incluye implementaciones verificadas y una suite de pruebas con 141 pruebas unitarias exhaustivas para validar tu comprensión en todos los 70 días del plan:

# Ejecutar todas las pruebas unitarias de Python desde la raíz del proyecto:
py -m unittest practica.test_soluciones -v

# Ejecutar las pruebas unitarias de Rust de las 5 Reglas de Oro:
rustc --test starter_algorithms.rs -o starter_test.exe
.\starter_test.exe

📁 Estructura del Repositorio#

• GLOSARIO.md: Glosario Maestro de 106 conceptos en 4 capas cognitivas y modelos de hardware en Rust y Python.
• glossary/README.md: Réplica sincronizada del glosario maestro con rutas relativas a la suite de diagramas.
• diagrams/: Suite visual con 80 diagramas SVG panorámicos y de sesión diaria.
• diagrams/README.md: Documentación completa de la arquitectura visual de memoria y diccionario de notación física.
• sesiones/: Contiene las 70 lecciones interactivas en Markdown con teoría profunda, diagramas de hardware, trazas en papel, preguntas de active recall y código fuente.
• practica/: Código Python limpio, modular y tipado con las soluciones de referencia de los 70 días.
• practica/test_soluciones.py: Pruebas unitarias de cobertura exhaustiva (141 pruebas pasando al 100%).