🎓 Módulo Práctico de IntegraciónVectores + Funciones por Referencia

Examen Práctico: Sistema CRUD de Estudiantes y Notas

En este módulo aprenderás a integrar dos de los pilares más importantes de la programación en C++:Vectores Dinámicos Paralelos (std::vector) yFunciones Modulares con Paso por Referencia (&). Analizaremos línea por línea un sistema real de gestión de estudiantes con notas (Create, Read, Update, Delete y Reportes Estadísticos), interactuaremos con un simulador visual de memoria RAM y terminal, y pondremos a prueba tus conocimientos con un cuestionario práctico interactivo.

Ruta de Aprendizaje:

7.1 Arreglos Fijos (1D)7.2 std::vector Dinámico 7.3 Arreglos 2D (Pac-Man)7.4 Examen CRUD: Estudiantes

Fundamentos: ¿Qué conceptos se aplican en este código?

📦

1. Vectores Paralelos

En lugar de usar estructuras complejas, modelamos la información de cada alumno usando dos vectores sincronizados por el mismo índice i:

// Sincronización por posición:(mismo índice = mismo estudiante)

Vector \ Columna	Índice [ 0 ]	Índice [ 1 ]	Índice [ 2 ]
vector<string> nombres	"Ana"	"Carlos"	"Beatriz"
vector<float> notas	6.5	4.2	5.8
Estudiante	Estudiante 1	Estudiante 2	Estudiante 3

nombres[i] guarda el texto con el nombre del alumno.
notas[i] guarda el número decimal (float) con la calificación.
Regla de Oro: Toda inserción o eliminación debe aplicarse en ambos vectores en la misma posición para no desfasar los datos.

⚡

2. Paso por Referencia (`&`)

Por defecto, C++ pasa variables por valor (haciendo una copia completa que se destruye al terminar la función). Al añadir el símbolo &:

void crear(vector<string>& nombres, vector<float>& notas)

↑ El símbolo & conecta la función con los vectores originales del main().

Modificación Real: Los .push_back() y .erase() alteran directamente la memoria del main().
Alto Rendimiento: No se duplican miles de registros en RAM al invocar las funciones.
Principio de Mínimo Privilegio:actualizar() solo recibe vector<float>& notas porque no necesita tocar los nombres.

Código Fuente Completo del Ejercicio

sistema_estudiantes_crud.cpp

CPP

#include <iostream>
#include <vector>
#include <string>
 
using namespace std;
 
// 1. CREATE
void crear(vector<string>& nombres, vector<float>& notas) {
    string nombre;
    float nota;
    cout << "Ingrese nombre: ";
    cin >> nombre;
    cout << "Ingrese nota: ";
    cin >> nota;
    
    nombres.push_back(nombre); 
    notas.push_back(nota);
    cout << "-> Guardado con exito.\n";
}
 
// 2. READ
void leer(vector<string>& nombres, vector<float>& notas) {
    cout << "\n--- LISTA DE PERSONAS ---\n";
    for (int i = 0; i < nombres.size(); i++) {
        cout << "[" << i << "] " << nombres[i] << " | Nota: " << notas[i] << "\n";
    }
}
 
// 3. UPDATE
void actualizar(vector<float>& notas) {
    int indice;
    cout << "Ingrese el numero (indice) para modificar la nota: ";
    cin >> indice;
    if (indice >= 0 && indice < notas.size()) {
        cout << "Ingrese nueva nota: ";
        cin >> notas[indice];
        cout << "-> Nota actualizada.\n";
    } else {
        cout << "-> Indice incorrecto.\n";
    }
}
 
// 4. DELETE
void eliminar(vector<string>& nombres, vector<float>& notas) {
    int indice;
    cout << "Ingrese el numero (indice) a eliminar: ";
    cin >> indice;
    if (indice >= 0 && indice < nombres.size()) {
        nombres.erase(nombres.begin() + indice);
        notas.erase(notas.begin() + indice);
        cout << "-> Eliminado con exito.\n";
    } else {
        cout << "-> Indice incorrecto.\n";
    }
}
 
// 5. REPORTES
void reportes(vector<string>& nombres, vector<float>& notas) {
    if (nombres.empty()) {
        cout << "-> No hay registros para generar reportes.\n";
        return; 
    }
 
    cout << "\n--- REPORTES ---\n";
    cout << "- Total registrados: " << nombres.size() << "\n";
    cout << "- Primer registro: " << nombres.front() << " (Nota: " << notas.front() << ")\n";
    cout << "- Ultimo registro: " << nombres.back() << " (Nota: " << notas.back() << ")\n";
    
    // Promedio usando un ciclo for
    float suma = 0;
    for (int i = 0; i < notas.size(); i++) {
        suma += notas[i];
    }
    
    float promedio = suma / notas.size();
    cout << "- Promedio del curso: " << promedio << "\n";
}
 
// ==========================================
// MENÚ PRINCIPAL
// ==========================================
int main() {
    vector<string> nombres;
    vector<float> notas;
    int opcion;
 
    do {
        cout << "\n--- MENU CRUD ---\n";
        cout << "1. Agregar persona\n";
        cout << "2. Ver lista\n";
        cout << "3. Modificar nota\n";
        cout << "4. Eliminar persona\n";
        cout << "5. Ver reportes\n";
        cout << "6. Salir\n";
        cout << "Opcion: ";
        cin >> opcion;
 
        if (opcion == 1) {
            crear(nombres, notas);
        } else if (opcion == 2) {
            leer(nombres, notas);
        } else if (opcion == 3) {
            actualizar(notas);
        } else if (opcion == 4) {
            eliminar(nombres, notas);
        } else if (opcion == 5) {
            reportes(nombres, notas);
        } else if (opcion != 6) {
            cout << "-> Opcion no valida.\n";
        }
 
    } while (opcion != 6);
 
    return 0;
}

Explicación Paso a Paso: Anatomía de cada Función

Paso 1 · Operación CREATE (Crear)void crear(vector<string>& nombres, vector<float>& notas)

Esta función solicita al usuario el nombre del alumno y su calificación por consola con cin, y los añade al final de sus respectivos vectores mediante .push_back().

Entrada por Consola:cin >> nombre; cin >> nota;

Inserción al final:nombres.push_back(nombre); notas.push_back(nota);

Paso 2 · Operación READ (Leer / Listar)void leer(vector<string>& nombres, vector<float>& notas)

Recorre los vectores mediante un ciclo for desde i = 0 hasta nombres.size() - 1, imprimiendo en pantalla el número de índice [i], el nombre y la nota asociada.

for (int i = 0; i < nombres.size(); i++) { cout << "[" << i << "] " << nombres[i] << " | Nota: " << notas[i]; }

Paso 3 · Operación UPDATE (Actualizar)void actualizar(vector<float>& notas)

Permite modificar la calificación de un estudiante existente indicando su posición numérica. Incorpora una validación de rango defensiva (indice >= 0 && indice < notas.size()) para evitar accesos a posiciones de memoria inválidas que harían caer el programa (segmentation fault).

Reasignación directa:cin >> notas[indice];

Paso 4 · Operación DELETE (Eliminar)void eliminar(vector<string>& nombres, vector<float>& notas)

Elimina al estudiante y su calificación usando iteradores con el método .erase(). Como los arreglos son paralelos, se ejecuta:

nombres.erase(nombres.begin() + indice);
notas.erase(notas.begin() + indice);

Paso 5 · REPORTES Y ESTADÍSTICASvoid reportes(vector<string>& nombres, vector<float>& notas)

Calcula estadísticas útiles del curso aplicando métodos nativos de std::vector y un acumulador:

nombres.empty(): Evita divisiones por cero comprobando si hay registros.
nombres.size(): Retorna la cantidad total de alumnos matriculados.
nombres.front() y notas.front(): Obtiene el primer registro ingresado.
nombres.back() y notas.back(): Obtiene el último registro ingresado.
Cálculo del promedio: Acumula las notas en una variablesuma dentro de un ciclo for y divide por notas.size().

Paso 6 · MENÚ PRINCIPAL Y BUCLE DE CONTROLint main()

La función main() es el punto de entrada que orquesta todo el sistema:

Vectores Maestros: Declara vector<string> nombres; y vector<float> notas; en su memoria local.
Bucle do-while: Garantiza que el menú se dibuje en pantalla al menos una vez y siga corriendo en ciclo continuo hasta que el usuario elija opcion == 6 (Salir).
Despacho de Funciones: Mediante if-else if, llama a la función correspondiente pasando los vectores por referencia (crear(nombres, notas), etc.).
Control de Errores: Si el usuario ingresa un número fuera de rango (ej. 9 o -1), ejecuta else if (opcion != 6) { cout << "-> Opcion no valida.\n"; }.

do { ... cin >> opcion; if (opcion == 1) { crear(nombres, notas); } ... } while (opcion != 6);

🧪 Laboratorio Interactivo

Simulador de Consola y Memoria en Vivo

🕹️ Elige una acción del Menú (main):

// Salida de Terminal (cout):

Bienvenido al Simulador del Sistema CRUD de Estudiantes en C++.

Selecciona una opción arriba para ejecutar las funciones.

🧠 Estado en Memoria RAM (std::vector)

Total: 0 elementos

Índice [i]	vector<string> nombres	vector<float> notas	Dirección Relativa
(Vectores vacíos. Utiliza "1. Crear" o "Cargar Demo" para añadir registros).

Primer Alumno--

Último Alumno--

Promedio Curso--

Cuestionario de Evaluación: Pon a prueba lo aprendido

🧠 TEST DE AUTOEVALUACIÓN

¿Listo para validar tu comprensión técnica?

Responde 5 preguntas clave sobre paso por referencia (&), sincronización de índices paralelos y métodos esenciales de std::vector en una interfaz interactiva tipo examen.

10 Casos Prácticos Tipo Prueba: Vectores Paralelos & CRUD

Escenarios reales de examen universitario y técnico para ejercitar el modelado en memoria con funciones independientes.

🎮

¿Quieres resolver estos 10 casos en C++, Python, Java, C#, JS, PHP y PSeInt?

Disponible en la Zona Gamer con clave de revisión docente: 05092026 (o fecha actual DDMMAAAA)

Ir al Módulo Gamer→

1Herrería & Tienda RPG: Sistema CRUD y Catálogo de Armas

Arsenal RPG

Enunciado: Crear un sistema de consola con Menú interactivo (1-7) que gestione armas legendarias y sus valores en monedas de oro en vectores paralelos. Debe permitir: 1) Guardar arma nueva, 2) Listar catálogo completo con índices, 3) Buscar arma por nombre, 4) Actualizar precio en oro por índice con validación de límites, 5) Eliminar arma de ambos vectores a la vez, 6) Reporte estadístico (arma más costosa y promedio de oro), y 7) Salir.

Vectores: vector<string> armas | vector<float> precios

Operaciones: menu(), guardarArma(), listarArmas(), buscarArma(), actualizarPrecio(), eliminarArma(), reportes()

▶ Ver Solución C++ sugerida

caso1_herreria_rpg.cpp

CPP

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
// 1. Guardar / Crear
void guardarArma(vector<string>& armas, vector<float>& precios) {
    string nom; float pre;
    cout << "Nombre de arma a forjar: "; cin >> nom;
    cout << "Precio en monedas de oro: "; cin >> pre;
    armas.push_back(nom);
    precios.push_back(pre);
    cout << "-> ⚔️ Arma guardada con exito en el catalogo.\n";
}
 
// 2. Listar
void listarArmas(const vector<string>& armas, const vector<float>& precios) {
    cout << "\n=== 🛡️ ARSENAL Y TIENDA RPG ===\n";
    if (armas.empty()) {
        cout << "(Catalogo vacio. Forja tu primera arma).\n";
        return;
    }
    for (size_t i = 0; i < armas.size(); i++) {
        cout << "[" << i << "] " << armas[i] << " - " << precios[i] << " Monedas de Oro\n";
    }
}
 
// 3. Buscar
int buscarArma(const vector<string>& armas, const string& buscada) {
    for (size_t i = 0; i < armas.size(); i++) {
        if (armas[i] == buscada) {
            return (int)i;
        }
    }
    return -1;
}
 
// 4. Actualizar
void actualizarPrecio(vector<float>& precios) {
    int idx; float nuevoPre;
    cout << "Indice de arma a modificar: "; cin >> idx;
    if (idx >= 0 && idx < (int)precios.size()) {
        cout << "Nuevo valor en oro: "; cin >> nuevoPre;
        precios[idx] = nuevoPre;
        cout << "-> 💰 Precio actualizado.\n";
    } else {
        cout << "-> ❌ Indice fuera de rango.\n";
    }
}
 
// 5. Eliminar
void eliminarArma(vector<string>& armas, vector<float>& precios) {
    int idx;
    cout << "Indice de arma a desmantelar: "; cin >> idx;
    if (idx >= 0 && idx < (int)armas.size()) {
        armas.erase(armas.begin() + idx);
        precios.erase(precios.begin() + idx);
        cout << "-> 💥 Arma desmantelada de ambos vectores.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 6. Reportes
void reporteEstadisticas(const vector<string>& armas, const vector<float>& precios) {
    cout << "\n📊 === REPORTES DE LA HERRERIA ===\n";
    if (armas.empty()) {
        cout << "(Sin datos para reportes).\n";
        return;
    }
    float suma = 0; int maxIdx = 0;
    for (size_t i = 0; i < precios.size(); i++) {
        suma += precios[i];
        if (precios[i] > precios[maxIdx]) {
            maxIdx = (int)i;
        }
    }
    cout << "Total valor del arsenal: " << suma << " Oro\n";
    cout << "Precio promedio: " << (suma / precios.size()) << " Oro\n";
    cout << "👑 Arma Legendaria mas cara: " << armas[maxIdx] << " (" << precios[maxIdx] << " Oro)\n";
}
 
int main() {
    vector<string> armas = {"Espada Runica", "Arco Elfico", "Daga Sombria"};
    vector<float> precios = {250.0f, 180.5f, 95.0f};
    int opcion = 0;
 
    do {
        cout << "\n=================================\n";
        cout << "  HERRERIA & TIENDA RPG (CRUD)   \n";
        cout << "=================================\n";
        cout << "1. Guardar / Forjar Arma\n";
        cout << "2. Listar Arsenal Completo\n";
        cout << "3. Buscar Arma por Nombre\n";
        cout << "4. Actualizar Precio en Oro\n";
        cout << "5. Eliminar / Desmantelar Arma\n";
        cout << "6. Reportes y Estadisticas\n";
        cout << "7. Salir\n";
        cout << "Seleccione una opcion (1-7): "; cin >> opcion;
 
        if (opcion == 1) {
            guardarArma(armas, precios);
        } else if (opcion == 2) {
            listarArmas(armas, precios);
        } else if (opcion == 3) {
            string buscada;
            cout << "Ingrese nombre a buscar: "; cin >> buscada;
            int pos = buscarArma(armas, buscada);
            if (pos != -1) {
                cout << "-> 🔍 Encontrada en posicion [" << pos << "] - Precio: " << precios[pos] << " Oro\n";
            } else {
                cout << "-> ❌ Arma no encontrada en la tienda.\n";
            }
        } else if (opcion == 4) {
            actualizarPrecio(precios);
        } else if (opcion == 5) {
            eliminarArma(armas, precios);
        } else if (opcion == 6) {
            reporteEstadisticas(armas, precios);
        } else if (opcion != 7) {
            cout << "-> ⚠️ Opcion no valida.\n";
        }
    } while (opcion != 7);
 
    cout << "-> Programa finalizado. ¡Hasta pronto, aventurero!\n";
    return 0;
}

2Raid Boss & Squad: Gestión de Escuadrón, Salud y Triaje Crítico

Salud Squad

Enunciado: Administrar en la consola del Healer los nombres de héroes y salud HP (%) en vectores paralelos mediante un Menú interactivo. Debe permitir: 1) Guardar/Reclutar héroe con su HP inicial, 2) Listar escuadrón completo, 3) Buscar héroe por nombre, 4) Actualizar HP tras daño o curación, 5) Eliminar combatiente caído, 6) Reporte de Triaje Crítico (filtro de héroes con HP < 30.0% y héroe con mayor vida), y 7) Salir.

Vectores: vector<string> heroes | vector<float> hpActual

Operaciones: menu(), guardarHeroe(), listarSquad(), buscarHeroe(), actualizarHP(), eliminarHeroe(), reporteTriaje()

▶ Ver Solución C++ sugerida

caso2_salud_squad.cpp

CPP

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
// 1. Guardar / Crear
void guardarHeroe(vector<string>& heroes, vector<float>& hp) {
    string nom; float salud;
    cout << "Nombre del heroe: "; cin >> nom;
    cout << "Salud inicial (0-100%): "; cin >> salud;
    heroes.push_back(nom);
    hp.push_back(salud);
    cout << "-> 🛡️ Heroe reclutado en la party.\n";
}
 
// 2. Listar
void listarSquad(const vector<string>& heroes, const vector<float>& hp) {
    cout << "\n=== ⚔️ ESCUADRON RAID BOSS ===\n";
    if (heroes.empty()) {
        cout << "(El escuadron no tiene combatientes activos).\n";
        return;
    }
    for (size_t i = 0; i < heroes.size(); i++) {
        cout << "[" << i << "] " << heroes[i] << " - Salud: " << hp[i] << "% HP\n";
    }
}
 
// 3. Buscar
int buscarHeroe(const vector<string>& heroes, const string& target) {
    for (size_t i = 0; i < heroes.size(); i++) {
        if (heroes[i] == target) {
            return (int)i;
        }
    }
    return -1;
}
 
// 4. Actualizar
void actualizarHP(vector<float>& hp) {
    int idx; float nuevoHP;
    cout << "Indice de heroe a actualizar salud: "; cin >> idx;
    if (idx >= 0 && idx < (int)hp.size()) {
        cout << "Nuevo % de HP: "; cin >> nuevoHP;
        hp[idx] = nuevoHP;
        cout << "-> 🩸 Salud actualizada.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 5. Eliminar
void eliminarHeroe(vector<string>& heroes, vector<float>& hp) {
    int idx;
    cout << "Indice de heroe caido a retirar: "; cin >> idx;
    if (idx >= 0 && idx < (int)heroes.size()) {
        cout << "⚰️ " << heroes[idx] << " ha sido retirado del squad.\n";
        heroes.erase(heroes.begin() + idx);
        hp.erase(hp.begin() + idx);
        cout << "-> ✨ Escuadron reorganizado.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 6. Reportes
void reporteTriajeCritico(const vector<string>& heroes, const vector<float>& hp) {
    cout << "\n🚨 === REPORTE DE TRIAJE CRITICO (HP < 30%) ===\n";
    if (heroes.empty()) {
        cout << "(Sin miembros registrados).\n";
        return;
    }
    int criticos = 0; int maxIdx = 0;
    for (size_t i = 0; i < heroes.size(); i++) {
        if (hp[i] < 30.0f) {
            cout << "- 🩸 ¡ALERTA! " << heroes[i] << " (" << hp[i] << "% HP) ¡Curacion urgente!\n";
            criticos++;
        }
        if (hp[i] > hp[maxIdx]) {
            maxIdx = (int)i;
        }
    }
    if (criticos == 0) {
        cout << "-> ✅ Todos los miembros tienen salud estable (> 30%).\n";
    }
    cout << "🛡️ Heroe con mayor salud: " << heroes[maxIdx] << " (" << hp[maxIdx] << "% HP)\n";
}
 
int main() {
    vector<string> heroes = {"Arthur", "Freya", "Loki"};
    vector<float> hp = {85.0f, 22.5f, 14.0f};
    int opcion = 0;
 
    do {
        cout << "\n=================================\n";
        cout << "    SQUAD RAID BOSS (CRUD)       \n";
        cout << "=================================\n";
        cout << "1. Reclutar / Guardar Heroe\n";
        cout << "2. Listar Escuadron Completo\n";
        cout << "3. Buscar Heroe por Nombre\n";
        cout << "4. Actualizar Salud (HP %)\n";
        cout << "5. Eliminar Heroe Caido\n";
        cout << "6. Reporte de Triaje Critico\n";
        cout << "7. Salir\n";
        cout << "Seleccione una opcion (1-7): "; cin >> opcion;
 
        if (opcion == 1) {
            guardarHeroe(heroes, hp);
        } else if (opcion == 2) {
            listarSquad(heroes, hp);
        } else if (opcion == 3) {
            string buscado;
            cout << "Nombre del heroe a buscar: "; cin >> buscado;
            int pos = buscarHeroe(heroes, buscado);
            if (pos != -1) {
                cout << "-> 🔍 Encontrado en posicion [" << pos << "] con " << hp[pos] << "% HP\n";
            } else {
                cout << "-> ❌ Heroe no encontrado en el squad.\n";
            }
        } else if (opcion == 4) {
            actualizarHP(hp);
        } else if (opcion == 5) {
            eliminarHeroe(heroes, hp);
        } else if (opcion == 6) {
            reporteTriajeCritico(heroes, hp);
        } else if (opcion != 7) {
            cout << "-> ⚠️ Opcion no valida.\n";
        }
    } while (opcion != 7);
 
    cout << "-> Sistema de escuadron cerrado.\n";
    return 0;
}

3Gremio / Clan MMORPG: Registro de Miembros, DPS y Auditoría MVP

Métricas Raid

Enunciado: Diseñar el software administrativo de un Clan MMORPG en consola con Menú principal y vectores de Gamertags y puntos de daño DPS. Debe permitir: 1) Guardar nuevo jugador con su DPS, 2) Listar clan completo, 3) Buscar miembro por Gamertag, 4) Actualizar DPS tras equipar ítems, 5) Eliminar miembro expulsado, 6) Reportes Estadísticos (DPS total acumulado, promedio del clan y Jugador MVP con mayor daño), y 7) Salir.

Vectores: vector<string> miembros | vector<float> dpsPuntos

Operaciones: menu(), guardarMiembro(), listarClan(), buscarMiembro(), actualizarDPS(), eliminarMiembro(), reportesMVP()

▶ Ver Solución C++ sugerida

caso3_dps_clan.cpp

CPP

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
// 1. Guardar / Crear
void guardarMiembro(vector<string>& clan, vector<float>& dps) {
    string tag; float d;
    cout << "Gamertag del miembro: "; cin >> tag;
    cout << "DPS de combate: "; cin >> d;
    clan.push_back(tag);
    dps.push_back(d);
    cout << "-> 👑 Miembro reclutado en el clan.\n";
}
 
// 2. Listar
void listarClan(const vector<string>& clan, const vector<float>& dps) {
    cout << "\n=== 🛡️ MIEMBROS DEL CLAN Y DPS ===\n";
    if (clan.empty()) {
        cout << "(Clan sin miembros registrados).\n";
        return;
    }
    for (size_t i = 0; i < clan.size(); i++) {
        cout << "[" << i << "] " << clan[i] << " - " << dps[i] << " DPS\n";
    }
}
 
// 3. Buscar
int buscarMiembro(const vector<string>& clan, const string& tag) {
    for (size_t i = 0; i < clan.size(); i++) {
        if (clan[i] == tag) {
            return (int)i;
        }
    }
    return -1;
}
 
// 4. Actualizar
void actualizarDPS(vector<float>& dps) {
    int idx; float nuevoDPS;
    cout << "Indice a actualizar: "; cin >> idx;
    if (idx >= 0 && idx < (int)dps.size()) {
        cout << "Nuevo DPS: "; cin >> nuevoDPS;
        dps[idx] = nuevoDPS;
        cout << "-> 💥 DPS actualizado.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 5. Eliminar
void eliminarMiembro(vector<string>& clan, vector<float>& dps) {
    int idx;
    cout << "Indice a expulsar: "; cin >> idx;
    if (idx >= 0 && idx < (int)clan.size()) {
        cout << "❌ " << clan[idx] << " expulsado del clan.\n";
        clan.erase(clan.begin() + idx);
        dps.erase(dps.begin() + idx);
        cout << "-> ✨ Lista de clan actualizada.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 6. Reportes
void reportesDPS_MVP(const vector<string>& clan, const vector<float>& dps) {
    cout << "\n📊 === ESTADISTICAS Y AUDITORIA DPS ===\n";
    if (clan.empty()) {
        cout << "(Sin datos para reportes).\n";
        return;
    }
    float total = 0; int maxIdx = 0;
    for (size_t i = 0; i < dps.size(); i++) {
        total += dps[i];
        if (dps[i] > dps[maxIdx]) {
            maxIdx = (int)i;
        }
    }
    cout << "💥 DPS Total del Clan: " << total << "\n";
    cout << "📈 DPS Promedio: " << (total / dps.size()) << "\n";
    cout << "👑 MVP del Clan: " << clan[maxIdx] << " (" << dps[maxIdx] << " DPS)\n";
}
 
int main() {
    vector<string> clan = {"Valkyrie", "ShadowSniper", "Berserker"};
    vector<float> dps = {14200.0f, 18950.0f, 11500.0f};
    int opcion = 0;
 
    do {
        cout << "\n=================================\n";
        cout << "    GREMIO / CLAN MMORPG (CRUD)  \n";
        cout << "=================================\n";
        cout << "1. Reclutar / Guardar Miembro\n";
        cout << "2. Listar Clan y DPS\n";
        cout << "3. Buscar Miembro por Gamertag\n";
        cout << "4. Actualizar DPS\n";
        cout << "5. Expulsar / Eliminar Miembro\n";
        cout << "6. Reportes DPS y MVP\n";
        cout << "7. Salir\n";
        cout << "Seleccione una opcion (1-7): "; cin >> opcion;
 
        if (opcion == 1) {
            guardarMiembro(clan, dps);
        } else if (opcion == 2) {
            listarClan(clan, dps);
        } else if (opcion == 3) {
            string tag;
            cout << "Gamertag a buscar: "; cin >> tag;
            int pos = buscarMiembro(clan, tag);
            if (pos != -1) {
                cout << "-> 🔍 Miembro encontrado en posicion [" << pos << "] con " << dps[pos] << " DPS\n";
            } else {
                cout << "-> ❌ Miembro no encontrado.\n";
            }
        } else if (opcion == 4) {
            actualizarDPS(dps);
        } else if (opcion == 5) {
            eliminarMiembro(clan, dps);
        } else if (opcion == 6) {
            reportesDPS_MVP(clan, dps);
        } else if (opcion != 7) {
            cout << "-> ⚠️ Opcion no valida.\n";
        }
    } while (opcion != 7);
 
    cout << "-> Sistema de clan cerrado.\n";
    return 0;
}

4Hangar Sci-Fi: Control de Bahías, Naves y Asignación de Pilotos

Búsqueda Hangar

Enunciado: Crear el sistema del Hangar espacial con Menú interactivo y dos vectores paralelos: matrículas/IDs de naves y pilotos asignados. Debe permitir: 1) Guardar nave y piloto en una nueva bahía, 2) Listar estado general de todas las bahías, 3) Buscar nave por matrícula retornando la bahía y comandante, 4) Actualizar/Reasignar piloto, 5) Eliminar nave despegada, 6) Reportes de ocupación (total bahías activas), y 7) Salir.

Vectores: vector<string> matriculas | vector<string> pilotos

Operaciones: menu(), guardarNave(), listarHangar(), buscarNave(), actualizarPiloto(), eliminarNave(), reportes()

▶ Ver Solución C++ sugerida

caso4_hangar_scifi.cpp

CPP

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
// 1. Guardar / Crear
void guardarNave(vector<string>& mat, vector<string>& pil) {
    string m, p;
    cout << "Matricula de nave: "; cin >> m;
    cout << "Piloto comandante: "; cin >> p;
    mat.push_back(m);
    pil.push_back(p);
    cout << "-> 🚀 Nave acoplada en la bahia [" << mat.size() - 1 << "].\n";
}
 
// 2. Listar
void listarHangar(const vector<string>& mat, const vector<string>& pil) {
    cout << "\n=== 🚀 HANGAR DE NAVES ESTELARES ===\n";
    if (mat.empty()) {
        cout << "(Hangar vacio. Ninguna nave acoplada).\n";
        return;
    }
    for (size_t i = 0; i < mat.size(); i++) {
        cout << "[Bahia " << i << "] Matricula: " << mat[i] << " | Piloto: " << pil[i] << "\n";
    }
}
 
// 3. Buscar
int buscarNave(const vector<string>& mat, const string& buscada) {
    for (size_t i = 0; i < mat.size(); i++) {
        if (mat[i] == buscada) {
            return (int)i;
        }
    }
    return -1;
}
 
// 4. Actualizar
void actualizarPiloto(vector<string>& pil) {
    int idx; string nuevoPil;
    cout << "Indice de bahia a reasignar piloto: "; cin >> idx;
    if (idx >= 0 && idx < (int)pil.size()) {
        cout << "Nuevo piloto asignado: "; cin >> nuevoPil;
        pil[idx] = nuevoPil;
        cout << "-> 👨‍🚀 Piloto reasignado con exito.\n";
    } else {
        cout << "-> ❌ Bahía invalida.\n";
    }
}
 
// 5. Eliminar
void eliminarNave(vector<string>& mat, vector<string>& pil) {
    int idx;
    cout << "Indice de bahia a autorizar despegue: "; cin >> idx;
    if (idx >= 0 && idx < (int)mat.size()) {
        cout << "🚀 Nave " << mat[idx] << " despegando. Bahia liberada.\n";
        mat.erase(mat.begin() + idx);
        pil.erase(pil.begin() + idx);
        cout << "-> ✨ Registro de bahia actualizado.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 6. Reportes
void reportesOcupacion(const vector<string>& mat, const vector<string>& pil) {
    cout << "\n📊 === REPORTE DE OCUPACION DEL HANGAR ===\n";
    cout << "Total naves acopladas: " << mat.size() << "\n";
    if (!mat.empty()) {
        cout << "Primera nave acoplada: " << mat.front() << " (Piloto: " << pil.front() << ")\n";
        cout << "Ultima nave acoplada: " << mat.back() << " (Piloto: " << pil.back() << ")\n";
    }
}
 
int main() {
    vector<string> mat = {"NX-01", "X-WING-7", "MILLENNIUM"};
    vector<string> pil = {"Archer", "Luke", "Han Solo"};
    int opcion = 0;
 
    do {
        cout << "\n=================================\n";
        cout << "    HANGAR ESPACIAL SCI-FI (CRUD) \n";
        cout << "=================================\n";
        cout << "1. Guardar / Acoplar Nave\n";
        cout << "2. Listar Bahias del Hangar\n";
        cout << "3. Buscar Nave por Matricula\n";
        cout << "4. Reasignar / Actualizar Piloto\n";
        cout << "5. Despegar / Eliminar Nave\n";
        cout << "6. Reporte de Ocupacion\n";
        cout << "7. Salir\n";
        cout << "Seleccione una opcion (1-7): "; cin >> opcion;
 
        if (opcion == 1) {
            guardarNave(mat, pil);
        } else if (opcion == 2) {
            listarHangar(mat, pil);
        } else if (opcion == 3) {
            string buscada;
            cout << "Matricula a buscar: "; cin >> buscada;
            int pos = buscarNave(mat, buscada);
            if (pos != -1) {
                cout << "-> 🔍 Localizada en Bahia [" << pos << "] | Piloto: " << pil[pos] << "\n";
            } else {
                cout << "-> ❌ Nave no encontrada en el hangar.\n";
            }
        } else if (opcion == 4) {
            actualizarPiloto(pil);
        } else if (opcion == 5) {
            eliminarNave(mat, pil);
        } else if (opcion == 6) {
            reportesOcupacion(mat, pil);
        } else if (opcion != 7) {
            cout << "-> ⚠️ Opcion no valida.\n";
        }
    } while (opcion != 7);
 
    cout << "-> Sistema de hangar cerrado.\n";
    return 0;
}

5Alquimia & Forja Rúnica: Almacén de Ingredientes, Crafteo y Stock

Crafteo

Enunciado: Administrar el laboratorio alquímico con Menú de consola y dos vectores: materiales mágicos y stock disponible. Debe permitir: 1) Guardar nuevo ingrediente descubierto, 2) Listar todos los reactivos y unidades, 3) Buscar material por nombre, 4) Actualizar/Consumir stock por crafteo (descuenta 1 unidad si stock > 0), 5) Eliminar material de la bolsa, 6) Reportes de recursos agotados (stock == 0) y total de materiales, y 7) Salir.

Vectores: vector<string> materiales | vector<int> stock

Operaciones: menu(), guardarMaterial(), listarAlquimia(), buscarMaterial(), actualizarStock(), eliminarMaterial(), reporteAgotados()

▶ Ver Solución C++ sugerida

caso5_crafteo_alquimia.cpp

CPP

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
// 1. Guardar / Crear
void guardarMaterial(vector<string>& mats, vector<int>& stock) {
    string m; int cant;
    cout << "Nombre del material: "; cin >> m;
    cout << "Unidades iniciales: "; cin >> cant;
    mats.push_back(m);
    stock.push_back(cant);
    cout << "-> ✨ Ingrediente guardado en la bolsa de alquimia.\n";
}
 
// 2. Listar
void listarAlquimia(const vector<string>& mats, const vector<int>& stock) {
    cout << "\n=== 🧪 LABORATORIO DE ALQUIMIA & CRAFTEO ===\n";
    if (mats.empty()) {
        cout << "(Bolsa de alquimia vacia).\n";
        return;
    }
    for (size_t i = 0; i < mats.size(); i++) {
        cout << "[" << i << "] " << mats[i] << " - Stock: " << stock[i] << " unidades\n";
    }
}
 
// 3. Buscar
int buscarMaterial(const vector<string>& mats, const string& buscado) {
    for (size_t i = 0; i < mats.size(); i++) {
        if (mats[i] == buscado) {
            return (int)i;
        }
    }
    return -1;
}
 
// 4. Actualizar
void actualizarStock(vector<int>& stock) {
    int idx; int nuevaCant;
    cout << "Indice de material a modificar: "; cin >> idx;
    if (idx >= 0 && idx < (int)stock.size()) {
        cout << "Nuevo stock disponible: "; cin >> nuevaCant;
        stock[idx] = nuevaCant;
        cout << "-> 📦 Stock actualizado.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 5. Eliminar
void eliminarMaterial(vector<string>& mats, vector<int>& stock) {
    int idx;
    cout << "Indice a eliminar del laboratorio: "; cin >> idx;
    if (idx >= 0 && idx < (int)mats.size()) {
        cout << "🗑️ " << mats[idx] << " descartado de la bolsa.\n";
        mats.erase(mats.begin() + idx);
        stock.erase(stock.begin() + idx);
        cout << "-> ✨ Bolsa reorganizada.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 6. Reportes y Crafteo
void craftearItem(vector<string>& mats, vector<int>& stock) {
    string buscado;
    cout << "Material a consumir en la pocion/crafteo: "; cin >> buscado;
    int pos = buscarMaterial(mats, buscado);
    if (pos != -1) {
        if (stock[pos] > 0) {
            stock[pos]--;
            cout << "-> 🔮 ¡Crafteo exitoso! Se uso 1x " << mats[pos] << ". Quedan: " << stock[pos] << " u.\n";
        } else {
            cout << "-> ⚠️ Sin stock suficiente de " << mats[pos] << " para crafteo.\n";
        }
    } else {
        cout << "-> ❌ Material no encontrado en el laboratorio.\n";
    }
}
 
int main() {
    vector<string> mats = {"Mithril", "Polvo_Hada", "Escama_Dragon"};
    vector<int> stk = {3, 0, 5};
    int opcion = 0;
 
    do {
        cout << "\n=================================\n";
        cout << "  ALQUIMIA & CRAFTEO RPG (CRUD)  \n";
        cout << "=================================\n";
        cout << "1. Guardar / Recoger Material\n";
        cout << "2. Listar Bolsa de Alquimia\n";
        cout << "3. Buscar Material por Nombre\n";
        cout << "4. Actualizar Stock Manual\n";
        cout << "5. Descartar / Eliminar Material\n";
        cout << "6. Craftear Pocion (Consumir Stock)\n";
        cout << "7. Salir\n";
        cout << "Seleccione una opcion (1-7): "; cin >> opcion;
 
        if (opcion == 1) {
            guardarMaterial(mats, stk);
        } else if (opcion == 2) {
            listarAlquimia(mats, stk);
        } else if (opcion == 3) {
            string buscado;
            cout << "Material a buscar: "; cin >> buscado;
            int pos = buscarMaterial(mats, buscado);
            if (pos != -1) {
                cout << "-> 🔍 Encontrado en posicion [" << pos << "] | Stock: " << stk[pos] << " u.\n";
            } else {
                cout << "-> ❌ Ingrediente no encontrado.\n";
            }
        } else if (opcion == 4) {
            actualizarStock(stk);
        } else if (opcion == 5) {
            eliminarMaterial(mats, stk);
        } else if (opcion == 6) {
            craftearItem(mats, stk);
        } else if (opcion != 7) {
            cout << "-> ⚠️ Opcion no valida.\n";
        }
    } while (opcion != 7);
 
    cout << "-> Laboratorio de alquimia cerrado.\n";
    return 0;
}

6Torneo Arcade Global: Leaderboard, Clasificación y Tabla de Récords

Leaderboard

Enunciado: Desarrollar el leaderboard arcade en consola con Menú de opciones y vectores de Gamertags y puntajes. Debe permitir: 1) Guardar nuevo récord de jugador, 2) Listar la tabla de competidores, 3) Buscar jugador por Gamertag, 4) Actualizar score si supera su marca personal, 5) Eliminar jugador descalificado, 6) Reportes de Clasificación (algoritmo de ordenamiento burbuja descendente sincronizado y puntaje máximo del torneo), y 7) Salir.

Vectores: vector<string> gamertags | vector<int> puntajes

Operaciones: menu(), guardarPartida(), listarRanking(), buscarJugador(), actualizarScore(), eliminarJugador(), ordenarTopScores()

▶ Ver Solución C++ sugerida

caso6_ranking_arcade.cpp

CPP

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
 
// 1. Guardar / Crear
void guardarPartida(vector<string>& tags, vector<int>& scores) {
    string t; int s;
    cout << "Gamertag del jugador: "; cin >> t;
    cout << "Puntaje alcanzado: "; cin >> s;
    tags.push_back(t);
    scores.push_back(s);
    cout << "-> 🕹️ Record guardado en la maquina arcade.\n";
}
 
// 2. Listar
void listarRanking(const vector<string>& tags, const vector<int>& scores) {
    cout << "\n=== 🏆 TABLA DE CLASIFICACION ARCADE ===\n";
    if (tags.empty()) {
        cout << "(Sin records registrados en la maquina).\n";
        return;
    }
    for (size_t i = 0; i < tags.size(); i++) {
        cout << "#" << (i + 1) << " " << tags[i] << " - " << scores[i] << " PTS\n";
    }
}
 
// 3. Buscar
int buscarJugador(const vector<string>& tags, const string& target) {
    for (size_t i = 0; i < tags.size(); i++) {
        if (tags[i] == target) {
            return (int)i;
        }
    }
    return -1;
}
 
// 4. Actualizar
void actualizarPuntaje(vector<int>& scores) {
    int idx; int nuevoScore;
    cout << "Indice de jugador a actualizar score: "; cin >> idx;
    if (idx >= 0 && idx < (int)scores.size()) {
        cout << "Nuevo puntaje: "; cin >> nuevoScore;
        scores[idx] = nuevoScore;
        cout << "-> 🌟 Score actualizado con exito.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 5. Eliminar
void eliminarJugador(vector<string>& tags, vector<int>& scores) {
    int idx;
    cout << "Indice de jugador descalificado a retirar: "; cin >> idx;
    if (idx >= 0 && idx < (int)tags.size()) {
        cout << "❌ " << tags[idx] << " retirado del torneo.\n";
        tags.erase(tags.begin() + idx);
        scores.erase(scores.begin() + idx);
        cout << "-> ✨ Tabla reorganizada.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 6. Ordenar y Reportes
void ordenarRanking(vector<string>& tags, vector<int>& scores) {
    if (scores.empty()) {
        cout << "(Sin partidas para ordenar).\n";
        return;
    }
    for (size_t i = 0; i < scores.size(); i++) {
        for (size_t j = 0; j + 1 < scores.size() - i; j++) {
            if (scores[j] < scores[j + 1]) {
                swap(scores[j], scores[j + 1]);
                swap(tags[j], tags[j + 1]); // Sincronia de memoria paralela
            }
        }
    }
    cout << "-> 👑 Leaderboard ordenado de mayor a menor.\n";
    cout << "🏆 Campeon del Torneo: " << tags[0] << " con " << scores[0] << " PTS\n";
}
 
int main() {
    vector<string> tags = {"Viper_99", "NeonKnight", "CyberGhost"};
    vector<int> scores = {4500, 6200, 9950};
    int opcion = 0;
 
    do {
        cout << "\n=================================\n";
        cout << "  TORNEO ARCADE GLOBAL (CRUD)    \n";
        cout << "=================================\n";
        cout << "1. Guardar / Registrar Partida\n";
        cout << "2. Listar Leaderboard Actual\n";
        cout << "3. Buscar Jugador por Gamertag\n";
        cout << "4. Actualizar Puntaje por Indice\n";
        cout << "5. Descalificar / Eliminar Jugador\n";
        cout << "6. Ordenar Leaderboard y Ver MVP\n";
        cout << "7. Salir\n";
        cout << "Seleccione una opcion (1-7): "; cin >> opcion;
 
        if (opcion == 1) {
            guardarPartida(tags, scores);
        } else if (opcion == 2) {
            listarRanking(tags, scores);
        } else if (opcion == 3) {
            string target;
            cout << "Gamertag a buscar: "; cin >> target;
            int pos = buscarJugador(tags, target);
            if (pos != -1) {
                cout << "-> 🔍 Jugador encontrado en posicion [" << pos << "] con " << scores[pos] << " PTS\n";
            } else {
                cout << "-> ❌ Gamertag no encontrado en el torneo.\n";
            }
        } else if (opcion == 4) {
            actualizarPuntaje(scores);
        } else if (opcion == 5) {
            eliminarJugador(tags, scores);
        } else if (opcion == 6) {
            ordenarRanking(tags, scores);
            listarRanking(tags, scores);
        } else if (opcion != 7) {
            cout << "-> ⚠️ Opcion no valida.\n";
        }
    } while (opcion != 7);
 
    cout << "-> Maquina arcade en reposo.\n";
    return 0;
}

7Dungeon Crawler MMORPG: Servidor de Mazmorras, Salas y Partidas

Dungeons 3V

Enunciado: Modelar un servidor de dungeons multijugador con Menú interactivo y tres vectores: número de sala, estado ("LIBRE" / "EN_COMBATE") y líder de party. Debe permitir: 1) Guardar nueva mazmorra habilitada, 2) Listar estado en tiempo real de todas las salas, 3) Buscar sala por número, 4) Actualizar estado y asignar party (Entrada a Mazmorra), 5) Eliminar sala dada de baja, 6) Reportes de servidor (% ocupación y parties activas), y 7) Salir.

Vectores: vector<int> salas | vector<string> estados | vector<string> lideresParty

Operaciones: menu(), guardarSala(), listarSalas(), buscarSala(), actualizarEstado(), eliminarSala(), reportes()

▶ Ver Solución C++ sugerida

caso7_dungeons_mmorpg.cpp

CPP

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
// 1. Guardar / Crear
void guardarSala(vector<int>& salas, vector<string>& estados, vector<string>& lideres) {
    int s;
    cout << "Numero de mazmorra a habilitar: "; cin >> s;
    salas.push_back(s);
    estados.push_back("LIBRE");
    lideres.push_back("-");
    cout << "-> 🏰 Mazmorra [" << s << "] habilitada en el servidor.\n";
}
 
// 2. Listar
void listarSalas(const vector<int>& salas, const vector<string>& estados, const vector<string>& lideres) {
    cout << "\n=== 🏰 SERVIDOR DE DUNGEONS & RAIDS ===\n";
    if (salas.empty()) {
        cout << "(Sin mazmorras activas en el servidor).\n";
        return;
    }
    for (size_t i = 0; i < salas.size(); i++) {
        cout << "[Sala " << salas[i] << "] Estado: " << estados[i] << " | Lider: " << lideres[i] << "\n";
    }
}
 
// 3. Buscar
int buscarSala(const vector<int>& salas, int numSala) {
    for (size_t i = 0; i < salas.size(); i++) {
        if (salas[i] == numSala) {
            return (int)i;
        }
    }
    return -1;
}
 
// 4. Actualizar / Entrar
void entrarSala(const vector<int>& salas, vector<string>& estados, vector<string>& lideres) {
    int s; string lid;
    cout << "Numero de sala a ingresar: "; cin >> s;
    int pos = buscarSala(salas, s);
    if (pos != -1) {
        if (estados[pos] == "LIBRE") {
            cout << "Nombre de lider / Clan de la Party: "; cin >> lid;
            estados[pos] = "EN_COMBATE";
            lideres[pos] = lid;
            cout << "-> ⚔️ ¡Combate iniciado en Sala " << s << "! Lider: " << lid << "\n";
        } else {
            cout << "-> ⚠️ La sala " << s << " ya esta ocupada en combate.\n";
        }
    } else {
        cout << "-> ❌ Numero de sala no existe.\n";
    }
}
 
// 5. Eliminar
void eliminarSala(vector<int>& salas, vector<string>& estados, vector<string>& lideres) {
    int idx;
    cout << "Indice de sala a retirar del servidor: "; cin >> idx;
    if (idx >= 0 && idx < (int)salas.size()) {
        cout << "💥 Mazmorra [" << salas[idx] << "] dada de baja.\n";
        salas.erase(salas.begin() + idx);
        estados.erase(estados.begin() + idx);
        lideres.erase(lideres.begin() + idx);
        cout << "-> ✨ Lista de salas actualizada.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 6. Reportes
void reporteSalas(const vector<int>& salas, const vector<string>& estados, const vector<string>& lideres) {
    cout << "\n📊 === REPORTE DE OCUPACION DE DUNGEONS ===\n";
    int libres = 0; int enCombate = 0;
    for (size_t i = 0; i < salas.size(); i++) {
        if (estados[i] == "LIBRE") {
            libres++;
        } else {
            enCombate++;
        }
    }
    cout << "Total Mazmorras: " << salas.size() << " | Libres: " << libres << " | En Combate: " << enCombate << "\n";
}
 
int main() {
    vector<int> salas = {101, 102, 103};
    vector<string> estados = {"LIBRE", "EN_COMBATE", "LIBRE"};
    vector<string> lideres = {"-", "LordVoldemort", "-"};
    int opcion = 0;
 
    do {
        cout << "\n=================================\n";
        cout << "  SERVIDOR DE MAZMORRAS (CRUD)   \n";
        cout << "=================================\n";
        cout << "1. Guardar / Habilitar Mazmorra\n";
        cout << "2. Listar Estado de Mazmorras\n";
        cout << "3. Buscar Mazmorra por Numero\n";
        cout << "4. Ingresar Party (Asignar Combate)\n";
        cout << "5. Eliminar / Dar de Baja Sala\n";
        cout << "6. Reporte de Ocupacion\n";
        cout << "7. Salir\n";
        cout << "Seleccione una opcion (1-7): "; cin >> opcion;
 
        if (opcion == 1) {
            guardarSala(salas, estados, lideres);
        } else if (opcion == 2) {
            listarSalas(salas, estados, lideres);
        } else if (opcion == 3) {
            int num;
            cout << "Numero de sala a buscar: "; cin >> num;
            int pos = buscarSala(salas, num);
            if (pos != -1) {
                cout << "-> 🔍 Localizada en indice [" << pos << "] | Estado: " << estados[pos] << " | Lider: " << lideres[pos] << "\n";
            } else {
                cout << "-> ❌ Sala no encontrada.\n";
            }
        } else if (opcion == 4) {
            entrarSala(salas, estados, lideres);
        } else if (opcion == 5) {
            eliminarSala(salas, estados, lideres);
        } else if (opcion == 6) {
            reporteSalas(salas, estados, lideres);
        } else if (opcion != 7) {
            cout << "-> ⚠️ Opcion no valida.\n";
        }
    } while (opcion != 7);
 
    cout << "-> Servidor de mazmorras desconectado.\n";
    return 0;
}

8Supervivencia Post-Apocalíptica: Mochila Táctica, Municiones y Alertas HUD

Alerta HUD

Enunciado: Diseñar la computadora de supervivencia táctica con Menú de opciones y dos vectores: suministros y unidades en inventario. Debe permitir: 1) Guardar nuevo recurso recolectado, 2) Listar inventario táctico completo, 3) Buscar suministro por nombre, 4) Actualizar unidades tras disparar o consumir raciones, 5) Eliminar ítem descartado, 6) Reportes de Alerta HUD (filtrar recursos con unidades < 5 y total de provisiones), y 7) Salir.

Vectores: vector<string> suministros | vector<int> cantidades

Operaciones: menu(), guardarRecurso(), listarMochila(), buscarRecurso(), actualizarUnidades(), eliminarRecurso(), reporteAlertasHUD()

▶ Ver Solución C++ sugerida

caso8_supervivencia_hud.cpp

CPP

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
// 1. Guardar / Crear
void guardarRecurso(vector<string>& sum, vector<int>& cant) {
    string r; int c;
    cout << "Nombre del suministro: "; cin >> r;
    cout << "Unidades encontradas: "; cin >> c;
    sum.push_back(r);
    cant.push_back(c);
    cout << "-> 🎒 Recurso guardado en la mochila tactica.\n";
}
 
// 2. Listar
void listarMochila(const vector<string>& sum, const vector<int>& cant) {
    cout << "\n=== 🎒 INVENTARIO TACTICO DE SUPERVIVENCIA ===\n";
    if (sum.empty()) {
        cout << "(Mochila vacia. Busca provisiones en la zona).\n";
        return;
    }
    for (size_t i = 0; i < sum.size(); i++) {
        cout << "[" << i << "] " << sum[i] << " - " << cant[i] << " unidades\n";
    }
}
 
// 3. Buscar
int buscarRecurso(const vector<string>& sum, const string& target) {
    for (size_t i = 0; i < sum.size(); i++) {
        if (sum[i] == target) {
            return (int)i;
        }
    }
    return -1;
}
 
// 4. Actualizar
void actualizarCantidad(vector<int>& cant) {
    int idx; int nuevaCant;
    cout << "Indice de suministro a modificar: "; cin >> idx;
    if (idx >= 0 && idx < (int)cant.size()) {
        cout << "Nueva cantidad disponible: "; cin >> nuevaCant;
        cant[idx] = nuevaCant;
        cout << "-> 📦 Cantidad actualizada.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 5. Eliminar
void eliminarRecurso(vector<string>& sum, vector<int>& cant) {
    int idx;
    cout << "Indice de item a descartar: "; cin >> idx;
    if (idx >= 0 && idx < (int)sum.size()) {
        cout << "🗑️ " << sum[idx] << " descartado de la mochila.\n";
        sum.erase(sum.begin() + idx);
        cant.erase(cant.begin() + idx);
        cout << "-> ✨ Espacio liberado en la mochila.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 6. Reportes y Alerta HUD
void alertaRecursosCriticos(const vector<string>& sum, const vector<int>& cant, int minVal) {
    cout << "\n⚠️ === ALERTA HUD: SUMINISTROS CRITICOS (< " << minVal << " u.) ===\n";
    int criticos = 0;
    for (size_t i = 0; i < sum.size(); i++) {
        if (cant[i] < minVal) {
            cout << "- 🔻 " << sum[i] << " (" << cant[i] << " unidades restantes ¡Peligro!)\n";
            criticos++;
        }
    }
    if (criticos == 0) {
        cout << "-> ✅ Todos los suministros estan sobre el nivel seguro.\n";
    }
}
 
int main() {
    vector<string> sum = {"Balas_5.56mm", "Botiquines", "Granadas_IEM"};
    vector<int> cant = {2, 14, 3};
    int opcion = 0;
 
    do {
        cout << "\n=================================\n";
        cout << "  MOCHILA DE SUPERVIVENCIA (CRUD)\n";
        cout << "=================================\n";
        cout << "1. Guardar / Recoger Suministro\n";
        cout << "2. Listar Mochila Tactica\n";
        cout << "3. Buscar Suministro por Nombre\n";
        cout << "4. Actualizar Cantidad por Indice\n";
        cout << "5. Descartar / Eliminar Item\n";
        cout << "6. Alerta HUD (Recursos Criticos)\n";
        cout << "7. Salir\n";
        cout << "Seleccione una opcion (1-7): "; cin >> opcion;
 
        if (opcion == 1) {
            guardarRecurso(sum, cant);
        } else if (opcion == 2) {
            listarMochila(sum, cant);
        } else if (opcion == 3) {
            string target;
            cout << "Nombre del item a buscar: "; cin >> target;
            int pos = buscarRecurso(sum, target);
            if (pos != -1) {
                cout << "-> 🔍 Localizado en posicion [" << pos << "] | Cantidad: " << cant[pos] << " u.\n";
            } else {
                cout << "-> ❌ Suministro no encontrado en la mochila.\n";
            }
        } else if (opcion == 4) {
            actualizarCantidad(cant);
        } else if (opcion == 5) {
            eliminarRecurso(sum, cant);
        } else if (opcion == 6) {
            alertaRecursosCriticos(sum, cant, 5);
        } else if (opcion != 7) {
            cout << "-> ⚠️ Opcion no valida.\n";
        }
    } while (opcion != 7);
 
    cout << "-> Mochila asegurada.\n";
    return 0;
}

9Domador de Criaturas RPG: Bestiario, Afinidades Elementales y Capturas

Bestiario 3V

Enunciado: Construir el bestiario de un domador con Menú interactivo y tres vectores: nombres de criaturas, elemento afin y poder de combate CP. Debe permitir: 1) Guardar/Capturar nueva criatura, 2) Listar bestiario completo con estadísticas, 3) Buscar criatura por nombre, 4) Actualizar poder CP tras batalla, 5) Eliminar/Liberar criatura a su hábitat salvaje en los 3 vectores a la vez, 6) Reportes elementales (criatura con mayor CP y conteo por elemento), y 7) Salir.

Vectores: vector<string> nombres | vector<string> elementos | vector<float> poderCP

Operaciones: menu(), guardarCriatura(), listarBestiario(), buscarCriatura(), actualizarPoderCP(), eliminarCriatura(), reporteMaxCP()

▶ Ver Solución C++ sugerida

caso9_bestiario_rpg.cpp

CPP

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
// 1. Guardar / Crear
void guardarCriatura(vector<string>& nom, vector<string>& ele, vector<float>& cp) {
    string n, e; float p;
    cout << "Nombre de especie: "; cin >> n;
    cout << "Elemento afin: "; cin >> e;
    cout << "Poder de combate CP: "; cin >> p;
    nom.push_back(n);
    ele.push_back(e);
    cp.push_back(p);
    cout << "-> 🍃 Criatura capturada y registrada en el bestiario.\n";
}
 
// 2. Listar
void listarBestiario(const vector<string>& nom, const vector<string>& ele, const vector<float>& cp) {
    cout << "\n=== 🐾 BESTIARIO DEL DOMADOR ===\n";
    if (nom.empty()) {
        cout << "(Bestiario vacio. Explora la region para capturar criaturas).\n";
        return;
    }
    for (size_t i = 0; i < nom.size(); i++) {
        cout << "[" << i << "] " << nom[i] << " [" << ele[i] << "] - CP: " << cp[i] << "\n";
    }
}
 
// 3. Buscar
int buscarCriatura(const vector<string>& nom, const string& target) {
    for (size_t i = 0; i < nom.size(); i++) {
        if (nom[i] == target) {
            return (int)i;
        }
    }
    return -1;
}
 
// 4. Actualizar
void actualizarPoder(vector<float>& cp) {
    int idx; float nuevoCP;
    cout << "Indice de criatura a entrenar: "; cin >> idx;
    if (idx >= 0 && idx < (int)cp.size()) {
        cout << "Nuevo CP de combate: "; cin >> nuevoCP;
        cp[idx] = nuevoCP;
        cout << "-> ⚡ CP aumentado con exito tras el entrenamiento.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 5. Eliminar
void liberarCriatura(vector<string>& nom, vector<string>& ele, vector<float>& cp) {
    int idx;
    cout << "Indice de criatura a liberar a la naturaleza: "; cin >> idx;
    if (idx >= 0 && idx < (int)nom.size()) {
        cout << "🍃 " << nom[idx] << " [" << ele[idx] << "] liberada al bosque.\n";
        nom.erase(nom.begin() + idx);
        ele.erase(ele.begin() + idx);
        cp.erase(cp.begin() + idx);
        cout << "-> ✨ Bestiario actualizado.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 6. Reportes
void reporteMaxCP(const vector<string>& nom, const vector<string>& ele, const vector<float>& cp) {
    cout << "\n👑 === CRIATURA LEGENDARIA MVP (MAYOR CP) ===\n";
    if (nom.empty()) {
        cout << "(Sin criaturas en el bestiario).\n";
        return;
    }
    int maxIdx = 0;
    for (size_t i = 0; i < cp.size(); i++) {
        if (cp[i] > cp[maxIdx]) {
            maxIdx = (int)i;
        }
    }
    cout << "Criatura Legendaria: " << nom[maxIdx] << " [" << ele[maxIdx] << "] con " << cp[maxIdx] << " CP\n";
}
 
int main() {
    vector<string> nom = {"Ignisaur", "Aquafox", "Thundercat"};
    vector<string> ele = {"FUEGO", "AGUA", "RAYO"};
    vector<float> cp = {1250.0f, 890.0f, 1540.0f};
    int opcion = 0;
 
    do {
        cout << "\n=================================\n";
        cout << "   BESTIARIO DEL DOMADOR (CRUD)  \n";
        cout << "=================================\n";
        cout << "1. Guardar / Capturar Criatura\n";
        cout << "2. Listar Bestiario Completo\n";
        cout << "3. Buscar Criatura por Nombre\n";
        cout << "4. Entrenar / Aumentar CP\n";
        cout << "5. Liberar Criatura a la Naturaleza\n";
        cout << "6. Reporte Criatura con Mayor CP\n";
        cout << "7. Salir\n";
        cout << "Seleccione una opcion (1-7): "; cin >> opcion;
 
        if (opcion == 1) {
            guardarCriatura(nom, ele, cp);
        } else if (opcion == 2) {
            listarBestiario(nom, ele, cp);
        } else if (opcion == 3) {
            string target;
            cout << "Nombre de especie a buscar: "; cin >> target;
            int pos = buscarCriatura(nom, target);
            if (pos != -1) {
                cout << "-> 🔍 Localizada en posicion [" << pos << "] [" << ele[pos] << "] con " << cp[pos] << " CP\n";
            } else {
                cout << "-> ❌ Criatura no avistada en el bestiario.\n";
            }
        } else if (opcion == 4) {
            actualizarPoder(cp);
        } else if (opcion == 5) {
            liberarCriatura(nom, ele, cp);
        } else if (opcion == 6) {
            reporteMaxCP(nom, ele, cp);
        } else if (opcion != 7) {
            cout << "-> ⚠️ Opcion no valida.\n";
        }
    } while (opcion != 7);
 
    cout << "-> Bestiario cerrado.\n";
    return 0;
}

10Tienda Gacha & Pase de Batalla: Catálogo de Skins, Canjes y Auditoría

Economía Gacha

Enunciado: Diseñar el backend de la tienda de skins y pases con Menú interactivo y tres vectores: nombres de skins, stock disponible y costo en gemas. Debe permitir: 1) Guardar nueva skin de temporada, 2) Listar catálogo completo, 3) Buscar skin por nombre, 4) Actualizar precio o stock tras compra, 5) Eliminar skin retirada de la tienda, 6) Reportes económicos (recaudación potencial en gemas, skins agotadas y skin legendaria más cara), y 7) Salir.

Vectores: vector<string> skins | vector<int> stockSkins | vector<float> costosGemas

Operaciones: menu(), guardarSkin(), listarTienda(), buscarSkin(), actualizarSkin(), eliminarSkin(), reporteRecaudacion()

▶ Ver Solución C++ sugerida

caso10_gacha_skins.cpp

CPP

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
// 1. Guardar / Crear
void guardarSkin(vector<string>& skins, vector<int>& stock, vector<float>& costos) {
    string s; int stk; float c;
    cout << "Nombre de skin: "; cin >> s;
    cout << "Stock inicial disponible: "; cin >> stk;
    cout << "Costo en gemas: "; cin >> c;
    skins.push_back(s);
    stock.push_back(stk);
    costos.push_back(c);
    cout << "-> 🎟️ Skin agregada a la tienda de temporada.\n";
}
 
// 2. Listar
void listarTienda(const vector<string>& skins, const vector<int>& stock, const vector<float>& costos) {
    cout << "\n=== 🎟️ TIENDA GACHA & PASE DE BATALLA ===\n";
    if (skins.empty()) {
        cout << "(Catalogo vacio. No hay skins disponibles).\n";
        return;
    }
    for (size_t i = 0; i < skins.size(); i++) {
        cout << "[" << i << "] " << skins[i] << " - Stock: " << stock[i] << " disp. - " << costos[i] << " Gemas\n";
    }
}
 
// 3. Buscar
int buscarSkin(const vector<string>& skins, const string& target) {
    for (size_t i = 0; i < skins.size(); i++) {
        if (skins[i] == target) {
            return (int)i;
        }
    }
    return -1;
}
 
// 4. Actualizar
void actualizarStock(vector<int>& stock) {
    int idx; int nuevoStock;
    cout << "Indice de skin a modificar stock: "; cin >> idx;
    if (idx >= 0 && idx < (int)stock.size()) {
        cout << "Nuevo stock disponible: "; cin >> nuevoStock;
        stock[idx] = nuevoStock;
        cout << "-> 📦 Stock actualizado.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 5. Eliminar
void eliminarSkin(vector<string>& skins, vector<int>& stock, vector<float>& costos) {
    int idx;
    cout << "Indice de skin a retirar de la tienda: "; cin >> idx;
    if (idx >= 0 && idx < (int)skins.size()) {
        cout << "🗑️ " << skins[idx] << " retirada de la rotacion.\n";
        skins.erase(skins.begin() + idx);
        stock.erase(stock.begin() + idx);
        costos.erase(costos.begin() + idx);
        cout << "-> ✨ Catalogo actualizado.\n";
    } else {
        cout << "-> ❌ Indice invalido.\n";
    }
}
 
// 6. Canjear y Reportes
void canjearSkin(vector<string>& skins, vector<int>& stock, const vector<float>& costos) {
    string skin; int cant;
    cout << "Nombre de skin a canjear: "; cin >> skin;
    int pos = buscarSkin(skins, skin);
    if (pos != -1) {
        cout << "Cantidad a comprar: "; cin >> cant;
        if (stock[pos] >= cant && cant > 0) {
            stock[pos] -= cant;
            float totalGemas = cant * costos[pos];
            cout << "-> ✨ ¡Canje exitoso! Pagaste " << totalGemas << " Gemas por " << cant << "x " << skins[pos] << ".\n";
            cout << "   Stock restante en tienda: " << stock[pos] << " u.\n";
        } else {
            cout << "-> ❌ Stock insuficiente (solo quedan " << stock[pos] << " u.).\n";
        }
    } else {
        cout << "-> ❌ Skin no encontrada en la tienda.\n";
    }
}
 
int main() {
    vector<string> skins = {"Cyber_Samurai", "Neon_Valkyrie", "Mecha_Dragon"};
    vector<int> stock = {10, 2, 5};
    vector<float> costos = {1200.0f, 2500.0f, 5000.0f};
    int opcion = 0;
 
    do {
        cout << "\n=================================\n";
        cout << "  TIENDA GACHA & SKINS (CRUD)    \n";
        cout << "=================================\n";
        cout << "1. Guardar / Añadir Skin al Pase\n";
        cout << "2. Listar Tienda y Precios\n";
        cout << "3. Buscar Skin por Nombre\n";
        cout << "4. Actualizar Stock Disponible\n";
        cout << "5. Retirar / Eliminar Skin\n";
        cout << "6. Canjear Skin con Gemas\n";
        cout << "7. Salir\n";
        cout << "Seleccione una opcion (1-7): "; cin >> opcion;
 
        if (opcion == 1) {
            guardarSkin(skins, stock, costos);
        } else if (opcion == 2) {
            listarTienda(skins, stock, costos);
        } else if (opcion == 3) {
            string target;
            cout << "Nombre de skin a buscar: "; cin >> target;
            int pos = buscarSkin(skins, target);
            if (pos != -1) {
                cout << "-> 🔍 Localizada en posicion [" << pos << "] | Costo: " << costos[pos] << " Gemas | Stock: " << stock[pos] << " u.\n";
            } else {
                cout << "-> ❌ Skin no encontrada.\n";
            }
        } else if (opcion == 4) {
            actualizarStock(stock);
        } else if (opcion == 5) {
            eliminarSkin(skins, stock, costos);
        } else if (opcion == 6) {
            canjearSkin(skins, stock, costos);
        } else if (opcion != 7) {
            cout << "-> ⚠️ Opcion no valida.\n";
        }
    } while (opcion != 7);
 
    cout << "-> Tienda gacha cerrada.\n";
    return 0;
}

← 7.3 Arreglos 2D (Pac-Man)Módulo 8: Funciones en C++➡️

Contenido

📚 Cursos de Café y Código

Examen Práctico: Sistema CRUD de Estudiantes y Notas

Fundamentos: ¿Qué conceptos se aplican en este código?

1. Vectores Paralelos

2. Paso por Referencia (`&`)

Código Fuente Completo del Ejercicio

Explicación Paso a Paso: Anatomía de cada Función

Simulador de Consola y Memoria en Vivo

🕹️ Elige una acción del Menú (main):

Ingresar datos:

🧠 Estado en Memoria RAM (std::vector)

Cuestionario de Evaluación: Pon a prueba lo aprendido

¿Listo para validar tu comprensión técnica?

10 Casos Prácticos Tipo Prueba: Vectores Paralelos & CRUD

¿Quieres resolver estos 10 casos en C++, Python, Java, C#, JS, PHP y PSeInt?

1Herrería & Tienda RPG: Sistema CRUD y Catálogo de Armas

2Raid Boss & Squad: Gestión de Escuadrón, Salud y Triaje Crítico

3Gremio / Clan MMORPG: Registro de Miembros, DPS y Auditoría MVP

4Hangar Sci-Fi: Control de Bahías, Naves y Asignación de Pilotos

5Alquimia & Forja Rúnica: Almacén de Ingredientes, Crafteo y Stock

6Torneo Arcade Global: Leaderboard, Clasificación y Tabla de Récords

7Dungeon Crawler MMORPG: Servidor de Mazmorras, Salas y Partidas

8Supervivencia Post-Apocalíptica: Mochila Táctica, Municiones y Alertas HUD

9Domador de Criaturas RPG: Bestiario, Afinidades Elementales y Capturas

10Tienda Gacha & Pase de Batalla: Catálogo de Skins, Canjes y Auditoría

Cuestionario de Evaluación: Pon a prueba lo aprendido

¡Hecho con mucho cariño! ☕

Examen Práctico: Sistema CRUD de Estudiantes y Notas

Fundamentos: ¿Qué conceptos se aplican en este código?

1. Vectores Paralelos

2. Paso por Referencia (&)

Código Fuente Completo del Ejercicio

Explicación Paso a Paso: Anatomía de cada Función

Simulador de Consola y Memoria en Vivo

🕹️ Elige una acción del Menú (main):

Ingresar datos:

🧠 Estado en Memoria RAM (std::vector)

Cuestionario de Evaluación: Pon a prueba lo aprendido

¿Listo para validar tu comprensión técnica?

10 Casos Prácticos Tipo Prueba: Vectores Paralelos & CRUD

¿Quieres resolver estos 10 casos en C++, Python, Java, C#, JS, PHP y PSeInt?

1Herrería & Tienda RPG: Sistema CRUD y Catálogo de Armas

2Raid Boss & Squad: Gestión de Escuadrón, Salud y Triaje Crítico

3Gremio / Clan MMORPG: Registro de Miembros, DPS y Auditoría MVP

4Hangar Sci-Fi: Control de Bahías, Naves y Asignación de Pilotos

5Alquimia & Forja Rúnica: Almacén de Ingredientes, Crafteo y Stock

6Torneo Arcade Global: Leaderboard, Clasificación y Tabla de Récords

7Dungeon Crawler MMORPG: Servidor de Mazmorras, Salas y Partidas

8Supervivencia Post-Apocalíptica: Mochila Táctica, Municiones y Alertas HUD

9Domador de Criaturas RPG: Bestiario, Afinidades Elementales y Capturas

10Tienda Gacha & Pase de Batalla: Catálogo de Skins, Canjes y Auditoría

Cuestionario de Evaluación: Pon a prueba lo aprendido

2. Paso por Referencia (`&`)