Ejercicios C++: Registros y arrays (II)

Dada una matriz bidimensional de N×M elementos de tipo entero, implementar un programa
que lea dicha matriz y visualice por pantalla el mayor elemento de la matriz junto con la fila
y columna en la que se encuentra. Si el elemento mayor aparece varias veces, se deja a
criterio del alumno cuál seleccionar.

#include <iostream>
using namespace std;

typedef int TFilas[100];
typedef TFilas TMatriz[100];

void leerDimension(unsigned& n, unsigned& m){
 cout << "Introduce número de filas: ";
 cin >> n;
 cout << "Introduce número de columnas: ";
 cin >> m;
}

void leerMatriz(TMatriz& matriz, unsigned nf, unsigned nc){
 cout << "Introduce los valores de la matriz."<< endl;
 for(unsigned f = 0; f < nf; f++){
  for(unsigned c= 0; c < nc; c++){
   //cout << "Fila "<< f+1 <<". Columna "<<c+1<<"->";
   cin >> matriz[f][c];
  }
 }
}

void buscarMayor(const TMatriz& matriz, unsigned nf, unsigned nc){
 int mayor = matriz[0][0];
 int columna=1, fila=1;

 for(unsigned f = 0; f < nf; f++){
  for(unsigned c= 0; c < nc; c++){
   if(matriz[f][c] > mayor){
    mayor = matriz[f][c];
    columna = c+1;
    fila = f+1;
   }
  }
 }

 cout << "El mayor elemento de la matriz es el " <<mayor << " situado en la fila "<<fila<< " y la columna "<<columna;

}

int main() {
 cout << "Buscar el mayor valor de una matriz." << endl; 
 unsigned n, m;
 TMatriz matriz;
 leerDimension(n,m);
 leerMatriz(matriz, n, m);
 buscarMayor(matriz, n, m);
 return 0;
}

Dada una matriz bidimensional de N×N elementos de tipo entero, implementar un programa que indique si esa matriz es simétrica. Una matriz es simétrica si aij = aji para todo i distinto de j con i, j =1,2,3,4,...,N.

#include <iostream>
using namespace std;

typedef int TFilas[100];
typedef TFilas TMatriz[100];

void leerDimension(unsigned& n){
 do{
 cout << "Introduce número de filas y columnas (<100) : ";
 cin >> n;
 }while(n < 1 || n > 100);
}

void leerMatriz(TMatriz& matriz, unsigned n){
 cout << "Introduce los valores de la matriz."<< endl;
 for(unsigned f = 0; f < n; f++){
  for(unsigned c= 0; c < n; c++){
   //cout << "Fila "<< f+1 <<". Columna "<<c+1<<"->";
   cin >> matriz[f][c];
  }
 }
}

bool simetrica(const TMatriz& matriz, unsigned n){
 bool a = true;
 for(unsigned i = 1; i<= n; i++){
  for(unsigned j = 1; j<= n; j++){
   if(i!=j){
    if(matriz[i][j]!=matriz[j][i]){
     a = false;
    }

   }
  }
 }
 return a;
}

int main() {
 cout << "Comprobar si una matriz es simétrica." << endl; // prints !!!Hello World!!!
 unsigned n;
 TMatriz matriz;
 leerDimension(n);
 leerMatriz(matriz, n);
 if(simetrica(matriz,n)){
  cout << "La matriz es simétrica.";
 }else{
  cout << "La matriz no es simétrica";
 }
 return 0;
}

Un cuadrado mágico de orden n es una ordenación de los números 1 a n2 en una tabla
cuadrada de manera que la suma de cada fila y cada columna y las dos diagonales
principales es la misma.
Sea typedef unsigned Cuadrado[N][N];
Diseñar la siguiente función:
bool Es_Magica(const Cuadrado& A);
// Devuelve true si A es un cuadrado mágico y false en caso contrario

#include <iostream>
using namespace std;

typedef unsigned TFilas[100];
typedef TFilas TMatriz[100];

void leerDimension(unsigned& n){
 do{
 cout << "Introduce número de filas y columnas (<100) : ";
 cin >> n;
 }while(n < 1 || n > 100);
}

void leerMatriz(TMatriz& matriz, unsigned n){
 cout << "Introduce los valores de la matriz."<< endl;
 for(unsigned f = 0; f < n; f++){
  for(unsigned c= 0; c < n; c++){
   //cout << "Fila "<< f+1 <<". Columna "<<c+1<<"->";
   cin >> matriz[f][c];
  }
 }
}

unsigned sumaFila(const TMatriz& matriz, unsigned n, unsigned fila){
 unsigned suma = 0;
 for(unsigned i = 0; i < n; i++){
  suma+= matriz[fila][i];

 }

 return suma;
}

bool sumaFilas(const TMatriz& matriz, unsigned n, unsigned& ant1){
 bool sumasNoIguales= true;
 unsigned i = 1;
 ant1 = sumaFila(matriz, n, 0);
 while(sumasNoIguales== true && i < n){
  if(ant1 == sumaFila(matriz,n, i)){
   sumasNoIguales = true;
  }else{
   sumasNoIguales = false;
  }
  i++;
 }
 if(sumasNoIguales== true){
   cout << "Suma de las filas: "<< ant1<< endl;
 }
 return sumasNoIguales;
}

unsigned sumaColumna(const TMatriz& matriz, unsigned n, unsigned columna){
 unsigned suma = 0;
  for(unsigned i = 0; i < n; i++){
   suma+= matriz[i][columna];

  }

  return suma;
}

bool sumaColumnas(const TMatriz& matriz, unsigned n, unsigned& ant2){
 bool a = true;
 unsigned i = 1;
 ant2 = sumaColumna(matriz, n, 0);
 while(a== true && i < n){
  if(ant2 == sumaColumna(matriz,n, i)){
   a = true;
  }else{
   a = false;
  }
  i++;
 }
 if(a== true){
  cout << "Suma de las columnas: "<< ant2<< endl;
 }
 return a;
}


unsigned sumaDiagonalP(const TMatriz& matriz, unsigned n){
 unsigned suma = 0;
 for(unsigned i = 0; i< n; i++){
   for(unsigned j = 0; j< n; j++){
    if(i==j){
     suma += matriz[i][j];
    }
   }
  }
 cout << "Suma diagonal principal: "<< suma << endl;
 return suma;
}

unsigned sumaDiagonalS(const TMatriz& matriz, unsigned n){
 unsigned suma = 0;
 unsigned j = n-1;
 for(unsigned i = 0; i < n; i++){
  suma += matriz[i][j];
  j--;
 }
 cout << "Suma diagonal secundaria: "<< suma << endl;
 return suma;
}

bool Es_Magica(const TMatriz& A, unsigned n, unsigned ant1, unsigned ant2){
 bool es=false;
 bool sumaFilasIgual, sumaColumnasIgual;
 sumaFilasIgual = sumaFilas(A, n, ant1);
 sumaColumnasIgual = sumaColumnas(A, n,ant2);

 if(ant1 == ant2){
 if(sumaFilasIgual== true && sumaColumnasIgual== true){

  if(sumaDiagonalP(A, n) == sumaDiagonalS(A,n) ){
    es = true;
   }
 }
 }
 return es;
}

int main() {
 cout << "Averiguar si es un cuadrado mágico." << endl; // prints !!!Hello World!!!
 unsigned n;
 TMatriz matriz;
 leerDimension(n);
 leerMatriz(matriz, n);
 unsigned ant1=0, ant2=0;
 bool es;
 es = Es_Magica(matriz,n,ant1,ant2);

 if(es){
  cout << endl;
  cout << "Es cuadro mágico.";
 }else{
  cout << endl;
  cout << "No es cuadrado mágico.";
 }






 return 0;
}

Para realizar operaciones con números complejos, podemos definir el siguiente tipo:
struct TComplejo {
double p_real, p_imaginaria;
}
Se pide implementar un programa que dado un array de números complejos, imprima por
pantalla el número complejo de mayor módulo.

#include <iostream>

#include <math.h>
using namespace std;

const unsigned MAXIMO = 2;

struct TComplejo {
 double p_real, p_imaginaria;
};

typedef TComplejo TArrayComplejos[MAXIMO];




void leerArray(TArrayComplejos& complejos){
 cout << "Introduce "<<MAXIMO<<" números complejos."<< endl;
 for(unsigned i=0; i < MAXIMO; i++){
  cout << i+1<<".Parte real: ";
  cin >> complejos[i].p_real;
  cout << i+1<<".Parte imaginaria: ";
  cin >> complejos[i].p_imaginaria;
 }
}
void mostrarComplejo(TComplejo  a){
 cout << a.p_real << "+" << a.p_imaginaria <<"i" << endl;
}
void mostrarArray(const TArrayComplejos& complejos){
 cout << "El array de números es: "<< endl;
 for(unsigned i=0; i< MAXIMO; i++){
  mostrarComplejo(complejos[i]);
 }
}

double moduloComplejo(TComplejo num){
 double modulo;
 modulo = sqrt(pow(num.p_imaginaria,2)+ pow(num.p_real, 2));
 return modulo;
}

void buscarMayor(const TArrayComplejos& complejos){
 double mayor = moduloComplejo(complejos[0]);
 TComplejo resultado = complejos[0];

 for(unsigned i=1; i <= MAXIMO; i++){
  if(moduloComplejo(complejos[i]) > mayor ){
   mayor = moduloComplejo(complejos[i]);
   resultado = complejos[i];
  }
 }




 cout << "El complejo de mayor módulo es ";
 mostrarComplejo(resultado);
 cout << endl;

}


int main() {
 cout << "Imprime por pantalla el número complejo de mayor módulo." << endl; // prints !!!Hello World!!!
 TArrayComplejos complejos;
 leerArray(complejos);
 mostrarArray(complejos);

 buscarMayor(complejos);

 return 0;
}

La regla para generar el cuadrado mágico (si n es impar) del ejercicio 3 es la siguiente:

Se empieza con 1 en la mitad de la primera fila, a continuación subir a la izquierda
diagonalmente (si en este proceso se pasa el borde del cuadrado hay que considerar
como si el plano entero estuviese recubierto con dicho cuadrado) hasta alcanzar una
casilla del cuadrado llena; a continuación bajar un espacio a partir del último
cuadrado que se rellenó y continuar.

Diseñar un algoritmo que construya un cuadrado mágico para cualquier constante N impar
dada. Construir un programa que solicite dicho valor al usuario y visualice su cuadrado
mágico por pantalla.

#include <iostream>

using namespace std;


typedef unsigned TFilas[100];
typedef TFilas TMatriz[100];

void leerDimension(unsigned& n){
 do{
 cout << "Introduce número de filas y columnas (<100) : ";
 cin >> n;
 }while(n < 1 || n > 100);
}

void inicializarMatriz(TMatriz& matriz, unsigned n){

  for(unsigned f = 0; f < n; f++){
   for(unsigned c= 0; c < n; c++){
    matriz[f][c] =0;
   }
  }
}

void CuadradoMagico(TMatriz& matriz, unsigned n){
 unsigned fila = 0;
 unsigned nfila;
 unsigned columna = unsigned(n/2);
 unsigned ncolumna;
 for(unsigned i=1; i <= n*n; i++){
  if(matriz[fila][columna] == 0){
   matriz[fila][columna] = i;
  } else {
   fila++;
   matriz[fila][columna] = i;
  }

  nfila = fila;
  ncolumna= columna;

   if(columna == 0){
    ncolumna = n-1;
   }else{
    ncolumna--;
   }

   if(fila == 0){
    nfila = n-1;
   }else{
    nfila--;
   }
  if(matriz[nfila][ncolumna] == 0){
   fila = nfila;
   columna= ncolumna;
  }else{
   //columna = ncolumna;
   fila++;
  }

 }
}

void imprimirMatriz(const TMatriz& matriz, unsigned n){
 for(unsigned f = 0; f < n; f++){
   for(unsigned c= 0; c < n; c++){
    cout <<"\t "<< matriz[f][c];
   }
   cout << endl;
  }
}



int main() {

 TMatriz matriz;
 unsigned n;
 leerDimension(n);
 inicializarMatriz(matriz, n);
 CuadradoMagico(matriz,n);
 imprimirMatriz(matriz, n);
 return 0;
}

Escribir un programa que lea una sucesión de 10 números naturales, encuentre el valor máximo y lo imprima junto con el número de veces que aparece, y las posiciones en que esto ocurre. El proceso se repite con el resto de la sucesión hasta que no quede ningún elemento por tratar.

Ejemplo de entrada: 7 10 143 10 52 143 72 10 143 7
Salida generada: 143 aparece 3 veces, en posiciones 3 6 9.
                        72 se repite 1 vez, en posición 7.
                         ...
                        7 aparece 2 veces, en posiciones 1 10.

#include  <iostream>
using namespace std;

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

void leerArray(TArray& numeros){
 cout << "Introduce 10 números naturales." << endl;
 for(unsigned i= 0; i < MAXIMO; i++ ){
  cin >> numeros[i];
 }
}
unsigned contarNumero(const TArray& numeros, unsigned num){
 unsigned contador=0;

 for(unsigned i= 0; i < MAXIMO; i++){
  if(numeros[i]== num){
   contador++;
  }
 }
 return contador;

}

void buscarPosiciones(const TArray& numeros, unsigned num, unsigned contador){
 unsigned i = 0;
 unsigned c= 0;

 if(contador == 1){
  cout << " vez, en la posición ";
 }else{
  cout << " veces, en posiciones ";
 }
 while(i < MAXIMO  && c <= contador){
  if(numeros[i]== num){
   cout << i +1 << " ";
   c++;
  }
  i++;
 }
 cout <<"" << endl;
}
unsigned buscarMayor(const TArray& numeros){
 unsigned mayor = numeros[0];
 for(unsigned i= 1; i < MAXIMO; i++){
  if(numeros[i] > mayor){
   mayor = numeros[i];
  }
 }
 return mayor;
}

void eliminarUsado(TArray& numeros, unsigned mayor){
 for(unsigned i= 0; i < MAXIMO; i++){
  if(numeros[i] == mayor){
   numeros[i] = 0;
  }
 }
}



int main() {
 unsigned mayor, contador;
 TArray numeros;
 leerArray(numeros);
 mayor = buscarMayor(numeros);

 while(mayor != 0){
  cout << mayor << " aparece ";
   contador = contarNumero(numeros, mayor);
   cout << contador;
   buscarPosiciones(numeros, mayor, contador);
   eliminarUsado(numeros, mayor);
   mayor = buscarMayor(numeros);
 }



 return 0;
}

Ale.