Programación Estructurada

Práctica No. 4

Arreglos unidimensionales
Objetivo:
 El alumno resolverá problemas con algoritmos o pseudocódigos, diagramas
de flujo y su representación gráfica con raptor.
 El alumno codificará programas que incluyan arreglos unidimensionales en
lenguaje C.

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 y 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:

Figura 1.

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;

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 y 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:
datos[0]=8;
datos[1]=6;
datos[2]=10;
datos[3]=15;
datos[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:
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.
/*Ejemplo 1*/
#include <stdio.h>
#include<stdlib.h>
#include <conio.h>
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(“%c”, &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();
return 0;
}

Ejemplo 2:
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();
return 0;
}
Arreglos numéricos y de caracteres

Una cadena de texto es un conjunto de caracteres, tales como «HOLAMUNDO». C y C++ soporta
cadenas de texto utilizando un array de caracteres que contenga una secuencia de caracteres:
char cadena[ ] = “HOLAMUNDO”

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 3: 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 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();
system("Pause");
return 0;
}

Desarrollo Práctico
1. Escriba un programa en el que se introduzca “n” cantidad de datos enteros y los ordene de manera
ascendente.
/*Práctica 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();
return 0;
}

Nota: Corregir el programa si es necesario y mostrar la pantalla de ejecución.

Ejemplo 2. Escriba un programa que pida un rango y de entre 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();
return 0;
}

Nota: Corregir el programa si es necesario y mostrar la pantalla de ejecución.

/*Práctica 11.3 primos[D];ri=rango inicial, rf=rango final,i,j contadores */

/*Programa corregido.*/
#include<stdio.h>
#include<conio.h>
#include<stdlib.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++){
if(i%j==0)
primo++;
}//fin segundo for.
if(primo<=2){
primos[sub]=i;
sub++;
}
}
}////fin primer if

else {
for(i=rf;i<=ri;i--){
primo=0;
for(j=1;j<=i;j--){
if(i%j==0)
primo++;
 }
if(primo<=2)
primos[sub]=i;
}
}

printf("Los numeros primos son: \n");

printf("Subindice: Valor:\n");
for(i=0;i<sub;i++)
printf("[%2d] %10d\n",i,primos[i]);

getchar();

Ejemplo 3. Escriba un programa que lea una cadena y determine cuántas letras existen en ella.
/*Práctica 3*/
/*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();
return 0;
}
Nota: Corregir el programar si es necesario y mostrar la pantalla de ejecución.

Cuestionario
1. ¿Cuál es la ventaja de utilizar arreglos?
2. ¿Cuál es la sintaxis de la declaración de arreglos?
3. ¿De cuántos tipos se pueden declarar las variables en un arreglo?
4. ¿Cómo se diferencia una variable de otra en un arreglo?
5. ¿Qué hace el compilador cuando se declara un arreglo?
6. Se usa la misma memoria para almacenar un arreglo de enteros, flotantes y caracteres?
7. Defina que es un subíndice
8. ¿Cómo se accede a una sola letra en una cadena?
9. ¿Qué contiene una cadena después del nulo?
10. ¿Se puede leer un arreglos de números en una sola sentencia scanf() como lo hace la sentencia
gets() para obtener una cadena?
Conclusiones individuales