Arreglos unidimensionales

 Arreglos
unidimensionales
Instituto Politécnico Nacional
Secretaria Académica
Dirección de Educación Superior
ESIME Culhuacan
M. en C. Lorena Azuara Pérez
Ingeniería en Computación
Fundamentos de Programación
Práctica 11
Alumno:
Grupo:
Fecha:
Objetivo Al concluir está práctica el estudiante será capaz de: •
Definir estructuras de datos tipo arreglo. •
Utilizar arreglos de una dimensión para resolver problemas. Material y Equipo Computadora, Compilador C, unidad de almacenamiento (USB). Introducción teórica En esta práctica aprenderás el concepto y tratamiento de los arreglos. Un arreglo almacena muchos elementos del mismo tipo, tales como 20 enteros, 76 números de coma flotante o 30 caracteres. El arreglo es muy importante por diversas razones. Una aplicación importante es almacenar una secuencia o cadena de texto. Hasta el momento C proporciona datos en donde se almacena un solo carácter; utilizando datos de tipo arreglo, se puede crear una variable que contenga un grupo de caracteres. Arreglos unidimensionales Concepto y forma general Un arreglo se define como una colección finita, homogénea y ordenada de elementos. •
Finita: todo arreglo tiene un límite, es decir, se debe determinar cuál será el número máximo de elementos que podrán formar parte del arreglo. •
Homogénea: todos los elementos de un arreglo son del mismo tipo. •
Ordenada: se puede determinar cuál es el primer elemento, el segundo, el tercero, etc. Un arreglo puede representarse gráficamente como se muestra a continuación: Contenido/del/
arreglo
1
2
3
4
5
6
7
10
datos[0]
datos[1]
datos[2]
datos[3]
datos[4]
datos[5]
datos[6]
datos[7]
Nombre/del/arreglo
Subíndice
Figura 11.1 Práctica 11 Arreglos unidimensionales Un arreglo tiene la característica de que puede almacenar N elementos del mismo tipo y además permite el acceso a cada uno de estos elementos. Así se distinguen dos partes en los arreglos: •
Los componentes (contenido del arreglo) •
Los subíndices Los componentes hacen referencia a los elementos que forman el arreglo. Es decir, son los valores que se almacenan en cada una de sus casillas. Los subíndices por otra parte, son los que permiten accesar a los componentes del arreglo en forma individual. Entonces, podemos entender los arreglos (también conocidos como arrays) 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. Es posible tener un arreglo de cualquier tipo de datos: caracteres, enteros, números en coma flotante, etc. Un arreglo se declara de modo similar a otros tipos de datos, excepto que se debe indicar al compilador el tamaño o longitud del arreglo. Para indicar al compilador el tamaño o longitud del arreglo se debe hacer seguir al nombre, el tamaño encerrado entre corchetes. Los arreglos tienen cuatro propiedades básicas: •
Los elementos individuales de datos de un arreglo 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 arreglo es un valor constante que representa la dirección del primer elemento del arreglo. Para acceder a un elemento especifico del arreglo, 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. La declaración de los arreglos se realiza de la siguiente manera: tipo_de_dato Nombre_del_arreglo [tamaño]; int datos[8]; float serie[25]; char cadena [40]; 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: int cant[6] = {12, -­‐‑3, 0, 15, 8, 65}; double DesvTipica[8] = {0.23, 3.1416, -­‐‑0.5, 2.16789, -­‐‑56.78, 25, 0.15, -­‐‑14 }; 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 cant[5] = 65; M. en C. Lorena Azuara Pérez Práctica 11 Arreglos unidimensionales 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 de la 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 datos[ ]={8, 6, 10, -­‐‑15, 23}; b) char mes[ ]=”octubre”; que vienen siendo equivalente a: mes[0]=‘o’; datos[0]=8; mes[1]=‘c’; datos[1]=6; mes[2]=‘t’; datos[2]=10; mes[3]=‘u’ datos[3]=-­‐‑15; ;mes[4]=‘b’; datos[4]=23; mes[5]=‘r’; mes[6]=‘e’; mes[7]=‘\0’ Ejemplo: En cierta corporación financiera se requiere obtener las ventas acumuladas por mes. Los directivos desean ver en una tabla dos columnas. La primera de ellas reflejará las ventas generadas en el mes y la segunda las cantidades que se acumulen a lo largo del año. M. en C. Lorena Azuara Pérez Práctica 11 Arreglos unidimensionales /*Ejemplo 11.1*/
#include <stdio.h>
#include <conio.h>
void main( )
{
int cantidad[11], i;
long int suma;
printf(“Acumulados mensuales\n”);
for( i = 0; i < 12; i++)
{
printf(“Digite las ventas del mes
%d: ”, i+1);
scanf(“%d”, &cantidad[i]);
}
suma=0;
printf(“\n\nTabla de
acumulados\n\n”);
printf(“=============================”);
printf(“\nMes
Ventas
Acumulados\n”);
for(i = 0; i < 12; i++)
{
suma= suma + cantidad[i];
printf(“\n[%2d]
%10d %10d”, i+1,
mes[i], suma);
}
getch();
}
Acumulados mensuales Digite las ventas del mes 1: 1000 Digite las ventas del mes 2: 1200 Digite las ventas del mes 3: 1100 Digite las ventas del mes 4: 1350 Digite las ventas del mes 5: 500 Digite las ventas del mes 6: 120 Digite las ventas del mes 7: 750 Digite las ventas del mes 8: 4000 Digite las ventas del mes 9: 3210 Digite las ventas del mes 10: 800 Digite las ventas del mes 11: 1000 Digite las ventas del mes 12: 2300 Tabla de acumulados Mes Ventas Acumulados [ 1] 1000 1000 [ 2] 1200 2200 [ 3] 1100 3300 [ 4] 1350 4650 [ 5] 500 5150 [ 6] 120 5270 [ 7] 750 6020 [ 8] 4000 10020 [ 9] 3210 13230 [10] 800 14030 [11} 1000 15030 [12] 2300 17330 Ejemplo: Encontrar el valor máximo y mínimo almacenado en un arreglo. /*Ejemplo 11.2*/
#include<stdio.h>
#include<conio.h>
void main( )
{
int datos[100], n, max=0, min=32767,i;
printf(“Cuantos datos desea introducir: ”);
scanf(“%d”,&n);
for(i = 0; i < n; i++)
{
printf(“Teclea el dato %d: ”, i+1);
scanf(“%d”, &datos[i]);
if(datos[i] > max)
max = datos[i];
if(datos[i] < min)
min = datos[i];
}
printf(“\nValores encontrados\n”);
printf(“Maximo = %d\n”, max);
printf(“Minimo = %d \n”, min);
getch();
}
M. en C. Lorena Azuara Pérez Cuantos datos desea introducir: 8 Teclee el dato 1: 45 Teclee el dato 2: 8500 Teclee el dato 3: 78 Teclee el dato 4: 4561 Teclee el dato 5: 18 Teclee el dato 6: 1500 Teclee el dato 7: 2900 Teclee el dato 8: 1300 Valores encontrados Maximo: 8500 Minimo: 18 Práctica 11 Arreglos unidimensionales Arreglos numéricos y de caracteres Una cadena de texto es un conjunto de caracteres, tales como «HOLAMUNDO». C soporta cadenas de texto utilizando un array de caracteres que contenga una secuencia de caracteres: char cadena[ ] = “HOLAMUNDO” Contenido>del>
arreglo
H
[0]
O
[1]
L
[2]
A
[3]
M
[4]
U
[5]
N
[6]
D
[7]
O
[8]
)\0)
[9]
Subíndice
Las cadenas son en realidad arreglos de caracteres. Para declararlas se utiliza la siguiente sentencia: char cadena [ ] = "ʺHOLAMUNDO"ʺ; char nombre [50]; char dirección [100]; Ejemplo: Hacer un programa que lea una cadena y una letra desde el teclado. El programa debe indicar si la letra se encuentra presente en la cadena o no. /*Ejemplo 11.3*/
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main ( )
{
char cadena[100], letra;
int long, i, aux;
printf(“Teclea la cadena: ”);
gets(cadena);
printf(“Teclea el carácter a buscar: ”);
scanf(“%c”, &letra);
long = strlen(cadena);
i=0;
aux=0;
while(i < long && !aux)
{
if(cadena[i] == letra)
aux = 1;
i++;
}
if(aux)
printf(“\nLa letra %c, SI se encontró en la cadena\n”, letra);
else
printf(“\nLa letra %c, NO se encontró en la cadena\n”, letra);
getch();
}
M. en C. Lorena Azuara Pérez Teclea la cadena: Hola Mundo Teclea el carácter a buscar: e La letra e, NO se encontró en la cadena Teclea la cadena: Hola Mundo Teclea el carácter a buscar: u La letra u, SI se encontró en la cadena Práctica 11 Arreglos unidimensionales Desarrollo 1. Escriba un programa en el que se introduzca “n” cantidad de datos enteros y los ordene de manera ascendente. /*Práctica 11.1*/
#include<stdio.h>
#include<conio.h>
void main( )
{
int datos[100], n, i, j;
printf(“Cuantos datos desea introducir: ”);
scanf(“%d”,&n);
for(i = 0; i < n; i++)
{
printf(“Teclea el dato %d: ”, i+1);
scanf(“%d”, &datos[i]);
}
printf(“\nDatos desordenados\n”);
printf(“Subindice
Valor\n”);
for(i = 0; i < n; i++)
printf(“%d %7d\n”, i, datos[i]);
for(i = 0; i < n; i++)
{
for(j = 0; j < n; j++)
{
if(datos[j] > datos[j + 1])
{
aux= datos[j];
datos[j] = datos[j + 1];
datos[j + 1] = aux;
}
}
}
printf(“\nDatos Ordenados Ascendentemente\n”);
printf(“Subindice
Valor\n”);
for(i = 0; i < n; i++)
printf(“%d %7d\n”, i, datos[i]);
getch();
}
Cuantos datos desea introducir: 5 Teclee el dato 1: 21 Teclee el dato 2: 1 Teclee el dato 3: 17 Teclee el dato 4: 45 Teclee el dato 5: 24 Datos desordenados Subíndice Valor 0
21 1
1 2
17 3
45 4
24 Datos Ordenados Ascendentemente Subíndice Valor 0
1 1
17 2
21 3
24 4
45 2. Escriba un programa que pida un rango y de ese rango almacene únicamente los datos que sean primos. /*Práctica 11.2*/
#include<stdio.h>
#include<conio.h>
void main( )
{
int primos[100], ri, rf, i, j, primo, sub = 0;
printf(“Rango inicial: ”);
scanf(“%d”, &ri);
printf(“Rango final: ”);
scanf(“%d”, &rf);
if(ri < rf)
{
for(i = ri; i <= rf; i++)
{
primo = 0;
for(j = 1; j <= i; j++)
{
mod = i % j;
if (mod == 0)
primo++;
}
if(primo <= 2)
primos[sub] = i;
}
sub++;
}
else
{
for(i = rf; i <= ri; i--)
{
primo = 0;
for(j = i; j >= 1; j--)
{
mod = i % j;
if (mod == 0)
primo++;
}
if(primo <= 2)
primos[sub] = i;
}
}
printf(“Los números primos son \n”);
printf(“Subindice
Valor\n”);
for(i = 0; i < sub; i++)
printf(“%d %7d\n”, i primos[i]);
getch();
}
M. en C. Lorena Azuara Pérez Práctica 11 Arreglos unidimensionales Rango inicial: 1 Rango final: 25 Los números primos son Subíndice Valor 0
1 1
2 2
3 3
5 4
7 5
11 6
13 7
17 8
19 9
23 3. Escriba un programa que lea una cadena y determine cuántas palabras existen en ella. /*Práctica 11.3*/
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main ( )
{
char cadena[100];
char blanco = ’ ‘;
int num_palabras, i, longitud;
printf(“Teclea la cadena: ”);
gets(cadena);
longitud = strlen(cadena);
if(longitud > 0)
{
num_palabras = 1;
i = 0;
while(cadena[i] != ‘\0’)
{
if(cadena[i] == blanco || cadena[i] == ‘\0’)
{
while(cadena[++i] == blanco && cadena[i] != ‘\0’)
if(cadena[i] != ‘\0’ && cadena[i] != ‘\0’)
num_palabras++;
}
else
i++;
}
printf(“\nEl numero de palabras es: %d”, i);
}
else
printf(“\nDigite una cadena por favor”);
getch();
}
Teclea la cadena: Bienvenido a C El número de palabras es: 3 Teclea la cadena: Calle Alfredo Bonfil numero 88 El numero de palabras es: 5 Cuestionario 1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
¿Cuál es la ventaja de utilizar arreglos? ¿Cuál es la sintaxis de la declaración de arreglos? ¿De cuántos tipos se pueden declarar las variables en un arreglo? ¿Cómo se diferencia una variable de otra en un arreglo? ¿Qué hace el compilador cuando se declara un arreglo? Se usa la misma memoria para almacenar un arreglo de enteros, flotantes y caracteres? Defina que es un subíndice ¿Cómo se accede a una sola letra en una cadena? ¿Qué contiene una cadena después del nulo? ¿Se puede leer un arreglos de números en una sola sentencia scanf() como lo hace la sentencia gets() para obtener una cadena? Conclusiones M. en C. Lorena Azuara Pérez