Ejercicios C++: Registros y arrays

Empezamos a ver los registros y arrays de C++, por lo que la cosa ya se complica un poquito. Os dejo unos ejercicios para practicar.

En los ejercicios se pedirá la dimensión real del array, que deberá ser menor que el tamaño máximo que se haya puesto en la definición de dicho array. Para la realización de los ejercicios nos serán útiles las siguientes funciones:

unsigned leerDim()

void leerArray(TVector &v, unsigned dim)

void ImprimirVector(const TVector &v, unsigned n)

Otra opción más adecuada es definir una estructura registro que contenga tanto el array en sí como su dimensión:

const unsigned int MAX = 100;

typedef float TVect[MAX];

struct TVector

{

  TVect vect;

  unsigned dim;

};
 

Por tanto cada ejercicio os lo dejaré de ambas maneras aunque son muy parecidas ;)

Ejercicio 1.
Desarrollar una función de nombre tomar_mayor que tome como parámetro un array de valores reales (usar float o double queda a la elección del alumno) y dé como resultado el valor mayor contenido en dicho array. Como tamaño máximo del array puede tomarse el valor 100. Crear también una función main para comprobar que todo funciona bien.

#include <iostream>
using namespace std;

const unsigned MAXIMO = 100;
typedef double TVector[MAXIMO];


unsigned leerDim (){
 unsigned elementos;
 cout << "Introduce el número de elementos: ";
 cin >> elementos;
 return elementos;
}

void leerArray(TVector& miarray, unsigned elementos){
 cout << "Introduce "<< elementos << " elementos: "<< endl;
 for(unsigned i=0; i< elementos; i++){
  cin >> miarray[i];
 }
}

double tomar_mayor(const TVector& miarray, unsigned elementos){
 double mayor = miarray[0];
 for(unsigned i=1; i< elementos; i++){
  if(miarray[i] > mayor){
   mayor = miarray[i];
  }
 }
 return mayor;
}


int main() {
 cout << "Mayor contenido de un array." << endl;
 TVector miarray;
 unsigned elementos = leerDim();
 leerArray(miarray, elementos);
 cout << "El mayor de los números del array es "<< tomar_mayor(miarray, elementos); ;

 return 0;
}

#include  <iostream>
using namespace std;

const unsigned int MAX = 100;

typedef float TVect[MAX];

struct TVector
{
  TVect vect;
  unsigned dim;
};

void leerDim (TVector &v){
 cout << "Introduce el número de elementos: ";
 cin >> v.dim;
}

void leerArray(TVector& miarray){
 cout << "Introduce "<< miarray.dim << " elementos: "<< endl;
 for(unsigned i=0; i< miarray.dim; i++){
  cin >> miarray.vect[i];
 }
}

double tomar_mayor(const TVector& miarray){
 double mayor = miarray.vect[0];
 for(unsigned i=1; i< miarray.dim; i++){
  if(miarray.vect[i] > mayor){
   mayor = miarray.vect[i];
  }
 }
 return mayor;
}


int main() {
 cout << "Mayor contenido de un array." << endl;
 TVector miarray;
 leerDim(miarray);
 leerArray(miarray);
 cout << "El mayor de los números del array es "<< tomar_mayor(miarray); ;

 return 0;
}

Ejercicio 2.
Mediante el uso de arrays, diseñar una función para calcular la media de las estaturas de una clase asumiendo que el número máximo de alumnos en una clase es de 50 y que, además, las estaturas son valores expresados en centímetros. Crear otras dos funciones para determinar cuántos alumnos son más altos y cuántos más bajos que la media. El nombre de las funciones queda a criterio del alumno. Crear también una función main para comprobar que estas funciones se han codificado correctamente.

#include  <iostream>
using namespace std;

const unsigned MAXIMO = 50;

typedef unsigned TAlturas[MAXIMO];

unsigned leerDim (){
 unsigned elementos;
 cout << "Introduce el número de elementos: ";
 cin >> elementos;
 return elementos;
}

void leerArray(TAlturas& alturas, unsigned elementos){
 cout << "Introduce "<< elementos<< " elementos: "<< endl;
 for(unsigned i=0; i< elementos; i++){
  cin >> alturas[i];
 }
}

double calcularMedia (const TAlturas& alturas, unsigned elementos){
 unsigned suma = 0;
 for(unsigned i = 0; i < elementos; i++){
  suma = suma + alturas[i];
 }
 return suma/elementos;
}

unsigned masAltos(const TAlturas& alturas, double media, unsigned elementos){
 unsigned altos = 0;
 for(unsigned i = 0; i < elementos; i++){
   if(alturas[i] > media){
    altos++;
   }
 }
 return altos;
}


unsigned masBajos(const TAlturas& alturas, double media, unsigned elementos){
 unsigned bajos = 0;
 for(unsigned i = 0; i < elementos; i++){
   if(alturas[i] < media){
    bajos++;
   }
 }
 return bajos;
}


int main() {

 TAlturas alturas;
 unsigned elementos = leerDim();
 leerArray(alturas, elementos);
 double media = calcularMedia(alturas, elementos);
 cout << "La altura media de la clase es "<< media << " centímetros." << endl;
 cout << masAltos(alturas, media, elementos) << " alumnos son más altos que la media y "<< masBajos(alturas, media, elementos) << " alumnos son más bajos que la media.";


 return 0;
}

#include  <iostream>
using namespace std;

const unsigned MAXIMO = 50;

typedef unsigned TAlt[MAXIMO];

struct TAlturas
{
  TAlt vect;
  unsigned dim;
};

void leerDim (TAlturas &v){
 cout << "Introduce el número de elementos: ";
 cin >> v.dim;
}

void leerArray(TAlturas& miarray){
 cout << "Introduce "<< miarray.dim << " elementos: "<< endl;
 for(unsigned i=0; i< miarray.dim; i++){
  cin >> miarray.vect[i];
 }
}

double calcularMedia (const TAlturas& alturas){
 unsigned suma = 0;
 for(unsigned i = 0; i < alturas.dim; i++){
  suma = suma + alturas.vect[i];
 }
 return suma/alturas.dim;
}

unsigned masAltos(const TAlturas& alturas, double media){
 unsigned altos = 0;
 for(unsigned i = 0; i < alturas.dim; i++){
   if(alturas.vect[i] > media){
    altos++;
   }
 }
 return altos;
}


unsigned masBajos(const TAlturas& alturas, double media){
 unsigned bajos = 0;
 for(unsigned i = 0; i < alturas.dim; i++){
   if(alturas.vect[i] < media){
    bajos++;
   }
 }
 return bajos;
}


int main() {

 TAlturas alturas;
 leerDim(alturas);
 leerArray(alturas);
 double media = calcularMedia(alturas);
 cout << "La altura media de la clase es "<< media << " centímetros." << endl;
 cout << masAltos(alturas, media) << " alumnos son más altos que la media y "<< masBajos(alturas, media) << " alumnos son más bajos que la media.";


 return 0;
}

Ejercicio 3.
Diseñar un algoritmo (y desarrollar la función C++ correspondiente y el main para probarla) que acepte de teclado una secuencia de números entre 0 y 9 y cuente el número de veces que se repite cada dígito. La secuencia de números de entrada se da por finalizada al leer un número negativo. Ej.:
Entrada: 1 8 7 3 4 8 5 9 5 0 0 4 8 4 5 3 2 8 -1
Salida: 0: 2; 1:1; 2: 1; 3: 2; 4: 3; 5: 3; 6: 0; 7: 1; 8: 4; 9: 1

#include <iostream>
using namespace std;

typedef int TFrecuencias[10];

void inicializar(TFrecuencias& frecuencias){
 for(unsigned i= 0; i < 10; i++){
  frecuencias[i]= 0;
 }
}



void leerDatos(TFrecuencias& frecuencias){
 int num = -1;
 cout << "Introducir lista de números y terminar con un negativo: "<< endl;

 do {
  frecuencias[num]++;
  do{
  cin >> num;
  }while(num >= 10);
 }while(num >= 0);
}

void imprimirFrecuencias (const TFrecuencias& frecuencias){
 for(unsigned i= 0; i < 10; i++){
  cout << i << ":"<< frecuencias[i] <<"; ";
 }
}



int main() {
 TFrecuencias frecuencias;
 inicializar(frecuencias);
 leerDatos(frecuencias);
 imprimirFrecuencias(frecuencias);
 return 0;
}

Ejercicio 4.
Un histograma es una gráfica que muestra la frecuencia con que aparecen en una lista dada los distintos valores que la pudieran formar. Por ejemplo, si los valores de una lista pueden estar comprendidos entre 0 y 9, y la lista es:
6 4 4 1 9 7 5 6 4 2 3 9 5 6 4
entonces su histograma es:

Esto indica que los dígitos 0 y 8 no aparecen ninguna vez, que 1, 2, 3 y 7 aparecen una vez, 5 y 9 dos veces, etc. Escriba un programa que lea una lista de números comprendidos entre 0 y 9 separados por espacios (la lista acabará cuando se lea un número negativo, y a priori no se puede determinar cuántos números contiene) e imprima por pantalla un histograma como el anterior. Para ello deben usarse funciones y arrays.

#include <iostream>
using namespace std;

typedef unsigned TFrecuencias[10];

void inicializar(TFrecuencias& frecuencias){
 for(unsigned i= 0; i < 10; i++){
  frecuencias[i]= 0;
 }
}



void leerDatos(TFrecuencias& frecuencias){
 int num = -1;

 do {
  frecuencias[num]++;
  cin >> num;
 }while(num >= 0);
}

unsigned tomar_mayor(const TFrecuencias& miarray){
 unsigned mayor = miarray[0];
 for(unsigned i=1; i< 10; i++){
  if(miarray[i] > mayor){
   mayor = miarray[i];
  }
 }
 return mayor;
}


void imprimirFrecuencias (TFrecuencias& frecuencias, unsigned mayor){
 unsigned a = mayor;

 for(unsigned i= 0; i < mayor; i++){


  for(unsigned e=0; e< 10; e++){
   if(frecuencias[e] == a){
    cout << "* ";
    frecuencias[e] = frecuencias[e]-1;
   }else{
    cout << "  ";
   }
  }
  a = tomar_mayor(frecuencias);
  cout << endl;
 }

 cout << "0 1 2 3 4 5 6 7 8 9";

}



int main() {
 TFrecuencias frecuencias;
 inicializar(frecuencias);
 leerDatos(frecuencias);
 imprimirFrecuencias(frecuencias, tomar_mayor(frecuencias));
 return 0;
}

Ejercicio 5
La denominada Criba de Eratóstenes es un método para determinar los números primos
entre 1 y N, siguiendo los siguientes pasos:

• Se escriben los números naturales entre 1 y N.
• Se deja el 1.
• Se deja el 2 y se tachan todos los demás números pares.
• Se deja el 3 y se tachan todos sus múltiplos.
• Como el 4 ya está tachado, pasamos al 5, que se deja y se tachan todos sus múltiplos (los del 5).
• ...

Así, cuando pasemos del 13, estarán tachados 14, 15 y 16, con lo que seguimos el proceso
en el 17. El proceso acaba cuando llegamos a la raíz cuadrada de N. Los números que
queden sin tachar, serán primos. La siguiente figura muestra este método aplicado del 1 al
100. Aparecen en blanco los números no marcados y que, por tanto, son primos.

Se pide crear una función denominada eratostenes que, mediante la criba descrita y
haciendo uso de arrays, debe tomar como parámetro un natural N menor o igual a 1000 e
imprimir por pantalla todos los números primos del 1 al N.

#include <iostream>
#include <math.h>
using namespace std;

const unsigned MAXIMO = 1000;
typedef unsigned TArray[MAXIMO];

unsigned leerN (){
 unsigned N;
 do{
 cout << "Introduce N: ";
 cin >> N;
 }while(N > 1000);
 return N;
}

void inicializar(TArray& array, unsigned N){
 for(unsigned i= 0; i < N; i++)
  array[i]=i+1;
}

void eliminar (TArray array, unsigned N){
 for(unsigned i= 2; i < N; i++){
  if(array[i] != 0){
   for(unsigned j = i+1; j < N; j++){
    if((j+1)%(i+1) == 0){
     array[j] = 0;
    }


   }



  }
 }
}

void mostrar(const TArray& array, unsigned N){
 for(unsigned i = 0;i < N; i++){
  if(array[i] != 0){
   cout << array[i] << " ";
  }
 }
}

int main() {
 unsigned dim = leerN();
 TArray array;
 inicializar(array, dim);
 eliminar(array, dim);
 mostrar(array, dim);
 return 0;
}

Ejercicio 6 
Para realizar operaciones con números complejos, podemos definir el siguiente tipo:

struct TComplejo {

double p_real, p_imaginaria;

} 

Escribir funciones que realicen las operaciones de suma, resta, multiplicación y división de números complejos definidos con el tipo anterior:

void sumar(TComplejo &resultado, const TComplejo &a, const TComplejo &b)

void restar(TComplejo &resultado, const TComplejo &a, const TComplejo &b)

void multiplicar(TComplejo &resultado, const TComplejo &a, const TComplejo &b)

void dividir(TComplejo &resultado, const TComplejo &a, const TComplejo &b)

Crear asimismo una función main que permita comprobar el correcto funcionamiento de las funciones anteriores.

#include  <iostream>
using namespace std;

struct TComplejo {
 double p_real, p_imaginaria;
};

void leerComplejo(TComplejo& complejo){
 cout << "Introduce parte real: ";
 cin >> complejo.p_real;
 cout << "Parte imaginaria: ";
 cin >> complejo.p_imaginaria;
}


void sumar(TComplejo &resultado, const TComplejo &a, const TComplejo &b){
 //(a + bi) + (c + di) = (a + c) + (b + d)i
 resultado.p_real= a.p_real +b.p_real;
 resultado.p_imaginaria= a.p_imaginaria + b.p_imaginaria;

}
void restar(TComplejo &resultado, const TComplejo &a, const TComplejo &b){
 resultado.p_imaginaria = a.p_imaginaria - b.p_imaginaria;
 resultado.p_real = a.p_real - b.p_real;
}
void multiplicar(TComplejo &resultado, const TComplejo &a, const TComplejo &b){
 //(a + bi) · (c + di) = (ac − bd) + (ad + bc)i
 resultado.p_real = (a.p_real*b.p_real)-(a.p_imaginaria*b.p_imaginaria);
 resultado.p_imaginaria = (a.p_real*b.p_imaginaria)+(a.p_imaginaria*b.p_real);
}
void dividir(TComplejo &resultado, const TComplejo &a, const TComplejo &b){
 resultado.p_real = ((a.p_real*b.p_real)+(a.p_imaginaria*b.p_imaginaria))/(b.p_real*b.p_real + b.p_imaginaria*b.p_imaginaria);
 resultado.p_imaginaria = (a.p_imaginaria*b.p_real-a.p_real*b.p_imaginaria)/(b.p_real*b.p_real + b.p_imaginaria*b.p_imaginaria);
}
void mostrarComplejo(TComplejo & a){
 cout << a.p_real << "+" << a.p_imaginaria <<"i" << endl;
}

int main() {
 cout << "Operaciones con números complejos." << endl;
 TComplejo a, b, resultado;
 cout << "Introduce dos numeros complejos a operar." << endl;
 leerComplejo(a);
 leerComplejo(b);
 cout << "Resultado de su suma: ";
 sumar(resultado, a, b);
 mostrarComplejo(resultado);
 cout << "Resultado de su resta: ";
 restar(resultado, a, b);
 mostrarComplejo(resultado);
 cout << "Resultado de su multiplicacion: ";
 multiplicar(resultado, a, b);
 mostrarComplejo(resultado);
 cout << "Resultado de su division: ";
  dividir(resultado, a, b);
  mostrarComplejo(resultado);


 return 0;
}