Algoritmos y estructura de datos utp
2 recomendaciones8,326 vistas
Este documento presenta un resumen de 7 capítulos sobre conceptos fundamentales de algoritmos y estructura de datos. Cubre temas como tipos de datos, lenguaje de programación C, estructuras de control, programación modular, recursividad y aplicaciones. El documento servirá como material de apoyo para la asignatura de Algoritmos y Estructura de Datos I en la carrera de Ingeniería de Telecomunicaciones.
![Algoritmo y Estructura de Datos I
56
barra atrás ()
’ apóstrofe (‘)
” comillas (“)
Función scanf()
Esta función, lee datos del teclado y los entrega al programa. El formato es el siguiente:
scanf(“Cadena de control”, variable, variable, ...);
La cadena de control se usa para identificar el tipo de dato que se va a introducir o
capturar. Los identificadores empleados son los mismos que los empleados en la función
printf().
La variable o variables que se van a introducir tendrán que ir acompañadas delante del
nombre por el signo (&). Si el dato que se va a introducir es una tira de caracteres tipo
char[ ], no es necesario el signo.
Ejemplo:
/* Programa de empleo de printf() y scanf() */
main()
{
int edad;
char nombre[20];
printf(“Introduce nombre: n“);
scanf(“%s”, nombre);
printf(“Introduce edad: n”);
scanf(“%d”,&edad);
printf(“Tu nombre es %s y tienes %d años. n”, nombre, edad);
}
Librería conio.h
Las funciones de conio (CONsole Input Output) permiten, como las de Ncurses, cambiar el
color del texto y del fondo, mostrar caracteres en cualquier posición de la consola, leer
datos de entrada sin necesidad de pulsar intro, y un montón de cosas más. Eso sí, es
bastante más restrictiva que Ncurses en otros aspectos, como la definición y manipulación
de ventanas.
Conio es una librería no estándar. Estaba disponible en la mayor parte de los compiladores
de C para entornos MS‐DOS y Windows 3.x, pero había diferencias sustanciales entre unas
implementaciones y otras, precisamente debido a que la librería no es estándar.](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-57-320.jpg)
![Algoritmo y Estructura de Datos I
103
Es probable que, por esta razón, las versiones recursivas tengan mayores limitaciones al
ejecutarse en un computador.
La aplicación de las definiciones recursivas puede ampliarse a una amplia gama de
problemas, en los que la solución más natural puede ser la que se expresa de esta forma.
Ejemplo:
/*************************************************************************
**
* Ejemplo: Obtención del máximo en un vector de números (recursivamente).
**************************************************************************
*/
/* Definición del tamaño máximo del vector */
#define TAMANO_VECTOR 100
/*************************************************************************
**
* Función recursiva que obtiene el máximo en un vector de números enteros.
* Recibe como argumento el vector que contiene los números y el número
* de posiciones del vector que están siendo utilizadas. La función
* retorna el valor del máximo elemento dentro del vector.
**************************************************************************
*/
int Maximo(int vector[], int n) {
int max, maxResto;
if (n == 1) /* Caso base */
max = vector[0];
else {
maxResto = Maximo(vector+1, n‐1); /* Maximo del resto del vector */
if (vector[0] > maxResto)
max = vector[0];
else
max = maxResto;
}
return(max);
}](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-104-320.jpg)
![Algoritmo y Estructura de Datos I
104
/*************************************************************************
**
* Programa de prueba: Lee los valores del vector y despliega el maximo
**************************************************************************
*/
main() {
int i;
int n=0;
int vec[TAMANO_VECTOR];
/* Garantiza que el usuario ingresa un numero de elementos > 0 */
while (n < 1) {
printf("Ingrese el numero de elementos: ");
scanf("%d", &n);
}
/* Lee los elementos del vector */
for (i=0; i<n; i++) {
printf("tElemento[%d]: ", i);
scanf("%d", &vec[i]);
}
/* Calcula el maximo a la vez que despliega el resultado */
printf("nMaximo: %dn", Maximo(vec, n));
}
/*************************************************************************
**
* Ejemplo: Calculo iterativo del n‐esimo termino de fibonacci
* Por definición:
* Fibonacci(0) = 0
* Fibonacci(1) = 1
* Fibonacci(n) = Fibonacci(n ‐ 1) + Fibonacci(n ‐ 2)
**************************************************************************
*/
/*************************************************************************
**
* Función que calcula iterativamente el n‐esimo termino de fibonacci](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-105-320.jpg)
![Algoritmo y Estructura de Datos I
106
/*************************************************************************
**
* Ejemplo: Obtención del maximo en un vector de números (recursivamente).
**************************************************************************
*/
/* Definición del tamaño máximo del vector */
#define TAMANO_VECTOR 100
/*************************************************************************
**
* Función recursiva que obtiene el maximo en un vector de números enteros.
* Recibe como argumento el vector que contiene los números y el número
* de posiciones del vector que estan siendo utilizadas. La función
* retorna el valor del maximo elemento dentro del vector.
**************************************************************************
*/
int Maximo(int vector[], int n) {
int max, maxResto;
if (n == 1) /* Caso base */
max = vector[0];
else {
maxResto = Maximo(vector+1, n‐1); /* Maximo del resto del vector */
if (vector[0] > maxResto)
max = vector[0];
else
max = maxResto;
}
return(max);
}
/*************************************************************************
**
* Programa de prueba: Lee los valores del vector y despliega el maximo
**************************************************************************
*/
main() {](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-107-320.jpg)
![Algoritmo y Estructura de Datos I
107
int i;
int n=0;
int vec[TAMANO_VECTOR];
/* Garantiza que el usuario ingresa un numero de elementos > 0 */
while (n < 1) {
printf("Ingrese el numero de elementos: ");
scanf("%d", &n);
}
/* Lee los elementos del vector */
for (i=0; i<n; i++) {
printf("tElemento[%d]: ", i);
scanf("%d", &vec[i]);
}
/* Calcula el maximo a la vez que despliega el resultado */
printf("nMaximo: %dn", Maximo(vec, n));
}
6.2 Prototipos de funciones
Antes de usar una función C debe tener conocimiento acerca del tipo de dato que
regresará y el tipo de los parámetros que la función espera.
El estándar ANSI de C introdujo una nueva (mejor) forma de hacer lo anterior respecto a
las versiones previas de C.
La importancia de usar prototipos de funciones es la siguiente:
Se hace el código más estructurado y por lo tanto, más fácil de leer.
Se permite al compilador de C revisar la sintaxis de las funciones llamadas.
Lo anterior es hecho, dependiendo del alcance de la función. Básicamente si una función
ha sido definida antes de que sea usada (o llamada), entonces se puede usar la función sin
problemas.
Si no es así, entonces la función se debe declarar. La declaración simplemente maneja el
tipo de dato que la función regresa y el tipo de parámetros usados por la función.
Es una práctica usual y conveniente escribir el prototipo de todas las funciones al principio
del programa, sin embargo esto no es estrictamente necesario.](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-108-320.jpg)
![Algoritmo y Estructura de Datos I
108
Para declarar un prototipo de una función se indicará el tipo de dato que regresará la
función, el nombre de la función y entre paréntesis la lista del tipo de los parámetros de
acuerdo al orden que aparecen en la definición de la función. Por ejemplo:
int longcad(char []);
Lo anterior declara una función llamada longcad que regresa un valor entero y acepta una
cadena como parámetro.
Ejercicios
Escribir una función ``reemplaza'', la cual toma una cadena como parámetro, le reemplaza
todos los espacios de la cadena por un guión bajo, y devuelve el número de espacios
reemplazados. Por ejemplo:
char cadena[] = "El gato negro";
n = reemplaza( cadena );
deberá devolver:
cadena convertida "El_gato_negro"
n = 2
Escribir un programa que lea una línea de texto en un buffer (una cadena de caracteres)
usando la función gets y calcule la longitud de la línea (NO usar la función strlen).
Modificar el programa anterior para que lea un archivo de texto. El archivo deberá
redireccionarse al programa, debiendo mostrar el contenido del mismo. En caso de que se
lea una línea con longitud 0 deberá terminar el programa.
6.3 Arreglos unidimensionales y multidimensionales
Los arreglos son una colección de variables del mismo tipo que se referencian utilizando un
nombre común. Un arreglo consta de posiciones de memoria contigua. La dirección más
baja corresponde al primer elemento y la más alta al último. Un arreglo puede tener una o
varias dimensiones. Para acceder a un elemento en particular de un arreglo se usa un
índice.
El formato para declarar un arreglo unidimensional es:
tipo nombre_arr [ tamaño ]
Por ejemplo, para declarar un arreglo de enteros llamado listanum con diez elementos se
hace de la siguiente forma:](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-109-320.jpg)
![Algoritmo y Estructura de Datos I
109
int listanum[10];
En C, todos los arreglos usan cero como índice para el primer elemento. Por tanto, el
ejemplo anterior declara un arreglo de enteros con diez elementos desde listanum[0]
hasta listanum[9].
La forma como pueden ser accesados los elementos de un arreglo, es de la siguiente
forma:
listanum[2] = 15; /* Asigna 15 al 3er elemento del arreglo listanum*/
num = listanum[2]; /* Asigna el contenido del 3er elemento a la variable num */
El lenguaje C no realiza comprobación de contornos en los arreglos. En el caso de que
sobrepase el final durante una operación de asignación, entonces se asignarán valores a
otra variable o a un trozo del código, esto es, si se dimensiona un arreglo de tamaño N, se
puede referenciar el arreglo por encima de N sin provocar ningún mensaje de error en
tiempo de compilación o ejecución, incluso aunque probablemente se provoque el fallo del
programa. Como programador se es responsable de asegurar que todos los arreglos sean
lo suficientemente grandes para guardar lo que pondrá en ellos el programa.
C permite arreglos con más de una dimensión, el formato general es:
tipo nombre_arr [ tam1 ][ tam2 ] ... [ tamN];
Por ejemplo un arreglo de enteros bidimensionales se escribirá como:
int tabladenums[50][50];
Observar que para declarar cada dimensión lleva sus propios paréntesis cuadrados.
Para acceder los elementos se procede de forma similar al ejemplo del arreglo
unidimensional, esto es,
tabladenums[2][3] = 15; /* Asigna 15 al elemento de la 3ª fila y la 4ª columna*/
num = tabladenums[25][16];
A continuación se muestra un ejemplo que asigna al primer elemento de un arreglo
bidimensional cero, al siguiente 1, y así sucesivamente.
main()
{
int t,i,num[3][4];](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-110-320.jpg)
![Algoritmo y Estructura de Datos I
110
for(t=0; t<3; ++t)
for(i=0; i<4; ++i)
num[t][i]=(t*4)+i*1;
for(t=0; t<3; ++t)
{
for(i=0; i<4; ++i)
printf("num[%d][%d]=%d ", t,i,num[t][i]);
printf("n");
}
}
En C se permite la inicialización de arreglos, debiendo seguir el siguiente formato:
tipo nombre_arr[ tam1 ][ tam2 ] ... [ tamN] = {lista‐valores};
Por ejemplo:
int i[10] = {1,2,3,4,5,6,7,8,9,10};
int num[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
Un arreglo es un conjunto de variables del mismo tipo que pueden ser referenciadas a
través de un mismo nombre. La forma de identificar a un elemento determinado es a
través de un índice.
La declaración
int Array[10]; instruye al compilador a que reserve una cantidad de memoria suficiente
para almacenar 10 entidades enteras y referirse a esa memoria a traves del identificador
Array. Dado que el número de elementos en un arreglo suele ser utilizado en distintos
lugares de un programa, es buen estilo de programación el referenciarlo a través de una
constante simbólica:
#define N 10
int Array[N]; Los elementos individuales del arreglo se comienza a numerar a partir del
elemento 0, asi, Array[0] individualiza al primer elemento y Array[9] al último.
Los arreglos pueden ser multidimensionales, asi por ejemplo](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-111-320.jpg)
![Algoritmo y Estructura de Datos I
111
double Matriz[10][20]; Define una región de memoria como para almacenar 200 reales en
doble precisión. La forma en que se organizan en la memoria estos 200 elementos es la
siguiente:
Matriz[0][0], Matriz[0][1], Matriz[0][2], ..., Matriz[1][0], Matriz[1][1],...,...,Matriz[9][19] La
inicialización de un arreglo puede realizarse a través de una lista, si la lista es más corta
que el número de elementos en el arreglo, el resto de los elementos se inicializan a 0. Se
puede obviar el tamaño de un arreglo al inicializarlo con una lista, el tamaño será el mismo
que el de la lista en este caso. Ej:
float a[5] = {0.1, 1.2, 2.3, 3.4, 4.5};
double b[100] = {1.0}; /* los 99 restantes serán 0.0 */
int a[] = {2, 3, ‐5, 7}; /* equivale a a[4]={2,3,‐5,7} */
Ejemplo:
/*
Utilización de arreglos.
Programa que cuenta cuántas veces se repite cada dígito,
cada carácter separador, y otros carácteres.
*/
#include <stdio.h>
#define ND 10
int main()
{
int c, i, nWhite = 0, nOther = 0, nDigit[ND];
for(i = 0; i < ND; i++)
nDigit[i] = 0;
while((c = getchar()) != EOF)
if(c >= '0' && c <= '9')
nDigit[c ‐ '0']++;
else
if(c == ' ' || c == 'n' || c == 't')
nWhite++;
else
nOther++;
for(i = 0; i < ND; i++)
printf("Dígito %d: %dn",i,nDigit[i]);
printf("Caracteres separadores: %dn",nWhite);](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-112-320.jpg)
![Algoritmo y Estructura de Datos I
112
printf("Otros caracteres: %dn",nOther);
return 0;
}
Compile y corra el siguiente programa y explique lo que ocurre:
#include <stdio.h>
int main(){
int a[4] = {0, 1, 2, 3};
int b[4] = {4, 5, 6, 7};
int i;
for (i=0; i<8; i++)
printf ("a[%d] = %dn",i,a[i]);
return 0;
}
Cadenas
A diferencia de otros lenguajes de programación que emplean un tipo denominado cadena
string para manipular un conjunto de simbolos, en C, se debe simular mediante un arreglo
de caracteres, en donde la terminación de la cadena se debe indicar con nulo. Un nulo se
especifica como '0'. Por lo anterior, cuando se declare un arreglo de caracteres se debe
considerar un carácter adicional a la cadena más larga que se vaya a guardar. Por ejemplo,
si se quiere declarar un arreglo cadena que guarde una cadena de diez caracteres, se hará
como:
char cadena[11];
Se pueden hacer también inicializaciones de arreglos de caracteres en donde
automáticamente C asigna el caracter nulo al final de la cadena, de la siguiente forma:
char nombre_arr[ tam ]="cadena";
Por ejemplo, el siguiente fragmento inicializa cadena con ``hola'':
char cadena[5]="hola";
El código anterior es equivalente a:
char cadena[5]={'h','o','l','a','0'};](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-113-320.jpg)
![Algoritmo y Estructura de Datos I
113
Para asignar la entrada estándar a una cadena se puede usar la función scanf con la opción
%s (observar que no se requiere usar el operador &), de igual forma para mostrarlo en la
salida estándar.
Por ejemplo:
main()
{
char nombre[15], apellidos[30];
printf("Introduce tu nombre: ");
scanf("%s",nombre);
printf("Introduce tus apellidos: ");
scanf("%s",apellidos);
printf("Usted es %s %sn",nombre,apellidos);
}
El lenguaje C no maneja cadenas de caracteres, como se hace con enteros o flotantes, por
lo que lo siguiente no es válido:
main()
{
char nombre[40], apellidos[40], completo[80];
nombre="José María"; /* Ilegal */
apellidos="Morelos y Pavón"; /* Ilegal */
completo="Gral."+nombre+appellidos; /* Ilegal */
}](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-114-320.jpg)
![Algoritmo y Estructura de Datos I
142
Ejercicio 31:
/* Ejemplo 31.c
inicializar un arreglo */
#include <stdio.h>
/* la función main inicia la ejecución del programa */
int main()
{
int n[ 10 ]; /* n es un arreglo de 10 enteros */
int i; /* contador */
/* inicializa los elementos n a 0 del arreglo */
for ( i = 0; i < 10; i++ ) {
n[ i ] = 0; /* establece el elemento i a 0 */
} /* fin de for */
printf( "%s%13sn", "Elemento", "Valor" );
/* muestra el contenido del arreglo n en forma tabular */
for ( i = 0; i < 10; i++ ) {
printf( "%7d%13dn", i, n[ i ] );
} /* fin de for */
return 0; /* indica terminación exitosa */
} /* fin de main */
Ejercicio 32:
/* Ejemplo 32.c
Inicializa un arreglo mediante una lista de inicialización */
#include <stdio.h>
/* la función main comienza la ejecución del programa */
int main()
{
/* utiliza la lista de inicialización para inicializar el arreglo n */
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
int i; /* contador */
printf( "%s%13sn", "Elemento", "Valor" );](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-143-320.jpg)
![Algoritmo y Estructura de Datos I
143
/* muestra el contenido del arreglo en forma tabular */
for ( i = 0; i < 10; i++ ) {
printf( "%7d%13dn", i, n[ i ] );
} /* fin de for */
return 0; /* indica terminación exitosa */
} /* fin de main */
Ejercicio 33:
/* Ejemplo 33.c
Inicializa los elementos del arreglo s a
los enteros pares de 2 a 20 */
#include <stdio.h>
#define TAMANIO 10
/* la función main comienza la ejecución del programa */
int main()
{
/* se puede utilizar la constante simbólica TAMANIO para especificar el tamaño del
arreglo */
int s[ TAMANIO ]; /* el arreglo s contiene 10 elementos */
int j; /* conntador */
for ( j = 0; j < TAMANIO; j++ ) { /* establece los valores */
s[ j ] = 2 + 2 * j;
} /* fin de for */
printf( "%s%13sn", "Elemento", "Valor" );
/* muestra el contenido del arreglo s en forma tabular */
for ( j = 0; j < TAMANIO; j++ ) {
printf( "%7d%13dn", j, s[ j ] );
} /* fin de for */
return 0; /* indica terminación exitosa */
} /* fin de main */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-144-320.jpg)
![Algoritmo y Estructura de Datos I
144
Ejercicio 34:
/* Ejemplo 34.c
Calcula la suma de los elementos del arreglo */
#include <stdio.h>
#define TAMANIO 12
/* la función main comienza la ejecución del programa */
int main()
{
/* utiliza una lista de inicialización para inicializar el arreglo */
int a[ TAMANIO ] = { 1, 3, 5, 4, 7, 2, 99, 16, 45, 67, 89, 45 };
int i; /* contadorr */
int total = 0; /* suma del arreglo */
/* suma el contenido del arreglo a */
for ( i = 0; i < TAMANIO; i++ ) {
total += a[ i ];
} /* fin de for */
printf( "El total de los elementos del arreglo es %dn", total );
return 0; /* indica terminación exitosa */
} /* fin de main */
Ejercicio 35:
/* Ejemplo 35.c
Programa de respuestas de examen */
#include <stdio.h>
#define TAMANIO_RESPUESTA 40 /* define los tamaños de los arreglos */
#define TAMANIO_FRECUENCIA 11
/* la función main comienza la ejecución del programa */
int main()
{
int respuesta; /* contador a través de las 40 respuestas */
int rango; /* contador de rangoes de 1 a 10 */
/* inicializa los contadores de frecuancia a 0 */
int frecuencia[ TAMANIO_FRECUENCIA ] = { 0 };](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-145-320.jpg)
![Algoritmo y Estructura de Datos I
145
/* coloca las respuestas del exámen dentro del arreglo respuestas */
int respuestas[ TAMANIO_RESPUESTA ] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10,
1, 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6,
5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };
/* por cada respuesta, seleciona el valor de un elemento del arreglo respuestas
y utiliza dicho valor como subíndice en el arreglo frecuencia para
determinar el elemento a incrementar */
for ( respuesta = 0; respuesta < TAMANIO_RESPUESTA; respuesta++ ) {
++frecuencia[ respuestas [ respuesta ] ];
} /* fin de for */
/* despliega los resultados */
printf( "%s%17sn", "Rango", "Frecuencia" );
/* muestra las frecuencias en forma tabular */
for ( rango = 1; rango < TAMANIO_FRECUENCIA; rango++ ) {
printf( "%6d%17dn", rango, frecuencia[ rango ] );
} /* fin de for */
return 0; /* indica terminación exitosa */
} /* fin de main */
Ejercicio 36:
/* Ejemplo 36.c
Programa de impresión de un Histograma */
#include <stdio.h>
#define TAMANIO 10
/* la función main comienza la ejecución del programa */
int main()
{
/* utiliza una lista de inicialización para inicializar el arreglon */
int n[ TAMANIO ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
int i; /* contador for externo para el arreglo elementos */
int j; /* contador for interno cuenta *s en cada barra del histograma */
printf( "%s%13s%17sn", "Elemento", "Valor", "Histograma" );](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-146-320.jpg)
![Algoritmo y Estructura de Datos I
146
/* para cada elemento del arreglo n, muestra una barra en el histograma */
for ( i = 0; i < TAMANIO; i++ ) {
printf( "%7d%13d ", i, n[ i ]) ;
for ( j = 1; j <= n[ i ]; j++ ) { /* imprime una barra */
printf( "%c", '*' );
} /* fin del for interno */
printf( "n" ); /* fin de una barra del histograma */
} /* fin del for externo */
return 0; /* indica terminación exitosa */
} /* fin de main */
Ejercicio 37:
/* Ejemplo 37.c
Lanza un dado de seis lados 6000 veces */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define TAMANIO 7
/* la función main comienza la ejecución del programa */
int main()
{
int cara; /* valor aleatorio del dado entre 1 y 6 */
int tiro; /* contador de tiros */
int frecuencia[ TAMANIO ] = { 0 }; /* inicializa la cuenta */
srand( time( NULL ) ); /* generador de la semilla de números aleatorios */
/* tira el dado 6000 veces */
for ( tiro = 1; tiro <= 6000; tiro++ ) {
cara = 1 + rand() % 6;
++frecuencia[ cara ]; /* remplaza la instrucción switch de la línea 26 de la figura
5.8 */
} /* fin de for */
printf( "%s%17sn", "Cara", "Frecuencia" );](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-147-320.jpg)
![Algoritmo y Estructura de Datos I
147
/* muestra los elementos 1‐6 de frecuencia en forma tabular */
for ( cara = 1; cara < TAMANIO; cara++ ) {
printf( "%4d%17dn", cara, frecuencia[ cara ] );
} /* fin de for */
return 0; /* indica terminación exitosa */
} /* fin de main */
Ejercicio 38:
/* Figura 6.10: fig06_10.c
Manipulación de arreglos de caracteres como cadenas */
#include <stdio.h>
/* la función main comienza la ejecución del programa */
int main()
{
char cadena1[ 20 ]; /* reserva 20 caracteres */
char cadena2[] = "literal de cadena"; /* reserva 18 caracteres */
int i; /* contador */
/* lee la cadena del usuario y la introduce en el arreglo cadena1 */
printf("Introduce una cadena: ");
scanf( "%s", cadena1 ); /* entrada que finaliza con un espacio en blanco */
/* muestra las cadenas */
printf( "La cadena1 es: %sncadena2 es: %sn"
"La cadena1 con espacios entre caracteres es:n",
cadena1, cadena2 );
/* muestra los caracteres hasta que encuentra el caracter nulo */
for ( i = 0; cadena1[ i ] != '0'; i++ ) {
printf( "%c ", cadena1[ i ] );
} /* fin de for */
printf( "n" );
return 0; /* indica terminación exitosa */
} /* fin de main */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-148-320.jpg)
![Algoritmo y Estructura de Datos I
148
Ejercicio 39:
/* Ejemplo 39.c
Arreglos estáticos que se inicializan en cero */
#include <stdio.h>
void iniciaArregloEstatico( void ); /* prototipo de la función */
void iniciaArregloAutomatico( void ); /* prototipo de la función */
/* la función main comienza le ejecución del programa */
int main()
{
printf( "Primera llamada a cada función:n" );
iniciaArregloEstatico();
iniciaArregloAutomatico();
printf( "nnSegunda llamada a cada función:n" );
iniciaArregloEstatico();
iniciaArregloAutomatico();
return 0; /* indica terminación exitosa */
} /* fin de main */
/* función para demostrar un arreglo estático local */
void iniciaArregloEstatico( void )
{
/* inicializ los elementos a 0 la primera vez que se llama a la función */
static int arreglo1[ 3 ];
int i; /* contador */
printf( "nValores al entrar a iniciaArregloEstatico:n" );
/* muestra el contenido del arreglo1 */
for ( i = 0; i <= 2; i++ ) {
printf( "arreglo1[ %d ] = %d ", i, arreglo1[ i ] );
} /* fin de for */
printf( "nValores al salir de iniciaArregloEstatico:n" );
/* modifica y muestra el contenido de arreglo1 */
for ( i = 0; i <= 2; i++ ) {
printf( "arreglo1[ %d ] = %d ", i, arreglo1[ i ] += 5 );](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-149-320.jpg)
![Algoritmo y Estructura de Datos I
149
} /* fin de for */
} /* fin de la función iniciaArregloEstatico */
/* función para demostrar un arreglo local automático */
void iniciaArregloAutomatico( void )
{
/* inicializa loe elementos cada vez que se llama a la función */
int arreglo2[ 3 ] = { 1, 2, 3 };
int i; /* contador */
printf( "nnValores al entrar a iniciaArregloAutomatico:n" );
/* muestra el contenido de arreglo2 */
for ( i = 0; i <= 2; i++ ) {
printf("arreglo2[ %d ] = %d ", i, arreglo2[ i ] );
} /* fin de for */
printf( "nValores al salir de iniciaArregloAutomatico:n" );
/* modifica y muestra el contenido de arreglo2 */
for ( i = 0; i <= 2; i++ ) {
printf( "arreglo2[ %d ] = %d ", i, arreglo2[ i ] += 5 );
} /* fin de for */
} /* fin de la función iniciaArregloAutomatico */
Ejercicio 40:
/* Ejemplo 40.c
Paso de arreglos y de elementos de un arreglo a funciones */
#include <stdio.h>
#define TAMANIO 5
/* prototipos de las funciones */
void modificaArreglo( int b[], int tamanio );
void modificaElemento( int e );
/* la función main comienza la ejecución del programa */
int main()
{
int a[ TAMANIO ] = { 0, 1, 2, 3, 4 }; /* inicializa a */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-150-320.jpg)
![Algoritmo y Estructura de Datos I
150
int i; /* contador */
printf( "Efectos de pasar arreglos completos por referencia:nnThe "
"los valores del arreglo original son:n" );
/* muestra el arreglo original */
for ( i = 0; i < TAMANIO; i++ ) {
printf( "%3d", a[ i ] );
} /* fin de for */
printf( "n" );
/* pasa el arreglo a modificaArreglo por referencia */
modificaArreglo( a, TAMANIO );
printf( "Los valores del arreglo modificado son:n" );
/* muestra el arreglo modificado */
for ( i = 0; i < TAMANIO; i++ ) {
printf( "%3d", a[ i ] );
} /* fin de for */
/* muestra el valor de a[ 3 ] */
printf( "nnnEfectos de pasar un elemento del arreglo "
"por valor:nnEl valor de a[3] es %dn", a[ 3 ] );
modificaElemento( a[ 3 ] ); /* pasa el elemento a[ 3 ] del arreglo por valor */
/* muestra el valor a[ 3 ] */
printf( "El valor de a[ 3 ] es %dn", a[ 3 ] );
return 0; /* indica terminación exitosa */
} /* fin de main */
/* en la función modificaArreglo, "b" apunta al arreglo original "a"
e memoria */
void modificaArreglo( int b[], int tamanio )
{
int j; /* contador */
/* multiplica cada elemento del arreglo por 2 */
for ( j = 0; j < tamanio; j++ ) {](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-151-320.jpg)
![Algoritmo y Estructura de Datos I
151
b[ j ] *= 2;
} /* fin de for */
} /* fin de la función modificaArreglo */
/* en la función modificaElemento, "e" es una copia local del elemento a[ 3 ]
del arreglo se pasó desde main */
void modificaElemento( int e )
{
/* multiplica el parámetro por 2 */
printf( "El valor en modificaElemento es %dn", e *= 2 );
} /* fin de la función modificaElemento */
Ejercicio 41:
/* Ejemplo 41.c
Demostración del calificador de tipo const con arreglos */
#include <stdio.h>
void intentaModifElArreglo( const int b[] ); /* prototipo de la función */
/* la función main comienza la ejecución del programa */
int main()
{
int a[] = { 10, 20, 30 }; /* inicializa a */
intentaModifElArreglo( a );
printf("%d %d %dn", a[ 0 ], a[ 1 ], a[ 2 ] );
return 0; /* indica terminación exitosa */
} /* fin de main */
/* en la función intentaModifElArreglo, el arreglo b es const, por lo tanto no puede
ser
utilizado para modificar el arreglo original a en main. */
void intentaModifElArreglo( const int b[] )
{
b[ 0 ] /= 2; /* error */
b[ 1 ] /= 2; /* error */
b[ 2 ] /= 2; /* error */
} /* fin de la función intentaModifElArreglo */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-152-320.jpg)
![Algoritmo y Estructura de Datos I
152
Ejercicio 42:
/* Ejemplo 42.c
Este programa introduce el tema del análisis de datos.
Calcula la media, la mediana y la moda de los datos */
#include <stdio.h>
#define TAMANIO 99
/* prototipos de las funciones */
void media( const int resp[] );
void mediana( int resp[] );
void moda( int frec[], const int resp[] ) ;
void ordenamBurbuja( int a[] );
void imprimeArreglo( const int a[] );
/* la función main comienza la ejecución del programa */
int main()
{
int frecuencia[ 10 ] = { 0 }; /* inicializa el arreglo frecuencia */
/* inicializa el arreglo respuestas */
int respuesta[ TAMANIO ] =
{ 6, 7, 8, 9, 8, 7, 8, 9, 8, 9,
7, 8, 9, 5, 9, 8, 7, 8, 7, 8,
6, 7, 8, 9, 3, 9, 8, 7, 8, 7,
7, 8, 9, 8, 9, 8, 9, 7, 8, 9,
6, 7, 8, 7, 8, 7, 9, 8, 9, 2,
7, 8, 9, 8, 9, 8, 9, 7, 5, 3,
5, 6, 7, 2, 5, 3, 9, 4, 6, 4,
7, 8, 9, 6, 8, 7, 8, 9, 7, 8,
7, 4, 4, 2, 5, 3, 8, 7, 5, 6,
4, 5, 6, 1, 6, 5, 7, 8, 7 };
/* procesa las respuestas */
media( respuesta );
mediana( respuesta );
moda( frecuencia, respuesta );
return 0; /* indica terminación exitosa */
} /* fin de main */
/* calcula el promedio de todos los valores de las respuestas */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-153-320.jpg)
![Algoritmo y Estructura de Datos I
153
void media( const int resp[] )
{
int j; /* contador del total de elementos del arreglo */
int total = 0; /* variable para mantener la suma de los elementos del arreglo */
printf( "%sn%sn%sn", "********", " Media", "********" );
/* total de los valores de las respuestas */
for ( j = 0; j < TAMANIO; j++ ) {
total += resp[ j ];
} /* fin de for */
printf( "La media es el valor promedio de los datos.n"
"La media es igual al total den"
"todos los elementos de datos divididos porn"
"el numero de elementos de datos ( %d ). La median"
"en esta ejecución es: %d / %d = %.4fnn",
TAMANIO, total, TAMANIO, ( double ) total / TAMANIO );
} /* fin de la función media */
/* ordena el arreglo y determina el valor de la mediana */
void mediana( int resp[] )
{
printf( "n%sn%sn%sn%s",
"********", " Mediana", "********",
"El arreglo de respuestas desordenado es" );
imprimeArreglo( resp ); /* muestra el arreglo desordenado */
ordenamBurbuja( resp ); /* ordena el arreglo */
printf( "nnEl arreglo ordenado es " );
imprimeArreglo( resp ); /* muestra el arreglo ordenado */
/* muestra la mediana */
printf( "nnLa mediana es el elemento %d deln"
"arreglo ordenado de elementos %d.n"
"Para esta ejecución la mediana es %dnn",
TAMANIO / 2, TAMANIO, resp[ TAMANIO / 2 ] );
} /* fin de la función mediana */
/* determina las respuestas más frecuentes */
void moda( int frec[], const int resp[] )](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-154-320.jpg)
![Algoritmo y Estructura de Datos I
154
{
int rango; /* contador para acceder a los elementos de 1 a 9 del arreglo frec */
int j; /* contador para sumar los elementos de 0 a 98 des arreglo respuesta */
int h; /* contador para desplegar histogramas de los elementos en el arreglo frec */
int masGrande = 0; /* representa la frecuencia más grande */
int valorModa = 0; /* respresenta la respuesta más frecuente */
printf( "n%sn%sn%sn",
"********", " Moda", "********" );
/* inicializa las frecuencias a 0 */
for ( rango = 1; rango <= 9; rango++ ) {
frec[ rango ] = 0;
} /* fin de for */
/* suma las frecuencias */
for ( j = 0; j < TAMANIO; j++ ) {
++frec[ resp[ j ] ];
} /* fin de for */
/* muestra los encabezados de las columnast columns */
printf( "%s%11s%19snn%54sn%54snn",
"Respuesta", "Frecuencia", "Histograma",
"1 1 2 2", "5 0 5 0 5" );
/* muestra los resultados */
for ( rango = 1; rango <= 9; rango++ ) {
printf( "%8d%11d ", rango, frec[ rango ] );
/* sigue la pista del valor de la moda y del valor de la frecuencia más grande */
if ( frec[ rango ] > masGrande ) {
masGrande = frec[ rango ];
valorModa = rango;
} /* fin de if */
/* muestra los histogramas de barras que representan el valor de la frecuencia */
for ( h = 1; h <= frec[ rango ]; h++ ) {
printf( "*" );
} /* fin del for interno */
printf( "n" ); /* nueva línea de salida */
} /* fin del for externo */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-155-320.jpg)
![Algoritmo y Estructura de Datos I
155
/* despliega el valor de la moda */
printf( "La moda es el valor mas frecuente.n"
"Para esta ejecución la moda es %d el cual ocurrio"
" %d veces.n", valorModa, masGrande );
} /* fin de la función moda */
/* función que ordena un arreglo mediante el algoritmo del método de la burbuja
algorithm */
void ordenamBurbuja( int a[] )
{
int pasada; /* contador de pasadas */
int j; /* contaodr de pasadas */
int almacena; /* ubicación temporal utilizada para intercambiar los elementos */
/* ciclo para controlar el número de pasadas */
for ( pasada = 1; pasada < TAMANIO; pasada++ ) {
/* ciclo para controlar el número de comparaciones por pasada */
for ( j = 0; j < TAMANIO ‐ 1; j++ ) {
/* intercambia los elementos si no se encuentran en orden */
if ( a[ j ] > a[ j + 1 ] ) {
almacena = a[ j ];
a[ j ] = a[ j + 1 ];
a[ j + 1 ] = almacena;
} /* fin de if */
} /* fin del for interno */
} /* fin del for externo */
} /* fin de ordenamBurbuja */
/* muestra el contenido del arreglo (20 valores por línea) */
void imprimeArreglo( const int a[] )
{
int j; /* contador */
/* muestra el contenido del arreglo */
for ( j = 0; j < TAMANIO; j++ ) {
if ( j % 20 == 0 ) { /* comienza una nueva línea cada 20 valores */
printf( "n" );](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-156-320.jpg)
![Algoritmo y Estructura de Datos I
156
} /* fin de ifend if */
printf( "%2d", a[ j ] );
} /* fin de for */
} /* fin de la función imprimeArreglo */
Ejercicio 43:
/* Ejemplo 43.c
Búsqueda lineal en un arreglo */
#include <stdio.h>
#define TAMANIO 100
/* prototipo de la función */
int busquedaLineal( const int arreglo[], int llave, int tamanio );
/* la función main comienza la ejecución del programa */
int main()
{
int a[ TAMANIO ]; /* crea el arreglo a */
int x; /* contador para inicializar los elementos de 0 a 99 del arreglo a */
int llaveBusqueda; /* valor para localizar en el arreglo a */
int elemento; /* variable para almacenar la ubicación de llaveBusqueda o ‐1 */
/* crea los datos */
for ( x = 0; x < TAMANIO; x++ ) {
a[ x ] = 2 * x;
} /* fin de for */
printf( "Introduzca la llave de busqueda entera:n" );
scanf( "%d", &llaveBusqueda );
/* intenta localizar llaveBusqueda en el arreglo a */
elemento = busquedaLineal( a, llaveBusqueda, TAMANIO );
/* despliega los resultados */
if ( elemento != ‐1 ) {
printf( "Encontre el valor en el elemento %dn", elemento );
} /* fin de if */
else {
printf( "Valor no encontradon" );](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-157-320.jpg)
![Algoritmo y Estructura de Datos I
157
} /* fin de else */
return 0; /* indica terminación exitosa */
} /* fin de main */
/* compara la llave con cada elemento del arreglo hasta que localiza el elemento
o hasta que alcanza el final del arreglo; devuelve el subíndice del elemento
si lo encontró o ‐1 si no lo encontró */
int busquedaLineal( const int arreglo[], int llave, int tamanio )
{
int n; /* contador */
/* ciclo a través del arreglo */
for ( n = 0; n < tamanio; ++n ) {
if ( arreglo[ n ] == llave ) {
return n; /* devuelve la ubicación de la llave */
} /* fin de if */
} /* fin de for */
return ‐1; /* llave no encontrada */
} /* fin de la función busquedaLineal */
Ejercicio 44:
/* Ejemplo.c
Búsqueda binaria dentro de un arreglo */
#include <stdio.h>
#define TAMANIO 15
/* prototipos de las funciones */
int busquedaBinaria( const int b[], int claveDeBusqueda, int bajo, int alto );
void despliegaEncabezado( void );
void despliegaLinea( const int b[], int bajo, int medio, int alto );
/* la función main comienza la ejecución del programa */
int main()
{
int a[ TAMANIO ]; /* crea el arreglo a */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-158-320.jpg)
![Algoritmo y Estructura de Datos I
158
int i; /* contador para inicializar los elementos de 0 a 14 del arreglo a */
int llave; /* valor a localizar en el arreglo a */
int resultado; /* variable para almacenar la ubicación de la llave o ‐1 */
/* crea los datos */
for ( i = 0; i < TAMANIO; i++ ) {
a[ i ] = 2 * i;
} /* fin de for */
printf( "Introduzca un numero entre 0 y 28: " );
scanf( "%d", &llave );
despliegaEncabezado();
/* busca la llave en el arreglo a */
resultado = busquedaBinaria( a, llave, 0, TAMANIO ‐ 1 );
/* despliega los resultados */
if ( resultado != ‐1 ) {
printf( "n%d se encuentra en el elemento %d del arreglon", llave, resultado );
} /* fin de if */
else {
printf( "n%d no se encuentran", llave );
} /* fin de else */
return 0; /* indica terminación exitosa */
} /* fin de main */
/* función para realizar la búsqueda binaria en un arreglo */
int busquedaBinaria( const int b[], int claveDeBusqueda, int bajo, int alto )
{
int central; /* variable para mantener el elemento central del arreglo */
/* realiza el ciclo hasta que el subínice bajo es mayor que el subíndice alto */
while ( bajo <= alto ) {
/* determina el elemento central del subarreglo en el que se busca */
central = ( bajo + alto ) / 2;
/* despliega el subarreglo utilizado en este ciclo */
despliegaLinea( b, bajo, central, alto );](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-159-320.jpg)
![Algoritmo y Estructura de Datos I
159
/* si claveDeBusqueda coincide con el elemento central, devuelve central */
if ( claveDeBusqueda == b[ central ] ) {
return central;
} /* fin de if */
/* si claveDeBusqueda es menor que el elemento central, establece el nuevo valor
de alto */
else if ( claveDeBusqueda < b[ central ] ) {
alto = central ‐ 1; /* busca en la mitad inferior del arreglosearch low end of array
*/
} /* fin de else if */
/* si claveDeBusqueda es mayor que el elemento central, establece el nuevo valor
para bajo */
else {
bajo = central + 1; /* busca en la mitad superior del arreglo */
} /* fin de else */
} /* fin de while */
return ‐1; /* no se encontró claveDeBusqueda */
} /* fin de la funcipon busquedaBinaria */
/* Imprime un encabezado para la salida */
void despliegaEncabezado( void )
{
int i; /* contador */
printf( "nSubindices:n" );
/* muestra el encabezado de la columna */
for ( i = 0; i < TAMANIO; i++ ) {
printf( "%3d ", i );
} /* fin de for */
printf( "n" ); /* comienza la nueva línea de salida */
/* muestra una línea de caracteres ‐ */
for ( i = 1; i <= 4 * TAMANIO; i++ ) {
printf( "‐" );
} /* fin de for */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-160-320.jpg)
![Algoritmo y Estructura de Datos I
160
printf( "n" ); /* inicia una nueva línea de salida */
} /* fin de la función despliegaEncabezado */
/* Imprime una línea de salida que muestra la parte actual
del arreglo que se esta procesando. */
void despliegaLinea( const int b[], int baj, int cen, int alt )
{
int i; /* contador para la iteración a través del arreglo b */
/* ciclo a través del arreglo completo */
for ( i = 0; i < TAMANIO; i++ ) {
/* despliega espacios si se encuentra fuera del rango actual del subarreglo */
if ( i < baj || i > alt ) {
printf( " " );
} /* fin de if */
else if ( i == cen ) { /* despliega el elemento central */
printf( "%3d*", b[ i ] ); /* marca el valor central */
} /* fin de else if */
else { /* despliega otros elementos en el subarreglo */
printf( "%3d ", b[ i ] );
} /* fin de else */
} /* fin de for */
printf( "n" ); /* inicia la nueva línea de salida */
} /* fin de la función despliegaLinea */
Ejercicio 45:
/* Figura 6.22: fig06_22.c
Ejemplo de un arreglo de doble subíndice */
#include <stdio.h>
#define ESTUDIANTES 3
#define EXAMENES 4
/* prototipos de las funciones */
int minimo( const int calificaciones[][ EXAMENES ], int alumnos, int examenes );
int maximo( const int calificaciones[][ EXAMENES ], int alumnos, int examenes );
double promedio( const int estableceCalif[], int examenes );
void despliegaArreglo( const int calificaciones[][ EXAMENES ], int alumnos, int
examenes );](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-161-320.jpg)
![Algoritmo y Estructura de Datos I
161
/* la función main comienza la ejecución del programa */
int main()
{
int estudiante; /* contador de estudiantes */
/* inicializa las calificaciones para tres estudiantes (filas) */
const int calificacionesEstudiantes[ ESTUDIANTES ][ EXAMENES ] =
{ { 77, 68, 86, 73 },
{ 96, 87, 89, 78 },
{ 70, 90, 86, 81 } };
/* muestra el arreglo calificacionesEstudiantes */
printf( "El arreglo es:n" );
despliegaArreglo( calificacionesEstudiantes, ESTUDIANTES, EXAMENES );
/* determina el valor más pequeño y el valor más grande de las calificaciones */
printf( "nnCalificacion mas baja: %dnCalificacion mas alta: %dn",
minimo( calificacionesEstudiantes, ESTUDIANTES, EXAMENES ),
maximo( calificacionesEstudiantes, ESTUDIANTES, EXAMENES ) );
/* calcula el promedio de calificaciones de cada estudiante */
for ( estudiante = 0; estudiante < ESTUDIANTES; estudiante++ ) {
printf( "El promedio de calificacion del estudiante %d es %.2fn",
estudiante, promedio( calificacionesEstudiantes[ estudiante ], EXAMENES )
);
} /* fin de for */
return 0; /* indica terminación exitosa */
} /* fin de main */
/* Encuentra la calificación mínima */
int minimo( const int calificaciones[][ EXAMENES ], int alumnos, int examenes )
{
int i; /* contador de estudiantes */
int j; /* contador de examenes */
int califBaja = 100; /* inicializa a la calificación más alta posible */
/* ciclo a través de las filas de calificaciones */
for ( i = 0; i < alumnos; i++ ) {
/* ciclo a través de las columnas de calificaciones */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-162-320.jpg)
![Algoritmo y Estructura de Datos I
162
for ( j = 0; j < examenes; j++ ) {
if ( calificaciones[ i ][ j ] < califBaja ) {
califBaja = calificaciones[ i ][ j ];
} /* fin de if */
} /* fin del for interno */
} /* fin del for externo */
return califBaja; /* devuelve la calificación mínima */
} /* fin de la función main */
/* Encuentra la calificación más alta */
int maximo( const int calificaciones[][ EXAMENES ], int alumnos, int examenes )
{
int i; /* contador de estudiantes */
int j; /* contador de examenes */
int califAlta = 0; /* inicializa a la calificación más baja posible */
/* ciclo a través de las filas de calificaciones */
for ( i = 0; i < alumnos; i++ ) {
/* ciclo a través de las columnas de calificaciones */
for ( j = 0; j < examenes; j++ ) {
if ( calificaciones[ i ][ j ] > califAlta ) {
califAlta = calificaciones[ i ][ j ];
} /* fin de if */
} /* fin del for interno */
} /* fin del for externo */
return califAlta; /* devuelve la calificación máxima */
} /* fin de la función maximo */
/* Determina la calificación promedio para un estudiante en especial */
double promedio( const int conjuntoDeCalificaciones[], int examenes )
{
int i; /* contador de exáenes */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-163-320.jpg)
![Algoritmo y Estructura de Datos I
163
int total = 0; /* suma de las calificaciones del examen */
/* total de calificaciones de un estudiante */
for ( i = 0; i < examenes; i++ ) {
total += conjuntoDeCalificaciones[ i ];
} /* fin de for */
return ( double ) total / examenes; /* promedio */
} /* fin de la función promedio */
/* Imprime el arreglo */
void despliegaArreglo( const int calificaciones[][ EXAMENES ], int alumnos, int
examenes )
{
int i; /* contador de estudiantes */
int j; /* contador de examenes */
/* muestra el encabezado de las columnas */
printf( " [0] [1] [2] [3]" );
/* muestra las calificaciones en forma tabular */
for ( i = 0; i < alumnos; i++ ) {
/* muestra la etiqueta de la fila */
printf( "ncalificacionesEstudiantes[%d] ", i );
/* muestra las calificaciones de un estudiante */
for ( j = 0; j < examenes; j++ ) {
printf( "%‐5d", calificaciones[ i ][ j ] );
} /* fin del for interno */
} /* fin del for externo */
} /* fin de la función despliegaArreglo */
Ejercicio 46:
/* Ejemplo 46.c
Uso de los operadores & y * */
#include <stdio.h>
int main()](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-164-320.jpg)
![Algoritmo y Estructura de Datos I
166
Ejercicio 49:
/* Ejemplo 49.c
Conversión de letras minúsculas a letras mayúsculas
mediante el uso de un apuntador no constante a un dato no constante */
#include <stdio.h>
#include <ctype.h>
void convierteAmayusculas( char *ptrS ); /* prototipo */
int main()
{
char cadena[] = "caracteres y $32.98"; /* inicializa char arreglo */
printf( "La cadena antes de la conversion es : %s", cadena );
convierteAmayusculas( cadena );
printf( "nLa cadena despues de la conversion es: %sn", cadena );
return 0; /* indica terminación exitosa */
} /* fin de main */
/* convierte una cadena a letras mayúsculas */
void convierteAmayusculas( char *ptrS )
{
while ( *ptrS != '0' ) { /* el caracter actual no es '0' */
if ( islower( *ptrS ) ) { /* si el caracter es minúscula, */
*ptrS = toupper( *ptrS ); /* Lo convierte a mayúscula */
} /* fin de if */
++ptrS; /* mueve ptrS al siguiente caracter */
} /* fin del while */
} /* fin de la función convierteAmayusculas */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-167-320.jpg)
![Algoritmo y Estructura de Datos I
167
Ejercicio 50:
/* Figura 7.11: fig07_11.c
Impresión de una cadena caracter por caracter mediante el uso
de un apuntador no constante a un dato constante */
#include <stdio.h>
void imprimeCaracteres( const char *ptrS );
int main()
{
/* inicializa el arreglo de caracteres */
char cadena[] = "imprime los caracteres de una cadena";
printf( "La cadena es:n" );
imprimeCaracteres( cadena );
printf( "n" );
return 0; /* indica terminación exitosa */
} /* fin de main */
/* ptrS no puede modificar el caracter al cual apunta,
es decir, ptrS es un apuntador de "solo lectura" */
void imprimeCaracteres( const char *ptrS )
{
/* repite el ciclo para toda la cadena */
for ( ; *ptrS != '0'; ptrS++ ) { /* sin inicialización */
printf( "%c", *ptrS );
} /* fin de for */
} /* fin de la función imprimeCaracteres */](https://image.slidesharecdn.com/algoritmosyestructuradedatos-utp-171021183108/85/Algoritmos-y-estructura-de-datos-utp-168-320.jpg)
Algoritmos y estructura de datos utp
- 3. Algoritmo y Estructura de Datos I 2 © Algoritmo y Estructura de Datos I Desarrollo y Edición: Vicerrectorado de Investigación Elaboración del TINS: Ing. Carlos Lon Kan Prado Diseño y Diagramación: Julia Saldaña Balandra Soporte académico: Instituto de Investigación Producción: Imprenta Grupo IDAT Queda prohibida cualquier forma de reproducción, venta, comunicación pública y transformación de esta obra.
- 4. Algoritmo y Estructura de Datos I 3 “El presente material contiene una compilación de obras de Algoritmo I publicadas lícitamente, resúmenes de los temas a cargo del profesor; constituye un material auxiliar de enseñanza para ser empleado en el desarrollo de las clases en nuestra institución. Éste material es de uso exclusivo de los alumnos y docentes de la Universidad Tecnológica del Perú, preparado para fines didácticos en aplicación del Artículo 41 inc. C y el Art. 43 inc. A., del Decreto Legislativo 822, Ley sobre Derechos de Autor”.
- 6. Algoritmo y Estructura de Datos I 5 Presentación El presente texto elaborado en el marco de desarrollo de la Ingeniería, es un material de ayuda instruccional, en la Carrera de Ingeniería de Telecomunicaciones, para la Asignatura de Algoritmos y Estructura de Datos I. Plasma la iniciativa institucional de innovación de la enseñanza‐aprendizaje educativo universitario, que en acelerada continuidad promueve la producción de materiales educativos, actualizados en concordancia a las exigencias de estos tiempos. Esta primera edición apropiadamente recopilada, de diversas fuentes bibliográficas, de uso frecuente en la enseñanza de algoritmos, está ordenada en función del sillabus de la Asignatura, arriba mencionada. La conformación del texto ha sido posible gracias al esfuerzo y dedicación académica del Profesor Ing.Carlos Lo Kan Prado, como fruto de su destacada experiencia profesional y académica; contiene VII capítulos, cuyas descripciones genéricas son como sigue: En el Capítulo I está referido a los conceptos fundamentales de los algoritmos. En el Capítulo II se explica los diferentes tipos de datos que se utilizan en la programación. En el Capítulo III se aborda la herramienta informática que se utilizara para el desarrollo de las aplicaciones en el computador. En el Capítulo IV se explica las diversas estructuras de control que se presentan. El Capítulo V se centra en la solución de temas de programación modular. En el Capítulo VI se estudia los temas de recursividad. Y en el Capítulo VII se presenta las diversas aplicaciones en lenguaje C. Finalmente, al cierre de estas líneas, el agradecimiento institucional al profesor Ing.Carlos Lo Kan Prado por su contribución a la elaboración del presente texto. Ing. Lucio H. Huamán Ureta Vicerrectorado de Investigación
- 8. Algoritmo y Estructura de Datos I 7 Índice Capítulo I Conceptos Fundamentales 1.1 Introducción ........................................................................................................... 11 1.2 Definición de lenguaje............................................................................................ 13 1.3 Definición de algoritmo.......................................................................................... 14 1.4 Tipos de algoritmos ................................................................................................ 14 1.5 Lenguajes algorítmicos........................................................................................... 14 1.6 Metodología para la solución de problemas por medio de computadora ............ 31 1.7 Definición del problema ......................................................................................... 31 1.8 Análisis del problema ............................................................................................. 31 1.9 Diseño del algoritmo .............................................................................................. 32 1.10 Codificación ............................................................................................................ 32 1.11 Prueba y depuración............................................................................................... 32 1.12 Documentación ...................................................................................................... 32 1.13 Mantenimiento....................................................................................................... 33 Capítulo II Tipos de Datos 2.1 Tipos de datos......................................................................................................... 35 2.2 Expresiones............................................................................................................. 35 2.3 Operadores y operandos........................................................................................ 36 2.4 Identificadores........................................................................................................ 40 Capítulo III Lenguaje de Programación C 3.1 Introducción ........................................................................................................... 43 3.2 Características ........................................................................................................ 43 3.3 Proceso de edición y compilación .......................................................................... 43 3.4 Estructura de un programa .................................................................................... 44
- 9. Algoritmo y Estructura de Datos I 8 Capítulo IV Estructuras de Control 4.1 Tipos de estructuras básica .................................................................................... 59 4.2 Estructura secuencial ............................................................................................. 59 4.3 Problemas secuenciales.......................................................................................... 60 Capítulo V Programación Modular 5.1 El diseño descendente: subprogramas .................................................................. 89 5.2 El diseño modular................................................................................................... 90 Capítulo VI Recursividad 6.1 Recursividad ........................................................................................................... 99 6.2 Prototipos de funciones ......................................................................................... 107 6.3 Arreglos unidimensionales y multidimensionales.................................................. 108 Capítulo VII Aplicaciones Ejercicios............................................................................................................................ 115 Bibliografía ........................................................................................................................ 169
- 10. Algoritmo y Estructura de Datos I 9 Distribución Temática Clase N° Tema Semana Horas 1 Conceptos Fundamentales Concepto de algoritmo. Lenguajes de programación. Herramientas de programación. 1 2 Tipos de datos. Constantes, variables, identificadores, expresiones, funciones. 2 3 Estructura General de un Programa Estructura de un Programa en C. Estructura de algoritmos. Contadores, acumuladores. 3 4 Estructuras de Control Programación Estructurada. Estructuras de Control ‐ Tipos Secuencial Selectiva simple (SI). 4 5 Selectiva doble (SI ‐ SINO). Selectiva múltiple (SI ‐ SINO ‐ SI). 5 6 Selectiva de control (SEGÚN ‐SEA). 6 7 Iterativa (REPETIR ‐ DESDE). 7 8 Estructura Iterativa (REPETIR ‐ MIENTRAS). 8 9 Ejercicios propuestos y nivelación 9 10 E X A M E N P A R C I A L 10 11 Sub programación Programación Modular. Subprogramas – Tipos 11 12 Variables globales y locales. Funciones, paso de parámetros. Procedimientos paso de parámetros 12 13 Recursividad Datos estructurados 13
- 11. Algoritmo y Estructura de Datos I 10 14 Tipos. Arreglos unidimensionales, declaración y acceso. 14 Clase N° Tema Semana Horas 15 Arreglos bidimensionales, declaración y acceso. 15 16 Registros Concepto. Declaración y acceso. 16 17 Arreglo de registros. Cadena de caracteres. 17 18 Índices 18 19 Ejercicios propuestos y nivelación. 19 20 E X A M E N F I N A L 20
- 12. Algoritmo y Estructura de Datos I 11 CAPÍTULO I Conceptos Fundamentales 1.1 Introducción La computadora no solamente es una máquina que puede realizar procesos para darnos resultados, sin que tengamos la noción exacta de las operaciones que realiza para llegar a esos resultados. Con la computadora además de lo anterior también podemos diseñar soluciones a la medida, de problemas específicos que se nos presenten. Más aun, si estos involucran operaciones matemáticas complejas y/o repetitivas, o requieren del manejo de un volumen muy grande de datos. El diseño de soluciones a la medida de nuestros problemas, requiere como en otras disciplinas una metodología que nos enseñe de manera gradual, la forma de llegar a estas soluciones. A las soluciones creadas por computadora se les conoce como programas y no son más que una serie de operaciones que realiza la computadora para llegar a un resultado, con un grupo de datos específicos. Lo anterior nos lleva al razonamiento de que un programa nos sirve para solucionar un problema específico. Para poder realizar programas, además de conocer la metodología mencionada, también debemos de conocer, de manera específica las funciones que pueden realizarse en la computadora y las formas en que se pueden manejar los elementos que hay en la misma. Computadora: Es un dispositivo electrónico utilizado para procesar información y obtener resultados. Los datos y la información se pueden introducir en la computadora como entrada (input) y a continuación se procesan para producir una salida (output). Proceso de información en la computadora (Fig. 1) Datos de Proceso Datos de Entrada salida Figura 1. Proceso Programa: Es el conjunto de instrucciones escritas de algún lenguaje de programación y que ejecutadas secuencialmente resuelven un problema especifico.
- 13. Algoritmo y Estructura de Datos I 12 Organización física de una computadora CPU Unida de Unidad Dispositivos de Control Arit.-Log. Dispositivos de Entrada Salida Memoria Figura 2. Organización del Computador Dispositivos de Entrada: Como su nombre lo indica, sirven para introducir datos (información) en la computadora para su proceso. Los datos se leen de los dispositivos de entrada y se almacenan en la memoria central o interna. Ejemplos: teclado, scanners (digitalizadores de rastreo), mouse (ratón), trackball (bola de ratón estacionario), joystick (palancas de juego), lápiz óptico. Dispositivos de Salida: Regresan los datos procesados que sirven de información al usuario. Ejemplo: monitor, impresora. La Unidad Central de Procesamiento (C.P.U) se divide en dos: Unidad de control Unidad Aritmético ‐ Lógica Unidad de Control: Coordina las actividades de la computadora y determina que operaciones se deben realizar y en qué orden; así mismo controla todo el proceso de la computadora. Unidad Aritmética ‐ Lógica: Realiza operaciones aritméticas y lógicas, tales como suma, resta, multiplicación, división y comparaciones. La Memoria de la computadora se divide en dos: Memoria Central o Interna Memoria Auxiliar o Externa Memoria Central (interna): La CPU utiliza la memoria de la computadora para guardar información mientras trabaja con ella; mientras esta información permanezca en memoria, la computadora puede tener acceso a ella en forma directa. Esta memoria construida internamente se llama memoria de acceso aleatorio (RAM). La memoria interna consta de dos áreas de memoria: La memoria RAM (Randon Access Memory): Recibe el nombre de memoria principal o memoria del usuario, en ella se almacena información solo mientras la computadora esta
- 14. Algoritmo y Estructura de Datos I 13 encendida. Cuando se apaga o arranca nuevamente la computadora, la información se pierde, por lo que se dice que la memoria RAM es una memoria volátil. La memoria ROM (Read Only Memory): Es una memoria estática que no puede cambiar, la computadora puede leer los datos almacenados en la memoria ROM, pero no se pueden introducir datos en ella, o cambiar los datos que ahí se encuentran; por lo que se dice que esta memoria es de solo lectura. Los datos de la memoria ROM están grabados en forma permanente y son introducidos por el fabricante de la computadora. Memoria Auxiliar (Externa): Es donde se almacenan todos los programas o datos que el usuario desee. Los dispositivos de almacenamiento o memorias auxiliares (externas o secundarias) más comúnmente utilizados son: cintas magnéticas y discos magnéticos. 1.2 Definición de Lenguaje Lenguaje: Es una serie de símbolos que sirven para transmitir uno o más mensajes (ideas) entre dos entidades diferentes. A la transmisión de mensajes se le conoce comúnmente como comunicación. La comunicación es un proceso complejo que requiere una serie de reglas simples, pero indispensables para poderse llevar a cabo. Las dos principales son las siguientes: Los mensajes deben correr en un sentido a la vez. Debe forzosamente existir 4 elementos: Emisor, Receptor, Medio de Comunicación y Mensaje. Lenguajes de Programación Es un conjunto de símbolos, caracteres y reglas (programas) que permiten a las personas comunicarse con la computadora. Los lenguajes de programación tienen un conjunto de instrucciones que nos permiten realizar operaciones de entrada/salida, calculo, manipulación de textos, lógica/comparación y almacenamiento/recuperación. Los lenguajes de programación se clasifican en: Lenguaje Maquina: Son aquellos cuyas instrucciones son directamente entendibles por la computadora y no necesitan traducción posterior para que la CPU pueda comprender y ejecutar el programa. Las instrucciones en lenguaje maquina se expresan en términos de la unidad de memoria mas pequeña el bit (dígito binario 0 o 1). Lenguaje de Bajo Nivel (Ensamblador): En este lenguaje las instrucciones se escriben en códigos alfabéticos conocidos como mnemotécnicos para las operaciones y direcciones simbólicas.
- 15. Algoritmo y Estructura de Datos I 14 Lenguaje de Alto Nivel: Los lenguajes de programación de alto nivel (BASIC, pascal, cobol, frotran, etc.) son aquellos en los que las instrucciones o sentencias a la computadora son escritas con palabras similares a los lenguajes humanos (en general en ingles), lo que facilita la escritura y comprensión del programa. 1.3 Definición de Algoritmo Un algoritmo es una serie de pasos organizados que describe el proceso que se debe seguir, para dar solución a un problema específico. Un algoritmo es una secuencia finita de instrucciones cada una de las cuales tiene un significado claro y puede ser efectuada con una cantidad finita de esfuerzo en una longitud de tiempo también finito. En matemáticas, ciencias de la computación y disciplinas relacionadas, un algoritmo (del latín, dixit algorithmus y éste a su vez del matemático persa al‐Jwarizmi) es una lista bien definida, ordenada y finita de operaciones que permite hallar la solución a un problema. Dado un estado inicial y una entrada, a través de pasos sucesivos y bien definidos se llega a un estado final, obteniendo una solución. Los algoritmos son objeto de estudio de la algoritmia. En la vida cotidiana se emplean algoritmos en multitud de ocasiones para resolver diversos problemas. Algunos ejemplos se encuentran en los instructivos (manuales de usuario), los cuales muestran algoritmos para usar el aparato en cuestión o inclusive en las instrucciones que recibe un trabajador por parte de su patrón. También existen ejemplos de índole matemática, como el algoritmo de la división para calcular el cociente de dos números, el algoritmo de Euclides para calcular el máximo común divisor de dos enteros positivos, o el método de Gauss para resolver un Sistema lineal de ecuaciones. 1.4 Tipos de Algoritmos Cualitativos: Son aquellos en los que se describen los pasos utilizando palabras. Cuantitativos: Son aquellos en los que se utilizan cálculos numéricos para definir los pasos del proceso. 1.5 Lenguajes Algorítmicos Es una serie de símbolos y reglas que se utilizan para describir de manera explícita un proceso. Tipos de Lenguajes Algorítmicos Gráficos: Es la representación gráfica de las operaciones que realiza un algoritmo (diagrama de flujo).
- 16. Algoritmo y Estructura de Datos I 15 No Gráficos: Representa en forma descriptiva las operaciones que debe realizar un algoritmo (pseudocodigo). Medios de expresión de un algoritmo Los algoritmos pueden ser expresados de muchas maneras, incluyendo al lenguaje natural, pseudocódigo, diagramas de flujo y lenguajes de programación entre otros. Las descripciones en lenguaje natural tienden a ser ambiguas y extensas. El usar pseudocódigo y diagramas de flujo evita muchas ambigüedades del lenguaje natural. Dichas expresiones son formas más estructuradas para representar algoritmos; no obstante, se mantienen independientes de un lenguaje de programación específico. La descripción de un algoritmo usualmente se hace en tres niveles: Descripción de alto nivel. Se establece el problema, se selecciona un modelo matemático y se explica el algoritmo de manera verbal, posiblemente con ilustraciones y omitiendo detalles. Descripción formal. Se usa pseudocódigo para describir la secuencia de pasos que encuentran la solución. Implementación. Se muestra el algoritmo expresado en un lenguaje de programación específico o algún objeto capaz de llevar a cabo instrucciones. También es posible incluir un teorema que demuestre que el algoritmo es correcto, un análisis de complejidad o ambos. Diagrama de flujo Definición Es la representación gráfica de flujo de un algoritmo o de secuencia rutinaria. Se basan en la utilización de diversos símbolos para representar operaciones específicas. Se les llama diagramas de flujo porque los símbolos utilizados se conectan por medio de flechas para indicar la secuencia de la operación. Un diagrama de flujo es una forma de representar gráficamente los detalles algorítmicos de un proceso multifactorial. Se utiliza principalmente en programación, economía y procesos industriales, pasando también a partir de estas disciplinas a formar parte fundamental de otras, como la psicología cognitiva. Estos diagramas utilizan una Figura 3. Diagrama de flujo
- 17. Algoritmo y Estructura de Datos I 16 serie de símbolos con significados especiales y son la representación gráfica de los pasos de un proceso. En computación, son modelos tecnológicos utilizados para comprender los rudimentos de la programación lineal. Símbolos utilizados Los símbolos que se utilizan para diseño se someten a una normalización, es decir, se hicieron símbolos casi universales, ya que, en un principio cada usuario podría tener sus propios símbolos para representar sus procesos en forma de Diagrama de flujo. Esto trajo como consecuencia que sólo aquel que conocía sus símbolos, los podía interpretar. La simbología utilizada para la elaboración de diagramas de flujo es variable y debe ajustarse a las normas preestablecidas universalmente para dichos símbolos o datos. Los diagramas de flujo sirven para representar algoritmos de manera gráfica. Características que debe cumplir un diagrama de flujo En los diagramas de flujo se presuponen los siguientes aspectos: Existe siempre un camino que permite llegar a una solución (finalización del algoritmo). Existe un único inicio del proceso. Existe un único punto de fin para el proceso de flujo (salvo del rombo que indica una comparación con dos caminos posibles). Figura 4. Diagrama de flujo
- 18. Algoritmo y Estructura de Datos I 17 Desarrollo del Diagrama de Flujo Las siguientes son acciones previas a la realización del diagrama de flujo: Identificar las ideas principales a ser incluidas en el diagrama de flujo. Deben estar presentes el dueño o responsable del proceso, los dueños o responsables del proceso anterior y posterior y de otros procesos interrelacionados, otras partes interesadas. Definir qué se espera obtener del diagrama de flujo. Identificar quién lo empleará y cómo. Establecer el nivel de detalle requerido. Determinar los límites del proceso a describir. Los pasos a seguir para construir el diagrama de flujo son: Establecer el alcance del proceso a describir. De esta manera quedará fijado el comienzo y el final del diagrama. Frecuentemente el comienzo es la salida del proceso previo y el final la entrada al proceso siguiente. Identificar y listar las principales actividades/subprocesos que están incluidos en el proceso a describir y su orden cronológico. Si el nivel de detalle definido incluye actividades menores, listarlas también. Identificar y listar los puntos de decisión. Construir el diagrama respetando la secuencia cronológica y asignando los correspondientes símbolos. Asignar un título al diagrama y verificar que esté completo y describa con exactitud el proceso elegido. Recomendaciones A su vez, es importante que al construir diagramas de flujo, se observen las siguientes recomendaciones: Evitar sumideros infinitos, burbujas que tienen entradas pero no salidas. Evitar las burbujas de generación espontánea, que tienen salidas sin tener entradas, porque son sumamente sospechosas y generalmente incorrectas. Tener cuidado con los flujos y procesos no etiquetados. Esto suele ser un indicio de falta de esmero, pero puede esconder un error aún más grave: a veces el analista no etiqueta un flujo o un proceso porque simplemente no se le ocurre algún nombre razonable.
- 19. Algoritmo y Estructura de Datos I 18 Ventajas de los diagrama de flujo Favorecen la comprensión del proceso a través de mostrarlo como un dibujo. El cerebro humano reconoce fácilmente los dibujos. Un buen diagrama de flujo reemplaza varias páginas de texto. Permiten identificar los problemas y las oportunidades de mejora del proceso. Se identifican los pasos redundantes, los flujos de los re‐procesos, los conflictos de autoridad, las responsabilidades, los cuellos de botella, y los puntos de decisión. Muestran las interfaces cliente‐proveedor y las transacciones que en ellas se realizan, facilitando a los empleados el análisis de las mismas. Son una excelente herramienta para capacitar a los nuevos empleados y también a los que desarrollan la tarea, cuando se realizan mejoras en el proceso. Tipos de diagramas de flujos Formato vertical: En él el flujo o la secuencia de las operaciones, va de arriba hacia abajo. Es una lista ordenada de las operaciones de un proceso con toda la información que se considere necesaria, según su propósito. Formato horizontal: En él, el flujo o la secuencia de las operaciones, va de izquierda a derecha. Formato panorámico: El proceso entero está representado en una sola carta y puede apreciarse de una sola mirada mucho más rápido que leyendo el texto, lo que facilita su comprensión, aun para personas no familiarizadas. Registra no solo en línea vertical, sino también horizontal, distintas acciones simultáneas y la participación de más de un puesto o departamento que el formato vertical no registra. Formato Arquitectónico: Describe el itinerario de ruta de una forma o persona sobre el plano arquitectónico del área de trabajo. El primero de los flujogramas es eminentemente descriptivo, mientras que los utilizados son fundamentalmente representativos. Crear diagramas de flujos Un diagrama de flujo u organigrama es una representación diagramática que ilustra la secuencia de las operaciones que se realizarán para conseguir la solución de un problema. Figura 5. Diagrama de flujo
- 20. Algoritmo y Estructura de Datos I 19 Los diagramas de flujo se dibujan generalmente antes de comenzar a programar el código frente a la computadora. Los diagramas de flujo facilitan la comunicación entre los programadores y la gente del negocio. Estos diagramas de flujo desempeñan un papel vital en la programación de un problema y facilitan la comprensión de problemas complicados y sobre todo muy largos. Una vez que se dibuja el diagrama de flujo, llega a ser fácil escribir el programa en cualquier idioma de alto nivel. Vemos a menudo cómo los diagramas de flujo nos dan ventaja al momento de explicar el programa a otros. Por lo tanto, está correcto decir que un diagrama de flujo es una necesidad para la documentación mejor de un programa complejo. Reglas para dibujar un diagrama de flujo Los Diagramas de flujo se dibujan generalmente usando algunos símbolos estándares; sin embargo, algunos símbolos especiales pueden también ser desarrollados cuando sean requeridos. Algunos símbolos estándares, que se requieren con frecuencia para diagramar programas de computadora se muestran a continuación: Inicio o fin del programa Pasos, procesos o líneas de instrucción de programa de computo Operaciones de entrada y salida Toma de decisiones y Ramificación Conector para unir el flujo a otra parte del diagrama Cinta magnética Disco magnético Conector de pagina Líneas de flujo
- 21. Algoritmo y Estructura de Datos I 20 Anotación Display, para mostrar datos Envía datos a la impresora Figura 6. Simbolos para el diseño de diagramas de flujo Observación: Para obtener la correcta elaboración de los símbolos, existen plantillas. Las puedes conseguir en Papelerías. Símbolos gráficos Dentro de los símbolos fundamentales para la creación de diagramas de flujo, los símbolos gráficos son utilizados específicamente para operaciones aritméticas y relaciones condicionales. La siguiente es una lista de los símbolos más comúnmente utilizados: + Sumar ‐ Menos * Multiplicación / División ± Mas o menos = Equivalente a > Mayor que < Menor que >= Mayor o igual que <= Menor o igual que < > Diferente de Figura 7. Simbolos comunes Reglas para la creación de Diagramas a. Los Diagramas de flujo deben escribirse de arriba hacia abajo, y/o de izquierda a derecha. b. Los símbolos se unen con líneas, las cuales tienen en la punta una flecha que indica la dirección que fluye la información procesos, se deben de utilizar solamente líneas de flujo horizontal o verticales (nunca diagonales). c. Se debe evitar el cruce de líneas, para lo cual se quisiera separar el flujo del diagrama a un sitio distinto, se pudiera realizar utilizando los conectores. Se debe tener en cuenta que solo se van a utilizar conectores cuando sea estrictamente necesario. d. No deben quedar líneas de flujo sin conectar
- 22. Algoritmo y Estructura de Datos I 21 e. Todo texto escrito dentro de un símbolo debe ser legible, preciso, evitando el uso de muchas palabras. f. Todos los símbolos pueden tener más de una línea de entrada, a excepción del símbolo final. g. Solo los símbolos de decisión pueden y deben tener más de una línea de flujo de salida. Ejemplos de diagramas de flujo Diagrama de flujo que encuentra la suma de los primeros 50 números naturales Figura 8. Diagrama de flujo Bueno, ahora la descripción detallada del diagrama anterior Suma, es la variable a la que se le va agregando el valor de cada número natural. N, es el contador. Éste recorrerá los números hasta llegar al 50.
- 23. Algoritmo y Estructura de Datos I 22 • El primer bloque indica el inicio del Diagrama de flujo • El segundo bloque, es un Símbolo de procesos En este bloque se indica que las variables suma y N han sido declaradas previamente y se inicializan en 0 para comenzar el conteo y la suma de valores. • El tercer bloque, es también un Símbolo de procesos En éste paso se incrementa en 1 la variable N (N = N + 1). Por lo que, en la primera lectura la variable N valdrá 1, ya que se inicializo en 0. • El cuarto bloque es exactamente lo mismo que el anterior Pero aquí la variable suma es igual a la variable suma agregada en el valor de N (En el primer caso Suma contendrá 1, ya que N = 1). • El quinto bloque es un Símbolo de Toma de decisiones y Ramificación Lo que hay dentro del bloque es una pregunta que se le hace a alguna variable para validar una condición. En este caso ¿Es N=50?, Obviamente la respuesta es no, ya que N todavía es 1. por lo que el flujo de nuestro programa se dirigirá hacía la parte en donde se observa la palabra no: Tercer Bloque, éste le sumará 1 (N=N+1) y vuelve a llegar a éste bloque, donde preguntará ¿Es N=50?... ¡No!, todavía es 2. Entonces, regresa al Tercer bloque y vuelve hacer lo mismo. Y así hasta llegar a 50, obteniendo así la suma de los primeros 50 primeros números naturales. • Por último indicamos que el resultado será mostrado en la pantalla (Display). • Fin del programa (o diagrama) Pseudocódigo Pseudocódigo es la descripción de un algoritmo que asemeja a un lenguaje de programación pero con algunas convenciones del lenguaje natural. Tiene varias ventajas con respecto a los diagramas de flujo, entre las que se destaca el poco espacio que se requiere para representar instrucciones complejas. El pseudocódigo no está regido por ningún estándar. Pseudo viene de falso y por ende es un código al que aunque es entendible no se aplica al proceso que debe realizar la máquina o computador.
- 24. Algoritmo y Estructura de Datos I 23 Un pseudocódigo (lenguaje natural), es una serie de palabras léxicas y gramaticales referidos a los lenguajes de programación, pero sin llegar a la rigidez de la sintaxis de estos ni a la fluidez del lenguaje coloquial. Esto permite codificar un programa con mayor agilidad que en cualquier lenguaje de programación, con la misma validez semántica, normalmente se utiliza en las fases de análisis o diseño de Software, o en el estudio de un algoritmo. Forma parte de las distintas herramientas de la ingeniería de software. Es, netamente, lenguaje de tipo informático. Para probar el algoritmo se utiliza un Pseudo intérprete el cual se encuentra disponible para las plataformas GNU/Linux y Windows, es de código libre y está escrito en C++. El mismo se ejecuta en un Terminal. El pseudocódigo describe un algoritmo utilizando una mezcla de frases en lenguaje común, instrucciones de programación y palabras clave que definen las estructuras básicas. Su objetivo es permitir que el programador se centre en los aspectos lógicos de la solución a un problema. No siendo el pseudocódigo un lenguaje formal, varían de un programador a otro, es decir, no hay una estructura semántica ni arquitectura estándar. Es una herramienta ágil para el estudio y diseño de aplicaciones, veamos un ejemplo, que podríamos definir como: lenguaje imperativo, de tercera generación, según el método de programación estructurada. Pseudocódigo = Pseudo (Supuesto) + Código (Instrucción) Comencemos aclarando que no es una forma de programación. Se trata de una herramienta que los analistas de sistemas utilizan para comunicar a los programadores la estructura del programa que van a realizar, de forma de tener una idea bien clara de lo que se necesita programar. Digamos que el pseudo código es una forma de diagramar un algoritmo para resolver un determinado problema, sin atenerse a ningún lenguaje de programación en especial. Un algoritmo es un conjunto de procedimientos que permiten resolver un problema. En vez de escribir el programa directamente en un lenguaje de programación determinado (C, C++, Visual Basic, etc.), crearemos un borrador entendible para todos, para luego de tener bien en claro lo que se debe hacer, pasar a la programación propiamente dicha. Figura 9. Pseudo codigo
- 25. Algoritmo y Estructura de Datos I 24 No hay que confundirlo con un diagrama de flujo. En el diagrama de flujo se representa el transcurso del programa, el momento donde se obtienen los datos, cuando se procesan y el momento de presentar los resultados. Si bien son dos herramientas que se utilizan en conjunto, cada una representa dos partes distintas en el diseño de un sistema. El pseudo código se refiere a crear un código para orientar a los programadores, pero sin la sintaxis ni la estructura propia de ningún lenguaje. Utilización en la práctica En el trabajo de un ingeniero analista, una de las partes más trabajosas es la de determinar qué es lo que necesitan de un sistema los usuarios finales. Se dedican muchas horas a hacer un relevamiento de los datos que serán necesarios, los tipos de procesamientos, las salidas, etc. Y debe existir una realimentación entre el diseño y el usuario, para garantizar que el sistema cumpla con los requisitos del usuario. Figura 10. Un sistema Supongamos que tenemos un sistema para una empresa que utiliza una interfaz gráfica en Visual Basic, algunas aplicaciones específicas en C, y páginas PHP para trabajo vía Internet. Seguramente que crear un diagrama específico para cada lenguaje sería una tarea tediosa. Gracias a esta herramienta, podemos reunir a todos los programadores, dar las pautas de trabajo, y mediante el pseudo código, cada programador sabrá lo que hace el sistema, y podrá escribir el código correspondiente. Incluso dos programadores que dominen el mismo lenguaje pueden tener metodologías de trabajo distintas. Un problema puede ser resuelto de muchas maneras, cada una más o menos eficiente que la otra, pero todas cumplen con el objetivo.
- 26. Algoritmo y Estructura de Datos I 25 Figura 11. Lenguajes y el pseudo codigo El pseudo código elimina estas diferencias, dando libertad a los programadores para que puedan ajustarse a su metodología de trabajo. Generalmente, este código se escribe con la participación de todos los programadores. Esto representa la ventaja de que muchas opiniones ayudan a elegir la mejor entre todas, logrando una solución efectiva y eficaz al problema planteado. Definición de datos del Pseudocódigo La definición de datos se da por supuesta, sobre todo en las variables sencillas, si se emplea formaciones: pilas, colas, vectores o registros, se pueden definir en la cabecera del algoritmo, y naturalmente cuando empleemos el pseudocódigo para definir estructuras de datos, esta parte la desarrollaremos adecuadamente. Funciones y operaciones Como se había mencionado antes, cada autor usa su propio pseudocódigo con sus respectivas convenciones. Por ejemplo, considere la instrucción "Reemplace el valor de la variable x por el valor de la variable y"; algunas de las posibles sintaxis para indicar lo anterior podrían ser: Asigne a el valor de Las operaciones aritméticas se representan de la forma usual en matemáticas.
- 27. Algoritmo y Estructura de Datos I 26 y las operaciones complejas se representan del mismo modo: Ejemplo 1: Hacer un pseudocodigo que imprima los números del 1 al 100. PROGRAMA contador1 ENTORNO: c 0 ALGORITMO: Borrar_pantalla( ) MIENTRAS c < 101 HACER ESCRIBIR c c c + 1 FINMIENTRAS FINPROGRAMA Ejemplo 2: Hacer un pseudocodigo que imprima los números del 100 al 0, en orden decreciente. PROGRAMA contador2 ENTORNO: c 100 ALGORITMO: Borrar_pantalla( ) MIENTRAS c >= 0 HACER ESCRIBIR c c c ‐ 1 FINMIENTRAS FINPROGRAMA
- 28. Algoritmo y Estructura de Datos I 27 Ejemplo 3: Hacer un pseudocodigo que imprima los números pares entre 0 y 100. PROGRAMA pares ENTORNO: c 2 ALGORITMO: Borrar_pantalla( ) MIENTRAS c < 101 HACER ESCRIBIR c c c + 2 FINMIENTRAS FINPROGRAMA Ejemplo 4: Hacer un programa que imprima la suma de los 100 primeros números. PROGRAMA suma ENTORNO: c 1 suma 0 ALGORITMO: Borrar_pantalla( ) MIENTRAS c <= 100 HACER suma suma + c c c + 1 FINMIENTRAS ESCRIBIR "La suma de los 100 primeros números es: " ESCRIBIR suma FINPROGRAMA
- 29. Algoritmo y Estructura de Datos I 28 Ejemplo 5: Hacer un pseudocódigo que imprima los números impares hasta el 100 y que imprima cuantos impares hay. PROGRAMA impares ENTORNO: c 1 son 0 ALGORITMO: Borrar_pantalla( ) MIENTRAS c < 100 ESCRIBIR c c c + 2 son son + 1 FINMIENTRAS ESCRIBIR "El numero de impares: " ESCRIBIR son FINPROGRAMA Ejemplo 6: Hacer un pseudocodigo que imprima todos los números naturales que hay desde la unidad hasta un numero que introducimos por teclado. PROGRAMA natural ENTORNO: i 0 n 0 ALGORITMO: Borrar_pantalla( ) ESCRIBIR "Introduce un numero: " LEER n MIENTRAS i < n HACER i i + 1 ESCRIBIR i FINMIENTRAS FINPROGRAMA
- 30. Algoritmo y Estructura de Datos I 29 Ejemplo 7: Introducir un numero por teclado. Que nos diga si es par o impar. PROGRAMA paridad ENTORNO: num 0 ALGORITMO: Borrar_pantalla( ) ESCRIBIR "Introduce un n£mero: " LEER num SI num = int( num / 2 ) * 2 ENTONCES ESCRIBIR "es par" SINO ESCRIBIR "es impar" FINSI FINPROGRAMA Ejemplo 8: Imprimir y contar los múltiplos de 3 desde la unidad hasta un numero que introducimos por teclado. PROGRAMA multiplo ENTORNO: i 3 n 0 c 0 ALGORITMO: Borrar_pantalla( ) ESCRIBIR "Numero: " LEER n MIENTRAS i <= n HACER SI i = int( i / 3 ) * 3 ENTONCES ESCRIBIR i c c + 1 FINSI i i + 1 FINMIENTRAS ESCRIBIR "El n£mero de m£ltiplos de 3 son: " ESCRIBIR c FINPROGRAMA
- 31. Algoritmo y Estructura de Datos I 30 Ejercicios Propuestos Construir diagramas de Flujo y Pseudo Códigos para los siguientes enunciados: 1. Mostrar su Nombre y su Apellido 2. Mostrar el Nombre y Apellido de cualquier persona de quien se introduzcan los datos. 3. Sumar 2 + 2 y mostrar el resultado (por pantalla, por impresora, por pantalla e impresora) 4. Sumar 2 números cualesquiera. 5. Dados 2 números, estar en capacidad de sumarlos, restarlos, multiplicarlos y dividirlos. 6. Dados los coeficientes de una Ecuación de 2do Grado, calcular y mostrar x1 y x2. 7. Calcular la Serie de Fibonacci hasta un número dado. 8. Calcular la edad fácil: al introducir sólo el año de nacimiento mediano: al introducir el mes y año de nacimiento complejo: al introducir el día, mes y año de nacimiento 9. Calcular la nota definitiva para 5 alumnos, tomando en cuenta las ponderaciones siguientes: 1er Practica: 30% 2do Practica: 25% 3er Practica: 20% 4ta Practica: 25% 10. 10.Calcular el sueldo quincenal, tomando en cuenta los siguientes parámetros: Bs 450.000 por quincena Bono de 10% de profesionalización a los que tienen título universitario Bono quincenal de transporte de Bs 70.000 Bono de alimentación de Bs 5.000 por día laborado Deducciones: 2% Seguro Colectivo 1% Paro Forzoso 2% Seguro Social 2% Caja de Ahorro 11. Calcular los números primos en un rango dado. 12. Calcular la suma de todos los números enteros impares, en un rango dado. 13. Calcular el factorial de un número. 14. Problema: Buscar una carta Se tiene un mazo de cartas inglesas, el cual no está completo, pero se sabe que tiene “n” cartas, y está desordenado. Se desea determinar si una carta determinada está o no en el mazo, y si está, en qué posición 15. Problema: serie de ulam Dado un valor inicial “x”, se pide generar los términos de la serie de Ulam.
- 32. Algoritmo y Estructura de Datos I 31 Se dice que cualquier número menor que 1800 converge a 1 si se calcula cada término siguiendo las reglas de la serie de Ulam. La regla para calcular el término siguiente a “x” es: Si x par, el siguiente término se obtiene dividiendo x por 2 Si x es impar, el siguiente término se obtiene multiplicando x por 3 y sumando 1 al resultado. 16. Problema: caída libre La ecuación que rige el movimiento uniformemente acelerado de una partícula está dado por la siguiente fórmula: x(t)= xo + vo * t + ½ * a * t2, donde xo es la posición inicial de la partícula, vo es la velocidad inicial y a, la aceleración. El movimiento de caída libre se rige por la misma ecuación anterior, salvo que la velocidad inicial es cero, (se deja caer el objeto del reposo), y la aceleración es la constante g, que se puede aproximar por 10 con signo negativo. Construya un algoritmo que reciba como entrada una altura h, desde la cual se deja caer un objeto, y entregue como salida la posición de la partícula, y el tiempo transcurrido en cada segundo desde que es soltado hasta que llega al suelo. Indicación. Considere posición inicial h, y posición final 0 (suelo) 17. Problema: Máquina de Sencillar Se tiene una máquina que permite sencillar dinero. La máquina está diseñada para que, dado un monto cualquiera, indique cuantos billetes de 1000 y monedas de 100, 10 y 1 debe entregar, a cambio de ese monto. Una característica de esta máquina es que siempre intentará dar la menor cantidad de monedas. Construya el algoritmo que permita que la máquina funcione de la forma descrita. Es decir, un algoritmo que reciba como entrada un monto de dinero, entero, positivo y entregue como salida la cantidad de billetes y de monedas de las distintas denominaciones que equivalen a dicho monto. 1.6 Metodología para la solución de problemas por medio de computadora 1.7 Definición del Problema Esta fase está dada por el enunciado del problema, el cual requiere una definición clara y precisa. Es importante que se conozca lo que se desea que realice la computadora; mientras esto no se conozca del todo no tiene mucho caso continuar con la siguiente etapa. 1.8 Análisis del Problema Una vez que se ha comprendido lo que se desea de la computadora, es necesario definir: Los datos de entrada. Cuál es la información que se desea producir (salida) Los métodos y fórmulas que se necesitan para procesar los datos.
- 33. Algoritmo y Estructura de Datos I 32 Una recomendación muy practica es el que nos pongamos en el lugar de la computadora y analicemos que es lo que necesitamos que nos ordenen y en que secuencia para producir los resultados esperados. 1.9 Diseño del Algoritmo Las características de un buen algoritmo son: Debe tener un punto particular de inicio. Debe ser definido, no debe permitir dobles interpretaciones. Debe ser general, es decir, soportar la mayoría de las variantes que se puedan presentar en la definición del problema. Debe ser finito en tamaño y tiempo de ejecución. 1.10 Codificación La codificación es la operación de escribir la solución del problema (de acuerdo a la lógica del diagrama de flujo o pseudocodigo), en una serie de instrucciones detalladas, en un código reconocible por la computadora, la serie de instrucciones detalladas se le conoce como código fuente, el cual se escribe en un lenguaje de programación o lenguaje de alto nivel. 1.11 Prueba y Depuración Los errores humanos dentro de la programación de computadoras son muchos y aumentan considerablemente con la complejidad del problema. El proceso de identificar y eliminar errores, para dar paso a una solución sin errores se le llama depuración. La depuración o prueba resulta una tarea tan creativa como el mismo desarrollo de la solución, por ello se debe considerar con el mismo interés y entusiasmo. Resulta conveniente observar los siguientes principios al realizar una depuración, ya que de este trabajo depende el éxito de nuestra solución. 1.12 Documentación Es la guía o comunicación escrita es sus variadas formas, ya sea en enunciados, procedimientos, dibujos o diagramas. A menudo un programa escrito por una persona, es usado por otra. Por ello la documentación sirve para ayudar a comprender o usar un programa o para facilitar futuras modificaciones (mantenimiento). La documentación se divide en tres partes: Documentación Interna Documentación Externa Manual del Usuario
- 34. Algoritmo y Estructura de Datos I 33 Documentación Interna: Son los comentarios o mensaje que se añaden al código fuente para hacer más claro el entendimiento de un proceso. Documentación Externa: Se define en un documento escrito los siguientes puntos: Descripción del Problema Nombre del Autor Algoritmo (diagrama de flujo o pseudocodigo) Diccionario de Datos Código Fuente (programa) Manual del Usuario: Describe paso a paso la manera cómo funciona el programa, con el fin de que el usuario obtenga el resultado deseado. 1.13 Mantenimiento Se lleva a cabo después de terminado el programa, cuando se detecta que es necesario hacer algún cambio, ajuste o complementación al programa para que siga trabajando de manera correcta. Para poder realizar este trabajo se requiere que el programa este correctamente documentado.
- 36. Algoritmo y Estructura de Datos I 35 CAPÍTULO II Tipos de Datos 2.1 Tipos De Datos Todos los datos tienen un tipo asociado con ellos. Un dato puede ser un simple carácter, tal como ‘b’, un valor entero tal como 35. El tipo de dato determina la naturaleza del conjunto de valores que puede tomar una variable. Numéricos Simples Lógicos Alfanuméricos (string) Tipos de datos Arreglos (Vectores, Matrices) Estructurados Registros (Def. por el Archivos usuario) Apuntadores Tipos de Datos Simples Datos Numéricos: Permiten representar valores escalares de forma numérica, esto incluye a los números enteros y los reales. Este tipo de datos permiten realizar operaciones aritméticas comunes. Datos Lógicos: Son aquellos que solo pueden tener dos valores (cierto o falso) ya que representan el resultado de una comparación entre otros datos (numéricos o alfanuméricos). Datos Alfanuméricos (String): Es una secuencia de caracteres alfanuméricos que permiten representar valores identificables de forma descriptiva, esto incluye nombres de personas, direcciones, etc. Es posible representar números como alfanuméricos, pero estos pierden su propiedad matemática, es decir no es posible hacer operaciones con ellos. Este tipo de datos se representan encerrados entre comillas. Ejemplo: “Instituto Tecnológico de los Olivos” “2009” 2.2 Expresiones Las expresiones son combinaciones de constantes, variables, símbolos de operación, paréntesis y nombres de funciones especiales. Por ejemplo:
- 37. Algoritmo y Estructura de Datos I 36 a+(b + 3)/c Cada expresión toma un valor que se determina tomando los valores de las variables y constantes implicadas y la ejecución de las operaciones indicadas. Una expresión consta de operadores y operandos. Según sea el tipo de datos que manipulan, se clasifican las expresiones en: Aritméticas Relaciónales Lógicas 2.3 Operadores y Operandos Operadores: Son elementos que relacionan de forma diferente, los valores de una o más variables y/o constantes. Es decir, los operadores nos permiten manipular valores. Aritméticos Tipos de Operadores Relaciónales Lógicos Operadores Aritméticos: Los operadores aritméticos permiten la realización de operaciones matemáticas con los valores (variables y constantes). Los operadores aritméticos pueden ser utilizados con tipos de datos enteros o reales. Si ambos son enteros, el resultado es entero; si alguno de ellos es real, el resultado es real. Operando (Operador) Operando Valor (constante o variable) Operadores Aritméticos + Suma ‐ Resta * Multiplicación / División Mod Modulo (residuo de la división entera)
- 38. Algoritmo y Estructura de Datos I 37 Ejemplos: Expresión Resultado 7 / 2 = 3.5 12 mod 7 = 5 4 + 2 * 5 = 14 Prioridad de los Operadores Aritméticos Todas las expresiones entre paréntesis se evalúan primero. Las expresiones con paréntesis anidados se evalúan de dentro a fuera, el paréntesis más interno se evalúa primero. Dentro de una misma expresión los operadores se evalúan en el siguiente orden. 1.‐ ^ Exponenciación 2.‐ *, /, mod Multiplicación, división, modulo. 3.‐ +, ‐ Suma y resta. Los operadores en una misma expresión con igual nivel de prioridad se evalúan de izquierda a derecha. Ejemplos: 4 + 2 * 5 = 14 23 * 2 / 5 = 9.2 46 / 5 = 9.2 3 + 5 * (10 ‐ (2 + 4)) = 23 3 + 5 * (10 ‐ 6) = 3 + 5 * 4 = 3 + 20 = 23 3.5 + 5.09 ‐ 14.0 / 40 = 5.09 3.5 + 5.09 ‐ 3.5 = 8.59 ‐ 3.5 = 5.09 2.1 * (1.5 + 3.0 * 4.1) = 28.98 2.1 * (1.5 + 12.3) = 2.1 * 13.8 = 28.98 Operadores Relaciónales: Se utilizan para establecer una relación entre dos valores. Compara estos valores entre si y esta comparación produce un resultado de certeza o falsedad (verdadero o falso).
- 39. Algoritmo y Estructura de Datos I 38 Los operadores relaciónales comparan valores del mismo tipo (numéricos o cadenas) Tienen el mismo nivel de prioridad en su evaluación. Los operadores relaciónales tiene menor prioridad que los aritméticos. Operadores Relaciónales > Mayor que < Menor que > = Mayor o igual que < = Menor o igual que < > Diferente = Igual Ejemplos: Si a = 10, b = 20, c = 30 a + b > c Falso a ‐ c Verdadero a ‐ b = c Falso a * b < > c Verdadero Ejemplos no lógicos: a < b < c 10 < 20 < 30 T < 30 (no es lógico porque tiene diferentes operandos) Operadores Lógicos: Estos operadores se utilizan para establecer relaciones entre valores lógicos. Estos valores pueden ser resultado de una expresión relacional. Operadores Lógicos And Y Or O Not Negación
- 40. Algoritmo y Estructura de Datos I 39 Operando And Operando1 Operador Operando2 Resultado T AND T T T F F F T F F F F Operando Or Operando1 Operador Operando2 Resultado T OR T T T F T F T T F F F Operando Not Operando Resultado T F F T Ejemplos: (a < b) and (b < c) (10<20) and (20<30) T and T T Prioridad de los Operadores Lógicos Not And Or Prioridad de los Operadores en General 1.- ( ) 2.- ^ 3.- *, /, Mod, Not 4.- +, -, And 5.- >, <, > =, < =, < >, =, Or
- 41. Algoritmo y Estructura de Datos I 40 Ejemplos: a = 10 b = 12 c = 13 d =10 1) ((a > b) or (a < c)) and ((a = c) or (a > = b)) F T F F T F F 2) ((a > = b) or (a < d)) and (( a > = d) and (c > d)) F F T T F T F 3) not (a = c) and (c > b) F T T T 2.4 Identificadores Los identificadores representan los datos de un programa (constantes, variables, tipos de datos). Un identificador es una secuencia de caracteres que sirve para identificar una posición en la memoria de la computadora, que nos permite tener acceso a su contenido. Ejemplo: Nombre Num_hrs Calif2 Reglas para formar un Identificador Debe comenzar con una letra (A a Z, mayúsculas o minúsculas) y no deben contener espacios en blanco. Letras, dígitos y caracteres como la subraya ( _ ) están permitidos después del primer carácter. La longitud de identificadores puede ser de hasta 8 caracteres. Constantes y Variables Constante: Una constante es un dato numérico o alfanumérico que no cambia durante la ejecución del programa. Ejemplo: pi = 3.1416
- 42. Algoritmo y Estructura de Datos I 41 Variable: Es un espacio en la memoria de la computadora que permite almacenar temporalmente un dato durante la ejecución de un proceso, su contenido puede cambia durante la ejecución del programa. Para poder reconocer una variable en la memoria de la computadora, es necesario darle un nombre con el cual podamos identificarla dentro de un algoritmo. Ejemplo: área = pi * radio ^ 2 Las variables son: el radio, el área y la constate es pi Clasificación de las Variables Numéricas Por su Contenido Lógicas Alfanuméricas (String) Variables De Trabajo Por su Uso Contadores Acumuladores Por su Contenido Variable Numéricas: Son aquellas en las cuales se almacenan valores numéricos, positivos o negativos, es decir almacenan números del 0 al 9, signos (+ y ‐) y el punto decimal. Ejemplo: IGV=0.15 pi=3.1416 costo=2500 Variables Lógicas: Son aquellas que solo pueden tener dos valores (cierto o falso) estos representan el resultado de una comparación entre otros datos. Variables Alfanuméricas: Esta formada por caracteres alfanuméricos (letras, números y caracteres especiales). Ejemplo: letra=’a’ apellido=’lopez’ direccion=’Av. Libertad #190’
- 43. Algoritmo y Estructura de Datos I 42 Por su Uso Variables de Trabajo: Variables que reciben el resultado de una operación matemática completa y que se usan normalmente dentro de un programa. Ejemplo: Suma=a+b/c Contadores: Se utilizan para llevar el control del número de ocasiones en que se realiza una operación o se cumple una condición. Con los incrementos generalmente de uno en uno. Acumuladores: Forma que toma una variable y que sirve para llevar la suma acumulativa de una serie de valores que se van leyendo o calculando progresivamente.
- 44. Algoritmo y Estructura de Datos I 43 CAPÍTULO III Lenguaje de Programación C 3.1 Introducción Fue creado por Dennis Ritchie de los laboratorios BELL en 1972, cuando trabajaba junto a Ken Thompson, en el diseño del sistema operativo UNIX. Se deriva del lenguaje B de Thompson, que a su vez se deriva del BCPL de Martín Richards. 3.2 Características Es un lenguaje moderno de propósito general, que incorpora las características de control apuntadas como deseables por la teoría y práctica de la informática. Planificación escalonada. Programación estructurada. Diseño modular. Programas compactos. Rapidez de ejecución. Portátil. De relativo bajo nivel. Precisa compilarse. 3.3 Proceso de edición y compilación Los pasos necesarios para desarrollar un programa C son los siguientes: a. Edición: Utilizar un editor para escribir el programa fuente texto. b. Compilación: Compilar el programa fuente, es decir, traducir el programa a lenguaje máquina. c. Ejecución: Una vez compilado se procede a la ejecución del programa tecleando el nombre del fichero‐programa.
- 45. Algoritmo y Estructura de Datos I 44 Figura 1. Diagrama de flujo 3.4 Estructura de un programa Un programa en C consiste en una o más funciones, de las cuales una de ellas, debe llamarse main() y es la principal de todas. El programa comienza con la función: main() Cada función o programa, consta de un cuerpo de función delimitado por llaves de comienzo y fin { } En el cuerpo de la función irán incluidas: sentencias, variables, funciones, etc. terminadas cada una de ellas por un punto y coma;
- 47. Algoritmo y Estructura de Datos I 46 Los datos en C: Variables y Constantes Tipos de Datos Los datos manejados en C pueden ser de cinco tipos básicos. INT: enteros sin decimales entre (‐32768 y +32767). Ocupan en la memoria 2 bytes. CHAR: caracteres alfabéticos, signos especiales, etc. El rango es (0 y 255). Ocupan en la memoria 1 byte. FLOAT: números decimales entre (3.4E‐38 a 3.4E+38) con ocho dígitos de precisión. Ocupan en la memoria 4 bytes. DOUBLE: números decimales entre (1.7E‐308 a 1.7E+308) con 16 dígitos de precisión. Ocupan en la memoria 8 bytes. VOID: sin valor. No almacenar nada y por tanto no necesitan espacio físico de la memoria. Identificadores de Tipo Todos los tipos básicos excepto void pueden tener modificadores. Se usan para alterar el significado de un tipo base de acuerdo con nuestras necesidades. Los modificadores son: signed unsigned long short Se pueden aplicar todos los modificadores para los tipos base carácter y entero. También se puede aplicar el modificador long a double. A continuación mostramos todas las posibles combinaciones de los tipos básicos y los modificadores.
- 48. Algoritmo y Estructura de Datos I 47 Figura 2. Tipos de identificadores NOTA: El espacio ocupado en la memoria por los tipos de datos aquí mostrados vendrá determinado por el tipo de compilador implementado. En cualquier caso, mediante la función sizeof (tipo de dato) se podrá determinar el número de bytes ocupados. Variables Se utilizan para almacenar datos internamente en la memoria de trabajo del ordenador, durante la ejecución de un programa. Como nombres de variables se admiten letras y números (por norma letras minúsculas). El primer carácter debe ser una letra. No se admiten blancos pero sí el signo de subrayado. Sólo se admiten los ocho primeros caracteres. Mayúsculas y minúsculas se diferencian. No se pueden emplear palabras clave del lenguaje. Las variables deben ser declaradas según el tipo de datos que van a almacenar. Bien al comienzo del programa o antes de ser usadas por primera vez. La forma de declararlas es: Se define el tipo de dato a almacenar. Nombre de la variable. Asignación de un valor inicial (no obligatorio).
- 49. Algoritmo y Estructura de Datos I 48 Ejemplo: /* Declaración de variables */ #include <stdio.h> main() { int a=3, b=7, c=0; c=a*b; printf(“El resultado es: %d”,c); } Constantes Son valores que no varían durante la ejecución de un programa. Pueden adoptar cualquiera de los tipos de datos declarados anteriormente. Es conveniente declararlas al principio del programa. La sentencia #define es usada para definir las constantes y se coloca al principio del programa antes de la función main(). #define PI 3.14159 #define PRIMO 13 Las constantes como norma se suelen escribir con mayúsculas. Operadores Fundamentales En C se utilizan operadores para representar operaciones matemáticas. Por ejemplo, el operador + hace que se sumen los valores situados a su izquierda y derecha. Veamos los que hemos dado en llamar fundamentales. Operador de asignación: = Asigna a la variable de la izquierda el valor de la derecha. bmw=2002; Operador de adición: + Hace que los dos valores situados a su izquierda y derecha se sumen. bmw=10+20;
- 51. Algoritmo y Estructura de Datos I 50 La diferencia entre ambos, es la misma que en el caso anterior. Operadores Condicionales o de Relación Los operadores de relación o condicionales se emplean para hacer comparaciones. A continuación, mostramos una lista completa de estos operadores en C. Operadores Lógicos Cuando necesitamos combinar dos o más expresiones de relación, hacemos uso de los operadores lógicos. Existen tres operadores lógicos en C. Operadores de Bit Las operaciones sobre bits se refieren a la comprobación, configuración o desplazamiento de los bits reales en un byte o palabra, que corresponden a los tipos de datos char e int. No se pueden usar operaciones sobre bits en los tipos float, double, long doublé y void. Los operadores que existen para el tratamiento de bits, son los siguientes:
- 52. Algoritmo y Estructura de Datos I 51 Normas de Precedencia de los Operadores No todos los operadores tienen la misma prioridad, lo que quiere decir, que aquellas operaciones que utilizan ciertos operadores se efectuarán antes que otras. Libreria stdio.h stdio.h, que significa "standard input‐output header" (cabecera estandar E/S), es la biblioteca estándar del lenguaje de programación C, el archivo de cabecera que contiene las definiciones de macros, las constantes, las declaraciones de funciones y la definición de tipos usados por varias operaciones estándar de entrada y salida. Por motivos de compatibilidad, el lenguaje de programación C++ (derivado de C) también tiene su propia implementación de estas funciones, que son declaradas con el archivo de cabecera cstdio. Las funciones declaradas en stdio.h son sumamente populares.
- 53. Algoritmo y Estructura de Datos I 52 Ejemplo: En lenguaje C y sus derivados, todas las funciones son declaradas en archivos de cabecera. Así, los programadores tienen que incluir el archivo de cabecera stdio.h dentro del código fuente para poder utilizar las funciones que están declaradas. nota: el compilador diferencia las mayúsculas entre las minúsculas. #include <stdio.h> int main(void) { int ch; while ((ch = getchar()) != EOF) putchar(ch); putchar('n'); return 0; } El programa lee todas las entradas desde la entrada estándar y las muestra en la salida estándar, línea a línea. Funciones miembro Las funciones declaradas en stdio.h pueden clasificarse en dos categorías: Funciones de manipulación de ficheros y funciones de manipulación de entradas y salidas. Nombre Descripción Funciones de manipulación de ficheros fclose cierra un fichero a través de su puntero fopen, freopen, fdopen abre un fichero para lectura, para escritura/reescritura o para adición remove elimina un fichero rename cambia al fichero de nombre rewind La función rewind coloca el indicador de posición de fichero para el stream apuntado por stream al comienzo del fichero. tmpfile crea y abre un fichero temporal que es borrado cuando cerramos con la función fclose()
- 54. Algoritmo y Estructura de Datos I 53 Funciones de manipulación de entradas y salidas clearerr Despeja los indicadores de final de fichero y de posición de fichero para el stream apuntado por stream al comienzo del fichero. feof comprueba el indicador de final de fichero ferror comprueba el indicador de errores fflush Si stream apunta a un stream de salida o de actualización cuya operación más reciente no era de entrada, la función fflush envía cualquier dato aún sin escribir al entorno local o a ser escrito en el fichero; si no, entonces el comportamiento no está definido. Si stream es un puntero nulo, la función fflush realiza el despeje para todos los streams cuyo comportamiento está descrito anteriormente. fgetpos devuelve la posición actual del fichero fgetc devuelve un carácter de un fichero fgets consigue una cadena de caracteres de un fichero fputc escribe un carácter en un fichero fputs escribe una cadena de caracteres en un fichero ftell devuelve la posición actual del fichero como número de bytes fseek sitúa el puntero de un fichero en una posición aleatoria fsetpos cambia la posición actual de un fichero fread lee diferentes tamaños de datos de un fichero fwrite envía, desde el array apuntado por puntero, hasta nmemb de elementos cuyo tamaño es especificado por tamanyo. El indicador de posición de ficheros es avanzado por el número de caracteres escritos correctamente. Si existe un error, el valor resultante del indicador de posición de ficheros es indeterminado. getc devuelve un carácter desde un fichero getchar igual que getc gets lee caracteres de entrada hasta que encuentra un salto de línea, y los almacena en un único argumento. printf, fprintf, sprintf snprintf usados para imprimir salidas de datos vprintf también utilizado para imprimir salidas
- 55. Algoritmo y Estructura de Datos I 54 perror escribe un mensaje de error a stderr putc devuelve un carácter de un fichero putchar, fputchar igual que putc(stdout) scanf, fscanf, sscanf utilizado para introducir entradas. vfscanf, vscanf, vsscanf también utilizado para introducir entradas. setbuf Esta función es equivalente a la función setvbuf pasando los valores _IOFBF para modo y BUFSIZ para tamaño, o (si acumulador es un puntero nulo), con el valor _IONBF para modo. setvbuf sólo puede ser usada después de que el stream apuntado por stream ha sido asociado con un fichero abierto y antes de otra operación cualquiera es llevada acabo al stream. El argumento modo determina cómo stream será almacenado según lo siguiente: _IOFBF ocasiona la entrada/salida a ser completamente almacenado; _IOLBF ocasiona la entrada/salida a almacenar por líneas; _IONBF ocasiona la entrada/salida a no ser almacenado. Si acumulador no es un puntero nulo, el array al que es apuntado puede ser usado en vez de la acumulación adjudicada por la función setvbuf. El argumento tamanyo específica el tamaño del array. tmpnam Genera una cadena de caracteres que es un nombre válido para ficheros y que no es igual al nombre de un fichero existente. La función tmpnam genera una cadena diferente cada vez que es llamada, hasta un máximo de TMP_MAX veces. Si la función es llamada más veces que TMP_MAX, entonces el comportamiento de la función está definido según la implementación del compilador. ungetc puts imprime una de cadena de caracteres Funciones de Entrada/Salida Las funciones de entrada/salida permiten al programa comunicarse con el exterior. Son utilizadas para sacar determinadas informaciones por la pantalla y capturar valores por el teclado. Son estándar de la propia librería de C por lo que no hay necesidad de definirlas de nuevo.
- 56. Algoritmo y Estructura de Datos I 55 Función printf() Lee datos del programa (variables, resultados de operaciones, frases, mensajes, etc.) y los envía a la pantalla. El formato es el siguiente: printf(“Cadena de control”, variables, operaciones, ...); La cadena de control se usa para escribir mensajes, identificar el tipo de dato que se va a mostrar, indicar controles tales como: salto de línea, salto de página, etc. Los identificadores empleados son los siguientes: Un número colocado entre el % y el orden de formato, actúa como especificador mínimo de ancho de campo. Este especificador completa la salida con blancos o ceros para asegurar que al menos es la longitud mínima. Si la cadena o el número a representar es mayor que el campo mínimo, el campo se amplía para imprimir la cadena o el número completo. Ejemplos: %5d ajuste a la derecha, rellena con espacios %05d juste a la derecha, rellena con ceros %10.4f ajuste a la derecha, rellena con espacios y cuatro decimales %‐10.2f ajuste a la izquierda, rellena con espacios y dos decimales Caracteres de control son: Control Efecto en pantalla n cambia de línea r retorno de carro t tabulador b retroceso del cursor una posición f cambio de página
- 57. Algoritmo y Estructura de Datos I 56 barra atrás () ’ apóstrofe (‘) ” comillas (“) Función scanf() Esta función, lee datos del teclado y los entrega al programa. El formato es el siguiente: scanf(“Cadena de control”, variable, variable, ...); La cadena de control se usa para identificar el tipo de dato que se va a introducir o capturar. Los identificadores empleados son los mismos que los empleados en la función printf(). La variable o variables que se van a introducir tendrán que ir acompañadas delante del nombre por el signo (&). Si el dato que se va a introducir es una tira de caracteres tipo char[ ], no es necesario el signo. Ejemplo: /* Programa de empleo de printf() y scanf() */ main() { int edad; char nombre[20]; printf(“Introduce nombre: n“); scanf(“%s”, nombre); printf(“Introduce edad: n”); scanf(“%d”,&edad); printf(“Tu nombre es %s y tienes %d años. n”, nombre, edad); } Librería conio.h Las funciones de conio (CONsole Input Output) permiten, como las de Ncurses, cambiar el color del texto y del fondo, mostrar caracteres en cualquier posición de la consola, leer datos de entrada sin necesidad de pulsar intro, y un montón de cosas más. Eso sí, es bastante más restrictiva que Ncurses en otros aspectos, como la definición y manipulación de ventanas. Conio es una librería no estándar. Estaba disponible en la mayor parte de los compiladores de C para entornos MS‐DOS y Windows 3.x, pero había diferencias sustanciales entre unas implementaciones y otras, precisamente debido a que la librería no es estándar.
- 58. Algoritmo y Estructura de Datos I 57 En lenguaje C esta librería contiene los prototipos de las funciones, macros, y constantes para preparar y manipular la consola en modo texto en el entorno de MS‐DOS. Lee un solo carácter directamente desde el teclado, sin mostrar tal carácter en pantalla. La función getch retorna el carácter leído desde el teclado. Ejemplo: #include <conio.h> int main() { cprintf( "Pulsa una tecla: " ); cprintf( "'%c'rn", getch() ); getch(); return 0; } Funciones importantes para la librería conio A continuación se resumen las funciones más relevantes de la librería conio. Puede encontrar una referencia completa en http://c.conclase.net/Borland. gotoxy (columna, fila) Sitúa el cursor en la columna y fila especificada. Por ejemplo, esta instrucción: gotoxy (5, 2);…sitúa el cursor en la fila 2, columna 5 de la pantalla. La siguiente instrucción de escritura en consola comenzará a escribir a partir de esas coordenadas. cprintf() y cscanf() Son las equivalentes a printf() y scanf(). Su sintaxis es la misma, y es recomendable usarlas en lugar de las funciones estándar para evitar funcionamientos extraños. textcolor(color) Cambia el color del texto. Los colores predefinidos son: BLACK, BLUE, RED, GREEN, CYAN, MAGENTA, BROWN, DARKGRAY. Además, existen las variedades “claras” de estos colores: LIGHTBLUE, LIGHTRED, LIGHTGREEN, etc. Así, si ejecutamos: textcolor (LIGHTRED);…el texto que se escriba a continuación aparecerá el color rojo intenso.
- 60. Algoritmo y Estructura de Datos I 59 CAPÍTULO IV Estructuras de Control Sentencias de Control del Programa 4.1 Tipos de Estructuras Básicas Las sentencias de control de los programas especifican el orden en que se han de realizar las operaciones. Existen tres formas básicas de flujo en los programas. • Estructuras secuenciales: se componen de una serie de sentencias que se ejecutan unas tras otras en el orden escrito en el programa. Para estas estructuras no se necesita ninguna sentencia de control del flujo del programa. • Estructuras condicionales: dentro del flujo del programa se toman decisiones para realizar unas acciones u otras dependiendo de que se cumplan una serie de condiciones. • Estructuras repetitivas: repetición de una serie de sentencias mientras no se cumpla una determinada condición. También denominadas bucles. - Asignación Secuenciales - Entrada - Salida - Simples Estructuras Condicionales Algoritmicas - Múltiples - Hacer para Cíclicas - Hacer mientras - Repetir hasta 4.2 Estructura Secuencial La estructura secuencial es aquella en la que una acción (instrucción) sigue a otra en secuencia. Las tareas se suceden de tal modo que la salida de una es la entrada de la siguiente y así sucesivamente hasta el fin del proceso. Una estructura secuencial se representa de la siguiente forma:
- 61. Algoritmo y Estructura de Datos I 60 Inicio Accion1 Accion2 . . AccionN Fin Asignación: La asignación consiste, en el paso de valores o resultados a una zona de la memoria. Dicha zona será reconocida con el nombre de la variable que recibe el valor. La asignación se puede clasificar de la siguiente forma: Simples: Consiste en pasar un valor constate a una variable (a=15) Contador: Consiste en usarla como un verificador del número de veces que se realiza un proceso (a=a+1) Acumulador: Consiste en usarla como un sumador en un proceso (a=a+b) De trabajo: Donde puede recibir el resultado de una operación matemática que involucre muchas variables (a=c+b*2/4). Lectura: La lectura consiste en recibir desde un dispositivo de entrada (p.ej. el teclado) un valor. Esta operación se representa en un pseudocodigo como sigue: Leer a, b Donde “a” y “b” son las variables que recibirán los valores Escritura: Consiste en mandar por un dispositivo de salida (p.ej. monitor o impresora) un resultado o mensaje. Este proceso se representa en un pseudocodigo como sigue: Escribe “El resultado es:”, R Donde “El resultado es:” es un mensaje que se desea aparezca y R es una variable que contiene un valor. 4.3 Problemas Secuenciales P1: Suponga que un individuo desea invertir su capital en un banco y desea saber cuánto dinero ganara después de un mes si el banco paga a razón de 2% mensual. Inicio Leer cap_inv gan = cap_inv * 0.02 Imprimir gan Fin
- 62. Algoritmo y Estructura de Datos I 61 P2: Un vendedor recibe un sueldo base más un 10% extra por comisión de sus ventas, el vendedor desea saber cuánto dinero obtendrá por concepto de comisiones por las tres ventas que realiza en el mes y el total que recibirá en el mes tomando en cuenta su sueldo base y comisiones. Inicio Leer sb, v1, v2, v3 tot_vta = v1 + v2 + v3 com = tot_vta * 0.10 tpag = sb + com Imprimir tpag, com Fin P3: Una tienda ofrece un descuento del 15% sobre el total de la compra y un cliente desea saber cuánto deberá pagar finalmente por su compra. Inicio Leer tc d = tc * 0.15 tp = tc ‐ d Imprimir tp Fin P4: Un alumno desea saber cuál será su calificación final en la materia de Algoritmos. Dicha calificación se compone de los siguientes porcentajes: 55% del promedio de sus tres calificaciones parciales. 30% de la calificación del examen final. 15% de la calificación de un trabajo final. Inicio Leer c1, c2, c3, ef, tf prom = (c1 + c2 + c3)/3 ppar = prom * 0.55 pef = ef * 0.30 ptf = tf * 0.15 cf = ppar + pef + ptf Imprimir cf Fin Figura 1. Lenguaje C
- 63. Algoritmo y Estructura de Datos I 62 P5: Un maestro desea saber qué porcentaje de hombres y que porcentaje de mujeres hay en un grupo de estudiantes. Inicio Leer nh, nm ta = nh + nm ph = nh * 100 / ta pm = nm * 100 / ta Imprimir ph, pm Fin P6: Realizar un algoritmo que calcule la edad de una persona. Inicio Leer fnac, fact edad = fact ‐ fnac Imprimir edad Fin. Problemas Propuestos Problema1: Dada un cantidad en soles, obtener la equivalencia en dólares, asumiendo que la unidad cambiaría es un dato desconocido. Problema2: Leer un numero y escribir el valor absoluto del mismo. Problema3: La presión, el volumen y la temperatura de una masa de aire se relacionan por la formula: masa = (presión * volumen)/(0.37 * (temperatura + 460)) Problema4: Calcular el número de pulsaciones que una persona debe tener por cada 10 segundos de ejercicio, si la formula es: num. pulsaciones = (220 ‐ edad)/10 Problema5: Calcular el nuevo salario de un obrero si obtuvo un incremento del 25% sobre su salario anterior. Figura 2. Conversion monedas
- 64. Algoritmo y Estructura de Datos I 63 Problema6: En un hospital existen tres áreas: Ginecología, Pediatría, Traumatología. El presupuesto anual del hospital se reparte conforme a la siguiente tabla: Área Porcentaje del presupuesto Ginecología 40% Traumatología 30% Pediatría 30% Obtener la cantidad de dinero que recibirá cada área, para cualquier monto presupuestal. Problema7: El dueño de una tienda compra un artículo a un precio determinado. Obtener el precio en que lo debe vender para obtener una ganancia del 30%. Problema8: Todos los lunes, miércoles y viernes, una persona corre la misma ruta y cronometra los tiempos obtenidos. Determinar el tiempo promedio que la persona tarda en recorrer la ruta en una semana cualquiera. Problema9: Tres personas deciden invertir su dinero para fundar una empresa. Cada una de ellas invierte una cantidad distinta. Obtener el porcentaje que cada quien invierte con respecto a la cantidad total invertida. Problema10: Un alumno desea saber cuál será su promedio general en las tres materias más difíciles que cursa y cuál será el promedio que obtendrá en cada una de ellas. Estas materias se evalúan como se muestra a continuación: La calificación de Matemáticas se obtiene de la siguiente manera: Examen 90% Promedio de tareas 10% En esta materia se pidió un total de tres tareas. La calificación de Física se obtiene de la siguiente manera: Examen 80% Promedio de tareas 20% En esta materia se pidió un total de dos tareas. Figura 3. Lenguaje C
- 65. Algoritmo y Estructura de Datos I 64 La calificación de Química se obtiene de la siguiente manera: Examen 85% Promedio de tareas 15% En esta materia se pidió un promedio de tres tareas. Estructuras Condicionales: Las estructuras condicionales comparan una variable contra otro(s) valor(es), para que en base al resultado de esta comparación, se siga un curso de acción dentro del programa. Cabe mencionar que la comparación se puede hacer contra otra variable o contra una constante, según se necesite. Existen dos tipos básicos, las simples y las múltiples. Simples: Las estructuras condicionales simples se les conocen como “Tomas de decisión”. Estas tomas de decisiones tienen la siguiente forma: Si <condición> entonces Acción(es) Fin‐si Dobles: Las estructuras condicionales dobles permiten elegir entre dos opciones o alternativas posibles en función del cumplimiento o no de una determinada condición. Se representa de la siguiente forma: Si <condición> entonces Acción(es) si no Acción(es) Fin‐si Sentencia if‐else. El formato es el siguiente: Formato 1: if (condición) { sentencias } Figura 4. Estructuras Condicionales
- 68. Algoritmo y Estructura de Datos I 67 Inicio Leer p_int, cap int = cap * p_int si int > 7000 entonces capf = cap + int fin‐si Imprimir capf fin Prob2: Determinar si un alumno aprueba a reprueba un curso, sabiendo que aprobara si su promedio de tres calificaciones es mayor o igual a 70; reprueba en caso contrario. Inicio Leer calif1, calif2, calif3 prom = (calif1 + calif2 + calif3)/3 Si prom >= 70 entonces Imprimir “alumno aprobado” si no Imprimir “alumno reprobado” Fin‐si Fin Prob3: En un almacén se hace un 20% de descuento a los clientes cuya compra supere los $1000 ¿Cuál será la cantidad que pagara una persona por su compra? Inicio Leer compra Si compra > 1000 entonces desc = compra * 0.20 si no desc = 0 fin‐si tot_pag = compra ‐ desc imprimir tot_pag fin. Figura 5. Ejercicios condicionales
- 69. Algoritmo y Estructura de Datos I 68 Problemas Selectivos Dobles Prob4: Un obrero necesita calcular su salario semanal, el cual se obtiene de la siguiente manera: Si trabaja 40 horas o menos se le paga $16 por hora Si trabaja más de 40 horas se le paga $16 por cada una de las primeras 40 horas y $20 por cada hora extra. Inicio Leer ht Si ht > 40 entonces he = ht ‐ 40 ss = he * 20 + 40 * 16 si no ss = ht * 16 Fin‐si Imprimir ss Fin Prob5: Un hombre desea saber cuánto dinero se genera por concepto de intereses sobre la cantidad que tiene en inversión en el banco. El decidirá reinvertir los intereses siempre y cuando estos excedan a $7000, y en ese caso desea saber cuánto dinero tendrá finalmente en su cuenta. Inicio Leer p_int, cap int = cap * p_int si int > 7000 entonces capf = cap + int fin‐si Imprimir capf fin Prob6: Que lea dos números y los imprima en forma ascendente Inicio Leer num1, num2 Si num1 < num2 entonces Imprimir num1, num2 si no Imprimir num2, num1 fin‐si fin
- 70. Algoritmo y Estructura de Datos I 69 Prob7: Una persona enferma, que pesa 70 kg, se encuentra en reposo y desea saber cuántas calorías consume su cuerpo durante todo el tiempo que realice una misma actividad. Las actividades que tiene permitido realizar son únicamente dormir o estar sentado en reposo. Los datos que tiene son que estando dormido consume 1.08 calorías por minuto y estando sentado en reposo consume 1.66 calorías por minuto. Inicio Leer act$, tiemp Si act$ = “dormido” entonces cg = 1.08 * tiemp si no cg = 1.66 * tiemp fin‐si Imprimir cg Fin Prob8: Hacer un algoritmo que imprima el nombre de un articulo, clave, precio original y su precio con descuento. El descuento lo hace en base a la clave, si la clave es 01 el descuento es del 10% y si la clave es 02 el descuento en del 20% (solo existen dos claves). Inicio Leer nomb, cve, prec_orig Si cve = 01 entonces prec_desc = prec_orig ‐ prec_orig * 0.10 si no prec_desc = prec_orig ‐ prec_orig * 0.20 fin‐si Imprimir nomb, cve, prec_orig, prec_desc fin Prob9: Hacer un algoritmo que calcule el total a pagar por la compra de camisas. Si se compran tres camisas o mas se aplica un descuento del 20% sobre el total de la compra y si son menos de tres camisas un descuento del 10% Figura 6. Condicionales dobles
- 71. Algoritmo y Estructura de Datos I 70 Inicio Leer num_camisas, prec tot_comp = num_camisas * prec Si num_camisas > = 3 entonces tot_pag = tot_comp ‐ tot_comp * 0.20 si no tot_pag = tot_comp ‐ tot_comp * 0.10 fin‐si Imprimir tot_pag fin Prob10: Una empresa quiere hacer una compra de varias piezas de la misma clase a una fábrica de refacciones. La empresa, dependiendo del monto total de la compra, decidirá qué hacer para pagar al fabricante. Si el monto total de la compra excede de $500 000 la empresa tendrá la capacidad de invertir de su propio dinero un 55% del monto de la compra, pedir prestado al banco un 30% y el resto lo pagara solicitando un crédito al fabricante. Si el monto total de la compra no excede de $500 000 la empresa tendrá capacidad de invertir de su propio dinero un 70% y el restante 30% lo pagara solicitando crédito al fabricante. El fabricante cobra por concepto de intereses un 20% sobre la cantidad que se le pague a crédito. Inicio Leer costopza, numpza totcomp = costopza * numpza Si totcomp > 500 000 entonces cantinv = totcomp * 0.55 préstamo = totcomp * 0.30 crédito = totcomp * 0.15 si no cantinv = totcomp * 0.70 crédito = totcomp * 0.30 préstamo = 0 fin‐si int = crédito * 0.20 Imprimir cantinv, préstamo, crédito, int Fin
- 72. Algoritmo y Estructura de Datos I 71 Problemas Propuestos 1. Calcular el total que una persona debe pagar en una llantera, si el precio de cada llanta es de $800 si se compran menos de 5 llantas y de $700 si se compran 5 o más. 2. En un supermercado se hace una promoción, mediante la cual el cliente obtiene un descuento dependiendo de un número que se escoge al azar. Si el numero escogido es menor que 74 el descuento es del 15% sobre el total de la compra, si es mayor o igual a 74 el descuento es del 20%. Obtener cuánto dinero se le descuenta. 3. Calcular el número de pulsaciones que debe tener una persona por cada 10 segundos de ejercicio aeróbico; la formula que se aplica cuando el sexo es femenino es: a. num. pulsaciones = (220 ‐ edad)/10 y si el sexo es masculino: b. num. pulsaciones = (210 ‐ edad)/10 4. Una compañía de seguros está abriendo un depto. de finanzas y estableció un programa para captar clientes, que consiste en lo siguiente: Si el monto por el que se efectúa la fianza es menor que $50 000 la cuota a pagar será por el 3% del monto, y si el monto es mayor que $50 000 la cuota a pagar será el 2% del monto. La afianzadora desea determinar cuál será la cuota que debe pagar un cliente. 5. En una escuela la colegiatura de los alumnos se determina según el número de materias que cursan. El costo de todas las materias es el mismo. Se ha establecido un programa para estimular a los alumnos, el cual consiste en lo siguiente: si el promedio obtenido por un alumno en el último periodo es mayor o igual que 18, se le hará un descuento del 30% sobre la colegiatura y no se le cobrara IGV; si el promedio obtenido es menor que 18 deberá pagar la colegiatura completa, la cual incluye el 18% de IGV. Obtener cuanto debe pagar un alumno. 6. Una empresa de bienes raíces ofrece casas de interés social, bajo las siguientes condiciones: Si los ingresos del comprador son menores de $8000 o más el enganche será del 15% del costo de la casa y el resto se distribuirá en pagos mensuales, a pagar en diez años. Si los ingresos del comprador son menos de $8000 o más el enganche será del 30% del costo de la casa y el resto se distribuirá en pagos mensuales a pagar en 7 años.
- 73. Algoritmo y Estructura de Datos I 72 La empresa quiere obtener cuanto debe pagar un comprador por concepto de enganche y cuanto por cada pago parcial. 7. El gobierno ha establecido el programa SAR (Sistema de Ahorro para el Retiro) que consiste en que los dueños de la empresa deben obligatoriamente depositar en una cuenta bancaria un porcentaje del salario de los trabajadores; adicionalmente los trabajadores pueden solicitar a la empresa que deposite directamente una cuota fija o un porcentaje de su salario en la cuenta del SAR, la cual le será descontada de su pago. Un trabajador que ha decidido aportar a su cuenta del SAR desea saber la cantidad total de dinero que estará depositado a esa cuenta cada mes, y el pago mensual que recibirá. 8. Una persona desea iniciar un negocio, para lo cual piensa verificar cuanto dinero le prestara el banco por hipotecar su casa. Tiene una cuenta bancaria, pero no quiere disponer de ella a menos que el monto por hipotecar su casa sea muy pequeño. Si el monto de la hipoteca es menor que $1 000 000 entonces invertirá el 50% de la inversión total y un socio invertirá el otro 50%. Si el monto de la hipoteca es de $ 1 000 000 o más, entonces invertirá el monto total de la hipoteca y el resto del dinero que se necesite para cubrir la inversión total se repartirá a partes iguales entre el socio y el. 9. El gobierno del Perú desea reforestar un bosque que mide determinado número de hectáreas. Si la superficie del terreno excede a 1 millón de metros cuadrados, entonces decidirá sembrar de la siguiente manera: Porcentaje de la superficie del bosque Tipo de árbol a. 70% pino b. 20% oyamel c. 10% cedro Si la superficie del terreno es menor o igual a un millón de metros cuadrados, entonces decidirá sembrar de la siguiente manera: Porcentaje de la superficie del bosque Tipo de árbol d. 50% pino e. 30% oyamel f. 20% cedro El gobierno desea saber el número de pinos, oyameles y cedros que tendrá que sembrar en el bosque, si se sabe que en 10 metros cuadrados caben 8 pinos, en 15
- 74. Algoritmo y Estructura de Datos I 73 metros cuadrados caben 15 oyameles y en 18 metros cuadrados caben 10 cedros. También se sabe que una hectárea equivale a 10 mil metros cuadrados. 10. Una fábrica ha sido sometida a un programa de control de contaminación para lo cual se efectúa una revisión de los puntos IMECA generados por la fábrica. El programa de control de contaminación consiste en medir los puntos IMECA que emite la fabrica en cinco días de una semana y si el promedio es superior a los 170 puntos entonces tendrá la sanción de parar su producción por una semana y una multa del 50% de las ganancias diarias cuando no se detiene la producción. Si el promedio obtenido de puntos IMECA es de 170 o menor entonces no tendrá ni sanción ni multa. El dueño de la fábrica desea saber cuánto dinero perderá después de ser sometido a la revisión. 11. Una persona se encuentra con un problema de comprar un automóvil o un terreno, los cuales cuestan exactamente lo mismo. Sabe que mientras el automóvil se devalúa, con el terreno sucede lo contrario. Esta persona comprara el automóvil si al cabo de tres años la devaluación de este no es mayor que la mitad del incremento del valor del terreno. Ayúdale a esta persona a determinar si debe o no comprar el automóvil. Problemas Selectivos Compuestos PP1: Leer 2 números; si son iguales que los multiplique, si el primero es mayor que el segundo que los reste y si no que los sume. Inicio Leer num1, num2 si num1 = num2 entonces resul = num1 * num2 si no si num1 > num2 entonces resul = num1 ‐ num2 si no resul = num1 + num2 fin‐si fin‐si fin
- 75. Algoritmo y Estructura de Datos I 74 PP2: Leer tres números diferentes e imprimir el número mayor de los tres. Inicio Leer num1, num2, num3 Si (num1 > num2) and (num1 > num3) entonces mayor = num1 si no Si (num2 > num1) and (num2 > num3) entonces mayor = num2 si no mayor = num3 fin‐si fin‐si Imprimir mayor fin PP3: Determinar la cantidad de dinero que recibirá un trabajador por concepto de las horas extras trabajadas en una empresa, sabiendo que cuando las horas de trabajo exceden de 40, el resto se consideran horas extras y que estas se pagan al doble de una hora normal cuando no exceden de 8; si las horas extras exceden de 8 se pagan las primeras 8 al doble de lo que se pagan las horas normales y el resto al triple. Inicio Leer ht, pph Si ht < = 40 entonces tp = ht * pph si no he = ht ‐ 40 Si he < = 8 entonces pe = he * pph * 2 si no pd = 8 * pph * 2 pt = (he ‐ 8) * pph * 3 pe = pd + pt fin‐si tp = 40 * pph + pe fin‐si Imprimir tp fin
- 76. Algoritmo y Estructura de Datos I 75 PP4: Calcular la utilidad que un trabajador recibe en el reparto anual de utilidades si este se le asigna como un porcentaje de su salario mensual que depende de su antigüedad en la empresa de acuerdo con la siguiente tabla: Tiempo Utilidad Menos de 1 año 5 % del salario 1 año o más y menos de 2 años 7% del salario 2 años o más y menos de 5 años 10% del salario 5 años o más y menos de 10 años 15% del salario 10 años o más 20% del salario Inicio Leer sm, antig Si antig < 1 entonces util = sm * 0.05 si no Si (antig > = 1) and (antig < 2) entonces util = sm * 0.07 si no Si (antig > = 2) and (antig < 5) entonces util = sm * 0.10 si no Si (antig > = 5) and (antig < 10) entonces util = sm * 0.15 si no util = sm * 0.20 fin‐si fin‐si fin‐si fin‐si Imprimir util fin PP5: En una tienda de descuento se efectúa una promoción en la cual se hace un descuento sobre el valor de la compra total según el color de la bolita que el cliente saque al pagar en caja. Si la bolita es de color blanco no se le hará descuento alguno, si es verde se le hará un 10% de descuento, si es amarilla un 25%, si es azul un 50% y si es roja un 100%. Determinar la cantidad final que el cliente deberá pagar por su compra. se sabe que solo hay bolitas de los colores mencionados.
- 77. Algoritmo y Estructura de Datos I 76 Inicio leer tc, b$ si b$ = ‘blanca’ entonces d=0 si no si b$ = ‘verde’ entonces d=tc*0.10 si no si b$ = ‘amarilla’ entonces d=tc*0.25 si no si b$ = ‘azul’ entonces d=tc*0.50 si no d=tc fin‐si fin‐si fin‐si fin‐si fin PP6: El IMSS requiere clasificar a las personas que se jubilaran en el año de 1997. Existen tres tipos de jubilaciones: por edad, por antigüedad joven y por antigüedad adulta. Las personas adscritas a la jubilación por edad deben tener 60 años o más y una antigüedad en su empleo de menos de 25 años. Las personas adscritas a la jubilación por antigüedad joven deben tener menos de 60 años y una antigüedad en su empleo de 25 años o más. Las personas adscritas a la jubilación por antigüedad adulta deben tener 60 años o más y una antigüedad en su empleo de 25 años o más. Determinar en qué tipo de jubilación, quedara adscrita una persona. Inicio leer edad,ant si edad >= 60 and ant < 25 entonces imprimir “la jubilación es por edad” si no si edad >= 60 and ant > 25 entonces imprimir “la jubilación es por edad adulta” si no si edad < 60 and ant > 25 entonces imprimir “la jubilación es por antigüedad joven”
- 78. Algoritmo y Estructura de Datos I 77 si no imprimir “no tiene por que jubilarse” fin‐si fin‐si fin‐si fin Problemas Propuestos Prob‐1: En una fábrica de computadoras se planea ofrecer a los clientes un descuento que dependerá del número de computadoras que compre. Si las computadoras son menos de cinco se les dará un 10% de descuento sobre el total de la compra; si el número de computadoras es mayor o igual a cinco pero menos de diez se le otorga un 20% de descuento; y si son 10 o más se les da un 40% de descuento. El precio de cada computadora es de $11,000 Prob‐2: En una llantera se ha establecido una promoción de las llantas marca “Ponchadas”, dicha promoción consiste en lo siguiente: Si se compran menos de cinco llantas el precio es de $300 cada una, de $250 si se compran de cinco a 10 y de $200 si se compran más de 10. Obtener la cantidad de dinero que una persona tiene que pagar por cada una de las llantas que compra y la que tiene que pagar por el total de la compra. Prob‐3: En un juego de preguntas a las que se responde “Si” o “No” gana quien responda correctamente las tres preguntas. Si se responde mal a cualquiera de ellas ya no se pregunta la siguiente y termina el juego. Las preguntas son: 1. Colon descubrió América? 2. La independencia de Perú fue en el año 1866? 3. The Doors fue un grupo de rock Americano? Prob‐4: Un proveedor de estéreos ofrece un descuento del 10% sobre el precio sin IGV, de algún aparato si este cuesta $2000 o más. Además, independientemente de esto, ofrece un 5% de descuento si la marca es “PONY”. Determinar cuánto pagara, con IGV incluido, un cliente cualquiera por la compra de su artefacto.
- 79. Algoritmo y Estructura de Datos I 78 Prob‐5: Una frutería ofrece las manzanas con descuento según la siguiente tabla: NUM. DE KILOS COMPRADOS % DESCUENTO 0 ‐ 2 0% 2.01 ‐ 5 10% 5.01 ‐ 10 15% 10.01 en adelante 20% Determinar cuánto pagara una persona que compre manzanas es esa frutería. Prob‐6: El dueño de una empresa desea planificar las decisiones financieras que tomara en el siguiente año. La manera de planificarlas depende de lo siguiente: Si actualmente su capital se encuentra con saldo negativo, pedirá un préstamo bancario para que su nuevo saldo sea de $10 000. Si su capital tiene actualmente un saldo positivo pedirá un préstamo bancario para tener un nuevo saldo de $20 000, pero si su capital tiene actualmente un saldo superior a los $20 000 no pedirá ningún préstamo. Posteriormente repartirá su presupuesto de la siguiente manera. $5 000 para equipo de computo $2 000 para mobiliario y el resto la mitad será para la compra de insumos y la otra para otorgar incentivos al personal. Desplegar que cantidades se destinaran para la compra de insumos e incentivos al personal y, en caso de que fuera necesario, a cuánto ascendería la cantidad que se pediría al banco. Prob‐7: Tomando como base los resultados obtenidos en un laboratorio de análisis clínicos, un medico determina si una persona tiene anemia o no, lo cual depende de su nivel de hemoglobina en la sangre, de su edad y de su sexo. Si el nivel de hemoglobina que tiene una persona es menor que el rango que le corresponde, se determina su resultado como positivo y en caso contrario como negativo. La tabla en la que el médico se basa para obtener el resultado es la siguiente: EDAD NIVEL HEMOGLOBINA 0 ‐ 1 mes 13 ‐ 26 g% > 1 y < = 6 meses 10 ‐ 18 g% > 6 y < = 12 meses 11 ‐ 15 g% > 1 y < = 5 años 11.5 ‐ 15 g%
- 80. Algoritmo y Estructura de Datos I 79 > 5 y < = 10 años 12.6 ‐ 15.5 g% > 10 y < = 15 años 13 ‐ 15.5 g% mujeres > 15 años 12 ‐ 16 g% hombres > 15 años 14 ‐ 18 g% Prob‐8: Una institución educativa estableció un programa para estimular a los alumnos con buen rendimiento académico y que consiste en lo siguiente: Si el promedio es de 19 o más y el alumno es de preparatoria, entonces este podrá cursar 55 unidades y se le hará un 25% de descuento. Si el promedio es mayor o igual a 18 pero menor que 19 y el alumno es de preparatoria, entonces este podrá cursar 50 unidades y se le hará un 10% de descuento. Si el promedio es mayor que 14 y menor que 18 y el alumno es de preparatoria, este podrá cursar 50 unidades y no tendrá ningún descuento. Si el promedio es de 14 o menor, el numero de materias reprobadas es de 0 a 3 y el alumno es de preparatoria, entonces podrá cursar 45 unidades y no tendrá descuento. Si el promedio es de 14 o menor, el numero de materias reprobadas es de 4 o más y el alumno es de preparatoria, entonces podrá cursar 40 unidades y no tendrá ningún descuento. Si el promedio es mayor o igual a 19 y el alumno es de profesional, entonces podrá cursar 55 unidades y se le hará un 20% de descuento. Si el promedio es menor de 19 y el alumno es de profesional, entonces podrá cursar 55 unidades y no tendrá descuento. Obtener el total que tendrá que pagar un alumno si la colegiatura para alumnos de profesional es de $300 por cada cinco unidades y para alumnos de preparatoria es de $180 por cada cinco unidades. Prob‐9: Que lea tres números diferentes y determine el número medio del conjunto de los tres números (el número medio es aquel número que no es ni mayor, ni menor). Estructuras Cíclicas Se llaman problemas repetitivos o cíclicos a aquellos en cuya solución es necesario utilizar un mismo conjunto de acciones que se puedan ejecutar una cantidad específica de veces. Esta cantidad puede ser fija (previamente determinada por el programador) o puede ser variable (estar en función de algún dato dentro del programa).Los ciclos se clasifican en:
- 82. Algoritmo y Estructura de Datos I 81 Problemas (Hacer para) Ejercicio 1: Calcular el promedio de un alumno que tiene 7 calificaciones en la materia de Diseño Estructurado de Algoritmos Inicio Sum=0 Leer Nom Hacer para c = 1 a 7 Leer calif Sum = sum + calif Fin‐para prom = sum /7 Imprimir prom Fin. Ejercicio 2: Leer 10 números y obtener su cubo y su cuarta. Inicio Hacer para n = 1 a 10 Leer num cubo = num * num * num cuarta = cubo * num Imprimir cubo, cuarta Fin‐para Fin. Ejercicio 3: Leer 10 números e imprimir solamente los números positivos Inicio Hacer para n = 1 a 10 Leer num Si num > 0 entonces Imprimir num fin‐si Fin‐para Fin.
- 83. Algoritmo y Estructura de Datos I 82 Ejercicio 4: Leer 20 números e imprimir cuantos son positivos, cuantos negativos y cuantos neutros. Inicio cn = 0 cp = 0 cneg = 0 Hacer para x = 1 a 20 Leer num Sin num = 0 entonces cn = cn + 1 si no Si num > 0 entonces cp = cp + 1 si no cneg = cneg + 1 Fin‐si Fin‐si Fin‐para Imprimir cn, cp, cneg Fin. Ejercicio 5: Leer 15 números negativos y convertirlos a positivos e imprimir dichos números. Inicio Hacer para x = 1 a 15 Leer num pos = num * ‐1 Imprimir num, pos Fin‐para Fin. Ejercicio 6: Suponga que se tiene un conjunto de calificaciones de un grupo de 40 alumnos. Realizar un algoritmo para calcular la calificación media y la calificación más baja de todo el grupo.
- 84. Algoritmo y Estructura de Datos I 83 Inicio sum = 0 baja = 9999 Hacer para a = 1 a 40 Leer calif sum = sum + calif Si calif < baja entonces baja = calif fin‐si Fin‐para media = sum / 2 Imprimir media, baja fin Ejercicio 7: Calcular e imprimir la tabla de multiplicar de un número cualquiera. Imprimir el multiplicando, el multiplicador y el producto. Inicio Leer num Hacer para X = 1 a 10 resul = num * x Imprimir num, “ * “, X, “ = “, resul Fin‐para fin. Ejercicio 8: Simular el comportamiento de un reloj digital, imprimiendo la hora, minutos y segundos de un día desde las 0:00:00 horas hasta las 23:59:59 horas Inicio Hacer para h = 1 a 23 Hacer para m = 1 a 59 Hacer para s = 1 a 59 Imprimir h, m, s Fin‐para Fin‐para Fin‐para fin.
- 85. Algoritmo y Estructura de Datos I 84 Problemas Propuestos Prop‐1: Una persona debe realizar un muestreo con 50 personas para determinar el promedio de peso de los niños, jóvenes, adultos y viejos que existen en su zona habitacional. Se determinan las categorías con base en la sig, tabla: CATEGORIA EDAD Niños 0 ‐ 12 Jóvenes 13 ‐ 29 Adultos 30 ‐ 59 Viejos 60 en adelante Prop‐2: Al cerrar un expendio de naranjas, 15 clientes que aun no han pagado recibirán un 15% de descuento si compran más de 10 kilos. Determinar cuánto pagara cada cliente y cuanto percibirá la tienda por esas compras. Prop‐3: En un centro de verificación de automóviles se desea saber el promedio de puntos contaminantes de los primeros 25 automóviles que lleguen. Asimismo se desea saber los puntos contaminantes del carro que menos contamino y del que más contamino. Prop‐4: Un entrenador le ha propuesto a un atleta recorrer una ruta de cinco kilómetros durante 10 días, para determinar si es apto para la prueba de 5 Kilómetros o debe buscar otra especialidad. Para considerarlo apto debe cumplir por lo menos una de las siguientes condiciones: Que en ninguna de las pruebas haga un tiempo mayor a 16 minutos. Que al menos en una de las pruebas realice un tiempo mayor a 16 minutos. Que su promedio de tiempos sea menor o igual a 15 minutos. Prop‐5: Un Zoólogo pretende determinar el porcentaje de animales que hay en las siguientes tres categorías de edades: de 0 a 1 año, de más de 1 año y menos de 3 y de 3 o más años. El zoológico todavía no está seguro del animal que va a estudiar. Si se decide por elefantes solo tomara una muestra de 20 de ellos; si se decide por las jirafas, tomara 15 muestras, y si son chimpancés tomara 40. Ciclos con un Número Indeterminado de Iteraciones (Hacer‐Mientras, Repetir‐Hasta) Son aquellos en que el número de iteraciones no se conoce con exactitud, ya que esta dado en función de un dato dentro del programa.
- 86. Algoritmo y Estructura de Datos I 85 Hacer‐Mientras: Esta es una estructura que repetirá un proceso durante “N” veces, donde “N” puede ser fijo o variable. Para esto, la instrucción se vale de una condición que es la que debe cumplirse para que se siga ejecutando. Cuando la condición ya no se cumple, entonces ya no se ejecuta el proceso. La forma de esta estructura es la siguiente: Figura 7. Hacer mientras Ejemplo: #include <stdio.h> int main (){ int i = 1; do{ printf("i = %in",i); i++; } while ( i <= 3 ); } Problemas (Hacer Mientras) Ejemplo 1: Una compañía de seguros tiene contratados a n vendedores. Cada uno hace tres ventas a la semana. Su política de pagos es que un vendedor recibe un sueldo base, y un 10% extra por comisiones de sus ventas. El gerente de su compañía desea saber cuánto dinero obtendrá en la semana cada vendedor por concepto de comisiones por las tres ventas realizadas, y cuanto tomando en cuenta su sueldo base y sus comisiones. Ejemplo 2: En una empresa se requiere calcular el salario semanal de cada uno de los “n” obreros que laboran en ella. El salario se obtiene de la siguiente forma:
- 87. Algoritmo y Estructura de Datos I 86 Si el obrero trabaja 40 horas o menos se le paga $20 por hora Si trabaja más de 40 horas se le paga $20 por cada una de las primeras 40 horas y $25 por cada hora extra. Ejemplo 3: Determinar cuántos hombres y cuantas mujeres se encuentran en un grupo de n personas, suponiendo que los datos son extraídos alumno por alumno. Ejemplo 4: El Depto. de Seguridad Publica y Transito del D.F. desea saber, de los n autos que entran a la ciudad de México, cuantos entran con calcomanía de cada color. Conociendo el último dígito de la placa de cada automóvil se puede determinar el color de la calcomanía utilizando la siguiente relación: DÍGITO COLOR 1 o 2 amarilla 3 o 4 rosa 5 o 6 roja 7 o 8 verde 9 o 0 azul Ejemplo 5: Obtener el promedio de calificaciones de un grupo de n alumnos. Ejemplo 6: Una persona desea invertir su dinero en un banco, el cual le otorga un 2% de interés. ¿Cuál será la cantidad de dinero que esta persona tendrá al cabo de un año si la ganancia de cada mes es reinvertida? Ejemplo 7: Calcular el promedio de edades de hombres, mujeres y de todo un grupo de alumnos. Ejemplo 8: Encontrar el menor valor de un conjunto de n números dados. Ejemplo 9: Encontrar el mayor valor de un conjunto de n números dados. Ejemplo 10: En un supermercado un cajero captura los precios de los artículos que los clientes compran e indica a cada cliente cual es el monto de lo que deben pagar. Al final
- 88. Algoritmo y Estructura de Datos I 87 del día le indica a su supervisor cuanto fue lo que cobro en total a todos los clientes que pasaron por su caja. Ejemplo 11: Cinco miembros de un club contra la obesidad desean saber cuánto han bajado o subido de peso desde la última vez que se reunieron. Para esto se debe realizar un ritual de pesaje en donde cada uno se pesa en diez básculas distintas para así tener el promedio más exacto de su peso. Si existe diferencia positiva entre este promedio de peso y el peso de la última vez que se reunieron, significa que subieron de peso. Pero si la diferencia es negativa, significa que bajaron. Lo que el problema requiere es que por cada persona se imprima un letrero que diga: “SUBIO” o “BAJO” y la cantidad de kilos que subió o bajo de peso. Ejemplo 12: Se desea obtener el promedio de “g” grupos que están en un mismo año escolar; siendo que cada grupo puede tener n alumnos que cada alumno puede llevar “m” materias y que en todas las materias se promedian tres calificaciones para obtener el promedio de la materia. Lo que se desea desplegar es el promedio de los grupos, el promedio de cada grupo y el promedio de cada alumno. Repetir‐Hasta Esta es una estructura similar en algunas características, a la anterior. Repite un proceso una cantidad de veces, pero a diferencia del Hacer‐ Mientras, el Repetir‐Hasta lo hace hasta que la condición se cumple y no mientras, como en el Hacer‐Mientras. Por otra parte, esta estructura permite realizar el proceso cuando menos una vez, ya que la condición se evalúa al final del proceso, mientras que en el Hacer‐Mientras puede ser que nunca llegue a entrar si la condición no se cumple desde un principio. La forma de esta estructura es la siguiente: Ejemplo1: En una tienda de descuento las personas que van a pagar el importe de su compra llegan a la caja y sacan una bolita de color, que les dirá que descuento tendrán sobre el total de su compra. Determinar la cantidad que pagara cada cliente desde que la tienda abre hasta que cierra. Se sabe que si el color de la bolita es roja el cliente obtendrá un 40% de descuento; si es amarilla un 25% y si es blanca no obtendrá descuento. Figura 8. Repetir hasta
- 89. Algoritmo y Estructura de Datos I 88 Ejemplo 2: En un supermercado una ama de casa pone en su carrito los artículos que va tomando de los estantes. La señora quiere asegurarse de que el cajero le cobre bien lo que ella ha comprado, por lo que cada vez que toma un articulo anota su precio junto con la cantidad de artículos iguales que ha tomado y determina cuánto dinero gastara en ese artículo; a esto le suma lo que ira gastando en los demás artículos, hasta que decide que ya tomo todo lo que necesitaba. Ayúdale a esta señora a obtener el total de sus compras. Ejemplo 3: Un teatro otorga descuentos según la edad del cliente. Determinar la cantidad de dinero que el teatro deja de percibir por cada una de las categorías. Tomar en cuenta que los niños menores de 5 años no pueden entrar al teatro y que existe un precio único en los asientos. Los descuentos se hacen tomando en cuenta el siguiente cuadro: Edad Descuento Categoría 1 5 ‐ 14 35 % Categoría 2 15 ‐ 19 25 % Categoría 3 20 ‐ 45 10 % Categoría 4 46 ‐ 65 25 % Categoría 5 66 en adelante 35 %
- 90. Algoritmo y Estructura de Datos I 89 CAPÍTULO V Programación Modular La modularización, es una técnica usada por los programadores para hacer sus códigos más cortos, ya que consiste en reducir un gran problema complejo, en pequeños problemitas más sencillos, concentrándose en la solución por separado, de cada uno de ellos. En C, se conocen como funciones aquellos trozos de códigos utilizados para dividir un programa con el objetivo que, cada bloque realice una tarea determinada. En las funciones juegan un papel muy importe las variables, ya que como se ha dicho estas pueden ser locales o globales. Una estrategia muy utilizada para la resolución de problemas complejos con la computadora, es como lo he venido comentando, la división del problema en otros problemas más pequeños o sub problemas. Estos sub problemas se implementan mediante módulos o subprogramas. Los subprogramas son una herramienta importante para el desarrollo de algoritmos y programas de modo que normalmente un proyecto de programación está compuesto generalmente de un programa principal y un conjunto de subprogramas con las llamadas a los mismos dentro del programa principal. Los subprogramas se clasifican en: procedimientos y funciones. 5.1 El Diseño Descendente: Subprogramas Uno de los métodos fundamentales para resolver un problema es dividirlo en problemas más pequeños, llamados sub problemas, en referencias sucesivas. Estos problemas a su vez pueden ser divididos repetidamente en problemas más pequeños hasta que los problemas más pequeños puedan ser solucionados. Esta técnica de dividir el problema principal en sub problemas se denomina frecuentemente divide y vencerás. El método de diseño se denomina diseño descendente, debido a que se comienza en la parte superior con un problema general y se diseñan soluciones específicas a sus sub problemas. El problema principal se resuelve con el programa principal (también llamado conductor del programa), y los sub problemas (módulos) mediante subprogramas: procedimientos y funciones.
- 91. Algoritmo y Estructura de Datos I 90 Un subprograma realiza una tarea concreta que se describe con una serie de instrucciones. Veamos un ejemplo: Leer el radio de un círculo y calcular e imprimir su superficie y longitud. • Análisis Especificaciones de Entrada Radio: Real Especificaciones de Salida Superficie: Real Longitud: Real • Algoritmo 1. Leer el valor del radio 2. Calcular la Superficie 3. Calcular la Longitud 4. Visualizar los valores de la superficie y la longitud • Refinamiento del Algoritmo 1. Leer el valor del radio 2. Calcular la superficie 1. pi <‐ 3.141592 (constante pi) 2. S <‐ pi * Radio * Radio 3. Calcular la longitud 1. pi <‐ 3.141592 2. L <‐ 2 * pi * Radio 4. Visualizar los valores de la superficie y la longitud 5.2 El Diseño Modular Los sub problemas o módulos se diseñan con subprogramas, que a su vez se clasifican en procedimientos y funciones. Los procedimientos y las funciones son unidades de programas diseñadas para ejecutar una tarea específica. Por ejemplo, los procedimientos predefinidos, printf() y scanf(), están diseñados para realizar operaciones de entrada y salida. El proceso de descomposición de un problema en módulos se conoce como modulación y a la programación relativa a ellos programación modular. Los procedimientos y funciones son similares, aunque presentan notables diferencias entre ellos: Las funciones normalmente, devuelven un solo valor a la unidad de programa (programa principal u otro subprograma) que la referencia o la llama.
- 92. Algoritmo y Estructura de Datos I 91 Los procedimientos pueden devolver cero, uno o varios valores. En el caso de no devolver ningún valor, realizan alguna tarea tal como alguna operación de entrada/salida. A un nombre de procedimiento no se puede asignar un valor, y por consiguiente ningún tipo está asociado con un nombre de procedimiento. Una función se referencia utilizando su nombre en una instrucción (de asignación o expresión matemática), mientras que un procedimiento se referencia por una llamada o invocación al mismo. Transferencia de Información a/desde Módulos Los Parámetros Los módulos o subprogramas sirven para ejecutar tareas concretas, pero no utilizan ningún tipo de dato del resto del programa. Sin embargo, una de las características importantes y diferenciadora de los subprogramas es la posibilidad de comunicación entre el programa principal y los subprogramas (o entre los subprogramas). Esta comunicación se realiza a través de una lista de parámetros Un parámetro es un método para pasar información (valores a variables) del programa principal a un módulo o viceversa. Así pues, los módulos se clasifican en: Módulos sin parámetros (no existe comunicación entre el programa principal y los módulos o entre módulos). Módulos con parámetros (existe comunicación entre el programa principal y los módulos, y entre ellos). Un parámetro es prácticamente, una variable cuyo valor debe ser o bien proporcionado por el programa principal al módulo o ser devuelto desde el módulo hasta el programa principal. Por consiguiente hay dos tipos de parámetros: entrada y salida. Los parámetros de entrada son aquellos cuyos valores deben ser proporcionados por el programa principal, y los de salida son aquellos cuyos valores se calcularán en el subprograma o módulo y se deben devolver al programa principal para su proceso posterior. Las sentencias llamadas a subprogramas constan de dos partes: un nombre de subprograma y una lista de parámetros llamados actuales.
- 93. Algoritmo y Estructura de Datos I 92 nombreSubprograma(pa1,pa2,...) En la declaración de un subprograma, cuando se incluyen parámetros, estos se denominan parámetros formales o ficticios. Ellos sirven para contener los valores de parámetros actuales cuando se llama al subprograma. Procedimiento o función nombresubprograma(pf1,pf2,...) Los parámetros actuales en la llamada al subprograma deben coincidir en número, orden y tipo con los parámetros ficticios de la declaración del subprograma. Es decir, debe existir una correspondencia entre parámetros actuales y ficticios. Parámetros Valor y Parámetros Variable Existen dos tipos de parámetros, como se indico anteriormente, que nos ayudan a transferir/recibir información de otros subprogramas, o del programa principal, a saber: parámetros de entrada (por valor) y parámetros de salida o de entrada/salida (variable). Parámetros Valor Son parámetros unidireccionales que se utilizan para proporcionar información a un subprograma, pero no pueden devolver valores, al programa llamador. Se les llama parámetros de entrada, ya que en la llamada al subprograma el valor del parámetro actual se pasa a la variable que representa a la variable actual. Este valor puede ser modificado dentro del subprograma pero el valor modificado no es devuelto al programa o subprograma llamador. Parámetros Variable Se utilizan tanto para recibir como para transmitir valores entre el subprograma y el programa llamador. Este puede actuar como parámetro de salida o de entrada/salida. Nota: En la notación de pseudocódigo representaré a estos parámetros anteponiendo la palabra var antes del identificador;). Este algoritmo ilustra la diferencia entre parámetros valor y parámetros variable, y la correspondencia entre ellos. Algoritmo Ejemplo_Parametros Variables A, B, C: enteros procedimiento imprimir (D,E,F: enteros) inicio escribir ("A =", D, "B =", E, "C =", F) fin_imprimir
- 94. Algoritmo y Estructura de Datos I 93 procedimiento pasar (D,E: entero; var F: entero) inicio escribir ("Entrada al procedimiento pasar:") imprimir (D,E,F) F <‐ D * F escribir ("Salida del procedimiento pasar:") imprimir (D,E,F) fin_pasar inicio A <‐ 2 B <‐ 3 C <‐ 4 escribir ("Antes de llamar al procedimiento pasar") imprimir (A,B,C) pasar (A,B,C) escribir ("Despues del retorno del procedimiento pasar") imprimir (A,B,C) fin La salida del programa en pantalla sería la siguiente: Antes de llamar al procedimiento pasar A = 2, B = 3, C = 4 Entrada al procedimiento pasar A = 2, B = 3, C = 4 Salida del procedimiento pasar A = 2, B = 3, C = 6 Despues del retorno del procedimiento pasar A = 2, B = 3, C = 6 Variables Locales y Variables Globales Las variables utilizadas en un programa con subprogramas pueden ser de dos tipos: locales y globales. Variables Locales Una variable local es una variable que está declarada dentro de un subprograma y se dice que es local al subprograma. Una variable local solo está disponible durante el funcionamiento del subprograma, al terminar su función el subprograma y regresar al programa llamador, se pierde el valor que se encontraba guardado en la variable local.
- 95. Algoritmo y Estructura de Datos I 94 Variables Globales Las variables declaradas en el programa principal se denominan variables globales. Al contrario que las variables locales cuyos valores se pueden utilizar solo dentro del subprograma en que fueron declaradas, las variables globales se pueden utilizar en todo el programa principal y en todos los subprogramas, donde se haga referencia al identificador de esta variable. Ámbito de un Identificador La mayoría de los programas tienen una estructura tipo árbol, el programa principal es la raíz y de este penden muchas ramas (procedimientos y funciones). Los subprogramas en los que un identificador puede ser utilizado se conocen como ámbito o alcance del identificador, dicho de otro modo, es en esta sección donde el identificador es válido. Reglas de Ámbito a. El ámbito de un identificador es el dominio en que está declarado. Por consiguiente un identificador declarado en un bloque P puede ser usado en el subprograma P y en todos los subprogramas llamados en el subprograma P. b. Si un identificador j declarado en el procedimiento P se redeclara en algún subprograma interno Q invocado en P, entonces el subprograma Q y todas sus invocaciones a otros subprogramas se excluyen del ámbito de j declarado en P. Procedimientos y Funciones Los procedimientos y funciones son la base principal en la programación modular, estudiaremos aquí su funcionamiento y su sintaxis. Procedimientos Un procedimiento es un subprograma que realiza una tarea específica. Puede recibir cero o más valores del programa que llama y devolver cero o más valores a dicho programa. Un procedimiento está compuesto de un grupo de sentencias a las que se asigna un nombre (identificador) y constituye una unidad de programa. La tarea determinada al procedimiento se ejecuta siempre que se encuentra el nombre del procedimiento. La declaración indica las instrucciones a ejecutar. Su sintaxis es: procedimiento nombreproc (lista de par) declaraciones locales inicio cuerpo del procedimiento (instrucciones) fin.
- 96. Algoritmo y Estructura de Datos I 95 Un procedimiento es llamado en un programa o dentro de otro procedimiento directamente por su nombre en cualquiera de las dos formas: nombreproc nombreproc (lista par. actuales) Funciones Una función es un subprograma que recibe como argumentos o parámetros, datos de tipos numérico o no numérico, y devuelve un único resultado. Esta característica le diferencia esencialmente de un procedimiento. Su formato es el siguiente: funcion nombrefuncion (p1,p2,...) : tipo a devolver declaraciones locales inicio cuerpo de la función nombrefuncion <‐ valor a devolver fin Una función es llamada por medio de su nombre, en una sentencia de asignación o en una sentencia de salida. Se puede llamar a una función en cualquiera de las siguientes formas: nombrefuncion o nombrefuncion(par) idVar <‐ nombrefuncion. Un problema complejo se puede dividir en pequeños subproblemas más sencillos. Estos subproblemas se conocen como “Módulos” y su complementación en un lenguaje se llama subprograma (procedimientos y funciones). Un subprograma realiza las mismas acciones que un programa, sin embargo, un subprograma lo utiliza solamente un programa para un propósito especifico. Un subprograma recibe datos de un programa y le devuelve resultados (el programa “llama” o “invoca” al subprograma, este ejecuta una tarea específica y devuelve el “control” al programa que lo llamo).
- 97. Algoritmo y Estructura de Datos I 96 Funciones Tipos de Módulos Procedimientos Función: Una función en matemáticas, es una operación que toma un o mas valores (argumentos) y devuelve un resultado (valor de la función para los argumentos dados). Por ejemplo: F(X) = X / (1+X2) Donde: F ………….. Nombre de la función X …………. Es el argumento (también conocido como parámetro formal) Definición de funciones: Una definición de función se presenta de la siguiente manera: Función nombre_funcion (p1, p2, …, pn) Inicio Bloque de instrucciones Fin Donde: Función …………… Es la palabra clave que nos indica una definición de función. Nombre_funcion …. Es el identificador con el cual se reconoce a la función en el cuerpo del algoritmo principal. P1,p2,…,pn ……... Es el grupo de parámetros que define a la función. Llamado a una función Cuando definimos una función solo le indicamos al algoritmo que esta función existe, pero una definición de función no implica la realización de las instrucciones que la constituyen. Para hacer uso de una función, el algoritmo principal la debe llamar. Por ejemplo: Función F(X) Inicio F = X /(1 + X^2) Fin Inicio Imprimir “Este es el algoritmo principal” Leer N
- 98. Algoritmo y Estructura de Datos I 97 R = F(N) llamado de la función Imprimir “El resultado de la función es:”,R Fin Podemos definir una función cualquiera de la misma manera en que definimos la función main(). Basta con poner su tipo, su nombre, sus argumentos entre paréntesis y luego, entre llaves, su código: /* Inclusión de archivos */ #include <stdio.h> void holamundo(void) /*Función donde se ejecuta la lógica del programa*/ { printf("Hola Mundon"); /*imprime la cadena*/ return; /*sale de la función*/ } int main(void) /*Función principal del programa*/ { holamundo(); /*llamada a la función que lleva el peso*/ return 0; /*sale del programa: correcto*/ } Este código es en todo equivalente al "Hola Mundo" original, sólo que nos muestra cómo escribir y cómo utilizar una función. Y además nos muestra un principio de buena programación: meter las sentencias que "hacen el trabajo" en otras funciones específicas para sacarlas de main(), dejando en ésta tan sólo un guión general de lo que hace el programa, no las órdenes específicas. De esta manera se facilita la comprensión del programa, y por tanto el futuro trabajo de modificarlo. De la misma manera que tenemos que declarar una variable antes de utilizarla, no es indiferente el orden en que se sitúen las diferentes funciones en el fichero: las funciones deben declararse antes de ser llamadas. Igualmente vemos que, para una función void, la sentencia de control return no puede llamarse como pseudofunción, porque en dicho caso la función void (en nuestro caso holamundo()) devolvería un valor, cosa que su definición no permite. Las funciones también permiten recibir tipos de datos, así pues las funciones nos sirven para hacer de un gran problema pequeñas partes de un problema o sea dividir un gran problema en diferentes problemas más pequeños. Así que las funciones también pueden retornar un tipo de dato que hemos definido dentro de la misma.
- 99. Algoritmo y Estructura de Datos I 98 Así que si definimos una función para sumar dos números seria de la siguiente manera: /* * suma.c * * Julio Calderon Bramo <bramo@gmail.com> 2009 * * para el libro "Programación en C" * adaptado del Dominio Público */ #include <stdio.h> int sumar(int numero1, int numero2); /* prototipo de la función */ int main(void) { int suma; /* definimos una variable*/ suma = sumar(5, 3); /* la variable obtiene el valor retornado de sumar * puede verse que entre los paréntesis se mandan los valores * de los números que se desean sumar en este caso 5 y 3 * pueden haberse declarados estos dos números en otras variables * int dato = 4, valor = 3; * suma = sumar(dato, valor); */ /* imprimimos la suma de los dos números */ printf("La suma es: %d ", suma); return 0; } int sumar(int numero1, int numero2) { int retsuma; /* creamos la variable a retornar*/ retsuma = numero1 + numero2; /* asignamos esa varia la suma de número 1 y 2*/ return retsuma; /* retornamos la suma de los números */ }
- 100. Algoritmo y Estructura de Datos I 99 CAPÍTULO VI Recursividad 6.1 Recursividad: La recursividad es una técnica de programación importante. Se utiliza para realizar una llamada a una función desde la misma función. Como ejemplo útil se puede presentar el cálculo de números factoriales. Él factorial de 0 es, por definición, 1. Los factoriales de números mayores se calculan mediante la multiplicación de 1 * 2 * ..., incrementando el número de 1 en 1 hasta llegar al número para el que se está calculando el factorial. El siguiente párrafo muestra una función, expresada con palabras, que calcula un factorial. "Si el número es menor que cero, se rechaza. Si no es un entero, se redondea al siguiente entero. Si el número es cero, su factorial es uno. Si el número es mayor que cero, se multiplica por él factorial del número menor inmediato." Para calcular el factorial de cualquier número mayor que cero hay que calcular como mínimo el factorial de otro número. La función que se utiliza es la función en la que se encuentra en estos momentos, esta función debe llamarse a sí misma para el número menor inmediato, para poder ejecutarse en el número actual. Esto es un ejemplo de recursividad. La recursividad y la iteración (ejecución en bucle) están muy relacionadas, cualquier acción que pueda realizarse con la recursividad puede realizarse con iteración y viceversa. Normalmente, un cálculo determinado se prestará a una técnica u otra, sólo necesita elegir el enfoque más natural o con el que se sienta más cómodo. Claramente, esta técnica puede constituir un modo de meterse en problemas. Es fácil crear una función recursiva que no llegue a devolver nunca un resultado definitivo y no pueda llegar a un punto de finalización. Este tipo de recursividad hace que el sistema ejecute lo que se conoce como bucle "infinito". Para entender mejor lo que en realidad es el concepto de recursión veamos un poco lo referente a la secuencia de Fibonacci. Principalmente habría que aclarar que es un ejemplo menos familiar que el del factorial, que consiste en la secuencia de enteros. 0,1,1,2,3,5,8,13,21,34,...,
- 101. Algoritmo y Estructura de Datos I 100 Cada elemento en esta secuencia es la suma de los precedentes (por ejemplo 0 + 1 = 0, 1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, ...) sean fib(0) = 0, fib (1) = 1 y así sucesivamente, entonces puede definirse la secuencia de Fibonacci mediante la definición recursiva (define un objeto en términos de un caso más simple de sí mismo): fib (n) = n if n = = 0 or n = = 1 fib (n) = fib (n ‐ 2) + fib (n ‐ 1) if n >= 2 Por ejemplo, para calcular fib (6), puede aplicarse la definición de manera recursiva para obtener: Fib (6) = fib (4) + fib (5) = fib (2) + fib (3) + fib (5) = fib (0) + fib (1) + fib (3) + fib (5) = 0 + 1 fib (3) + fib (5) 1.+ fib (1) + fib (2) + fib(5) = 1.+ 1 + fib(0) + fib (1) + fib (5) = 2.+ 0 + 1 + fib(5) = 3 + fib (3) + fib (4) = 3.+ fib (1) + fib (2) + fib (4) = 3 + 1 + fib (0) + fib (1) + fib (4) = 4.+ 0 + 1 + fib (2) + fib (3) = 5 + fib (0) + fib (1) + fib (3) = 5.+ 0 + 1 + fib (1) + fib (2) = 6 + 1 + fib (0) + fib (1) = 6.+ 0 + 1 = 8 Obsérvese que la definición recursiva de los números de Fibonacci difiere de las definiciones recursivas de la función factorial y de la multiplicación. La definición recursiva de fib se refiere dos veces a sí misma. Por ejemplo, fib (6) = fib (4) + fib (5), de tal manera que al calcular fib (6), fib tiene que aplicarse de manera recursiva dos veces. Sin embargo calcular fib (5) también implica calcular fib (4), así que al aplicar la definición hay mucha
- 102. Algoritmo y Estructura de Datos I 101 redundancia de cálculo. En ejemplo anterior, fib(3) se calcula tres veces por separado. Sería mucho más eficiente "recordar" el valor de fib(3) la primera vez que se calcula y volver a usarlo cada vez que se necesite. Es mucho más eficiente un método iterativo como el que sigue parar calcular fib (n). If (n < = 1) return (n); lofib = 0 ; hifib = 1 ; for (i = 2; i < = n; i ++) { x = lofib ; lofib = hifib ; hifib = x + lofib ; } /* fin del for*/ return (hifib) ; Hasta el momento, las únicas funciones que hemos estudiado han sido llamadas desde otra función; pero es posible crear funciones que puedan llamarse a sí mismas, estas son llamadas: funciones recursivas. Una función puede ser recursiva tanto de forma directa (si es llamada a sí misma) o de forma indirecta (si llama a una función que luego la llama). Existen algunos problemas que pueden ser resueltos de forma más eficiente (o su resolución puede ser más naturalmente pensada) utilizando funciones recursivas. Una función recursiva puede dar origen a un típico problema en programación, la recursión infinita, que es cuando una función se llama a sí misma infinitas veces. Esto detiene el normal funcionamiento de un programa.
- 103. Algoritmo y Estructura de Datos I 102 Para que esto no suceda una función recursiva debe ser muy bien pensada. Principalmente una función recursiva debe saber resolver el caso más simple, llamado caso base. Si la función es llamada con el caso base, inmediatamente retorna el resultado (no necesita volver a llamarse a sí misma para poder resolverlo). Compárese el numero de adiciones (sin incluir los incrementos de la variable índice, i) que se ejecutan para calcular fib (6) mediante este algoritmo al usar la definición recursiva. En el caso de la función factorial, tienen que ejecutarse el mismo número de multiplicaciones para calcular n! Mediante ambos métodos: recursivo e iterativo. Lo mismo ocurre con el número de sumas en los dos métodos al calcular la multiplicación. Sin embargo, en el caso de los números de Fibonacci, el método recursivo es mucho más costoso que el iterativo. Para definir una función en forma recursiva es necesario especificar: Caso(s) base: Donde la recursividad se detiene Paso de recursión: Como se define un elemento distinto de la base, en términos de elementos anteriores. Usualmente los lenguajes de programación permiten definir funciones de manera recursiva. El lenguaje C es uno de ellos. La definición recursiva para el factorial sería: int factorial(int n) { if ((n == 0) || (n == 1)) return(1); else return(n*factorial(n‐1)); } Normalmente las definiciones recursivas pueden expresarse en forma no recursiva. Sin embargo, dependiendo del caso, el resultado puede ser más confuso. Por ejemplo, una función en C que calcula el factorial en forma iterativa sería: int factorial(int n) { int i, fact = 1; for (i=2; i<=n; i++) fact = fact * i; return(fact); } Sin embargo, los algoritmos iterativos tienen una ventaja en cuanto al uso de memoria, si se comparan con los iterativos. La recursividad requiere que se guarde el estado de la ejecución antes de cada llamado recursivo, implicando un gasto considerable de memoria.
- 104. Algoritmo y Estructura de Datos I 103 Es probable que, por esta razón, las versiones recursivas tengan mayores limitaciones al ejecutarse en un computador. La aplicación de las definiciones recursivas puede ampliarse a una amplia gama de problemas, en los que la solución más natural puede ser la que se expresa de esta forma. Ejemplo: /************************************************************************* ** * Ejemplo: Obtención del máximo en un vector de números (recursivamente). ************************************************************************** */ /* Definición del tamaño máximo del vector */ #define TAMANO_VECTOR 100 /************************************************************************* ** * Función recursiva que obtiene el máximo en un vector de números enteros. * Recibe como argumento el vector que contiene los números y el número * de posiciones del vector que están siendo utilizadas. La función * retorna el valor del máximo elemento dentro del vector. ************************************************************************** */ int Maximo(int vector[], int n) { int max, maxResto; if (n == 1) /* Caso base */ max = vector[0]; else { maxResto = Maximo(vector+1, n‐1); /* Maximo del resto del vector */ if (vector[0] > maxResto) max = vector[0]; else max = maxResto; } return(max); }
- 108. Algoritmo y Estructura de Datos I 107 int i; int n=0; int vec[TAMANO_VECTOR]; /* Garantiza que el usuario ingresa un numero de elementos > 0 */ while (n < 1) { printf("Ingrese el numero de elementos: "); scanf("%d", &n); } /* Lee los elementos del vector */ for (i=0; i<n; i++) { printf("tElemento[%d]: ", i); scanf("%d", &vec[i]); } /* Calcula el maximo a la vez que despliega el resultado */ printf("nMaximo: %dn", Maximo(vec, n)); } 6.2 Prototipos de funciones Antes de usar una función C debe tener conocimiento acerca del tipo de dato que regresará y el tipo de los parámetros que la función espera. El estándar ANSI de C introdujo una nueva (mejor) forma de hacer lo anterior respecto a las versiones previas de C. La importancia de usar prototipos de funciones es la siguiente: Se hace el código más estructurado y por lo tanto, más fácil de leer. Se permite al compilador de C revisar la sintaxis de las funciones llamadas. Lo anterior es hecho, dependiendo del alcance de la función. Básicamente si una función ha sido definida antes de que sea usada (o llamada), entonces se puede usar la función sin problemas. Si no es así, entonces la función se debe declarar. La declaración simplemente maneja el tipo de dato que la función regresa y el tipo de parámetros usados por la función. Es una práctica usual y conveniente escribir el prototipo de todas las funciones al principio del programa, sin embargo esto no es estrictamente necesario.
- 109. Algoritmo y Estructura de Datos I 108 Para declarar un prototipo de una función se indicará el tipo de dato que regresará la función, el nombre de la función y entre paréntesis la lista del tipo de los parámetros de acuerdo al orden que aparecen en la definición de la función. Por ejemplo: int longcad(char []); Lo anterior declara una función llamada longcad que regresa un valor entero y acepta una cadena como parámetro. Ejercicios Escribir una función ``reemplaza'', la cual toma una cadena como parámetro, le reemplaza todos los espacios de la cadena por un guión bajo, y devuelve el número de espacios reemplazados. Por ejemplo: char cadena[] = "El gato negro"; n = reemplaza( cadena ); deberá devolver: cadena convertida "El_gato_negro" n = 2 Escribir un programa que lea una línea de texto en un buffer (una cadena de caracteres) usando la función gets y calcule la longitud de la línea (NO usar la función strlen). Modificar el programa anterior para que lea un archivo de texto. El archivo deberá redireccionarse al programa, debiendo mostrar el contenido del mismo. En caso de que se lea una línea con longitud 0 deberá terminar el programa. 6.3 Arreglos unidimensionales y multidimensionales Los arreglos son una colección de variables del mismo tipo que se referencian utilizando un nombre común. Un arreglo consta de posiciones de memoria contigua. La dirección más baja corresponde al primer elemento y la más alta al último. Un arreglo puede tener una o varias dimensiones. Para acceder a un elemento en particular de un arreglo se usa un índice. El formato para declarar un arreglo unidimensional es: tipo nombre_arr [ tamaño ] Por ejemplo, para declarar un arreglo de enteros llamado listanum con diez elementos se hace de la siguiente forma:
- 110. Algoritmo y Estructura de Datos I 109 int listanum[10]; En C, todos los arreglos usan cero como índice para el primer elemento. Por tanto, el ejemplo anterior declara un arreglo de enteros con diez elementos desde listanum[0] hasta listanum[9]. La forma como pueden ser accesados los elementos de un arreglo, es de la siguiente forma: listanum[2] = 15; /* Asigna 15 al 3er elemento del arreglo listanum*/ num = listanum[2]; /* Asigna el contenido del 3er elemento a la variable num */ El lenguaje C no realiza comprobación de contornos en los arreglos. En el caso de que sobrepase el final durante una operación de asignación, entonces se asignarán valores a otra variable o a un trozo del código, esto es, si se dimensiona un arreglo de tamaño N, se puede referenciar el arreglo por encima de N sin provocar ningún mensaje de error en tiempo de compilación o ejecución, incluso aunque probablemente se provoque el fallo del programa. Como programador se es responsable de asegurar que todos los arreglos sean lo suficientemente grandes para guardar lo que pondrá en ellos el programa. C permite arreglos con más de una dimensión, el formato general es: tipo nombre_arr [ tam1 ][ tam2 ] ... [ tamN]; Por ejemplo un arreglo de enteros bidimensionales se escribirá como: int tabladenums[50][50]; Observar que para declarar cada dimensión lleva sus propios paréntesis cuadrados. Para acceder los elementos se procede de forma similar al ejemplo del arreglo unidimensional, esto es, tabladenums[2][3] = 15; /* Asigna 15 al elemento de la 3ª fila y la 4ª columna*/ num = tabladenums[25][16]; A continuación se muestra un ejemplo que asigna al primer elemento de un arreglo bidimensional cero, al siguiente 1, y así sucesivamente. main() { int t,i,num[3][4];
- 111. Algoritmo y Estructura de Datos I 110 for(t=0; t<3; ++t) for(i=0; i<4; ++i) num[t][i]=(t*4)+i*1; for(t=0; t<3; ++t) { for(i=0; i<4; ++i) printf("num[%d][%d]=%d ", t,i,num[t][i]); printf("n"); } } En C se permite la inicialización de arreglos, debiendo seguir el siguiente formato: tipo nombre_arr[ tam1 ][ tam2 ] ... [ tamN] = {lista‐valores}; Por ejemplo: int i[10] = {1,2,3,4,5,6,7,8,9,10}; int num[3][4]={0,1,2,3,4,5,6,7,8,9,10,11}; Un arreglo es un conjunto de variables del mismo tipo que pueden ser referenciadas a través de un mismo nombre. La forma de identificar a un elemento determinado es a través de un índice. La declaración int Array[10]; instruye al compilador a que reserve una cantidad de memoria suficiente para almacenar 10 entidades enteras y referirse a esa memoria a traves del identificador Array. Dado que el número de elementos en un arreglo suele ser utilizado en distintos lugares de un programa, es buen estilo de programación el referenciarlo a través de una constante simbólica: #define N 10 int Array[N]; Los elementos individuales del arreglo se comienza a numerar a partir del elemento 0, asi, Array[0] individualiza al primer elemento y Array[9] al último. Los arreglos pueden ser multidimensionales, asi por ejemplo
- 112. Algoritmo y Estructura de Datos I 111 double Matriz[10][20]; Define una región de memoria como para almacenar 200 reales en doble precisión. La forma en que se organizan en la memoria estos 200 elementos es la siguiente: Matriz[0][0], Matriz[0][1], Matriz[0][2], ..., Matriz[1][0], Matriz[1][1],...,...,Matriz[9][19] La inicialización de un arreglo puede realizarse a través de una lista, si la lista es más corta que el número de elementos en el arreglo, el resto de los elementos se inicializan a 0. Se puede obviar el tamaño de un arreglo al inicializarlo con una lista, el tamaño será el mismo que el de la lista en este caso. Ej: float a[5] = {0.1, 1.2, 2.3, 3.4, 4.5}; double b[100] = {1.0}; /* los 99 restantes serán 0.0 */ int a[] = {2, 3, ‐5, 7}; /* equivale a a[4]={2,3,‐5,7} */ Ejemplo: /* Utilización de arreglos. Programa que cuenta cuántas veces se repite cada dígito, cada carácter separador, y otros carácteres. */ #include <stdio.h> #define ND 10 int main() { int c, i, nWhite = 0, nOther = 0, nDigit[ND]; for(i = 0; i < ND; i++) nDigit[i] = 0; while((c = getchar()) != EOF) if(c >= '0' && c <= '9') nDigit[c ‐ '0']++; else if(c == ' ' || c == 'n' || c == 't') nWhite++; else nOther++; for(i = 0; i < ND; i++) printf("Dígito %d: %dn",i,nDigit[i]); printf("Caracteres separadores: %dn",nWhite);
- 113. Algoritmo y Estructura de Datos I 112 printf("Otros caracteres: %dn",nOther); return 0; } Compile y corra el siguiente programa y explique lo que ocurre: #include <stdio.h> int main(){ int a[4] = {0, 1, 2, 3}; int b[4] = {4, 5, 6, 7}; int i; for (i=0; i<8; i++) printf ("a[%d] = %dn",i,a[i]); return 0; } Cadenas A diferencia de otros lenguajes de programación que emplean un tipo denominado cadena string para manipular un conjunto de simbolos, en C, se debe simular mediante un arreglo de caracteres, en donde la terminación de la cadena se debe indicar con nulo. Un nulo se especifica como '0'. Por lo anterior, cuando se declare un arreglo de caracteres se debe considerar un carácter adicional a la cadena más larga que se vaya a guardar. Por ejemplo, si se quiere declarar un arreglo cadena que guarde una cadena de diez caracteres, se hará como: char cadena[11]; Se pueden hacer también inicializaciones de arreglos de caracteres en donde automáticamente C asigna el caracter nulo al final de la cadena, de la siguiente forma: char nombre_arr[ tam ]="cadena"; Por ejemplo, el siguiente fragmento inicializa cadena con ``hola'': char cadena[5]="hola"; El código anterior es equivalente a: char cadena[5]={'h','o','l','a','0'};
- 114. Algoritmo y Estructura de Datos I 113 Para asignar la entrada estándar a una cadena se puede usar la función scanf con la opción %s (observar que no se requiere usar el operador &), de igual forma para mostrarlo en la salida estándar. Por ejemplo: main() { char nombre[15], apellidos[30]; printf("Introduce tu nombre: "); scanf("%s",nombre); printf("Introduce tus apellidos: "); scanf("%s",apellidos); printf("Usted es %s %sn",nombre,apellidos); } El lenguaje C no maneja cadenas de caracteres, como se hace con enteros o flotantes, por lo que lo siguiente no es válido: main() { char nombre[40], apellidos[40], completo[80]; nombre="José María"; /* Ilegal */ apellidos="Morelos y Pavón"; /* Ilegal */ completo="Gral."+nombre+appellidos; /* Ilegal */ }
- 120. Algoritmo y Estructura de Datos I 119 Ejercicio 8: /* Ejemplo 8.c Programa para obtener el promedio de calificaciones de una clase mediante una repetición controlada por contador */ #include <stdio.h> /* la función main inicia la ejecución del programa */ int main() { int contador; /* número de la calificación siguiente */ int calificación; /* valor de la calificación */ int total; /* suma de las calificaciones introducidas por el usuario */ int promedio; /* promedio de las calificaciones */ /* fase de inicialización */ total = 0; /* inicializa total */ contador = 1; /* inicializa el contador del ciclo */ /* fase de proceso */ while ( contador <= 10 ) { /* repite 10 veces el ciclo */ printf( "Introduzca la calificación: " ); /* indicador para la entrada */ scanf( "%d", &calificación ); /* lee la calificación del usuario */ total = total + calificación; /* suma la calificación al total */ contador = contador + 1; /* incrementa el contador */ } /* fin de while */ /* fase de terminación */ promedio = total / 10; /* división entera */ printf( "El promedio de la clase es %dn", promedio ); /* despliega el resultado */ return 0; /* indica que el programa terminó con exito */ } /* fin de la función main */
- 121. Algoritmo y Estructura de Datos I 120 Ejercicio 9: main() { float cm, pul, valor; char unidad; printf(“Introduce número y unidad (p=pulg. o c=cm: “); scanf(“%f %c”,&valor, &unidad); if (unidad==’p’) { cm=valor*2.54; printf(“Las %f pulgadas son %f centímetrosn”,valor,cm); } if (unidad==’c’) { pul=valor/2.54; printf(“Los %f centímetros son %f pulgadasn”,valor,pul); } if (unidad!=’p’ && unidad!=’c’) printf(“No está puesta correctamente la unidadn”); } Ejercicio 10: /* Ejemplo 10.c Programa para obtener el promedio de calificaciones de una clase mediante una repetición controlada por centinela */ #include <stdio.h> /* la función main inicia la ejecución del programa */ int main() { int contador; /* número de calificaciones introducidas */ int calificación; /* valor de la calificación */ int total; /* suma de las calificaciones */ float promedio; /* número con punto decimal para el promedio */ /* fase de inicialización */ total = 0; /* inicializa el total */ contador = 0; /* inicializa el contador del ciclo */ /* fase de proceso */
- 123. Algoritmo y Estructura de Datos I 122 /* inicializa las variables en las definiciones */ int aprobados = 0; /* número de aprobados */ int reprobados = 0; /* número de reprobados*/ int estudiante = 1; /* contador de estudiantes */ int resultado; /* resultado de un examen */ /* procesa las calificaciones de 10 estudiantes mediante el uso de un ciclo controlado por un contador */ while ( estudiante <= 10 ) { /* indica al usuario la introducción del valor del usuario */ printf( "Introduzca el resultado ( 1=aprobado,2=reprobado ): " ); scanf( "%d", &resultado ); /* si el resultado es igual a 1, incrementa aprobados */ if ( resultado == 1 ) { aprobados = aprobados + 1; } /* fin de if */ else { /* de lo contrario, incrementa reprobados */ reprobados = reprobados + 1; } /* fin de else */ estudiante = estudiante + 1; /* incrementa el contador de estudiante */ } /* fin de while */ /* fase de terminación; despliega el número de aprobados y reprobados */ printf( "Aprobados %dn", aprobados ); printf( "Reprobados %dn", reprobados ); /* si aprobaron más de ocho estudiantes , imprime "objetivo alcanzado" */ if ( aprobados > 8 ) { printf( "Objetivo alcanzadon" ); } /* fin de if */ return 0; /* indica que el programa terminó con exito */ } /* fin de la función main */
- 134. Algoritmo y Estructura de Datos I 133 Ejercicio 24: /* Ejemplo 24.c Escala y cambio de enteros producidos por 1 + rand() % 6. */ #include <stdio.h> #include <stdlib.h> /* la función main comienza la ejecución del programa */ int main() { int i; /* contador */ /* repite 20 veces */ for ( i = 1; i <= 20; i++ ) { /* obtiene un número aleatorio entre 1 y 6 y lo despliega */ printf( "%10d", 1 + ( rand() % 6 ) ); /* si el contador es divisible entre 5, comienza una nueva línea de salida */ if ( i % 5 == 0 ) { printf( "n" ); } /* fin de if */ } /* fin de for */ return 0; /* indica terminación exitosa */ } /* fin de main */ Ejercicio 25: /* Ejemplo 25.c Tiro de un dado de seis lados 6000 veces */ #include <stdio.h> #include <stdlib.h> /* la función main comienza la ejecución del programa */ int main() { int frecuencia1 = 0; /* contador del tiro 1 */ int frecuencia2 = 0; /* contador del tiro 2 */ int frecuencia3 = 0; /* contador del tiro 3 */
- 137. Algoritmo y Estructura de Datos I 136 return 0; /* indica terminación exitosa */ } /* fin de main */ Ejercicio 27: /* Ejemplo 27.c Craps */ #include <stdio.h> #include <stdlib.h> #include <time.h> /* contiene el prototipo de la función time */ /* constantes de enumeración que representan es estatus del juego */ enum Estatus { CONTINUA, GANA, PIERDE }; int tiraDados( void ); /* prototipo de la función */ /* la función main comienza la ejecución del programa */ int main() { int suma; /* suma del tiro de datos */ int miPunto; /* punto ganado */ enum Estatus estatusJuego; /* puede contener CONTINUA, GANA o PIERDE */ /* randomiza el generador de números aleatorios mediante el uso de la función time */ srand( time( NULL ) ); suma = tiraDados(); /* primer tiro de los dados */ /* determina el estatus del juego basado en la suma de los dados */ switch( suma ) { /* gana en el primer tiro */ case 7: case 11: estatusJuego = GANA; break; /* pierde en el primer tiro */
- 146. Algoritmo y Estructura de Datos I 145 /* coloca las respuestas del exámen dentro del arreglo respuestas */ int respuestas[ TAMANIO_RESPUESTA ] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 1, 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6, 5, 6, 7, 5, 6, 4, 8, 6, 8, 10 }; /* por cada respuesta, seleciona el valor de un elemento del arreglo respuestas y utiliza dicho valor como subíndice en el arreglo frecuencia para determinar el elemento a incrementar */ for ( respuesta = 0; respuesta < TAMANIO_RESPUESTA; respuesta++ ) { ++frecuencia[ respuestas [ respuesta ] ]; } /* fin de for */ /* despliega los resultados */ printf( "%s%17sn", "Rango", "Frecuencia" ); /* muestra las frecuencias en forma tabular */ for ( rango = 1; rango < TAMANIO_FRECUENCIA; rango++ ) { printf( "%6d%17dn", rango, frecuencia[ rango ] ); } /* fin de for */ return 0; /* indica terminación exitosa */ } /* fin de main */ Ejercicio 36: /* Ejemplo 36.c Programa de impresión de un Histograma */ #include <stdio.h> #define TAMANIO 10 /* la función main comienza la ejecución del programa */ int main() { /* utiliza una lista de inicialización para inicializar el arreglon */ int n[ TAMANIO ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 }; int i; /* contador for externo para el arreglo elementos */ int j; /* contador for interno cuenta *s en cada barra del histograma */ printf( "%s%13s%17sn", "Elemento", "Valor", "Histograma" );
- 161. Algoritmo y Estructura de Datos I 160 printf( "n" ); /* inicia una nueva línea de salida */ } /* fin de la función despliegaEncabezado */ /* Imprime una línea de salida que muestra la parte actual del arreglo que se esta procesando. */ void despliegaLinea( const int b[], int baj, int cen, int alt ) { int i; /* contador para la iteración a través del arreglo b */ /* ciclo a través del arreglo completo */ for ( i = 0; i < TAMANIO; i++ ) { /* despliega espacios si se encuentra fuera del rango actual del subarreglo */ if ( i < baj || i > alt ) { printf( " " ); } /* fin de if */ else if ( i == cen ) { /* despliega el elemento central */ printf( "%3d*", b[ i ] ); /* marca el valor central */ } /* fin de else if */ else { /* despliega otros elementos en el subarreglo */ printf( "%3d ", b[ i ] ); } /* fin de else */ } /* fin de for */ printf( "n" ); /* inicia la nueva línea de salida */ } /* fin de la función despliegaLinea */ Ejercicio 45: /* Figura 6.22: fig06_22.c Ejemplo de un arreglo de doble subíndice */ #include <stdio.h> #define ESTUDIANTES 3 #define EXAMENES 4 /* prototipos de las funciones */ int minimo( const int calificaciones[][ EXAMENES ], int alumnos, int examenes ); int maximo( const int calificaciones[][ EXAMENES ], int alumnos, int examenes ); double promedio( const int estableceCalif[], int examenes ); void despliegaArreglo( const int calificaciones[][ EXAMENES ], int alumnos, int examenes );
- 162. Algoritmo y Estructura de Datos I 161 /* la función main comienza la ejecución del programa */ int main() { int estudiante; /* contador de estudiantes */ /* inicializa las calificaciones para tres estudiantes (filas) */ const int calificacionesEstudiantes[ ESTUDIANTES ][ EXAMENES ] = { { 77, 68, 86, 73 }, { 96, 87, 89, 78 }, { 70, 90, 86, 81 } }; /* muestra el arreglo calificacionesEstudiantes */ printf( "El arreglo es:n" ); despliegaArreglo( calificacionesEstudiantes, ESTUDIANTES, EXAMENES ); /* determina el valor más pequeño y el valor más grande de las calificaciones */ printf( "nnCalificacion mas baja: %dnCalificacion mas alta: %dn", minimo( calificacionesEstudiantes, ESTUDIANTES, EXAMENES ), maximo( calificacionesEstudiantes, ESTUDIANTES, EXAMENES ) ); /* calcula el promedio de calificaciones de cada estudiante */ for ( estudiante = 0; estudiante < ESTUDIANTES; estudiante++ ) { printf( "El promedio de calificacion del estudiante %d es %.2fn", estudiante, promedio( calificacionesEstudiantes[ estudiante ], EXAMENES ) ); } /* fin de for */ return 0; /* indica terminación exitosa */ } /* fin de main */ /* Encuentra la calificación mínima */ int minimo( const int calificaciones[][ EXAMENES ], int alumnos, int examenes ) { int i; /* contador de estudiantes */ int j; /* contador de examenes */ int califBaja = 100; /* inicializa a la calificación más alta posible */ /* ciclo a través de las filas de calificaciones */ for ( i = 0; i < alumnos; i++ ) { /* ciclo a través de las columnas de calificaciones */
- 163. Algoritmo y Estructura de Datos I 162 for ( j = 0; j < examenes; j++ ) { if ( calificaciones[ i ][ j ] < califBaja ) { califBaja = calificaciones[ i ][ j ]; } /* fin de if */ } /* fin del for interno */ } /* fin del for externo */ return califBaja; /* devuelve la calificación mínima */ } /* fin de la función main */ /* Encuentra la calificación más alta */ int maximo( const int calificaciones[][ EXAMENES ], int alumnos, int examenes ) { int i; /* contador de estudiantes */ int j; /* contador de examenes */ int califAlta = 0; /* inicializa a la calificación más baja posible */ /* ciclo a través de las filas de calificaciones */ for ( i = 0; i < alumnos; i++ ) { /* ciclo a través de las columnas de calificaciones */ for ( j = 0; j < examenes; j++ ) { if ( calificaciones[ i ][ j ] > califAlta ) { califAlta = calificaciones[ i ][ j ]; } /* fin de if */ } /* fin del for interno */ } /* fin del for externo */ return califAlta; /* devuelve la calificación máxima */ } /* fin de la función maximo */ /* Determina la calificación promedio para un estudiante en especial */ double promedio( const int conjuntoDeCalificaciones[], int examenes ) { int i; /* contador de exáenes */
- 164. Algoritmo y Estructura de Datos I 163 int total = 0; /* suma de las calificaciones del examen */ /* total de calificaciones de un estudiante */ for ( i = 0; i < examenes; i++ ) { total += conjuntoDeCalificaciones[ i ]; } /* fin de for */ return ( double ) total / examenes; /* promedio */ } /* fin de la función promedio */ /* Imprime el arreglo */ void despliegaArreglo( const int calificaciones[][ EXAMENES ], int alumnos, int examenes ) { int i; /* contador de estudiantes */ int j; /* contador de examenes */ /* muestra el encabezado de las columnas */ printf( " [0] [1] [2] [3]" ); /* muestra las calificaciones en forma tabular */ for ( i = 0; i < alumnos; i++ ) { /* muestra la etiqueta de la fila */ printf( "ncalificacionesEstudiantes[%d] ", i ); /* muestra las calificaciones de un estudiante */ for ( j = 0; j < examenes; j++ ) { printf( "%‐5d", calificaciones[ i ][ j ] ); } /* fin del for interno */ } /* fin del for externo */ } /* fin de la función despliegaArreglo */ Ejercicio 46: /* Ejemplo 46.c Uso de los operadores & y * */ #include <stdio.h> int main()
- 170. Algoritmo y Estructura de Datos I 169 Bibliografía • BORES Rosario, ROSALES Roman; "Computación. Metodología, lógica computacional y programación" Mc Graw Hill 2006 • CORREA URIBE Guillermo; "Desarrollo de algoritmos y sus aplicaciones en Basic, Pascal y C (3ª. Edición)" Mc Graw Hill 2005 • JEAN Paul Tremblay, B. Bunt Richard; "Introducción a la ciencias de las computadoras (enfoque algoritmico)" Mc Graw Hill 2005 • JOYANES AGUILAR Luis; "Metodología de la programación" Mc Graw Hill 2006 • JOYANES AGUILAR Luis; "Problemas de metodología de la programación" Mc Graw Hill 2006 • JOYANES AGUILAR Luis; "Fundamentos de programación, algoritmos y estructura de datos". Mc Graw Hill 2006 • JOYANES AGUILAR Luis, Luis Rodríguez Baena y Matilde Fernández Azuela; "Fundamentos de programación, libro de problemas" Mc graw Hill 2005 • LEVINE Guillermo; "Introducción a la computación y a la programación estructurada" Mc Graw Hill 2006 • LOZANO Letvin; "Diagramación y programación estructurada y libre" Mc Graw Hill 2006