Arreglos Bidimensionales

Curso básico de C 6/10: Arrays y registros
A la hora de desarrollar aplicaciones necesitamos almacenar una gran cantidad de

información, necesitamos también estructuras que recojan varios tipos de datos a la vez. C
cuenta con varias herramientas para poder desarrollar todas estas funcionalidades. En éste
capítulo 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, también veremos los registros para poder trabajar con conjuntos de variables.
- See more at: http://programavideojuegos.blogspot.com.es/2013/05/curso-basico-de-c-610-

arrays-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 posición (o índice) donde se encuentre dentro del array.
Declaración.
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 sería así:
int num[20];
La declaración es exactamente igual que cuando declaramos variables normales, salvo que
hay que añadir la longitud del array en cuestión.
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 tendría las
siguientes posiciones:
num[0], num[1], num[2], num[3], num[4], num[5], num[6] … num[19].
En una misma fila de declaración se pueden declarar tanto varios arrays a la vez como
variables normales.
int num1,num2,num3[10],num4,num5[5];
También es posible declarar arrays prescindiendo del uso de números para definir su
tamaño, aunque es necesario que tengamos en cuenta ciertos factores:
1 – Para declarar un array usando identificadores sólo se podrá usar constantes definidas
mediante #define.
#define TAM 50
int main(void)
{
int a[TAM];
}
2 – No es correcto definir el tamaño de un array con variables.
int main(void)
{
int tam=50;
int a[tam];
}
3 – No es correcto definir el tamaño 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 sólo lectura.
int main(void)
{
const int tam=50;
int a[tam];
}
Asignación de valores e iniciación 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.
Asignación directa de un valor mediante el operador de asignación =, hay que especificar

mediante su índice la celda concreta donde se va a almacenar. En el array anterior sería 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 inicialización 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;
}
También es posible inicializar un array en su propia declaración, para ello debemos

seguir la siguiente estructura:
Tipo_dato nombre_variable [longitud_array] = {valor0, valor1... valor_longitud_array};
Un ejemplo práctico sería 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 condición para salir del bucle es el tamaño 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 disposición es el array de caracteres, la forma de tratarlo es exactamente igual que
con los arrays de otros tipos de datos a excepción 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 consideración el término 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 carácter especial \0, con éste le diremos al programa que
tenga en cuenta dentro del array todos los caracteres hasta llegar al carácter \0.
El \0 cuenta como un carácter más dentro del array y como tal ocupa una celda, es por
eso que si definimos un array de 50 caracteres en realidad sólo podremos rellenar los
primeros 49, ya que siempre el carácter final es el \0.
H O L A \0
H A Y \0
El carácter \0 no tenemos por qué introducirlo nosotros, el programa puede encargarse,
con que sepamos qué significa y cómo utilizarlo y controlarlo es suficiente.
Un truco para poder almacenar un número de caracteres en un array con el tamaño de ese
número es definir el array con un tamaño igual y sumar una posición:
#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 instrucción scanf cumple con su cometido de leer una palabra, pero se presenta un
problema y es el que acabo de decir, sólo lee una palabra, no una frase completa.
Pero a eso le daremos solución en el siguiente apartado, ahora veamos cómo utilizar la
instrucción scanf:
#include <stdio.h>
#define TAM 50
int main(void)
{
char saludo[TAM +1];
scanf(“%s”,saludo);
return 0;
}
Como se puede observar no es necesario de nuevo recorrer el array, la instrucción hace

posible asignar los caracteres directamente en sus celdas.
También si se observa el código, en la instrucción 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 dirección de memoria donde alojar el valor, cosa que hacíamos con “&”,
como los arrays son en si mismos direcciones de memoria indexados no es necesario
colocar el “&”.
Prueba el código introduciendo la siguiente cadena “Hola buenos días” y observa el

resultado.
Cadenas y gets.
Para solucionar el problema del scanf con el array de caracteres tenemos dentro de la
librería stdio.h la instrucción gets
Con gets no es necesario utilizar una marca de formato, tan sólo con especificar el array
es suficiente, veamos un ejemplo:
#include <stdio.h>
#define TAM 50
int main(void)
{
char saludo[TAM +1];
gets(saludo);
return 0;
}
Prueba ahora el código introduciendo de nuevo la cadena “Hola buenos días” 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 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 estaríamos intentando hacer es asignar la dirección de memoria de otra dirección de
memoria.
La copia de cadenas debe realizarse carácter a carácter, 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)
{
for (x=0;x<TAM;x++)
{
despedida[x]=saludo[x];
}
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 sólo 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)
{
for (x=0;x<TAM;x++)
{
despedida[x]=saludo[x];
if (saludo[x]==’\0’)
{
break;
}
}
return 0;
}
Esto se puede plantear de múltiples 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 número
determinado de filas, es posible ampliar todo esto bastante más, 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, también podemos darle más dimensiones al
array.
Declaración
Los arrays multidimensionales se declaran de la misma forma que los arrays normales,
pero por cada dimensión que queramos añadir 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 declaración debemos agregar tantos bucles como sean
necesarios y anidaarlos entre ellos.
Para los arrays anteriores sería 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 válido para los arrays
multimensionales, no necesitan de mayores retoques.
Registros.
El último punto de éste capítulo es bastante interesante, imaginemos que necesitamos
gestionar los datos de una tienda de discos, sería necesario conocer varios datos como por
ejemplo el nombre del disco, el año en que se puso a la venta o el género 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 música, es sencillo
porque utilizaremos tres arrays, uno para el nombre del disco, otro para el año de
publicación y otro para el género. Todo perfecto.
Ahora imaginemos que necesitamos buscar un disco en concreto y mostrar la información

completa del disco, del que sólo sabemos el nombre. Buscamos en el primer array y lo
localizamos, tenemos el nombre, ahora busquemos en el segundo array el año en que se
publicó, deberemos saber en qué posición del array se encuentra, después busquemos en el
siguiente array el género 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, después al array de año y luego al array de
género, 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 año y el género. 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 sólo, y si
queremos realizar cualquier operación la estaremos haciendo con un solo array, un array de
registros.
La representación de los tres arrays podría ser así:
Disco1 2000 Pop

Disco2 1997 Rock
Disco3 1999 Pop
La representación de un array de registros podría ser así:
Disco1
2000
Pop
Disco2
1997
Rock
Disco3
1999
Pop
Así lo tenemos mucho mejor ¿verdad? La representación de los datos mediante un array de
registros nos facilita operar con los datos y evitar mantenimientos incómodos y que de
resultar erróneos podría 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 basándonos en la

estructura siguiendo el siguiente esquema:
Struct NombreRegistro nombre_variable;
El registro lo definimos antes del programa principal (main), concretamente después

del #define, y por consiguiente después del #include, la declaración de variables basadas
en el registro la podemos hacer en cualquier momento.
Tanto en las variables de la definición como en la declaración podemos usar arrays de

cualquier dimensión.
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 planteábamos, ahora tenemos un array de 100
registros donde gestionaremos nuestra colección de discos.
Para poder hacer referencia a una variable del registro tan sólo 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 capítulo del curso básico de C. En éste capítulo hemos
aprendido los conceptos de arrays simples y multidimensionales, hemos visto como
recorrerlos y como trabajar con sus datos, también hemos visto las cadenas o arrays de
caracteres y la nueva instrucción gets, por último hemos definido los registros, hemos visto
como construirlos y como operar con ellos.
En el siguiente capítulo veremos dos conceptos importantes dentro de la programación, los

procedimientos y las funciones, así como el paso de parámetros y formas de utilización.
- See more at: http://programavideojuegos.blogspot.com.es/2013/05/curso-basico-de-c-610-
arrays-y-registros.html#sthash.B3z8RSeV.dpuf
25 ejercicios resueltos de arrays y registros en C
19:19 Curso básico de C 6 comments
Durante el sexto capítulo del curso básico de C vimos la teoría de los arrays y los
registros. Hace unos días dejé una tanda de 25 ejercicios para practicar.
Foto tomada de freedigitalphotos.net
Pues como viene siendo habitual os dejo la solución de los mismos.
Realice un programa en C:
1. Que rellene un array con los 100 primeros números 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 números 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--)
{
system("PAUSE");
return 0;
3. Que rellene un array con los números 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++)
system("PAUSE");
return 0;
4. Que rellene un array con los números pares comprendidos entre 1 y 100 y los muestre en
#include <stdio.h>
#include <stdlib.h>
int main(void)
i=0;
for (x=1;x<=100;x++)
cont=0;
if (x%2==0)
tabla[i]=x;
i++;
for (x=0;x<i;x++)
system("PAUSE");
return 0;
}
5. Que rellene un array con los números impares comprendidos entre 1 y 100 y los muestre en
#include <stdio.h>
#include <stdlib.h>
int main(void)
i=0;
for (x=1;x<=100;x++)
cont=0;
if (x%2==1)
tabla[i]=x;
i++;
for (x=0;x<i;x++)
}
system("PAUSE");
return 0;
6. Que lea 10 números por teclado, los almacene en un array y muestre la suma, resta,
multiplicación y división 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 número\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("Multiplicación: %d\n",mul);
printf("División: %d\n",div);
system("PAUSE");
return 0;
7. Que lea 10 números 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 número");
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 números por teclado, 5 para un array y 5 para otro array distinto. Mostrar los 10
números 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++){
scanf("%d",&numeros1[i]);
for (i=0;i<5;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 números 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++){
for(i=0;i<5;i++)
numeros2[i]=numeros1[i]*2;
for (i=0;i<5;i++){
system("PAUSE");
return 0;
10. Que lea 5 números 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++){
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++){
}
system("PAUSE");
return 0;
11. Que rellene un array con los 100 primeros números 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 números 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++){
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 números 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++){
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 números y luego busque un número 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++){
scanf("%d",&vector[i]);
printf("Escriba el número 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 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 números de izquierda a derecha usando un array de dos
dimensiones.
#include <stdio.h>
#include <stdlib.h>
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 números 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 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 números pares, lo pinte y después que pida
una posición X,Y y mostrar el número correspondiente.
#include <stdio.h>
#include <stdlib.h>
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 número 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 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 ", numeros[y][x]);
printf("\n\n\n");
}
system("PAUSE");
return 0;
20. Que lea una cadena y la muestre al revés.
#include <stdio.h>
#include <stdlib.h>
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 sum=0,x;
char frase[50];

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 mayúsculas hay.
#include <stdio.h>
#include <stdlib.h>
int sum=0,x;
char frase[50];
gets(frase);
for(x = 0;x < 50;x++)
if (frase[x]>=65 && frase[x]<=90)
{
sum++;
printf("\n\nEn la frase hay %d mayúsculas\n\n",sum);
printf("\n\n");
system("PAUSE");
return 0;
23. Que lea una cadena y la encripte sumando 3 al código ASCII de cada carácter. Mostrar por
pantalla.
#include <stdio.h>
#include <stdlib.h>
int sum=0,x;
char frase[50];
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 información 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;
};
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 opción: ");
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)
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)
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. Modificar su nota.
c. Realizar la media de todas las notas.
d. Realizar la media de las notas menores de 5.
e. Mostrar el alumno que mejores notas ha sacado.
f. Mostrar el alumno que peores notas ha sacado.
#include <stdio.h>
#include <stdlib.h>
struct alumno {
char nombre[50];
float nota;
};
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 opción: ");
scanf("%d",&opcion);
if (opcion==1)
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)
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 electrónicoEscribe un blogCompartir con TwitterCompartir con Facebook
218
Google +
15.8K
Entrada más reciente Entrada antigua Página principal
6 comentarios:
1.
Salvador19 de noviembre de 2013, 17:21

Muy sencillos y útiles para quienes comienzan en la programación. Sería deseable
que hubieras modularizado las soluciones, usando funciones. Gracias de todos
modos.
Responder
Respuestas
1.
Juan Carlos García Romero21 de noviembre de 2013, 16:40
Sí, es lo suyo Salvador, pero como éste post es parte de un curso de nivel
básico he preferido ponerlo así para que la persona que lo siga pudiera
practicar mucho.
Gracias por la observación, un saludo.
Responder
2.
yorbin molina28 de enero de 2014, 22:18
muy buenos gracias
Responder
Respuestas
1.
Juan Carlos García 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 números y los vaya almacenando en una cadena, y
cuando ponga el numero "0" deje de pedir números, luego que diga cuales son pares
y cuales impares.
Alguien sabe hacerlo?
Responder
Cargar más...
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, dirección, teléfono), 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 Dirección: ');
Readln( P.Direccion );
Write(' Ingrese su Teléfono: ');
Readln( P.Telefono )
{ fin carga del registro}
{mostrar información 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 Dirección es: ', P.Direccion );
Writeln(' el numero de Teléfono es: ' ,P.Telefono );
{fin mostrar información 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 cuál es la más joven.
Program Mas_joven;
Uses Crt;
Type
Personas : Record
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;
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 Dirección: ');
Readln( persona[i].Direccion );
Write(' Ingrese su Teléfono: ');
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 más joven es ',Nombre,' y tiene ',Menor,' años 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 dimensión 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 dimensión 10x12.
3. Un instituto desea controlar los resultados de los alumnos en las distintas asignaturas de la
facultad de Ingeniería. 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 están
codificadas de 1 a 6 y hay 30 alumnos.
Practica 10: Ejercicios con Arreglos unidimensionales.
Materia: Lógica Computacional.

Profesor: Lic. Salomón Aquino.
I. Objetivo. Al finalizar la práctica el estudiante será capaz de:
• Definir estructuras de datos y arreglos.
• Utilizar arreglos en una dimensión para resolver problemas.
II. Introducción Teórica.
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 números se denominan valores
índice o subíndice 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 (también conocidos como arreglos o formaciones) como
variables que contienen diferentes tipos de datos homogéneos. Se puede acceder a cada
elemento de datos individual de la variable mediante un subíndice, o índice. En los lenguajes C y
C++, un array no se corresponde con un tipo de dato estándar; 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, números 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 tamaño o longitud del array. Para indicar al compilador el tamaño o longitud del
array se debe hacer seguir al nombre, el tamaño encerrado entre corchetes.
Los arrays tienen cuatro propiedades básicas:
• 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 subíndice (o índice) del primer elemento es cero.
• El nombre de un array es un valor constante que representa la dirección del primer elemento del
array.
Para acceder a un elemento especifico del array, se utiliza el nombre de éste seguido por uno o
más “índices” (donde cada uno representa una dimensión del arreglo o array) encerrado entre
corchetes. Supongamos que tenemos un arreglo unidimensional llamado X con un tamaño 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 términos generales para definir un array se especifica el tipo de almacenamiento (atributo
opcional), el tipo de datos, el identificador y entre corchetes el tamaño del arreglo. Abajo se
muestra algunos ejemplos de definición 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 función de constantes

A veces es conveniente definir el tamaño de un array en términos 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 líneas de código) donde se halle un array de
20 items, y a lo largo del programa se hace referencia unas 12 veces al arreglo, y supongamos
también que se necesita cambiar el tamaño del arreglo. Sin usar la constante se tendría que
revisar todo el programa para localizar las líneas de código y efectuar el cambio al nuevo tamaño,
en cambio con el uso de constantes sólo se le cambia el tamaño a la misma y el problema esta
resuelto. La definición de un array a través de una constante se muestra en el siguiente ejemplo:
# include stdio.h>
# include stdlib.h>
/* Definición de la constante */
#define tamano 20
main()
{
/* Utilización de la constante para definir la dimensión 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 utilización de constantes definidas garantiza que las siguientes referencias al array no
sobrepasen el tamaño definido para el mismo.
C no comprueba que los índices del array están dentro del rango definido.
Inicialización 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 continuación 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 explícitos, éstos son
puestos a cero, a continuación tenemos un ejemplo:
int edades[8]={25,13,18};
El resultado de la asignación 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 método de inicializar arrays mediante valores constantes después de su definición, es

adecuado cuando el número de elementos del arreglo es pequeño.
Una nota interesante en cuanto a la inicialización de arreglos, es que el tamaño no necesita ser
indicado explícitamente. Con los arrays numéricos el tamaño será fijado igual al número de valores
incluidos. En cuanto a las cadenas, el tamaño se fijará igual al número de caracteres del string o
cadena mas uno (el carácter nulo “\0”).
C puede dejar los corchetes vacíos, sólo 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 automáticamente 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 números en un arreglo, calcule la suma,
promedio, cuadrado , cubo y desviación estándar 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 desviación
estandar de una serie de números */
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 impresión de cuadrado, cubo y desviación 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 tamaño de los valores
que se generan en los cálculos.
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? __________________________________________

_______________________________________________________________
Cuál 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? __________________________________________
_______________________________________________________________
Cuál es la salida? _______
¿En qué se diferencia del ejemplo anterior? ____________________________
_______________________________________________________________
Ejercicio 3
Elabore un programa que sume los primeros 25 números enteros guardados en un vector. Se
desea imprimir la lista de números y al final la suma de los mismos.
Ejercicio 4
Generar e imprimir un vector de 10 números enteros y encontrar el mayor de ellos. Desplegar el
resultado.
Ejercicio 5
Dadas dos listas A y B de igual número 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 García V.
PROBLEMA NRO 1
/* ENUNCIADO : Hacer un programa que calcule la nota de un alumno en una prueba 10
preguntas de opciones múltiples ('a',...o,'e'). Cada pregunta se evalúa 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> // cin y cout
#include<iomanip.h> // setw()
#include<conio.h> // getch() o getche()
#include<stdlib.h> // toupper y tolower
#include<stdio.h>// gets()
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 tamaño 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 Mínima talla de un grupo de N
atletas. Defina N como constante al inicio del programa. */
// LIBRERIAS
#include<iomanip.h>
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
const int N = 5;
void main()
{
// se declara array de tamaño 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 tamaño N considerado constante. El tamaño maximo de las
cadenas considerela 20. */
// LIBRERIAS C++
#include <iostream.h> // cin y cout
#include <iomanip.h> // setw()
#include <conio.h> // getch()
#include <stdio.h> // gets()
#include <string.h> // 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++) // numero de pasos
{
for(j=0;j<N-1-k;j++) // 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]); // a auxN le asigna nom[j]
strcpy(nom[j],nom[j+1]); // a nom[j] le asigna nom[j+1]
strcpy(nom[j+1],auxN); // a nom[j+1] le asigna auxN
}
}
}
cout<<endl;
// MUESTRA EL ARRAY EN ORDEN ALFABETICO
for(i=0;i< N;i++)
{ cout<<setw(15)<<nom[i]<<endl; }
cout<<endl;getch();
}
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<conio.h>
#include<iomanip.h>
#include<stdio.h>
#include<string.h>
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 alfabético. Debe mostrar este reporte:
Nombre Nota
xxxxxx 99
xxxxxx 99
----
Promedio 99
*/
// Librerias C++
#include<conio.h>
#include<iomanip.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
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 numérico de un
polinomio de grado N cuyos coeficientes , grado y valor de x son ingresados con
teclado. Considere un grado máximo de 99
**/
#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 producción de n
productos ingresados por teclado, si se conocen los costos unitarios y las
unidades producidas de cada uno de los productos
*/
#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 tamaño 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 librería 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 números 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
calorías
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á simultáneamente 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 electrónica
i1 i2 i3
6 7 8
1 2 9
5. Escriba 3 problemas en los cuales se usen los arreglos para su solución
Ejemplo 1
El siguiente código despliega todos los elementos de un arreglo bidimensional de 3 por 4,
empleando dos técnicas diferentes.
Ejemplo 2
El siguiente programa muestra el resultado de multiplicar cada elemento del arreglo val por el
número 10.
Ejemplo 3
Algoritmo para saber la temperatura.
6. Escriba 3 ejemplos de la declaración de arreglos unidimensionales Usando Dev-C++.

7. Escriba 3 ejemplos de la declaración de arreglos bidimensionales usando Dev-C++.
Arrays en C++. Ejemplos
Un array es una colección finita de datos del mismo tipo, que se almacenan en
posiciones consecutivas de memoria y reciben un nombre común.
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 gráficamente 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
más índices que indican la posición que ocupa el elemento dentro del array.
Cada índice se escribe entre corchetes.
El primer elemento del array ocupa la posición 0, el segundo la posición 1,

etc. En un array de N elementos el último ocupará la posición N-1.
En el ejemplo anterior, notas[0] contiene la nota del primer alumno y

notas[19] contiene la del último
Cómo declarar un array:
Un array se declara de forma parecida a una variable de tipo simple

añadiéndole al nombre el número 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 números
enteros positivos o expresiones con un resultado entero positivo. Indican el
número 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.
Más ejemplos de declaración 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 número de índices determina la dimensión del array. Si el array tiene

solo un índice es un array de una dimensión o unidimensional (también
llamado vector), si tiene dos índices es un array de dos dimensiones o
bidimensional (también llamados matrices, tablas o arreglos), si tienen tres
índice tridimensional, etc.
Para facilitar la modificación del programa, el tamaño del array se puede

declarar utilizando una constante en lugar de una cantidad entera. Esto hace
más fácil modificar el programa ya que todas las referencias al tamaño máximo
del array (por ejemplo, en bucles for o en definiciones de arrays) pueden ser
modificadas cambiando el valor de la constante.
Por ejemplo, declaración 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 tamaño de los arrays, solo habrá que cambiar el
valor de la constante.
Los arrays declarados como locales en una función tienen como valores
iniciales valores indeterminados, como ocurre con las variables locales.
La declaración de un array puede incluir la asignación de valores

iniciales.
La forma general de hacerlo es:
tipo nombre_array[tamaño]={valor1,valor2,..,valorn};
Donde valor1 es el valor del primer elemento del array, valor2 el valor del
segundo elemento, y así sucesivamente.
El tamaño del array es opcional cuando se asignan valores iniciales en la

declaración.
Todos los elementos del array que no tienen asignados valores iniciales
explícitos, (sucede cuando un array tienes más elementos que valores iniciales
se han asignado), serán puestos automáticamente a cero.
Ejemplos de asignación de valores iniciales en la declaración 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 número de elementos no es necesario indicarlo porque se están 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 número de elementos aunque no es necesario hacerlo. Se están 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 número de elementos del array porque solo se le asignan valores iniciales a
los cuatro primeros. El compilador asumiría 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 implícitas: para cada array que se declara hay que indicar el
tipo y la dimensión.
Una alternativa a esto es definir un nuevo tipo de dato para el array

asignándole un nombre, y posteriormente declarar las variables como
pertenecientes a ese tipo.
C++ dispone del especificador typedef que permite la creación de nuevos

tipos de datos.
Los tipos de datos creados con typedef son sinónimos de otros tipos ya
existentes.
Por ejemplo, la siguiente instrucción crea un nuevo tipo de dato llamado

entero, sinónimo de int.
typedef int entero;
A partir de esta instrucción podemos declarar variables enteras así:
entero a, b=3;
Utilizando typedef podemos crear nuevos tipos de datos sinónimos de tipos array. La
forma general de hacerlo es:
typedef tipo_base nombre_nuevo_tipo[dimension];
Ejemplo:
typedef int Tvector[30];
Esta instrucción crea un nuevo tipo de dato llamado Tvector. Las variables que
se declaren de este tipo serán 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 límites 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 ejecución si esa posición 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 están dentro de los límites del array.
Ejemplo 2: recorrer un array
Para recorrer un array se utiliza una instrucción iterativa (normalmente una

instrucción 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 continuación recorre el array, utilizando la
instrucción for, para mostrar por pantalla el contenido del array.
#include <iostream>
#include <iomanip>
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. También 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>
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");
}
Capítulo VII: Matrices
Posted by
Posted on sep - 25 - 2011
0 Comment
Son arreglos bidimensionales, es una colección finita, homogénea 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.
Declaración de una matriz:
tipo_de_dato identificador[numFilas][numColumnas];;
Dónde :
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
declaración de los mismos.
Ejemplo:
int A[3][4]; // Declaración de una matriz de enteros de 3 filas y 4

1columnas
float B[6][2]; // Declaración de una matriz de reales de 6 filas y 2
2
columnas
3char C[4][10]; // Declamación 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 sería el siguiente:
1tipo_de_dato identificador[ filas ][ columnas ] = {
2 { columnas de la fila 1 },
3 { columnas de la fila 2 },
4 ... ,
5 { columnas de la última fila }
};
6
No debemos olvidar el ‘;’ al final.

Ejemplo:
int temperaturas[3][5] = { { 15, 17, 20, 25, 10 }, { 18, 20, 21, 23, 18
1
}, { 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.
#include<iostream>
1
2
3
#define MAX 10
4
5
void ordenMatriz(int &f, int &c);
6
void ingresoMatriz(float M[MAX][MAX], int f, int c);
7
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
int f,c;
15
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;
cout<<"El menor es : "<<menor(M,f,c)<<endl;

20
cout<<"El promedio : "<<promedio(M,f,c)<<endl;
21
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 }while(f<=0 || f>MAX);
do{
31
cout<<"Numero de columnas : ";
32
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 cout<<endl;
51 }
52}
53
54float mayor(float M[][MAX], int f, int c)

{
55
int i,j;
56
float may=M[0][0];
57
for(i=0;i<f;i++)
58 for(j=0;j<c;j++)
59 if(M[i][j]>may)
may=M[i][j];
60
return may;
61
}
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 for(j=0;j<c;j++)
69 if(M[i][j]<men)
men=M[i][j];
70
return men;
71
}
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 for(j=0;j<c;j++)
79 s=s+M[i][j];
80 return s/(f*c);
}
81
82
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>
3 using namespace std;
5 #define MAX 10
6
7
8
9
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);
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
29
{
30
do{
31
cout<<"Numero de filas : ";
32
cin>>f;
34 do{
35 cout<<"Numero de columnas : ";
36 cin>>c;
}
38
39
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
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 {
sf[i]=0;
64
for(j=0;j<c;j++)
65
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 sc[j]=sc[j]+A[i][j];
76 }
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
2
#define MAX 10
3
4 void ordenMatriz(int &f, int &c);
5 void ingresoMatriz(float M[MAX][MAX], int f, int c);

6
void transpuesta(float M[MAX][MAX], int f, int c,float T[MAX][MAX]);
7
int main()
8
{
9
float M[MAX][MAX],T[MAX][MAX];
10
int f,c;
11 ordenMatriz(f,c);
14 reporteMatriz(M,f,c);
transpuesta(M,f,c,T);
15
cout<<"Matriz Transpuesta "<<endl;
16
reporteMatriz(T,c,f);
17
system("PAUSE");
18
}
19
20{
21 do{
23 cin>>f;
do{
25
26
cin>>c;
27
}while(c<=0 || c>MAX);
28
}
29
30void ingresoMatriz(float M[][MAX], int f, int c)
31{
int i,j;
32
for(i=0;i<f;i++)
33
for(j=0;j<c;j++)
34
{
35
cout<<"M["<<i<<"]["<<j<<"]:";
36
cin>>M[i][j];
37 }
38}
39
41{
int i,j;
42
for(i=0;i<f;i++)
43
{
44
for(j=0;j<c;j++)
45
cout<<M[i][j]<<"t";
46
cout<<endl;
47 }
48}
49
50void transpuesta(float M[MAX][MAX], int f, int c,float T[MAX][MAX])
51{
52 int i,j;
for(i=0;i<f;i++)
53
54 for(j=0;j<c;j++)
55 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.
3 #define MAX 10
4
5
6
7
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
if(c1==f2)
27
{
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
38
{
39
do{
41 cin>>f;
}while(f<=0 || f>MAX);
42
do{
43
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
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++)
71 for(j=0;j<c;j++)
72 S[i][j]=A[i][j]+B[i][j];
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++)
80 for(j=0;j<c2;j++)
{
81
P[i][j]=0;
82
for(k=0;k<c1;k++)
83
P[i][j]=P[i][j]+A[i][k]*B[k][j];
84
}
85
}
86
87
88
89
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.
4 #define MAX 10
6 void ordenMatriz(int &n);

7
8
float sumaDiagonalPrincipal(float M[MAX][MAX], int n);
9
float promedioDiagonalSecundaria(float M[MAX][MAX], int n);
10
float mayorElementoTriangularSuperior(float M[MAX][MAX], int n);
11
float promedioMatrizTriangularInferior(float M[MAX][MAX], int n);
12
13
int main()
14 {
15 float M[MAX][MAX];
16 int n;
17 ordenMatriz(n);
ingresoMatriz(M,n,n);
18
20 reporteMatriz(M,n,n);
cout<<"Suma de la diagonal principal :

21
"<<sumaDiagonalPrincipal(M,n)<<endl;
22 cout<<"Promedio de los elementos de la diagonal
secundaria: "<<promedioDiagonalSecundaria(M,n)<<endl;
23
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 {
33 do{
34 cout<<"Orden de la matriz cuadrada: ";
cin>>n;
35
}while(n<=0 || n>MAX);
36
}
37
38
39
{
40
int i,j;
41 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++)
53 cout<<M[i][j]<<"t";
54 cout<<endl;
}
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)
64 s=s+M[i][j];
65 return s;
}
66
67
float promedioDiagonalSecundaria(float M[][MAX], int n)
68
{
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
return s/n;
75
}
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
return may;
85
}
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++)
for(j=0;j<n;j++)
92
if(i>=j)
93
{
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 simétrica.
2
3
#define MAX 10
4
5
void ordenMatriz(int &n);
6
7
8
bool esSimetrica(float M[MAX][MAX], int n);
9
10
11int main()
12{
int n;
14
ordenMatriz(n);
15
ingresoMatriz(M,n,n);
16
17
reporteMatriz(M,n,n);
18
if(esSimetrica(M,n))
19 cout<<"La matriz es simetrica"<<endl;
20 else
21 cout<<"La matriz no es simetrica"<<endl;
22 system("PAUSE");
return 0;
23
}
24
25
26
void ordenMatriz(int &n)
27
{
28
do{
29
cout<<"Orden de la matriz cuadrada: ";
30 cin>>n;
31 }while(n<=0 || n>MAX);
32}
33
34void ingresoMatriz(float M[MAX][MAX], int f, int c)
35{
int i,j;
36
37 for(i=0;i<f;i++)
38 for(j=0;j<c;j++)
{
39
cout<<"M["<<i<<"]["<<j<<"]:";
40
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 for(j=i+1;j<n;j++)
58 if(M[i][j]!=M[j][i])
return false;
59
return true;
60
}
61
62
63
64
65
66
7) Ingresar una matriz y reportar el mayor elemento de cada fila
#include<iostream>
1
2
3
#define MAX 10
4
5
6
7
8 void mayorElementoDeCadaFila(float M[MAX][MAX], int f, int c);
10int main()
11{
int f,c;
13
ordenMatriz(f,c);
14
ingresoMatriz(M,f,c);
15
16
reporteMatriz(M,f,c);
17
mayorElementoDeCadaFila(M,f,c);
18 system("PAUSE");
19 return 0;
20}
21
22
23
24
{
25
do{
26
cout<<"Numero de filas : ";
27
cin>>f;
28
}while(f<=0 || f>MAX);
29 do{
30 cout<<"Numero de columnas : ";
31 cin>>c;
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{
45 int i,j;
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 int i,j;
float may;
56
for(i=0;i<f;i++)
57
{
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 simétrica. Recordar que una
matriz es simétrica si se cumple la condición: 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 número de fila y eliminarla de la matriz.
b) Ingresar un número de columna y eliminarla de la matriz.
c) Ingresar un número de fila e insertar una fila en la matriz.
d) Ingresar un número de columna e insertar una columna en la matriz.
e) Intercambiar 2 filas de la Matriz. El número de las filas a intercambiar debe ingresarse.
f) Intercambiar 2 columnas de la Matriz. El número 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 Computación tiene n alumnos y se rinden 4 exámenes. 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 calificación.
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
penúltima y así sucesivamente).
5) Escribir un programa que genere un cuadrado mágico. Un cuadrado mágico se representa

por una matriz cuadrada de orden n, impar y contiene los números comprendidos entre 1 y
n*n. En un cuadrado mágico la suma de cualquiera de las filas, columnas y diagonales
principales siempre es la misma. El cuadrado mágico se genera aplicando el siguiente
algoritmo:
a) El primer numero 1 se coloca en la celda central de la primera fila.
b) El siguiente número 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 número es un sucesor de un múltiplo de n, no aplique la regla 2. Coloque el número
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 fábrica proporcione la siguiente información
a) Las ventas mensuales de la fábrica 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 penúltima 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 Mágico.(En un cuadrado mágico 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 están arriba y abajo de la diagonal principal.
e) Reporta los elementos que están arriba y abajo de la diagonal secundaria.
13) Programa para ingresar una matriz de números enteros diferentes de cero de filas y c
columnas y la acomode para que queden primero los números positivos y luego los
números 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 línea de impresión.
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 operación 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 revés
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

Arreglos Bidimensionales

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Arreglos Bidimensionales

Diunggah oleh

Hak Cipta:

Format Tersedia

Curso básico de C 6/10: Arrays y registros

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

- See more at: http://programavideojuegos.blogspot.com.es/2013/05/curso-basico-de-c-610-

Para declarar un array hay que seguir la siguiente estructura:

Tipo_dato nombre_variable [longitud_array];

num[0], num[1], num[2], num[3], num[4], num[5], num[6] … num[19].

2 – No es correcto definir el tamaño de un array con variables.

3 – No es correcto definir el tamaño de un array con constantes declaradas mediante

Asignación de valores e iniciación de un array.

Cuando se declara un array las celdas de éste contienen valores completamente

Asignación directa de un valor mediante el operador de asignación =, hay que especificar

Un ejemplo de inicialización de un array es el siguiente:

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

También es posible inicializar un array en su propia declaración, para ello debemos

Tipo_dato nombre_variable [longitud_array] = {valor0, valor1... valor_longitud_array};

Un ejemplo práctico sería el siguiente:

int num[10] = {0,0,0,0,0,0,0,0,0,0}:

Como hemos podido comprobar en el anterior apartado, un array se recorre mediante un

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

Cadenas de texto o array de caracteres.

Consideraciones del array de caracteres

Para poder escribir un array de caracteres utilizamos la sentencia printf y la marca de

printf ("%s.\n", saludo);

printf ("%s.\n", saludo);

Como se puede observar no es necesario de nuevo recorrer el array, la instrucción hace

También si se observa el código, en la instrucción scanf no he puesto un “&” delante del

Prueba el código introduciendo la siguiente cadena “Hola buenos días” y observa el

printf ("%s.\n", saludo);

printf ("%s.\n", despedida);

Esto es incorrecto, el compilador dará error y el programa no llegará ni a ejecutarse, esto

printf ("%s.\n", despedida);

printf ("%s.\n", despedida);

Esto se puede plantear de múltiples formas, podemos refinarlo de diferentes maneras,

Recorrer un array multidimensional.

Un array multidimensional se recorre de la misma forma que un array normal, mediante

Para los arrays anteriores sería así:

Ahora imaginemos que necesitamos buscar un disco en concreto y mostrar la información

En C disponemos de la posibilidad de declarar registros, esto son agrupaciones de datos

La representación de los tres arrays podría ser así:

Disco1 2000 Pop

La representación de un array de registros podría ser así:

Una vez lo hemos definido procedemos a declarar las variables basándonos en la

Struct NombreRegistro nombre_variable;

El registro lo definimos antes del programa principal (main), concretamente después

Tanto en las variables de la definición como en la declaración podemos usar arrays de

Veamos el caso del programa para gestionar discos:

#define TAM 100

Donde X es el índice del array.

En el siguiente capítulo veremos dos conceptos importantes dentro de la programación, los

25 ejercicios resueltos de arrays y registros en C

19:19 Curso básico de C 6 comments

Pues como viene siendo habitual os dejo la solución de los mismos.

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

float aux, numeros[10];

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

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

float sum, numeros1[10];

float aux, numeros[10];

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

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

printf("Escriba el número a buscar");

else if(dato < vector [centro] )

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