Estructuras de Datos

Estructuras de datos
Hasta ahora se han usado datos que representan valores de tipo simple como un nmero
entero, real carcter.
Sin embargo, en muchas situaciones se necesita procesar un conjunto de valores que estn
relacionados entre s por algn mtodo, por ejemplo, una lista de calificaciones, una serie
de temperaturas.
En este caso, el procesamiento con datos simples se hace muy difcil, por lo que la mayora
de los lenguajes de programacin incluyen caractersticas de estructuras de datos
En computacin, una estructura de datos es una manera de almacenar informacin (datos)
en un computador de manera que puedan ser usados de una manera eficiente.
Una seleccin cuidadosa de la estructura permitir usar un algoritmo ms eficiente. Una
estructura bien diseada permitir efectuar una variedad de operaciones, usando un
mnimo de tiempo de ejecucin y espacio de memoria.
Los tipos de datos mas utilizados son:
Datos SIMPLES
Datos ESTRUCTURADOS
Entero
Real
Carcter
Lgico
Arreglos
Registros
Archivos
Las estructuras de datos estticas son aquellas en las que el tamao ocupado en memoria
se define antes de que el programa se ejecute y no puede modificarse dicho tamao durante
la ejecucin del programa.
Las estructuras dinmicas pueden ser definidas en tiempo de ejecucin y la limitacin
seria el tamao de la memoria disponible.
1.1. Arreglos Unidimensionales - NDimensionales.
Un arreglo es una secuencia de posiciones consecutivas de memoria que almacenan datos
del mismo tipo.Estos datos comparten un nombre comn.
En cuanto a su dimensin ,los arreglos se pueden clasificar como :
Unidimensionales:
Vector, lista, matriz de una dimensin.
Ej : Un vector denominado ventas, de 10 elementos, se puede representar como :
ventas[1]
ventas[2]
ventas[3]
ventas[10]
El subndice de cada elemento designa su posicin en la ordenacin del vector. Se observa

que todos los elementos comparten el nombre y que cada elemento se referencia por su
subndice o sea su posicin relativa en el vector.
Declaracin de un arreglo Unidimensional :

Esttico :
tipo nombre [dimensin]
Ej : la instruccin entero x[8] declara un arreglo de nombre x, de 8 elementos de tipo
entero.
Bidimensionales (Tabla, Matriz ) :
Se pueden considerar como un vector de vectores. En este caso se necesita especificar dos
subndices para identificar cada elemento del arreglo : El primer subndice se refiere a las
filas ( i ) y el segundo a las columnas ( j ) .
Declaracin de un arreglo de dos dimensiones :
Esttico :
tipo nombre [filas, coumnas]
Ej : entero A [3,3] declara un arreglo de datos tipo entero de 3 filas y tres columnas.
Almacenamiento de arreglos en memoria

Arreglos de Una y dos dimensiones se representan como se muestra:
A[1]
A[2]
A[3]
A[4]
...
A[n]
A[1,1]
A[1,2]
A[1,3]
A[1,4]
...
A[1,n]
A[2,1]
A[2,2]
A[2,3]
A[2,4]
...
A[2,n]
A[3,1]
A[3,2]
A[3,3]
A[3,4]
...
A[3,n]
A[m,1]
A[m,2]
A[m,3]
A[m,4]
A[m,n]
La memoria de la computadora es unidimensional, por lo que el almacenamiento de los

arreglos de ms de una dimensin requiere que la posicin de los elementos del arreglo sea
"linealizada".
La forma mas comn de almacenamiento de vectores de dos dimensiones es por filas, as un
vector A[3,4] se almacenara de la manera siguiente:
1
A[1,1]
2
A[1,2]
3
A[1,3]
4
A[1,4]
5
A[2,1]
6
A[2,2]
7
A[2,3]
8
A[2,4]
9
A[3,1]
La posicin de un elemento A[i,j] del arreglo A[3,4] de dimensiones [m,n] con relacin al
primer elemento es: Posicin = n*(i -1) + j
As la posicin dentro del arreglo del elemento A[2,3] del ejemplo anterior sera:
m = 3, n = 4, i = 2, j = 3 Posicin = 4 * (2 - 1) + 3 = 7
Operaciones sobre arreglos

Las operaciones que se pueden realizar con arreglos durante el proceso de resolucin de un
problema son:
Asignacin
Lectura / Escritura
Recorrido
Bsqueda
Ordenamiento.
Asignacin :
La asignacin de valores a un elemento de un arreglo se representa con la instruccin:
A[10] = 3 / asigna el valor 3 al elemento 10 del vector A
ventas[2,2] = 1500
Si se desea asignar valores a todos los elementos de un vector, se debe usar estructuras de
repeticin.
Caso Unidimensional: Asignar el valor 6 a todos los elementos de un vector A[5]
repetir_desde ( i = 1; i <= 5 ; i=i+1)

A[i] = 6
fin_repetir_desde
Caso Bidimensional: Inicializar un vector B[2,3] con el valor cero.
repetir_desde ( i = 1; i <= 2 ; i=i+1)

repetir_desde ( j = 1; j <= 3 ; j=j+1)
B[i,j] = 0
fin_repetir_desde
fin_repetir_desde
Lectura / Escritura :
La lectura/escritura de datos en arreglos u operaciones de entrada/salida, normalmente se
realizan con estructuras repetitivas o selectivas. Las instrucciones simples de
lectura/escritura se representan como:
leer(Nombre_del_arreglo[Indice])
mostrar(Nombre_del_arreglo[Indice])
Ej : leer(X[3]) / Lee el elemento 3 del vector X
Recorrido :
A la operacin de efectuar alguna accin sobre todos los elementos del vector se le llama
recorrido. Estas operaciones se realizan usando estructuras de repeticin,
cuyas variables de control se usan como ndices del vector. Se puede realizar esta operacin
para introducir datos al vector (leer) o para ver su contenido (mostrar).
Ejemplo 1: Lectura de los 10 valores de un vector P.
Ejemplo 2: El siguiente algoritmo lee las notas del primer examen de Computacin de una
seccin de 40 alumnos , a fin de calcular el promedio.
Si se deseara mostrar la cantidad de alumnos con notas superiores al promedio se agregan

las siguientes lneas al algoritmo anterior:
Ejemplo 3: Leer una matriz de dos dimensiones A[5,4].

Dado que es una matriz de dos dimensiones, se necesitan dos bucles anidados para recorrer
todos sus elementos.
Ejemplo 4: Inicializar una matriz de dos dimensiones con valor constante 0.

El algoritmo debe asignar la constante 0 a todos los elementos de la matriz A[5,4].
Dado que es una matriz de dos dimensiones, se necesitan dos bucles anidados para recorrer
todos sus elementos:
Ejemplo 5: Realizar la suma de dos matrices bidimensionales.

Para sumar dos matrices es preciso que las dos matrices tengan las mismas dimensiones. La
matriz suma[I,J] tendr las mismas dimensiones de las matrices sumandos y cada elemento
ser la suma de los mismos elementos correspondientes en las matrices sumandos:
suma[I,J] = A[I,J] + B[I,J].
Dado que las matrices son de dos dimensiones se requieren dos bucles anidados:
Ejemplo 6: Disear un algoritmo que genere una matriz identidad de orden n.
La matriz identidad tiene todos los elementos de la diagonal principal igual a uno
(1), todos los dems elementos son igual a cero (0).
En los elementos de la diagonal principal I = J.
Algoritmos Bsicos de Bsqueda y Ordenamiento

Bsqueda :
La operacin de bsqueda es una de las tareas ms comunes en computacin y bsicamente

consiste en encontrar la posicin de un elemento especfico en un conjunto de elementos
dados.
Bsqueda secuencial :
Suponemos una lista (vector) de elementos, donde no hay elementos repetidos ; la forma
mas sencilla de buscar un elemento especfico es recorriendo la lista y verificando si existe
alguna coincidencia entre los elementos de la lista y el elemento buscado.
Ejemplo: Suponemos se desea buscar un nombre en una lista de n elementos. El algoritmo
debe mostrar los mensajes :
- nombre encontrado, si el nombre est en la lista.
- nombre no existe, si no se encuentra el nombre.
Se supone que no hay elementos repetidos.
Anlisis : Se requiere leer el nmero de elementos ( n ) y el elemento a buscar. Se debe
recorrer toda la lista y preguntar si cada elemento de la lista es el que estamos buscando,
para lo cual se requiere un ciclo con contador (i - desde 1 hasta n) y una estructura de
decisin para confirmar la condicin del elemento buscado.
Se usa adems una variable tipo interruptor (sw) , la cual se incializa en cero antes de
comenzar el ciclo de bsqueda y se cambia a uno cuando se encuentra el nombre buscado.
Diseo del algoritmo :
Bsqueda Menor / Mayor :

El problema consiste en buscar el elemento menor/mayor de un conjunto de elementos
almacenados en un arreglo. Por ejemplo, buscar el elemento mayor del vector A mostrado:
Anlisis :
La estrategia a seguir consiste en asignar la condicin deseada (MAYOR) al primer
elemento de la lista (A[1]) y se empieza a comparar con todos los elementos de la lista. Si
alguno de los elementos resulta mayor que el elemento al cual se le ha asignado la
condicin, se cambia la condicin al nuevo elemento. Al terminar de recorrer todo el vector,
el valor que mantiene la condicin deseada es el mayor.
Los resultados sobre el ejemplo se podran ver como sigue:
Diseo del algoritmo:
Ordenamiento
El ordenamiento es una labor comn que realizamos continuamente y es algo tan corriente
en nuestras vidas que no nos detenemos a pensar en ello. Ordenar es simplemente
organizar informacin de una manera especificada (criterio de ordenamiento).
El ordenamiento puede ser:
Interno : La operacin se realiza en memoria central. (Arreglos)
Externo: La operacin se realiza sobre un soporte externo (Archivos).
En la computacin el ordenamiento de datos tambin cumple un rol muy importante, ya
sea como un fin en s o como parte de otros procedimientos ms complejos. Se han
desarrollado muchas tcnicas en este mbito, cada una con caractersticas especficas, y con
ventajas y desventajas sobre las dems.
Mtodo de Intercambio o de burbuja:
El algoritmo se basa en el principio de comparar pares de elementos e intercambiarlos entre

s hasta que estn todos ordenados.
Para intercambiar dos elementos A[i] y A[i+1], es necesario considerar una variable
auxiliar, usando el siguiente procedimiento:
aux = A[i]
A[i] = A[i+1]
A[i+1] = aux
Ejemplo:
Aplicaciones sobre Arreglos

1.- Dados tres arreglos A, B, C de n elementos enteros cada uno, generar un cuarto arreglo D
de tres elementos, donde el contenido de cada elemento sea la suma de los elementos de A ,
B y C, es decir : D[1] = A[1]+ A[2]+ A[3]+A[n]..
Diseo del Algoritmo :
Algoritmo Creacin de Arreglo
Inicio
2.- Un vendedor que hizo 20 ventas en el da desea calcular su comisin total sobre las
ventas diarias, sabiendo que le corresponde un 5% de comisin sobre artculos
cuyo precio es menor de 10000 Bs.y el 10% de comisin por artculos cuyo precio = 10000
Bs. mas.Adems,el vendedor desea saber cuantas ventas hizo menores de 10000 y cuntas
de 10000 mas.
El algoritmo debe permitir realizar los diferentes procesos como opciones a escoger por el
usuario, como un dato de entrada.
Diseo del Algoritmo:
Algoritmo Clculo de comisin
Inicio
entero i,cont_menor, cont_mayor, opcin
real precio[20], comisin, comisin_total
caracter respuesta
cont_menor = 0, cont_mayor = 0,comisin_total = 0
respuesta = "s"
Repetir mientras (respuesta == "s")
Mostrar ("Introduzca su opcin : 1.- Leer arreglo de precios
2.- Calcular comisin
3.- Mostrar resultados " )
Leer (opcin)
En caso de (opcion)
caso 1 :
Repetir desde ( i= 1; i <=20) ; i=i+1)
Mostrar ( " Introduzca el precio del artculo ", i )
Leer ( precio[i] )
Fin Repetir desde
caso 2 :
Repetir desde ( i= 1; i <=20) ; i=i+1)
Si ( Precio [i]< 10000)
comisin = 0.05*precio[i]
cont_menor = cont_menor + 1
sino
comisin = 0.10*precio[i]
cont_mayor = cont_mayor + 1
Fin Si
comisin_total = comisin_total + comisin
Fin Repetir desde
caso 3 :
Mostrar ( "Artculos vendidos con precio inferior a 10000 :",
cont_menor )
Mostrar ( "Artculos vendidos con precio superior a 10000 :",
cont_mayor )
Mostrar (" Comisin total del vendedor = ", comisin_total )
Fin En caso de
Mostrar (" Desea continuar : s/n ")
Leer (respuesta )
Fin Repetir mientras
Fin
3.- Un tablero de damas se puede representar con un arreglo de 8 filas por 8 columnas,
donde un 1 representa la presencia de una ficha roja en el tablero, un 2 representa la
presencia de una ficha negra y un tres representa ausencia de ficha.
Se requiere calcular y mostrar :
El nmero de fichas rojas , el nmero de fichas negras y el nmero total de fichas.
4.- Se tiene el monto de cada una de 100 ventas realizadas por una vendedora de un
establecimiento comercial. Por cada venta calcule : el IVA de 15.5 %, calcule y muestre el
monto a pagar incluyendo el IVA, calcule y muestre el monto total en ventas y monto total
en impuesto por todas las 100 ventas.
Anlisis:
EL dato sera un vector VENTAS[100], el cual contiene los montos de las 100
ventas.
Se debe generar un vector IVA[100],haciendo IVA[I] = VENTAS[I]*0.155.
El monto a pagar de cada venta se guarda en un vector MONTO[100]. Este vector se

calcula haciendo MONTO[I] = Ventas[I] + IVA[I].
El monto total en ventas (T_VENTAS) se obtiene sumando los elementos del vector
MONTO[100].
El monto total de impuesto (T_IMP) se obtiene sumando los elementos del vector
IVA[100].
Se requiere calcular el vector IVA para lo cual es necesario recorrer el vector ventas
y multiplicar cada elemento por el 15.5 %.
Dentro del mismo ciclo se puede calcular el vector MONTO.
5.-Llenar un vector de n elementos con los primeros n valores enteros y primos.

Anlisis:
Un nmero primo es aquel que es divisible nicamente por el mismo y la unidad.

Para chequear si un numero es divisible por otro se usa la funcin mod, la cual devuelve
el resto de la divisin : si (A mod B = 0 ),el nmero A es divisible por B.
Para verificar si un nmero es primo se comprueba la divisin del nmero por todos
los valores enteros que estn por debajo de el, excluyendo la unidad y el nmero mismo.
Los nmeros 1,2 y 3 son primos.
6.-Generar la siguientes matrices:
Anlisis:
las matrices se almacenan como se muestra:
La matriz A se recorre por filas y se asigna a cada elemento un valor que puede ser
un contador inicializado en 1.
La matriz B se recorre por columnas y se asigna a cada elemento un valor que puede
ser el contador inicializado en 1.
La matriz C se crea utilizando un criterio (i == j) para llenarla.
Ejercicios propuestos
ESTRUCTURAS DE DATOS (ARREGLOS)
1. Escriba un algoritmo que lea una lista de N nmeros reales y calcule el promedio de estos
nmeros.
2. Si XPR representa la media de los numero X1, X2, X3,.XN, la varianza es la media de
los cuadrados de las desviaciones de los nmeros de la media y la desviacin estndar es la
raz cuadrada de la varianza:
Escriba un algoritmo que lea una secuencia de nmeros reales y a continuacin calcule y
muestre su media, varianza y desviacin estndar.
3. Escriba un algoritmo que lea un vector de nmeros enteros y determine el valor mximo
y el valor mnimo.
4. Disee un algoritmo que lea una lista de nmeros reales y calcule la media de los
nmeros de posiciones pares y la media de los nmeros de posiciones impares.
5. Escriba un algoritmo que lea una matriz NxN de nmeros enteros y determine la posicin
de la matriz en la que se encuentra el valor mximo.
6. Escriba un algoritmo que efecte la suma y la resta de dos matrices NxM de nmeros
reales.
7. Una agencia de ventas de vehculos distribuye 10 modelos y tiene contratados 15
vendedores. Escribir un algoritmo que calcule y muestre una tabla resumen donde se
muestre:
a. Cuantos autos coloc cada vendedor.
b. Cuantos autos se vendieron, por modelo.
c. Cual modelo se vendi menos.
d. Organizar la informacin de manera que se muestre en forma creciente las ventas totales
por vendedor.
8. Disee un algoritmo que lea un vector de 500 elementos enteros y a partir de ese vector
genere un nuevo vector con un mximo de 30 elementos, donde cada elemento es primo.
Autor:
Pablo Turmero
Comentarios
Leer ms: http://www.monografias.com/trabajos100/diseno-algotirmos-arreglos/diseno-algotirmosarreglos.shtml#ixzz4VJREmcnBEl siguiente es el primer ejercicio que hice con matrices. Quizs
alguno de estos ejercicios te puedan servir como una base.

Puedes leer el post anterior sobre vectores, matrices y punteros si an no haz trabajo con ellos.
Recomiendo que intentes y practiques mucho antes de copiar y pegar. Si te sientes estancado
en algn problema recin trata de buscar una gua para llegar a la solucin.
Esta clase matriz tendr 3 atributos: Matriz, nmero de filas y nmero de columnas. Tiene un
constructor por defecto, constructor copia y un constructor por parmetro que recibe el nmero
de filas y columnas.
Las siguientes funciones fueron implementadas:
Generar una matriz dinmicamente
LLenar la matriz desde teclado:
Llenar la matriz aleatoriamente:
Imprimir la matriz
Hallar el mayor elemento.
Hallar el menor elemento.
Hallar la moda.
Intercambiar filas.
Intercambiar columnas.
Sumar otra matriz: Sumar 2 objetos de tipo matriz retornar otra matriz. Ejem: c = a + b.
Restar otra matriz: Igual que la suma. Ejem: c = a b
Multiplicar por otra matriz: Ejem: c = a * b. El nro de filas de a debe ser igual al nro de
columnas de b
Multiplicar por un escalar: Ingreso un nmero y todos los elementos de la matriz se

multiplican por ese nmero.
Hallar matriz transpuesta: matr[m][n] su transpuesta es matr[n][m]. Se obtiene

cambiando filas por columnas. Donde los elementos de la fila m ahora pertenecen a la
columna m de la transpuesta.
Verificar si es simtrica: Una matriz es simtrica si es cuadrada(filas = columnas) y

cuando su transpuesta es igual a su matriz original.
Verificar si es identidad: Es identidad si tiene todos sus elementos nulos excepto los de
la diagonal principal que son iguales a 1.
NOTA: He aplicado un poco de templates para manejar la matriz con varios tipos de datos (int,
float, char, double) y sobrecarga de operadores para la suma, resta y multiplicacin de
matrices.
Recien estoy aprendiendo a usar estas 2 caractersticas importantes del lenguaje (templates y
sobrecarga de operadores).
En breve:
Un template es una manera de que funciones, clases, mtodos puedan ser usados con varios
tipos de datos. Imagnense crear una lista de datos y tener que crear funciones insertar,
eliminar, buscar, concatenar, etc para cada tipo de dato. Si los mtodos y la clase tienen la
misma lgica para que reescribir cdigo si podemos reutilizar.
La sobrecarga de operadores es una manera de realizar las mismas operaciones que solemos
hacer con tipos de datos comunes con tipos abstractos de datos. Por ejemplo, la sobrecarga
me permiti sumar 2 objetos de tipo Matriz y almacenar el resultado en otro objeto Matriz, del
modo c = a + b
Aqu est la definicin e implementacin de la clase Matriz.
matrix.h
#ifndef MATRIX_H
1
#define MATRIX_H
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <time.h>
#include <stdlib.h>
using namespace std;
template <class T>
class Matrix {
public:
Matrix();
Matrix(int, int);
Matrix(const Matrix &m);
~Matrix();
Matrix<T> operator+ (const Matrix &matrix_2);
Matrix<T> operator- (const Matrix &matrix_2);
Matrix<T> operator* (const Matrix &matrix_2);
bool isSymmetric();
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
bool isIdentity();
T get_max();
T get_min();
T get_mode();
void
void
void
void
void
void
void
void
delete_matrix();
fill_by_user();
fill_random();
get_transpose();
multiply_by_scalar(T);
print_matrix();
swap_cols(int, int);
swap_rows(int, int);
private:
T m_ele;
T m_max;
T m_min;
T m_mode;
T **m_matrix;
};
int m_dim_matrix;
int m_cols;
int m_rows;
#endif // MATRIX_H
matrix.cpp
#include "matrix.h"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Constructor por defecto

template<typename T>
Matrix<T>::Matrix()
{
m_rows = 4;
m_cols = 4;
}
// Constructor copia
Matrix<T>::Matrix(const Matrix &m)
{
*this = m;
}
// Constructor por parmetro
Matrix<T>::Matrix(int rows , int cols)
{
m_cols = cols;
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
m_rows = rows;
m_matrix = new T*[m_rows];
for (int i = 0; i < m_rows; i++) {
m_matrix[i] = new T[m_cols];
}
}
// Suma de matrices con sobrecarga de operadores

Matrix<T> Matrix<T>::operator+ (const Matrix &matrix_2)
{
Matrix matrix_result(m_rows, m_cols);
for (int j = 0; j < m_cols; j++) {
matrix_result.m_matrix[i][j] = m_matrix[i][j] + matrix_2.m_matrix[i]
}
}
return matrix_result;
}
// Resta de matrices con sobrecarga de operadores

Matrix<T> Matrix<T>::operator- (const Matrix &matrix_2)
{
matrix_result.m_matrix[i][j] = m_matrix[i][j] - matrix_2.m_matrix[i]
}
}
}
// Multiplicacin de matrices con sobrecarga de operadores
Matrix<T> Matrix<T>::operator* (const Matrix &matrix_2)
{
Matrix matrix_result(m_rows, matrix_2.m_cols);
T total;
for (int j = 0; j < matrix_2.m_cols; j++) {
for (int k = 0; k < m_cols; k++) {
total += (m_matrix[i][k] * matrix_2.m_matrix[k][j]);
}
matrix_result.m_matrix[i][j] = total;
// Limpiar el total sumado arriba
total = 0;
}
}
}
// Verificar si una Matriz es simtrica

bool Matrix<T>::isSymmetric()
{
if (m_rows != m_cols) {
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
return false;
}

if (m_matrix[i][j] != m_matrix[j][i]) {
return false;
}
}
}
return true;
// Verificar si una Matriz es identidad

bool Matrix<T>::isIdentity()
{
return false;
}

if (i == j) {
if (m_matrix[i][j] != 1)
return false;
} else {
return false;
}
}
}
return true;
// Obtener el mayor de la Matriz

T Matrix<T>::get_max()
{
if (m_matrix[i][j] > m_max) {
m_max = m_matrix[i][j];
}
}
}
return m_max;
}
// Obtener el menor de la Matriz
T Matrix<T>::get_min()
{
if (m_matrix[i][j] < m_min) {
m_min = m_matrix[i][j];
}
}
}
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
return m_min;
}
// Obtener la moda de la Matriz
T Matrix<T>::get_mode()
{
// Creo una Matrix auxiliar
Matrix matrix_aux(m_rows, m_cols);
// Lleno la Matriz con ceros
matrix_aux.m_matrix[i][j] = 0;
}
}
m_dim_matrix = m_rows * m_cols;
// Para retener una fila n veces
int y = 0;
// Para retener una columna n veces
int z = 0;
// Empiezo a comparar cada elemento n veces
for (int x = 0; x < m_dim_matrix; x++) {
if (m_matrix[y][z] == m_matrix[i][j]) {
matrix_aux.m_matrix[i][j]++;
}
}
}
// Pasar a la siguiente columna despues de n comparaciones
z++;
/* Empiezo a comparar con la siguiente fila
despues empiezo nuevamente en la 1era columna
Y luego paso a la siguiente fila */
if (z == m_cols) {
z = 0;
y++;
}
}
// Obtengo el mayor valor de la Matriz
m_max = matrix_aux.get_max();
// Si ningun valor se ha repetido ms de una vez, entonces no hay moda
if (m_max == 1) {
return -1;
} else {
if (matrix_aux.m_matrix[i][j] == m_max) {
m_mode = m_matrix[i][j];
}
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
}
}
return m_mode;
void Matrix<T>::delete_matrix()
{
delete[] m_matrix[i];
}
delete[] m_matrix;
}
// Llenar una Matriz desde teclado
void Matrix<T>::fill_by_user()
{
cout << "Fila " << i + 1 << endl;
cout << "Ingresa el elemento " << j + 1 << endl;
cin >> m_ele;
m_matrix[i][j] = m_ele;
}
cout << endl;
}
m_max = m_matrix[0][0];
m_min = m_matrix[0][0];
}
// Llenar aleatoriamente una Matriz
void Matrix<T>::fill_random()
{
m_matrix[i][j] = rand() % 30;
}
}
srand(time(NULL));
}
// Obtener la transpuesta de una Matriz
void Matrix<T>::get_transpose()
{
Matrix matrix_result(m_cols, m_rows);
for (int i = 0; i < m_cols; i++) {
for (int j = 0; j < m_rows; j++) {
matrix_result.m_matrix[i][j]= m_matrix[j][i];
}
}
matrix_result.print_matrix();
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
}
// Multiplicar a una Matriz por un escalar
void Matrix<T>::multiply_by_scalar(T scalar)
{
m_matrix[i][j] = m_matrix[i][j] * scalar;
}
}
cout << "Se multiplic a la Matriz por el escalar " << scalar << endl;
}
// Imprimir Matriz
void Matrix<T>::print_matrix()
{
cout << m_matrix[i][j] << " ";
}
cout << endl << endl;
}
}
// Intercambiar dos columnas en una Matriz
void Matrix<T>::swap_cols(int col_1, int col_2)
{
if (col_1 > m_cols || col_2 > m_cols) {
cout << "Esa columna se encuentra fuera de rango." << endl;
} else {
T temp;
col_1--;
col_2--;
endl;
}
}

temp = m_matrix[i][col_1];
m_matrix[i][col_1] = m_matrix[i][col_2];
m_matrix[i][col_2] = temp;
}
cout << "Se intercambiaron las columnas " << col_1 + 1 << " y " << col_2 +
// Intercambiar dos filas en una Matriz

void Matrix<T>::swap_rows(int row_1, int row_2)
{
if (row_1 > m_rows || row_2 > m_rows) {
cout << "Esa fila se encuentra fuera de rango." << endl;
} else {
T temp;
row_1--;
row_2--;
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
temp = m_matrix[row_1][i];
m_matrix[row_1][i] = m_matrix[row_2][i];
m_matrix[row_2][i] = temp;
}
cout << "Se intercambiaron las filas: " << row_1 + 1 << " y " << row_2 +
endl;
}
}
Matrix<T>::~Matrix() {}
319
320
321
322
323
324
325
326
327
328
329
330
main.cpp
#include <iostream>
1
#include "matrix.h"
2
#include "matrix.cpp"
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

int main()
{
// Para no generar los mismos nmeros aleatorios
srand(time(NULL));
int n_rows;
int n_cols;
int
int
int
int
int
col_1;
col_2;
row_1;
row_2;
scalar;
cout << "Ingresa nro de filas: " << endl;

cin >> n_rows;
cout << "Ingresa nro de columnas: " << endl;
cin >> n_cols;
cout << endl;
Matrix<int> a(n_rows, n_cols);
Matrix<int> b(n_rows, n_cols);
// Matriz para almacenar el resultado de las operaciones
Matrix<int> c(n_rows, n_cols);
a.fill_random();
b.fill_random();
cout << "********** Operaciones bsicas con la Matriz A **********" << endl;
cout << "Matriz A " << endl;
a.print_matrix();
cout
cout
cout
cout
<<
<<
<<
<<
"El mayor de la Matriz es: " << a.get_max() << endl;

"El menor de la Matriz es: " << a.get_min() << endl;
"La moda de la Matrix es: " << a.get_mode() << endl;
(a.isSymmetric() ? "" : "No") << " Es simtrica." << endl;
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
cout << (a.isIdentity() ? "" : "No") << " Es identidad." << endl;
cout << endl;
cout << "Ingresa el escalar: " << endl;
cin >> scalar;
a.multiply_by_scalar(scalar);
a.print_matrix();
cout << "Intercambio: Ingresa 2 columnas del 1 al " << n_cols << endl;
cout << "Columna 1: " << endl;
cin >> col_1;
cin >> col_2;
a.swap_cols(col_1, col_2);
a.print_matrix();
cout << "Intercambio: Ingresa 2 filas del 1 al " << n_rows << endl;
cout << "Fila 1: " << endl;
cin >> row_1;
cin >> row_2;
a.swap_rows(row_1, row_2);
a.print_matrix();
cout << "Transpuesta de A " << endl;
a.get_transpose();
cout << "********** Operaciones con matrices **********" << endl;
a.print_matrix();
cout << "Matriz B " << endl;
b.print_matrix();
cout << "Matriz A + B " << endl;
c = a + b;
c.print_matrix();
cout << "Matriz A - B " << endl;
c = a - b;
c.print_matrix();
cout << "Matriz A * B " << endl;
c = a * b;
c.print_matrix();
a.delete_matrix();
b.delete_matrix();
c.delete_matrix();
return 0;
88
89
90
91
92
93
94
95
Particularmente, todos los ejercicios no son nada difciles de resolver, pero yo me estanqu en
la moda y fue el problema que me hizo pensar un rato.
Lo resolv, pero sinceramente no me siento bien con la solucin. No me gust porque tiene una
complejidad de O(n2) y con una matriz muy grande puede tarda mucho debido al nmero de
recorridos y comparaciones.
La solucin consisti en:
Crear otra matriz auxiliar con el mismo nro de filas columas y llenarla con ceros.
Recorrer la matriz original e ir comparando el primer elemento con todos los otros
elementos de la matriz y contar sus repeticiones y as sucesivamente con los dems
elementos.
Si encuentro una repeticin, incremento en uno el valor en esa posicin de la matriz

auxiliar.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Luego hallar el mayor elemento de la matriz auxiliar.

Y finalmente recorrer la matriz auxiliar, cuando algn elemento de esta matriz sea igual
al mayor elemento, quiere decir, que ese fue el elemento que ms se repiti en la matriz
original. Por lo tanto la moda se encuentra en esa posicin.
Matriz original
17 16 10 26
10 3 9 19
29 7 1 6
6 20 0 10
Matriz auxiliar al inicio
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
Matriz auxiliar despues de las comparaciones
con el nro de repeticiones de los valores
1 1 3 1
3 1 1 1
1 1 1 2
2 1 1 3
La moda de la matriz es: 10,

3 es el valor maximo que se repite en la matriz
Y en las posiciones en que se encuentra 3 se encuentra 10 en la matriz original.
Un tip que me di el profe es reducir el nro de comparaciones creando una matriz booleana e ir
poniendo unos y ceros a los nmeros que ya compar para luego no volver a comparar con los
nmeros que compar anteriormente. Voy a seguir resolviendo el problema,si alguien tiene otra
solucin y puede explicarla fantstico.
El cdigo fuente de este y otros ejercicios de C++ est disponible en

Github:
https://github.com/ronnyml/C---Tutorial
Gracias por tu visita al blog. Puedes seguirme en Twitter haciendo click en el siguiente enlace:
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
#ifndef MATRIX_H
#define MATRIX_H
#include <iostream>
#include <time.h>
#include <stdlib.h>
template <class T>
class Matrix {
public:
Matrix();
Matrix(int, int);
~Matrix();
bool isSymmetric();
bool isIdentity();
T get_max();
T get_min();
T get_mode();
void
void
void
void
void
void
void
void
delete_matrix();
fill_by_user();
fill_random();
get_transpose();
print_matrix();
private:
T m_ele;
T m_max;
T m_min;
T m_mode;
T **m_matrix;
int m_dim_matrix;
int m_cols;
int m_rows;
};
#endif // MATRIX_H
45
46
47
48
49
50
matrix.cpp
#include "matrix.h"
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

Matrix<T>::Matrix()
{
m_rows = 4;
m_cols = 4;
}
{
*this = m;
}
{
m_cols = cols;
m_rows = rows;

}

{
}
}
}

{
}
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
}

{
T total;
}
total = 0;
}
}

{
return false;
}

return false;
}
}
}
return true;

{
return false;
}
if (i == j) {
return false;
} else {
return false;
}
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
}
}
return true;
}
{
}
}
}
return m_max;
}
{
}
}
}
return m_min;
}
{
}
}
int y = 0;
int z = 0;
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
}
}

z++;

if (z == m_cols) {
z = 0;
y++;
}

if (m_max == 1) {
return -1;
} else {
}
}
}
}
return m_mode;
{
}
delete[] m_matrix;
}
{
cout << "Fila " << i + 1 << endl;
cin >> m_ele;
}
cout << endl;
}
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
}
{
}
}
srand(time(NULL));

{

}
}

{
}
}
}
// Imprimir Matriz
{
}
}
}
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
{
} else {
T temp;
col_1--;
col_2--;
}
endl;
}
}
{
} else {
T temp;
row_1--;
row_2--;
endl;
}
}

}
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
main.cpp
#include <iostream>
1
#include "matrix.h"
2
3
4
5
6
7
8
9
10
11
12

int main()
{
srand(time(NULL));
int n_rows;
int n_cols;
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
int
int
int
int
int
col_1;
col_2;
row_1;
row_2;
scalar;

cin >> n_rows;
cin >> n_cols;
cout << endl;
a.fill_random();
b.fill_random();
a.print_matrix();
cout
cout
cout
cout
cout
cout
<<
<<
<<
<<
<<
<<

(a.isIdentity() ? "" : "No") << " Es identidad." << endl;
endl;

cin >> scalar;
a.print_matrix();
cin >> col_1;
cin >> col_2;
a.print_matrix();
cin >> row_1;
cin >> row_2;
a.print_matrix();
a.get_transpose();
a.print_matrix();
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

b.print_matrix();
c = a + b;
c.print_matrix();
c = a - b;
c.print_matrix();
c = a * b;
c.print_matrix();
a.delete_matrix();
b.delete_matrix();
c.delete_matrix();
return 0;
}
elementos.

auxiliar.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Matriz original
17 16 10 26
10 3 9 19
29 7 1 6
6 20 0 10
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
1 1 3 1
3 1 1 1
1 1 1 2
2 1 1 3

Github:
Gracias por tu visita al blog. Puedes seguirme en Twitter haciendo click en el siguiente enlace
Practica 10: Ejercicios con Arreglos unidimensionales.

Materia: Lgica Computacional.
Profesor: Lic. Salomn Aquino.
I. Objetivo. Al finalizar la prctica el estudiante ser capaz de:
Definir estructuras de datos y arreglos.
Utilizar arreglos en una dimensin para resolver problemas.
II. Introduccin Terica.
Los Arreglos (Vectores o Array)
Un array (lista o tabla9 es una secuencia de datos del mismo tipo. Los datos
se llaman elementos del array y se numeran consecutivamente 0, 1, 2, 3, ,,
etc. Estos nmeros se denominan valores ndice o subndice del array. El
tipo de elementos almacenados en el array pueden ser cualquier tipo de
dato de C, incluyendo estructuras definidas por el usuario.

Entonces, podemos entender los arrays (tambin conocidos como arreglos o
formaciones) como variables que contienen diferentes tipos de datos
homogneos. Se puede acceder a cada elemento de datos individual de la
variable mediante un subndice, o ndice. En los lenguajes C y C++, un array
no se corresponde con un tipo de dato estndar; en su lugar, se trata de un
tipo agregado que se obtiene a partir de otros tipos de datos. Es posible
tener un array de cualquier cosa: caracteres, enteros, nmeros en coma
flotante, arrays, etc.
Un array se declara de modo similar a otros tipos de datos, excepto que se
debe indicar al compilador el tamao o longitud del array. Para indicar al
compilador el tamao o longitud del array se debe hacer seguir al nombre,
el tamao encerrado entre corchetes.
Los arrays tienen cuatro propiedades bsicas:
Los elementos individuales de datos de un array se denominan elementos.
Todos los elementos deben ser del mismo tipo de dato.
Todos los elementos se almacenan en posiciones contiguas de la memoria
de la computadora y el subndice (o ndice) del primer elemento es cero.
El nombre de un array es un valor constante que representa la direccin
del primer elemento del array.
Para acceder a un elemento especifico del array, se utiliza el nombre de
ste seguido por uno o ms ndices (donde cada uno representa una
dimensin del arreglo o array) encerrado entre corchetes. Supongamos que
tenemos un arreglo unidimensional llamado X con un tamao de n
elementos, su esquema grafico es el siguiente:
Como puede verse en el esquema, aunque el arreglo es de n elementos,

en realidad tienen n-1 elementos porque comienzan a enumerarse desde
cero.
En trminos generales para definir un array se especifica el tipo de
almacenamiento (atributo opcional), el tipo de datos, el identificador y entre
corchetes el tamao del arreglo. Abajo se muestra algunos ejemplos de
definicin de arreglos:
a) int num[100]; (un array de 100 enteros)
b) char apellido[25]; (un array de 25 caracteres)
c) float prom[30]; (un array de 30 coma flotante)
d) char contrasena[16]; (un array de 16 caracteres)
La necesidad de definir arrays en funcin de constantes
A veces es conveniente definir el tamao de un array en trminos de una
constante, en lugar de estar especificando una cantidad entera fija. Esto se
realiza por facilidad de mantenimiento. Por ejemplo, suponga que tenemos
un programa (con 350 lneas de cdigo) donde se halle un array de 20
items, y a lo largo del programa se hace referencia unas 12 veces al arreglo,
y supongamos tambin que se necesita cambiar el tamao del arreglo. Sin
usar la constante se tendra que revisar todo el programa para localizar las
lneas de cdigo y efectuar el cambio al nuevo tamao, en cambio con el
uso de constantes slo se le cambia el tamao a la misma y el problema
esta resuelto. La definicin de un array a travs de una constante se
muestra en el siguiente ejemplo:
# include stdio.h>
# include stdlib.h>
/* Definicin de la constante */
#define tamano 20
main()
{
/* Utilizacin de la constante para definir la dimensin del arreglo */
int promedios[tamano];
/* Leer valores utilizando la variable i como contador dentro del ciclo FOR y
++i como acumulador*/
for (i=0; i < tamano; ++i)
scanf(%d,&promedios[i]);
.....
.....
}
La utilizacin de constantes definidas garantiza que las siguientes
referencias al array no sobrepasen el tamao definido para el mismo.
C no comprueba que los ndices del array estn dentro del rango definido.
Inicializacin de arreglos
En ciertas circunstancias puede ser necesario darle valores iniciales a los
arreglos, para ello basta con colocar entre llaves el conjunto de valores
deseados separados por comas y en el orden requerido. A continuacin se
muestran algunos ejemplos:
a) int cant[6]={12,-3,0,15,8};
b) double DesvTipica[8]={0.23, 3.1416, -0.5, 2.16789, -56.78, 25, 0.15,
-14 };
c) char meses[12]={E, F, M, A, M, J, J, A, S, O, N, D};
Para el caso del arreglo cant es como tener:
Cant[0]=12
Cant[1]= -3
Cant[2]=0
Cant[3]=15
Cant[4]=8
Cuando los elementos del arreglo no tienen asignados valores iniciales
explcitos, stos son puestos a cero, a continuacin tenemos un ejemplo:
int edades[8]={25,13,18};
El resultado de la asignacin seria el siguiente:
Edades[0]=25;
Edades[1]=13;
Edades[2]=18;
Edades[3]=0;
Edades[4]=0;
Edades[5]=0;
Edades[6]=0;
Edades[7]=0;
Este mtodo de inicializar arrays mediante valores constantes despus de
su definicin, es adecuado cuando el nmero de elementos del arreglo es
pequeo.
Una nota interesante en cuanto a la inicializacin de arreglos, es que el

tamao no necesita ser indicado explcitamente. Con los arrays numricos el
tamao ser fijado igual al nmero de valores incluidos. En cuanto a las
cadenas, el tamao se fijar igual al nmero de caracteres del string o
cadena mas uno (el carcter nulo \0).
C puede dejar los corchetes vacos, slo cuando se asignan valores al array,
tal como
int cuenta[ ] = { 15, 25, -45 , 0 , 50 };
char c[ ] = { L, u, i, s }; /* declara un array de 4 elementos */
El compilador asigna automticamente cinco elementos a cuenta.
Otros ejemplos:
a) Int porcent[ ]={8, 6, 10, -15, 23};
b) Char mes[ ]=octubre;
que vienen siendo equivalente a:
Porcent[0]=8;
porcent[1]=6;
porcent[2]=10;
porcent[3]= -15;
porcent[4]=23;
mes[0]=o;
mes[1]=c;
mes[2]=t;
mes[3]=u;
mes[4]=b;
mes[5]=r;
mes[6]=e;
mes[7]=\0
Ejemplo 1:
Elabore un programa que permita leer una lista de nmeros en un arreglo,
calcule la suma, promedio, cuadrado , cubo y desviacin estndar de los
mismos:
#include stdio.h>
#include stdlib.h>
#include conio.h>
#include math.h>
#define tam 4
/* programa para calcular la suma, promedio, cuadrado, cubo y desviacin
estandar de una serie de nmeros */
main ( )
{
double vector[tam],cuadrado, cubo;
float prom, desv,suma=0;
int i, j;
system("cls" );
printf ("PROGRAMA PARA CALCULAR \n");
printf(" PROMEDIO, SUMA, CUADRADO, CUBO Y DESV. EST.\n\n") ;
//Captura de valores y suma de los mismos
for(i = 0 ; i < tam ; ++i)
{
printf ("num [%d] = " , i) ;
scanf ("%lf" , &vector[i]) ;
suma+= vector[i] ;
}
prom = suma / tam ;
printf (" \n El promedio de los numeros es: %4.2f\n ", prom) ;
//Calculo e impresin de cuadrado, cubo y desviacin estandar
printf(" \n \n NUMERO CUADRADO CUBO DESV. EST.\n");
for( i = 0 ; i < tam ; ++i )
{
cuadrado = vector[i] * vector[i] ;
cubo = pow (vector[i], 3) ;
desv = vector [i] - prom ;
printf ("%.2lf", vector[i] ) ;
printf (" \t%.2lf", cuadrado) ;
printf (" \t%.2lf", cubo) ;
printf (" \t%.2f\n", desv) ;
}
system("pause");
return(0);
}
Nota que los valores fueron declarados de tipo double no enteros, por el
tamao de los valores que se generan en los clculos.
Ejemplo 2:
El siguiente programa lee 5 valores de teclado y los guarda en un arreglo a.
Luego los escribe.
#include stdio.h>
#include stdlib.h>
main()
{
int a[5],i,num;
for(i=0; i<5;i++){
printf("Digite el numero:\n");
scanf("%d",&num);
a[i]=num;
}
printf("\nEscribiendo el arreglo con los datos leidos:\n\n");
for(i=0; i<5;i++){
printf("a[%d]= %d\n\n",i,a[i]);
}
system("pause");
return 0;
}
Ejemplo 3:
El siguiente programa, pide 5 numeros y calcula los cubos de ellos, los
cuales son guardados en un arreglo y son desplegados.
#include stdio.h>
#include stdlib.h>
#include math.h>
main()
{
int i;
double a[5], num;
for (i=0; i<5; i++)
{
printf("\n Digite numero:");
scanf("%lf", &num);
a[i]=num;
}
printf("_________________________________________\n");
printf("Los cubos de los numeros leidos son:\n");
for (i=0; i<5; i++){
a[i]=pow(a[i],3);
printf("%.0lf\n",a[i]);
}
printf("\n");
system("pause");
return 0;
}
EJERCICIOS:
Ejercicio 1:
Digite, compile y ejecute el siguiente programa.
#include stdio.h>
#include stdlib.h>
main()
{
int a,b=0;
int c[10]={1,2,3,4,5,6,7,8,9,0};
for (a=0;a<10;++a)
if ((c[a]%2)==0) b+=c[a];
printf("%d\n",b);
system(pause);
return 0;
}
Qu hace el programa? __________________________________________
_______________________________________________________________
Cul es la salida? _______
Ejercicio 2:
Digite, compile y ejecute el siguiente programa.
#include stdio.h>
#include stdlib.h>
main()
{
int a,b=0;
int c[10]={1,2,3,4,5,6,7,8,9,0};
for (a=0;a<10;++a)
if ((a%2)==0)b+=c[a];
printf("%d\n",b);
system(pause);
return 0;
}
Qu hace el programa? __________________________________________
_______________________________________________________________
Cul es la salida? _______
En qu se diferencia del ejemplo anterior? ____________________________
_______________________________________________________________
Ejercicio 3
Elabore un programa que sume los primeros 25 nmeros enteros guardados
en un vector. Se desea imprimir la lista de nmeros y al final la suma de los
mismos.
Ejercicio 4
Generar e imprimir un vector de 10 nmeros enteros y encontrar el mayor
de ellos. Desplegar el resultado.
Ejercicio 5
Dadas dos listas A y B de igual nmero de elementos, se desea generar e

imprimir una lista C conteniendo las sumas: A[i] + B[i] = C[i]
PUBLICADO POR SALOMONAQUINO EN 20:36
4 7 C O M E N TA R I O S :
Annimo dijo...
no sirve para nada solo observo programas mediocres.
26 DE SEPTIEMBRE DE 2008, 13:49
Annimo dijo...
tu hermana no sirve para nada!
estupido (a)
Annimo dijo...
Informacin sencilla pero concreta... muy buena :)
9 DE NOVIEMBRE DE 2008, 11:06
Annimo dijo...
Sencillo, pero Util y didactico
12 DE NOVIEMBRE DE 2008, 5:48
Annimo dijo...
jajaj m salvaste
8 D E M AYO D E 2 0 0 9 , 2 2 : 5 9
Luis dijo...
alguien me puede dar una mano?
me pidieron un programa en donde cargue las precipitaciones del ao y muestra la
menor, la mayor, la acumulada y el promedio, y mediante una funcion una opcion
donde puede ingresar el numero de mes y me muestre la descripcion, por ejemplo:
ingreso el 4 y el programa me muestre Abril. desde ya muchas gracias
2 1 D E M AYO D E 2 0 0 9 , 1 2 : 3 1
victor_m dijo...
alguien me puede ayudar con este programa:
Una casa de cambio desea obtener estadisticas semanales (dia por dia) de la ventana
de dolares, las estadisticas a obtener
son las siguientes:
dia ventas dolares
lunes xxxxxx xxxxxx
martes xxxxxx xxxxxx
miercoles xxxxxx xxxxxx
jueves xxxxxx xxxxxx
viernes xxxxxx xxxxxx
sabado xxxxxx xxxxxx
para esto se cuenta con los reportes de venta de la semana cada reporte tiene el
mumero del dia en que se hizo la venta (1 a 6, 1=lunes)
y la cantidad de dolares vendidos.
nota: puede haber varias ventas de un mismo dia puede haber dias sin ventas, los
reportes no estan organizados.
3 DE OCTUBRE DE 2009, 17:26
Annimo dijo...
los ejercicios se me hacen bien para personas que van iniciando en la programacion...
estan sencillos y fciles de entender...
4 DE OCTUBRE DE 2009, 15:29
Annimo dijo...
Muchas gracias, ejercicios muy ilustrativos para los que nos estamos iniciando en C++
7 DE DICIEMBRE DE 2009, 15:22
Annimo dijo...
TODOS LOS EJEMPLOS SACAN ERRORES, ALGUIEN ME PUEDE COLABORAR DICIENDOME
COMO LOS CORRIJO
25 DE FEBRERO DE 2010, 17:35
Henryk dijo...
Que pena por los comentarios de algunas personas sin sentido humano, as de felices
han de ser cuando programan su vida...
"Si no sientes pasin por lo que haces deja de hacerlo, la vida no te lo perdonar."
Henryk
Gracias, por los ejercicios.
D.r. Henryk
10 DE MARZO DE 2010, 6:15
Beatriz dijo...
Alguien podra mostrar los 3 ejercicios resueltos? No logro realizarlos, me estoy
iniciando en este tema.Muchas gracias
15 DE MARZO DE 2010, 6:39
Annimo dijo...
solo faltan las respuestas de los ultimos,.,.///
//*aios*//
14 DE JUNIO DE 2010, 23:46
elmer dijo...
necesito urgente 10 ejercicios de arreglos unidimensionales les agardeceria un
monton si me lo mandan flad81@hotmail.com
10 DE OCTUBRE DE 2010, 18:58
Annimo dijo...
ayudeme con los bidimencionales
20 DE ENERO DE 2011, 7:07
Annimo dijo...
me pueden ayudar a hacer mi programa que a traves de un arreglo unidimensional
almacene el numero total de toneladas de cereales cosechados durante cada mes del
ao.proporcionando la sig.informacion
a)el promedio anual de toneladas cosechadas
b)cuantos meses tuvieron una cosecha superior al promedio anual
C)que mes tuvo la mayor cosecha
10 DE MARZO DE 2011, 16:18
FABIAN dijo...
me pueden ayudar con los 3 ultimos ejercicios, la verdad q soy novato, y tengo como
ejercicios en la escuela...
11 DE MARZO DE 2011, 17:40
Annimo dijo...
sera ke me pueden ayudar con el iguiente ejercicio:
reliazar un progrma ke al introducir el dia y mes de nacimiento de los 42 estudiantes
del salon imprima el signo del zodiaco
3 D E AB R I L D E 2 0 1 1 , 1 2 : 2 9
Annimo dijo...
necesito un programa kon arreglos k me ayude a realizar el juego del ahorcado k
consiste en pediarle a l usuario k adivine las letras k deben de ir en una palabra
introducida y despues muestre si tengo errores o si la palabra introducida es correcta
xfovor lo necesiti lo mas rapido posible
1 2 D E AB R I L D E 2 0 1 1 , 9 : 3 3
Annimo dijo...
Muy buenos ejemplos para principiantes, te felicito y lstima de comentarios que
hacen algunos y no hacen nada para ayudar y colaborar, con los principiantes
2 1 D E AB R I L D E 2 0 1 1 , 1 6 : 3 8
Lili dijo...
Hola estoy en el primer ao de informatica y todo esto de c++ es nuevo para mi y
como estoy en curso por trabajadores no tengo mucho tiempo de aprender, pero con
este sitio creo que voy a avanzar mucho esto es genial, aqui tengo un ejercicio para
mi trabajo final de este curso y necesito ayuda, por favor ayudenme saludos lili
14. En una empresa es conocida por cada trabajador: el nombre, el salario base
mensual, la evaluacin de idoneidad (B, R, M) con carcter anual y las ausencias en
todos los meses del ao. Se sabe que si la evaluacin es B y que no tiene ausencias
por 9 o ms meses del ao y el porcentaje de ausencias en caso de que ellos tenan no
supera el 10% del mes, que cobra 30% de el salario bsico por concepto de
estimulacin. Hacer una aplicacin que permite determinar:
a) Cunto de la compaa debe pagar por concepto de estimulacin
b) De los trabajadores evaluados de M que de menor salario.
c) El mes con mayor cantidad de ausencias.
d) Para obtener un listado con los trabajadores que deben cobrar la estimulacin y la
cantidad que debe recibir el pago por este concepto, ordenada de mayor a menor.
e) Los trabajadores que no fueron estimulados para que usted / ellos no completan
los requisitos de asistencia.
f) Qu porcentaje se evaluaron los trabajadores de B representan?
1 8 D E M AYO D E 2 0 1 1 , 1 1 : 2 3
joc dijo...
NECESITO AYUDA PARA PODER PROGRAMAS:
5. En un arreglo unidimensional de tipo real se tienen almacenadas las toneladas
mensuales de cereales cosechadas durante 2 aos (2009 y 2010). Escriba un programa
que calcule e imprima lo siguiente: El promedio anual de toneladas cosechadas en el
ao 2009. Cuntos meses tuvieron una cosecha inferior al promedio anual del 2009?
En qu meses de ambos aos se produjo un menor numero de toneladas que el
promedio de los 24 meses juntos.
2 8 D E AG O S TO D E 2 0 1 1 , 1 5 : 5 9
Annimo dijo...
ALGUIEN ME PUEDE AYUDAR...tengo un problema en C
realizar la programacion necesaria que me permita ingresar el tamao de 2 vectores
numericos.luego a traves de un menu poder cargar los mismos, mostrar los numeros
que superen el promedio, mostrar los vectores en forma inversa y por ultimo unir los
2 vectores en 1 solo.
Annimo dijo...
1. Desarrolle un programa en C++, aplicando el concepto de arreglos en una

dimensin:
La agencia de seguros Atlas desea obtener un reporte al final del da de sus 5
empleados para determinar cul fue el empleado que obtuvo el mayor sueldo en base
a sus ventas y comisiones, se registrar el nombre del empleado la edad y el sueldo
que obtuvo al final del da. Desarrollar un programa en C++ que pida al usuario el
nombre de los empleados, su edad y el sueldo para generar un reporte que lo muestre
en pantalla de la siguiente manera: el nombre del empleado, edad, sueldo, el
empleado con mayor sueldo, el sueldo del empleado que gana ms y su edad.
2. Desarrolle un programa en C++, aplicando el concepto de arreglos
multidimensionales:
El maestro de la clase de Matemticas quiere obtener un reporte de sus alumnos del
examen que les aplico de matemticas, el maestro acomod a sus alumnos en cinco 5
hileras y cada hilera con 5 asientos, el reporte que el maestro desea obtener es el
promedio de los alumnos colocados por hilera y la calificacin ms alta y ms baja.
Desarrollar un programa en C++ que pida al usuario las calificaciones de los alumnos.
Despus el programa debe dar la opcin de calcular el promedio de las calificaciones
de los alumnos por hilera, obtener la calificacin ms alta y ms baja de curso.
Mostrar en pantalla el arreglo de los alumnos con sus calificaciones, el promedio de
calificaciones por hilera y la calificacin ms alta y ms baja
guiente es el primer ejercicio que hice con matrices. Quizs alguno de estos ejercicios te
puedan servir como una base.
Puedes leer el post anterior sobre vectores, matrices y punteros si an no haz trabajo con ellos.
Recomiendo que intentes y practiques mucho antes de copiar y pegar. Si te sientes estancado
en algn problema recin trata de buscar una gua para llegar a la solucin.
Esta clase matriz tendr 3 atributos: Matriz, nmero de filas y nmero de columnas. Tiene un
constructor por defecto, constructor copia y un constructor por parmetro que recibe el nmero
de filas y columnas.
Las siguientes funciones fueron implementadas:
Generar una matriz dinmicamente
LLenar la matriz desde teclado:
Llenar la matriz aleatoriamente:
Imprimir la matriz
Hallar el mayor elemento.
Hallar el menor elemento.
Hallar la moda.
Intercambiar filas.
Intercambiar columnas.
Sumar otra matriz: Sumar 2 objetos de tipo matriz retornar otra matriz. Ejem: c = a + b.
Restar otra matriz: Igual que la suma. Ejem: c = a b
Multiplicar por otra matriz: Ejem: c = a * b. El nro de filas de a debe ser igual al nro de
columnas de b
Multiplicar por un escalar: Ingreso un nmero y todos los elementos de la matriz se

multiplican por ese nmero.
Hallar matriz transpuesta: matr[m][n] su transpuesta es matr[n][m]. Se obtiene

cambiando filas por columnas. Donde los elementos de la fila m ahora pertenecen a la
columna m de la transpuesta.
Verificar si es simtrica: Una matriz es simtrica si es cuadrada(filas = columnas) y

cuando su transpuesta es igual a su matriz original.
Verificar si es identidad: Es identidad si tiene todos sus elementos nulos excepto los de
la diagonal principal que son iguales a 1.
NOTA: He aplicado un poco de templates para manejar la matriz con varios tipos de datos (int,
float, char, double) y sobrecarga de operadores para la suma, resta y multiplicacin de
matrices.
Recien estoy aprendiendo a usar estas 2 caractersticas importantes del lenguaje (templates y
sobrecarga de operadores).
En breve:
Un template es una manera de que funciones, clases, mtodos puedan ser usados con varios
tipos de datos. Imagnense crear una lista de datos y tener que crear funciones insertar,
eliminar, buscar, concatenar, etc para cada tipo de dato. Si los mtodos y la clase tienen la
misma lgica para que reescribir cdigo si podemos reutilizar.
La sobrecarga de operadores es una manera de realizar las mismas operaciones que solemos
hacer con tipos de datos comunes con tipos abstractos de datos. Por ejemplo, la sobrecarga
me permiti sumar 2 objetos de tipo Matriz y almacenar el resultado en otro objeto Matriz, del
modo c = a + b
Aqu est la definicin e implementacin de la clase Matriz.
matrix.h
#ifndef MATRIX_H
1
#define MATRIX_H
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <time.h>
#include <stdlib.h>
template <class T>
class Matrix {
public:
Matrix();
Matrix(int, int);
~Matrix();
bool isSymmetric();
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
bool isIdentity();
T get_max();
T get_min();
T get_mode();
void
void
void
void
void
void
void
void
delete_matrix();
fill_by_user();
fill_random();
get_transpose();
print_matrix();
private:
T m_ele;
T m_max;
T m_min;
T m_mode;
T **m_matrix;
};
int m_dim_matrix;
int m_cols;
int m_rows;
#endif // MATRIX_H
matrix.cpp
#include "matrix.h"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Matrix<T>::Matrix()
{
m_rows = 4;
m_cols = 4;
}
{
*this = m;
}
{
m_cols = cols;
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
m_rows = rows;
}
}

{
}
}
}

{
}
}
}
{
T total;
}
total = 0;
}
}
}

{
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
return false;
}

return false;
}
}
}
return true;

{
return false;
}

if (i == j) {
return false;
} else {
return false;
}
}
}
return true;

{
}
}
}
return m_max;
}
{
}
}
}
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
return m_min;
}
{
}
}
int y = 0;
int z = 0;
}
}
}
z++;
if (z == m_cols) {
z = 0;
y++;
}
}
if (m_max == 1) {
return -1;
} else {
}
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
}
}
return m_mode;
{
}
delete[] m_matrix;
}
{
cout << "Fila " << i + 1 << endl;
cin >> m_ele;
}
cout << endl;
}
}
{
}
}
srand(time(NULL));
}
{
}
}
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
}
{
}
}
}
// Imprimir Matriz
{
}
}
}
{
} else {
T temp;
col_1--;
col_2--;
endl;
}
}

}

{
} else {
T temp;
row_1--;
row_2--;
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
}
endl;
}
}
319
320
321
322
323
324
325
326
327
328
329
330
main.cpp
#include <iostream>
1
#include "matrix.h"
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

int main()
{
srand(time(NULL));
int n_rows;
int n_cols;
int
int
int
int
int
col_1;
col_2;
row_1;
row_2;
scalar;

cin >> n_rows;
cin >> n_cols;
cout << endl;
a.fill_random();
b.fill_random();
a.print_matrix();
cout
cout
cout
cout
<<
<<
<<
<<

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
cout << (a.isIdentity() ? "" : "No") << " Es identidad." << endl;
cout << endl;
cin >> scalar;
a.print_matrix();
cin >> col_1;
cin >> col_2;
a.print_matrix();
cin >> row_1;
cin >> row_2;
a.print_matrix();
a.get_transpose();
a.print_matrix();
b.print_matrix();
c = a + b;
c.print_matrix();
c = a - b;
c.print_matrix();
c = a * b;
c.print_matrix();
a.delete_matrix();
b.delete_matrix();
c.delete_matrix();
return 0;
88
89
90
91
92
93
94
95
elementos.

auxiliar.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Matriz original
17 16 10 26
10 3 9 19
29 7 1 6
6 20 0 10
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
1 1 3 1
3 1 1 1
1 1 1 2
2 1 1 3


Github:
El clculo del determinante de una matriz cuadrada NxN permite saber si esta es invertible.
Si es cero no tiene inversa y entonces podemos programar una excepcin para no ejecutar el
cdigo para el clculo de la inversa.
A continuacin presentamos el cdigo para el clculo del determinante de cualquier matriz
NxN. En lugar de introducir los datos manualmente por pantalla se van a leer desde un
archivo externo (datos.in) que vamos a colocar en la carpeta datos y esta, a su vez, en una
carpeta que vamos a llamar DETERMINANTE. El archivo datos.in contendr lo siguiente:
Cdigo:
3
123
214
341
El primer valor es el orden de la matrix (3x3 en este caso) y a continuacin se tienen todos los
elementos de una matriz simtrica.
Para calcular el determinante de una matriz NxN colocamos el siguiente cdigo:
Cdigo:
#include<iostream>
#include<fstream>
#include<cstdlib>
usingnamespacestd;
voidinvermat(intn,double**a,double&determ);
intmain(){
system("clear");
ifstreamlabel1("datos//datos.in");//Abreelarchivodeentradade
datos
//Definicindevariablesyasignacindinmicadememoria
inti,j,n;
label1>>n;
double**a,determ=0;
a=newdouble*[n];
for(j=0;j<n;j++){
a[j]=newdouble[n];
}
//Lecturadelamatriz(label1apuntaadatos.inenelsubdirectorio
datosdelhomedeusuario)
for(i=0;i<n;i++){
for(j=0;j<n;j++){
label1>>a[i][j];
}
}
cout<<"Imprimelamatrizdeorigen\n\n";
//Matrizdeorigen;a
for(i=0;i<n;i++){
for(j=0;j<n;j++){
cout<<a[i][j]<<"";
}
cout<<endl;
}
cout<<endl;
invermat(n,a,determ);
cout<<"Eldeterminantedelamatrizanteriores="<<determ<<"\n\n";
deletea;
return0;
}
voidinvermat(intn,double**a,double&determ){
//AlgoritmoparalaeliminacinsimpledeGauss
inti,j,k;
doublefactor;
double**L,*D,*X;
X=newdouble[n];D=newdouble[n];
L=newdouble*[n];
for(j=0;j<n;j++)
L[j]=newdouble[n];
for(k=0;k<n1;k++){
for(i=k+1;i<n;i++){
factor=a[i][k]/a[k][k];
for(j=k+1;j<n+1;j++){
a[i][j]=a[i][j]factor*a[k][j];
}

}
}
//Clculodeldeterminante
determ=1.;
for(i=0;i<n;i++){
determ=determ*a[i][i];
}
deleteL,D,X;
}
que implementa la eliminacin simple de Gauss para producir una matriz triangular antes del
clculo del determinante (pasado por referencia desde la funcin invermat). Este cdigo se
graba como determ.c++ dentro de la carpeta DETERMINANTE. Para compilarlo, en una
cnsola nos dirigimos a la carpeta DETERMINANTE y ejecutamos:
g++ determ.c++ -o determ
Para correr el programa:
./determ
La salida es:
Cdigo:
Imprimelamatrizdeorigen
123
214
341
Eldeterminantedelamatrizanteriores=20
Si queremos calcular otro determinante pero para esta matriz:

Cdigo:
1234
2156
3517
4671
modificamos el datos.in y ejecutamos con ./determ para obtener:

Cdigo:
Imprimelamatrizdeorigen
1234
2156
3517
4671
Eldeterminantedelamatrizanteriores=258
Para verificar que el cdigo funciona bien, se puede probar con lenguaje R. Esta es la salida
en una cnsola de mi sistema con los comandos empleados:
Cdigo:
>w<matrix(data=0,4,4)
>data.entry(w)
>w
var1var2var3var4
[1,]1234
[2,]2156
[3,]3517
[4,]4671
>det(w)
[1]258
Mejor respuesta: Hola: Poco has participado, asi que se merecedor de lo que otros hacen
por vos.
El scanf suele producir errores cuando se carga una matriz, asi que no es aconsejable, pero
igual te adjunto este codigo
#include <stdio.h>
#include <conio.h>
int matriz[5][5], i, j;
void llenar();
void mostrar();
void main(){
clrscr();
llenar();
mostrar();
}
void llenar(){
for(i=0; i<5; i++){
for(j=0; j<5; j++){
printf("Ingrese el elementos de la columna: %d y fila: %d " , j + 1, i +1);
scanf("%i" , &matriz[i][j]);
}}}
void mostrar(){
for(i=0; i<5; i++){
for(j=0; j<5; j++){

printf("\t %i" , matriz[i][j]);
}
printf("\n");
}
char st[2];
getch();
}
Dios te bendiga
Saludos
Antonio
aem hace 6 aos
0
Pulgar hacia arriba
0
Pulgar hacia abajo
Comentario
Notificar abuso
//Listo tu codigo en C
#include <stdlib.h>
#include <stdio.h>
void llenar(int matriz[][5]);
void mostrar(int matriz[][5]);
int main(void){
int matriz[5][5];
llenar(matriz);
system("cls");
mostrar(matriz);
system("pause");
return 0;}
void llenar(int m[][5]){
int i,j;
for(i=0; i<5; i++)
for(j=0; j<5; j++){
printf("Elemento [%d][%d]: ",i+1,j+1);
scanf("%d",&m[i][j]);}}
void mostrar(int m[][5]){
int i,j;
for(i=0; i<5; i++)

for(j=0; j<5; j++)
printf("Elemento [%d][%d]: %d\n",i+1,j+1,m[i][j]);}
Fuente(s):

Estructuras de Datos

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Estructuras de Datos

Enviado por

Direitos autorais:

Formatos disponíveis

Estructuras de datos

El subndice de cada elemento designa su posicin en la ordenacin del vector. Se observa

Declaracin de un arreglo Unidimensional :

Almacenamiento de arreglos en memoria

La memoria de la computadora es unidimensional, por lo que el almacenamiento de los

Operaciones sobre arreglos

Caso Unidimensional: Asignar el valor 6 a todos los elementos de un vector A[5]

repetir_desde ( i = 1; i <= 5 ; i=i+1)

Caso Bidimensional: Inicializar un vector B[2,3] con el valor cero.

repetir_desde ( i = 1; i <= 2 ; i=i+1)

Si se deseara mostrar la cantidad de alumnos con notas superiores al promedio se agregan

Ejemplo 3: Leer una matriz de dos dimensiones A[5,4].

Ejemplo 4: Inicializar una matriz de dos dimensiones con valor constante 0.

Ejemplo 5: Realizar la suma de dos matrices bidimensionales.

Ejemplo 6: Disear un algoritmo que genere una matriz identidad de orden n.

Algoritmos Bsicos de Bsqueda y Ordenamiento

La operacin de bsqueda es una de las tareas ms comunes en computacin y bsicamente

Bsqueda Menor / Mayor :

Diseo del algoritmo:

El algoritmo se basa en el principio de comparar pares de elementos e intercambiarlos entre

Aplicaciones sobre Arreglos

El monto a pagar de cada venta se guarda en un vector MONTO[100]. Este vector se

Diseo del algoritmo:

5.-Llenar un vector de n elementos con los primeros n valores enteros y primos.

Un nmero primo es aquel que es divisible nicamente por el mismo y la unidad.

Los nmeros 1,2 y 3 son primos.

Diseo del algoritmo:

6.-Generar la siguientes matrices:

las matrices se almacenan como se muestra:

La matriz C se crea utilizando un criterio (i == j) para llenarla.

Diseo del algoritmo:

alguno de estos ejercicios te puedan servir como una base.

Generar una matriz dinmicamente

LLenar la matriz desde teclado:

Llenar la matriz aleatoriamente:

Hallar el mayor elemento.

Hallar el menor elemento.

Restar otra matriz: Igual que la suma. Ejem: c = a b

Multiplicar por un escalar: Ingreso un nmero y todos los elementos de la matriz se

Hallar matriz transpuesta: matr[m][n] su transpuesta es matr[n][m]. Se obtiene

Verificar si es simtrica: Una matriz es simtrica si es cuadrada(filas = columnas) y

// Constructor por defecto

// Suma de matrices con sobrecarga de operadores

// Resta de matrices con sobrecarga de operadores

// Verificar si una Matriz es simtrica

for (int i = 0; i < m_rows; i++) {

// Verificar si una Matriz es identidad

for (int i = 0; i < m_rows; i++) {

// Obtener el mayor de la Matriz

for (int i = 0; i < m_rows; i++) {

// Intercambiar dos filas en una Matriz

using namespace std;

cout << "Ingresa nro de filas: " << endl;

"El mayor de la Matriz es: " << a.get_max() << endl;

Si encuentro una repeticin, incremento en uno el valor en esa posicin de la matriz

Luego hallar el mayor elemento de la matriz auxiliar.

La moda de la matriz es: 10,

El cdigo fuente de este y otros ejercicios de C++ est disponible en

// Constructor por defecto

for (int i = 0; i < m_rows; i++) {

// Suma de matrices con sobrecarga de operadores

// Resta de matrices con sobrecarga de operadores

// Multiplicacin de matrices con sobrecarga de operadores