Curso bsico de C 6/10: Arrays y registros

A la hora de desarrollar aplicaciones necesitamos almacenar una gran cantidad de

informacin, necesitamos tambin estructuras que recojan varios tipos de datos a la vez. C
cuenta con varias herramientas para poder desarrollar todas estas funcionalidades. En ste
captulo veremos los Arrays simples y multidimensionales para poder almacenar una
cantidad determinada de datos de un mismo tipo, acceder a ellos en cualquier momento y
operar, tambin veremos los registros para poder trabajar con conjuntos de variables.
- See more at: http://programavideojuegos.blogspot.com.es/2013/05/curso-basico-de-c-610arrays-y-registros.html#sthash.nba92OGX.dpuf

Arrays
Un array, vector, tabla o arreglo es una cantidad de valores de un determinado tipo
colocados de manera secuencial e indexados, cuya forma de acceder a ellos es
especificando la posicin (o ndice) donde se encuentre dentro del array.
Declaracin.
Para declarar un array hay que seguir la siguiente estructura:
Tipo_dato nombre_variable [longitud_array];
El tipo de datos puede ser cualquier de los vistos anteriormente, por ejemplo, un array de
20 enteros sera as:
int num[20];
La declaracin es exactamente igual que cuando declaramos variables normales, salvo que
hay que aadir la longitud del array en cuestin.
Una cosa importante que hay que tener en cuenta a la hora de trabajar con arrays en C es
que la primera celda del array tiene el ndice 0, por lo que el array anterior tendra las
siguientes posiciones:
num[0], num[1], num[2], num[3], num[4], num[5], num[6] num[19].
En una misma fila de declaracin se pueden declarar tanto varios arrays a la vez como
variables normales.

int num1,num2,num3[10],num4,num5[5];
Tambin es posible declarar arrays prescindiendo del uso de nmeros para definir su
tamao, aunque es necesario que tengamos en cuenta ciertos factores:
1 Para declarar un array usando identificadores slo se podr usar constantes definidas
mediante #define.
#define TAM 50
int main(void)
{
int a[TAM];
}
2 No es correcto definir el tamao de un array con variables.
int main(void)
{
int tam=50;
int a[tam];
}
3 No es correcto definir el tamao de un array con constantes declaradas mediante
const. Esto es debido a que, a efectos del compilador, una constante declarada mediante
const es una variable de slo lectura.
int main(void)
{
const int tam=50;
int a[tam];
}
Asignacin de valores e iniciacin de un array.
Cuando se declara un array las celdas de ste contienen valores completamente
aleatorios, es necesario que le asignemos los valores con los que necesitamos trabajar, para
esto hay varias posibilidades.
Asignacin directa de un valor mediante el operador de asignacin =, hay que especificar
mediante su ndice la celda concreta donde se va a almacenar. En el array anterior sera tal
que as:
a[2] = 1;

Por lo general cuando comenzamos un programa se debe inicializar los valores de todo el
array, es decir, tendremos que asignar valores en todos sus ndices, para ello lo mejor es
recorrer el array completo mediante un bucle.
El bucle for es perfecto para trabajar con arrays puesto que al tener controlados todos los
elementos esenciales de un bucle podemos centrarnos en trabajar con el array directamente.
Un ejemplo de inicializacin de un array es el siguiente:
#include <stdio.h>
#define TAM 20
int main(void)
{
int x, a[TAM];
for (x = 0; x < TAM; x++)
{
a[x]=0;
}
return 0;
}
Tambin es posible inicializar un array en su propia declaracin, para ello debemos
seguir la siguiente estructura:
Tipo_dato nombre_variable [longitud_array] = {valor0, valor1... valor_longitud_array};
Un ejemplo prctico sera el siguiente:
int num[10] = {0,0,0,0,0,0,0,0,0,0}:
as nos aseguramos de que tenemos el array con valores definidos por nosotros desde el
principio del programa.
Recorrer un array.
Como hemos podido comprobar en el anterior apartado, un array se recorre mediante un
bucle.
Se toma como primer valor el cero puesto que la primera celda tiene ndice cero, por lo
tanto la condicin para salir del bucle es el tamao menos uno. Si recorremos el array y nos
pasamos, o bien hacemos referencia a una celda fuera del rango del array el programa dar
errores.

Veamos un ejemplo donde recorremos un array y mostramos su valor por pantalla:

#include <stdio.h>
#define TAM 5
int main(void)
{
int x,
int a[TAM] = {0,0,0,0,0};
for (x = 0; x < TAM; x++)
{
printf(%d,a[x]);
}
return 0;
}

Cadenas de texto o array de caracteres.

El tipo de dato String o Cadena no existe en C como tal, en lugar de eso lo que tenemos
a nuestra disposicin es el array de caracteres, la forma de tratarlo es exactamente igual que
con los arrays de otros tipos de datos a excepcin de muchas instrucciones, entre ellas printf
y scanf.
Consideraciones del array de caracteres
Definir un array de caracteres es sencillo, exactamente igual que con los otros tipos de
datos, pero debemos tener en consideracin el trmino de la cadena.
En las variables de tipo entero todas las celdas del array se rellenan por defecto con valores
aleatorios, en los arrays de caracteres pasa igual. Al introducir o rellenar un array con
caracteres no es necesario que lo rellenos al completo, no obstante hay que indicar cuando
termina la cadena.
Para eso en C disponemos del carcter especial \0, con ste le diremos al programa que
tenga en cuenta dentro del array todos los caracteres hasta llegar al carcter \0.
El \0 cuenta como un carcter ms dentro del array y como tal ocupa una celda, es por
eso que si definimos un array de 50 caracteres en realidad slo podremos rellenar los
primeros 49, ya que siempre el carcter final es el \0.
H

\0

\0

El carcter \0 no tenemos por qu introducirlo nosotros, el programa puede encargarse,

con que sepamos qu significa y cmo utilizarlo y controlarlo es suficiente.
Un truco para poder almacenar un nmero de caracteres en un array con el tamao de ese
nmero es definir el array con un tamao igual y sumar una posicin:
#define TAM 5
int main(void)
{
char a[TAM+1};
return 0;
}
Cadenas y printf
Para poder escribir un array de caracteres utilizamos la sentencia printf y la marca de
formato %s
#include <stdio.h>
#define TAM 50
int main(void)
{
char saludo[TAM +1] = "hola";
printf ("%s.\n", saludo);
return 0;
}
No es necesario utilizar los bucles y recorrer celda a celda, aunque se puede, resulta
trabajoso ya que a veces los arrays pueden ser bastante grandes.
Cadenas y scanf.
La instruccin scanf cumple con su cometido de leer una palabra, pero se presenta un
problema y es el que acabo de decir, slo lee una palabra, no una frase completa.
Pero a eso le daremos solucin en el siguiente apartado, ahora veamos cmo utilizar la
instruccin scanf:
#include <stdio.h>
#define TAM 50
int main(void)

{
char saludo[TAM +1];
scanf(%s,saludo);
printf ("%s.\n", saludo);
return 0;
}
Como se puede observar no es necesario de nuevo recorrer el array, la instruccin hace
posible asignar los caracteres directamente en sus celdas.
Tambin si se observa el cdigo, en la instruccin scanf no he puesto un & delante del
array, esto es debido a que hasta ahora hemos usado el scanf con & porque lo que scanf
necesita es una direccin de memoria donde alojar el valor, cosa que hacamos con &,
como los arrays son en si mismos direcciones de memoria indexados no es necesario
colocar el &.
Prueba el cdigo introduciendo la siguiente cadena Hola buenos das y observa el
resultado.
Cadenas y gets.
Para solucionar el problema del scanf con el array de caracteres tenemos dentro de la
librera stdio.h la instruccin gets
Con gets no es necesario utilizar una marca de formato, tan slo con especificar el array
es suficiente, veamos un ejemplo:
#include <stdio.h>
#define TAM 50
int main(void)
{
char saludo[TAM +1];
gets(saludo);
printf ("%s.\n", saludo);
return 0;
}
Prueba ahora el cdigo introduciendo de nuevo la cadena Hola buenos das y observa el
resultado.

Copiar cadenas.
El caso de necesitar hacer una copia de cadenas es una cosa que nos podemos encontrar
perfectamente en un programa, hasta ahora todo parece que se puede realizar perfectamente
mediante sentencias, por lo que copiar cadenas no debe ser muy distinto, veamos el
siguiente ejemplo:
#include <stdio.h>
#define TAM 50
int main(void)
{
char saludo[TAM +1] = "hola";
char despedida[TAM +1];
despedida=saludo;
printf ("%s.\n", despedida);
return 0;
}
Esto es incorrecto, el compilador dar error y el programa no llegar ni a ejecutarse, esto
es debido a que, recordemos, las cadenas son arrays, y los arrays son direcciones de
memoria que una vez declarados no se pueden alterar, por lo que en el programa anterior lo
que estaramos intentando hacer es asignar la direccin de memoria de otra direccin de
memoria.
La copia de cadenas debe realizarse carcter a carcter, asignando los valores uno a
uno en todas las posiciones implicadas, veamos el mismo ejemplo pero correctamente:
#include <stdio.h>
#define TAM 50
int main(void)
{
char saludo[TAM +1] = "hola";
char despedida[TAM +1];
for (x=0;x<TAM;x++)
{
despedida[x]=saludo[x];
}
printf ("%s.\n", despedida);
return 0;

}
Esta es la forma correcta de copiar cadenas, no obstante se puede refinar un poco dado
que tenemos dos cadenas de 50 caracteres y realmente slo tenemos que copiar cuatro, para
ello introduciremos un condicional if para detectar el \0 y salir del bucle, veamos el
resultado final:
#include <stdio.h>
#define TAM 50
int main(void)
{
char saludo[TAM +1] = "hola";
char despedida[TAM +1];
for (x=0;x<TAM;x++)
{
despedida[x]=saludo[x];
if (saludo[x]==\0)
{
break;
}
}
printf ("%s.\n", despedida);
return 0;
}
Esto se puede plantear de mltiples formas, podemos refinarlo de diferentes maneras,
controlando en algunos sitios o bien modificando las condiciones del bucle.

Arrays Multidimensionales.
Hasta ahora lo que hemos visto como array es una tabla de una columna y un nmero
determinado de filas, es posible ampliar todo esto bastante ms, para ello se utilizan los
arrays multidimensionales. De esta forma podemos trabajar con una tabla de filas y
columnas a determinar, pero eso no es todo, tambin podemos darle ms dimensiones al
array.
Declaracin
Los arrays multidimensionales se declaran de la misma forma que los arrays normales,
pero por cada dimensin que queramos aadir debemos especificar igualmente su longitud.

int numeros [10][2];

int numeros [10][2][5];
Recorrer un array multidimensional.
Un array multidimensional se recorre de la misma forma que un array normal, mediante
el bucle for, pero al igual que en la declaracin debemos agregar tantos bucles como sean
necesarios y anidaarlos entre ellos.
Para los arrays anteriores sera as:
for (x=0;x<10,x++)
{
for (y=0;y<2,y++)
{
}
}
De sta forma recorremos de la siguiente forma: Primera fila, primera columna, segunda
columna, ... , segunda fila, primera columna, segunda columna, ... etc.
for (x=0;x<10,x++)
{
for (y=0;y<2,y++)
{
for (z=0;z<5,z++)
{
}
}
}
Aqu recorremos as: Primera fila, primera columna, primera celda, segunda celda, ... ,
primera fila, segunda columna, primera celda, segunda celda, ... etc.
Todo lo que hemos visto en el apartado de arrays es completamente vlido para los arrays
multimensionales, no necesitan de mayores retoques.

Registros.
El ltimo punto de ste captulo es bastante interesante, imaginemos que necesitamos
gestionar los datos de una tienda de discos, sera necesario conocer varios datos como por
ejemplo el nombre del disco, el ao en que se puso a la venta o el gnero al que pertenece.
Esto se puede realizar perfectamente usando variables y arrays, pero hay ocasiones en las
que es mejor agrupar estos datos con el fin de poder acceder a todos ellos de una sola vez.

Imaginemos que queremos gestionar los datos de 100 discos de msica, es sencillo
porque utilizaremos tres arrays, uno para el nombre del disco, otro para el ao de
publicacin y otro para el gnero. Todo perfecto.
Ahora imaginemos que necesitamos buscar un disco en concreto y mostrar la informacin
completa del disco, del que slo sabemos el nombre. Buscamos en el primer array y lo
localizamos, tenemos el nombre, ahora busquemos en el segundo array el ao en que se
public, deberemos saber en qu posicin del array se encuentra, despus busquemos en el
siguiente array el gnero al que pertenece No es un poco engorroso esto?
Ahora un caso perfectamente posible, imaginemos que deseamos eliminar un disco, nos
vamos al array del nombre y lo eliminamos, despus al array de ao y luego al array de
gnero, nuevamente engorroso.
Ahora lo ltimo, imaginemos que nos hemos equivocado al programar y resulta que por
un error al eliminar el nombre del disco no hemos podido eliminar el ao y el gnero. El
caos est servido.
En C disponemos de la posibilidad de declarar registros, esto son agrupaciones de datos
de cualquier tipo, accesibles mediante identificadores.
Usando un registro podemos agrupar los tres arrays anteriores en uno slo, y si
queremos realizar cualquier operacin la estaremos haciendo con un solo array, un array de
registros.
La representacin de los tres arrays podra ser as:
Disco1
Disco2
Disco3

2000
1997
1999

Pop
Rock
Pop

La representacin de un array de registros podra ser as:

Disco1
2000
Pop
Disco2
1997
Rock
Disco3
1999
Pop
As lo tenemos mucho mejor verdad? La representacin de los datos mediante un array de
registros nos facilita operar con los datos y evitar mantenimientos incmodos y que de
resultar errneos podra ocasionar errores de datos muy graves.

Para definir un registro usaremos el siguiente esquema:

struct NombreRegistro {
variable1;
variable2;
variable3;
...
variableN;
};
Una vez lo hemos definido procedemos a declarar las variables basndonos en la
estructura siguiendo el siguiente esquema:
Struct NombreRegistro nombre_variable;
El registro lo definimos antes del programa principal (main), concretamente despus
del #define, y por consiguiente despus del #include, la declaracin de variables basadas
en el registro la podemos hacer en cualquier momento.
Tanto en las variables de la definicin como en la declaracin podemos usar arrays de
cualquier dimensin.
Veamos el caso del programa para gestionar discos:
#include <stdio.h>
#include <string.h>
#define TAM 100
#define TAMEST 50
struct Discos {
char nombre[TAMEST+1];
int anno;
char genero[TAMEST+1];
};
int main(void)
{
struct Discos misdiscos[TAM];
return 0;
}
Con esto habremos contemplado el caso que plantebamos, ahora tenemos un array de 100
registros donde gestionaremos nuestra coleccin de discos.

Para poder hacer referencia a una variable del registro tan slo debemos indicar su
nombre de la siguiente forma:
Discos.nombre
Discos.anno
Discos.genero
El tratamiento con respecto a los operadores es el mismo que con las variables, podemos
asignar valores, realizar operaciones, comparar, etc.
En el caso que nos ocupa, el de los discos, al tratarse de un array lo recorremos como ya
hemos visto y trabajaremos con las variables as:
Discos[x].nombre
Discos[x].anno
Discos[x].genero
Donde X es el ndice del array.
Con esto hemos terminado el sexto captulo del curso bsico de C. En ste captulo hemos
aprendido los conceptos de arrays simples y multidimensionales, hemos visto como
recorrerlos y como trabajar con sus datos, tambin hemos visto las cadenas o arrays de
caracteres y la nueva instruccin gets, por ltimo hemos definido los registros, hemos visto
como construirlos y como operar con ellos.
En el siguiente captulo veremos dos conceptos importantes dentro de la programacin, los
procedimientos y las funciones, as como el paso de parmetros y formas de utilizacin.
- See more at: http://programavideojuegos.blogspot.com.es/2013/05/curso-basico-de-c-610arrays-y-registros.html#sthash.B3z8RSeV.dpuf

25 ejercicios resueltos de arrays y registros en C

19:19 Curso bsico de C 6 comments

Durante el sexto captulo del curso bsico de C vimos la teora de los arrays y los
registros. Hace unos das dej una tanda de 25 ejercicios para practicar.

Foto tomada de freedigitalphotos.net

Pues como viene siendo habitual os dejo la solucin de los mismos.

Realice un programa en C:

1. Que rellene un array con los 100 primeros nmeros enteros y los muestre en pantalla en
orden ascendente.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int x,tabla[100];

for (x=1;x<=100;x++)
{
tabla[x]=x;
}

for (x=1;x<=100;x++)
{
printf("%d\n",tabla[x]);
}

system("PAUSE");
return 0;
}

2. Que rellene un array con los 100 primeros nmeros enteros y los muestre en pantalla en
orden descendente.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int x,tabla[100];

for (x=1;x<=100;x++)
{
tabla[x]=x;
}

for (x=100;x>=1;x--)

{
printf("%d\n",tabla[x]);
}

system("PAUSE");
return 0;
}

3. Que rellene un array con los nmeros primos comprendidos entre 1 y 100 y los muestre en
pantalla en orden ascendente.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int x,cont,z,i,tabla[100];

i=0;
for (x=1;x<=100;x++)
{
cont=0;
for (z=1;z<=x;z++)
{
if (x%z==0)
{

cont++;
}
}

if (cont==2 || z==1 || z==0)

{
tabla[i]=x;
i++;
}

for (x=0;x<i;x++)
{
printf("%d\n",tabla[x]);
}

system("PAUSE");
return 0;
}

4. Que rellene un array con los nmeros pares comprendidos entre 1 y 100 y los muestre en
pantalla en orden ascendente.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int x,cont,z,i,tabla[100];

i=0;
for (x=1;x<=100;x++)
{
cont=0;
if (x%2==0)
{
tabla[i]=x;
i++;
}
}

for (x=0;x<i;x++)
{
printf("%d\n",tabla[x]);
}

system("PAUSE");
return 0;
}

5. Que rellene un array con los nmeros impares comprendidos entre 1 y 100 y los muestre en
pantalla en orden ascendente.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int x,cont,z,i,tabla[100];

i=0;
for (x=1;x<=100;x++)
{
cont=0;
if (x%2==1)
{
tabla[i]=x;
i++;
}
}

for (x=0;x<i;x++)
{
printf("%d\n",tabla[x]);
}

system("PAUSE");
return 0;
}

6. Que lea 10 nmeros por teclado, los almacene en un array y muestre la suma, resta,
multiplicacin y divisin de todos.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int x,tabla[10];
int sum,res,mul,div;

for (x=0;x<10;x++)
{
printf("Introduzca nmero\n");
scanf("%d",&tabla[x]);
}

sum=tabla[0];
res=tabla[0];
mul=tabla[0];
div=tabla[0];

for (x=1;x<10;x++)
{
sum=sum+tabla[x];
res=res-tabla[x];
mul=mul*tabla[x];
div=div/tabla[x];
}

printf("Suma: %d\n",sum);
printf("Resta: %d\n",res);
printf("Multiplicacin: %d\n",mul);
printf("Divisin: %d\n",div);

system("PAUSE");
return 0;
}

7. Que lea 10 nmeros por teclado, los almacene en un array y los ordene de forma ascendente.

#include <stdio.h>
#include <stdlib.h>

int main()
{
float aux, numeros[10];
int i,j,n=10;

for (i=0;i<n;i++){
printf("Escriba un nmero");
scanf("%f",&numeros[i]);
}

for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
if(numeros[i]<numeros[j])
{
aux=numeros[i];
numeros[i]=numeros[j];
numeros[j]=aux;
}
}
}

for (i=n-1;i>=0;i--){
printf("%f\n",numeros[i]);
}

system("PAUSE");
return 0;
}

8. Que lea 10 nmeros por teclado, 5 para un array y 5 para otro array distinto. Mostrar los 10
nmeros en pantalla mediante un solo array.

#include <stdio.h>
#include <stdlib.h>

int main()
{
int aux, numeros1[5],numeros2[5],numeros3[10];
int i,j;

for (i=0;i<5;i++){
printf("Escriba un nmero");
scanf("%d",&numeros1[i]);
}

for (i=0;i<5;i++){
printf("Escriba un nmero");
scanf("%d",&numeros2[i]);
}

for(i=0;i<5;i++)
{
numeros3[i]=numeros1[i];

for(i=0;i<5;i++)
{
numeros3[5+i]=numeros2[i];
}

for (i=0;i<10;i++){
printf("%d\n",numeros3[i]);
}

system("PAUSE");
return 0;
}

9. Que lea 5 nmeros por teclado, los copie a otro array multiplicados por 2 y muestre el
segundo array.

#include <stdio.h>
#include <stdlib.h>

int main()
{
int aux, numeros1[5],numeros2[5];
int i,j;

for (i=0;i<5;i++){
printf("Escriba un nmero");
scanf("%d",&numeros1[i]);
}

for(i=0;i<5;i++)
{
numeros2[i]=numeros1[i]*2;
}

for (i=0;i<5;i++){
printf("%d\n",numeros2[i]);
}

system("PAUSE");
return 0;
}

10. Que lea 5 nmeros por teclado, los copie a otro array multiplicados por 2 y los muestre todos
ordenados usando un tercer array.

#include <stdio.h>
#include <stdlib.h>

int main()
{

int aux, numeros1[5],numeros2[5],numeros3[10];

int i,j;

for (i=0;i<5;i++){
printf("Escriba un nmero");
scanf("%d",&numeros1[i]);
}

for(i=0;i<5;i++)
{
numeros2[i]=numeros1[i]*2;
}

for(i=0;i<5;i++)
{
numeros3[i]=numeros1[i];
}

for(i=0;i<5;i++)
{
numeros3[5+i]=numeros2[i];
}

for (i=0;i<10;i++){
printf("%d\n",numeros3[i]);
}

system("PAUSE");
return 0;
}

11. Que rellene un array con los 100 primeros nmeros pares y muestre su suma.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int x,cont,sum,i,tabla[100];

i=0;
sum=0;
for (x=1;x<=100;x++)
{
cont=0;
if (x%2==0)
{
tabla[i]=x;
i++;
}
}

for (x=0;x<i;x++)
{
sum=sum+tabla[x];
}

printf("%d\n",sum);

system("PAUSE");
return 0;
}

12. Que lea 10 nmeros por teclado, los almacene en un array y muestre la media.

#include <stdio.h>
#include <stdlib.h>

int main()
{
float sum, numeros1[10];
int i;

sum=0;
for (i=0;i<10;i++){
printf("Escriba un nmero");
scanf("%f",&numeros1[i]);
}

for(i=0;i<10;i++)
{
sum=sum+numeros1[i];
}

printf("%f\n",sum/10);

system("PAUSE");
return 0;
}

13. Que mediante un array almacene nmeros tanto positivos como negativos y los muestre
ordenados.

#include <stdio.h>
#include <stdlib.h>

int main()
{
float aux, numeros[10];
int i,j,n=10;

for (i=0;i<n;i++){
printf("Escriba un nmero");
scanf("%f",&numeros[i]);

for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
if(numeros[i]<numeros[j])
{
aux=numeros[i];
numeros[i]=numeros[j];
numeros[j]=aux;
}
}
}

for (i=n-1;i>=0;i--){
printf("%f\n",numeros[i]);
}

system("PAUSE");
return 0;
}

14. Que rellene un array con 20 nmeros y luego busque un nmero concreto.

#include <stdio.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

int i,x=0,vector[20], n=20, dato, centro,inf=0,sup=n-1;

for (i=0;i<20;i++){
printf("Escriba un nmero");
scanf("%d",&vector[i]);
}

printf("Escriba el nmero a buscar");

scanf("%d",&dato);

while(inf<=sup)
{
centro=(sup+inf)/2;
if (vector[centro]==dato)
{
printf("Existe\n");
x=1;
break;
}
else if(dato < vector [centro] )
{

sup=centro-1;
}
else
{
inf=centro+1;
}
}

if (x==0)
{
printf("No existe\n");
}

system("PAUSE");
return 0;

15. Que pinte un tablero de ajedrez, los peones con la letra P, las torres con T, los caballos con C,
los alfiles con A, el rey con R y la reina con M.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])

{

int x,y;

for (x=0;x<8;x++)
{
for (y=0;y<8;y++)
{
//peones
if (x==1 || x==6)
{
printf("P");
}
//torres
else if ((x==0 && y==0) ||
(x==7 && y==0) ||
(x==0 && y==7) ||
(x==7 && y==7)
)
{
printf("T");
}
//caballos
else if ((x==0 && y==1) ||
(x==7 && y==1) ||
(x==0 && y==6) ||
(x==7 && y==6)

)
{
printf("C");
}
//alfiles
else if ((x==0 && y==2) ||
(x==7 && y==2) ||
(x==0 && y==5) ||
(x==7 && y==5)
)
{
printf("A");
}
//reina
else if ((x==0 && y==3) ||
(x==7 && y==3)
)
{
printf("M");
}
//rey
else if ((x==0 && y==4) ||
(x==7 && y==4)
)
{
printf("R");

}
else
{
printf(" ");
}
}
printf("\n");
}

system("PAUSE");
return 0;

16. Que muestre los primeros 100 nmeros de izquierda a derecha usando un array de dos
dimensiones.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])

{

int x,y, numeros[10][10];

for (x=0;x<10;x++)

{
for (y=0;y<10;y++)
{
numeros[x][y]=(x*10)+1+y;
}

for (x=0;x<10;x++)
{
for (y=0;y<10;y++)
{
printf("%d ",numeros[x][y]);
}
printf("\n");
}

system("PAUSE");
return 0;

17. Que muestre los primeros 100 nmeros de izquierda a derecha usando un array de dos
dimensiones, la ltima fila a mostrar la suma de sus respectivas columnas.

#include <stdio.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

int x,y,sum, numeros[11][10];

for (y=0;y<10;y++)
{
sum=0;
for (x=0;x<10;x++)
{
numeros[x][y]=(x*10)+1+y;
sum=sum+numeros[x][y];
}
numeros[10][y]=sum;
}

for (x=0;x<11;x++)
{
for (y=0;y<10;y++)
{
printf("%d ",numeros[x][y]);
}
printf("\n");
}

system("PAUSE");
return 0;
}

18. Que rellene un array de dos dimensiones con nmeros pares, lo pinte y despus que pida
una posicin X,Y y mostrar el nmero correspondiente.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])

{

int x,y,num=2, numeros[3][3];

for (x=0;x<3;x++)
{
for (y=0;y<3;y++)
{
numeros[x][y]=num;
num=num*2;
}
}

printf("Introduzca coordenada x: ");

scanf("%d",&x);
printf("Introduzca coordenada y: ");
scanf("%d",&y);

printf("El nmero es: %d\n",numeros[x][y]);

system("PAUSE");
return 0;
}

19. Que rellene una matriz de 3x3 y muestre su traspuesta (la traspuesta se consigue
intercambiando filas por columnas y viceversa).

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])

{

int x,y,num=0, numeros[4][4];

for (x=0;x<3;x++)
{
for (y=0;y<3;y++)
{
numeros[x][y]=num;

num++;
}
}

printf("El array original es: \n\n\n");

for(x = 0;x < 3;x++)

{
for(y = 0;y < 3;y++)
{
printf(" %d

", numeros[x][y]);

}
printf("\n\n\n");
}

printf("La traspuesta es: \n\n\n");

for(x = 0;x < 3;x++)

{
for(y = 0;y < 3;y++)
{
printf(" %d
}
printf("\n\n\n");
}

", numeros[y][x]);

system("PAUSE");
return 0;
}

20. Que lea una cadena y la muestre al revs.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])

{

int indice,x;
char frase[50];

printf("Introduzca una frase: ");

gets(frase);

for(x = 0;x < 50;x++)

{
if (frase[x]=='\0')
{
indice=x;
break;
}
}

printf("La frase al reves es: \n\n");

for(x = indice-1;x >=0;x--)

{
printf("%c",frase[x]);
}

printf("\n\n");

system("PAUSE");
return 0;
}

21. Que lea una cadena y diga cuantas vocales hay.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])

{

int sum=0,x;
char frase[50];

printf("Introduzca una frase: ");

gets(frase);

for(x = 0;x < 50;x++)

{
switch (frase[x])
{
case 'a':
sum++;
break;
case 'e':
sum++;
break;
case 'i':
sum++;
break;
case 'o':
sum++;
break;
case 'u':
sum++;
break;
default:
break;
}

printf("\n\nEn la frase hay %d vocales\n\n",sum);

printf("\n\n");

system("PAUSE");
return 0;
}

22. Que lea una cadena y diga cuantas maysculas hay.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])

{
int sum=0,x;
char frase[50];

printf("Introduzca una frase: ");

gets(frase);

for(x = 0;x < 50;x++)

{
if (frase[x]>=65 && frase[x]<=90)
{

sum++;
}
}

printf("\n\nEn la frase hay %d maysculas\n\n",sum);

printf("\n\n");

system("PAUSE");
return 0;
}

23. Que lea una cadena y la encripte sumando 3 al cdigo ASCII de cada carcter. Mostrar por
pantalla.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])

{
int sum=0,x;
char frase[50];

printf("Introduzca una frase: ");

gets(frase);

for(x = 0; x < 50;x++)

{
if (frase[x]!='\0')
{
frase[x]=frase[x]+3;
}
}

printf("\n\nLa nueva frase es:\n\n",sum);

printf("\n\n%s\n\n",frase);
printf("\n\n");

system("PAUSE");
return 0;
}

24. Que gestione los datos de stock de una tienda de comestibles, la informacin a recoger ser:
nombre del producto, precio, cantidad en stock. La tienda dispone de 10 productos distintos. El
programa debe ser capaz de:

a. Dar de alta un producto nuevo.

b. Buscar un producto por su nombre.
c. Modificar el stock y precio de un producto dado.

#include <stdio.h>
#include <stdlib.h>

struct producto {
char nombre[50];
float precio;
int cantidad;
};

int main(int argc, char *argv[])

{
struct producto prod,productos[10];

int x,opcion=1;

for (x=0;x<10;x++)
{
strcpy(productos[x].nombre,"X");
productos[x].precio=0;
productos[x].cantidad=0;
}

while ((opcion==1 || opcion==2 || opcion==3) && (opcion!=4))

{

printf("1- Alta de producto\n");

printf("2- Buscar por nombre\n");
printf("3- Modificar stock y precio\n");
printf("4- Salir\n");

printf("Introduzca una opcin: ");

scanf("%d",&opcion);

if (opcion==1)
{
printf("Introduzca un nombre: ");
gets(prod.nombre);
gets(prod.nombre);
printf("Introduzca un precio: ");
scanf("%f",&prod.precio);
printf("Introduzca un stock: ");
scanf("%d",&prod.cantidad);

for(x = 9; x >=0; x--)

{
if (x!=0)
{
strcpy(productos[x].nombre,productos[x-1].nombre);
productos[x].precio=productos[x-1].precio;
productos[x].cantidad=productos[x-1].cantidad;
}
else
{
strcpy(productos[x].nombre,prod.nombre);
productos[x].precio=prod.precio;
productos[x].cantidad=prod.cantidad;

}
}
printf("\nProducto creado. \n\n");
}
else if (opcion==2)
{
printf("Introduzca un nombre: ");
gets(prod.nombre);
gets(prod.nombre);

for(x = 0; x < 10;x++)

{

if (strcmp(productos[x].nombre,prod.nombre)==0)
{
printf("\nNombre: %s\n",productos[x].nombre);
printf("Precio: %f\n",productos[x].precio);
printf("Cantidad en Stock: %d\n",productos[x].cantidad);
}
}
printf("\n\n");
}
else if (opcion==3)
{
printf("Introduzca un nombre: ");
gets(prod.nombre);

gets(prod.nombre);

for(x = 0; x < 10;x++)

{
if (strcmp(productos[x].nombre,prod.nombre)==0)
{
printf("Introduzca un precio: ");
scanf("%f",&productos[x].precio);
printf("Introduzca un stock: ");
scanf("%d",&productos[x].cantidad);
printf("\nProducto modificado.");
}
}
printf("\n\n");
}
}

system("PAUSE");
return 0;
}

25. Que gestiona las notas de una clase de 20 alumnos de los cuales sabemos el nombre y la
nota. El programa debe ser capaz de:

a. Buscar un alumno.

b.
c.
d.
e.
f.

Modificar su nota.
Realizar la media de todas las notas.
Realizar la media de las notas menores de 5.
Mostrar el alumno que mejores notas ha sacado.
Mostrar el alumno que peores notas ha sacado.

#include <stdio.h>
#include <stdlib.h>

struct alumno {
char nombre[50];
float nota;
};

int main(int argc, char *argv[])

{
struct alumno alum,alumnos[5];

int x,opcion=1;
float sum=0,cont=0,mejor,peor;

for (x=0;x<5;x++)
{
printf("Introduzca nombre alumno:");
gets(alumnos[x].nombre);
gets(alumnos[x].nombre);
printf("Introduzca nota:");

scanf("%f",&alumnos[x].nota);
}

while ((opcion==1 || opcion==2 ||

opcion==3 || opcion==4 ||
opcion==5 || opcion==6) && (opcion!=7))
{

printf("1- Buscar un alumno\n");

printf("2- Modificar nota\n");
printf("3- Media de todas las notas\n");
printf("4- Media de todas las notas inferiores a 5\n");
printf("5- Alumno con mejores notas\n");
printf("6- Alumno con peores notas\n");
printf("7- Salir\n");
printf("Introduzca una opcin: ");
scanf("%d",&opcion);

if (opcion==1)
{
printf("Introduzca un nombre: ");
gets(alum.nombre);
gets(alum.nombre);

for(x = 0; x < 5;x++)

{

if (strcmp(alumnos[x].nombre,alum.nombre)==0)
{
printf("\nNombre: %s\n",alumnos[x].nombre);
printf("Nota: %f\n",alumnos[x].nota);
}
}
printf("\n\n");
}
else if (opcion==2)
{
printf("Introduzca un nombre: ");
gets(alum.nombre);
gets(alum.nombre);

for(x = 0; x < 5;x++)

{
if (strcmp(alumnos[x].nombre,alum.nombre)==0)
{
printf("Introduzca una nota: ");
scanf("%f",&alumnos[x].nota);
printf("\nNota modificada.");
}
}
printf("\n\n");
}
else if (opcion==3)

{
sum=0;
for(x = 0; x < 5;x++)
{
sum=sum+alumnos[x].nota;
}
printf("\nLa media de las notas es de: %f \n",(sum/5));
}
else if (opcion==4)
{
sum=0;
cont=0;
for(x = 0; x < 5;x++)
{
if (alumnos[x].nota<5)
{
sum=sum+alumnos[x].nota;
cont++;
}
}
printf("\nLa media de las notas inferiores a 5 es: %f \n",sum/cont);
}
else if (opcion==5)
{
mejor=0;
for(x = 0; x < 5;x++)

{
if (alumnos[x].nota>mejor)
{
mejor=alumnos[x].nota;
alum.nota=alumnos[x].nota;
strcpy(alum.nombre,alumnos[x].nombre);
}
}
printf("\nEl alumno con mejores notas es: %s \n",alum.nombre);
}
else if (opcion==6)
{
peor=10;
for(x = 0; x < 5;x++)
{
if (alumnos[x].nota<peor)
{
peor=alumnos[x].nota;
alum.nota=alumnos[x].nota;
strcpy(alum.nombre,alumnos[x].nombre);
}
}
printf("\nEl alumno con peores notas es: %s \n",alum.nombre);
}
}

system("PAUSE");
return 0;
}

Qu os parecen los ejercicios?

Enviar por correo electrnicoEscribe un blogCompartir con TwitterCompartir con Facebook
218

0
Google +

15.8K

Entrada ms reciente Entrada antigua Pgina principal

6 comentarios:

1.
Salvador19 de noviembre de 2013, 17:21

Muy sencillos y tiles para quienes comienzan en la programacin. Sera deseable

que hubieras modularizado las soluciones, usando funciones. Gracias de todos
modos.
Responder
Respuestas

1.
Juan Carlos Garca Romero21 de noviembre de 2013, 16:40

S, es lo suyo Salvador, pero como ste post es parte de un curso de nivel

bsico he preferido ponerlo as para que la persona que lo siga pudiera
practicar mucho.
Gracias por la observacin, un saludo.
Responder

2.
yorbin molina28 de enero de 2014, 22:18

muy buenos gracias

Responder
Respuestas

1.
Juan Carlos Garca Romero29 de enero de 2014, 21:18

Gracias a ti por comentar.

Un saludo.

Responder

3.
gregory vera30 de enero de 2014, 0:21

amigo soy un estudiante novato de ingeneria en sistema y estoy trabajando estos

ejercicios de practica en java eclipse ... y me da muchos errores por que sera?
Responder

4.
Danny Rueda Hurtado4 de febrero de 2014, 23:12

Ejercicio que pida al usuario nmeros y los vaya almacenando en una cadena, y
cuando ponga el numero "0" deje de pedir nmeros, luego que diga cuales son pares
y cuales impares.

Alguien sabe hacerlo?

Responder
Cargar ms...

Enlaces a esta entrada

Crear un enlace
Suscribirse a: Enviar comentarios (Atom)
Search

Celebramos un Game Jam?

Acerca de m
Suscribete al RSS

Seguidores Blogger
Facebook

Popular

Tags

EJERCICIOS RESUELTOS Y PROPUESTOS

1. (Ejercicio de Registro) Escriba un programa que lea datos de una persona 'P' (nombre,
edad, sexo, direccin, telfono), los almacene en un registro y los muestre.
Program Datos;
Uses Crt;
Type
Persona : Record
Nombre : String[30];
Edad : Integer;
Sexo : Char;
Direccion : String[50];
Telefono : string[12];
End;
Var
P: Persona;
Begin
Clrscr;
{carga del registro}
Write(' Ingrese su Nombre: ');
Readln( P.Nombre );
Write(' Ingrese su Edad: ');
Readln( P.Edad );
Write(' Ingrese su Sexo [M / F]: ');
Readln( P.Sexo );
Write(' Ingrese su Direccin: ');
Readln( P.Direccion );
Write(' Ingrese su Telfono: ');
Readln( P.Telefono )
{ fin carga del registro}
{mostrar informacin del registro}
Writeln(' El Nombre es: ' , P.Nombre );
Writeln(' La Edad es: ,P.Edad );
Writeln(' El sexo de la persona es: , P.Sexo );
Writeln(' La Direccin es: ', P.Direccion );
Writeln(' el numero de Telfono es: ' ,P.Telefono );
{fin mostrar informacin del registro}
End.

2. (Ejercicio de arreglo de registro) Usando el ejercicio anterior, supongamos que ahora

deseamos guardar los datos de 20 personas y buscar cul es la ms joven.
Program Mas_joven;
Uses Crt;
Type
Personas : Record
Nombre : String[30];
Edad : Integer;
Sexo : Char;
Direccion : String[50];
Telefono : string[12];
End;
arre_persona=array[1..20] of persona;
Var
persona:arre_persona;
i, Menor : Integer;
Nombre : String[30];
Begin
Clrscr;
For i := 1 to 20 do
Begin
Write(' Ingrese el Nombre de la persona ', i , ': ');
Readln( persona[i].Nombre );
Write(' Ingrese su Edad: ');
Readln( persona[i].Edad );
Write(' Ingrese su Sexo [M / F]: ');
Readln( persona[i].Sexo );
Write(' Ingrese su Direccin: ');
Readln( persona[i].Direccion );
Write(' Ingrese su Telfono: ');
Readln( persona[i].Telefono )
End;
Menor := persona[1].Edad;
For i := 2 to 20 do
If persona[i].Edad < Menor then
Begin
Menor := persona [i].Edad;
Nombre := persona [i].Nombre;
End;
Writeln(' El ms joven es ',Nombre,' y tiene ',Menor,' aos de edad.');
End.
(Ejercicio de arreglo de registro) Hacer un programa en pascal de 10 alumnos guardar
nombre, nombre de la asignatura y 4 notas. Calcular y mostrar el promedio y la suma de las
notas.
PROGRAM ARR_REGISTROS;

USES CRT;
TYPE
ALUMNOS=RECORD
NOMBRE:STRING[30];
ASIGNATURA:STRING[40];
NOTA:array[1..4] of REAL;
END;
ARRE_ALUMNOS=ARRAY[1..10] OF ALUMNOS;
VAR
ALUM:ARRE_ALUMNOS;
I,J:INTEGER;
SUMA,MEDIA:REAL;
BEGIN
CLRSCR;
FOR I:=1 TO 10 DO
BEGIN
WRITELN('INTRODUZCA EL NOMBRE DEL ALUMNO ',I);
READLN(ALUM[I].NOMBRE);
WRITELN('INTRODUZCA EL NOMBRE DE LA ASIGNATURA');
READLN(ALUM[I].ASIGNATURA);
SUMA:=0;
FOR J:=1 TO 4 DO
BEGIN
WRITELN('INTRODUZCA LA NOTA ',J);
READLN(ALUM[I].NOTA[J]);
SUMA:=SUMA + ALUM[I].NOTA[J];
END;
MEDIA:=SUMA/4;
WRITELN('LA MEDIA DEL ALUMNO ',ALUM[I].NOMBRE,' ES ', MEDIA:2:2);
WRITELN('LA SUMA ES: ',SUMA:2:2);
READLN;
END;
END.
EJERCICIO RESUELTO DE ARREGLOS DE REGISTROS
hacer un programa en pascal que almacene en un arreglo de registro la siguiente informacion de
10 trabajadores: nombre, edad, sexo, estado civil y salario base, Calcular y mostrar por pantalla la
cantidad de trabajadores del sexo masculino, cantidad de trabajadoras casadas y suma de todos
los sueldos.
program arreglo_registros;uses crt; type
trabajadores=record
nombre:string[30];
edad:integer;

sexo:char;
edo_civil:char;
salario:real;
end;
arre_trabajadores=array[1..10] of trabajadores;
var
trabajador:arre_trabajadores;
i, cant_masculino,cant_casadas:integer;
acum_salarios:real;
procedure inicializar;
begin
acum_salarios:=0;
cant_masculino:=0;
cant_casadas:=0;
end;
procedure cargar_datos;
begin for i:= 1 to 10 do
begin
writeln('tipee el nombre: ');
readln(trabajador[i].nombre);
writeln('tipee la edad del trabajador:');
readln(trabajador[i].edad);
writeln('tipee el sexo del trabajador f=femenino /m=masculino:');
readln(trabajador[i].sexo);
writeln('tipee el estado civil del trabajador c=casado/s=soltero:');
readln(trabajador[i].edo_civil);
writeln('tipee el sueldo del trabajador:');
readln(trabajador[i].salario);
end;
end;
procedure masculinos_casadas;
begin
for i:=1 to 10 do
begin
if upcase(trabajador[i].sexo)='M' then
cant_masculino:=cant_masculino+ 1;
if (upcase(trabajador[i].sexo)='F') and (upcase(trabajador[i].edo_civil)='C') then
cant_casadas:=cant_casadas+ 1; end;end;
procedure sumar_salarios;
begin
for i:= 1 to 5 do
acum_salarios:=acum_salarios + trabajador[i].salario;
end;
procedure mostrar_datos_trabajador;
begin
for i:=1 to 5 do
begin
writeln('el nombre del trabajador es: ', trabajador[i].nombre);
readln;

writeln('la edad del trabajador es: ', trabajador[i].edad);

readln;
if upcase(trabajador[i].edo_civil)='S' then
begin
writeln('el estado civil es: soltero');
readln;
end
else
begin
writeln('el estado civil es: casado');
readln;
end; writeln('el salario del trabajador es: ', trabajador[i].salario:2:2);
readln;
end;
end;
procedure mostrar;
begin
writeln('la cantidad de trabajadores masculinos es: ', cant_masculino);
readln;
writeln('la cantidad de mujeres casadas es: ', cant_casadas);
readln;
writeln('la suma de todos los sueldos es: ' ,acum_salarios:2:2);
readln;
end; {programa principal}
begin
clrscr;
inicializar;
cargar_datos;
masculinos_casadas;
sumar_salarios;
mostrar_datos_trabajador;
mostrar;
end.
(*Escribir un programa en pascal que rellene un array unidimensional con 5 nombres y en un
arreglo bidimensional guardar el monto pagado por 3 meses. Calcular el monto total pagado por
cada persona. Mostrar nombre, el monto total pagado por esa persona y los montos de cada mes*)
PROGRAM pagos;
USES
crt;
TYPE
arreglo_personas=array[1..5] of string;
arreglo_monto=array[1..5,1..3] of real;
arreglo_suma=array[1..5] of real;
VAR
per:arreglo_personas;
monto:arreglo_monto;
f,c:integer;

suma:arreglo_suma;
sumas:real;
BEGIN
FOR f:=1 TO 5 DO
BEGIN
WRITELN('Introduzca el nombre:' );
READLN(per[f]);
WRITELN('Introduzca los 3 montos de 3 meses');
sumas:=0;
FOR c:=1 TO 3 DO
BEGIN
READLN(monto[f,c]);
sumas:=sumas+monto[f,c];
END;
suma[f]:=sumas;
END;
FOR f:=1 TO 5 DO
BEGIN
WRITELN('el cliente' , per[f] , 'en tres meses ha pagado: ' , suma[f]:2:2);
READLN;
FOR c:=1 TO 3 DO
BEGIN
WRITELN('En el mes' , c, ' la persona ha pagado: ' , monto[f,c]:2:2);
READLN;
END;
END;
CLRCSR;
END.
PROPUESTOS
1. Inicializar una matriz con ceros (0) y que sea de dimensin 10x12.
2. Colocar un uno (1) en todos los espacios de la matriz en que la suma de sus ndices sea mayor
que 6. Utilice la misma matriz de dimensin 10x12.
3. Un instituto desea controlar los resultados de los alumnos en las distintas asignaturas de la
facultad de Ingeniera. El programa debe ingresar las calificaciones de los alumnos y visualizar en
pantalla la media de notas por alumno y la media de notas por asignatura. Las asignaturas estn
codificadas de 1 a 6 y hay 30 alumnos.

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]

PROBLEMAS RESUELTOS DE ARREGLOS

Ing. Gladys Garca V.

PROBLEMA NRO 1
/* ENUNCIADO : Hacer un programa que calcule la nota de un alumno en una prueba 10
preguntas de opciones mltiples ('a',...o,'e'). Cada pregunta se evala con dos puntos.
Debe inicializa un arreglo con las respuestas correctas.
El programa debe mostrar el nombre, el arreglo de respuestas correctas y el arreglo de
respuestas del alumno y la nota del alumno.
*/
// LIBRERIAS

#include<iostream.h>
#include<iomanip.h>
#include<conio.h>
#include<stdlib.h>
#include<stdio.h>// gets()

// cin y cout
// setw()
// getch() o getche()
// toupper y tolower

void main()
{
// Inicializa el array
char RptaOK[] = {'A','C','E','D','B','C','D','E','B','C'};
char ARpta[10];
char nombre[20];
int i, nota;
cout<<"Ingrese nombre del alumno : "<<endl;gets(nombre);
cout<<"Ingrese el array de respuestas: "<<endl;
// Lee array ARpta

for (i=0;i<=9;i++)
{
cin>>ARpta[i];
// convierte a mayusculas elementos de ARpta

ARpta[i] = toupper(ARpta[i]);
}
// calcula la nota del alumno

nota = 0;
for (i=0;i<=9;i++)
{
if (ARpta[i] == RptaOK[i])
{ nota = nota + 2; }
}
// muestra el nombre del alumno

cout<<"Alumno : "<<nombre<<endl;
// muestra los dos arreglos respuestas

for (i=0;i<=9;i++)
{ cout<<setw(10)<<RptaOK[i]<<setw(10)<<ARpta[i]<<endl; }
cout<<endl;
cout<<"nota = "<<nota<<endl;
getch();
}

PROBLEMA NRO 2
/*
ENUNCIADO : Hacer un programa que obtenga el maximo numero de canastas
convertido por el equipo de basket en los N partidos que jugo en el campeonato
sudamericano. Defina N como constante al inicio del programa. */
// PROGRAMA C++
// LIBRERIAS
#include<iostream.h>
#include<iomanip.h>
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>

const int N = 5;
void main()
{
// se declara array de tamao N
int Canastas[N],i,Max;
// Lectura del array A

cout<<"Ingrese los elementos del array Canastas"<<endl;

for (i=0; i< N ; i++)
{
cin>>Canastas[i]; }
// Obtener EL MAXIMO VALOR

Max = Canastas[0];
for (i=1; i< N ; i++)
{
if (Canastas[i]>Max)
{ Max = Canastas[i]; }
}
// MUESTRA EL VALOR MAXIMO Y A QUE INDICE CORRESPONDE

cout<<"Max = "<<Max<<endl;
for (i=0; i< N ; i++)
{
if (Canastas[i]==Max)
{ cout<<" i = "<<setw(5)<<i; }
}
cout<<endl;
getch();
}

PROBLEMA NRO 3

/*
ENUNCIADO : Hacer un programa que obtenga la Mnima talla de un grupo de N
atletas. Defina N como constante al inicio del programa. */
// LIBRERIAS
#include<iostream.h>
#include<iomanip.h>
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>

const int N = 5;
void main()
{
// se declara array de tamao N

double Talla[N],Min;
int i;
// Lectura del array A

cout<<"Ingrese los elementos del array Talla"<<endl;

for (i=0; i< N ; i++)
{
cin>>Talla[i]; }
// Obtener EL MINIMO VALOR

Min = Talla[0];
for (i=1; i< N ; i++)
{
if (Talla[i] < Min)
{ Min = Talla[i]; }
}
// MUESTRA EL VALOR MINIMO Y A QUE INDICE CORRESPONDE

cout<<"Min = "<<Min<<endl;
for (i=0; i< N ; i++)
{
if (Talla[i]==Min)
{ cout<<" i = "<<setw(5)<<i; }
}
cout<<endl;
getch();
}

PROBLEMA NRO 4:
/*ENUNCIADO : Hacer un programa que permita ordenar alfabeticamente una lista

de nombres de tamao N considerado constante. El tamao maximo de las

cadenas considerela 20. */
// LIBRERIAS C++
#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>

// cin y cout
// setw()
// getch()
// gets()
// strcmp() y strcpy()

const int N = 4, TC = 20;

void main()
{
char nom[N][TC],auxN[TC];
int i,j,k,v;
// LEE EL ARRAY DE NOMBRES

cout<<"Ingrese los nombres : "<<endl;

for(i=0;i< N;i++)
{ gets(nom[i]);}
// ORDENA EN ORDEN ALFABETICO

for(k=0;k<N-1;k++)
{
for(j=0;j<N-1-k;j++)
{

// numero de pasos

// numero de conbinaciones

// pregunta si nom[j] es mayor que num[j+1]

if (strcmp(nom[j],nom[j+1]) > 0)
{
strcpy(auxN,nom[j]);
strcpy(nom[j],nom[j+1]);
strcpy(nom[j+1],auxN);
}
}
}
cout<<endl;
// MUESTRA EL ARRAY EN ORDEN ALFABETICO

for(i=0;i< N;i++)
{ cout<<setw(15)<<nom[i]<<endl; }
cout<<endl;getch();
}

// a auxN le asigna nom[j]

// a nom[j] le asigna nom[j+1]
// a nom[j+1] le asigna auxN

PROBLEMA NRO 5
/* ENUNCIADO : Hacer un programa que ordene las notas de N alumnos en orden
decreciente, mostrando el reporte:
Nombre
Nota
xxxx
99
xxxx
99
-------Promedio
99
*/
// Librerias c++
#include<iostream.h>
#include<conio.h>
#include<iomanip.h>
#include<stdio.h>
#include<string.h>

const int N = 5, TC = 20;

void main()
{ double nota[N],auxNt, SNota, PromN;
char nom[N][TC],auxN[TC];

int i,j,k;
// lectura de loa arrays nom y nota

SNota = 0;
for(i=0;i<N;i++)
{ cout<<"nombre: "<<endl;gets(nom[i]);
cout<<"nota : ";cin>>nota[i];
SNota = SNota + nota[i];

}
PromN = SNota/N;
// ordenamiento de notas de mayor a menor

for(k=0;k<N-1;k++) // nro de pasos

{ for(j=0;j<N-1-k;j++) // nro de comparaciones
{ // compara las notas
if (nota[j]<nota[j+1])
{ // intercambio de notas

auxNt = nota[j];
nota[j] = nota[j+1];
nota[j+1] = auxNt;
// intercambio de nombres

strcpy (auxN , nom[ j ]);

strcpy (nom[ j ], nom[ j+1]);
strcpy (nom[ j + 1], auxN);

}
}
}
// muestra los arrays paralelos ordenados

cout<<setw(20)<<"nombre"<<setw(20)<<"nota"<<endl;
for(i=0;i<N;i++)
{ cout<<setw(20)<<nom[i]<<setw(20)<<nota[i]<<endl;
}
cout<<setw(40)<<"-----"<<endl; cout<<setw(40)<<PromN<<endl; getch();
}

PROBLEMA NRO 6
/* ENUNCIADO : Hacer un programa que ordene los nombres de N alumnos en sentido
inverso al alfabtico. Debe mostrar este reporte:
Nombre
Nota
xxxxxx
99
xxxxxx
99
---Promedio
99

*/
// Librerias C++
#include<iostream.h>
#include<conio.h>
#include<iomanip.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>

const int N = 5, TC = 20;

void main()
{ double nota[N], auxNt; // auxiliar de nota
char nom[N][TC], auxN[TC]; // auxiliar de nombre
int rpta,i,j,k,v;
// lectura de loa arrays nom y nota

for(i=0;i< N;i++)
{ cout<<"nombre: "<<endl;gets(nom[i]);
cout<<"nota : ";cin>>nota[i];
}
// ordenamiento de notas de mayor a menor

for (k=0;k< N-1;k++)

// nro de pasos
{
for (j=0;j<N-1-k;j++) // nro de comparac.
{ if (strcmp(nom[j],nom[j+1])<0)
{ // intercambio de notas
auxNt = nota[j];
nota[j] = nota[j+1];
nota[j+1] = auxNt;
// intercambio de nombres

strcpy(auxN , nom[j]);
strcpy(nom[j], nom[j+1]);
strcpy(nom[j+1], auxN);
}
}
}
// muestra los arrays paralelos ordenados

cout<<setw(25)<<"nombre"<<setw(25)<<"nota"<<endl;
for (i=0;i<=4;i++)
{ cout<<setw(25)<<nom[i]<<setw(25)<<nota[i]<<endl; }
getch();
}

PROBLEMA NRO 7
/* ENUNCIADO : Hacer un programa que calcule el valor numrico de un
polinomio de grado N cuyos coeficientes , grado y valor de x son ingresados con
teclado. Considere un grado mximo de 99
**/
#include<iostream.h>
#include<conio.h>
#include<math.h>

const int N = 100;

void main()
{
int G,i;
double Poli[100], X, VN;
cout<<"Ingrese el grado del polinomio : ";cin>>G;
cout<<"Ingrese el valor de X = ";cin>>X;
// Lectura DE los coeficientes del polinomio

cout<<"Ingrese los coeficientes del polinomio: "<<endl;

for(i=0;i<G+1;i=i+1)
{
cout<<"Poli[ "<<i<<"] = ";cin>>Poli[i];
}
// calculo del valor numerico:

VN = 0;
for(i=0;i<G+1;i=i+1)

{
VN = VN + Poli[i] * pow(X,i) ;
}
cout<<"Valor numerico = "<<VN<<endl;
getch();
}

PROBLEMA NRO 8
/* ENUNCIADO : Hacer un programa que calcule los costos de produccin de n
productos ingresados por teclado, si se conocen los costos unitarios y las
unidades producidas de cada uno de los productos
*/
#include<iostream.h>
#include<conio.h>
#include<iomanip.h>

const int N = 15;

void main()
{
double CosUni[N], costo[N],CosTot;
int UnidProd[N],n,i;
cout<<"Ingrese el tamao de los arrays ";cin>>n;
// LEER LOS ARRAYS CosUni y UnidProd

cout<<"Ingrese elementos de CosuUni y UnidProd : "<<endl;

for(i=0;i<n;i=i+1)
{ cin>>CosUni[i];
cin>>UnidProd[i];
}
// Calculo del array Costo :

for(i=0;i<n;i=i+1)
{ costo[i]= CosUni[i]*UnidProd[i]; }
// Calculo del costo total CosTot

CosTot =0;
for(i=0;i<n;i=i+1)
{ CosTot = CosTot + costo[i]; }

// mostrar el reporte

for(i=0;i<n;i=i+1)
{ cout<<setw(10)<<CosUni[i]<<setw(10)<<UnidProd[i]<<setw(10)<<costo[i]<<endl; }
cout<<setw(30)<<CosTot<<endl;
getch();
}

PROBLEMA NRO 9 :
/* ENUNCIADO : Una librera que comercializa 5 productos diversos, maneja los siguientes arrays:
- cosUni que guarda el Precio costo de cada producto
- preUni que guarda el Precio venta de cada producto
- UnidVend que guarda las unidades vendidas en un mes
Hacer un programa que permita calcular:
el monto de dinero invertido,
el monto de la venta, la ganancia en cada producto y
la ganancia total
Debe mostrar este reporte:
Venta
Costo
Ganancia
999.99
999.99
999.99
999.99
999.99
999.99
.....
.....
......
999.99
999.99
999.99
---------------999.99
999.99
999.99 */
// Librerias C++
#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
const int N = 5;

void main()
{ double cosUni[N], preUni[N], UnidVend[N], Costo[N],Venta[N],Gan[N],GT;
int i,j;
// Lectura de los arrays cosUni, preUni, UnidVend

for (i=0;i<N;i++)

cout<<"cosUni["<<i<<"] = ";cin>>cosUni[i];
cout<<"preUni["<<i<<"] = ";cin>>preUni[i];
cout<<"UnidVend["<<i<<"] = ";
cin>>UnidVend[i];

GT=0.0; // inicializa la ganancia total en 0

for (i=0;i<N;i++)
{ // Genera los arrays MonInver, Venta
Costo[i] = cosUni[i] * UnidVend[i];
Venta[i] = preUni[i] * UnidVend[i];
// Genera el array Gan

Gan[i] = Venta[i] - Costo[i];

GT = GT + Gan[i]; // Acumula la ganancia total
}
// Muestra Reporte:

cout<<"El REPORTE ES EL SIGUIENTE :"<<endl;

cout<<setw(10)<<"Costo"<<setw(10)<<"Venta"<<setw(10)<<"Ganancia"<<endl;

for (i=0;i<N;i++)
{

cout<<setw(10)<<Costo[i]<<setw(10)<<Venta[i]<<setw(10)<<Gan[i]<<endl; }

cout<<setw(30)<<GT<<endl;
getch();
}

Cuestionario de Arreglos
Cuestionario de Arreglos
1. Que es un arreglo unidimensional?
Un arreglo unidimensional se trata de un conteo o una cuenta ya sea de nmeros o de
almacenamiento de datos en el que esta compuesta de una sola columna o una sola fila.
2. Escriba 3 ejemplos de arreglos unidimensionales
Ejemplo 1
lista de litros de agua
1
2
2
3
4
n
Ejemplo 2
caloras
250
234
500
1000
10000
Ejemplo 3
reprobados en universidades
5
6
7
8
9
1000
3. Que es un arreglo bidimensional?
Los arreglos bidimensionales son tablas de valores Cada elemento de un arreglo bidimensional
est simultneamente en una fila y en una columna como las matrices.

4. Escriba 3 ejemplos de arreglos bidimensionales

Ejemplo 1
matriz
100
010
100
Ejemplo 2
matriz
23 24 25
11 12 14
11 0 34
Ejemplo 3
matriz en electrnica
i1 i2 i3
6 7 8
1 2 9
5. Escriba 3 problemas en los cuales se usen los arreglos para su solucin
Ejemplo 1
El siguiente cdigo despliega todos los elementos de un arreglo bidimensional de 3 por 4,
empleando dos tcnicas diferentes.

Ejemplo 2

El siguiente programa muestra el resultado de multiplicar cada elemento del arreglo val por el
nmero 10.

Ejemplo 3
Algoritmo para saber la temperatura.

6. Escriba 3 ejemplos de la declaracin de arreglos unidimensionales Usando Dev-C++.

7. Escriba 3 ejemplos de la declaracin de arreglos bidimensionales usando Dev-C++.

Arrays en C++. Ejemplos

Un array es una coleccin finita de datos del mismo tipo, que se almacenan en
posiciones consecutivas de memoria y reciben un nombre comn.

Ejemplo de array: Supongamos que queremos guardar las notas de los 20

alumnos de una clase. Para ello utilizaremos un array de 20 elementos y en
cada elemento almacenaremos una nota.
Podemos representar grficamente el array de notas de la siguiente forma:
Array notas:

Para acceder a cada elemento del array se utiliza el nombre del array y uno o
ms ndices que indican la posicin que ocupa el elemento dentro del array.
Cada ndice se escribe entre corchetes.
El primer elemento del array ocupa la posicin 0, el segundo la posicin 1,
etc. En un array de N elementos el ltimo ocupar la posicin N-1.
En el ejemplo anterior, notas[0] contiene la nota del primer alumno y
notas[19] contiene la del ltimo
Cmo declarar un array:
Un array se declara de forma parecida a una variable de tipo simple
aadindole al nombre el nmero de elementos que contendr el array.
De forma general, un array se declara as:
tipo_dato nombre_array[elementos1][elementos2]..;
elementos1, elementos2, etc. son los ndices del array. Deben ser nmeros
enteros positivos o expresiones con un resultado entero positivo. Indican el
nmero de elementos del array.
En el ejemplo anterior, el array notas se declara como:
double notas[20];
El array es unidimensional, se llama notas y contiene 20 elementos de tipo
double.
Ms ejemplos de declaracin de arrays:
int ventas[10] ; //array llamado ventas que contiene 10 enteros

double grados[20]; //array grados que contiene 20 elementos de tipo double

float precios[30]; //array llamado precios que contiene 30 elementos de tipo float
El nmero de ndices determina la dimensin del array. Si el array tiene
solo un ndice es un array de una dimensin o unidimensional (tambin
llamado vector), si tiene dos ndices es un array de dos dimensiones o
bidimensional (tambin llamados matrices, tablas o arreglos), si tienen tres
ndice tridimensional, etc.
Para facilitar la modificacin del programa, el tamao del array se puede
declarar utilizando una constante en lugar de una cantidad entera. Esto hace
ms fcil modificar el programa ya que todas las referencias al tamao mximo
del array (por ejemplo, en bucles for o en definiciones de arrays) pueden ser
modificadas cambiando el valor de la constante.
Por ejemplo, declaracin de 4 arrays A, B, C y D de 10 elementos cada uno de
tipo double usando una constante llamada ELEMENTOS:
const int ELEMENTOS = 10;
double A[ELEMENTOS], B[ELEMENTOS], C[ELEMENTOS], D[ELEMENTOS];
En este caso si se modifica el tamao de los arrays, solo habr que cambiar el
valor de la constante.
Los arrays declarados como locales en una funcin tienen como valores
iniciales valores indeterminados, como ocurre con las variables locales.
La declaracin de un array puede incluir la asignacin de valores
iniciales.
La forma general de hacerlo es:
tipo nombre_array[tamao]={valor1,valor2,..,valorn};
Donde valor1 es el valor del primer elemento del array, valor2 el valor del
segundo elemento, y as sucesivamente.
El tamao del array es opcional cuando se asignan valores iniciales en la
declaracin.
Todos los elementos del array que no tienen asignados valores iniciales
explcitos, (sucede cuando un array tienes ms elementos que valores iniciales
se han asignado), sern puestos automticamente a cero.

Ejemplos de asignacin de valores iniciales en la declaracin de un array en

C++:
double porcentaje[]={0, 0.3, 7.25, 4.2};
Se declara un array unidimensional llamado porcentaje que contiene 4 elementos de tipo double.
El nmero de elementos no es necesario indicarlo porque se estn asignando4 valores iniciales. El
compilador asume que el array tiene 4 elementos.
int numeros[5]= {1,4,-7,5,9};
Se declara un array unidimensional llamado numeros que contiene 5 elementos de tipo int. Se
indica el nmero de elementos aunque no es necesario hacerlo. Se estn asignando 5 valores
iniciales. El compilador asume que el array tiene 5 elementos.
int digitos[8]= {3,4,2,7};
Se declara un array unidimensional llamado digitos que contiene 8 elementos de tipo int. Aqu s
es necesario indicar el nmero de elementos del array porque solo se le asignan valores iniciales a
los cuatro primeros. El compilador asumira que el array tiene solo 4 elementos. En este caso los
cuatro ltimos elementos del array que no reciben valores iniciales, toman el valor 0.
digitos[0]=3, digitos[1]=4, digitos[2]=2, digitos[3]=7,
digitos[4]=0, digitos[5]=0, digitos[6]=0, digitos[7]=0
Las declaraciones de arrays que hemos hecho hasta ahora se llaman
declaraciones implcitas: para cada array que se declara hay que indicar el
tipo y la dimensin.
Una alternativa a esto es definir un nuevo tipo de dato para el array
asignndole un nombre, y posteriormente declarar las variables como
pertenecientes a ese tipo.
C++ dispone del especificador typedef que permite la creacin de nuevos
tipos de datos.
Los tipos de datos creados con typedef son sinnimos de otros tipos ya
existentes.
Por ejemplo, la siguiente instruccin crea un nuevo tipo de dato llamado
entero, sinnimo de int.
typedef int entero;
A partir de esta instruccin podemos declarar variables enteras as:
entero a, b=3;

Utilizando typedef podemos crear nuevos tipos de datos sinnimos de tipos array. La
forma general de hacerlo es:

typedef tipo_base nombre_nuevo_tipo[dimension];

Ejemplo:

typedef int Tvector[30];

Esta instruccin crea un nuevo tipo de dato llamado Tvector. Las variables que
se declaren de este tipo sern arrays de 30 enteros.
Por ejemplo:
Tvector a, b;
Se han declarado a y b de tipo Tvector; a y b son dos arrays de 30 enteros.
Ejemplos de arrays es C++:
Ejemplo 1: programa C++ que accede y modifica los elementos de un array
Los elementos de un array se pueden utilizar igual que cualquier otra variable y se
puede hacer con ellos las mismas operaciones que se pueden hacer con el resto de
variables.
#include <iostream>
using namespace std;
int main ()
{
int n, m = 5;
int a[]={2,8,3,0,4}; //se declara un array de 5 elementos de tipo
//int con esos valores iniciales
n = a[0];

//n = 2

a[0]=a[1]+a[2]; //a[0]= 8 + 3 = 11
a[1]++;

//a[1]= 9

a[n]=m+10;

//a[2]= 15

a[n+1]=7;

//a[3]= 7

if(a[0]>=a[1])

//if(11 >= 9)

a[4]=a[0];

//

a[4]= 11

cout << a[0]<<" "<< a[1]<< " "<< a[2]<< " "<< a[3]<< " "<< a[4];
cout << endl;
system("pause");
}
La salida de este programa es:
11 9 15 7 11
Si se intenta acceder a un elemento que est fuera de los lmites del array (un
elemento con ndice negativo o con un valor del ndice mayor que el que corresponde
al ltimo elemento del array) el compilador no avisa del error. El error se producir
durante la ejecucin si esa posicin de memoria que se intenta acceder est fuera de
la zona de memoria asignada al programa.
Es responsabilidad del programador comprobar que los valores de los ndices utilizados
en los accesos a los elementos del array estn dentro de los lmites del array.
Ejemplo 2: recorrer un array

Para recorrer un array se utiliza una instruccin iterativa (normalmente una

instruccin for) utilizando una variable entera como ndice que tomar valores
desde el primer elemento al ltimo o desde el ltimo al primero.
El siguiente programa declara un array de 7 elementos de tipo double llamado
notas y le asigna valores iniciales. A continuacin recorre el array, utilizando la
instruccin for, para mostrar por pantalla el contenido del array.
#include <iostream>
#include <iomanip>
using namespace std;
int main ()
{
int i;
double notas[]={2.3,8.5,3.2,9.5,4,5.5,7.0}; //array de 7
elementos
cout << fixed << setprecision(2);
for(i=0; i<7; i++)

cout << notas[i] << " "; //se muestra cada elemento del
array
cout << endl;
system("pause");
}
La salida que muestra este programa es:
2.30 8.50 3.20 9.50 4.00 5.50 7.00
Ejemplo 3: Recorrido de un array. Programa C++ que lee por teclado la nota de los
alumnos de una clase y calcula la nota media del grupo. Tambin muestra los alumnos
con notas superiores a la media.

Este programa declara un array de elementos de tipo float que contendr las
notas de los alumnos.
Se realizan 3 recorridos sobre el array, el primero para asignar a cada
elemento las notas introducidas por teclado, el segundo para sumarlas y el
tercero para mostrar los alumnos con notas superiores a la media.
#include <iostream>
#include <iomanip>
using namespace std;
int main ()
{
float notas[20];

//array de NUMALUM elementos tipo float

int i = 0;
float suma = 0, media;

// Entrada de datos. Se asigna a cada elemento del array

// la nota introducida por teclado
for (i=0; i<20; i++)
{
cout << "Alumno " << i+1 << " Nota final: ";

cin >> notas[i];

}

// Sumar todas las notas

for (i=0; i<20; i++)
suma = suma + notas[i];

// Calcular la media
media = suma / 20;

// Mostrar la media
cout << fixed << setprecision(2);
cout << endl<< endl << "Nota media del curso: " << media <<
endl;

// Mostrar los valores superiores a la media

cout << "Listado de notas superiores a la media" << endl;
cout << "--------------------------------------" << endl;
for (i=0; i<20; i++)
if (notas[i] > media)
{
cout << "Alumno numero " << setw(3) << i+1;
cout << " Nota final: " << notas[i] << endl;
}
cout << endl;
system("pause");
}

Captulo VII: Matrices

Posted by
Posted on sep - 25 - 2011
0 Comment

Son arreglos bidimensionales, es una coleccin finita, homognea y ordenada de datos. Una
matriz esta compuesta por filas y columnas, en la que se hace referencia a cada elemento
por medio de dos ndices. El primero de los ndices se utiliza para indicar la fila y el
segundo de los ndices para indicar la columna.

Declaracin de una matriz:

tipo_de_dato identificador[numFilas][numColumnas];;
Dnde :
tipo_de_dato: Es el tipo de datos que contendr la matriz.
identificador: Es el nombre que le damos a la variable matriz y por el cual la
referenciaremos en nuestro programa.
[numFilas][numColumnas] : Especifica el numero de Filas y de columnas que tendr la
matriz
El espacio que las matrices ocupan en memoria se reserva en el momento de realizar la
declaracin de los mismos.
Ejemplo:
int A[3][4];
1columnas
float B[6][2];
columnas

// Declaracin de una matriz de enteros de 3 filas y 4

// Declaracin de una matriz de reales de 6 filas y 2

3char C[4][10]; // Declamacin de una matriz de caracteres de 4 filas y 10

columnas

Inicializacion de una Matriz

Una matriz se pude inicializar para esto hay que agrupar entre {} cada fila. El formato a
utilizar sera el siguiente:
1tipo_de_dato identificador[ filas ][ columnas ] = {
2

{ columnas de la fila 1 },

{ columnas de la fila 2 },

... ,

{ columnas de la ltima fila }

};

No debemos olvidar el ; al final.

Ejemplo:
int temperaturas[3][5] = { { 15, 17, 20, 25, 10 }, { 18, 20, 21, 23, 18
}, { 12, 17, 23, 29, 16 } };

Ejercicios Resueltos de Matrices

1) Hacer un programa para generar una matriz de f filas y c columnas y calcular el mayor,
el menor y el promedio.
1
2

#include<iostream>
using namespace std;

3
#define MAX 10

4
5
6
7

void ordenMatriz(int &f, int &c);

void ingresoMatriz(float M[MAX][MAX], int f, int c);
void reporteMatriz(float M[MAX][MAX], int f, int c);

8 float mayor(float M[MAX][MAX], int f, int c);

9 float menor(float M[MAX][MAX], int f, int c);
float promedio(float M[MAX][MAX], int f, int c);

10
11

int main()

12

13
float M[MAX][MAX];

14
15

int f,c;
ordenMatriz(f,c);

16

ingresoMatriz(M,f,c);

17

cout<<"Matriz ingresada"<<endl;

18

reporteMatriz(M,f,c);

19

cout<<"El mayor es : "<<mayor(M,f,c)<<endl;

20
21

cout<<"El menor es : "<<menor(M,f,c)<<endl;

cout<<"El promedio : "<<promedio(M,f,c)<<endl;
system("PAUSE");

22
return 0;

23

24
25

void ordenMatriz(int &f, int &c)

26{
27

do{

28

cout<<"Numero de filas : ";

29

cin>>f;

30
31
32

}while(f<=0 || f>MAX);
do{
cout<<"Numero de columnas : ";
cin>>c;

33

}while(c<=0 || c>MAX);

34}
void ingresoMatriz(float M[][MAX], int f, int c)

35

36

int i,j;

37
for(i=0;i<f;i++)

38

for(j=0;j<c;j++)

39

40

cout<<"M["<<i<<"]["<<j<<"]:";

41

cin>>M[i][j];
}

42
43}

44void reporteMatriz(float M[][MAX],int f, int c)

{

45

int i,j;

46
for(i=0;i<f;i++)

47

48

for(j=0;j<c;j++)

49

cout<<M[i][j]<<"t";

50
51

cout<<endl;
}

52}
53
54float mayor(float M[][MAX], int f, int c)
{

55
56

int i,j;
float may=M[0][0];

57
for(i=0;i<f;i++)

58
59
60
61

for(j=0;j<c;j++)
if(M[i][j]>may)
may=M[i][j];
return may;

62
63
float menor(float M[][MAX], int f, int c)

64

65

int i,j;

66

float men=M[0][0];

67

for(i=0;i<f;i++)

68
69

for(j=0;j<c;j++)
if(M[i][j]<men)
men=M[i][j];

70
71

return men;

72
73
float promedio(float M[][MAX], int f, int c)

74

75

int i,j;

76

float s=0;

77

for(i=0;i<f;i++)

78
79
80
}

81
82

for(j=0;j<c;j++)
s=s+M[i][j];
return s/(f*c);

83
84
85
86
87
88
89
90

2) Ingresar una matiz de f filas y c columnas y calcular la suma de filas y la suma de

columnas
1 #include<iostream>
2
3 using namespace std;
4
5 #define MAX 10
6
7
8

void ordenMatriz(int &f, int &c);

void ingresoMatriz(float M[MAX][MAX], int f, int c);
void reporteMatriz(float M[MAX][MAX], int f, int c);

void sumaDeFilas(float A[MAX][MAX], int f, int c,float sf[MAX]);

10

void sumaDeColumnas(float A[MAX][MAX], int f, int c,float sc[MAX]);

11
12

int main()

13{
14

float M[MAX][MAX],sf[MAX],sc[MAX];

15

int f,c,i,j;

16

ordenMatriz(f,c);

17

ingresoMatriz(M,f,c);
cout<<"Matriz ingresada"<<endl;

18

reporteMatriz(M,f,c);

19

sumaDeFilas(M,f,c,sf);

20
for(i=0;i<f;i++)

21

cout<<"suma de fila "<<i<<" = "<<sf[i]<<endl;

22

sumaDeColumnas(M,f,c,sc);

23

for(j=0;j<c;j++)

24

cout<<"suma de columna "<<j<<" = "<<sc[j]<<endl;

25

system("PAUSE");

26

return 0;

27}
28
void ordenMatriz(int &f, int &c)

29

30
do{

31

cout<<"Numero de filas : ";

32

cin>>f;

33

}while(f<=0 || f>MAX);

34

do{

35

cout<<"Numero de columnas : ";

36

cin>>c;

37

}while(c<=0 || c>MAX);

38
39

void ingresoMatriz(float M[][MAX], int f, int c)

40

41

int i,j;

42

for(i=0;i<f;i++)
for(j=0;j<c;j++)

43

44

cout<<"M["<<i<<"]["<<j<<"]:";

45
cin>>M[i][j];

46

47

48
49void reporteMatriz(float M[][MAX],int f, int c)
50{
51

int i,j;

52

for(i=0;i<f;i++)

53

{
for(j=0;j<c;j++)

54

cout<<M[i][j]<<"t";

55
cout<<endl;

56

57

58
59void sumaDeFilas(float A[MAX][MAX], int f, int c,float sf[MAX])
60{
61

int i,j;

62

for(i=0;i<f;i++)

63

64
65

sf[i]=0;
for(j=0;j<c;j++)
sf[i]=sf[i]+A[i][j];

66

67}
68
void sumaDeColumnas(float A[MAX][MAX], int f, int c,float sc[MAX])

69

70

int i,j;

71
for(j=0;j<c;j++)

72

73

sc[j]=0;

74

for(i=0;i<f;i++)

75
76

sc[j]=sc[j]+A[i][j];
}

77}
78
79
80
81
82
83
84
85

3) Ingresar una matriz de f filas y c columnas y calcular su matriz transpuesta.

#include<iostream>

1
using namespace std;

2
3

#define MAX 10

4 void ordenMatriz(int &f, int &c);

5 void ingresoMatriz(float M[MAX][MAX], int f, int c);
6
7

void reporteMatriz(float M[MAX][MAX], int f, int c);

void transpuesta(float M[MAX][MAX], int f, int c,float T[MAX][MAX]);
int main()

8
{

float M[MAX][MAX],T[MAX][MAX];

10

int f,c;

11

ordenMatriz(f,c);

12

ingresoMatriz(M,f,c);

13

cout<<"Matriz ingresada"<<endl;

14

reporteMatriz(M,f,c);

15
16

transpuesta(M,f,c,T);
cout<<"Matriz Transpuesta "<<endl;
reporteMatriz(T,c,f);

17
system("PAUSE");

18

19

void ordenMatriz(int &f, int &c)

20{
21

do{

22

cout<<"Numero de filas : ";

23

cin>>f;

24
25
26

}while(f<=0 || f>MAX);
do{
cout<<"Numero de columnas : ";
cin>>c;

27
}while(c<=0 || c>MAX);

28

29
30void ingresoMatriz(float M[][MAX], int f, int c)
31{
32
33

int i,j;
for(i=0;i<f;i++)
for(j=0;j<c;j++)

34
{

35

cout<<"M["<<i<<"]["<<j<<"]:";

36

cin>>M[i][j];

37

38}
39
40void reporteMatriz(float M[][MAX],int f, int c)
41{
42
43

int i,j;
for(i=0;i<f;i++)
{

44
for(j=0;j<c;j++)

45

cout<<M[i][j]<<"t";

46
47

cout<<endl;
}

48}
49
50void transpuesta(float M[MAX][MAX], int f, int c,float T[MAX][MAX])
51{
52
53

int i,j;
for(i=0;i<f;i++)

54
55

for(j=0;j<c;j++)
T[j][i]=M[i][j];

56
57
58
59
60
61
62

4) Programa para ingresar dos matrices, una de f1 filas y c1 columnas y otra de f2 filas y c2
columnas y reportar su suma y su producto si es que se pueden realizar.
1 #include<iostream>
2 using namespace std;
3 #define MAX 10
4
5

void ordenMatriz(int &f, int &c);

void ingresoMatriz(float M[MAX][MAX], int f, int c);

6
void reporteMatriz(float M[MAX][MAX], int f, int c);

void sumaMatrices(float A[MAX][MAX],float B[MAX][MAX],float C[MAX][MAX],

8 int f, int c);

9 void productoMatrices(float A[MAX][MAX],float B[MAX][MAX],float

P[MAX][MAX], int f1, int c1,int c2);

10

int main()

11

12

float A[MAX][MAX],B[MAX][MAX],C[MAX][MAX],S[MAX][MAX],P[MAX][MAX];

13

int f1,c1,f2,c2;

14

cout<<"Primera matriz"<<endl;

15

ordenMatriz(f1,c1);

16

ingresoMatriz(A,f1,c1);
cout<<"Segunda matriz"<<endl;

17

ordenMatriz(f2,c2);

18

ingresoMatriz(B,f2,c2);

19
if(f1==f2 && c1 == c2)

20

21

sumaMatrices(A,B,S,f1,c1);

22

cout<<"Matriz Suma"<<endl;

23

reporteMatriz(S,f1,c1);

24

25

else
cout<<"No se pueden sumar las matrices"<<endl;

26
27

if(c1==f2)
{

28
productoMatrices(A,B,P,f1,c1,c2);

29

cout<<"Matriz Producto"<<endl;

30

reporteMatriz(P,f1,c2);

31

32

else

33

cout<<"No se pueden multiplicar las matrices "<<endl;

34

system("PAUSE");

35

return 0;

36
37

void ordenMatriz(int &f, int &c)

38

39
do{

40

cout<<"Numero de filas : ";

41

cin>>f;

42
43

}while(f<=0 || f>MAX);
do{
cout<<"Numero de columnas : ";

44
cin>>c;

45

}while(c<=0 || c>MAX);

46

47void ingresoMatriz(float M[][MAX], int f, int c)

48{
49

int i,j;

50

for(i=0;i<f;i++)
for(j=0;j<c;j++)

51

52

cout<<"M["<<i<<"]["<<j<<"]:";

53
cin>>M[i][j];

54

55

56
57void reporteMatriz(float M[][MAX],int f, int c)
58{
59

int i,j;

60

for(i=0;i<f;i++)

61

{
for(j=0;j<c;j++)

62

cout<<M[i][j]<<"t";

63

cout<<endl;

64
}

65}
66
67void sumaMatrices(float A[MAX][MAX],float B[MAX][MAX],float S[MAX][MAX],
int f, int c)

68

69

int i,j;

70

for(i=0;i<f;i++)
for(j=0;j<c;j++)

71

S[i][j]=A[i][j]+B[i][j];

72
73
}

74
75

void productoMatrices(float A[MAX][MAX],float B[MAX][MAX],float

76P[MAX][MAX], int f1, int c1,int c2)

77{
78

int i,j,k;

79

for(i=0;i<f1;i++)
for(j=0;j<c2;j++)

80

81

P[i][j]=0;

82

for(k=0;k<c1;k++)

83
84
85

86
87
88
89

P[i][j]=P[i][j]+A[i][k]*B[k][j];
}

90
91
92

5) Programa que ingresa el orden de una Matriz cuadrada y generarla y luego

hacer lo siguiente:
a) Calcula la suma de los elementos de la diagonal principal.
b) Calcula el promedio de los elementos de la diagonal secundaria.
c) Calcula el mayor de los elementos de la matriz triangular inferior.
d) Calcula el promedio de los elementos de la matriz triangular superior.
1

#include<iostream>

using namespace std;

3
4

#define MAX 10

5
6
7
8
9

void ordenMatriz(int &n);

void ingresoMatriz(float M[MAX][MAX], int f, int c);
void reporteMatriz(float M[MAX][MAX], int f, int c);
float sumaDiagonalPrincipal(float M[MAX][MAX], int n);
float promedioDiagonalSecundaria(float M[MAX][MAX], int n);

10
11

float mayorElementoTriangularSuperior(float M[MAX][MAX], int n);

float promedioMatrizTriangularInferior(float M[MAX][MAX], int n);

12
13

int main()

14 {
15

float M[MAX][MAX];

16

int n;

17

ordenMatriz(n);

18

ingresoMatriz(M,n,n);

19

cout<<"Matriz ingresada"<<endl;

20

reporteMatriz(M,n,n);

21
22
23

cout<<"Suma de la diagonal principal :

"<<sumaDiagonalPrincipal(M,n)<<endl;
cout<<"Promedio de los elementos de la diagonal
secundaria: "<<promedioDiagonalSecundaria(M,n)<<endl;
cout<<"Mayor elemento de la matria triangular superior

24 "<<mayorElementoTriangularSuperior(M,n)<<endl;
25

cout<<"Promedio de la matria triangular inferior:

"<<promedioMatrizTriangularInferior(M,n)<<endl;

26

system("PAUSE");

27

return 0;

28 }
29
30
31 void ordenMatriz(int &n)
32 {
do{

33

cout<<"Orden de la matriz cuadrada: ";

34

cin>>n;

35

}while(n<=0 || n>MAX);

36
}

37
38
void ingresoMatriz(float M[][MAX], int f, int c)

39
40
41

{
int i,j;
for(i=0;i<f;i++)

42

for(j=0;j<c;j++)

43

44

cout<<"M["<<i<<"]["<<j<<"]:";

45

cin>>M[i][j];
}

46
47

}
void reporteMatriz(float M[][MAX],int f, int c)

48
{

49

int i,j;

50

for(i=0;i<f;i++)

51

52

for(j=0;j<c;j++)
cout<<M[i][j]<<"t";

53

cout<<endl;

54
}

55
56

57
float sumaDiagonalPrincipal(float M[][MAX], int n)

58
{

59

int i,j;

60

float s=0;

61

for(i=0;i<n;i++)

62

for(j=0;j<n;j++)

63

if(i==j)
s=s+M[i][j];

64

return s;

65
66

67
68

float promedioDiagonalSecundaria(float M[][MAX], int n)

{

69

int i,j;

70

float s=0;
for(i=0;i<n;i++)

71

for(j=0;j<n;j++)

72

if(i+j==n-1)

73
s=s+M[i][j];

74
75

return s/n;
}

76
77 float mayorElementoTriangularSuperior(float M[MAX][MAX], int n)
78 {
79

int i,j;

80

float may=M[0][0];
for(i=0;i<n;i++)

81

for(j=0;j<n;j++)

82

if(i<=j && M[i][j]>may)

83
may=M[i][j];

84
85

return may;
}

86
87 float promedioMatrizTriangularInferior(float M[MAX][MAX], int n)
88 {
89

int i,j,c=0;

90

float s=0;

91

for(i=0;i<n;i++)

92
93

for(j=0;j<n;j++)
if(i>=j)
{

94

s = s + M[i][j];

95

c++;
}

96

return s/c;

97
}

98
99
100
101
102
103
104
105

6) Ingresar una matriz cuadrada y reportar si es simtrica.

1 #include<iostream>
2

using namespace std;

3
4

#define MAX 10

5
void ordenMatriz(int &n);

6
7
8

void ingresoMatriz(float M[MAX][MAX], int f, int c);

void reporteMatriz(float M[MAX][MAX], int f, int c);
bool esSimetrica(float M[MAX][MAX], int n);

9
10
11int main()

12{
13
14
15

float M[MAX][MAX];
int n;
ordenMatriz(n);
ingresoMatriz(M,n,n);

16
cout<<"Matriz ingresada"<<endl;

17
18

reporteMatriz(M,n,n);
if(esSimetrica(M,n))

19
20

cout<<"La matriz es simetrica"<<endl;

else
cout<<"La matriz no es simetrica"<<endl;

21
22
23

system("PAUSE");
return 0;

24
25
26

void ordenMatriz(int &n)

27
{

28
29
30
31

do{
cout<<"Orden de la matriz cuadrada: ";
cin>>n;
}while(n<=0 || n>MAX);

32}
33
34void ingresoMatriz(float M[MAX][MAX], int f, int c)
35{
36

int i,j;

for(i=0;i<f;i++)

37

for(j=0;j<c;j++)

38

39
40

cout<<"M["<<i<<"]["<<j<<"]:";
cin>>M[i][j];

41
}

42

43

void reporteMatriz(float M[MAX][MAX],int f, int c)

44{
45

int i,j;

46

for(i=0;i<f;i++)

47

{
for(j=0;j<c;j++)

48

cout<<M[i][j]<<"t";

49

cout<<endl;

50
}

51

52
53

bool esSimetrica(float M[MAX][MAX], int n)

54{
55

int i,j;

56

for(i=0;i<n;i++)

57
58
59
60
}

61

for(j=i+1;j<n;j++)
if(M[i][j]!=M[j][i])
return false;
return true;

62
63
64
65
66

7) Ingresar una matriz y reportar el mayor elemento de cada fila

1
2

#include<iostream>
using namespace std;

3
#define MAX 10

4
5
void ordenMatriz(int &f, int &c);

6
7

void ingresoMatriz(float M[MAX][MAX], int f, int c);

void reporteMatriz(float M[MAX][MAX], int f, int c);

8 void mayorElementoDeCadaFila(float M[MAX][MAX], int f, int c);

9
10int main()
11{
12
13
14

float M[MAX][MAX];
int f,c;
ordenMatriz(f,c);
ingresoMatriz(M,f,c);

15
cout<<"Matriz ingresada"<<endl;

16
17
18

reporteMatriz(M,f,c);
mayorElementoDeCadaFila(M,f,c);
system("PAUSE");

19

return 0;

20}
21
22
23
void ordenMatriz(int &f, int &c)

24

25

do{

26
cout<<"Numero de filas : ";

27
28
29

cin>>f;
}while(f<=0 || f>MAX);
do{

30

cout<<"Numero de columnas : ";

31

cin>>c;

32

}while(c<=0 || c>MAX);

33}
void ingresoMatriz(float M[MAX][MAX], int f, int c)

34

35
int i,j;

36

for(i=0;i<f;i++)

37

for(j=0;j<c;j++)

38

39

cout<<"M["<<i<<"]["<<j<<"]:";

40

cin>>M[i][j];

41

42}
void reporteMatriz(float M[MAX][MAX],int f, int c)

43

44{
int i,j;

45

for(i=0;i<f;i++)

46

47

for(j=0;j<c;j++)

48
cout<<M[i][j]<<"t";

49

cout<<endl;

50

51}
52
53void mayorElementoDeCadaFila(float M[MAX][MAX], int f, int c)
54{
55
56
57

int i,j;
float may;
for(i=0;i<f;i++)
{

58
may=M[i][0];

59

for(j=0;j<c;j++)

60

61

if(M[i][j]>may)

62

may=M[i][j];

63

64

cout<<"El mayor elemento de la fila "<<i<<" es : "<<may<<endl;

65
}

66
67
68

69
70
71
72

Ejercicios Propuestos
1) Ingresar una matriz cuadrada de orden n y reportar si es simtrica. Recordar que una
matriz es simtrica si se cumple la condicin: a[i][j]=a[j][i]
2) Programa para ingresar una matriz de f filas y c columnas, y que se haga lo siguiente:
a) Ingresar un nmero de fila y eliminarla de la matriz.
b) Ingresar un nmero de columna y eliminarla de la matriz.
c) Ingresar un nmero de fila e insertar una fila en la matriz.
d) Ingresar un nmero de columna e insertar una columna en la matriz.
e) Intercambiar 2 filas de la Matriz. El nmero de las filas a intercambiar debe ingresarse.
f) Intercambiar 2 columnas de la Matriz. El nmero de las columnas a intercambiar debe
ingresarse.
g) Ordenar las filas de una matriz
h) Ordenar las columnas de una matriz
3) El curso de Computacin tiene n alumnos y se rinden 4 exmenes. Escribir un programa
que reporte lo siguiente:
a) El promedio de calificaciones de cada alumno.
b) El promedio de cada Examen
c) El alumno que obtuvo el mejor Promedio
d) El examen que tuvo el mayor promedio de calificacin.
4) Hacer un programa para invertir las columnas de una matriz (Los elementos de la
primera columna se intercambian con los de la ultima, los de la segunda con los de la
penltima y as sucesivamente).
5) Escribir un programa que genere un cuadrado mgico. Un cuadrado mgico se representa
por una matriz cuadrada de orden n, impar y contiene los nmeros comprendidos entre 1 y
n*n. En un cuadrado mgico la suma de cualquiera de las filas, columnas y diagonales
principales siempre es la misma. El cuadrado mgico se genera aplicando el siguiente
algoritmo:
a) El primer numero 1 se coloca en la celda central de la primera fila.
b) El siguiente nmero se coloca en la celda de la fila anterior y columna posterior.
c) La fila anterior al primero es el ltimo. La columna posterior a la ltima es la primera.

d) Si el nmero es un sucesor de un mltiplo de n, no aplique la regla 2. Coloque el nmero

en la celda de la misma columna de la fila posterior.
6) Hacer un programa para que coloque un 1 en las diagonales principales de una matriz
cuadrada. El resto se debe completar con ceros.
7) Hacer un programa que, al recibir los montos de ventas mensuales de cinco
departamentos de una fbrica proporcione la siguiente informacin
a) Las ventas mensuales de la fbrica incluido el monto anual.
b) El departamento que tuvo la mayor venta en el mes de Julio, incluyendo el monto de la
venta.
c) El mes en el que se obtuvieron las mayores y menores ventas del departamento I, donde I
se debe ingresar.
8) Hacer un programa para invertir las filas de una matriz (Los elementos de la primera fila
se intercambian con los de la ultima, los de la segunda con los de la penltima y as
sucesivamente).
9) Hacer un programa que al recibir una matriz cuadrada de orden impar. Determine si la
misma se pude considerar un cuadrado Mgico.(En un cuadrado mgico la suma de
cualquiera de las filas, columnas y diagonales principales siempre es la misma).
10) Hacer un programa que al recibir como dato una matriz , recorra esta matriz en forma
de espiral. Tal como se muestra en la figura:
11) Hacer un programa que al recibir como dato una matriz recorra esta matriz columna a
columna tal como se muestra en la figura.
12) Programa que ingresa el orden de una Matriz cuadrada y generarla y luego hacer lo
siguiente:
a) Reporta solo las diagonales.
b) Intercambia las diagonales.
c) Invierte las diagonales.
d) Reporta los elementos que estn arriba y abajo de la diagonal principal.
e) Reporta los elementos que estn arriba y abajo de la diagonal secundaria.
13) Programa para ingresar una matriz de nmeros enteros diferentes de cero de filas y c
columnas y la acomode para que queden primero los nmeros positivos y luego los
nmeros negativos
14) Ingresar una matriz de f filas y c columnas y calcular el Mayor, y reportar todas las
posiciones donde se encuentra el mayor. Y calcular el menor y reportar todas las posiciones
donde se encuentra el menor
15) Ingresar una matriz cuadrada y verificar si es una matriz Triangular inferior.
16) Crear un proyecto que permita digitar los valores enteros de una matriz A(4 x 5), luego
proceda a multiplicar la matriz por una constante N que deber ser digitada, asignando el
resultado a una segunda matriz B(4 x 5), luego listar por filas la matriz A y la matriz
resultado B.
17) Crear un proyecto que permita mostrar los valores de la tabla de multiplicar del 1 al 12
en un Matriz de forma tal que cada fila, aparezca en una lnea de impresin.
18) Crear un proyecto que permita digitar los valores para dos matrices C(4 x 3) y D(4 x 3),
luego proceder a efectuar la siguiente operacin de matrices:

R = 3 * C D/3
Listar las matrices C, D y la resultante R
19) Lea un conjunto de palabras. Luego invierta cada una de ellas de tal manera que cada
fila contenga la palabra original pero con sus caracteres al revs
20) En una matriz cada fila almacena los resultados de un sorteo de la tinka, esto es los 6
numeros ganadores. Diga cuantas veces sali cada numero de la tinka. La tinka tiene un
total de 46 numeros que pueden salir (1-46)
21) Una matriz diagonal es una matriz cuadrada que son ceros todos sus elementos que no
pertenecen a la diagonal principal. Escriba una funcion que diga si una matriz es diagonal.
22) Dada una matriz, obtenga el menor elemento de cada columna
23) Se tiene una matriz con el total de emergencias en un hospital por cada hora y cada dia
de la semana A que hora ocurre la mayor cantidad de emergencias ? Que dia hay mas
cantidad de emergencias ? */
24) Lea una matriz cuadrada y escriba la suma de todos los elementos que no pertenecen a
la diagonal principal