---

Modo de uso

1. Copia la sección de enunciados en tu entrada y protégela con el bloque spoiler de tu theme/plug-in.
2. Indica al lector que dispone de 2 h 30 min para completarlo.
3. La sección de soluciones colócala en un spoiler aparte, para que sólo se revele al corregir.
4. Recomienda repetir el simulacro hasta alcanzar ≥ 8/10.

---

1️⃣ Enunciados

Dada una lista doble dll_t<T>, implementa

template<typename T>
void dll_t<T>::rotate_left(std::size_t k);

que rota la lista k posiciones a la izquierda (el primer nodo pasa al final).

• Debe ejecutarse en O(n) tiempo y O(1) memoria.
• Controla los casos k ≥ n y lista vacía.

---

Implementa una plantilla:

template<typename Container, typename T>
int binary_search(const Container& c, const T& x, int l, int r);

• Devuelve el índice de x si existe; -1 en caso contrario.
• Requiere que c disponga de operator[] y size().
• Complejidad O(log n).

---

Completa el método:

template<typename T>
class avl_t {
  /* …nodo, altura, etc… */
  node_t* insert(node_t* root, const T& x);
};

• Debe mantener el factor de balance ∈ {-1,0,1}.
• Implementa las rotaciones LL, RR, LR, RL.
• Devuelve el nuevo root tras insertar x.

---

Para un grafo no dirigido:

using graph_t = vector_t< vector_t<int> >;

Implementa

int connected_components(const graph_t& g);

usando DFS con pila explícita (no recursión). Complejidad O(V + E).

---

Partiendo de:

struct triple { int i, j; double v; };        // fila, col, valor
using sparse_t = vector_t<triple>;            // ordenado por (i,j)

Implementa

sparse_t sparse_mult(const sparse_t& A, const sparse_t& B,
                     int m, int n, int p);

que devuelve C = A × B, donde

• A es m × n, B es n × p, C es m × p.
• Sólo almacena triples no nulos.
• Aprovecha que los vectores están ordenados para lograr O( |A|·|B| ).

---

Dados dos stack_l_t<T> s1, s2, crea la función libre

template<typename T>
void swap_tops(stack_l_t<T>& s1, stack_l_t<T>& s2, std::size_t k);

que intercambia los k elementos superiores de cada pila. Usa sólo operaciones de la propia pila; complejidad O(k).

---

FIN de la parte visible
——— No mires debajo hasta terminar ———

---

2️⃣ Soluciones oficiales

---

---

3️⃣ Mini-tests de autocorrección

---

4️⃣ Consejos exprés

• Compila con g++ -std=c++17 -Wall -Wextra -pedantic.
• Pon assert en pre-/post-condiciones: puntúan fácil.
• Memoriza complejidades y casos borde (n = 0, k ≥ n, etc.).
• Dibuja punteros en papel para evitar errores de lógica.

---

¡Listo! Añade este cuarto simulacro a tu blog y ofrece a tus lectores aún más práctica antes del examen.
¿Te ha resultado útil? ¡Comenta y comparte! 🚀

---

NUESTRAS ÚLTIMAS PUBLICACIONES

Buscar

• Proyectos que puedes empezar para aprender a programar (Academia San Roque)
• 15 ejercicios básicos en R (con soluciones)
• 📘 5 Ejercicios Sencillos de Programación en R (con soluciones)
• Guía para Aprender a Estudiar Programación con las 10 Claves de la Autodisciplina
• Serializar una lista de personas (nombre, apellido, DNI) en Java y guardarla en un archivo binario
• 
  Simulacro de Examen — Fundamentos de Programación (Laboratorio)
• 
  Reflexiones en Academia SanRoque: La importancia de la motivación, el esfuerzo y el aprendizaje en la educación y la formación
• 
  CHECK Constraint en Oracle SQL: garantiza la calidad de tus datos paso a paso
• 
  Simulacro #4 – Examen de C++ / Estructuras de Datos
• 
  Simulacro #3 – Examen de C++ / Estructuras de Datos
• 
  Simulacro #2 de Examen C++
• 
  Simulacro de Examen de Estructuras de Datos en C++ (con Soluciones)Guía completa para repasar antes del parcial/final

---