Algoritmos 1 - UTP PDF

Algoritmo y Estructura de Datos I
UNIVERSIDAD TECNOLÓGICA DEL PERÚ
Vicerrectorado de Investigación


TINS Básicos
Ingeniería de Telecomunicaciones

TEXTOS DE INSTRUCCIÓN BÁSICOS (TINS) / UTP

Lima ‐ Perú

1

© 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.
2

“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”.
3
4
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
5
6
Í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

7
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

8

Distribución Temática

Clase
Tema Semana Horas
N°
Concepto de algoritmo.
1 1
Lenguajes de programación.
Herramientas de programación.
Tipos de datos.
2 Constantes, variables, identificadores, expresiones, 2
funciones.
Estructura General de un Programa
Estructura de un Programa en C.
3 3
Estructura de algoritmos.
Contadores, acumuladores.
Programación Estructurada.
4 Estructuras de Control ‐ Tipos 4
Secuencial
Selectiva simple (SI).
Selectiva doble (SI ‐ SINO).
5 5
Selectiva múltiple (SI ‐ SINO ‐ SI).
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

Sub programación
11 Programación Modular. 11
Subprogramas – Tipos
Variables globales y locales.
12 Funciones, paso de parámetros. 12
Procedimientos paso de parámetros
Recursividad
13 13
Datos estructurados
9
Tipos.
14 14
Arreglos unidimensionales, declaración y acceso.
Clase
Tema Semana Horas
N°
15 Arreglos bidimensionales, declaración y acceso. 15
Registros
16 Concepto. 16
Declaración y acceso.
Arreglo de registros.
17 17
Cadena de caracteres.
18 Índices 18
19 Ejercicios propuestos y nivelación. 19
20 E X A M E N F I N A L 20

10

CAPÍTULO I

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.

11
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:
9 Unidad de control
9 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:
9 Memoria Central o Interna
9 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
12
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.

13
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

9 Cualitativos: Son aquellos en los que se describen los pasos utilizando palabras.
9 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).

14
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 Figura 3. Diagrama de flujo
psicología cognitiva. Estos diagramas utilizan una
15
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.
Figura 4. Diagrama de flujo
Características que debe cumplir un
diagrama de flujo
En los diagramas de flujo se presuponen los siguientes aspectos:

9 Existe siempre un camino que permite llegar a una solución (finalización del
algoritmo).
9 Existe un único inicio del proceso.
9 Existe un único punto de fin para el proceso de flujo (salvo del rombo que indica
una comparación con dos caminos posibles).
16
Desarrollo del Diagrama de Flujo
Las siguientes son acciones previas a la realización del diagrama de flujo:
9 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.
9 Definir qué se espera obtener del diagrama de flujo.
9 Identificar quién lo empleará y cómo.
9 Establecer el nivel de detalle requerido.
9 Determinar los límites del proceso a describir. Los pasos a seguir para construir el
diagrama de flujo son:
9 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.
9 Identificar y listar las principales actividades/subprocesos que están incluidos en el
proceso a describir y su orden cronológico.
9 Si el nivel de detalle definido incluye actividades menores, listarlas también.
9 Identificar y listar los puntos de decisión.
9 Construir el diagrama respetando la secuencia cronológica y asignando los
correspondientes símbolos.
9 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:

9 Evitar sumideros infinitos, burbujas que tienen entradas pero no salidas.
9 Evitar las burbujas de generación espontánea, que tienen salidas sin tener
entradas, porque son sumamente sospechosas y generalmente incorrectas.
9 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.

17
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 Figura 5. Diagrama de flujo
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.
18
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

19
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
20
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


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.
21

• 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.

22
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
23

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.
24
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.

25

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

26
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

27
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

28
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
29
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
9 fácil: al introducir sólo el año de nacimiento
9 mediano: al introducir el mes y año de nacimiento
9 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:
9 1er Practica: 30%
9 2do Practica: 25%
9 3er Practica: 20%
9 4ta Practica: 25%
10. 10.Calcular el sueldo quincenal, tomando en cuenta los siguientes parámetros:
9 Bs 450.000 por quincena
9 Bono de 10% de profesionalización a los que tienen título universitario
9 Bono quincenal de transporte de Bs 70.000
9 Bono de alimentación de Bs 5.000 por día laborado
9 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.
30
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:
9 Si x par, el siguiente término se obtiene dividiendo x por 2
9 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:

9 Los datos de entrada.
9 Cuál es la información que se desea producir (salida)
9 Los métodos y fórmulas que se necesitan para procesar los datos.

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

9 Debe tener un punto particular de inicio.
9 Debe ser definido, no debe permitir dobles interpretaciones.
9 Debe ser general, es decir, soportar la mayoría de las variantes que se puedan
presentar en la definición del problema.
9 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
32

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:

9 Descripción del Problema
9 Nombre del Autor
9 Algoritmo (diagrama de flujo o pseudocodigo)
9 Diccionario de Datos
9 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.

33
34
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:

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

9 Aritméticas
9 Relaciónales
9 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)

36
Ejemplos:

Expresión Resultado

9 7 / 2 = 3.5
9 12 mod 7 = 5
9 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:

9 Se utilizan para establecer una relación entre dos valores.
9 Compara estos valores entre si y esta comparación produce un resultado de
certeza o falsedad (verdadero o falso).
37
9 Los operadores relaciónales comparan valores del mismo tipo (numéricos o

cadenas)
9 Tienen el mismo nivel de prioridad en su evaluación.
9 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:

9 Estos operadores se utilizan para establecer relaciones entre valores lógicos.
9 Estos valores pueden ser resultado de una expresión relacional.

Operadores Lógicos

And Y
Or O
Not Negación

38
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

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

9 Nombre
9 Num_hrs
9 Calif2

Reglas para formar un Identificador

9 Debe comenzar con una letra (A a Z, mayúsculas o minúsculas) y no deben
contener espacios en blanco.
9 Letras, dígitos y caracteres como la subraya ( _ ) están permitidos después del
primer carácter.
9 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

40
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’
41
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.

42
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.

9 Planificación escalonada.
9 Programación estructurada.
9 Diseño modular.
9 Programas compactos.
9 Rapidez de ejecución.
9 Portátil.
9 De relativo bajo nivel.
9 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.

43

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.

9 El programa comienza con la función: main()
9 Cada función o programa, consta de un cuerpo de función delimitado por llaves de
comienzo y fin { }
9 En el cuerpo de la función irán incluidas: sentencias, variables, funciones, etc.
terminadas cada una de ellas por un punto y coma;

44

Programa ejemplo:

/* Este programa imprime un mensaje */
#include <stdio.h>
main()
{
printf(“LENGUAJE C\n”);
}

En el programa anterior, existen dos funciones: main() que es la principal del programa en
sí y la función printf() que es una función de la librería estándar del lenguaje C.

Al ejecutar el programa, en pantalla aparece el texto LENGUAJE C.
Programa ejemplo:

/* El programa solicita el radio y muestra el */
/* valor del área del círculo y la longitud de */
/* la circunferencia */
#include <stdio.h>
#define PI 3.14159
main()
{
int r;
float l, a;
printf(“Introduce radio (entero): “);
scanf(“%d”, &r);
l=2*PI*r; a=PI*r*r;
printf(“La longitud de la circunferencia vale %f\n”, l);
printf(“El área del círculo vale %f\n”, a);
}

45
Los datos en C: Variables y Constantes

Tipos de Datos
Los datos manejados en C pueden ser de cinco tipos básicos.

9 INT: enteros sin decimales entre (‐32768 y +32767). Ocupan en la memoria 2
bytes.
9 CHAR: caracteres alfabéticos, signos especiales, etc. El rango es (0 y 255). Ocupan
en la memoria 1 byte.
9 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.
9 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.
9 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:

9 signed
9 unsigned
9 long
9 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.

46
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).
9 El primer carácter debe ser una letra.
9 No se admiten blancos pero sí el signo de subrayado.
9 Sólo se admiten los ocho primeros caracteres.
9 Mayúsculas y minúsculas se diferencian.
9 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:
9 Se define el tipo de dato a almacenar.
9 Nombre de la variable.
9 Asignación de un valor inicial (no obligatorio).

47
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;

48
Operador de sustracción: ‐ Hace que se reste el número situado a su derecha del
situado a su izquierda.

costo=350‐25;

El signo menos también se utiliza para indicar o cambiar el signo algebraico de un
valor.

pepe=‐12;
paco=‐pepe;

Operador de multiplicación: * Hace que se multipliquen los dos valores situados a
su izquierda y derecha.

pulg=10;
cm=2.54*pulg;

Operador de división: / Hace que el valor situado a su izquierda sea dividido por el
que se encuentra a su derecha.

cuatro=12.0/3.0;

Operadores Adicionales
A la lista de los operadores anteriores (que son los más comunes), vamos a añadir ahora
tres operadores que resultan bastantes útiles.

Operador módulo: % Proporciona el resto de la división entera del número situado a su
izquierda entre el situado a su derecha.

pepe=15%5;

Operador incremento: ++ Realiza la tarea de incrementar en uno el valor de su operando.

a++; modo sufijo
++a; modo prefijo

La diferencia entre ambos, reside en el preciso momento en que se realiza la operación
incremento.

Operador decremento: ‐‐ Realiza la tarea de disminuir en uno el valor de su operando.

b‐‐; modo sufijo
‐‐b; modo prefijo
49
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:

50
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.

51
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, abre un fichero para lectura, para escritura/reescritura o para adición
fdopen
remove elimina un fichero
rename cambia al fichero de nombre
La función rewind coloca el indicador de posición de fichero para el stream
rewind
apuntado por stream al comienzo del fichero.
crea y abre un fichero temporal que es borrado cuando cerramos con la
tmpfile
función fclose()
52
Funciones de manipulación de entradas y salidas
Despeja los indicadores de final de fichero y de posición de fichero para el
clearerr
stream apuntado por stream al comienzo del fichero.
feof comprueba el indicador de final de fichero
ferror comprueba el indicador de errores
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
fflush
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
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
fwrite 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
lee caracteres de entrada hasta que encuentra un salto de línea, y los
gets
almacena en un único argumento.
printf,
fprintf,
usados para imprimir salidas de datos
sprintf
snprintf
vprintf también utilizado para imprimir salidas
53
perror escribe un mensaje de error a stderr
putc devuelve un carácter de un fichero
putchar,
igual que putc(stdout)
fputchar
scanf,
fscanf, utilizado para introducir entradas.
sscanf
vfscanf,
vscanf, también utilizado para introducir entradas.
vsscanf
Esta función es equivalente a la función setvbuf pasando los valores _IOFBF
setbuf para modo y BUFSIZ para tamaño, o (si acumulador es un puntero nulo), con
el valor _IONBF para modo.
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
setvbuf 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.
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
tmpnam
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.

54
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
55
\\ 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.

56
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\'\r\n", 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.

57
textbackground (color)
Establece el color del fondo del texto. Los colores predefinidos son los mismos que para
textcolor(). Así, este código:

textbackground (BLUE);…hace que el texto que se escriba a continuación aparezca con el
fondo en color azul oscuro.

getch ()
Lee un carácter desde el teclado, sin mostrar el eco y sin necesidad de
pulsar Return. Devuelve el código ASCII del carácter tecleado. Ahí va
un ejemplo:

char c;
c = getch();clrscr ()

Borra la pantalla. No necesita argumentos.
58
CAPÍTULO IV

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:

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

9 Simples: Consiste en pasar un valor constate a una variable (a=15)
9 Contador: Consiste en usarla como un verificador del número de veces que se
realiza un proceso (a=a+1)
9 Acumulador: Consiste en usarla como un sumador en un proceso (a=a+b)
9 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:

9 Leer a, b
9 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:

9 Escribe “El resultado es:”, R
9 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

60
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 Figura 1. Lenguaje C
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
61
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: Figura 2. Conversion monedas

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.
62

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
Figura 3. Lenguaje C
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%
En esta materia se pidió un total de dos tareas.
63
La calificación de Química se obtiene de la siguiente manera:
Examen 85%
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 Figura 4. Estructuras Condicionales
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 }

64
Formato 2:
if (condición)
{ sentencias 1}
else
{ sentencias 2 }

Ejemplo:

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ímetros\n”,valor,cm);
}
if (unidad==’c’)
{
pul=valor/2.54;
printf(“Los %f centímetros son %f pulgadas\n”,valor,pul);
}
if (unidad!=’p’ && unidad!=’c’)
printf(“No está puesta correctamente la unidad\n”);
}

En C existe una forma abreviada de expresar la sentencia if‐else. Se denomina “expresión
condicional” y emplea el operador condicional? : . El formato es el siguiente:

expresión 1 ? expresión 2 : expresión 3

El valor de la expresión total es igual al valor de la expresión 2, si expresión 1 es cierta,
mientras que si es falsa toma el valor de la expresión 3.

Sentencia switch‐case‐default.
El formato es el siguiente:

65
switch (variable)
{
case etiq 1: sentencia 1
case etiq 2: sentencia 2
....................................
default: sentencia 3
}

Ejemplo:

main()
{
char unidad;
switch(unidad)
{
case ‘p’: cm=valor*2.54;
pul=valor;
break;
case ‘c’: pul=valor/2.54;
cm=valor;
break;
default:
exit();
}
printf(“\nLas %f pulgadas son %f centímetros\n”, pul, cm);
}

Problemas Condicionales

Problemas Selectivos Simples
Prob1: 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.

66
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? Figura 5. Ejercicios condicionales

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.

67
Problemas Selectivos Dobles
Prob4: Un obrero necesita calcular su salario semanal, el cual se obtiene de la siguiente
manera:

9 Si trabaja 40 horas o menos se le paga $16 por hora
9 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
68
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
Figura 6. Condicionales dobles
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%

69
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.

9 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.
9 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

70

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.

71
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
72
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

73
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

74
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
util = sm * 0.10
si no
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.

75
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”
76
si no
imprimir “no tiene por que jubilarse”
fin‐si
fin‐si
fin‐si
fin


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:

9 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.
9 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.

77
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%
78
> 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:

9 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.
9 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.
9 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.
9 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.
9 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.
9 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.
9 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:

79
Bucle for. El formato es el siguiente:

for (inicio; condición; incremento)
{
sentencias
}

Bucle while. El formato es el siguiente:

while ( condición)
{
sentencias
}

Bucle do‐while. El formato es el siguiente:

do
{
sentencias
}
while (condición);

Ejemplo:

main()
{
long acum=1;
int i, n;
do
{
printf(“Introduce número positivo: “);
scanf(“%d”,&n);
}
while(n<0);
for(i=n; i>1; ‐‐i)
acum*=i;
printf(“\nEl factorial es %ld”, acum);
}

80
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.

81
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.

82
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.

83

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:

9 Que en ninguna de las pruebas haga un tiempo mayor a 16 minutos.
9 Que al menos en una de las pruebas realice un tiempo mayor a 16 minutos.
9 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.
84
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 = %i\n",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:
85
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
86
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:
Figura 8. Repetir hasta

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.

87
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 %

88
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.

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

9 Las funciones normalmente, devuelven un solo valor a la unidad de programa
(programa principal u otro subprograma) que la referencia o la llama.
90
9 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.

91
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
92
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.

93
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.
94
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).

95
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
96
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 Mundo\n"); /*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.

97
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 */
}
98
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,...,

99
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
100
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.

101
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.
102
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);
}

103
/*************************************************************************
**
* 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: %d\n", 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
104

**************************************************************************
*/

double Fibonacci(int n) {
int i;
double Fibi, Fibn1, Fibn2;

switch (n) {
case 0 : return 0;
case 1 : return 1;
default :
Fibn2 = 0; /* Fibonacci(n ‐ 2) */
Fibn1 = 1; /* Fibonacci(n ‐ 1) */
for (i = 2; i <= n; i++) {
Fibi = Fibn1 + Fibn2;
Fibn2 = Fibn1;
Fibn1 = Fibi;
}
return Fibi;
}
}

/*************************************************************************
**
* Programa que calcula, de forma iterativa, el termino n‐esimo de la
* sucesión de fibonacci, para un valor n dado por el usuario.

**************************************************************************
*/

main() {
int n;

/* Se solicita al usuario el valor de n */
printf("Ingrese el valor de n: ");
scanf("%d", &n); /* scanf requiere puntero: & */

/* Imprime el fibonacci de n */
printf("El termino %d de Fibonacci es: %.0lf\n", n, Fibonacci(n));
}

105
/*************************************************************************
**
* 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() {
106
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: %d\n", 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.

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

108
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];

109
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

110
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: %d\n",i,nDigit[i]);

printf("Caracteres separadores: %d\n",nWhite);
111
printf("Otros caracteres: %d\n",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] = %d\n",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'};
112
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 %s\n",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 */
}

113
114
CAPÍTULO VII
Aplicaciones

Ejercicio 1:

/* Ejemplo 1
El primer programa en C */
#include <stdio.h>

/* la función main inicia la ejecución del programa */
int main( void )
{
printf( "Bienvenido a C!\n" );

return 0; /* indica que el programa terminó con exito */

} /* fin de la función main */

Ejercicio 2:

/* Ejemplo 2
Impresión de una línea mediante dos instrucciones printf */
#include <stdio.h>

int main()
{
printf( "Bienvenido " );
printf( "a C!\n" );

return 0; /* indica que el programa terminó con éxito */


115
Ejercicio 3:

/* Ejemplo 3.c
Impresión de múltiples líneas mediante una sola instrucción printf */
#include <stdio.h>

int main()
{
printf( "Bienvenido\na\nC!\n" );



Ejercicio 4:

/* Ejercicio 4.c
Programa de suma */
#include <stdio.h>

int main()
{
int entero1; /* primer número introducido por el usuario */
int entero2; /* segundo número introducido por el usuario */
int suma; /* variable en la cual se almacena la suma */

printf( "Introduzca el primer entero\n" ); /* indicador */
scanf( "%d", &entero1 ); /* lee un entero */

printf( "Introduzca el segundo entero\n" ); /* indicador */
scanf( "%d", &entero2 ); /* lee un entero */

suma = entero1 + entero2; /* asigna el total a suma */

printf( "La suma es %d\n", suma ); /* imprime la suma */


116
Ejercicio 5:
/* Ejercicio 5.c
Uso de instrucciones if, operadores de
relación, y operadores de igualdad */
#include <stdio.h>

main()
{
int num1; /* primer número que lee el usuario */
int num2; /* segundo número que lee el usuario */

printf( "Introduzca dos enteros, y le dire\n" );
printf( "las relaciones que satisfacen: " );

scanf( "%d%d", &num1, &num2 ); /* lectura de los enteros */

if ( num1 == num2 ) {
printf( "%d es igual que %d\n", num1, num2 );
} /* fin de if */

if ( num1 != num2 ) {
printf( "%d no es igual que %d\n", num1, num2 );
} /* fin de if */

if ( num1 < num2 ) {
printf( "%d es menor que %d\n", num1, num2 );
} /* fin de if */

if ( num1 > num2 ) {
printf( "%d es mayor que %d\n", num1, num2 );
} /* fin de if */

if ( num1 <= num2 ) {
printf( "%d es menor o igual que %d\n", num1, num2 );
} /* end if */

if ( num1 >= num2 ) {
printf( "%d es mayor o igual que %d\n", num1, num2 );
} /* fin de if */

117
Ejercicio 6:

/* eleva x a la potencia y */
#include <stdio.h>

int main()
{
int x, y, i, potencia; /* definición de las variables */

i = 1;
potencia = 1; /* inicializa la potencia */
scanf( "%d", &x ); /* lectura de x del usuario */
scanf( "%d", &y ); /* lectura de y del usuario */

while ( i <= y ) { /* repetirá el ciclo while mientras i sea menor o igual a y */
potencia *= x; /* multiplica potencia por x */
++i; /* incrementa i */

} /* fin del while */

printf( "%d\n", potencia ); /* despliega la potencia */

return 0;


Ejercicio 7:

#include <stdio.h>
int main()
{
int x = 1, total = 0, y;
while ( x <= 10 ) {
y = x * x;
printf( "%d\n", y );
total += y;
++x;
}
printf( "El total es: %d\n", total );
return 0;
}

118

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>

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 %d\n", promedio ); /* despliega el resultado */



119
Ejercicio 9:

main()
{
char unidad;
if (unidad==’p’)
{
cm=valor*2.54;
printf(“Las %f pulgadas son %f centímetros\n”,valor,cm);
}
if (unidad==’c’)
{
pul=valor/2.54;
printf(“Los %f centímetros son %f pulgadas\n”,valor,pul);
}
if (unidad!=’p’ && unidad!=’c’)
}

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>

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 */
120
/* obtiene la primera calificación del usuario */
printf( "Introduzca la calificación, ‐1 para terminar: " ); /* indicador para la entrada
*/
scanf( "%d", &calificación ); /* lee la calificación del usuario */

/* realiza el ciclo mientras no se introduzca el valor centinela */
while ( calificación != ‐1 ) {
total = total + calificación; /* suma calificación a total */
contador = contador + 1; /* incrementa el contador */

/* obtiene la siguiente calificación del usuario */
printf( "Introduzca la calificación, ‐1 para terminar: " ); /* indicador para la entrada
*/
scanf("%d", &calificación); /* lee la siguiente calificación */

/* fase de terminación */
/* si el usuario introduce al menos una calificación */
if ( contador != 0 ) {

/* calcula el promedio de todas las calificaciones introducidas */
promedio = ( float ) total / contador; /* evita la truncación */

/* despliega el promedio con dos dígitos de precisión */
printf( " El promedio de la clase es: %.2f\n", promedio );
} /* fin de if*/
else { /* si no se introduce calificación alguna , despliega el mensaje */
printf( "No se introdujeron calificaciones\n" );
} /* fin de else */


Ejercicio 11:

/* Ejemplo 11.c
Análisis de los resultados de un examen */
#include <stdio.h>

int main()
{
121
/* 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 */

/* fase de terminación; despliega el número de aprobados y reprobados */
printf( "Aprobados %d\n", aprobados );
printf( "Reprobados %d\n", reprobados );

/* si aprobaron más de ocho estudiantes , imprime "objetivo alcanzado" */
if ( aprobados > 8 ) {
printf( "Objetivo alcanzado\n" );
} /* fin de if */



122
Ejercicio 12:

/* Ejemplo12.c
Preincremeno y postincremento */
#include <stdio.h>

int main()
{
int c; /* define la variable */

/* demuestra el postincremento */
c = 5; /* le asigna 5 a c */
printf( "%d\n", c ); /* imprime 5 */
printf( "%d\n", c++ ); /* imprime 5 y hace el postincremento */
printf( "%d\n\n", c ); /* imprime 6 */

/* demuestra el preincremento */
c = 5; /* le asigna 5 a c */
printf( "%d\n", ++c ); /* preincrementa e imprime 6 */



Ejercicio 13:

/* Ejemplo 13.c
Repetición controlada por contador */
#include <stdio.h>

/* la función main comienza la ejecución del programa */
int main()
{
int contador = 1; /* inicialización */

while ( contador <= 10 ) { /* condición de repetición */
printf ( "%d\n", contador ); /* despliega el contador */
contador++; /* incremento */
123

return 0; /* indica terminación exitosa */


Ejercicio 14:

/* Ejemplo 14.c
Repetición controlada por contador mediante la instrucción for */
#include <stdio.h>

int main()
{
int contador; /* definición del contador */

/* la inicialización, condición de repetición, e incremento
se incluyen en el encabezado de la instrucción for. */
for ( contador = 1; contador <= 10; contador++ ) {
printf( "%d\n", contador );
} /* fin del for */

return 0; /* indica terminación exitosa del programa */


Ejercicio 15:

/* Ejemplo 15.c
Suma con for */
#include <stdio.h>

int main()
{
int suma = 0; /* inicializa la suma */
int numero; /* número a adicionar a suma */

for ( numero = 2; numero <= 100; numero += 2 ) {
suma += numero; /* suma el número a suma */
} /* fin de for */
124

printf( "La suma es %d\n", suma ); /* muestra la suma */



Ejercicio 16:

/* Ejemplo 16.c
Cálculo del interés compuesto */
#include <stdio.h>
#include <math.h>

int main()
{
double monto; /* monto del depósito */
double principal = 1000.0; /* monto principal */
double tasa = .05; /* interés compuesto anual */
int anio; /* contador de años */

/* muestra el encabezado de salida de la tabla */
printf( "%4s%21s\n", "Anio", "Monto del deposito" );

/* calcula el monto del depósito para cada uno de los diez años */
for ( anio = 1; anio <= 10; anio++ ) {

/* calcula el nuevo monto para el año especificado */
monto = principal * pow( 1.0 + tasa, anio );

/* muestra una línea de la tabla */
printf( "%4d%21.2f\n", anio, monto );
} /* fin de for */

125
Ejercicio 17:

/* Ejemplo 17.c
Cuenta las calificaciones con letras */
#include <stdio.h>

int main()
{
int calificación; /* una calificación */
int cuentaA = 0; /* número de As */
int cuentaB = 0; /* número de Bs */
int cuentaC = 0; /* número de Cs */
int cuentaD = 0; /* número de Ds */
int cuentaF = 0; /* número de Es */

printf( "Introduzca la letra de la calificación.\n" );
printf( "Introduzca el caracter EOF para finalizar la entrada de datos.\n" );

/* repite hasta que el usuario digita la secuencia de teclas de fin‐de‐archivo */
while ( ( calificación = getchar() ) != EOF ) {

/* determina cual calificación se introdujo */
switch ( calificación ) { /* switch anidado dentro del while */

case 'A': /* la calificación es A */
case 'a': /* o a */
++cuentaA; /* incrementa cuentaA */
break; /* necesario para salir de switch */

case 'B': /* la calificación es B */
case 'b': /* o b */
++cuentaB; /* incrementa cuentaB */
break; /* sale de switch */

case 'C': /* la calificación es C */
case 'c': /* o c */
++cuentaC; /* incrementa cuentaC */

case 'D': /* la calificación es D */
case 'd': /* o d */
++cuentaD; /* incrementa cuentaD */
126

case 'F': /* la calificación es F */
case 'f': /* o f */
++cuentaF; /* incrementa cuentaF */

case '\n': /* ignora nuevas líneas, */
case '\t': /* tabuladores, */
case ' ': /* y espacios en la entrada */
break; /* fin de switch */

default: /* atrapa todos los demás caracteres */
printf( "Introdujo una letra incorrecta." );
printf( " Introduzca una nueva calificación.\n" );
break; /* opcional; de todas maneras saldrá del switch */
} /* fin de switch */


/* muestra el resumen de los resultados */
printf( "\nLos totales por calificación son:\n" );
printf( "A: %d\n", cuentaA ); /* despliega el número de calificaciones A */
printf( "B: %d\n", cuentaB ); /* despliega el número de calificaciones B */
printf( "C: %d\n", cuentaC ); /* despliega el número de calificaciones C */
printf( "D: %d\n", cuentaD ); /* despliega el número de calificaciones D */
printf( "F: %d\n", cuentaF ); /* despliega el número de calificaciones F */



Ejercicio 18:

/* Ejemplo 18.c
Uso de la instrucción de repetición do/while */
#include <stdio.h>

int main()
{
int contador = 1; /* inicializa el contador */
127
do {
printf( "%d ", contador ); /* despliega el contador */
} while ( ++contador <= 10 ); /* fin del do...while */

return 0; /* indica la terminación exitosa del programa */


Ejercicio 19:

/* Ejemplo 19.c
Uso de la instrucción break dentro de la instrucción for */
#include <stdio.h>

int main()
{
int x; /* contador */

/* repite 10 veces el ciclo */
for ( x = 1; x <= 10; x++ ) {

/* si x es 5, termina el ciclo */
if ( x == 5 ) {
break; /* rompe el ciclo sólo si x es 5 */
} /* fin de if */

printf( "%d ", x ); /* despliega el valor de x */
} /* fin de for */

printf( "\nRompe el ciclo en x == %d\n", x );



128
Ejercicio 20:

/* Ejemplo 20.c
Uso de la instrucción continue dentro de una instrucción for */
#include <stdio.h>

int main()
{

/* repite el ciclo 10 veces */
for ( x = 1; x <= 10; x++ ) {

/* si x es 5, continua con la siguiente iteración del ciclo */
if ( x == 5 ) {
continue; /* ignora el resto del código en el cuerpo del ciclo */
} /* fin de if */

printf( "%d ", x ); /* despliega el valor de x */
} /* fin de for */

printf( "\nUtiliza continue para ignorar la impresión del valor 5\n" );



Ejercicio 21:

/* Ejemplo 21.c */
/* Verificación de las funciones matemáticas de la biblioteca */
#include <stdio.h>
#include <math.h>

int main()
{
/* calcula y despliega la raiz cuadrada */
printf( "sqrt(%.1f) = %.1f\n", 900.0, sqrt( 900.0 ) );
printf( "sqrt(%.1f) = %.1f\n", 9.0, sqrt( 9.0 ) );

129
/* calcula y despliega la función exponencial e a la x */
printf( "exp(%.1f) = %f\n", 1.0, exp( 1.0 ) );
printf( "exp(%.1f) = %f\n", 2.0, exp( 2.0 ) );

/* calcula y despliega el logaritmo the logorithm (base e) */
printf( "log(%f) = %.1f\n", 2.718282, log( 2.718282 ) );
printf( "log(%f) = %.1f\n", 7.389056, log( 7.389056 ) );

/* calcula y despliega el logaritmo (base 10) */
printf( "log10(%.1f) = %.1f\n", 1.0, log10( 1.0 ) );

/* calcula y despliega el valor absoluto */
printf( "fabs(%.1f) = %.1f\n", 13.5, fabs( 13.5 ) );
printf( "fabs(%.1f) = %.1f\n", 0.0, fabs( 0.0 ) );
printf( "fabs(%.1f) = %.1f\n", ‐13.5, fabs( ‐13.5 ) );

/* calcula y despliega ceil( x ) */
printf( "ceil(%.1f) = %.1f\n", 9.2, ceil( 9.2 ) );
printf( "ceil(%.1f) = %.1f\n", ‐9.8, ceil( ‐9.8 ) );

/* calcula y despliega floor( x ) */
printf( "floor(%.1f) = %.1f\n", 9.2, floor( 9.2 ) );
printf( "floor(%.1f) = %.1f\n", ‐9.8, floor( ‐9.8 ) );

/* calcula y despliega pow( x, y ) */
printf( "pow(%.1f, %.1f) = %.1f\n", 2.0, 7.0, pow( 2.0, 7.0 ) );
printf( "pow(%.1f, %.1f) = %.1f\n", 9.0, 0.5, pow( 9.0, 0.5 ) );

/* calcula y despliega fmod( x, y ) */
printf( "fmod(%.3f/%.3f) = %.3f\n", 13.675, 2.333,
fmod( 13.675, 2.333 ) );

/* calcula y despliega sin( x ) */
printf( "sin(%.1f) = %.1f\n", 0.0, sin( 0.0 ) );

/* calcula y despliega cos( x ) */
printf( "cos(%.1f) = %.1f\n", 0.0, cos( 0.0 ) );

/* calcula y despliega tan( x ) */
printf( "tan(%.1f) = %.1f\n", 0.0, tan( 0.0 ) );

130

} /* fin de main */

Ejercicio 22:

/* Ejemplo 22.c
Creación y uso de una función definida por el usuario */
#include <stdio.h>

int cuadrado( int y ); /* prototipo de la función */

int main()
{

/* repite 10 veces el ciclo y calcula e imprime cada vez el cuadrado de x */
for ( x = 1; x <= 10; x++ ) {
printf( "%d ", cuadrado( x ) ); /* llamada a la función */
} /* fin de for */

printf( "\n" );


} /* fin de main */

/* definición de la función cuadrado, devuelve el cuadrado del parámetro */
int cuadrado( int y ) /* y es una copia del argumento para la función */
{
return y * y; /* devuelve el cuadrado de y como un int */

} /* fin de la función cuadrado */

131
Ejercicio 23:

/* Ejemplo 23.c
Encuentra el máximo de tres enteros */
#include <stdio.h>

int maximo( int x, int y, int z ); /* prototipo de la función */

int main()
{
int numero1; /* primer entero */
int numero2; /* segundo entero */
int numero3; /* tercer entero */

printf( "Introduzca tres enteros: " );
scanf( "%d%d%d", &numero1, &numero2, &numero3 );

/* numero1, numero2 y numero3 son argumento
para la llamada a la función maximo */
printf( "El maximo es: %d\n", maximo( numero1, numero2, numero3 ) );


} /* fin de main */

/* Definición de la función máximo */
/* x, y, y z son parámetros */
int maximo( int x, int y, int z )
{
int max = x; /* asume que x es el mayor */

if ( y > max ) { /* si y es mayor que max, asigna y a max */
max = y;
} /* fin de if */

if ( z > max ) { /* si z es mayor que max, asigna z a max */
max = z;
} /* fin de if */

return max; /* max es el valor más grande */

} /* fin de la función máximo */
132
Ejercicio 24:

/* Ejemplo 24.c
Escala y cambio de enteros producidos por 1 + rand() % 6. */
#include <stdio.h>
#include <stdlib.h>

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 */


} /* fin de main */

Ejercicio 25:

/* Ejemplo 25.c
Tiro de un dado de seis lados 6000 veces */
#include <stdio.h>
#include <stdlib.h>

int main()
{
int frecuencia1 = 0; /* contador del tiro 1 */
133

int tiro; /* contador de tiros, valores de 1 a 6000 */
int cara; /* representa un tiro del dado, valores de 1 a 6 */

/* repite 6000 veces y resume los resultados */
for ( tiro = 1; tiro <= 6000; tiro++ ) {
cara = 1 + rand() % 6; /* número aleatorio de 1 a 6 */

/* determina el valor de la cara e incrementa el contador apropiado */
switch ( cara ) {

case 1: /* tiro 1 */
++frecuencia1;
break;

++frecuencia2;
break;

++frecuencia3;
break;

++frecuencia4;
break;

++frecuencia5;
break;

++frecuencia6;
break; /* opcional */

} /* fin de for */

/* despliega los resultados en forma tabular */
printf( "%s%13s\n", "Cara", "Frecuencia" );
134
printf( " 1%13d\n", frecuencia1 );


} /* fin de main */

Ejercicio 26:

/* Ejemplo 26.c
Randomización del programa de dados */
#include <stdlib.h>
#include <stdio.h>

int main()
{
unsigned semilla; /* número que se utiliza para establecer la semilla del generador
de números aleatorios */

printf( "Introduzca la semilla: " );
scanf( "%u", &semilla ); /* observe %u para un unsigned */

srand( semilla ); /* establece la semilla del generador de números aleatorios */

/* repite 10 veces */
for ( i = 1; i <= 10; i++ ) {

/* toma un número aleatorio de 1 a 6 y lo muestra */
printf( "%10d", 1 + ( rand() % 6 ) );

/* si contador es divisible entre 5, comienza una nueva línea de salida */
if ( i % 5 == 0 ) {
printf( "\n" );
} /* fin de if */

} /* fin de for */
135


} /* 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 */

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 */
136
case 2:
case 3:
case 12:
estatusJuego = PIERDE;
break;

/* recuerda el punto */
default:
estatusJuego = CONTINUA;
miPunto = suma;
printf( "Su punto es %d\n", miPunto );
break; /* opcional */

/* mientras el juego no se complete */
while ( estatusJuego == CONTINUA ) {
suma = tiraDados(); /* tira de nuevo los dados */

/* determina el estatus del juego */
if ( suma == miPunto ) { /* gana por punto */
estatusJuego = GANA; /* fin del juego, gana el jugador */
} /* fin de if */
else {

if ( suma == 7 ) { /* pierde al tirar 7 */
estatusJuego = PIERDE; /* termina el juego, pierde el jugador */
} /* fin de if */

} /* fin de else */


/* despliega el mensaje del ganador o perdedor */
if ( estatusJuego == GANA ) { /* ¿Ganó el jugador? */
printf( "Gana el jugador\n" );
} /* fin de if */
else { /* pierde el jugador */
printf( "Pierde el jugador\n" );
} /* fin de else */


} /* fin de main */
137

/* tiro de dados, calcula la suma y despliega los resultados */
int tiraDados( void )
{
int dado1; /* primer dado */
int dado2; /* segundo dado */
int sumaTemp; /* suma de los dados */

dado1 = 1 + ( rand() % 6 ); /* toma el aleatorio para el dado1 */
dado2 = 1 + ( rand() % 6 ); /* toma el aleatorio para el dado2 */
sumaTemp = dado1 + dado2; /* suma el dado1 y el dado2 */

/* despliega los resultados de este tiro */
printf( "El jugador tiro %d + %d = %d\n", dado1, dado2, sumaTemp );

return sumaTemp; /* devuelve la suma de los dados */

} /* fin de la función tiraDados */

Ejercicio 28:

/* Ejemplo 28.c
Ejemplo de alcance */
#include <stdio.h>

void usoLocal( void ); /* prototipo de función */
void usoStaticLocal( void ); /* prototipo de función */
void usoGlobal( void ); /* prototipo de función */

int x = 1; /* variable global */

int main()
{
int x = 5; /* variable local a main */

printf("x local fuera del alcance de main es %d\n", x );

{ /* comienza el nuevo alcance */
int x = 7; /* variable local con nuevo alcance */

printf( "x local en el alcance interno de main es %d\n", x );
138
} /* fin de nuevo alcance */

printf( "x local en el alcance externo de main es %d\n", x );

usoLocal(); /* usoLocal contiene a automatic local x */
usoStaticLocal(); /* usoStaticLocal contiene a static local x */
usoGlobal(); /* usoGlobal utiliza global x */
usoLocal(); /* usoLocal reinicializa automatic local x */
usoStaticLocal(); /* static local x retiene su valor previo */
usoGlobal(); /* x global también retiene su valor */

printf( "\nx local en main es %d\n", x );


} /* fin de main */

/* usoLocal reinicializa a la variable local x durante cada llamada */
void usoLocal( void )
{
int x = 25; /* se inicializa cada vez que se llama usoLocal */

printf( "\nx local en usoLocal es %d después de entrar a usoLocal\n", x );
x++;
printf( "x local en usoLocal es %d antes de salir de usoLocal\n", x );
} /* fin de la función usoLocal */

/* usoStaticLocal initializa la variable static local x sólo la primera vez
que se invoca a la función; el valor de x se guarda entre las llamadas a esta
función */
void usoStaticLocal( void )
{
/* se inicializa sólo la primera vez que se invoca usoStaticLocal */
static int x = 50;

printf( "\nlocal static x es %d al entrar a usoStaticLocal\n", x );
x++;
printf( "local static x es %d al salir de usoStaticLocal\n", x );
} /* fin de la función usoStaticLocal */

/* la función usoGlobal modifica la variable global x durante cada llamada */
void usoGlobal( void )
{
139
printf( "\nx global es %d al entrar a usoGlobal\n", x );
x *= 10;
printf( "x global es %d al salir de usoGlobal\n", x );
} /* fin de la función usoGlobal */

Ejercicio 29:

/* Ejemplo 29.c
Función recursiva del factorial */
#include <stdio.h>

long factorial( long numero ); /* prototipo de la función */

int main()
{

/* repite 11 veces; durante cada iteración, calcula
el factorial( i ) y despliega el resultado */
for ( i = 0; i <= 10; i++ ) {
printf( "%2d! = %ld\n", i, factorial( i ) );
} /* fin de for */


} /* fin de main */

/* definición recursiva de la función factorial */
long factorial( long número )
{
/* caso base */
if ( número <= 1 ) {
return 1;
} /* fin de if */
else { /* paso recursivo */
return ( numero * factorial( numero ‐ 1 ) );
} /* fin de else */

} /* fin de la función factorial */
140
Ejercicio 30:

/* Ejemplo 30.c
Función recursiva de fibonacci */
#include <stdio.h>

long fibonacci( long n ); /* prototipo de la función */

int main()
{
long resultado; /* valor fibonacci */
long numero; /* numero a introducir por el usuario */

/* obtiene un entero del usuario */
printf( "Introduzca un entero: " );
scanf( "%ld", &numero);

/* calcula el valor fibonacci del número introducido por el usuario */
resultado = fibonacci( numero );

/* despliega el resultado */
printf( "Fibonacci( %ld ) = %ld\n", numero, resultado );


} /* fin de main */

/* definición de la función recursiva fibonacci */
long fibonacci( long n )
{
/* caso base */
if ( n == 0 || n == 1 ) {
return n;
} /* fin de if */
else { /* paso recursivo */
return fibonacci( n ‐ 1 ) + fibonacci( n ‐ 2 );
} /* fin de else */

} /* fin de la función fibonacci */

141
Ejercicio 31:

/* Ejemplo 31.c
inicializar un arreglo */
#include <stdio.h>

int main()
{
int n[ 10 ]; /* n es un arreglo de 10 enteros */

/* 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%13s\n", "Elemento", "Valor" );

/* muestra el contenido del arreglo n en forma tabular */
for ( i = 0; i < 10; i++ ) {
printf( "%7d%13d\n", i, n[ i ] );
} /* fin de for */


} /* fin de main */

Ejercicio 32:

/* Ejemplo 32.c
Inicializa un arreglo mediante una lista de inicialización */
#include <stdio.h>

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 };

142

/* muestra el contenido del arreglo en forma tabular */
for ( i = 0; i < 10; i++ ) {
printf( "%7d%13d\n", i, n[ i ] );
} /* fin de for */


} /* 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

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 */


/* muestra el contenido del arreglo s en forma tabular */
for ( j = 0; j < TAMANIO; j++ ) {
printf( "%7d%13d\n", j, s[ j ] );
} /* fin de for */


} /* fin de main */

143
Ejercicio 34:

/* Ejemplo 34.c
Calcula la suma de los elementos del arreglo */
#include <stdio.h>
#define TAMANIO 12

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 %d\n", total );


} /* 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

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 };
144

/* 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%17s\n", "Rango", "Frecuencia" );

/* muestra las frecuencias en forma tabular */
for ( rango = 1; rango < TAMANIO_FRECUENCIA; rango++ ) {
printf( "%6d%17d\n", rango, frecuencia[ rango ] );
} /* fin de for */


} /* fin de main */

Ejercicio 36:

/* Ejemplo 36.c
Programa de impresión de un Histograma */
#include <stdio.h>
#define TAMANIO 10

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%17s\n", "Elemento", "Valor", "Histograma" );

145
/* 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 */


} /* 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

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%17s\n", "Cara", "Frecuencia" );

146
/* muestra los elementos 1‐6 de frecuencia en forma tabular */
for ( cara = 1; cara < TAMANIO; cara++ ) {
printf( "%4d%17d\n", cara, frecuencia[ cara ] );
} /* fin de for */


} /* fin de main */

Ejercicio 38:

/* Figura 6.10: fig06_10.c
Manipulación de arreglos de caracteres como cadenas */
#include <stdio.h>

int main()
{
char cadena1[ 20 ]; /* reserva 20 caracteres */
char cadena2[] = "literal de cadena"; /* reserva 18 caracteres */

/* 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: %s\ncadena2 es: %s\n"
"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" );


} /* fin de main */

147
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( "\n\nSegunda llamada a cada función:\n" );
iniciaArregloEstatico();
iniciaArregloAutomatico();


} /* 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 ];

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 );
148
} /* 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 };

printf( "\n\nValores 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 );

int main()
{
int a[ TAMANIO ] = { 0, 1, 2, 3, 4 }; /* inicializa a */
149

printf( "Efectos de pasar arreglos completos por referencia:\n\nThe "
"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( "\n\n\nEfectos de pasar un elemento del arreglo "
"por valor:\n\nEl valor de a[3] es %d\n", 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 %d\n", a[ 3 ] );


} /* 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++ ) {
150
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 %d\n", 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 */

int main()
{
int a[] = { 10, 20, 30 }; /* inicializa a */

intentaModifElArreglo( a );

printf("%d %d %d\n", a[ 0 ], a[ 1 ], a[ 2 ] );


} /* 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 */
151
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

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[] );

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 );


} /* fin de main */

/* calcula el promedio de todos los valores de las respuestas */
152
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( "%s\n%s\n%s\n", "********", " 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 de\n"
"todos los elementos de datos divididos por\n"
"el numero de elementos de datos ( %d ). La media\n"
"en esta ejecución es: %d / %d = %.4f\n\n",
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%s\n%s\n%s\n%s",
"********", " Mediana", "********",
"El arreglo de respuestas desordenado es" );

imprimeArreglo( resp ); /* muestra el arreglo desordenado */

ordenamBurbuja( resp ); /* ordena el arreglo */

printf( "\n\nEl arreglo ordenado es " );
imprimeArreglo( resp ); /* muestra el arreglo ordenado */

/* muestra la mediana */
printf( "\n\nLa mediana es el elemento %d del\n"
"arreglo ordenado de elementos %d.\n"
"Para esta ejecución la mediana es %d\n\n",
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[] )
153
{
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%s\n%s\n%s\n",
"********", " 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%19s\n\n%54s\n%54s\n\n",
"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( "*" );

printf( "\n" ); /* nueva línea de salida */

154
/* 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 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" );
155
} /* 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 );

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 );

if ( elemento != ‐1 ) {
printf( "Encontre el valor en el elemento %d\n", elemento );
} /* fin de if */
else {
printf( "Valor no encontrado\n" );
156
} /* fin de else */


} /* 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

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 );

int main()
{
int a[ TAMANIO ]; /* crea el arreglo a */
157
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 );

if ( resultado != ‐1 ) {
printf( "\n%d se encuentra en el elemento %d del arreglo\n", llave, resultado );
} /* fin de if */
else {
printf( "\n%d no se encuentra\n", llave );
} /* fin de else */


} /* 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 );

158
/* 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 */


return ‐1; /* no se encontró claveDeBusqueda */

} /* fin de la funcipon busquedaBinaria */

/* Imprime un encabezado para la salida */
void despliegaEncabezado( void )
{

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 */

159
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

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 );
160

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( "\n\nCalificacion mas baja: %d\nCalificacion mas alta: %d\n",
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 %.2f\n",
estudiante, promedio( calificacionesEstudiantes[ estudiante ], EXAMENES )
);
} /* fin de for */


} /* 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 */
161
for ( j = 0; j < examenes; j++ ) {

if ( calificaciones[ i ][ j ] < califBaja ) {
califBaja = calificaciones[ i ][ j ];
} /* fin de if */



return califBaja; /* devuelve la calificación mínima */


/* Encuentra la calificación más alta */
int maximo( const int calificaciones[][ EXAMENES ], int alumnos, int 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 */

if ( calificaciones[ i ][ j ] > califAlta ) {
califAlta = calificaciones[ i ][ j ];
} /* fin de if */



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 */
162
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 )
{

/* 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 */
printf( "%‐5d", calificaciones[ i ][ j ] );


} /* fin de la función despliegaArreglo */

Ejercicio 46:
/* Ejemplo 46.c
Uso de los operadores & y * */
#include <stdio.h>

int main()
163
{
int a; /* a es un entero */
int *ptrA; /* ptrA es un apuntador a un entero */

a = 7;
ptrA = &a; /* ptrA toma la dirección de a */

printf( "La direccion de a es %p"
"\nEl valor de ptrA es %p", &a, ptrA );

printf( "\n\nEl valor de a es %d"
"\nEl valor de *ptrA es %d", a, *ptrA );

printf( "\n\nMuestra de que * y & son complementos "
"uno del otro\n&*ptrA = %p"
"\n*&ptrA = %p\n", &*ptrA, *&ptrA );


} /* fin de main */

Ejercicio 47:

/* Figura 7.6: fig07_06.c
Eleva al cubo una variable mediante una llamada por valor */
#include <stdio.h>

int cuboPorValor( int n ); /* prototipo */

int main()
{
int numero = 5; /* inicializa numero */

printf( "El valor original de numero es %d", numero );

/* pasa numero por valor a cuboPorValor */
numero = cuboPorValor( numero );

printf( "\nEl nuevo valor de numero es %d\n", numero );


164
} /* fin de main */

/* calcula y devuelve el cubo de un argumento entero */
int cuboPorValor( int n )
{
return n * n * n; /* eleva al cubo la variable local n y devuelve el resultado */

} /* fin de la función cuboPorValor */

Ejercicio 48:

/* Figura 7.7: fig07_07.c
Eleva al cubo una variable mediante el uso de una llamada por referencia con un
apuntador como argumento */

#include <stdio.h>

void cuboPorReferencia( int *ptrN ); /* prototipo */

int main()
{
int numero = 5; /* inicializa numero */

printf( "El valor original de numero es %d", numero );

/* pasa la dirección de numera a cuboPorReferencia */
cuboPorReferencia( &numero );

printf( "\nEl nuevo valor de numero es %d\n", numero );


} /* fin de main */

/* calcula el cubo de *ptrN; modifica la variable numero en main */
void cuboPorReferencia( int *ptrN )
{
*ptrN = *ptrN * *ptrN * *ptrN; /* cubo de *ptrN */
} /* fin de la función cuboPorReferencia */

165
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: %s\n", cadena );


} /* 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 de la función convierteAmayusculas */
166
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" );


} /* 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 */

167
168
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
169

Algoritmos 1 - UTP PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Algoritmos 1 - UTP PDF

Transféré par

Droits d'auteur :

Formats disponibles

Algoritmo y Estructura de Datos I

10 E X A M E N P A R C I A L 10

19 Ejercicios propuestos y nivelación. 19

20 E X A M E N F I N A L 20

Datos de Proceso Datos de

9 Los operadores relaciónales comparan valores del mismo tipo (numéricos o

1) ((a > b) or (a < c)) and ((a = c) or (a > = b))

2) ((a > = b) or (a < d)) and (( a > = d) and (c > d))

3) not (a = c) and (c > b)

P2: Un vendedor recibe un sueldo

Prob7: Una persona enferma, que pesa

Vous aimerez peut-être aussi