Queremos crear un codigo en C++ para solucionar el siguiente problema:
Se realizó una competencia de aritmética donde participaron x cantidad de alumnos y se les tomo 3 exámenes, siendo el ganador el del mejor promedio.
- DNI
- NOMBRE
- APELLIDO
- CALIFICACION 1
- CALIFICACION 2
- CALIFICACION 3
Una vez cargados los datos de los x alumnos deberás calcular el promedio (mediante una función para evitar escribir código duplicado) y buscar entre los promedios la nota más alta, recuerda que las notas no tienen decimales.
Para terminar la carga deberá ingresar un 0 en DNI y el ciclo se cerrará y se mostrará los datos de los alumnos.
Solución
Este código utiliza un vector de estructuras para almacenar los datos de los alumnos. La carga de datos se realiza mediante un ciclo while que solicita el ingreso de datos por teclado hasta que se ingresa un DNI igual a 0. Para calcular el promedio se define una función promedio() que recibe las tres calificaciones como argumentos. Para encontrar el alumno con el mejor promedio se utiliza la función max_element() de la biblioteca <algorithm>, que compara los promedios de cada alumno utilizando una función lambda. Finalmente se imprime la tabla de datos y se muestra el alumno con el mejor promedio.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 | #include <iostream> #include <vector> #include <string> #include <algorithm> using namespace std; struct Alumno { string dni; string nombre; string apellido; int calif1; int calif2; int calif3; }; double promedio(int calif1, int calif2, int calif3) { return (calif1 + calif2 + calif3) / 3.0; } int main() { vector<Alumno> alumnos; while (true) { string dni, nombre, apellido; int calif1, calif2, calif3; cout << "Ingrese DNI (o 0 para salir): "; cin >> dni; if (dni == "0") { break; } cout << "Ingrese nombre: "; cin >> nombre; cout << "Ingrese apellido: "; cin >> apellido; cout << "Ingrese calificacion 1: "; cin >> calif1; cout << "Ingrese calificacion 2: "; cin >> calif2; cout << "Ingrese calificacion 3: "; cin >> calif3; alumnos.push_back({dni, nombre, apellido, calif1, calif2, calif3}); } auto mejor_promedio = max_element(alumnos.begin(), alumnos.end(), [](const Alumno& a, const Alumno& b) { return promedio(a.calif1, a.calif2, a.calif3) < promedio(b.calif1, b.calif2, b.calif3); }); double promedio_maximo = promedio(mejor_promedio->calif1, mejor_promedio->calif2, mejor_promedio->calif3); cout << "+--------------+-----------------+------------------+------+------+------+" << endl; cout << "| DNI | Nombre | Apellido | Cal1 | Cal2 | Cal3 |" << endl; cout << "+--------------+-----------------+------------------+------+------+------+" << endl; for (const auto& alumno : alumnos) { cout << "| " << alumno.dni << " | " << alumno.nombre << " | " << alumno.apellido << " | " << alumno.calif1 << " | " << alumno.calif2 << " | " << alumno.calif3 << " |" << endl; } cout << "+--------------+-----------------+------------------+------+------+------+" << endl; cout << "El mejor promedio es " << promedio_maximo << " y pertenece a " << mejor_promedio->nombre << " " << mejor_promedio->apellido << " (DNI: " << mejor_promedio->dni << ")" << endl; return 0; } |
Se podria hacer mejor?
El código que se proporcionó no hace uso de características específicas de C++14 o versiones posteriores, ya que utiliza conceptos básicos del lenguaje que están disponibles desde versiones anteriores.
Sin embargo, se podrían agregar algunas características de C++14 o versiones posteriores para mejorar la legibilidad y la eficiencia del código, como:
- La declaración de variables constexpr, que permite definir variables constantes en tiempo de compilación y, por lo tanto, mejorar la eficiencia del código.
- La función std::max_element, que permite encontrar el elemento máximo en un rango de valores.
- La función std::accumulate, que permite realizar una operación de acumulación en un rango de valores.
- El bucle for-each, que permite iterar sobre los elementos de un contenedor de manera más legible y eficiente que el bucle for convencional.
- Las funciones lambda, que permiten definir funciones anónimas y simplificar la sintaxis del código.
- Los punteros inteligentes, como std::unique_ptr y std::shared_ptr, que ayudan a manejar la memoria dinámica de manera más segura y eficiente.
En general, el uso de características más recientes de C++ puede ayudar a escribir código más legible, eficiente y seguro. Sin embargo, es importante recordar que estas características no siempre están disponibles en todas las plataformas o versiones de compiladores, por lo que es necesario evaluar cuidadosamente si su uso es apropiado para el proyecto en cuestión.
Aquí te presento una versión del código utilizando características de C++14 y posteriores, como el uso de lambdas, la función std::max_element, y la biblioteca iomanip para la salida formateada:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 | #include <iostream> #include <algorithm> #include <iomanip> #include <vector> struct Alumno { std::string dni; std::string nombre; std::string apellido; int calificacion1; int calificacion2; int calificacion3; double promedio() const { return (calificacion1 + calificacion2 + calificacion3) / 3.0; } }; int main() { std::vector<Alumno> alumnos; // Carga de los datos std::cout << "Ingrese los datos de los alumnos:" << std::endl; while (true) { Alumno a; std::cout << "DNI: "; std::getline(std::cin, a.dni); if (a.dni == "0") break; std::cout << "Nombre: "; std::getline(std::cin, a.nombre); std::cout << "Apellido: "; std::getline(std::cin, a.apellido); std::cout << "Calificacion 1: "; std::cin >> a.calificacion1; std::cout << "Calificacion 2: "; std::cin >> a.calificacion2; std::cout << "Calificacion 3: "; std::cin >> a.calificacion3; std::cin.ignore(); // Ignorar el caracter de salto de línea alumnos.push_back(a); } // Calcular el promedio de cada alumno y buscar el máximo auto promedios = std::vector<double>(alumnos.size()); std::transform(alumnos.begin(), alumnos.end(), promedios.begin(), [](const Alumno& a) { return a.promedio(); }); auto max_promedio = *std::max_element(promedios.begin(), promedios.end()); // Mostrar los datos de los alumnos std::cout << "+----+----------+-----------+---------------+---------------+---------------+" << std::endl; std::cout << "| # | DNI | Nombre | Apellido | Promedio | Estado |" << std::endl; std::cout << "+----+----------+-----------+---------------+---------------+---------------+" << std::endl; int i = 1; for (const auto& a : alumnos) { std::cout << "|"; std::cout << std::setw(4) << i++; std::cout << "|"; std::cout << std::setw(10) << a.dni; std::cout << "|"; std::cout << std::setw(11) << a.nombre; std::cout << "|"; std::cout << std::setw(15) << a.apellido; std::cout << "|"; std::cout << std::setw(15) << std::fixed << std::setprecision(2) << a.promedio(); std::cout << "|"; std::cout << std::setw(15) << (a.promedio() >= max_promedio ? "GANADOR" : ""); std::cout << "|" << std::endl; } std::cout << "+----+----------+-----------+---------------+---------------+---------------+" << std::endl; return 0; } |
Esta versión del código aprovecha las características más modernas de C++ para mejorar tanto su lejibilidad como la eficiencia del codigo.