---

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

• 
  ¡VOLVEMOS A NUESTROS HORARIOS HABITUALES!
• 
  Especificadores de formato en C (printf/sprintf y scanf)
• 
  Propuestas de actividades avanzadas con XML, DTD, XPath y XSLT
• 
  Apuntes extensos de XML y XSLT
• 
  El momento IDEAL para impulsar tu FORMACIÓN y alcanzar tus Metas Académicas: LAS NAVIDADES.
• 
  20 ejercicios de funciones avanzadas en Python (al estilo de Ackermann)
• 
  Cómo guardar una página web completa en MySQL con PHP (urlencode, BLOB y otras técnicas)
• 
  60 ejercicios de funciones recursivas en Python para la carrera de Informática
• 
  SIMULACRO 2 – FP Programación de Videojuegos
• 
  Simulacro de examen – FP Programación de Videojuegos
• 
  ALERTA METEOROLÓGICA
• 
  Proyectos que puedes empezar para aprender a programar (Academia San Roque)

---