Guest User

Solución problema nota-estudiantes C++

a guest
Mar 1st, 2020
194
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /////////////////////////////////////////// FORMA 1 (UN SOLO ARREGLO DE CALIFICACIONES) ///////////////////////////////////////////
  2.  
  3. /*
  4. La idea de lo que se está haciendo aquí es la siguiente:
  5.     Se ingresan los nombres de los cinco estudiantes.
  6.     Por cada uno, se ingresan las tres calificaciones que le corresponden.
  7.     Se calcula el promedio del alumno y se lo muestra en pantalla.
  8.     Se vuelven a pedir las calificaciones pero esta vez de un alumno distinto; sin necesidad de crear otro arreglo de calificaciones porque podemos sobreescribir el arreglo creado con anterioridad.
  9.     Se realiza el proceso tantas veces como alumnos haya.
  10. */
  11.  
  12. #include<iostream>
  13. #include<string.h>
  14.  
  15. #define MAX_ESTUDIANTES 5 //Definimos que vamos a trabajar con 5 estudiantes como máximo.
  16. #define MAX_CALIFICACIONES 3 //Definimos que la máxima cantidad de calificaciones que tendrá un estudiante es de 3.
  17.  
  18. int main()
  19. {
  20.     std::string estudiantes[MAX_ESTUDIANTES]; //Arreglo que contendrá 5 elementos de tipo std::string (5 nombres de estudiantes)
  21.    
  22.     float calificaciones[MAX_CALIFICACIONES],promedio; //Arreglo que contendrá 3 elementos de tipo float (3 calificaciones)
  23.     float suma = 0; //Suma parcial que nos servirá para calcular el promedio
  24.    
  25.     for(int i=0; i<MAX_ESTUDIANTES; i++) //Llenamos el arreglo de estudiantes con sus nombres...
  26.     {
  27.         std::cout << "Ingrese el nombre del estudiante #" << i+1 << ": ";
  28.         std::cin >> estudiantes[i];
  29.     }
  30.    
  31.     std::cout << std::endl; //Salto de línea...
  32.    
  33.     for(int j=0; j<MAX_ESTUDIANTES; j++) //Para cada alumno...
  34.     {
  35.         for(int k=0; k<MAX_CALIFICACIONES; k++) //Ingresamos 3 calificaciones...
  36.         {
  37.             std::cout << "Ingrese la calificacion #" << k+1 << " del estudiante #" << j+1 << ": ";
  38.             std::cin >> calificaciones[k];
  39.            
  40.             suma += calificaciones[k]; //Y esas calificaciones las almacenamos sumándose entre sí en la variable 'suma'...
  41.         }
  42.        
  43.         //Cuando terminamos de ingresar todas las calificaciones de un alumno...      
  44.  
  45.         promedio = suma/MAX_CALIFICACIONES; //Calculamos el promedio dividiendo la suma de sus calificaciones entre la cantidad máxima cantidad de calificaciones por alumno...
  46.        
  47.         std::cout << "El promedio del alumno #" << j+1 << " es: " << promedio << std::endl << std::endl; //Lo mostramos en pantalla...
  48.        
  49.         //Reseteamos las variables 'promedio' y 'suma' para que no se mezclen datos de estudiantes...
  50.         promedio = 0;
  51.         suma = 0;
  52.     }
  53.    
  54.     return EXIT_SUCCESS;
  55. }
  56.  
  57. /*
  58. ********** PROS DE ESTE CÓDIGO **********
  59.     1) Fácil de entender.
  60.     2) Variables con nombes intuitivos.
  61.     3) Funciona.
  62.  
  63. ********** CONTRAS DE ESTE CÓDIGO **********
  64.     1) No se crea un arreglo de calificaciones para cada alumno. El único arreglo que se utiliza se sobreescribe cada vez que se pide las calificaciones de un estudiante.
  65.     2) No está orientado a objetos, lo cual podría simplificar la contra (1), pudiendo así crear un arreglo de calificaciones para cada alumno y no perder esos datos.
  66. */
  67.  
  68. /////////////////////////////////// FORMA 2 (UN ARREGLO DE CALIFICACIONES POR CADA ESTUDIANTE) ///////////////////////////////////
  69.  
  70. /*
  71. La idea en este segundo código es similar a la primera:
  72.     Se ingresan los nombres de los cinco estudiantes.
  73.     Se crea un arreglo de calificaciones para cada uno.
  74.     Por cada uno, se ingresan las tres calificaciones que le corresponden en su respectivo arreglo de calificaciones.
  75.     Se calcula el promedio de cada uno y se lo muestra en pantalla.
  76. */
  77.  
  78. #include<iostream>
  79. #include<string.h>
  80.  
  81. #define MAX_ESTUDIANTES 5
  82. #define MAX_CALIFICACIONES 3
  83.  
  84. int main()
  85. {
  86.     std::string estudiantes[MAX_ESTUDIANTES];
  87.    
  88.     float calif1[MAX_CALIFICACIONES],calif2[MAX_CALIFICACIONES],calif3[MAX_CALIFICACIONES],calif4[MAX_CALIFICACIONES],calif5[MAX_CALIFICACIONES],promedios[MAX_ESTUDIANTES]; //Creamos un arreglo de calificaciones para cada estudiantes...
  89.     float sumas[MAX_ESTUDIANTES]; //Creamos un arreglo que almacene las sumas de las calificaciones de cada estudiantes...
  90.    
  91.     for(int i=0; i<MAX_ESTUDIANTES; i++) //Pedimos los nombres de los estudiantes...
  92.     {
  93.         std::cout << "Ingrese el nombre del estudiante #" << i+1 << ": ";
  94.         std::cin >> estudiantes[i];
  95.     }
  96.    
  97.     std::cout << std::endl;
  98.    
  99.     for(int j=0; j<MAX_ESTUDIANTES; j++) //Para cada estudiante...
  100.     {
  101.         for(int k=0; k<MAX_CALIFICACIONES; k++) //Pedimos sus tres calificaciones...
  102.         {
  103.             std::cout << "Ingrese la calificacion #" << k+1 << " del estudiante #" << j+1 << ": ";
  104.            
  105.             switch(j) //Las almacenamos en el arreglo correspondiente según el valor de alumno (según j)
  106.             {
  107.                 case 0: //Si j==0, estamos hablando del alumno #1...
  108.                 {
  109.                     std::cin >> calif1[k];
  110.                    
  111.                     sumas[j] += calif1[k]; //Incrementamos el valor de 'suma[0]', haciendo referencia a la suma del alumno #1...
  112.                    
  113.                     break;
  114.                 }
  115.                
  116.                 case 1: //Si j==1, estamos hablando del alumno #2...
  117.                 {
  118.                     std::cin >> calif2[k];
  119.                    
  120.                     sumas[j] += calif2[k]; //Incrementamos el valor de 'suma[1]', haciendo referencia a la suma del alumno #2...
  121.                    
  122.                     break;
  123.                 }
  124.                
  125.                 case 2:
  126.                 {
  127.                     std::cin >> calif3[k];
  128.                    
  129.                     sumas[j] += calif3[k];
  130.                    
  131.                     break;
  132.                 }
  133.                
  134.                 case 3:
  135.                 {
  136.                     std::cin >> calif4[k];
  137.                    
  138.                     sumas[j] += calif4[k];
  139.                    
  140.                     break;
  141.                 }
  142.                
  143.                 default: //Sentencia obligatoria para un 'switch'. Aquí ahce referencia a j==4.
  144.                 {
  145.                     std::cin >> calif5[k];
  146.                    
  147.                     sumas[j] += calif5[k];
  148.                    
  149.                     break;
  150.                 }
  151.             }
  152.         }
  153.        
  154.         std::cout << std::endl;
  155.     }
  156.    
  157.     std::cout << std::endl;
  158.    
  159.     for(int i=0; i<MAX_ESTUDIANTES; i++) //Para cada estudiante...
  160.     {
  161.         promedios[i] = sumas[i]/MAX_CALIFICACIONES; //Calculamos su promedio teniendo en cuenta la suma de sus notas y el máximo de notas admitido...
  162.        
  163.         std::cout << "El promedio del estudiante #" << i+1 << " es: " << promedios[i] << std::endl; //Y lo mostramos en pantalla.
  164.     }
  165.    
  166.     return EXIT_SUCCESS;
  167. }
  168.  
  169. /*
  170. ********** PROS DE ESTE CÓDIGO **********
  171.     1) Variables con nombes intuitivos.
  172.     2) Funciona.
  173.     3) Mantiene las notas de los alumnos por si más adelante se quieren utilizar nuevamente.
  174.  
  175. ********** CONTRAS DE ESTE CÓDIGO **********
  176.     1) No está orientado a objetos, lo cual simplificaría las cosas.
  177.     2) Muchos casos a la hora de hacer el 'switch'.
  178.     3) Se ocupa más memoria al tener que declarar tantas variables.
  179.     4) Si tuviéramos muchos alumnos, la cantidad de arreglos que habría que declarar sería muy grande.
  180. */
  181.  
  182. ///////////////////////////////////////////////// MIS RECOMENDACIONES /////////////////////////////////////////////////
  183.  
  184. /*
  185. En primer lugar, intenta ponerle nombres fáciles de leer a las variables. Nombres que a primera vista te den información sobre lo que almacenan. Trata de evitar abreviaciones, acrónimos y demás.
  186. Personalmente, te recomiendo que trabajes, al menos, con funciones. Puedes leer acerca de ello en internet. Hay toneladas de información y tutoriales para aprender a manejarlas muy bien. Una vez que te familiaricez con ellas, intenta aplicarlas para resolver este problema.
  187. Por otra parte, te recomiendo que cuando ya lo hayas podido resolver con funciones, intentes adentrarte en lo que son CLASES y la PROGRAMACIÓN ORIENTADA A OBJETOS. Estas dos cosas son herramientas muy poderosas que pueden hacer que un problema como el tuyo se resuelva fácilmente en unas pocas líneas de código. Es, además, el paradigma de programación para el que están desarrollados los lenguajes de programación como C++, Java, Python, etcétera.
  188.  
  189. ¡Espero haber sido de ayuda! Un saludo.
  190.  
  191. Akamai.
  192. */
RAW Paste Data