Libro 1 - Fundamentos de Programación PDF

Fundamentos de
Programación
Código del Curso: CY300
Versión 4.0
Guía del Estudiante
Libro 1: Fundamentos
de Programación
IBM IT Education Services

Worldwide Certified Material
Información Sobre la Publicación
Esta publicación ha sido producida usando Microsoft Word 2000 y Microsoft PowerPoint
2000 para Windows.
Marcas Registradas
IBM ® es una marca registrada por International Business Machines Corporation.
Otras compañías, productos, y nombre de servicios pueden ser marcas registradas o

marcas de servicios de otros.
Trademarks of International Business Machines Corporation
DB2 Informix
Lotus Script Net.data
Marcas Registradas de otras Compañías
Windows, Microsoft Visual Studio Microsoft Corporation
Sybase Sybase Inc.
Edición Agosto 2007
La información contenida en este documento no ha sido sometida a ninguna prueba

formal de IBM y es distribuida básicamente “como es" sin ninguna garantía ya sea
expresa o implícita. El uso de esta información o la implementación de cualquiera de
estas técnicas es responsabilidad del comprador y dependerá de la habilidad de éste
para su evaluación e integración en el ambiente operacional del comprador. A pesar de
que cada tema ha sido revisado por IBM para su exactitud en una situación específica,
no hay garantía de que obtener el mismo resultado o uno similar a éste en otra
situación. Los compradores que intenten adaptar estas técnicas a sus propios
ambientes lo hacen bajo su propio riesgo.
Copyright International Business Machines Corporation, 2007. All rights reserved.

Este documento no puede ser reproducido en su totalidad o en parte sin el previo
permiso escrito de IBM.
Instrucciones Especiales para la Impresión de este Curso:
No elimine páginas en blanco que puedan aparecer al final de cada unidad ó entre
unidades. Estas páginas fueron insertadas intencionalmente.
.
Guía del Estudiante Fundamentos de Programación
Contenido
Descripción del Curso........................................................................................1
Descripción de Unidades ...................................................................................2
Volumen 1: Conceptos de Programación .........................................................5
Unidad 1: Programas de Computadora ............................................................7
Objetivos del Aprendizaje 7
1. Introducción 8
2. Sistemas de Procesamiento 9
3. Algoritmos 9
4. Metodología para Diseñar Algoritmos 9
5. Programas de Computadora 10
6. Definiciones Básicas 11
7. Crear un Programa de Computadora 12
8. Funcionamiento del Compilador/Enlazador 13
9. Datos, Tipos de Datos y Funciones Incorporadas 14
10. Expresiones: Tipos y Operadores 17
11. Funciones Incorporadas 22
12. Operación de Asignación 23
13. Recomendaciones 24
Resumen 25
Unidad 1: Examen de Autoevaluación 26
Respuestas de la Unidad 1: Examen de Autoevaluación 28
Unidad 2: Conceptos de Diseño Estructurado...............................................29
1. Introducción 30
2. Conceptos de Diseño Estructurado 30
3. Diseño Top Down 30
4. Diagramas de Estructura 32
5. Diagramas de Flujo o Flujograma 32
6. Recomendaciones para hacer Diagramas de Flujo 36
7. Ejemplo de un Diagrama de Flujo 36
8. Diagramas N-S o de Nassi-Schederman: 37
9. Pseudocódigo 39
Resumen 41
i
© Copyright IBM Corp. 2007
Los materiales del curso no pueden ser reproducidos total o
parcialmente sin el previo permiso escrito de IBM.
Fundamentos de Programación Guía del Estudiante

Respuesta de la Unidad 2: Examen de Autoevaluación 44
Unidad 3: Programación Estructurada ...........................................................45
1. Introducción 46
2. Estructuras Secuenciales 46
3. Estructuras Selectivas 47
4. Estructuras Repetitivas o de Ciclo 49
5. Estructuras Anidadas 52
6. Control de Datos de Entrada 54
Resumen 57
Respuestas de la Unidad 3: Examen de Autoevaluación 60
Unidad 4: Funciones y Procedimientos..........................................................61
1. Introducción 62
2. Funciones 63
3. Procedimientos 67
4. Ámbitos: Variables Globales y Locales 69
5. Comunicación entre Subprogramas: Paso de Parámetros 71
6. Recursividad 75
Resumen 78
Unidad 5: Estructura de Datos: Arreglos........................................................83
1. Introducción 84
2. Arreglos Unidimensionales: Arreglos o Vectores 84
3. Arreglos Bidimensionales: Matrices m x n 89
4. Arreglos Multidimensionales: Matrices m x n x...z 91
5. Almacenamiento de Arreglos en Memoria 91
Resumen 93
Unidad 6: Entrada y Salida...............................................................................97
ii

1. Introducción 98
2. Entrada y Salida de un Programa 98
3. Buffers de Entrada y Salida 99
4. Imprimir Datos 100
5. Entrada/Salida de Archivo: Formatos de Registros 103
Resumen 107
Unidad 7: Ejemplos de Programas................................................................111
1. Verificar la Secuencias 112
2. Rupturas de Control 112
3. Emparejar Transacciones 113
Resumen 117
Volumen 2: Complementos I..........................................................................119
Unidad 1: Sentencias Simples .......................................................................121
1. Conceptos 121
Ejercicios Resueltos 123
Ejercicios por Resolver 129
Unidad 2: Estructuras de Decisión................................................................131
1. Conceptos 131
Unidad 3: Estructuras de Repetición ............................................................141
1. Conceptos 141
Ejercicios Propuestos 148
Unidad 4: Sentencias Simples (Pseudocódigo) ...........................................149
Unidad 5: Estructuras de Decisión (Pseudocódigo)....................................153
Unidad 6: Estructuras de Repetición (Pseudocódigo) ................................161
iii

Volumen 3: Complementos II.........................................................................169
Unidad 4: Funciones y Procedimientos........................................................171
Unidad 5: Estructuras de Datos - Arreglos...................................................179
Volumen 4: Ejercicios Propuestos ................................................................189
Unidad 1: Programas de Computadora ........................................................191
Respuestas de la Unidad 1: Ejercicios Propuestos 192
Unidad 2: Conceptos de Diseño Estructurado.............................................193
Respuestas de la Unidad 2: Ejercicios Propuestos 194
Unidad 3: Programación Estructurada. ........................................................197
Respuesta Unidad 3: Ejercicios Propuestos 198
Unidad 4: Procedimientos y Funciones ........................................................203
Unidad 5: Estructura de Datos: Arreglos......................................................207
iv
Descripción del Curso

Nombre del Curso
Fundamentos de Programación.
Duración
La duración del curso es de 40 horas.
Propósito
El propósito de este curso es introducir los fundamentos de programación, para ello se
estudian los elementos del proceso de desarrollo de aplicaciones que se ejecutan en las
computadoras. El curso, cubre los conceptos de programa, estructura de datos, tipos de
datos, variables y constantes. También, se discuten algunas técnicas para desarrollar
algoritmos, que se implementan en la programación estructurada, así como, los
elementos estándar de un programa de aplicación de computadora.
Audiencia
Cualquier persona que desee obtener un conocimiento básico acerca de los
fundamentos de la programación.
Pre-requisitos
Ninguno.
Objetivos del Curso
Después de completar este curso, usted estará en la capacidad de:

• Crear la lógica básica de un programa.
• Conocer los pasos básicos necesarios para ir desde el diseño de un programa
hasta su ejecución.
• Describir los componentes básicos de la configuración de una computadora.
Agenda
Cada unidad de este curso es de dos horas académicas de duración.
Libro 1: Fundamentos de Programación Descripción del Curso 1

Descripción de Unidades
Volumen 1: Conceptos de Programación
Unidad 1: Programas de Computadora
En esta unidad se define el propósito y el contenido de un programa de computación y
se aprende una metodología para resolver problemas de procesamiento de datos. Se
discuten los elementos de un programa, para ello se estudian los conceptos de
variables, variables contadoras, variables acumuladoras, constantes, los operadores
aritméticos y operadores lógicos. Se estudian las operaciones incorporadas y se
discuten algunos de los errores más comunes que se cometen en la programación. Se
presentan también, algunas sugerencias para programar con estilo y disciplina.
Unidad 2: Conceptos de Diseño Incorporado
Aquí se definen los conceptos utilizados para facilitar el entendimiento de un problema.

Se utilizan técnicas Top-Down (de abajo hacia arriba) y se aprende cómo dibujar
gráficos que muestran la jerarquía de un problema, y así poder, a partir de estos
gráficos, analizar el problema, crear los diagramas de flujo y el pseudocódigo necesario
para comenzar a escribir un programa de computación. Se discuten los Diagramas de
Estructura, los Diagramas de Flujo, los Diagramas N-S o de Nassi-Schederman, así
como los conceptos y elementos del pseudocódigo.
Unidad 3: Programación Estructurada
Se describen los conceptos relacionados con las estructuras de los bloques de código
que conforman un programa de computadora bajo el concepto de Programación
Estructurada. Se revisan las estructuras secuenciales, las selectivas o de bifurcación
para direccionar el flujo de control. También, se estudian las estructuras de bloques de
código para ciclos o repeticiones, en conjunto con las capacidades de anidamiento de
bloques de código. Por último, se muestran algunos casos del uso de las estructuras de
control y repetición en la entrada de datos.
Unidad 4: Funciones y Procedimientos
En esta unidad, se estudia el concepto de funciones y procedimientos. Se describe la

sintaxis y el uso de los procedimientos y funciones como parte de un programa de
computadora. Se analiza el ámbito de las variables, la invocación de funciones y
procedimientos desde un programa, así como la comunicación entre subprogramas o
pase de parámetros o argumentos. Por último, se revisa el concepto de recursividad,
además de cómo se definen y usan las funciones y procedimientos recursivos.
Descripción de Unidades Libro 1: Fundamentos de Programación 2

Unidad 5: Estructura de Datos: Arreglos
Se estudian las estructuras de almacenamiento continuo y su representación en la

memoria del computador. Se revisan los conceptos de arreglos unidimensionales o
vectores, matrices de dos dimensiones y matrices multidimensionales.
Unidad 6: Entrada y Salida
Esta unidad presenta la descripción de los conceptos básicos de entrada y salida en un

programa de computadora, tomando en cuenta algunas consideraciones específicas
para imprimir una salida. Se describen los conceptos de registros de datos fijos, variable
y bloqueado. Se finaliza con la creación del diseño de un programa que permite manejar
encabezados de página.
Unidad 7: Ejemplos de Programas

Esta unidad está diseñada para reforzar los conceptos presentados en las unidades
anteriores. Se presentan ejemplos que permiten diseñar programas para manejar la
verificación de secuencias y rupturas de control, así como para resolver problemas de
emparejamiento de transacciones.
Volumen 2: Complementos I
Unidad 1: Sentencias Simples
En esta unidad se aprecia cómo se realiza la Declaración de Variables, Asignación de
Variables, Lectura de Variables desde un dispositivo de entrada de datos hacia la
memoria, Escritura de Datos desde la memoria hacia un dispositivo de salida, todo esto
con su respectiva notación de Diagramas de Flujo o Flujogramas. También se
presentan una serie de Ejercicios Resueltos aplicando la técnica de Diagrama de Flujo o
Flujograma.
Unidad 2: Estructuras de Decisión

Aquí se visualiza la aplicación de los tres tipos de Estructuras de Decisión: simple,
dobles y múltiples. Denotando el concepto de cada una de ellas y aplicando estas bajo
la técnica de Flujograma o Diagrama de Flujo.
Unidad 3: Estructuras de Repetición

Se describen los conceptos relacionados con las estructuras de Repetición: Ciclo
Mientras.. Hacer (while .. do), Ciclo Repetir .. Hasta (Repeat ..until), Ciclo Desde (for);
aplicando cada uno de ellos bajo la técnica de Flujograma o Diagrama de Flujo.
Unidad 4: Sentencias Simples (Pseudocódigo)
En esta unidad se aprecia cómo se realiza la Declaración de Variables, Asignación de
Variables, Lectura de Variables, así como la estructura básica de un algoritmo
Libro 1: Fundamentos de Programación Descripción de Unidades 3

representada bajo la técnica de Pseudocódigo. También se presentan una serie de

Ejercicios Resueltos aplicando la técnica de Pseudocódigo.
Unidad 5: Estructuras de Decisión (Pseudocódigo)
Aquí se visualiza la aplicación de los tres tipos de Estructuras de Decisión: simple,
dobles y múltiples. Denotando el concepto de cada una de ellas y aplicando estas bajo
la técnica de Pseudocódigo.
Unidad 6: Estructuras de Repetición (Pseudocódigo)

Se describen los conceptos relacionados con las estructuras de Repetición: Ciclo
Mientras.. Hacer (while .. do), Ciclo Repetir .. Hasta (Repeat ..until), Ciclo Desde (for);
aplicando cada uno de ellos bajo la técnica de Pseudocódigo.
Volumen 3: Complementos II
Aquí se presentan una serie de ejercicios resueltos aplicando la técnica de
Pseudocódigo, empleando los conceptos de Funciones y Procedimientos que permite
visualizar su aplicación.
Unidad 2: Estructuras de Datos - Arreglos
En esta unidad se aprecia la representación de Arreglos unidimensionales y

bidimensionales por medio de ejercicios resueltos, utilizando la técnica de
Pseudocódigo.
Volumen 4: Ejercicios Propuestos

Desde la Unidad 1 hasta la Unidad 5, se presenta una variedad de ejercicios
correspondientes a los conceptos manejados por cada unidad, que han sido resueltos
para mayor comprensión. En la mayoría de los casos se aplica la técnica de
Pseudocódigo para el diseño de algoritmos, en otro caso una descripción comprensible
de la solución del problema como se puede visualizar en la resolución de los ejercicios
para la Unidad 1.
Descripción de Unidades Libro 1: Fundamentos de Programación 4

Volumen 1: Conceptos de Programación
Libro 1: Fundamentos de Programación Descripción de Unidades 5


Objetivos del Aprendizaje
Al finalizar esta unidad, usted será capaz de:
• Definir el propósito y el contenido de un programa de computadora.
• Establecer una metodología para resolver problemas de procesamiento de
datos.
• Definir el concepto de dato, los tipos de datos y las funciones incorporadas a los
lenguajes de programación.
• Enumerar las recomendaciones más comunes necesarias para programar con
estilo.
Unidad 1: Programas de Computadora Libro 1: Fundamentos de Programación 7

El material del curso no puede ser reproducido total ni
parcialmente sin el permiso escrito previo de IBM.
1. Introducción
En la actualidad es común contar con la ayuda de las computadoras para la solución de
problemas. Para casi cualquier problema típico en las áreas de negocios, servicios y
tecnologías, entre otras, la solución puede ser modelada con programas de
computadora, esta solución es generalmente más confiable y de menor costo.
Los programas de computadora permiten dar solución a problemas de cualquier nivel,

estas soluciones típicamente llamadas aplicaciones, las realiza un equipo
multidisciplinario donde se encuentran los programadores, diseñadores y analistas de
sistemas, entre otros especialistas.
Generalmente, los programadores utilizan algún lenguaje de programación para

desarrollar las aplicaciones requeridas por los clientes. Estos lenguajes de
programación sirven como puente de enlace entre el análisis realizado por el equipo de
desarrollo y la capacidad de cálculo que ofrece la computadora. En otras palabras, por
medio del lenguaje de programación, el programador le indicará al computador la
secuencia de instrucciones que se deben ejecutar para obtener la solución esperada
por los clientes.
Todo esto hace pensar que de alguna manera, un programador debe tener cierta lógica
que le ayude a tratar con el lenguaje de programación, esto es, debe saber
exactamente las capacidades brindadas por el lenguaje de programación y más aún,
debe tener nociones claras de los fundamentos generales de la programación.
Como cualquier ciencia, la programación requiere de una serie de conocimientos

básicos comunes a cualquier lenguaje de programación, que le permitan al programador
indicarle inequívocamente al computador las tareas que éste debe realizar. Dichos
conocimientos básicos son conocidos como Fundamentos de Programación, los cuales
no son más que un conjunto de reglas, técnicas y conceptos que ayudan a definir lo que
se puede hacer con un lenguaje de programación y así dar los primeros pasos para
desarrollar aplicaciones para la solución de problemas computacionales.
Este curso introduce al estudiante a los fundamentos de la programación de manera

breve y concisa. Se discuten diversos temas, tales como: ¿qué son los programas de
computadora?, el diseño estructurado, la lógica de programación, diagramas de flujos,
pseudocódigo, entrada y salida, entre otros.
Para desarrollar programas de computadora existe una gran variedad de lenguajes de

programación, por esta razón, fue necesario definir una notación genérica que
permitiera, en primer lugar, representar y describir el problema de forma clara y sencilla.
Esta representación se obtiene con el uso de algoritmos, los cuales permiten definir una
secuencia finita de pasos claros y sencillos, para obtener una solución del problema.
El proceso para desarrollar programas de computadora requiere entender y conceptuar

el problema, para luego definir los aspectos importantes acerca de la entrada, salida y
almacenamiento.
Libro 1: Fundamentos de Programación Unidad 1: Programas de Computadora 8

En esta unidad se discuten los conceptos básicos más importantes de la programación

y la metodología para desarrollar una solución computacional de un problema.
2. Sistemas de Procesamiento
Un ordenador es una máquina de procesamiento de información. Es una máquina,
porque tiene cables, circuitos y demás elementos mecánicos. Es además de
procesamiento, porque es capaz de transformar o procesar datos y de información
porque maneja conjuntos ordenados de datos.
Para procesar la información se requiere del hardware como microprocesador, memoria

RAM, entre otros y del software que sirve para manejar el hardware tal como
programas, sistema operativo, etc.
3. Algoritmos
El concepto de algoritmo fue desarrollado por el matemático persa Abu Jafar
Mohammed Ibn Musa Al Khwarizmi. Se puede decir que un algoritmo es una fórmula
para resolver un problema. Es un conjunto de acciones o secuencia de operaciones que
ejecutadas en un determinado orden, resuelven el problema planteado.
Un algoritmo debe tener las siguientes características:

• Estar bien definido.
• Ser preciso.
• Ser finito.
Básicamente, un algoritmo es un proceso metódico que define una serie finita de pasos
sencillos y sin ambigüedades para la solución de un problema.
La programación consiste en adaptar el algoritmo al ordenador. El algoritmo es

independiente de la implementación en algún lenguaje de programación.
4. Metodología para Diseñar Algoritmos

Un algoritmo es una fórmula para obtener la solución de un problema, ésta fórmula
puede ser planteada de diferentes formas y cada una de estas formas puede
efectivamente resolver el problema planteado. Por esa razón, el diseño de un algoritmo
es un proceso creativo, ya que no existe un conjunto de reglas que indiquen
expresamente cómo escribir un algoritmo en forma correcta, por el contrario, si existen
muchas maneras de resolver un problema, entonces existen muchos algoritmos que
implementen la solución.
Sin embargo, hay una serie de pasos que permiten resolver un problema de la forma
más conveniente, estos son:
• Análisis del problema.

• Diseño del algoritmo.

• Verificación del algoritmo.
Análisis del Diseño del Verificación

Problema Algoritmo del Algoritmo
Figura 1.1: Metodología de Diseño de Algoritmos
1.1 Análisis del Problema
El primer paso es identificar el problema. Se debe revisar cuidadosamente el problema

para determinar qué tipo de información se necesita producir como salida. Luego se
identifica toda la información que se necesita para encontrar la solución. En otras
palabras, es importante considerar lo que se está pidiendo en el problema, con qué
elementos se cuenta y cuáles se deben solicitar para establecer el camino a seguir en
la solucionar el problema. Luego de obtener todos estos datos, se inicia la fase de
Diseño del Algoritmo.
1.2 Diseño del Algoritmo
En esta fase, la solución del problema puede requerir varios pasos, así que es
necesario buscar la manera más fácil para simplificar la propuesta. Una forma de
hacerlo, es identificar los procesos más importantes y colocarlos en orden ascendente
según su importancia y precedencia, esto sirve como un algoritmo inicial.
Este algoritmo inicial podrá ser refinado en sucesivas operaciones, hasta obtener una
solución más detallada y más fácil de traducir a un lenguaje de programación.
1.3 Verificación del Algoritmo
Cuando el algoritmo está listo, es necesario comprobar que cumple con los procesos
ideados y produce el resultado esperado. Una manera de hacerlo, es por medio de la
ejecución manual, que consiste en realizar una prueba del algoritmo con datos
significativos y comprobar que al ejecutar todos los procesos se obtienen los resultados
esperados para la salida.
5. Programas de Computadora
Un programa es un conjunto de instrucciones que ejecutadas ordenadamente resuelven
un problema, en otras palabras es la implementación del algoritmo. Un programa de
computadora es una secuencia de instrucciones que le indican al computador que
realice operaciones específicas para lograr un resultado deseado. Consiste de uno o
más módulos o rutinas, cada uno de los cuales puede estar compuesto a su vez de
otros módulos o subprogramas. Un programa de computadora no es:
• Una caja mágica.

• Intrínsicamente correcto.
Un programa de computadora debe ser:
• Una solución a un problema.
• Una secuencia de instrucciones hechas para ejecutarse en una computadora.
• Sólo tan correcto como el programador lo haya hecho.
En resumen, un programa de computadora es un conjunto de instrucciones generadas
por el programador, que le dicen al computador exactamente lo que debe hacer.
6. Definiciones Básicas
A continuación se presentan un conjunto de definiciones básicas que se usan en el
entorno de un programa de computadora:
Lenguaje de Máquina: es un lenguaje que puede ser interpretado directamente por los
circuitos internos de la computadora porque está basado en instrucciones compuestas
por secuencias de ceros (0) y unos (1).
Ventajas:
• No necesita ser traducido puesto que la máquina lo entiende.
• Opera directamente con la máquina.
• Puede llegar a ser muy eficiente en el manejo de recursos.
Desventajas son:
• Extremadamente difícil de aprender, implementar y mantener.
• Es único y particular para cada procesador.
Lenguaje de Bajo Nivel (Ensamblador): es un lenguaje que usa el programador para
codificar sentencias simbólicas que un compilador (programa traductor) puede convertir
una a una en instrucciones de lenguaje de máquina. Hace uso de mnemotécnicos o
abreviaturas, para representar las instrucciones de máquina.
Ventajas:
• No es tan complicado como el lenguaje de máquina.
• Eficiente en el manejo de recursos.
Desventajas son:
• Cada procesador tiene su propio juego de instrucciones en ensamblador.
• Debe ser traducido (ensamblado).
Lenguaje de Alto Nivel: es un lenguaje de programación orientado al problema o
procedimientos, es cercano al idioma humano. Ejemplos de estos lenguajes son
COBOL, PL/I, FORTRAN, Java, etc.

Algunos lenguajes de alto nivel se denominan Lenguajes de Programación Orientado a

Objetos (ó OOPL). Ejemplos de éstos son: Smalltalk, Java, C++, Eiffel, etc.
Ventajas:
• Son independientes del procesador.
• Son mucho más fáciles de aprender, implementar y mantener.
• Tienen un carácter genérico.
Desventajas son:
• Menos eficientes en el manejo de los recursos.
• Requiere de un proceso de traducción (compilación).
Compilar: Es traducir un programa escrito en un lenguaje de alto nivel a un programa
en lenguaje de máquina, que es la forma en que la computadora puede ejecutar
directamente las acciones o instrucciones. Típicamente una instrucción de alto nivel se
compila o traduce, en muchas instrucciones de lenguaje de máquina.
En algunos casos, el proceso de compilación se descompone en dos pasos:

• Compilar las instrucciones de alto nivel para producir lo que se denomina el
código objeto.
• Enlazar (link) que es tomar el código objeto generado y cualquier otro código
objeto que sea requerido, que haya sido previamente generado y colocarlos
juntos, produciendo así el programa ejecutable o código ejecutable.
Base de Datos: Es una colección de datos completa e integrada, organizada para
evitar duplicados, que permite recuperar información para satisfacer a una amplia
variedad de usuarios.
Sistema Operativo: Es una colección organizada de software que se usa para ayudar y
controlar las operaciones de una computadora.
Almacenamiento: Se refiere a un dispositivo en el que los datos se pueden ingresar,

guardar y posteriormente recuperar.
7. Crear un Programa de Computadora

Para crear un programa de computadora, generalmente el programador debe partir de
un algoritmo y escribir las sentencias (instrucciones) del código fuente en un editor. Un
editor es un programa utilitario que permite la edición de textos y programas. Existen
muchos editores que están diseñados específicamente para ayudar en la creación del
programa fuente. Algunos incluso siguen la especificación de un lenguaje particular.
El conjunto de sentencias fuente se denomina un “programa fuente”. El programa fuente

es la entrada para el compilador, que lo convierte en un conjunto de comandos
entendibles por el computador llamado “programa ejecutable.”

Si se encuentra algún error en la sintaxis de los comandos en el programa fuente, el

compilador listará cada uno de ellos y no producirá el programa ejecutable. El
programador debe repetir los pasos de editar/compilar hasta que no se encuentren
errores de compilación.
La Figura 1.2 presenta en forma esquemática los pasos para crear un programa de
computadora.
Figura 1.2: Creación de un Programa de Computadora
8. Funcionamiento del Compilador/Enlazador

Previo a la creación del programa ejecutable, el compilador, si no detecta errores de
sintaxis, crea un programa objeto y un listado del programa fuente. La Figura 1.3
muestra la creación del programa ejecutable, partiendo del programa fuente, con un
paso de enlace (link) involucrado.
El programa objeto, producido por el compilador, se usa como la entrada al enlazador

para realizar lo que se llama el paso de “edición de enlace”. El enlazador, combina el
programa objeto recién creado con otros programas objeto ya existentes, produciendo

el programa ejecutable. Los otros programas objeto generalmente residen en un archivo

en disco llamado “Librería de Enlace”.
Programa Librerías de
Compilación Objeto enlace
Programa Compilación
fuente
Compilador Enlazador
Programa
Ejecutable
Enlace
Figura 1.3: Compilador / Enlazador
9. Datos, Tipos de Datos y Funciones Incorporadas

Un programa de computadora, para que pueda ser ejecutado, debe ser cargado en
memoria. La unidad de procesamiento del ordenador sólo puede trabajar con los datos
e instrucciones que residen en la memoria.
9.1 Dato
El dato es cualquier objeto o elemento de información que se usa a lo largo de diversas

operaciones dentro de un programa o fragmentos de éste. Los datos son los elementos
sobre los que se opera cuando se efectúa una operación en el computador, es decir,
cuando se ejecuta una instrucción en un programa.
Un dato tiene un nombre que lo identifica y distingue de los demás elementos del
programa. Dicho nombre no es más que otra forma de referenciar la dirección de
memoria que ocupa el dato, así que cuando se trabaja con el nombre del dato, en
realidad se trabajar con el valor que se encuentra en esa dirección de memoria.
Cuando se está trabajando con un programa de computadora, siempre se está

trabajando con direcciones de memoria, es por ello que es una estrategia común
referenciar esas posiciones de memoria por medio de nombres o identificadores
significativos para los humanos. En otras palabras, un programa de computadora es
una serie de instrucciones organizadas para manipular y trabajar con direcciones de
memoria en un computador.
Los datos pertenecen a un tipo de dato específico, lo cual le indica al computador el

rango de valores que dicho dato puede aceptar y las operaciones que sobre él se
pueden realizar.

Por último, los datos poseen un valor que bien puede cambiar o permanecer constante
a lo largo del programa o mientras el dato esté disponible.
9.2 Tipo de Dato
El tipo de dato es una definición que agrupa los valores válidos para un conjunto de
datos y las operaciones que sobre ellos se pueden realizar. Normalmente, se puede
establecer una relación de orden sobre los datos de naturaleza escalar o con valores
determinísticos.
Cada tipo de dato tiene una representación determinada en el computador. Esto tiene
que ver con el tamaño o la cantidad de memoria que el computador reserva para
almacenar los datos de un tipo especifico cualquiera. Todo, absolutamente todo, en la
memoria de un computador se representa por medio de código binario, un código
binario es un número en base 2, cuyos dígitos son ceros o unos. De esta manera, un
código cualquiera puede ser tratado como un número entero en un momento dado,
como un carácter en otro o en cualquier otra forma diferente de acuerdo a las
necesidades del programa.
Los tipos de datos pueden ser:

• Tipo dato primitivo: Tipos básicos o simples predefinidos en el sistema.
• Tipo de dato definidos por el usuario: Agregados por el programador.
Los tipos de datos primitivos más importantes son: numéricos, lógicos y carácter. A
continuación se detalla cada uno de ellos:
• Numéricos: Pueden ser a su vez:
- Entero: Subconjunto finito del conjunto matemático de los números enteros. No
tiene parte decimal. El rango de los valores depende del tamaño que se les
asigne en la memoria para su representación, este tamaño es definido por el
lenguaje de programación, usualmente 2 bytes.
- Real: Subconjunto finito del conjunto matemático de los números reales. Llevan
signo y parte decimal. Se almacenan usualmente en 4 bytes o más
(dependiendo del lenguaje de programación que se utilice). Si se utilizan
números reales muy grandes, se puede usar notación científica que se divide
en mantisa, base y exponente. De tal forma que el valor se obtiene
multiplicando la mantisa por la base elevada al exponente.
• Lógicos o booleanos: Es aquel que sólo puede tomar uno de los dos valores,
verdadero o falso (1 ó 0). Este es el tipo de dato que retorna todas las
operaciones lógicas.
• Carácter: Abarca al conjunto finito y ordenado de caracteres que reconoce la
computadora: letras, dígitos, caracteres especiales, ASCII, UNICODE.
Generalmente, sus valores se representan dentro de un par de comillas simples,
aunque también se puede suministrar su código numérico o posición dentro del
conjunto de caracteres válidos que se esté usando.

• Tipo cadena o string: Conjunto de caracteres, que usualmente se presentan

entre los símbolos de comilla doble (“”).
Los diversos lenguajes existentes pueden añadir más tipos de datos u otros
modificadores. Por ejemplo, el modificador Long se usa comúnmente con los tipos
entero (int) para indicar un entero de gran tamaño (Long int).
En algunos lenguajes se definen tipos especiales para la fecha y hora, sobre todo en los
lenguajes modernos, tales como Java.
9.3 Variables
Las variables son instancias de un tipo de dato determinado, cuyo valor puede cambiar
durante la ejecución del programa o corrida del algoritmo.
Antes de usar una variable, el programador debe definirla o declararla, indicando su

nombre y el tipo de dato al que pertenece.
El nombre que se elija para una variable se denomina identificador y debe ser un
nombre significativo que esté relacionado con el propósito para el que se vaya a usar la
variable en el programa.
El identificador de una variable será un conjunto de caracteres que tendrán ciertas

restricciones, según lo defina el lenguaje de programación. Por lo general, el
identificador de una variable tiene que empezar por una letra, el tamaño y caracteres
permitidos como parte del identificador dependen del lenguaje de programación.
Algunos lenguajes de programación asignan un valor por omisión o defecto a las

variables, al momento de su declaración. En cualquier caso una variable puede tomar
un valor inicial e ir cambiándolo a lo largo de la ejecución del programa o corrida del
algoritmo. Al momento de asignar un valor inicial a una variable, se le denomina
inicialización de la variable.
9.4 Variables Acumuladoras
Aquellas variables que el programador use para ir sumando valores a lo largo de la

ejecución del programa, se denominan acumuladoras y es recomendable inicializarlas
con un valor conveniente al uso que posteriormente se les dé.
9.5 Variables Contadoras
Se llaman así a las variables que el programador usa para ir contando a lo largo de la
ejecución del programa.
9.6 Constantes
Las constantes son instancias de un tipo de dato determinado, que tienen un valor fijo
asignado por el programador en el momento en que la define. Este valor no puede ser
modificado durante la ejecución del programa o corrida del algoritmo.

Las constantes pueden llevar asociados un nombre o no, si no lo llevan, se llaman

literales. El programador especifica su valor al definir la constante, que ya no puede
cambiar a lo largo de la ejecución del programa. En cuanto al tipo de dato, hay que
colocarlo o no dependiendo del lenguaje de programación. Si no hace falta colocarlo, es
porque la constante tomará el tipo de dato del valor que se le asigne al definirla.
Por ejemplo: Const PI=3,1416.
La ventaja de usar constantes con nombre, es que en cualquier lugar donde quiera que
vaya la constante, basta con colocar su nombre y luego el compilador lo sustituirá por su
valor.
Las constantes sin nombres o literales son de valor fijo: 5, 6, ‘a’, “hola”.
9.7 Relación entre Variables y Constantes en Memoria
Al declarar una variable o constante con nombre, automáticamente se reserva en

memoria espacio para guardarla. El espacio reservado depende del tipo de dato de la
variable o constante. En esa zona de memoria, es en la que se guardará el valor
asociado a la variable o constante. Cuando el programa use esa variable o constante,
irá a ese lugar de la memoria a buscar su valor.
10. Expresiones: Tipos y Operadores

Una expresión es una combinación de constantes, variables, signos de operación,
paréntesis y nombres especiales (nombres de funciones estándar), con un sentido
unívoco y definido. De la evaluación de una expresión resulta un único valor o resultado.
Una expresión tiene asociado un tipo de dato que corresponde con el tipo del valor que
devuelve la expresión cuando se evalúa, por lo que habrá tantos tipos de expresiones
como tipos de datos. En tal sentido, se tienen expresiones numéricas y lógicas.
10.1 Expresiones Numéricas: Operadores Aritméticos
La expresión numérica es una combinación de variables y constantes numéricas con

operadores aritméticos, que al evaluarla devuelve un valor numérico.
Algunos de los operadores aritméticos más comunes son: +, -, *, / , los cuales equivalen
a las operaciones suma, resta, multiplicación y división respectivamente.
Otras operaciones aritméticas soportadas en algunos lenguajes de programación son:

• Operador Resto o Módulo: Devuelve el resto de una división entera.

Lenguaje Operador Ejemplo Resultado

C % 5%2 1
Pascal mod 5 mod 2 1
Tabla 1.1: Operador Resto o Módulo
• Operador División Entera: Devuelve la parte entera del cociente de una

división.

C / 5/2 2
Pascal Div 5 div 2 2
Tabla 1.2: Operador División Entera
• Operador Potencia: Devuelve el valor de una base elevada a una potencia

dada.
Basic ^ 5^2 25
Tabla 1.3: Operador Potencia
Los operadores anteriores se denominan operadores binarios porque utilizan dos

operando. Existen también otros tipos de operadores que sólo necesitan de un
operando y se denominan operadores unarios.
Algunos de los operadores unarios más comunes son:

• El signo negativo: Operador unario que devuelve el valor actual del operando
multiplicado por menos uno (-1).

C - X= 5; -X; X= -5;
Tabla 1.4: Signo Negativo
• Operador Decremento: Operador unario que devuelve el valor actual del

operador decrementado en una unidad.


C -- X= 5; --X; X= 4;
• Operador Incremento: Operador unario que devuelve el valor actual del

operador incrementado en una unidad.

C ++ X= 5; ++X; X= 6;
10.2 Reglas de Precedencia
El orden en que se evalúan los operadores aritméticos dentro de una expresión influye
directamente en el resultado que retorna dicha expresión.
Ejemplo:
Sea la siguiente expresión aritmética: 2 + 3 * 2 + 3
Si se evalúa en el orden de aparición se tiene: (((2 + 3) * 2) + 3) = 13
Si se evalúa primero la suma (+) y luego la multiplicación (*) se tendrá la expresión:
(2 + 3) * (2 + 3) = 25
Si se evalúa primero la multiplicación y luego la suma se tendrá la expresión:
2 + (3 * 2) + 3 = 11
Entonces, ¿Cómo resolver está situación potencialmente problemática?
La solución es aplicar prioridad entre los operadores, de modo que ante la posibilidad
de usar varios operadores aritméticos en una misma expresión, siempre se aplicará
primero el de mayor prioridad.
Cada lenguaje de programación puede establecer sus propias reglas de prioridad o

precedencia de operadores. Siempre se pueden utilizar los paréntesis ( ) para definir y
cambiar el orden en que se evalúa una expresión aritmética dada.
El orden de precedencia definido comúnmente para los operadores aritméticos básicos

es:
1. ^

2. *, /, div y mod
3. + y –
Entre dos operaciones que tienen la misma precedencia, para resolver la ambigüedad
hay que usar la regla de la asociatividad. La más normal, es la asociatividad por la
izquierda (primero lo de la izquierda).
De esta forma, la expresión 2+3 * 2 / 3 – 5 ^ 2 será evaluada como (2 + ((3 * 2) / 3)) – (5

^ 2).
10.3 Expresiones Lógicas: Operadores Relacionales y Lógicos.
Una expresión lógica es aquella que sólo puede devolver uno de dos valores: verdadero
o falso. Los operadores que pueden aparecer en una expresión lógica son de dos tipos:
lógicos o relacionales. Los operadores lógicos sólo trabajan sobre expresiones o datos
que retornan valores booleanos. Los operadores relacionales trabajan con expresiones
numéricas para realizar comparaciones que retornan un valor booleano. Es común tener
expresiones que combinan tanto los operadores lógicos como relacionales, en estas
expresiones se evalúa más de una condición o relación por medio de operadores
lógicos.
Los operadores relacionales más usados son:
< menor que

> mayor que
= igualdad (en C: ==)
<> diferente (en C: !=)
≤ menor o igual que
≥ mayor o igual que
Para evaluar una expresión relacional:
• Se evalúa el primer operando y se sustituye por su valor.
• Se evalúa el segundo operando y se sustituye por su valor.
• Se aplica el operador relacional y se devuelve el valor booleano correspondiente.
Ejemplo:
((5 * 4) + 1 – (5 ^ 2)) < (2 - 1)
-4 < 1 la expresión retorna Verdadero
Ejercicio:
Evaluar las siguientes expresiones si a la variable “x” se le asigna el valor 2 y a la
variable “y” se le asigna el valor 4.
Cada respuesta debe ser VERDADERO o FALSO, según corresponda:

1. x == y : ___________
2. x <> y : ___________
3. y > x : ___________
4. x >= y : ___________
El problema es que en algunos casos se requiere preguntar o evaluar más de una
condición al mismo tiempo, para esto, están los operadores lógicos.
Los operadores lógicos más utilizados son:
Y (and, &&)
O (or, ||)
No (not, ~, !)
O exclusivo (xor, ^)
Y, O y O exclusivo son operadores binarios.
Estos operadores trabajan bajo el esquema: <Operando 1> Operador <Operando 2>
El operador No es de tipo unario y se coloca precediendo al operando al que se niega.
La tabla de verdad para los operadores lógicos binarios es como sigue:
Operando 1 Operando 2 AND OR XOR

V V V V F
V F F V V
F V F V V
F F F F F
V= Verdadero; F= Falso
Tabla 1.5: Tabla de Verdad para los operadores lógicos binarios
La tabla de verdad para el operador unario No es como sigue:
NOT Operando
V F
F V
Tabla 1.6: Tabla de Verdad para el operador unario “No”

Se observa que para que el operador lógico AND sea Verdadero, es necesario que
ambos operandos sean Verdaderos.
Para que el operador lógico OR sea Verdadero, basta con que al menos uno de sus
operandos sea Verdadero.
Para que el operador XOR sea Verdadero, ambos operandos deben ser diferentes entre
sí.
Ejercicio:
Si x representa “1 > 2” (FALSO) e y representa “4 < 8” (VERDADERO)
Cuál es el resultado de cada una de las siguientes expresiones:
1. NOT x : ___________
2. x AND y : ___________
3. y OR x : ___________
4. (NOT x) AND y : ___________
5. x XOR y : ___________
11. Funciones Incorporadas

Las funciones Incorporadas son funciones adicionales a las operaciones básicas, que
se incorporan al lenguaje de programación. Se consideran estándar en la mayoría de
lenguajes de programación. Son dependientes del lenguaje y normalmente se
encuentran en librerías externas que se pueden incluir en un programa. La sintaxis
exacta y el nombre de las funciones pueden variar de un lenguaje a otro, pero la
funcionalidad suele mantenerse entre las diversas herramientas de programación.
Las más comunes son las librerías de soporte matemático y las de entrada / salida.
Todos los lenguajes de programación proporcionan mecanismos para incorporar

diversos elementos que brinden funcionalidad extra a los programas. La Tabla 1.7,
muestra la forma en que algunos lenguajes de programación populares incorporan
funcionalidad extra.
Lenguaje Sentencia Ejemplo

Pascal use use conio;
C y C++ #include<> #include<iostream.h>
Java import Import java.io.*;
Tabla 1.7: Funcionalidad extra de algunos programas

12. Operación de Asignación

La operación de asignación consiste en atribuir un valor a una variable. El valor
asignado puede ser una expresión, una constante o el valor de otra variable.
Las formas más comunes del operador de asignación se resumen en la Tabla 1.8:
Lenguaje Operador Ejemplo

Pascal := var := 5 + 3;
C y C++ = var = var + 5;
Java = var = Math.sin(90.0);
Tabla 1.8: Operador de Asignación
En los ejemplos de la tabla anterior, var representa la variable a la que se le asigna el

valor dado en la expresión a la derecha del operador de asignación.
El proceso de asignación se realiza en 2 fases:

• Se evalúa la expresión de la parte derecha de la asignación obteniéndose un
único valor.
• Se asigna ese valor a la variable de la parte izquierda.
Debe tenerse en cuenta:
• En la parte izquierda de la operación de asignación, sólo puede haber una
variable.
• La variable a la que se le asigna el valor pierde su valor anterior.
• Si la variable a la que se le asigna un valor (parte izquierda) participa en la
expresión a evaluar (parte derecha), como por ejemplo la sentencia: x = x + 1 ,
entonces como primero se evalúa la expresión antes de realizar la asignación, el
valor usado en la expresión es el que tenía la variable antes de la operación. En
el ejemplo dado si x tenía un valor igual a 5, entonces la evaluación de la
expresión x = x + 1 sería x = 5 + 1, quedando x con un valor final de 6.
• El tipo de dato del valor resultante al evaluar la parte derecha de una operación
de asignación, tiene que ser del mismo tipo de dato o de un tipo compatible, con
la variable a la cual se le va a asignar el resultado de la operación. Muchos
lenguajes de programación imponen sus propias reglas de conversión de tipos
de datos, definiendo cuáles son las operaciones permitidas entre los diversos
tipos de datos.

13. Recomendaciones
Cuando se programa existen una serie de problemas y errores de programación que
tienden a presentarse una y otra vez en los programas.
Para minimizar la ocurrencia de errores en la programación, es aconsejable que se

consideren las siguientes recomendaciones:
• Reutilizar código probado: Puede existir un código ya desarrollado y probado
para resolver totalmente o parte del problema que pueda utilizarse. Esto facilita
la solución del problema y minimiza el tiempo de desarrollo.
Al reutilizar código no se desperdicia tiempo depurando una parte de la lógica
que se sabe que funciona.
• No asumir los datos de entrada como válidos: Si no se tiene ningún control sobre
la fuente de los datos, no se tiene ningún control sobre la calidad de los mismos.
• No asumir que los datos de entrada están en la secuencia correcta.
• Verificar siempre la secuencia: Es muy fácil para alguien proporcionar datos
erróneos.
• Diseñar los tamaños de los campos de datos, de modo que tengan capacidad
para contener el valor más grande permitido.
• Usar comentarios libremente. Explicar cualquier cosa que pueda confundir a un
futuro lector, además de señalar cualquier área que pueda estar sujeta a
cambios.
• Hacer programas legibles y fáciles de entender.
• Usar nombres adecuados para las variables, que sean auto descriptivos.
• Usar sangrías, alineación y espacios donde sea necesario (líneas blancas y
columnas).

Resumen
Ahora que ha completado esta unidad, usted debe ser capaz de:
• Definir el propósito y el contenido de un programa de computadora.
• Utilizar una metodología para resolver problemas de procesamiento de datos.
• Describir el funcionamiento de un compilador/enlazador.
• Definir el concepto de Dato.
• Describir los diferentes tipos de datos y las operaciones incorporadas a los
lenguajes de programación.
• Presentar las recomendaciones que ayudan a programar con estilo.

Unidad 1: Examen de Autoevaluación

1) ¿Cuáles de los siguientes son lenguajes de alto nivel?
a) Cobol
b) Fortran
c) Java
d) Ensamblador
2) Se entiende por algoritmo, un conjunto de reglas bien definidas para la solución de

un problema en un número de pasos que podría no ser finito.
a) Verdadero
b) Falso
3) Seleccione las afirmaciones correctas en referencia a un programa de

computadora.
a) Es una solución a un problema
b) Es una caja mágica
c) Es un conjunto de instrucciones hechas para ejecutarse en una computadora
d) Todas las anteriores
4) Para diseñar un programa de computadora se requiere de un proceso que cumpla

con las siguientes características:
a) Actualizable
b) Fácil de mantener
c) No estructurado
d) Ninguna de las anteriores
5) Seleccione las afirmaciones correctas:

a) El conjunto de sentencias creadas para resolver un problema se denomina
"programa fuente"
b) Un compilador convierte un programa fuente en un programa ejecutable
c) Si se encuentran errores de sintaxis en las instrucciones del programa fuente,
el compilador lista cada uno de ellos y produce un archivo ejecutable

6) ¿Cuáles de los siguientes son lenguajes de programación orientado a objetos?

a) Java
b) C
c) C++
d) Cobol
7) Compilar es traducir un programa escrito en un lenguaje de máquina en un

programa de alto nivel; forma en la cual la computadora puede ejecutar acciones o
instrucciones.
a) Verdadero
b) Falso
8) Para minimizar la ocurrencia de errores en la programación se recomienda revisar

que los programas cumplan con lo siguiente:
a) Reutilización de código
b) Asumir que todas las entradas de usuario son correctas
c) Verificar que la secuencia de entrada de datos es la requerida por el programa
d) Que las instrucciones sean legibles y fáciles de entender
9) Un sistema operativo es una colección organizada de software que se usa para

ayudar y, en parte, controlar las operaciones de una computadora.
a) Verdadero
b) Falso
10) ¿Cuáles de los siguientes son dispositivos de almacenamiento?

a) Teclado
b) Cinta magnética
c) Impresora
d) Otra computadora

Respuestas de la Unidad 1: Examen de Autoevaluación
1) a, b y c
2) b
3) a y c
4) a y b
5) a y b
6) a y c
7) b
8) a, c y d
9) a
10) b y d

Unidad 2: Conceptos de Diseño

Estructurado

• Listar las características del Diseño Estructurado.
• Definir los conceptos de diseño Top-Down.
• Describir los Diagramas de Estructura, Diagramas de Flujo y Diagramas de Nassi
– Schederman.
• Definir el concepto de Pseudocódigo.
Unidad 2: Conceptos de Diseño Estructurado Libro 1: Fundamentos de Programación 29

1. Introducción
Existen técnicas para facilitar el entendimiento de un problema en términos que permitan
desarrollar un algoritmo que ofrezca una solución y que, posteriormente, conlleve al
desarrollo de un programa que solucione el problema con la ayuda de un computador.
Éstas técnicas son:
• El diseño Top-Down (de arriba hacia abajo).
• Los diagramas de estructura.
• Los diagramas de flujo.
• El pseudocódigo.
2. Conceptos de Diseño Estructurado

El diseño estructurado es una metodología para el desarrollo de programas, que puede
ser definida a través de las siguientes características:
• El sistema desarrollado siguiendo el diseño estructurado tendrá una entrada y una
salida, con variaciones ocasionales.
• El diseño estructurado divide el problema a resolver en partes o módulos.
• El diseño estructurado evita el uso de la sentencia GOTO (sentencia que se utiliza
para desviar el flujo normal de un programa; la desventaja de esta sentencia es
que el seguimiento del programa puede ser desde difícil hasta imposible).
3. Diseño Top Down

El diseño top down o “refinamiento paso a paso”, establece que debe irse de lo más
general a lo más específico y se define como el proceso de dividir un problema en sub-
problemas más pequeños.
Para entender el diseño top down se presenta a continuación un problema ejemplo y se

discute cómo se aplica esta técnica en el diseño de programas.
Enunciado del problema:
Se le ha solicitado que escriba un programa para una tienda de videos que tenga como
objetivo permitir que un cliente, previamente registrado en la tienda, alquile videos.
Ya existe un sistema para llevar el control del inventario de películas y registro de clientes.
La tienda tiene un conjunto de reglas que deben cumplirse para que un cliente alquile un
video. Estas son:
• Un cliente es un miembro registrado.
• El cliente no debe tener alquileres vencidos.
Libro 1: Fundamentos de Programación Unidad 2: Conceptos de Diseño Estructurado 30

• El cliente no debe nada a la tienda.

• La película está en inventario.
• La película no está reservada.
Un programa de alto nivel será: Alquilar un video.
Al descomponer este programa de alto nivel, se obtienen los siguientes sub-programas:

• Verificar si el cliente es un miembro registrado.
• Verificar si tiene alquileres vencidos.
• Verificar si el miembro debe dinero.
• Verificar si la película está en el inventario.
• Verificar si la película está reservada.
Al descomponer de nuevo cada uno de los pasos anteriores, se obtiene:
1. Verificar si el cliente es un miembro registrado:

• Ingresar una identificación del cliente en el sistema.
• Verificar si el sistema ha encontrado un perfil que coincida con este cliente.
2. Verificar los alquileres vencidos:

• Ver si el perfil refleja cualquier alquiler vencido en el sistema.
3. Verificar si el miembro debe algún dinero:

• Ver si el perfil refleja algún cargo pendiente.
4. Verificar si la película está en el inventario:

• Ingresar el nombre de la película al sistema.
• Verificar si hay alguna copia que no esté alquilada.
5. Verificar si la película está reservada:

• Ver si las copias que no están alquiladas están reservadas.
De nuevo, al descomponer el sub-programa “Verificar si el cliente es un miembro

registrado”:
1.1. Verificar si el cliente es un miembro registrado:

• Preguntar la identificación al cliente.
1.2. Ingresar la identificación en el sistema:

• Seleccionar del menú la opción de “verificar la identificación del miembro”.
• Ingresar la identificación del cliente en el prompt.

• Presionar la tecla que indica al sistema que está listo, para que éste verifique por
un número que coincida con el que se ha ingresado.
1.3. Leer la pantalla para ver si el sistema ha encontrado alguna coincidencia:

• Verificar visualmente si el sistema dice ‘sí ' o ‘no ' es un miembro.
4. Diagramas de Estructura
Un diagrama de estructura es una manera gráfica de representar el diseño top down.
Permite representar en forma clara la organización de alto nivel de un programa.
La Figura 2.1 muestra un diagrama de estructura parcial del problema presentado en el

punto anterior.
Alquilar
una
Película
Verificar si Verificar Verificar Verificar si

deudas Verificar si
es un alquileres no está
pendientes película
miembro vencidos reservada
está
Preguntar Ingresar
identifica- identifica- Examinar
ción ción perfil
Figura 2.1: Diagrama de Estructura del Problema Ejemplo
5. Diagramas de Flujo o Flujograma

Un diagrama de flujo es una representación gráfica de la lógica del diseño. Generalmente,
presenta un nivel de detalle mucho mayor que los diagramas de estructura.
Un diagrama de flujo resulta adecuado cuando se desea obtener mayor detalle, tal como
agregar bifurcación de condicionales y/o iteraciones.
En todo diagrama de flujo, siempre habrá una caja de inicio y otra de fin para el principio y
final del algoritmo.

5.1 Los símbolos

A continuación los símbolos más comunes que se usan en un diagrama de flujo:
Flechas o Líneas de Flujo: sirven para conectar los
símbolos del diagrama. La flecha indica la secuencia en la
que se van a ejecutar las acciones.
Símbolo de Proceso: Indica la acción que tiene que

realizar la computadora. Dentro se escribe la acción.
Entrada/Salida: Representa las acciones de entrada y

salida. Dentro se colocan las acciones de lectura y
escritura.
Condición: En el rombo se coloca una condición, al

encontrar este signo, se evalúa la condición que hay
dentro. Según la condición, sea verdadera o falsa, se toma
un camino u otro. Sirve para representar estructuras
selectivas y repetitivas.
Principio y Fin: Dentro del símbolo va la palabra inicio o fin

del algoritmo.
Subprograma: Dentro se coloca el nombre del

subprograma al que se llama.
Conectores: Sirven cuando un flujograma no cabe en una

columna de la hoja y hay que seguir en otra columna. Se
colocan uno donde termina la columna y otro donde
empieza. Hay 2 tipos:
- Si es en la misma hoja.
- Si es en una hoja distinta.
Aclaratoria: Se usa para añadir comentarios que permitan

entender mejor el código, no es parte del código.

5.2 Otros Símbolos

Pantalla: Cuando una salida es por pantalla.
Teclado: También se usa para representar una entrada por

teclado.
Impresora
Entrada/Salida por Disco
Las bifurcaciones condicionales se ejecutan según una determinada condición, es decir, si

la condición es verdadera se ejecuta un bloque del proceso, si es falsa se ejecuta un
bloque diferente.
Una iteración es cuando en un segmento de un algoritmo, los pasos se repiten un número

determinado de veces mientras se cumple una determinada condición.
La metodología para representar un problema utilizando diagramas de flujo, se describe

en la Figura 2.2.

5.3 Metodología para Resolver un Problema con Diagramas de Flujo
Inicio
Determinar requerimientos del proceso
Determinar requerimientos del post-

proceso
Crear Diagrama de Flujo
Verificar Diagrama de Flujo
NO
¿Diagrama Flujo OK?
SI
Fin
Figura 2.2: Metodología para Resolver un Problema con Diagramas de Flujo

6. Recomendaciones para hacer Diagramas de Flujo

• El diagrama debe mostrar claramente donde inicia y donde termina.
• Cualquier camino que se siga, debe conducir al fin.
• Los símbolos deben estar organizados de tal forma, que visualmente el flujo vaya
de arriba abajo y de izquierda a derecha.
• No debe usarse lenguajes de programación dentro de los símbolos.
• El diagrama debe estar centrado dentro de la página.
• Las flechas deben ser verticales u horizontales, nunca diagonales.
• No deben cruzarse las flechas, para evitar esto están los conectores.
• No abusar de los conectores.
• A un símbolo sólo debe llegar una flecha, si fuese necesario otras flechas
entrantes, estas deben llegar a un conector.
• Las flechas deben entrar a los símbolos por arriba o por la izquierda,
preferiblemente.
• Debe tratarse de que el diagrama se ajuste a una página, de no ser posible debe
usarse un conector.
7. Ejemplo de un Diagrama de Flujo

Ejemplo 2.1
Calcular el producto de los números positivos introducidos por teclado. El proceso finaliza
cuando se ingresa un número negativo o un cero.
Algoritmo:
1. Iniciar la variable que va a contener el producto.

2. Leer el primer número.
3. Preguntar si es negativo o positivo.
4. Si es negativo o cero se sale de la iteración y se escribe el producto.
5. Si es mayor que cero, se multiplica el número leído y se lee un nuevo número. Se
vuelve al paso 2.

INICIO
P=1
LEER NUM
SI P = P x NUM
NUM > 0
NO
ESCRIBIR P
FIN
Figura 2.3: Diagrama de Flujo para el cálculo del producto de enteros
Fin del Ejemplo 2.1
8. Diagramas N-S o de Nassi-Schederman:

Es una forma de representación semejante al flujograma o diagrama de flujo, pero sin
flechas y cambiando los símbolos de condición y repetición. Está conformado por una
serie de cajas de procesos que constituyen las secuencias de acciones necesarias para
presentar el algoritmo. Las cajas de proceso o acción van unidas entre sí. Los Diagramas
N-S son muy útiles para representar diagramas estructurados.
A continuación en la Figura 2.4 se observa la representación de las condiciones.

Condición
SI NO
<Acciones> <Acciones>
Figura 2.4: Representación de Condiciones
Seguidamente, se presenta la Figura 2.5 en la cual se representan las estructuras

repetitivas:
Mientras <Condición>
<Acciones> Desde Var = V1 Hasta V2
Repetir Hasta <Condición>

<Acciones> <Acciones>
Figura 2.5: Estructuras Repetitivas
A continuación se presenta nuevamente el problema de determinar el producto de un

conjunto de enteros, cuya solución es representada en esta oportunidad mediante un
diagrama de N-S. Para ello, observe la Figura 2.6.
INICIO
p = 1
Leer num
Mientras (num > 0)
p = p x num
Leer num
Escribir p
FIN
Figura 2.6: Diagrama de N-S para el Cálculo del Producto de Enteros

9. Pseudocódigo
El pseudocódigo es un lenguaje de documentación de programas similar al español o al
inglés (se parece a cualquier lenguaje de programación de alto nivel). No necesita seguir
ninguna regla específica, como por ejemplo ser requerido por los programas que van a
ser traducidos o compilados. El pseudocódigo normalmente no es muy específico para las
áreas de E/S.
No hay ningún estándar en la industria definido para escribir pseudocódigo y tiene la

ventaja de que se puede crear fácilmente con cualquier editor de texto.
Un ejemplo de pseudocódigo parecido a PL/I, se muestra a continuación:
do while( count = 0 )
do process
count = count - 1
end
Un ejemplo de pseudocódigo parecido a COBOL:
perform until count = 0

perform process
subtract 1 from count
end-perform
El pseudocódigo también puede utilizar una serie de palabras claves o palabras
especiales que van indicando lo que significa el algoritmo.
Ejemplo 2.2
Ejemplo de palabras claves en pseudocódigo:
1. Inicio y Fin: Por donde empieza y termina el algoritmo.
2. Si <condición>
3. Entonces <acciones>
4. Sino <acciones>
5. Mientras <condición> hacer
6. Repetir / hasta <condición>
7. Desde / hasta
8. Según sea (Para evaluar opciones múltiples)
Nota: Se debe tomar en cuenta que los comentarios van encerrados entre llaves y hay
que utilizar sangría al escribir el código.
La estructura recomendada para los algoritmos en pseudocódigo es:

Algoritmo <nombre algoritmo>

Var
<nombre>: <tipo>
Inicio
<Instrucciones>
Fin
Se presenta el pseudocódigo para el ejemplo de determinar el producto de un conjunto de

enteros:
1. Algoritmo Producto
2. Var p, num: entero
3. Inicio
4. p = 1
5. Leer num
6. Mientras num > 0 hacer
7. p = p * num
8. Leer num
9. Fin mientras
10. Escribir p
11. Fin
Fin del Ejemplo 2.2

Resumen
• Listar las características del Diseño Estructurado.
• Definir los conceptos de diseño top-down.
• Describir los Diagramas de Estructura, Diagramas de Flujo y Diagramas de Nassi
– Schederman.
• Dibujar un diagrama de estructura para mostrar la jerarquía de un programa.
• Definir el concepto de Pseudocódigo.


1) El pseudocódigo es un lenguaje de documentación que:
a) Necesita una sintaxis específica
b) Necesita ser traducido pero no compilado
c) Se puede crear fácilmente
2) En diseño estructurado, el proceso de dividir un problema en subproblemas más

pequeños se conoce como:
a) Diagrama de flujo
b) Diagrama de estructura
c) Refinamiento paso a paso
d) Diseño Top – Down
3) ¿Cuáles de las siguientes afirmaciones son verdaderas sobre diseño estructurado?

a) Tiene una entrada y una salida
b) Divide el problema en sub-problemas.
c) Elimina el uso de la sentencia GO TO
4) El refinamiento paso a paso puede representarse gráficamente con un:

a) Diagrama de clases
b) Árbol binario
c) Diagrama de estructura
d) Diagrama de secuencia
5) Para la representación de un problema, cumple la misma función utilizar un diagrama

de flujo o un diseño top-down.
a) Verdadero
b) Falso
6) Si un algoritmo se representa en un diagrama de flujo, entonces no se puede

representar en pseudocódigo.
a) Verdadero
b) Falso

7) Cuando se trabaja con programas grandes se hace difícil:

a) El refinamiento paso a paso
b) La representación gráfica de la lógica del diseño
c) Probar totalmente el código
d) Todas las anteriores
8) Un diagrama de flujo es:

a) La representación de un algoritmo en un lenguaje de alto nivel
b) La representación gráfica de la lógica del diseño
c) Un refinamiento “paso a paso”
9) ¿Indique cuáles de las siguientes son características del pseudo-código?

a) Es un lenguaje de documentación similar al ingles o español
b) Normalmente no es muy específico para las áreas de entrada y salida
c) Se puede compilar para revisar las fallas de sintaxis
d) Se puede crear fácilmente con cualquier editor de texto
10) ¿Cuál es la forma de representación del diseño top-down?

a) Diagrama de Flujo
b) Algoritmos
c) Pseudocódigo
d) Diagrama de Estructura

Respuesta de la Unidad 2: Examen de Autoevaluación

1) c
2) c y d
3) a, b y c
4) c
5) b
6) b
7) d
8) b
9) a, b y d
10) d

Unidad 3: Programación Estructurada

Al finalizar esta unidad usted será capaz de:
• Conocer las técnicas de programación estructurada.
• Trabajar con las estructuras secuenciales.
• Trabajar con las estructuras selectivas.
• Trabajar con las estructuras repetitivas.
• Conocer la anidación de bucles y condicionales.
• Realizar el control de datos de entrada.
Unidad 3: Programación Estructurada Libro 1: Fundamentos de Programación 45

1. Introducción
La característica fundamental de la programación estructurada es que se basa en el uso
únicamente de tres estructuras de control y se apoya en los siguientes conceptos:
• Recursos Abstractos: Son los recursos que se tienen en el momento de
programar y que se irán transformando en recursos concretos.
• Diseño Descendente (top down): Se trata de ir descomponiendo el problema en
niveles o pasos cada vez más sencillos, de forma que la salida de una etapa va a
servir como entrada de la siguiente. En las primeras etapas se toma el punto de
vista externo, es decir, qué entradas se tienen y qué salidas se producen. A
medida que se avanza en la descomposición del problema, se van concretando las
abstracciones, es decir cómo en efecto se resuelve.
• Estructuras Básicas de Control: Para construir un programa se siguen los pasos
de razonamiento anteriores y al final se codifica el programa usando tres tipos de
estructuras: repetitivas, alternativas y secuenciales.
Al final todo programa tendrá una única entrada y una única salida. Desde la entrada
tienen que existir caminos que permitan pasar por todas las partes del programa y llegar a
la salida. Se permiten los bucles infinitos.
2. Estructuras Secuenciales
En las estructuras secuenciales una instrucción sigue a otra en secuencia, es decir, la
salida de una instrucción es la entrada de la siguiente. Observe la Figura 3.1.
FLUJOGRAMA DIAGRAMAS N-S PSEUDOCÓDIGO
Leer num
Leer num Leer num num = num * 2
Escribir num
num=num*2
num=num*2
Escribir num
Escribir num
Figura 3.1: Estructuras Secuenciales
Libro 1: Fundamentos de Programación Unidad 3: Programación Estructurada 46

3. Estructuras Selectivas
En este tipo de estructuras se evalúa una condición y en función del resultado lógico
(verdadero o falso) u otro resultado se ejecuta un conjunto de instrucciones. Son también
denominadas estructuras de control de flujo, estructuras condicionales o de toma de
decisiones. Hay tres tipos de estructuras selectivas: simples, dobles o múltiples.
3.1 Estructura Selectiva Simple
La estructura selectiva simple es la estructura condicional elemental y básica. Presenta la

forma:
Si <condición> entonces
<acciones>
Fin si
En esta estructura condicional se evalúa la condición, si el resultado es verdadero se
ejecuta el conjunto de acciones asociadas al bloque, entonces si el resultado es falso no
se ejecuta acción alguna. Esto está representado en la Figura 3.2.
Condición Si <condición>
Condición no SI NO entonces
<acciones>
Acciones Fin si
si
Acciones
Acciones
|
Figura 3.2: Estructura Selectiva Simple
3.2 Estructura Selectiva Doble
La estructura selectiva doble es una estructura condicional que evalúa una condición
dada. Si es verdad, se ejecutan el conjunto de acciones asociadas a la parte del ‘si’, si es
falso se ejecutan el conjunto de acciones asociadas a la parte del ‘no’. En la siguiente
figura se podrá observar con detalle esta estructura.

condición
No
condición acciones Si <condición>
Si No entonces
<acciones>
Si Sino
acciones acciones <acciones>
acciones
Fin si
acciones
Figura 3.3: Estructura Selectiva Doble
3.3 Estructura Selectiva de Alternativa Múltiple
En la estructura selectiva de alternativa múltiple se evalúa una condición o expresión que

puede tomar “n” valores distintos. Según sea el valor de la expresión en un instante dado,
se ejecutarán las acciones correspondientes a ese valor. En realidad equivale a un
conjunto de condiciones anidadas. En muchos lenguajes de programación se conocen
como sentencias Case o Switch.
Es una sentencia de la forma:

Según sea <expresión>
<valor1>: <acciones 1>
<valor2>: <acciones 2>
[<otro> : <acciones n>]
fin según
Las acciones asociadas a la opción ‘Otro:’ se ejecutan cuando la expresión no toma
ninguno de los valores que aparecen antes. En algunos lenguajes de programación se le
conoce como alternativa ‘Otherwise’, ‘Else’ o ‘Default’.
El valor con el que se compara la expresión es dependiente de los lenguajes de

programación. Por lo general, se espera un tipo de dato determinístico y con valores
secuenciales, tales como los enteros y caracteres. En general, ese valor puede ser un
valor constante, un rango de valores determinístico o incluso otra condición. La Figura 3.4
representa una Estructura Selectiva de Alternativa Múltiple.

Expresión
Expresión Según sea <expresión>
V1 V2 V3 V4 <valor1>:<acciones>
<valor2>:<acciones>
<valor3>:<acciones>
<valor4>:<acciones>
V1 V2 V3 V4 [<otro> :<acciones>]
Fin según
acciones
Figura 3.4: Estructura Selectiva de Alternativa Múltiple
Ejemplo 3.1: Uso de la Estructura Selectiva de Alternativa Múltiple
Escribir un programa que dada una nota entera presente por pantalla un mensaje acorde
a la nota suministrada según un rango de valores.
Var nota: entero

Leer nota
Según sea nota
1..4: escribir “suspendido”
5..6: escribir “aprobado”
7..8: escribir “Notable”
9: escribir “Sobresaliente”
10: escribir “Cuadro de honor”
Fin según
Fin del Ejemplo 3.1
4. Estructuras Repetitivas o de Ciclo

Las estructuras repetitivas o de ciclo representan un bucle o conjunto de instrucciones
que se repiten un número finito de veces. Cada repetición del bucle se llama una
iteración. Todo bucle tiene asociada una condición, que es la que va a determinar si debe
ejecutarse el bucle y hasta cuando.
Existen tres tipos de básicos de estructuras repetitivas:
1. Mientras-hacer (while)

2. Repetir-hasta (repeat until)

3. Desde (for)
4.1 Estructura Repetitiva Mientras-Hacer
En la estructura repetitiva Mientras-Hacer, la condición de entrada al ciclo se evalúa antes

de realizar cualquier iteración del bucle. Si la condición no se cumple, el ciclo no se
ejecuta y el programa continúa con la secuencia de acciones siguientes al ciclo. Si la
condición es verdadera, comienzan a ejecutarse las acciones del Mientras-Hacer.
Después de la última acción, se repite el proceso de evaluación de la condición, esto es,

si la condición es verdadera de nuevo, entonces se repiten las acciones. Este proceso se
conoce como un bucle y continua hasta que la condición sea falsa y la ejecución prosiga
con la sentencia siguiente después del bucle.
Al evaluarse la condición la primera vez antes de entrar en el bucle, si la condición es

falsa no se entra nunca en el bucle, en estas circunstancias el bucle nunca se ejecuta. Por
lo tanto, se usará el bucle Mientras-hacer en el caso de que exista la posibilidad de que el
bucle nunca deba ejecutarse.
Mientras <cond.>
No Hacer Mientras <condición>
condición Hacer
<acciones>
<acciones>
Si Fin mientras
acciones
Figura 3.5: Estructura Repetitiva Mientras-Hacer
4.2 Estructura Repetitiva Repetir-Hasta
En la estructura repetitiva Repetir-Hasta, la condición del ciclo se evalúa después de

realizar la primera iteración del bucle. Este bucle se repite mientras la condición evaluada
al final se mantenga falsa. Al cumplirse la condición y ser verdadera, se sale del bucle. De
allí su nombre “repetir hasta” que se cumpla la condición.

Como la condición se evalúa al final, se pasa al menos una vez por el bucle. Es decir que
cuando un bucle se tenga que ejecutar como mínimo una vez, se puede usar una
estructura ‘repetir hasta’. Ver Figura 3.6.
Acciones Repetir
<Acciones> <acciones>
Hasta <condición>
No
condición Repetir hasta
<condición>
Si
Figura 3.6: Estructura Repetitiva Repetir-Hasta
En un ciclo ‘mientras-hacer’ se repite el bucle siempre que la condición sea verdadera,

por el contrario, un ciclo ‘repetir-hasta’ se repite el bucle siempre que la condición sea
falsa. A continuación un ejemplo.
Ejemplo 3.2
Leer 3 números y calcular su suma:
Mientras hacer Repetir hasta

cont = 0 cont = 0
suma = 0 suma = 0
Mientras (cont <> 3) Hacer Repetir
Leer num Leer num
suma= suma + num suma= suma + num
cont= cont + 1 cont= cont + 1
Fin mientras Hasta (cont == 3)
Fin del Ejemplo 3.2
4.3 Estructura Repetitiva Desde
La estructura repetitiva ‘Desde’ se usa cuando se sabe el número exacto de veces que se
va ha ejecutar el bucle. El bucle lleva asociado una variable que se denomina variable

índice, a la que se le asigna un valor inicial y se establece cual va a ser su valor final. La
variable índice se incrementa o decrementa de manera automática, en cada iteración del
bucle, en un valor constante. El programador no se tiene que ocupar de actualizar el valor
de esta variable en cada iteración del bucle; es una operación implícita.
Por lo tanto, en cada iteración del bucle, la variable índice se actualiza automáticamente y
cuando alcanza el valor que se ha establecido como final, se termina la ejecución del
bucle. Observe la Figura 3.7.
Desde v=vi Desde <v=vi> hasta <vf>

v = vi hasta vf
<acciones>
v = v + 1 Fin desde
<acciones>
si
v <= vf acciones
no
Figura 3.7: Estructura Repetitiva Desde
5. Estructuras Anidadas
Las estructuras selectivas, como los bucles, se pueden escribir unas dentro de otras. Esto
se conoce como estructuras anidadas.
En otras palabras, por ejemplo un ciclo ‘desde’ puede tener dentro de sus sentencias otro
ciclo ‘desde’ o cualquier otra estructura estudiada anteriormente. También se pueden
presentar anidaciones de estructuras condicionales.
5.1 Anidación de Condicionales
En muchas situaciones, se requiere evaluar un conjunto de condiciones en forma

secuencial y separada. En estos casos, se recomienda utilizar una anidación de
sentencias condicionales. La ventaja de anidar sentencias condicionales, es que cuando
una se cumple no hay por que evaluar las condiciones que están debajo o que le siguen.
Sintaxis:

Si <condicion1>
Entonces <sentencia1>
Sino si <condicion2>
Sino si <condicion2>
Fin si
Fin si
Fin si
La forma común de realizar el anidamiento es colocar la condición en la parte ‘no’ (else)
de la sentencia.
La sentencia ‘según sea’ (case) siempre equivale a una anidación de condicionales, pero
lo contrario no es cierto.
5.2 Bucles Anidados
Al igual que se pueden colocar unas expresiones dentro de otras, los bucles pueden estar
unos dentro de otros. Al anidar bucles hay que tener en cuenta que el bucle interno
funciona como una sentencia más en el bloque del bucle externo, por lo tanto, en cada
iteración del bucle externo se van a ejecutar todas las iteraciones del bucle interno.
Los bucles deben estar bien formados y ser sintácticamente correctos para que pueda
haber un anidamiento válido, en otras palabras, nunca pueden cruzarse las sentencias de
los bucles. Si se tiene un ciclo ‘desde’ que internamente posee un ciclo ‘mientras hacer’,
es necesario finalizar las sentencias o instrucciones del ciclo más interno, en este caso
‘mientras-hacer’ antes de colocar la culminación del ciclo externo ‘desde’.
Si el bucle externo se repite n veces y el interno se repite m veces y por cada iteración del
externo se repite el interno, entonces el número total de iteraciones será el producto de m
x n. Los bucles que se anidan pueden ser de igual o distinto tipo.
A continuación se presenta un ejemplo de anidamiento de bucle.
Ejemplo 3.3
1. Desde i=1 hasta 8

2. Desde k=1 hasta 5
3. Escribir “Profesor ” i ” introduzca su asignatura
nº ” k
4. Leer asignatura
5. Fin desde
6. Fin desde

Note como cada ciclo interno termina antes de cerrar el más externo. No existen
limitaciones formales en cuanto al número de sentencias y estructuras anidadas que se
pueden colocar en un mismo bloque de código, esto depende del lenguaje de
programación que se está usando. No obstante, no es conveniente abusar de los
anidamientos de estructuras, ya que resultan en un código difícil de leer y por lo tanto
difícil de mantener.
Fin del Ejemplo 3.3
6. Control de Datos de Entrada

Existen una serie de situaciones comunes en programación donde se toman datos desde
un dispositivo de entrada y se requiere de alguna forma de control implementada por
bucles. A continuación algunas de estas situaciones.
6.1 Usando un Valor Centinela que Determina el Fin del Bucle
En este caso se espera la entrada de un valor centinela para decidir si se va a ingresar al

ciclo o no de entrada de datos. El bucle se va a repetir mientras no se lea un valor
determinado. La primera lectura se va a realizar fuera del bucle. Si al ingresar el dato de
entrada, éste es el valor centinela entonces no se entra en el bucle y se seguirá con el
resto del algoritmo. En caso contrario, se entra en el bucle para seguir con la entrada de
datos.
Se recomienda utilizar una estructura Mientras-Hacer.
Ejemplo 3.4
1. centinela = 9
2. Leer opcion
3. Mientras (opcion <> centinela) hacer
4. <acciones>
5. Leer opcion
6.Fin mientras
Fin del Ejemplo 3.4
6.2 Lectura Secuencial de un Archivo
Los datos de entrada pueden estar en un archivo, el cual debe ser leído desde el primer al
último registro para recuperar todos los datos, para ello se realiza una lectura secuencial
de todos los registros del archivo.
Una estrategia común de lectura para un archivo con acceso secuencial es:
abrir el archivo

leer un registro del archivo

verificar si no es fin de archivo al entrar a un ciclo para
recorrer el archivo
realizar operaciones con los datos de entrada
volver a leer datos del archivo, con cada operación de
lectura se avanza de registro en registro en los datos del
archivo
regresar al ciclo hasta que sea fin de archivo.
Ejemplo 3.5
1. Archivo mi_archivo
2. Abrir_Archivo(mi_archivo)
3. Leer_Archivo(mi_archivo)
4. Mientras (No (Fin_de_Archivo(mi_archivo))) Hacer
5. <acciones con los datos del archivo>
6. Leer_Archivo(mi_archivo)
7.Fin mientras
Fin del Ejemplo 3.5
6.3 Cuando se Sabe el Número Exacto de Veces que se Ejecuta una Acción o
Proceso
Cuando se sabe el número exacto de veces que se ejecuta una acción o proceso, la
opción natural para realizar el control de entrada es utilizar un ciclo o bucle
‘Desde...Hasta’.
Normalmente, el número de veces que se desea repetir el proceso, es solicitado como un

valor de entrada o es suministrado desde alguna otra fuente (variable de entorno,
constante, archivo de configuración, entre otros). Una vez que se obtiene este valor, se le
asigna a la variable de índice para el ciclo ‘Desde’. Se efectúa la operación hasta que se
cumpla el número de veces deseado.
Ejemplo 3.6
1. Var i : Entero
2. Mostrar “Ingrese el numero da materias a registrar: ”
3. Leer numero_materias
3. Desde i = 1 Hasta numero_materias
4. Mostrar “Ingresar datos Materia numero ” ,i, “ : ”
5. Leer materia
6. <acciones a realizar con materia>

7.Fin desde
Fin del Ejemplo 3.6
6.4 Control de Datos Para no Permitir Datos Erróneos
El control de ingreso de datos para evitar datos de entrada erróneos, se usa cuando se
controla al usuario para que introduzca los datos válidos. Por ejemplo: ‘un valor numérico
dentro de un rango determinado’, en estos casos, se recomienda usar un ciclo
‘Repetir...Hasta’.
Ejemplo 3.7
1. Var opcion : Entero

2. opcion = 0
3. Repetir
4. Mostrar “Menu:”
5. Mostrar “1. Crear Archivo”
6. Mostrar “2. Borra Archivo”
7. Mostrar “3. Incluir Registro”
8. Mostrar “4. Salir del sistema”
9. Mostrar “Su opcion :”
10. Leer opcion
11.Hasta (opcion >= 1) Y (opcion <= 4)
Fin del Ejemplo 3.7

Resumen
Ahora que ha completado esta unidad, Ud. debe ser capaz de:
• Conocer las técnicas de programación estructurada.
• Trabajar con las estructuras secuenciales.
• Trabajar con las estructuras selectivas.
• Trabajar con las estructuras repetitivas.
• Conocer la anidación de bucles y condicionales.
• Realizar el control de datos de entrada.

1) ¿Cuáles de los siguientes son estructuras de ciclo?

a) Mientras hacer
b) Desde
c) Hasta
d) Repetir hacer
2) Todo bucle tiene asociada dos condiciones: Una que determina si se ejecuta el bucle
y otras hasta cuando.
a) Falso
b) Verdadero
3) ¿Cuáles de las siguientes son estructuras básicas de control?

a) Alternativas
b) Directivas
c) Repetitivas
d) Ejecutorias
4) No es posible la anidación de estructuras de selección con estructuras de bucles.

a) Verdadero
b) Falso
5) ¿Cuáles de las siguientes afirmaciones son correctas con respecto a los centinelas?
a) Se recomienda utilizar una estructura Repetir
b) La primera lectura se va a realizar fuera del bucle
c) El bucle se va a repetir mientras no se lea un valor determinado
d) Se utiliza únicamente con lenguajes orientados a objetos
6) Con respecto a las estructuras repetitivas, ¿Cuáles de las siguientes no son

verdaderas?
a) Cada repetición del bucle se llama una iteración
b) Existen dos tipos básicos de estructuras repetitivas
c) Cada serie del bucle se llama una repetición
d) Son un conjunto de instrucciones que se repiten un número infinito de veces

7) El bucle ‘Mientras-hacer’ garantiza su ejecución por lo menos una vez.

a) Verdadero
b) Falso
8) La estructura de ciclo ‘Desde’ debe ser utilizada cuando no se conoce el número de

veces que se debe ejecutar el ciclo.
a) Verdadero
b) Falso
9) Las estructuras selectivas de selección múltiple no poseen un mecanismo que

permita evaluar otro valor diferente a los especificados puntualmente.
a) Verdadero
b) Falso
10) La variable índice del ciclo ‘Desde’ actualiza su valor automáticamente.

a) Verdadero
b) Falso

Respuestas de la Unidad 3: Examen de Autoevaluación

1) a y b
2) a
3) a y c
4) b
5) b y c
6) b, c y d
7) b
8) b
9) b
10) a


• Definir qué son las funciones, sus características y sintaxis.
• Definir los procedimientos, sus características y sintaxis.
• Explicar el ámbito de las variables.
• Explicar la comunicación entre subprogramas.
• Definir qué es la Recursividad.
Unidad 4: Funciones y Procedimientos Libro 1: Fundamentos de Programación 61

1. Introducción
La programación modular es una de las técnicas fundamentales de la programación. Se
apoya en el diseño top down y en la filosofía de “divide y vencerás”. La programación
modular toma el problema y lo divide en problemas más simples o más pequeños y cada
uno de estos se implementa como un módulo independiente. A cada uno de estos
módulos se le llama subprogramas. El objetivo es tener tanto subprogramas como sea
necesario para resolver un problema mayor y cada subprograma debe cumplir
cabalmente una tarea específica.
Siempre existirá un módulo o programa principal donde comienza la ejecución de todo el

programa. A partir de éste, se van llamando al resto de los módulos que posea el sistema
y que han sido implementados como subprogramas. Cada vez que se invoca a un
subprograma, en la llamada se le pasa la información que necesita, seguidamente éste
comienza a ejecutarse y cuando termina su ejecución el control regresa a la instrucción
siguiente a la línea de código en la cual se efectuó la llamada, en el programa o
subprograma que hizo la llamada.
Un ejemplo de programación modular puede ser un sistema que realice el cálculo de los
impuestos, donde el problema del cálculo de los impuestos puede ser dividido a su vez en
4 subproblemas, que se implementarán como 4 módulos o subprogramas, para ilustrarlo
gráficamente observe la Figura 4.1:
Cálculo de
Impuesto
Calcular Ingreso Calcular Retención Calcular Calcular Retención

antes de Impuesto Impuesto después de Impuesto
Calcular Calcular
Impuesto Impuesto
sobre la Renta Activos
Figura 4.1: Ejemplo de Programación Modular
Entre las ventajas de la programación modular están:

• Simplifica el diseño.
• Disminuye la complejidad de los algoritmos.
• Disminuye el tamaño total del programa.
Libro 1: Fundamentos de Programación Unidad 4: Funciones y Procedimientos 62

• Ahorra en tiempo de programación porque promueve la reusabilidad del código.

• Favorece el trabajo en equipo.
• Facilita la depuración y prueba.
• Facilita el mantenimiento.
• Permite la estructuración de librerías específicas.
Hay una correspondencia directa entre el problema principal y el algoritmo principal o
módulo principal (también llamado controlador) y también hay correspondencia entre los
subproblemas en los que se haya dividido el problema principal y los submódulos o
subprogramas que conforman el programa principal.
La estructura de un subprograma o módulo, es muy similar a la estructura de un programa

normal, va a tener una información de entrada que es la que se le pasa al hacer la
llamada y que se coloca junto al nombre del subprograma. Esta información de entrada se
denomina parámetros formales del subprograma o argumentos formales. Dentro del
cuerpo del subprograma se pueden colocar cualquier número de acciones o sentencias
de código e incluso declarar variables y llamar a otros módulos, tal como se hace desde
un programa principal. Al terminar la ejecución del módulo o subprograma puede que este
último devuelva o no resultados o valores al programa que lo llamó. A los subprogramas
que pueden retornar valores, usualmente se les denominan funciones, mientras que a los
subprogramas que no poseen valor de retorno se les denomina procedimientos.
2. Funciones
Desde el punto de vista matemático, una función es una operación que toma uno o varios
operando (parámetros) y devuelve un resultado. Desde el punto de vista algorítmico, una
función es un subprograma que toma uno o varios parámetros como entrada y devuelve
un único resultado.
Este único resultado irá asociado al nombre de la función, es por ello que es una práctica
común el hecho de que al invocar una función, su valor de retorno se le asigne a una
variable u expresión adecuada.
Existen dos tipos de funciones:

• Internas o Incorporadas: Son las que vienen definidas por defecto en el lenguaje
de programación.
• Externas o del Usuario: Son las que define el usuario y tienen un nombre o
identificador.
Para llamar a una función se escribe su nombre y entre paréntesis los argumentos o
parámetros que se quieren pasar a la función.

2.1 Declaración de una Función
La estructura de una función es semejante a la de cualquier subprograma. Tendrá una

cabecera con el nombre y los parámetros y un cuerpo con la declaración de los
parámetros de la función y las instrucciones.
Sintaxis
La sintaxis para la declaración de una función depende del lenguaje de programación

utilizado, se propone un esquema que usa la palabra ‘Función’ para indicar el inicio de la
función seguido del identificador o nombre, la lista de parámetros, el tipo de dato de
retorno de la función y por último, el cuerpo de la función enmarcado entre sentencias de
inicio y fin de bloque de código.
Función <nombre_funcion> (nom_parametro: tipo): tipo_retorno

Var <variables locales de la función>
Inicio
<acciones>
retorno <valor>
fin <nombre_función>
La lista de parámetros es la información que se le tiene que pasar a la función. Los
parámetros dentro del cuerpo de la función, se utilizan como variables locales definidas en
la función. Es necesario definirle a cada parámetro su nombre y tipo de dato al momento
de declarar la función. El nombre de la función lo da el programador y debe ser un nombre
significativo.
En las variables locales se declaran las variables que se desea utilizar dentro de la
función.
Dentro del cuerpo de la función, se escriben todas las acciones o sentencias de código
destinadas a cumplir el propósito de la función. Es necesario para las funciones, que entre
las acciones escritas en su cuerpo, se incluya una del tipo ‘retorno <valor>’. Esta
sentencia pondrá fin a la ejecución de la función y devolverá el valor de la función al
programa que la invocó. El valor de retorno tiene que ser del mismo tipo, que el tipo de
dato que se ha indicado al declarar la función en la parte final de la cabecera.
Por definición, una función siempre debe devolver algún valor. Algunos lenguajes de
programación declaran un tipo de dato nulo para permitir así que las funciones “no
retornen” valores, aunque en realidad retornan un tipo no utilizado.
Los parámetros que aparecen en la declaración de la función se denominan parámetros

formales. Los parámetros que se utilizan cuando la función es invocada se denominan
parámetros actuales o reales. Estos últimos son las constantes, valores de retorno,
expresiones, variables u otro elemento del contexto de la llamada que es necesario pasar
a la función.

2.2 Invocación de una Función
Para llamar o invocar una función, se coloca el nombre de la función y entre paréntesis se
añaden los parámetros reales que necesita la función. Los parámetros reales pueden ser
variables, expresiones e incluso constantes, pero siempre deben corresponder al mismo
tipo de dato que los parámetros formales asociados con la función.
Por ejemplo, si se tiene la siguiente declaración de función:
1. Función sumarEnteros(num1: Entero, num2:Entero): Entero

2. Var
3. resultado: Entero
4. Inicio
5. Resultado = num1 + num2
6. Retornar resultado
7. Fin sumarEnteros
La función puede ser llamada desde el programa principal o desde cualquier otro
subprograma mediante sentencias tales como:
1. Var
2. resultado : Entero
3. numero : Entero
4.Inicial
5. resultado= sumarEnteros(8, 9)
6. Mostrar “8 + 9 es: ” resultado
7. numero= 12;
8. resultado= sumarEnteros(numero, 5)
9. Mostrar “12 + 5 es: ” resultado
10. Mostrar “2 + 2 es: ” sumarEnteros(2, 2)
11.Fin
Para que una función pueda ser invocada desde cualquier parte de un programa, es
necesario que la definición de dicha función ya sea del conocimiento previo del
compilador antes de usarla. Esto último, es así porque usualmente la mayoría de los
lenguajes de programación requieren que la función, procedimiento o subrutina, esté
definida antes de permitir su uso. En otras palabras, la firma de la función que
corresponde a su nombre, tipo y número de argumentos debe estar presente en algún
lugar válido del programa antes de poder invocarla.
A través de los parámetros reales de la llamada, se proporciona a la función la

información que necesita para cumplir su cometido y al momento de hacer la llamada, se
produce una asociación automática entre los parámetros reales y los parámetros

formales. Esta asociación se realiza según el orden de aparición de izquierda a derecha

de los parámetros formales de la función.
Como regla general el parámetro real y su correspondiente parámetro formal deben ser
del mismo tipo. Si el parámetro formal no es del mismo tipo que el parámetro real, en
algunos lenguajes, como Pascal, se produce un error de compilación; en otros lenguajes,
como el lenguaje C, ocurre una conversión implícita de tipos, si es posible.
2.3 Pasos para Hacer la Llamada a una Función
Cuando se efectúa la llamada, se cede el control a la función y se asocia, es decir, se

asigna, el valor de cada parámetro real al parámetro formal correspondiente, siempre por
orden de aparición de izquierda a derecha. Se produce un error cuando no coincidan los
tipos o el número de parámetros formales y reales.
Si la llamada a la función es válida entonces se ejecutan las acciones de la función hasta

que se encuentre una instrucción del tipo ‘retorno <valor>’. Esta instrucción pondrá fin a
la ejecución de la función y el control se pasa al punto siguiente de donde se efectuó la
llamada. Pueden existir varias sentencias de retorno en la misma función, colocadas en
diferentes bloques de código y normalmente dependen de sentencias condicionales para
su ejecución.
En resumen, se asocia el valor retornado con el nombre de la función y se devuelve el

control al subprograma que hizo la llamada, sustituyendo así el nombre de la función por
el valor devuelto.
Ejemplo 4.1
Se necesita una función que calcule la mitad del valor que recibe como parámetro.
Suponga que el parámetro es un valor entero.
1. Funcion mitad (n: entero): real

2. Var med: real
3. Inicio
4. med = n / 2
5. Retorno med
6. Fin mitad
7. Algoritmo calcular_mitad
8. Var num: entero
9. Inicio
10. Escribir “Introduzca un número entero para hallar su
mitad: ”
11. Leer num

12. Escribir “La mitad de “ num ” es “ mitad(num)

13.Fin
En este ejemplo la función mitad() se llama desde una expresión.
Fin del Ejemplo 4.1
3. Procedimientos
Un procedimiento es un subprograma que realiza una determinada tarea, pero que tras
ejecutar esa tarea no tiene ningún valor asociado a su nombre, como ocurre en las
funciones. Si un procedimiento devuelve información, lo hace a través de parámetros de
entrada-salida o de salida.
Al invocar un procedimiento, se le cede el control, comienza a ejecutarse y cuando

termina devuelve el control a la instrucción siguiente, al punto donde se efectuó la
llamada.
3.1 Diferencias entre Funciones y Procedimientos
Las funciones están diseñadas para devolver un único valor y un procedimiento puede
devolver ningún o muchos valores por medio de sus argumentos o parámetros.
Ninguno de los resultados devueltos por el procedimiento se asocia a su nombre como

ocurre con la función.
Mientras que la llamada a una función siempre puede formar parte de una expresión, la
llamada a un procedimiento es una instrucción aislada, que por sí sola no puede formar
parte de una expresión.
3.2 Sintaxis
La sintaxis para declarar un procedimiento es esencialmente la misma que para definir

una función, sólo que no se coloca un tipo de retorno asociado. La cabecera va a estar
formada por el nombre del procedimiento que será un identificador válido y que debe ser
significativo. Luego, entre paréntesis, se deben colocar los parámetros o argumentos
formales que requiere el procedimiento. Por cada parámetro es necesario indicar el tipo
de paso de parámetro.
En el cuerpo del procedimiento se colocan todas las sentencias necesarias para cumplir
con su tarea y no habrá ninguna sentencia de tipo ‘retorno <valor>’. Ahora bien, si el
procedimiento devuelve resultados a través de sus parámetros, cosa que sólo podrá
hacer a través de los parámetros que se pasan por referencia, tendrán que existir
sentencias de asignación de valores a estos parámetros pasados por referencia para
devolver los resultados.

3.3 Pasos para Hacer la Llamada a un Procedimiento
En primer lugar, desde el programa principal o subrutina, se coloca el nombre del

procedimiento con su lista de parámetros reales entre paréntesis como una sentencia
única. Esto cede el control al procedimiento que se llama y después de esto lo primero
que se hace es sustituir cada parámetro formal de la definición, por el parámetro actual o
real asociado a él en la llamada. Esta asociación entre parámetros formales y reales se
realiza de izquierda a derecha por orden de ubicación. Para que se pueda producir la
asociación tienen que existir el mismo número de parámetros formales que reales y
además, el tipo de dato tiene que coincidir con el del parámetro formal asociado. Se
produce un error en la llamada al procedimiento si no se cumple alguna de estas
condiciones.
Si la asociación ha sido correcta, comienzan a ejecutarse las instrucciones del

procedimiento hasta llegar a la última instrucción. Al llegar a la instrucción, se vuelven a
asociar los parámetros formales que devuelven los resultados a los parámetros reales
asociados en la llamada, es decir, de esta manera algunos de los parámetros reales de la
llamada ya contendrán los resultados del procedimiento.
Finalmente, se cede el control a la instrucción siguiente a la que efectuó la llamada al

procedimiento.
Ejemplo 4.2
1. Procedimiento mitad (num:entero, ent-sal med:real)
2. Inicio
3. med = num / 2
4. Fin mitad
5. Algoritmo calcular_mitad
6. Var
7. n: entero
8. mit: real
9. Inicio
10. Escribir “Introduzca un número”
11. Leer n
12. mitad (n, mit)
13. Escribir “La mitad es” mit
14. fin
En el ejemplo anterior ent-sal med: real, se usa para indicar que el parámetro del tipo real
med es de entrada-salida o que es un parámetro por referencia. Cada lenguaje de
programación definirá su propia sintaxis para indicar cuándo los parámetros son por valor
o por referencia.

4. Ámbitos: Variables Globales y Locales

El ámbito de un identificador ya sea variable, constante, función, entre otros, se refiere a
la parte del programa en la que se conoce y por tanto se puede usar al identificador.
Recuerde que un identificador es un nombre construido bajo ciertas reglas de sintaxis y se
asocia a un elemento del programa.
Existen dos tipos de ámbitos básicos:

• El ámbito global: Se refiere a los identificadores que se declaran dentro del
programa principal y fuera de cualquier otro bloque de código. Al ser declarados
de esta forma, los identificadores globales están disponibles a lo largo del
programa y podrán ser usados en cualquier parte del mismo, de allí su nombre de
globales porque se dice que son globales al programa.
• El ámbito local: Se refiere a los identificadores declarados dentro de un bloque de
código diferente al programa principal, como por ejemplo una subrutina o
procedimiento, siendo visibles y accesibles, por lo tanto sólo dentro de ese bloque
de código específico.
Como regla general todo identificador sólo es visible y accesible dentro del bloque de
código que lo declara y dentro de los bloques anidados que éste último pueda tener. Lo
contrario no es cierto, es decir, los identificadores declarados en un sub-bloque de código
no son visibles ni accesibles desde el bloque de código del cual depende.
El ámbito es importante cuando se trabaja con variables, por lo que se tienen variables
locales y globales
4.1 Variable Local
Una variable local es aquella que está declarada y definida dentro de un subprograma o
sub-bloque de código, por lo tanto, su ámbito coincidirá con el ámbito del subprograma en
la que esté definida.
Esto quiere decir que la variable no tiene ningún significado, no se conoce y no se puede
acceder a ella desde fuera del subprograma o bloque de código. Tiene una posición de
memoria distinta a la de cualquier otra variable del programa, incluso si es de una variable
que tiene el mismo nombre pero que está definida fuera del subprograma.
Las variables locales de un subprograma se definen en la parte de definición de variables

del mismo. Los parámetros formales que se le ponen a un subprograma se comportan
dentro de él como si fueran también variables locales al subprograma.
Si se tiene una variable local con el mismo identificador que una variable global, las
referencias que se hacen dentro del bloque de código en que se declara la variable local,
harán referencia a dicha variable local y no a la variable global.

4.2 Variable Global
Una variable global es aquella que está definida a nivel del programa, es decir, su ámbito
es el programa o algoritmo principal y todos los subprogramas que dependen de éste
último.
Una variable global se puede acceder desde cualquiera de los subprogramas y cualquier
parte del programa principal, salvo que alguno de esos subprogramas tenga definida una
variable local con el mismo nombre que la variable global. En este caso, si se utiliza el
nombre de esa variable se va referir a la local, nunca a la global, ya que ambas variables
tienen ubicaciones de memoria diferentes.
Hay que ser cuidadosos a la hora de usar variables globales, ya que como todos los
subprogramas las pueden modificar, es posible que se pueda hacer un uso indebido o se
produzcan efectos indeseados cuando un subprograma utilice una variable global sin
saber que otro subprograma ya ha modificado su valor. Esta es la razón por la cual no se
deben utilizar variables globales para pasar información entre los subprogramas, para tal
fin, se recomienda usar variables locales por medio de parámetros reales.
4.3 Procedimientos Anidados
La anidación de procedimientos no se permite en todos los lenguajes y consiste en que

dentro de un procedimiento se pueda definir o declarar el código completo de otros
procedimientos.
Si la anidación de procedimientos está permitida, se plantean más problemas en cuanto al

ámbito, desde este punto de vista, se dice que una variable local se conoce en el
procedimiento en el que está definida y en todos los procedimientos anidados que
componen el ámbito de dicho procedimiento. Salvo que en alguno de esos procedimientos
anidados, se defina una variable local con el mismo nombre que la global, en cuyo caso,
dentro de ese procedimiento siempre se va a referir a la variable local, porque siempre se
considera el ámbito más restringido.
A continuación, se presenta la Figura 4.2, la cual es un ejemplo de declaración de

variables en diferentes ámbitos:
PP
P1 Var a, b
Var a, c, d
P1.1
Var d, e, f
P2
Var c, d
Figura 4.2: Ejemplo del Ámbito de la Declaración de Variables

En la declaración anterior de variables dentro de los diferentes procedimientos, su

visibilidad será como la representada en la Tabla 4.1.
VARIABLE AMBITO ÁMBITO SUBPROGRAMA

A PP PP, P2
B PP PP, P1, P1.1, P2
A P1 P1, P1.1
C P1 P1, P1.1
D P1 P1
D P1.1 P1.1
E P1.1 P1.1
F P1.1 P1.1
C P2 P2
D P2 P2
Tabla 4.1: Visibilidad de la declaración de variables anterior
5. Comunicación entre Subprogramas: Paso de

Parámetros
La mejor forma para llevar a cabo la comunicación entre subprogramas, es a través del
paso de parámetros. Cuando se invoca una función o procedimiento se le pasan, a través
de los parámetros los datos que necesita. En el caso de un procedimiento, los resultados
también se devuelven a través de sus parámetros. Para ello, se define el tipo del
parámetro al principio del subprograma, que es lo que se conoce como parámetros
formales. Al hacer la llamada se pasan los datos a través de los parámetros reales.
5.1 Cómo se Efectúa la Correspondencia entre Parámetros Formales y

Reales
Existen dos métodos para realizar la correspondencia entre parámetros formales y reales,
los cuales se explican a continuación:
5.1.1 Correspondencia Posicional

En este caso se hacen corresponder los parámetros formales y reales por la posición que
ocupan (orden de declaración) de izquierda a derecha. Para que se pueda realizar esta
asociación, tiene que haber el mismo número de parámetros formales y reales, además el
parámetro formal debe ser del mismo tipo que el parámetro real correspondiente.
Si se tiene el procedimiento:
Proc(x : entero, y : real)

Una llamada válida es:

Proc(8, a)
Donde ‘8’ es una constante literal entera y ‘a’ es una variable real previamente definida.
En este caso, al efectuar la llamada al parámetro formal ‘x’, se le asigna el valor de 8 y al
parámetro formal ‘y’ se le asignara el valor que tenga almacenado el parámetro real
definido por la variable ‘a’.
5.1.2 Correspondencia por Nombre Implícito

En este enfoque, en la llamada al subprograma, se coloca explícitamente a que parámetro
formal corresponde cada parámetro real.
En la llamada, se coloca el nombre del parámetro formal, separado por dos puntos (:) y
seguido por el nombre del parámetro real que se pasa, de esta forma no importa la
posición en la que se colocan los argumentos del procedimiento o función.
Para el ejemplo anterior y bajo este enfoque las siguientes llamadas son válidas:
Proc(x : 8, y : a)
Proc(y : a, x : 8)
ADA es un lenguaje de programación que permite la correspondencia de parámetros por
nombre implícito.
A lo largo de este manual se usará siempre el método de correspondencia posicional.
5.2 Tipos de parámetros
Existen tres tipos básicos de parámetros según su uso como entrada de datos o para
obtener resultados. Estos son:
• De Entrada: Son parámetros que sólo aportan el valor que tienen, como entrada
al subprogama al que pertenecen como parámetros. En el caso de las funciones,
todos sus parámetros son de este tipo. Como sólo sirven como entrada, sólo
pueden ser leídos, pero no modificados. Aunque sean modificados dentro de un
subprograma, esa modificación no va a tener efecto fuera del subprograma.
• De Salida: Se usan sólo y exclusivamente para devolver resultados a través de
ellos. Su valor al hacer la llamada al subprograma no es de relevancia. Ese valor
sólo va a tener sentido cuando termine la ejecución del subprograma. Un
parámetro de este tipo teóricamente nunca se puede leer, sólo se va actualizar o
modificar.
• De Entrada y Salida: El valor del parámetro tiene importancia tanto a la entrada
como a la salida del subprograma. Aporta dato cuando se llama al subprograma y
por otra parte, devuelve a través de él los resultados cuando se termina el
subprograma. En este caso, tiene sentido tanto poder leer como actualizar el
parámetro.

ADA es un lenguaje que soporta los tres tipos de pase de parámetros suministrados. Se
ponen como In, Out e In-Out respectivamente.
La mayoría de otros lenguajes sólo permiten dos tipos de parámetros: de entrada sólo
para leer datos y de entrada-salida para leer datos y devolver resultados.
5.3 Métodos de Paso de Parámetros
Existe una variedad de métodos definidos para el paso de parámetros, para efectos de
este manual sólo se estudiarán dos de ellos por ser los más utilizados y conocidos en las
herramientas de programación.
El paso de parámetros se va a clasificar en:

• Paso de parámetros por copia o por valor.
• Paso de parámetros por referencia.
5.3.1 Paso de Parámetros por Copia o Valor

La característica fundamental de este método de paso de parámetros es que la función o
procedimiento invocado, no puede modificar el valor de los parámetros reales. Al
realizarse la llamada a la función, se copia el valor del argumento en el parámetro formal
de la función. El parámetro formal de la función tiene asociada una dirección de memoria
diferente a la dirección de memoria del parámetro real, por lo tanto, este parámetro formal
se comporta como una variable local en la función o procedimiento al cual pertenece. Se
puede cambiar el valor del parámetro dentro de la rutina y no repercutirá en el argumento
originalmente transferido, ya que comparten direcciones de memoria diferentes e
independientes.
El parámetro real puede ser: una constante, expresión o variable. Como ya se sabe,
nunca se va a usar para devolver resultados a través de él; por esa razón, puede ser una
constante o una expresión, porque al no devolver resultados a través del parámetro, no
necesita tomar ninguna ubicación de memoria para almacenarlo.
Observe el siguiente ejemplo:
Ejemplo 4.3
1. Procedimiento Duplicar(x : entero)

2. Inicio
3. x = x * 2
4. Escribir x
5. Fin Duplicar
6. Algoritmo CopiaValor
7. Var a : entero

8. Inicio
9. a = 3
10. Duplicar(a)
11. Escribir a
12. Fin
El valor de ‘a’ será 3 y el de ‘x’ será 6.
Fin del Ejemplo 4.3
5.3.2 Paso de Parámetros por Referencia

La característica fundamental de este método de paso de parámetros es que la función
invocada puede modificar el valor de los parámetros reales.
Al realizar la llamada a la función o procedimiento, se almacena la dirección de memoria

de su parámetro real asociado, es decir, el parámetro formal apunta a la dirección de
memoria del parámetro real que tiene asociado. Cualquier modificación que se efectúe
sobre el parámetro formal dentro de la función, tendrá un efecto directo en el parámetro
real asociado, ya que se modificará el valor almacenado en la dirección de memoria que
indica el parámetro formal, que es a su vez la dirección de su parámetro real asociado.
El parámetro real no puede ser ni constantes ni expresiones. Sólo pueden ser variables.
Para indicar que el tipo de paso de parámetro es por referencia, se va a utilizar la palabra
clave ent-sal precediendo al parámetro que se pasa por referencia.
Procedimiento Duplicar(ent-sal x : entero)
Inicio
x = x * 2
Fin Duplicar
Algoritmo Referencia
Var a
Inicio
a = 3
Duplicar(a)
Escribir(a)
Fin
Al finalizar el algoritmo, el valor de ‘a’ será igual a 6, valor asignado a ‘x’ en el
subprograma Duplicar().
De acuerdo a lo estudiado en los dos puntos anteriores se puede resumir que en el paso
de parámetros por:

• Valor: El parámetro actual no cambia de valor.

• Referencia: El parámetro actual puede cambiar de valor.
6. Recursividad
Se dice que un subprograma es recursivo cuando se llama a sí mismo. La recursividad se
puede utilizar en subprogramas que se pueden definir en términos recursivos, es decir, en
términos de sí mismo, como procesos de alguna manera repetitivos.
Un ejemplo de definición recursiva es el de la función matemática factorial, donde:

Factorial(x) = x * Factorial(x-1)
Note como se utiliza la función factorial para definir el factorial de un número entero.
Hay que ser cuidadosos al utilizar la recursividad e incluso evitarla siempre que sea
posible utilizando algoritmos iterativos. Cada vez que un subprograma se llama a sí
mismo, hay que almacenar en la pila del sistema (un lugar de memoria especial) la
dirección de retorno de ese subprograma. De esta forma, si se efectúan muchas llamadas
recursivas se irá llenando la pila del sistema, existiendo la posibilidad de que se agote la
memoria disponible. Esta situación se conoce como desborde de la pila del sistema.
Todo programa recursivo tiene que tener alguna condición que ponga fin a la recursividad,
un punto en el que el subprograma deje de llamarse a sí mismo cuando se cumpla la
condición. De otra forma, se genera un bucle infinito con el consecuente error de
desbordamiento de pila mencionado anteriormente.
En el ejemplo de la función factorial, la condición de control es que el factorial de todo

número menor o igual a 1 es 1.
De aquí:
si (x > 1) entonces
Factorial(x) = x * Factorial(x-1)
sino Factorial(x)=1
La función factorial en forma recursiva:
Funcion FactorialRecursiva(x : entero): entero
Inicio
Si (x > 1) entonces
Retornar (x * FactorialRecursiva(x – 1))
Sino
Retornar 1
Fin FactorialRecursiva

Si se realiza el cálculo del factorial de 4, la función al ejecutarse realizaría los siguientes

pasos:
x=4
Factorial(4)=4*Factorial(3)
retorno Factorial=24
x=3
retorno
Factorial=6
x=2
retorno
Factorial=2
x=1
Factorial(1)=1
retorno Factorial=1
Figura 4.3: Pasos para calcular el factorial de 4
A continuación se presenta el Ejemplo 4.4 para efectuar la función factorial en forma

iterativa:
Ejemplo 4.4
1. Funcion FactorialIterativa(x : entero): entero
2. Var
3. res : entero
4. i : entero
5. Inicio
6. res = x
7. Si (x > 1) entonces
8. Desde i = x - 1 hasta 1
9. res = res * i

10. Fin Desde

11. Sino
12. res = 1
13. Retorno (res)
14. Fin FactorialIterativa
Toda función recursiva puede expresarse en forma iterativa, lo contrario no es cierto.
Fin del Ejemplo 4.4
Como guía para el uso o no de la recursividad, puede considerarse:

• Las funciones y procedimientos recursivos se pueden utilizar, cuando los datos
del problema están organizados en una estructura de datos que se define
recursivamente.
• Si un algoritmo no recursivo se puede obtener y es menos complejo que el
recursivo, es mejor utilizar el no recursivo.
• No debe usarse la recursividad a menos que se tenga un medio para terminar
las llamadas recursivas.
• Cada llamada recursiva requiere la asignación de espacio de memoria para
todas las variables locales, parámetros por valor y la dirección de retorno. Por
lo que cada llamada utiliza memoria, lo que representa una limitación.

Resumen
• Definir qué son las funciones.
• Listar las características de las funciones.
• Conocer la sintaxis de las funciones.
• Definir los Procedimientos.
• Listar las características de los procedimientos.
• Explicar el Ámbito de las Variables.
• Explicar la comunicación entre subprogramas.
• Definir que es la recursividad.

1) En relación a las Funciones, ¿Cuáles de siguientes afirmaciones son correctas?

I. Un programador puede establecer que la función devuelva o no un valor
II. Es necesario que en el cuerpo se incluya una sentencia retorno <valor>
III. Se puede devolver varios resultados asociados al nombre de la función
IV. El parámetro real de una función puede ser el valor de retorno de otra función
a) I, II, IV
b) II, III, IV
c) I, II, III, IV
2) Los parámetros pueden ser pasados por:

a) Referencia
b) Copia
c) Constantes
3) Con respecto a la recursividad, ¿Cuáles de las siguientes afirmaciones no son

verdaderas?
I. Todo algoritmo recursivo debe tener una condición que finalice la recursividad
II. Todo algoritmo iterativo puede ser reescrito como un algoritmo recursivo
III. Los algoritmos iterativos son menos eficientes que los algoritmos recursivos
IV. Un programa recursivo puede ocasionar un desborde de pila del sistema
a) I, II, IV
b) II, III
c) I, IV
d) II, III, IV
4) La mayoría de los lenguajes sólo permiten tipos de parámetros de entrada y de

salida
a) Verdadero
b) Falso

5) Con respecto a la anidación de procedimientos ¿Cuál de las siguientes afirmaciones

es cierta?
a) Está permitida en todos los lenguajes
b) Se presentan problemas en el ámbito de las variables
c) El procedimiento interno únicamente es visto por el procedimiento externo al
cual pertenece.
d) Una variable x en el procedimiento externo puede ser ocultada por una variable
x en el procedimiento interno.
6) La cabecera de una función comprende:

a) Tipo de dato de retorno
b) Lista de parámetros
c) Identificador
d) Grupo de sentencias
7) Con relación a los procedimientos, ¿Cuáles de las siguientes afirmaciones son

verdaderas?
I. Sólo pueden devolver cero o un valor por sus parámetros
II. Por si solos pueden formar parte de una expresión
III. El valor devuelto es asociado al nombre del procedimiento
IV. Puede recibir sólo parámetros por referencia
a) I, II
b) II, III, IV
c) III, IV
8) El valor de un parámetro por referencia pasado a una función no puede ser

modificado dentro de ella
a) Verdadero
b) Falso
9) Dado el siguiente algoritmo:

Procedimiento Duplicar(x:entero)
Inicio
x=x*2
Fin Duplicar
Algoritmo Sumar
Var a,b: entero
Inicio

a=3
b=Duplicar(a)+Duplicar(a)
Escribir(b)
Fin
Se puede decir que el algoritmo está bien elaborado y funciona correctamente
a) Verdadero
b) Falso
10) Las variables locales a una función o procedimiento sólo existen dentro del contexto
en donde se encuentran definidas
a) Verdadero
b) Falso

1) a
2) a y b
3) b
4) b
5) b, c y d
6) a, b y c
7) d
8) b
9) b
10) a


• Conocer las estructuras de datos.
• Trabajar con arreglos unidimensionales o vectores.
• Realizar operaciones con arreglos unidimensionales o vectores.
• Trabajar con arreglos bidimensionales o matrices.
• Conocer los arreglos multidimensionales.
• Entender el almacenamiento de arreglos en memoria.
Unidad 5: Estructura de Datos: Arreglos Libro 1: Fundamentos de Programación 83

1. Introducción
En las unidades anteriores se estudiaron los conceptos de algoritmos y programas, así
como una serie de elementos, entre ellos, la lógica, que ayudan a resolver problemas
computacionales. También se discutió cómo un programa o algoritmo puede ser
representado gráficamente mediante un diagrama de flujo y se trabajó con los principios
de la programación estructurada, sus recursos y técnicas. Ésta unidad se ocupa de
estudiar una de las representaciones de datos más usadas en programación: Los Arreglos
o Vectores. Los arreglos se utilizan para almacenar datos consecutivos de un mismo tipo,
por lo que se usan generalmente en algoritmos de clasificación, ordenamiento y
búsqueda.
2. Arreglos Unidimensionales: Arreglos o Vectores

Un arreglo unidimensional o vector, es un conjunto finito, consecutivo y organizado de
elementos homogéneos, es decir, elementos pertenecientes a un mismo tipo de dato.
Se dice que es:

• Finito: El arreglo tiene un número determinado de elementos.
• Homogéneo: Todos los elementos del arreglo son del mismo tipo.
• Organizado: Existe una forma de referenciar cada elemento del arreglo y de
acceder a cada uno de sus elementos de manera independiente.
• Consecutivo: Por la forma en que se almacena o representa un vector en la
memoria del computador, en posiciones consecutivas de la memoria.
Para referenciar cada elemento de un arreglo se usa el índice, que es un valor que directa
o indirectamente referencia la posición del elemento dentro del arreglo.
Los índices deben ser de cualquier tipo de datos escalar, porque en un escalar se puede
definir un orden y entre dos elementos consecutivos no puede haber infinitos elementos.
Un ejemplo de datos escalares son los enteros y caracteres. Normalmente, como índices
se van a utilizar números enteros.
Para referenciar un elemento de un arreglo se usa el nombre del arreglo y entre corchetes
([ ]) el índice que determina la posición de ese elemento en el arreglo.
El rango o longitud de un vector o arreglo lineal es la diferencia entre el índice de valor

máximo en el arreglo y el índice de valor mínimo + 1. Normalmente, los índices comienzan
a enumerarse desde 0 ó 1, como el valor mínimo del índice, dependiendo del lenguaje de
programación (en Pascal inician con 1 y en ‘C’ inician con 0). Sin embargo, nada impide
que comiencen con cualquier otro valor.
Los arreglos se almacenan siempre en posiciones consecutivas de memoria y se puede

acceder a cada elemento del arreglo de manera independiente, a través de los índices.
Un índice no tiene porque ser un valor constante, puede ser también una variable o una
Libro 1: Fundamentos de Programación Unidad 5: Estructura de Datos: Arreglos 84

expresión que al ser evaluada devuelva un valor escalar que se encuentre entre el índice
menor y el índice mayor del arreglo o ambos inclusive.
2.1 Definición de un Arreglo o Vector
Para definir un arreglo, se da el nombre del arreglo, el rango de sus índices y el tipo de los
datos que contiene. Esto es:
<nom_arreglo>: arreglo [rango] de <tipo>
Ejemplo:
sueldo: arreglo[8] de real
i: entero
i = 2
sueldo[i]= 23.5
Si el valor mínimo del rango del índice es 1 la sentencia sueldo[i]= 23.5 asigna el valor
23.5 a la segunda posición de un arreglo de ocho elementos.
Si el valor mínimo del rango del índice es 0 la sentencia sueldo[i]= 23.5, se asigna el valor
23.5 a la tercera posición de un arreglo dado que el valor del índice i es 2.
Se considera un error intentar acceder a una posición del arreglo que esté fuera del rango
del índice. Este error se denomina comúnmente ‘índice fuera de rango’.
2.2 Operaciones con vectores
Se va a usar la declaración de vector:

ventas: arreglo[12] de entero
Gráficamente éste vector puede representarse como:
1 2 3 4 5 6 7 8 9 10 11 12
2.2.1 Asignar un Dato a una Posición del Arreglo

Consiste en asignar un valor dado a una posición del arreglo dada por un índice.
La sintaxis de ésta operación es:

<nom_arreglo>[indice] = valor
Ejemplo: Asignar el valor 600000 a la posición 5 del vector.
ventas[5] = 600000
2.2.2 Lectura y Escritura de Datos

Consiste en usar una posición cualquiera del arreglo definida por un índice para
operaciones de entrada y salida.

La sintaxis para estas operaciones es:
Leer <nom_arreglo>[indice]
Escribir <nom_arreglo>[indice]
Ejemplo 5.1
Leer y mostrar las ventas de los 12 meses del año y almacenarlas en un vector.
1. Desde i = 1 Hasta 12
2. Escribir “Introduzca las ventas del mes ” i
3. Leer ventas[i]
4. Fin Desde
6. Escribir “Ventas del mes ” i ” = ” ventas [i]
7. Fin Desde
Fin del Ejemplo 5.1
2.2.3 Recorrido o Acceso Secuencial de un Arreglo

Consiste en pasar por todas las posiciones del arreglo para procesar su información.
Usualmente, se usa un ciclo ‘Desde’ para recorrer el vector.
La sintaxis de esta operación es:

Desde indice = 1 Hasta Rango_Arreglo
<acciones con el arreglo>
Fin Desde
Ejemplo 5.2
Sumar 1 millón a las ventas de cada mes.
2. Ventas[i] = ventas[i] + 1000000
3. Fin Desde
Fin del Ejemplo 5.2

2.2.4 Actualización de un Arreglo
• Añadir Datos
Es un caso especial de la operación de inserción de un elemento en un arreglo, donde el
elemento nuevo se agrega después de la última posición que contiene información válida
en el arreglo. Para hacer esta operación, es necesario que si actualmente el arreglo tiene
k posiciones de información válida, tenga un tamaño de al menos k + 1 para que se pueda
añadir otro elemento a continuación del elemento en la posición k.
Sintaxis: <nom_arreglo>[K + 1] = valor

• Insertar Datos
Consiste en introducir un elemento en una posición del interior de un arreglo, para lo cual
será necesario desplazar una posición a la derecha a todos los elementos que estén a la
derecha de donde se va a insertar el elemento, esto con el fin de conservar el orden
relativo entre los elementos.
Para que se pueda insertar un nuevo elemento en el arreglo, si ya existen n elementos

con información en el arreglo, el arreglo tendrá que tener un tamaño al menos de n + 1
para poder insertar el nuevo elemento.
C E F J M O
Al insertar ‘G’ en la cuarta posición queda:
C E F G J M O
Si k es la posición donde se va a insertar el nuevo elemento, n es el número de elementos

válidos en el arreglo en el momento de la inserción y suponiendo un tamaño mínimo de n
+ 1, el algoritmo de inserción es:
Desde i= n hasta k con decremento 1
A[i+1] = A[i]
Fin Desde
A[k] = valor
Ejemplo 5.3
Insertar 30000 correspondientes a las ventas del mes 5.
1. Desde i= 11 hasta 5 con decremento 1

2. ventas[i + 1] = ventas[i]

3. Fin Desde
4. ventas[5] = 30000
Fin del Ejemplo 5.3
• Eliminar Datos
Para eliminar un elemento de un arreglo, si ese elemento está posicionado al final del
arreglo, no hay ningún problema, simplemente si el tamaño del arreglo era n, ahora hay
que considerar que el tamaño del arreglo es n - 1.
Si el elemento a eliminar ocupa cualquier otra posición, entonces se tendrán que

desplazar una posición hacia la izquierda todos los elementos situados a la derecha del
elemento a borrar, para que el arreglo quede organizado.
C E F J M O
Al borrar el elemento J de la cuarta posición.
C E F M O
Suponiendo que el número de elementos válidos actualmente es “n” y que se desea

borrar el elemento de la posición k.
Desde i = k Hasta n - 1
A[i] = A[i+1]
Fin Desde
Ejemplo 5.4
Eliminar las ventas registradas en el mes 4 y desplazar las de los meses subsiguientes
hacia la izquierda.
1. Desde i= 4 Hasta 11
2. ventas[i] = ventas[i+1]
3. Fin Desde
4. El número de elementos validos n es ahora n = n – 1
Fin del Ejemplo 5.4

3. Arreglos Bidimensionales: Matrices m x n

En un arreglo unidimensional o vector cada elemento es referenciado por un índice. En un
arreglo bidimensional cada elemento se va a referenciar por 2 índices.
La representación lógica de un arreglo bidimensional es una matriz de dimensiones M x

N, donde M es el número de filas de la matriz y N es el número de columnas, es decir, la
1ª dimensión indica las filas y la 2ª dimensión indica las columnas. Al acceder a un
elemento I,J se está accediendo al elemento que ocupa la fila I y la columna J.
Un arreglo bidimensional de M x N elementos es un conjunto de M x N elementos, todos

del mismo tipo, cada uno de los cuales es referenciado a través de 2 subíndices. El primer
subíndice varía entre 1 y M o entre 0 hasta M-1, dependiendo desde donde comience el
índice. El segundo índice varía entre 1 y N o entre 0 y N-1.
En general se puede definir un arreglo de 2 dimensiones de la siguiente manera:

<nombre arreglo>: arreglo[rango-filas, rango-columnas] de
<tipo de dato>
Así la matriz para la representación de las ventas mensuales de cinco años será:
ventas: arreglo[5, 12] de real

tamaño = m x n = 5 x 12 = 60
En memoria, sin embargo todos los elementos del arreglo se almacenan en posiciones
contiguas.
Matriz de ventas 5 x 12, total de 60 elementos:
1 2 3 4 5 6 7 8 9 10 11 12
1
2
3
4 120
5
ventas[4, 3] = 120
En memoria se almacenan los elementos en forma consecutiva:
1,1 1,2 1,3 1,4 ... 1,12 2,1 2,2 2,3 … 5,1 ... 5,12

3.1 Manejo de Matrices
3.1.2 Colocar el Valor de Cero a todos los Elementos de la Matriz

Esta es una operación útil cuando se desea inicializar todos los elementos de la matriz a
un valor dado, usualmente ese valor es cero, aunque bien podría ser cualquier otro valor
válido.
Sintaxis
M: arreglo[m, n] de entero
Var i, j : entero
Desde i = 1 Hasta m
Desde j = 1 Hasta n
M[i, j] = 0
Fin Desde
Fin Desde
Ejemplo 5.5
Inicializar la matriz de ventas mensuales para 5 años.
1. ventas: arreglo[5, 12] de entero

2. Var i, j : entero
4. Desde j = 1 Hasta 12
5. ventas[i, j] = 0
6. Fin Desde
7. Fin Desde
Fin del Ejemplo 5.5
3.1.3 Colocar el valor de cero a sólo los elementos de una fila dada
En este caso, se mantiene fija la fila y se recorren las columnas asignándoles un valor
suministrado, usualmente ese valor es cero.
Sintaxis
M: arreglo[m, n] de entero
Var i, j : entero
i = fila
Desde j = 1 Hasta n
M[i, j] = 0
Fin desde

Ejemplo 5.6
Inicializar las ventas mensuales del año 3.
1. ventas: arreglo[5, 12] de entero

2. Var i, j : entero
3. i = 3
4. Desde j = 1 Hasta 12
5. M[i, j] = 0
6. Fin desde
En este caso, se le asignó el valor de cero a los elementos de la tercera fila de la matriz
ventas.
Fin del Ejemplo 5.6
4. Arreglos Multidimensionales: Matrices m x n x...z

Un arreglo multidimensional es una matriz de 3 ó más dimensiones. Si se tiene un arreglo
de N dimensiones, donde cada dimensión es de tamaño d1,d2,..,dN, el número de
elementos del arreglo será d1xd2x..xdN.
Para acceder a un elemento del arreglo se utilizan N índices, cada uno de los cuales
referencia a una posición dentro de una dimensión, siempre según el orden de
declaración.
En memoria, el arreglo se sigue almacenando en posiciones consecutivas.
La declaración de un arreglo multidimensional será:

Nom_arreglo: arreglo[rangoI, rangoII, ..., rangoN] de tipo
Ejemplo 5.7
Definir la matriz de ventas mensuales por cinco años para tres vendedores y asignar a las
ventas del mes 10 del cuarto año para el vendedor 2, la cantidad de 120000.5.
ventas : arreglo[3, 5, 12] de real

ventas[2, 4, 10]= 120000.5
Fin del Ejemplo 5.7
5. Almacenamiento de Arreglos en Memoria

Un arreglo en memoria siempre se almacena en posiciones contiguas a partir de la
dirección base de comienzo del arreglo, la cual se asigna cuando se declara una variable
del tipo arreglo.

El tamaño que ocupa el arreglo en memoria es el producto del número de sus elementos
por el tamaño de cada uno de ellos. Por ejemplo, Arreglo[100] de carácter, si se asume
que cada carácter necesita un byte para ser almacenado, entonces el arreglo necesita un
total de 100 bytes de memoria: 1 byte x 100 elementos = 100 bytes.
En el caso de un arreglo multidimensional, también se almacena en posiciones contiguas

de memoria. Su tamaño será el producto de sus elementos por el tamaño requerido para
representar cada elemento en memoria. Por ejemplo, Arreglo[3, 5, 12] de enteros, si se
asume que cada entero necesita dos byte para ser almacenado y se tiene un total de 3 x
5 x 12 = 180 elementos, entonces el arreglo requiere un total de 360 bytes de memoria: 2
bytes x (3 x 5 x 12) elementos = 360 bytes.

Resumen
• Conocer las estructuras de datos.
• Trabajar con arreglos unidimensionales o vectores.
• Realizar operaciones con arreglos unidimensionales o vectores.
• Trabajar con arreglos bidimensionales o matrices.
• Conocer los arreglos multidimensionales.
• Entender el almacenamiento de arreglos en memoria.

1) Un vector es un conjunto finito, consecutivo y organizado de elemento heterogéneos.

a) Verdadero
b) Falso
2) Si se asume que el tipo de dato real requiere 4 bytes para su almacenamiento,

¿cuántos bytes se necesitan en memoria para almacenar la matriz Arreglo[2,3,5] de
real?
a) 10 bytes
b) 30 bytes
c) 120 bytes
d) 120 bits
3) La representación lógica de un arreglo bidimensional es una matriz de dimensiones

M x N donde M representa:
a) El número de la dimensión del vector
b) El número de filas de la matriz
c) El número de columnas de la matriz
4) Un índice puede ser un valor constante.

a) Verdadero
b) Falso
5) Con referencia a los vectores, ¿Cuáles de las siguientes afirmaciones son correctas?
a) La longitud de un vector es dada por la multiplicación del rango del vector por el
tamaño en bytes del tipo de datos.
b) Se almacenan en posiciones lineales o contiguas de memoria.
c) En los índices de un arreglo, por lo común, se utilizan tipos de datos enteros y
caracteres.
d) El tamaño máximo de un arreglo es el tamaño del tipo de datos al que pertenece
menos uno.
6) Se puede utilizar un procedimiento que devuelva un valor entero como índice de un

arreglo.
a) Verdadero
b) Falso

7) El siguiente algoritmo:
M: arreglo [1..N,1..M] de entero
Var i,j entero
Desde i=1 hasta N
Desde j=1 hasta M
M [1,j]= 5
Fin desde
Fin desde
a) Inicializa a cinco todos los elementos del arreglo multidimensional

b) Inicializa a cinco todas las filas del arreglo multidimensional
c) Inicializa a cinco todas las columnas del arreglo multidimensional
8) Todos los lenguajes de programación permiten declarar arreglos multidimensionales.

a) Verdadero
b) Falso
9) Al eliminar el primer elemento de un arreglo de cinco elementos, los restantes

elementos deben ser desplazados hacia la izquierda.
a) Verdadero
b) Falso
10) Dado un arreglo X de M x N elementos, donde los elementos son números enteros,
la dirección de comienzo del elemento 5º del arreglo sabiendo que se almacena a
partir de la dirección 1200 y que en nuestra máquina los enteros ocupan 2 bytes es:
a) 1200
b) 1204
c) 1206
d) 1208


1) b
2) c
3) b
4) a
5) b y c
6) b
7) d
8) b
9) a
10) d

Unidad 6: Entrada y Salida

• Describir los conceptos básicos de entrada y salida en un programa de
computadora.
• Listar algunas consideraciones específicas para imprimir la salida.
• Describir los conceptos de registros de datos fijo, variable y bloqueado.
Unidad 6: Entrada y Salida Libro 1: Fundamentos de Programación 97

1. Introducción
La solución a problemas de la vida real mediante computadoras incluye el uso de
programas especializados para resolver dichos problemas. Los programas generalmente
usarán, leyendo y escribiendo, datos provenientes de fuentes externas. Para que esto sea
posible, las computadoras ofrecen capacidades de entrada y salida que le permiten a las
aplicaciones comunicarse con ese entorno que se encuentra fuera del programa mismo.
En esta unidad se introducen los conceptos básicos de entrada y salida (E/S), mediante
los cuales los programas de computadora pueden intercambiar, capturar y mostrar datos
para la solución de problemas específicos.
2. Entrada y Salida de un Programa

Un programa se carga en la computadora en el Procesador o Unidad Central de
Procesamiento (CPU), cuando el programa se ejecute necesitará probablemente leer
datos o escribir datos desde o hacia algún dispositivo.
El lenguaje que se emplee para escribir un programa tendrá algunos comandos

especiales o funciones que se pueden usar para realizar la entrada y salida de los datos.
La entrada y salida, generalmente son las partes más complejas de cualquier programa o
cualquier lenguaje de programación. La transferencia real de datos hacia o desde los
dispositivos de E/S, suele ser la parte más lenta de un programa.
Los comandos que se usan para la entrada son normalmente: read, get o scan. Los
comandos de la salida son, por su parte: print, write o put.
La Figura 6.1 muestra posibles entradas y salidas de un programa.
Impresora
Teclado
Archivo
Archivo en en disco
disco
PROCESADOR
ENTRADA (programa en SALIDA
ejecución)
Red Pantalla
Red
Scanner
Figura 6.1: Entrada/Salida
Libro 1: Fundamentos de Programación Unidad 6: Entrada y Salida 98

3. Buffers de Entrada y Salida

Los datos externos que se procesan en un programa se leen y escriben realmente en un
buffer que maneja la computadora. Un buffer es un espacio de memoria que el sistema
operativo reserva para operaciones específicas, con la finalidad de acelerar esas
operaciones y así optimizar el rendimiento. El sistema lee físicamente los datos de algún
dispositivo externo a un buffer de entrada y los escribe en un buffer de salida. El sistema
es propietario de los buffers y los administra.
El programa accede a los datos usando estos buffers del sistema, de tal forma que lee del
buffer de entrada y escribe al buffer de salida. El manejo de estos buffers es total
competencia del sistema operativo e ignorado por el programador.
Cuando se empieza el procesamiento con una operación de entrada, el sistema lee los
datos del dispositivo de entrada y llena el buffer de entrada. A medida que se vacían los
datos del buffer de entrada, el sistema sigue la pista del buffer y llena el buffer desde el
dispositivo cuando está vacío.
Igualmente, las operaciones de escritura de un programa se realizan en el buffer de

salida, también monitoreado por el sistema operativo. Cuando el buffer de salida está
lleno, el sistema escribe el contenido del buffer de salida al dispositivo de salida
designado, de forma transparente al programador.
Todo este movimiento de datos externo, lo maneja la parte del sistema operativo
denominada Sistema de Control de I/O (IOCS). El IOCS se ejecuta paralelamente a la
ejecución del programa. Esto significa que el programa puede continuar haciendo lo que
necesite a los datos y el sistema se ocupa de transportarlos hacia y desde los dispositivos
de E/S. Observe la Figura 6.2.

Buffers
Programa
...
Disco E LEER HACER
N (READ) MIENTRAS
T (MAS DATOS)
R LEER
A
D /*
A ESCRIBIR PROCESAR */
(WRITE)
S ESCRIBIR
A FINHACER
L ...
I
D
A
Figura 6.2: Buffers de Datos
4. Imprimir Datos
Imprimir la salida a una impresora requiere ciertas consideraciones especiales como:
• Definir los formatos de salida para las líneas de datos y las líneas de título.
• Contar las líneas impresas para no exceder la hoja de papel.
• Contar las páginas para imprimir el número de página.
• Escribir encabezados de páginas para identificar los datos impresos.
• Control físico del carro de la impresora para imprimir los datos en el lugar
adecuado de la página.
Las situaciones enumeradas anteriormente deben ser manejadas en el programa.
Se puede inferir que hay que considerar formatos especiales cuando se escriben datos a
un dispositivo de impresión. Debe mantenerse un contador de líneas para tener
seguimiento de cuántas líneas se han impreso, para que así se pueda tener control de
cuándo saltar a una nueva página y colocar los encabezados en una nueva página de
salida. Debe mantenerse un contador de páginas que permita colocar el número de la
página en la nueva página y se incremente cada vez que se vaya a imprimir una nueva
página.
Por otra parte, hacen falta formatos específicos de impresión para imprimir las líneas de
datos y las líneas de encabezado. Normalmente, el encabezado de la página requiere de

formatos únicos de línea para las múltiples líneas de encabezado y los encabezados de
columna.
El control de carro le indica a la impresora dónde imprimir la próxima línea.
4.1 Control de Carro de Impresora
La mayoría de los lenguajes de programación que proporcionan acceso directo a una

impresora, también proporcionan un medio para controlar dónde se va a imprimir una
línea. Esto generalmente se hace con un carácter de control en la primera posición de la
impresión de cada línea. En la Tabla 6.1 se presentan los caracteres de control.
Caracteres Acción de Control

espacio Espaciar 1 línea
0 Espaciar 2 línea
_ Espaciar 3 línea
1 Saltar a una nueva página
+ Suprimir espaciado
Tabla 6.1: Caracteres de Control
Los caracteres de control se colocan en la primera posición de la impresión de cada línea

y no se verán en la copia impresa. Este carácter de control siempre se aplica a la línea
que se va a imprimir a continuación.
Cuando se usa el carácter de control “0” se da la apariencia de doble espacio. El “+”

puede usarse para suprimir el espaciado de línea, para dar apariencia de sobreimpresión
(overstrike) o negrita.
4.2 Imprimir Reportes
Como se mencionó anteriormente, cuando se escriben los reportes a una impresora, el

programador tiene que considerar aspectos tales como; encabezados de páginas,
números de las páginas, además de contadores de línea y pie de páginas que serán
necesarias para cada página impresa.
Existen varios tipos de líneas que deben definirse:

• Línea de título: Contiene información que identifica al reporte: fecha, nombre del
reporte y aparece en parte superior de cada página.
• Líneas de encabezados: Los encabezados de las columnas deben ser alineados
con el de los datos.
• Líneas de datos: Son los datos del reporte.

• Líneas de resumen: Son los totales de página, totales finales o información

complementaria.
• Líneas de pie de página: Contiene los números de la página, información de
seguridad, etc.
El programador define la información para las partes constantes de las líneas de título,
encabezado y de pie de página. Estos registros constantes se imprimirán mediante rutinas
que se deberán ejecutar cuando se alcanza el inicio de una nueva página o el fin de ésta,
según corresponda.
El fin de una página se determina contando las líneas y probando éste valor contra un
número máximo deseado de líneas por página. Cuando se alcanza el límite de la página,
el programa debe imprimir una línea de pie de página opcional en la página actual y, de
haber una nueva página, imprimir una línea de título en la nueva página. Si se usan
encabezados de columnas, éstos deben imprimirse antes de continuar la impresión y
contar las líneas de detalle.
Pueden tenerse una rutina o procedimiento, para manejar las líneas de encabezado y otra
para el pie de página o puede ser una sola que se encargue de ambas situaciones.
4.3 Encabezados de Páginas
El programador debe definir el tamaño de la página y una variable como contador de

línea. El contador de línea se inicializa con el número máximo de líneas a imprimir, para
permitir la invocación al procedimiento que imprime el encabezado del reporte.
Las consideraciones para el contador de línea son:

• Después de imprimir cada línea de detalle debe compararse (>=) con el tamaño de
página, para determinar cuándo se debe llamar a la rutina de encabezado de
página.
• Se debe incrementar inmediatamente después de imprimir una línea, basado en el
espaciado simple, doble o triple.
• Siempre debe reflejar el número de la línea de la última línea escrita.
• La rutina de encabezado de página debe inicializar de nuevo el contador de línea.
El tamaño de la página es el número máximo de líneas a ser impresas en la página. El
programador decide el número que será y lo fija como una constante en el programa.
La rutina de encabezado de página también debe ocuparse de la variable contadora de

página, la cual debe ser incrementada cada vez que se vaya a escribir en una nueva
página. Esta variable puede ser parte de la línea del título o de pie de página, según el
estilo del reporte.

5. Entrada/Salida de Archivo: Formatos de Registros

Los datos escritos o leídos desde un archivo, generalmente se manejan como un registro.
Existen típicamente dos formas en que pueden procesarse los datos de un registro, estas
son como registros de largo fijo o como registros de largo variable. Los registros también
pueden formar bloques para lograr eficiencia en la transferencia hacia y desde el
dispositivo de almacenamiento. La Figura 6.4 representa esto.
FIJO REGISTRO REGISTRO REGISTRO REGIST
BLOQUE
FIJO
BLOQUEADO REGISTRO REGISTRO REGISTRO REGIST
VARIABLE REGISTRO REGISTRO REGISTRO
Número de bytes en el registro
BLOQUE
VARIABLE
BLOQUEADO REGISTRO REGISTRO REGISTRO
Número de bytes en el bloque
Figura 6.4: Formatos de Registros
Las operaciones de E/S que usan un archivo de disco o cinta, normalmente trabajan con
registros de datos y requieren que el programador considere los formatos del registro.
El tamaño de los registros fijos se establece generalmente, como un parámetro en el

proceso de E/S. El tamaño de los registros variables es diferente para cada registro y se
coloca en la cabecera del registro para indicar el número de bytes que éste ocupa.
Esto también se cumple para bloques de datos. El número de registros en cada bloque de
un conjunto de datos de bloque fijo, se da como un parámetro del sistema de E/S. El
tamaño para bloques variables puede ser diferente para cada bloque, así que el tamaño
también es embebido en una porción de la cabecera de cada bloque.
Organizar datos en bloques es ventajoso, porque permite al sistema de control de E/S leer
o escribir múltiples registros en cada transacción de flujo de los datos, según la cantidad
de registros que contenga el bloque.

Ejemplo 6.1: Ejercicio de E/S
Diseñe un programa para generar un reporte de las horas trabajadas por un grupo de
empleados. El formato del informe debe reflejar el nombre del empleado, las horas
trabajadas y una indicación de horas de sobre tiempo, si el empleado trabajó más de
cuarenta horas. El reporte debe contener un título y encabezados de columnas y debe
manejar múltiples páginas.
La tarea será examinar los registros de entrada y el formato del reporte deseado, para
luego hacer lo siguiente:
• Listar las localidades de entrada, salida y de procesamiento requeridos.
• Listar los requerimientos de pre-proceso, proceso y post-proceso.
• Dibujar un diagrama de flujo que muestra una solución correcta.
• Verificar la solución.
Registros Entrada:
Anderson 35
Andrews 42
Appleton 40
Arnold 30
Astor 45
Formato del Reporte:
Reporte de Horas Trabajadas
Nombre Horas Sobre tiempo
Anderson 35
Andrews 42 si
Appleton 40
Arnold 30
Astor 45 si

A continuación se presenta el diagrama de flujo de la solución al problema de E/S:

PROCESAR REGISTRO
INICIO
INICIO
SI
CONT_LINEA = CONT_LINEA
MAX_LINEAS
NUEVA PÁGINA
>=
CONT_PG = 1 CONT PG
LEER 1er. NO
REGISTRO
SI INDICADOR = ‘SI’
HORAS
> 40
LEER SIGUIENTE NO
REGISTRO
INDICADOR = ‘NO’
PROCESAR
REGISTRO
NO FIN DE SI
ARCHIVO ASIGNAR CAMPOS ENTRADA A
CAMPOS SALIDA
NO
ESCRIBIR REGISTRO
FIN
CONT_LINEA = CONT_LINEA + 1
FIN
Figura 6.5: Diagrama de Flujo del Ejercicio de E/S

NUEVA PÁGINA
INICIO
SALTAR A NUEVA
PÁGINA
ESCRIBIR LINEA DE
CABECERA
ESCRIBIR LINEA DE
TÍTULO
CONT_LINEA =
MAX LINEA
CON_PG = CONT_PG + 1
FIN
Figura 6.6: Diagrama de Flujo del Ejercicio de E/S
Fin del Ejemplo 6.1

Resumen
• Describir los conceptos básicos de entrada y salida para programas de
computadora.
• Listar algunas consideraciones específicas para imprimir la salida.
• Describir los conceptos de registros de datos fijo, variable y bloqueado.
• Crear un diseño de programa para manejar encabezados de página.


1) Indique las sentencias correctas en referencia a entrada salida:
a) Los comandos que se usan para escribir un programa incluyen funciones o
procedimientos especiales que se pueden usar para realizar la entrada y salida.
b) La entrada y salida generalmente son las partes más complejas de cualquier
programa o cualquier lenguaje de programación
c) La transferencia real de datos hacia o desde los dispositivos de E/S, será
generalmente la parte más lenta de un programa.
d) Sólo (a) y (c)
2) Los comandos que se usan para la entrada son normalmente:

a) write
b) get
c) display
d) scan
3) Los comandos que se usan para la salida son normalmente:

a) print
b) write
c) put
d) get
4) Los datos externos que se procesan en un programa se leen y escriben realmente en

un buffer que maneja la computadora.
a) Verdadero
b) Falso
5) De las siguientes, ¿cuáles son consideraciones especiales requeridas para Imprimir

la salida a una impresora?
a) Separar los formatos de salida para las líneas de datos y las líneas del título
b) Contadores de línea
c) Contadores de páginas
d) Encabezados de páginas
e) Caracteres de control de carro en las líneas de salida

6) El carácter de control para indicar espaciado de 2 líneas es:

a) espacio
b) –
c) 0
d) 1
7) Existen típicamente dos formas en que pueden procesarse los datos de un registro,
estas son:
a) Registros encapsulados
b) Registros fijos
c) Registros variables
d) Registros hash
8) El tamaño de los registros fijos, se establece generalmente como un parámetro en el

proceso de E/S
a) Verdadero
b) Falso
9) El tamaño de los registros variables, varía para cada registro y se coloca en el

registro en la cabecera para indicar el número de bytes que ocupa.
a) Verdadero
b) Falso
10) Organizar datos en los bloques permite al sistema de control de E/S leer o escribir
múltiples registros (el valor de un bloque) para cada transacción en el flujo de los
datos.
a) Verdadero
b) Falso

1) a, b y c
2) b y d
3) b y c
4) a
5) b, c, d y e
6) c
7) b y c
8) a
9) a
10) a

Unidad 7: Ejemplos de Programas

• Diseñar un programa para manejar la verificación de secuencias y rupturas de
control.
• Diseñar un programa para resolver un problema de emparejamiento de
transacción.
Libro 1: Fundamentos de Programación Unidad 7: Ejemplos de Programas 111

1. Verificar la Secuencias
Una secuencia puede ser:
• Una serie continua o conectada: El alfabeto.
• Un orden consecutivo o por rango: Los naipes.
• Un conjunto de elementos ordenados: Los números naturales.
Una verificación de secuencia es el proceso de garantizar el orden correcto de los
registros al procesar un archivo secuencial, esto implica que esos datos se han
ordenado previamente y requieren una jerarquía de datos y un valor clave para
determinar el orden correcto.
Verificar la secuencia implica trabajar con un archivo de registros de datos que se ha

ordenado previamente, generalmente en orden ascendente. Ejemplos de valores claves
para ordenar pueden ser el número del empleado para registros de empleado o el
número de parte para los registros del inventario.
El proceso de ordenar las cosas en orden ascendente es un problema de programación

clásico. Esto se puede realizar a través de alguna función del sistema o proceso
periférico fuera del programa que se está produciendo.
2. Rupturas de Control
La ruptura de control (Control Break) es el reconocimiento de un cambio en el valor
clave, cuando se procesan secuencias de registros que contienen múltiples registros
con una clave común. Normalmente, se usa para procesar registros en secuencia en un
sistema que contiene múltiples actualizaciones a registros maestros.
La ruptura de control, generalmente implica recolectar subtotales o imprimir los

resúmenes parciales.
Un ejemplo de procesamiento con ruptura de control es el procesamiento de promedio

de notas de los estudiantes de un salón de clase. La clave para hacer la ruptura de
control, puede ser el ID del estudiante o el nombre del estudiante.
A medida que el programa lee el conjunto ordenado de registros de notas del

estudiante, promedia las notas de todos los cursos del estudiante en particular y rompe
el control cuando encuentra un nuevo ID de estudiante o nombre.
Al interrumpir el control, este programa calcula el promedio de notas del estudiante y

luego reinicializan todos los acumuladores para preparar el procesamiento del próximo
estudiante.
Unidad 7: Ejemplos de Programas Libro 1: Fundamentos de Programación 112

3. Emparejar Transacciones
Emparejar Transacciones es emparejar el valor clave de un registro de un archivo
contra el valor clave de los registros en un archivo maestro.
El Archivo Maestro es una colección de registros que contienen los datos permanentes
o acumulados para un sistema. Ver Figura 7.1
Archivo
Maestro
Transacciones
00120
01655
01655
24898
59437
59437
76990
76990
98144
Figura 7.1: Transacciones
Emparejar transacciones es una actividad común en el procesamiento de archivos.

Típicamente hay muchos registros de transacción para ser procesados contra sólo un
registro en el archivo maestro con el valor clave.
Algunos ejemplos donde se aplica son:

• Las notas del estudiante de un semestre: Las transacciones son las notas que
se emparejan contra los registros de notas permanentes para la cohorte que
constituyen el archivo maestro.
• La comprobación diaria y la actividad de depósito: Las transacciones son los
movimientos diarios que se emparejan contra el registro de cuenta para la
cuenta corriente, que conforma el archivo maestro.
• Un almacén y el reabastecimiento diario: Las ventas diarias son las
transacciones, emparejado contra la información detallada de inventario actual
para un producto, que conforma el archivo maestro.
3.1 Ejercicio de Punto de Chequeo
Hay que diseñar un programa para generar un informe del resumen de ventas para un
grupo de departamentos. El formato del informe debe reflejar el número del
departamento y las ventas totales. Cada departamento puede tener múltiples registros
de entrada. Se requiere verificar la secuencia del número del departamento. Si un
registro de entrada está fuera de la secuencia, se debe imprimir un mensaje de error,
los resultados acumulados y terminar el programa. El informe debe contener las

cabeceras de las columnas y debe ocuparse de páginas múltiples. El título para el

informe es optativo. La tarea será examinar los registros de entrada, el formato del
informe deseado y hacer lo siguiente:
• Listar la entrada, salida y localidades de almacenamiento de proceso requeridas.
• Listar los requisitos de pre-proceso, proceso y post-proceso.
• Hacer un diagrama de flujo que muestre una solución correcta.
• Verificar la solución usando los dos juegos de entrada que se muestran a
continuación:
Entrada 1: Entrada 2:
5 200.00 5 200.00
5 100.00 5 100.00
5 100.00 5 100.00
6 50.00 16 300.00
6 200.00 16 200.00
16 300.00 9 50.00
16 100.00 6 200.00
Salida 1: Salida 2:
Dpto. No. Ventas Dpto. No. Ventas
5 400.00 5 400.00
6 250.00 16 500.00
16 400.00
Error de Secuencia
Figura 7.2: Punto de Chequeo

PUNTO DE CHEQUEO
PROCESAR VENTAS
INICIO
INICIO
CONT_LINEA = MAX_LINEA
CONT_PG = 1
DEPT si RUPTURA
<
DEPT-LEIDO
VENTAS_ACUM = 0
SW = 1
SW = 0
no
LEER 1ER REGISTRO
no VENTAS_ACUM =
DEPT
> VENTAS_ACUM +
DEPT-LEIDO VENTAS_LEIDAS
DEPT = DEPT-LEIDO
si
LEER SIGUIENTE ERROR

REGISTRO
SI
FIN
NO FIN ARCHIVO Y PROCESAR
SW = 1 VENTAS
NO
ASIGNAR Y ESCRIBIR
TOTAL DE VENTAS
ÚLTIMO
SI MENSAJE DE
SW = 0 ERROR DE
SECUENCIA
NO
FIN
Figura 7.3: Diagrama de Flujo del Ejercicio de Punto de Chequeo

RUPTURA
INICIO
INICIO
NO SALTAR A NUEVA
CONT_LINEA >=
MAX_LINEA
PÁGINA
SI ESCRIBIR LINEA DE
CABECERA
NUEVA_PAGINA
ESCRIBIR LINEA DE
TÍTULO
ASIGNAR Y ESCRIBIR LINEA DE

DAYTOS PARA EL DPTO. CONT_LINEA =
MAX LINEA
CON_PG = CONT_PG + 1
DEPT = DEPT-LEIDO
FIN
CONT_LINEA = CONT_LINEA + 1
VENTAS_ACUM = VENTAS_LEIDAS
FIN
Figura 7.4: Diagrama de Flujo del Ejercicio de Punto de Chequeo

Resumen
• Diseñar un programa para manejar la verificación de secuencias y rupturas de
control.
• Diseñar un programa para resolver un problema de emparejamiento de
transacción.

Volumen 2: Complementos I


1. Conceptos
Un algoritmo es una serie de pasos lógicos, que se estructuran para resolver un
problema. Generalmente, un algoritmo se compone de sentencias simples y sentencias
de control. Las sentencias simples son:
1.1 Declaración de Variables
Consiste en escribir el tipo de datos y la lista de identificadores que se tendrán de dicho

tipo, separando cada identificador por medio de comas (,). Para mejorar la claridad de la
declaración se puede colocar dos puntos (:) para separar el tipo de datos de la lista de
identificadores, por ejemplo:
Entero: edad
Real: estatura, peso,

sueldo
Cadena: nombre,
dirección
1.2 Asignación de Variables
Asignar un valor a una variable equivale a decir que se guarda dicho valor en la posición
de memoria reservada para la variable en mención. Ejm:
Edad = 10
Estatura = 1.80
Resultado = 2 * 3
1.3 Lectura de Variables
La instrucción (LEER, OBTENER o ADQUIRIR) se utiliza para enviar información desde

un dispositivo de entrada de datos hacia la memoria, por ejemplo:
edad
Libro 1: Fundamentos de Programación Unidad 1: Sentencias Simples 121

Estatura, peso
Para la leer u obtener datos desde un dispositivo de entrada hacia la memoria,

frecuencia también se utiliza el símbolo:
edad
1.4 Escritura de Datos
La instrucción (MOSTRAR, IMPRIMIR o ESCRIBIR) permite enviar datos desde la

memoria hacia un dispositivo de salida como la pantalla. La información que se envía
puede ser el calor de una constante o también el contenido de variables, por ejemplo:
Edad
“Su peso es: ”

peso
Unidad 1: Sentencias Simples Libro 1: Fundamentos de Programación 122

Ejercicios Resueltos
1) Dada las horas trabajadas de una persona y la tarifa de pago por hora, calcule su
salario e imprímalo.
INICIO
entero horas
real tarifa, salario
“Ingrese la
cantidad de
horas”
horas
“Ingrese
la tarifa”
tarifa
salario = horas *
tarifa
“El salario es:

”salario
FIN

2) Dada la base y altura de un rectángulo, calcular el área y el perímetro del mismo.

Las fórmulas a utilizar son: Area = base * altura y Perímetro = 2 * (base + altura)
INICIO
real base, altura,

area, perimetro
“Ingrese
la base:
”
base
“Ingrese
la
altura: ”
altura
area = base * altura
perimetro = 2 *
(base + altura)
“El area es:”

area
“El perímetro
es:”
perimetro
FIN

3) Obtener la edad de una persona en meses, si se ingresa su edad en años y

meses. Por ejemplo, si se ingresan 3 años 4 meses debe mostrar 40 meses
INICIO
entero meses, anios, totalM
“Ingrese los años

de la persona”
anios
“Ingrese los meses

de la persona”
meses
totalM = (anios * 12) + meses
“La edad en meses

es: ” totalM
FIN

4) Escriba un algoritmo que permita convertir un valor ingresado en pies a metros. La

fórmula a utilizar es 1pie = 30.48 cm.
INICIO
real pies, metros, centimetros
“Ingrese un valor en
pies”
pies
centimetros = pies * 30.48
metros = centimetros / 100
pies “pies equivalen

a ” metros “metros”
FIN
5) Convertir una velocidad expresada en km/h a m/s. Si 1Km=1000 m y 1h=3600

seg.
INICIO
real kmph, mps
“Ingrese la
velocidad en Km/h”
kmph
mps = kmph * 5 / 18
kmph “Km/h
equivales a: ” mps
“M/s”
FIN

6) Dada una cantidad de hombres y de mujeres, calcular el porcentaje de cada

género dentro del grupo.
INICIO
entero hombres, mujeres, total

real porch, porcm
“Ingrese cantidad
de hombres”
hombres
“Ingrese cantidad
de mujeres”
mujeres
total = hombres + mujeres
porch = hombres / total
porcm = mujeres / total
“%hombres= ”
porch
“% mujeres = ” porcm
FIN

7) Un instructor prepara tres modelos de exámenes para tres salones en un curso de

programación. El instructor sabe que tarda 5 min en el modelo del salón A, 8 min
en el modelo del salón B y 6 minutos en el modelo del salón C. Dadas las
cantidades de estudiantes en cada salón, ¿Cuántas horas y minutos tardará el
instructor en revisar los exámenes de todos los salones?
INICIO
entero estA, estB, estC, tiempoA,

tiempoB, tiempoC, tiempoT,
horasT, minT
“Ingrese la cantidad
de estudiantes de
los salones A, B y
C”
estA, estB, estC
tiempoA = estA * 5
tiempoB = estB * 8
tiempoC = estC * 6
tiempoT = tiempoA + tiempoB+tiempoC
horasT = tiempoT div 60
minT = tiempoT mod 60
“El instructor
tardará ” horasT
“horas y ” minT
“minutos”
FIN

Ejercicios por Resolver

1) Determine el promedio de 3 números reales.
2) Calcular y mostrar el área de un triángulo si se ingresa por teclado la base y la
altura.
3) Calcular el área y perímetro de un triángulo, conocidos sus lados.
4) Hacer un algoritmo que permita ingresar dos números enteros y calcule las 4
operaciones básicas (suma, resta, multiplicación, división). Además, calcular la
potencia. El algoritmo debe mostrar los números y los resultados.
5) Escriba un algoritmo que lea la velocidad en km/h y el número de horas
transcurridas por un móvil, para determinar la distancia recorrida.
6) Un corredor reporta el número de minutos que corre en un año. Escribir un
programa que dé como salida la cantidad de tiempo equivalente en meses,
semanas, días, horas y minutos.
7) Calcule el interés generado (interes), por un capital depositado (capdep) durante
cierta cantidad de períodos (cp) a una tasa de interés determinada (tasa)
expresada en porcentaje. Use las fórmulas:
a) monto = (capdep)*(1+tasa/100)cp
b) interes = monto – capdep
8) Dado un tiempo en minutos, calcular los días, horas y minutos que le
corresponden.


1. Conceptos
Las estructuras de decisión o también llamadas de selección, permiten que el algoritmo
tome decisiones y ejecute u omita algunos procesos dependiendo del cumplimiento de
una condición.
Se pueden manejar tres tipos de decisiones: simple, doble y múltiple.
Una decisión es simple, cuando sólo se tiene determinado los pasos a seguir si el
resultado de la condición es verdadero, mientras que si es falso, la ejecución del
algoritmo continúa después de la estructura condicional.
Una decisión es doble, cuando se tiene un curso de acción para el caso que el resultado
de la comparación sea verdadero y otro para cuando sea falso.
La decisión múltiple determina el valor de una variable y dependiendo de éste sigue un

curso de acción. Es importante tener en cuenta que sólo se verifica la condición de
igualdad entre la variable y la constante.
Libro 1: Fundamentos de Programación Unidad 2: Estructuras de Decisión 131

1) Solicite un número al usuario e imprima su valor absoluto. Recuerde que el valor
absoluto de un número es el mismo valor si es positivo y es el valor cambiado de
signo en caso de que sea negativo.
INICIO
entero numero
“Ingrese un
número entero”
numero
si
numero=numero * (-1)
num ero < 0
no
“El valor
absoluto es: “
numero
FIN
Unidad 2: Estructuras de Decisión Libro 1: Fundamentos de Programación 132

2) Elabore un programa que imprima el mayor de dos números enteros introducidos

por el usuario.
INICIO
entero a, b, mayor
“Ingrese el
primer valor”
“Ingrese el
segundo
valor”
NO a>b SI
mayor = b mayor = a
“El mayor
es:” mayor
FIN

3) Dados dos números introducidos por el usuario, identifique cuál es el mayor, cuál
es el menor y si son iguales muestre un mensaje.
INICIO
entero a, b
“Ingrese el
primer valor”
“Ingrese el
segundo valor”
no si
a == b
NO SI
a>b “Los
números son
iguales”
“El mayor “El mayor
es:” b es:” a
“El menor “El menor

es:” a es:” b
FIN

4) Elabore un programa que solicite el salario de un empleado y calcule el nuevo

salario de la siguiente forma: Si el empleado gana hasta de 500.000 tendrá un
incremento del 10%, si devenga más de 500.000 y hasta 800.000 recibirá un
aumento del 8% y si gana más de 800.000 un aumento del 5%. Muestre por pantalla
el monto del aumento y el nuevo salario total del empleado.
INICIO
real salario, porc, aumento, nuevosal
“Ingrese el
salario: “
salario
no si
salario <= 500000 porc = 10
no si
porc = 5 salario <= porc = 8
800000
aumento = salario * porc / 100
nuevosal = salario + aumento
“Ud ha recibido un aumento

de “ aumento “ Su nuevo
salario es “ nuevosal
FIN

5) Elaborar un programa que lea tres notas y calcule el promedio. Si éste es menor
a 10, imprimir: “Nota deficiente”. Si es mayor o igual a 10 y menor o igual a 15,
imprimir: “Nota regular”. Si es mayor que 15, imprimir: “Nota excelente”.
INICIO
entero nota1, nota2, nota3

real promedio
“Ingrese 3 notas: “
nota1, nota2, nota3
promedio = (nota1+nota2+nota3)/3
no
promedio < 10
no si “Nota deficiente”
promedio <= 15
“Nota excelente” “Nota regular”
FIN

6) Una tienda que vende televisores, lavadoras y neveras tiene una promoción. Si
el cliente compra tres artículos iguales o más, recibe un descuento del 15% sobre el
precio de dicho artículo; de lo contrario sólo recibe un descuento del 5%. Calcular el
monto total a pagar por el cliente y mostrarlo por pantalla. Los televisores cuestan
25.000, las lavadoras 30.000 y las neveras 75.000.
INICIO A
Entero cantT, cantL, cantN totalT = cantT * precioT

Real precioT, precioL, precioN
Real totalT, totalL, totalN, total
totalL = cantL * precioL
“Ingrese cantidad
de TV’s, lavadoras totalN = cantN * precioN
y neveras”
total = totalT + totalL +

totalN
cantT, cantL, cantN
“Monto a pagar”
“Televisores: “ totalT
no si “Lavadoras: “ totalL
cantT >= 3 “Neveras: “ totalN
“Monto Total: “ total
precioT=25000*0.95 precioT=25000*0.85
FIN
cantL >= 3
precioL=30000*0.95 precioL=30000*0.85
cantN >= 3
precioN=75000*0.95 precioN=75000*0.85

7) Una aseguradora de vehículos tiene los siguientes porcentajes de prima

dependiendo de los años de antigüedad del vehículo. Los vehículos de 1 año pagan
el 5% de su valor, de dos años el 8%, de tres años el 10%, de cuatro años el 12% y
de cinco años o más pagan el 15%. Elabore un programa que solicite el valor del
vehículo y los años de antigüedad y muestre por pantalla el valor de la prima.
INICIO
Entero valor, anios

Real porc, prima
“Ingrese el valor del

vehículo y los años
de antigüedad:”
valor, anios
anios
1 2 3 4 otro
porc = 5 porc = 8 porc = 10 porc = 12 porc =15
prima = valor * porc/100
“El monto de la
prima es: “ prima
FIN


1) Dados sus tres lados (a,b,c), determinar si un triangulo es: equilátero, isósceles o
escaleno.
2) A un trabajador le pagan según sus horas y una tarifa de pago por horas. Si la
cantidad de horas trabajadas es mayor a 40 horas, entonces la tarifa se
incrementa en un 50% para las horas extras. Calcular el salario del trabajador
dadas las horas trabajadas y la tarifa.
3) A un trabajador le descuentan de su sueldo el 10% si su sueldo es menor o igual a
1000. por encima de 1000 y hasta 2000 el 5% del adicional y por encima de 2000
el 3% del adicional. Calcular el descuento y sueldo neto que recibe el trabajador
dado su sueldo.
4) Dado un monto, calcular el descuento considerando que por encima de 100 el
descuento es el 10% y por debajo de 100 el descuento es el 2%.
5) Elabore un programa que permita emitir la factura correspondiente a una compra
de un artículo determinado, del que se adquieren una o varias unidades. El IVA es
del 15% y si el monto bruto (precio venta más IVA) es mayor de 50.00 pesetas se
debe realizar un descuento del 5% sobre el monto total.
6) Dado un tiempo en segundos, calcular los segundos restantes que le
correspondan para convertirse exactamente en minutos. Por ejemplo, si el usuario
introduce 340 el resultado debe ser 20.


1. Conceptos
Un ciclo consiste en un grupo de acciones que se ejecutan repetidas veces
dependiendo del cumplimiento de una condición. En algunos casos, el número de
repeticiones se conoce con anterioridad, mientras que en otros depende de cálculos o
estados de variables que se dan dentro de la solución del problema. Existen tres tipos
de ciclos, los cuales se explican a continuación.
1.1 Ciclo Mientras .. Hacer (while .. do)
Este ciclo consiste en un conjunto de instrucciones que se repiten mientras se cumpla

una condición. De igual manera que en los condicionales, la condición es evaluada y
retorna un valor lógico, que puede ser verdadero o falso. En el caso del ciclo mientras,
las instrucciones contenidas en la estructura de repetición se ejecutarán solamente si al
evaluar la condición se genera un valor verdadero; es decir, si la condición se cumple;
en caso contrario, se ejecutará la instrucción que aparece después de fin mientras.
El ciclo mientras, comienza evaluando la expresión condicional, si el resultado es

verdadero se ejecutarán las instrucciones que estén entre el mientras y el fin mientras.
Al encontrarse la línea fin mientras, se volverá a evaluar la condición, si se cumple se
ejecutarán nuevamente las instrucciones y así sucesivamente hasta que la condición
deje de cumplirse, en cuyo caso, el control del programa pasa a la línea que aparece
después de fin mientras.
Si en la primera pasada por el ciclo mientras la condición no se cumple las instrucciones

que están dentro del ciclo no se ejecutarán ni una sola vez.
1.2 Ciclo Repetir .. Hasta (Repeat .. until)
En este ciclo, se ejecutarán las sentencias, hasta que se cumpla la condición. Además,
una diferencia con la sentencia de control anterior, es que en ésta por lo menos se entra
una vez en el ciclo.
1.3 Ciclo Desde (for)
Este ciclo, al igual que los demás, permite ejecutar repetidas veces una instrucción o un
grupo de ellas, pero a diferencia de otras instrucciones de repetición, ésta maneja el
valor inicial, el valor de incremento o decremento y el valor final de la variable de control
como parte de la instrucción.
Cuando al ejecutarse un algoritmo se encuentra una instrucción para la variable de

control (contador) toma el valor inicial, se verifica que el valor inicial no sobrepase el
valor final y luego se ejecutan las instrucciones del ciclo. Al encontrar la instrucción fin
para, se produce el incremento y se vuelve a verificar que la variable de control no haya
Libro 1: Fundamentos de Programación Unidad 3: Estructuras de Repetición 141

superado el límite admitido y se vuelven a ejecutar las instrucciones que están dentro
del ciclo, y así sucesivamente tantas veces como sea necesario hasta que se supere el
valor final establecido.
El ciclo termina en el momento en que la variable de control (contador) sobrepasa el

valor final; es decir, que la igualdad está permitida y las instrucciones se ejecutan
cuando el contador es igual al valor final.
Unidad 3: Estructuras de Repetición Libro 1: Fundamentos de Programación 142

1) Elabore un programa que muestre los números del 1 al 10. Ciclo Mientras..Hacer.
INICIO
Entero numero = 1
si
numero <= 10 numero
numero = numero + 1
no
FIN

2) Solicite al usuario 10 números y muestre el promedio de ellos. Ciclo

Mientras..Hacer.
INICIO
Entero numero, suma=0, n=1,

Real promedio
n=n+1
suma = suma + numero
si “Ingrese un
n <= 10 numero” numero
no
promedio = suma / 10
“El promedio es: “

promedio
FIN

3) Solicite al usuario 10 números positivos y muestre el mayor de ellos. Ciclo

Hacer..Mientras.
INICIO
Entero numero,
mayor = 0, contador =
“Ingrese un numero
entero positivo”
numero
si
numero > mayor mayor = numero
no
contador = contador + 1
si
contador < 10
no
“El mayor es “
mayor
FIN

4) La serie Fibonacci comienza con los números: 0, 1, 1, 2, 3, 5, 8, 13, 21, ... Se

requiere un algoritmo para generar los primeros 10 números. Ciclo Mientras..Hacer.
INICIO
Entero a = 1, b = 1, n = 2, c
“1, 1”
n = n +1
b=c
a=b
“, “ c
si c=a+b
n < 10
FIN

5) Dado N notas de un estudiante calcular:

a) Cuántas notas tiene desaprobadas.
b) Cuántas notas tiene aprobadas.
c) El promedio de todas las notas.
d) El promedio de notas aprobadas y desaprobadas.
º
INICIO
A
Entero n ,i=1, nota, naprob=0, ndes=0,

acum._aprb=0, acum._des=0 promaprob = acum_aprob / naprob
Real promaprob, promdes, promtotal
promdes = acum_des / ndes

“¿Cuántas notas
desea introducir?”
promtotal = (acum_aprob + acum_des) / n
“Notas aprobadas: “ acum._aprob

i = i +1 “Notas desaprobadas: “ acum_des
“Promedio total: “ promtotal
“Promedio aprobadas: “ promaprob
“Promedio desaprobadas: “ promdes
acum_des = acum_aprob =
acum_des + nota acum_aprob + nota FIN
ndes = ndes + 1 napron = naprob + 1
no si
nota >= 10
nota
si
i <= n “Ingrese nota”
no

Ejercicios Propuestos
1. Construya un algoritmo que reciba como entrada un cierto valor n y genere como
salida n veces la palabra “hola".
2. Construya un algoritmo que reciba como entrada un cierto valor n y genere como
salida el valor de la serie: 1 + 2 + 3 + 4 + : : : + n
3. Dado un número determinar la suma de sus dígitos.
4. Realizar un algoritmo que permita pedir 20 números naturales y determine e imprima
cuántos son pares, impares, positivos y negativos.
5. Desarrollar un algoritmo para calcular e imprimir el factorial de un número.
6. Elaborar un programa que lea N cantidad de notas, calcule el promedio. Si éste es
menor que 10, imprimir: “Reprobado”. Si es mayor o igual a 10, imprimir:”Aprobado”.
7. En un evento público donde entran N cantidad de personas y las entradas cuestan S
cantidad de bolívares, hay un descuento para adultos de 25%, para menores de 12
años de 50% y para menores de 6 años de 70%. Elaborar un programa que solicite
el valor de las entradas y las edades de N personas y calcule el monto a pagar.
8. Calcular y visualizar la suma y el producto de los números pares comprendidos entre
20 y 400 ambos inclusive.
9. Hacer un programa que al ingresar un número indique si es o no es un número
Ámstrong, si no lo es que indique que vuelva a intentar (un número es Ámstrong si la
suma de los dígitos que lo componen, elevados al cubo, es igual al número. Ejemplo:
153 es Ámstrong porque 13 + 53 + 33 = 1 + 125+ 27).


(Pseudocódigo)
1. Dada las horas trabajadas de una persona y la tarifa de pago por hora, calcule su
salario e imprímalo.
1. algoritmo salario
2. var horas: entero
3. tarifa, salario: real
4. inicio
5. mostrar “Ingrese la cantidad de horas: ”
6. leer horas
7. mostrar “Ingrese la tarifa”
8. leer tarifa
9. salario = horas * tarifa
10. mostrar “El salario es: ” salario
11.fin salario
2. Dada la base y altura de un rectángulo, calcular el área y el perímetro del mismo.

Las fórmulas a utilizar son: Area = base * altura y Perímetro = 2 * (base + altura).
1. algoritmo rectangulo
2. var base, altura, area, perímetro: real
3. inicio
4. mostrar “Ingrese la base: ”
5. leer base
6. mostrar “Ingrese la altura: ”
7. leer altura
8. area = base * altura
9. perimetro = 2 * (base + altura)
10. mostrar “El area es: ” area
11. mostrar “El perímetro es: ” perimetro
12.fin rectangulo
Libro 1: Fundamentos de Programación Unidad 4: Sentencias Simples (Pseudocódigo) 149

3. Obtener la edad de una persona en meses, si se ingresa su edad en años y

meses. Por ejemplo: Si se ingresan 3 años 4 meses debe mostrar 40 meses.
1. algoritmo edad
2. var meses, anios, totalM: entero
3. inicio
4. mostrar “Ingrese los años de la persona: ”
5. leer anios
6. mostrar “Ingrese los meses de la persona: ”
7. leer meses
8. totalM = (anios * 12) + meses
9. mostrar “La edad en meses es: ” totalM
10. fin edad
4. Escriba un algoritmo que permita convertir un valor ingresado en pies a metros.

La fórmula a utilizar es 1pie = 30.48 cm.
1. algoritmo piesametros
2. var pies, metros, centímetros: real
3. inicio
4. mostrar “Ingrese un valor en pies: ”
5. leer pies
6. centimetros = pies * 30.48
7. metros = centimetros / 100
8. mostrar pies “ equivalen a ” metros “ metros.”
9. fin piesametros
5. Convertir una velocidad expresada en km/h a m/s. Si 1Km=1000 m y 1h=3600

segundos.
1. algoritmo kmhamps
2. var kmph, mps: real
3. inicio
4. mostrar “Ingrese la velocidad en Km/h: ”
5. leer kmph
6. mps = kmph * 5 / 18
7. mostrar kmph “ Km/h equivales a ” mps “ m/s.”
8. fin kmhamps
Unidad 4: Sentencias Simples (Pseudocódigo) Libro 1: Fundamentos de Programación 150

6. Dada una cantidad de hombres y de mujeres, calcular el porcentaje de cada

género dentro del grupo.
1. algoritmo porcgeneros
2. var hombres, mujeres, total: entero
3. porch, porcm: real
4. inicio
5. mostrar “Ingrese la cantidad de hombres: ”
6. leer hombres
7. mostrar “Ingrese la cantidad de mujeres: ”
8. leer mujeres
9. total = hombres + mujeres
10. porch = hombres / total
11. porcm = mujeres / total
12. mostrar “%hombres = ” porch
13. mostrar “%mujeres = ” porcm
14.fin porcgeneros
7. Un instructor prepara tres modelos de exámenes para tres salones en un curso de

programación. El instructor sabe que tarda 5 min en el modelo del salón A, 8 min en
el modelo del salón B y 6 minutos en el modelo del salón C. Dadas las cantidades
de estudiantes en cada salón, ¿Cuántas horas y minutos tardará el instructor en
revisar los exámenes de todos los salones?
1. algoritmo examenes
2. var estA, estB, estC, tiempoA, tiempoB, tiempoC, tiempoT,
horasT, minT: entero
3. inicio
4. mostrar “Ingrese la cantidad de estudiantes de los salones
A, B y C: ”
5. leer estA, estB, estC
6. tiempoA = estA * 5
7. tiempoB = estB * 8
8. tiempoC = estC * 6
9. tiempoT = tiempoA + tiempoB + tiempoC
10. horasT = tiempoT / 60
11. minT = tiempoT mod 60
12. mostrar “El instructor tardará ” horasT “ horas con ” minT “
minutos.”
13.fin examenes
Libro 1: Fundamentos de Programación Unidad 4: Sentencias Simples (Pseudocódigo) 151


1. Determine el promedio de 3 números reales.
2. Calcular y mostrar el área de un triángulo si se ingresa por teclado la base y la altura.
3. Calcular el área y perímetro de un triángulo, conocidos sus lados.
4. Hacer un algoritmo que permita ingresar dos números enteros y calcule las 4
operaciones básicas (suma, resta, multiplicación, división). Además, calcular la
potencia. El algoritmo debe mostrar los números y los resultados.
5. Escriba un algoritmo que lea la velocidad en km/h y el número de horas transcurridas
por un móvil, para determinar la distancia recorrida.
6. Un corredor reporta el número de minutos que corre en un año. Escribir un programa
que dé como salida la cantidad de tiempo equivalente en meses, semanas, días,
horas y minutos.
7. Calcule el interés generado (interes) por un capital depositado (capdep) durante
cierta cantidad de períodos (cp) a una tasa de interés determinada (tasa) expresada
en porcentaje. Use las fórmulas:
a. monto = (capdep)*(1+tasa/100)cp
b. interes = monto – capdep
8. Dado un tiempo en minutos, calcular los días, horas y minutos que le corresponden.
Unidad 4: Sentencias Simples (Pseudocódigo) Libro 1: Fundamentos de Programación 152


(Pseudocódigo)
1. Solicite un número al usuario e imprima su valor absoluto. Recuerde que el valor
absoluto de un número es el mismo valor si es positivo y es el valor cambiado de
signo en caso de que sea negativo.
1. algoritmo valor_absoluto
2. var numero: entero
3. inicio
4. mostrar “Ingrese un número entero: ”
5. leer numero
6. si numero < 0 entonces
7. numero = numero * (-1)
8. fin si
9. mostrar “El valor absoluto es: ” numero
10.fin valor_absoluto
2. Elabore un programa que imprima el mayor de dos números enteros introducidos

por el usuario.
1. algoritmo mayor
2. inicio
3. var a, b, mayor: entero
4. inicio
5. mostrar “Ingrese el primer valor: ”
6. leer a
7. mostrar “Ingrese el segundo valor: ”
8. leer b
9. si a > b entonces
10. mayor = a
11. sino
12. mayor = b
13. fin si
14. mostrar “El mayor es: ” mayor
15.fin mayor
Libro 1: Fundamentos de Programación Unidad 5: Estructuras de Decisión (Pseudocódigo) 153

3. Dados dos números introducidos por el usuario, identifique cuál es el mayor, cuál
es el menor y si son iguales muestre un mensaje.
1. algoritmo comparar
2. var a, b: entero
3. inicio
4. mostrar “Ingrese el primer valor: ”
5. leer a
6. mostrar “Ingrese el segundo valor: ”
7. leer b
8. si a == b entonces
9. mostrar “Los números son iguales. ”
10. sino
11. si a > b entonces
12. mostrar “El mayor es: ” a
13. mostrar “El menor es: ” b
14. sino
15. mostrar “El mayor es: ” b
16. mostrar “El menor es: ” a
17. fin si
18. fin si
19. fin comparar
4. Elabore un programa que solicite el salario de un empleado y calcule el nuevo

salario de la siguiente forma: Si el empleado gana hasta de 500.000 tendrá un
incremento del 10%, si devenga más de 500.000 y hasta 800.000 recibirá un
aumento del 8% y si gana más de 800.000 un aumento del 5%. Muestre por pantalla
el monto del aumento y el nuevo salario total del empleado.
1. algoritmo aumento
2. var salario, porc, aumento, nuevosal: real
3. inicio
4. mostrar “Ingrese el salario: ”
5. leer salario
6. si salario <= 500000 entonces
7. porc = 10
8. sino
9. si salario <= 800000 entonces
10. porc = 8
11. sino
12. porc = 5
13. fin si
Unidad 5: Estructuras de Decisión (Pseudocódigo) Libro 1: Fundamentos de Programación 154

14. fin si
15. aumento = salario * porc / 100
16. nuevosal = salario + aumento
17. mostrar “Ud. ha recibido un aumento de: ” aumento
18. mostrar “Su nuevo salario es: ” nuevosal
19.fin aumento
5. Elaborar un programa que lea tres notas y calcule el promedio. Si éste es menor
a 10, imprimir: “Nota deficiente”. Si es mayor o igual a 10 y menor o igual a 15,
imprimir: “Nota regular”. Si es mayor que 15, imprimir: “Nota excelente”.
1. algoritmo promedio
2. var nota1, nota2, nota3: entero
3. promedio: real
4. inicio
5. mostrar “Ingrese las tres notas: ”
6. leer nota1, nota2, nota3
7. promedio = (nota1 + nota2 + nota3) / 3
8. si promedio < 10 entonces
9. mostrar “Nota deficiente”
10. sino
11. si promedio <= 15 entonces
12. mostrar “Nota regular”
13. sino
14. mostrar “Nota excelente”
15. fin si
16. fin si
17. fin promedio
6. Dado un tiempo en segundos, calcular los segundos restantes que le

correspondan para convertirse exactamente en minutos.
1. algoritmo tiempo
2. var tiempo_seg, segundos = 0: entero
3. inicio
4. mostrar “Ingrese el tiempo en segundos: ”
5. leer tiempo_seg
6. segundos = tiempo_seg mod 60
7. si segundos > 0 entonces
8. segundos = 60 – segundos
9. fin si

10. mostrar “Faltan: ” segundos “ seg.”

11. fin tiempo
7. Una tienda que vende televisores, lavadoras y neveras tiene una promoción. Si el
cliente compra tres artículos iguales o más recibe un descuento del 15% sobre el
precio de dicho artículo; de lo contrario sólo recibe un descuento del 5%. Calcular el
monto total a pagar por el cliente y mostrarlo por pantalla. Los televisores cuestan
25.000, las lavadoras 30.000 y las neveras 75.000.
1. algoritmo tienda
2. var cantT, cantL, cantN: entero
3. precioT, precioL, precioN, totalT, totalL, totalN,
total: real
4. inicio
5. mostrar “Ingrese la cantidad de TV’s, Lavadoras y Neveras: ”
6. leer cantT, cantL, cantN
7. si cantT >= 3 entonces
8. precioT = 25000 * 0.85
9. sino
10. precioT = 25000 * 0.95
11. fin si
12. si cantL >= 3 entonces
13. precioL = 30000 * 0.85
14. sino
15. precioL = 30000 * 0.95
16. fin si
17. si cantN >= 3 entonces
18. precioN = 75000 * 0.85
19. sino
20. precioN = 75000 * 0.95
21. fin si
22. totalT = cantT * precioT
23. totalL = cantL * precioL
24. totalN = cantN * precioN
25. total = totalT + totalL + totalN
26. mostrar “Monto a pagar”
27. mostrar “Televisores: ” totalT
28. mostrar “Lavadoras: ” totalL
29. mostrar “Neveras: ” totalN
30. mostrar “Monto total: ” total
31.fin tienda

8. Una aseguradora de vehículos tiene los siguientes porcentajes de prima

dependiendo de los años de antigüedad del vehículo. Vehículos de 1 año pagan el
5% de su valor, de dos años el 8%, de tres años el 10%, de cuatro años el 12% y de
cinco años o más pagan el 15%. Elabore un programa que solicite el valor del
vehículo, los años de antigüedad y muestre por pantalla el valor de la prima.
1. algoritmo seguros
2. var valor, anios: entero
3. porc, prima: real
4. inicio
5. mostrar “Ingrese el valor del vehículo y los años de
antiguedad: ”
6. leer valor, anios
7. segun sea anios
8. 1: porc = 5
9. 2: porc = 8
10. 3: porc = 10
11. 4: porc = 12
12. otro: porc = 15
13. fin segun
14. prima = porc * valor
15. mostrar “El monto de la prima es: ”
16.fin seguros
9. A un trabajador le pagan según sus horas y una tarifa de pago por horas. Si la
cantidad de horas trabajadas es mayor a 40 horas, entonces la tarifa se incrementa
en un 50% para las horas extras. Calcular el salario del trabajador dadas las horas
trabajadas y la tarifa.
1. algoritmo salario
2. var horas_trabajadas: entero
3. tarifa,horas_extras,salario,tarifa_extra: real
4. inicio
5. mostrar “Ingrese las horas trabajadas y la tarifa normal: ”
6. leer horas_trabajadas,tarifa
7. si horas_trabajadas <= 40 entonces
8. salario = horas_trabajadas * tarifa
9. sino
10. tarifa_extra = tarifa + 0.50 * tarifa
11. horas_extras = horas_trabajadas - 40
12. salario = horas_extras * tarifa_extra + 40 * tarifa
13. fin si

14. mostrar “El salario es: ” salario

15.fin salario
10. A un trabajador le descuentan de su sueldo el 10% si su sueldo es menor o

igual a 1000, por encima de 1000 y hasta 2000 el 5% del adicional y por encima de
2000 el 3% del adicional. Calcular el descuento y sueldo neto que recibe el
trabajador dado su sueldo.
1. algoritmo descuento
2. var sueldo,sueldo_neto,descuento: real
3. inicio
4. mostrar “Ingrese el sueldo: ”
5. leer sueldo
6. si sueldo <= 1000 entonces
7. descuento = sueldo * 0.1
8. sino
9. si sueldo <= 2000 entonces
10. descuento = (sueldo - 1000) * 0.05 + 1000 * 0.1
11. sino
12. descuento = (sueldo - 2000) * 0.03 + 1000 * 0.1
13. fin si
14. fin si
15. mostrar “Descuento: ” descuento
16. Fin descuento
11. Dado un monto calcular el descuento considerando que por encima de 100 el
descuento es el 10% y por debajo de 100 el descuento es el 2%.
1. algoritmo descuento100
2. var monto,descuento: real
3. inicio
4. mostrar “Ingrese el monto: ”
5. leer monto
6. si monto > 100 entonces
7. descuento = monto * 10 / 100
8. sino
9. descuento = monto * 2 / 100
10. fin si
11. mostrar “Monto: ” monto
12. mostrar “Descuento: ” descuento
13.fin descuento100


1. Escribir un programa que pida un número e indique si se trata de un número par.
2. Escribir un programa que pida una nota e imprima por pantalla la calificación en
formato “Apto” o “No Apto” según si la nota es mayor o menor que 10.
3. Escribir un programa que lea tres valores enteros y muestre por pantalla el máximo y
el mínimo de ellos.
4. Escribir un programa que pida un número entero y determine si es múltiplo de 2 y de
5.
5. Escribir un programa que pida la nota de un examen (un número real entre 0 y 20) e
imprima por pantalla la calificación en formato “Suspendido”, si la nota es menor que
10, “Aprobado” si está entre 10 inclusive y 15 sin incluir, “Notable” si está entre 15
inclusive y 18 sin incluir, “Sobresaliente” si está entre 18 inclusive y 20 sin incluir y
“Matrícula de honor” si la nota es igual a 20.
6. Escribir un programa que, dado el número del mes y la información de si el año es
bisiesto, imprima por pantalla el número de días del mes.
7. Escribir un programa que, pida la fecha de nacimiento de una persona e imprima por
pantalla su signo zodiacal.
8. Elabore un programa que permita emitir la factura correspondiente a una compra de
un artículo determinado, del que se adquieren una o varias unidades. El IVA es del
14% y si el monto bruto (precio venta mas IVA) es mayor que 50.000 se debe realizar
un descuento del 5% sobre el monto total.
9. Dados sus tres lados (a,b,c), determinar si un triangulo es : Equilátero, isósceles o
escaleno.

Fundamentos de Programación Complementos II

(Pseudocódigo)
1. Calcular mediante un algoritmo repetitivo la suma de los N primeros números
naturales.
1. algoritmo naturales
2. var N, i, suma: entero
3. inicio
4. mostrar “¿Cuantos números naturales desea sumar? ”
5. Leer N
6. i = 1
7. suma = 0
8. mientras i <= N hacer
9. suma = suma + i
10. i = i + 1
11. fin mientras
12. mostrar “La suma es: ” suma
13. fin naturales
2. Solicite 10 números enteros al usuario e imprima su promedio.

1. algoritmo promedio
2. var suma = 0, promedio, I, numero: entero
3. inicio
4. I = 1
5. mientras I <= 10 hacer
7. Leer numero
8. suma = suma + numero
9. I = I +1
10. fin mientras
11. promedio = suma /10
12. mostrar “El promedio es: ” promedio
13.fin promedio
Unidad 1: Funciones y Procedimientos Volumen 1: Conceptos de Programación 161

3. Dada las horas trabajadas de n personas y la tarifa general de pago por hora,
calcule el salario de todos los trabajadores y muéstrelo por pantalla. Muestre
además la suma de todos los salarios.
1. algoritmo nomina
2. var N, I, suma, tarifa, horas, sueldo: entero
3. inicio
4. mostrar “¿Cuantos trabajadores desea introducir?”
5. leer: N
6. mostrar “¿Cual es la tarifa general? ”
7. leer tarifa
8. I = 1
9. suma = 0
10. mientras I <= N hacer
11. mostrar “Ingrese las horas trabajadas: ”
12. Leer horas
13. sueldo = horas * tarifa
14. mostrar “El sueldo es: ” sueldo
15. suma = suma + sueldo
16. I = I + 1
17. fin mientras
18. mostrar “El monto total de la nómina es: ” suma
19.fin nomina
4. Dado N notas de un estudiante calcular:

a) Cuántas notas tiene desaprobadas.
b) Cuántos aprobadas.
c) El promedio de notas.
d) El promedio de notas aprobadas y desaprobadas.
1. algoritmo notas
2. var n, i=1, nota, naprob = 0, ndes = 0, acum_aprob = 0,
acum_des = 0: entero
3. promaprob, promdes, promtotal: real
4. inicio
5. mostrar “Cuantas notas desea introducir?”
6. leer n
7. mientras I <= n hacer
8. mostrar “Ingrese nota: ”
Volumen 1: Conceptos de Programación Unidad 1: Funciones y Procedimientos 162

Complementos II Fundamentos de Programación
9. leer nota
10. si nota >= 10 entonces
11. naprob = naprob + 1
12. acum_aprob = acum_aprob + nota
13. sino
14. ndes = ndes + 1
15. acum_des = acum_des + nota
16. fin si
17. I = I + 1
18. fin mientras
19. promaprob = acum_aprob / naprob
20. promdes = acum_des / ndes
21. promtotal = (acum_aprob + acum_des) / n
22. mostrar “Notas aprobadas: ” acum_aprob
23. mostrar “Notas desaprobadas: ” acum_des
24. mostrar “Promedio total: ” promtotal
25. mostrar “Promedio aprobadas: ” promaprob
26. mostrar “Promedio desaprobadas: ” promdes
27. fin notas
5. Dado un número entero determinar la suma de sus dígitos.

1. algoritmo digitos
2. var n, suma, residuo: entero
3. inicio
5. Leer n
6. suma = 0
7. mientras n <> 0 hacer
8. residuo = n mod 10
9. suma = suma + residuo
10. n = n div 10
11. fin mientras
12. mostrar “La suma es: ” suma
13.fin digitos
6. Realizar un algoritmo que solicite 20 números enteros al usuario y muestre

cuántos de ellos son pares, impares, positivos y negativos.

1. algoritmo naturales
2. var pares = 0, impares = 0, positivos = 0, negativos =
0, I, numero: entero
3. inicio
4. desde I = 1 hasta 100
5. mostrar “Ingrese un numero entero: ”
6. leer numero
7. si numero mod 2 == 0 entonces
8. pares = pares + 1
9. sino
10. impares = impares + 1
11. fin si
12. si numero > 0 entonces
13. positivos = positivos + 1
14. sino
15. negativos = negativos + 1
16. fin si
17. fin desde
18. mostrar “Pares: ” pares
19. mostrar “Impares : ” impares
20. mostrar “Positivos: ” positivos
21. mostrar “Negativos: ” negativos
22.fin naturales
7. Desarrollar un algoritmo para calcular e imprimir el factorial de un número.

1. algoritmo factorial
2. var fact, num, I: entero
3. inicio
4. mostrar “Ingrese un número entero positivo: ”
5. fact = 1
6. desde I = 1 hasta num
7. fact = fact * I
8. fin desde
9. mostrar “El factorial de ” num “ es: ” fact
10.fin factorial
8. Calcular y visualizar la suma y el producto de los números pares comprendidos

entre 20 y 400, ambos inclusive.

1. algoritmo sumayprod
2. var suma, producto, I: entero
3. inicio
4. suma = 0
5. producto = 1
6. I = 20
7. mientras I <= 400 hacer
8. suma = suma + I
9. producto = producto * I
10. I = I + 2
11. fin mientras
12. mostrar “Suma: ” suma
13. mostrar “Producto: ” producto
14.fin sumayprod

1) Hacer un programa que al ingresar un número de Amstrong escriba si es o no un
número de Amstrong, si no es, indique que vuelva a intentar.
2) Construya un algoritmo que reciba como entrada dos valores: a y b, donde a < b.
Este algoritmo debe generar como salida los múltiplos de a, que son menores que
b.
3) Construya un algoritmo que reciba como entrada varios montos de depósito y
despliegue la suma de ellos. Considere que un valor negativo, significa que no hay
más datos y no debe ser considerado como dato válido.
4) Construya un algoritmo que reciba como entrada una secuencia de valores
numéricos y genere como salida la suma de los valores pares y la multiplicación de
los impares. Considere que un valor negativo significa que no hay más datos y no
debe ser considerado como dato válido.
5) Construya un algoritmo que reciba como entrada una secuencia de valores de
temperaturas y genere como salida el total de veces que la temperatura fue 0±.
Considere que un valor de temperatura negativo significa que no hay más datos y
no debe ser considerado como válido.
6) Construya un algoritmo que reciba como entrada una secuencia de valores de
temperaturas y genere como salida el total de veces que se registró una
temperatura menor que 0±, el total de veces que fue 0± y el total de veces que fue
mayor que 0±. Considere que una temperatura con valor 99± ó (°99)± es una
temperatura no válida e indica el término de los datos.
7) Construya un algoritmo que genere como salida los términos de la siguiente serie:
2; 5; 7; 10; 12; 15; 17; : : : ; 1800
8) Los n superamigos del “Salón de la Justicia" lograron obtener un aumento de
sueldo en el último mes. Este aumento de sueldo se determinó por niveles, de
acuerdo a la siguiente tabla:
nivel sueldo %aumento
A 0 - 1000000 8
B 1000001 – 6
3000000
C 3000001 – 4
6000000
D > 6000000 2
9) Construya un algoritmo que reciba como entrada el sueldo actual de cada uno de
los trabajadores y calcule el nuevo sueldo. Además, el algoritmo deberá indicar
cuánto más gasta la empresa por concepto de sueldos, después del aumento.
10) Se dispone de una tabla con las temperaturas registradas a medio día durante el
año 2003. Se desea determinar cuál fue la máxima, cuál fue la mínima y cuántas
veces se repitió cada una de estas durante el año 2003. Además, se desea saber
el promedio de dichas temperaturas.

11) Construya un algoritmo que reciba como entrada un valor n y calcule una
aproximación del valor de e, como la suma de la siguiente serie:
1 1 1 1 1 1
1+ + + + + + ... +
1! 2! 3! 4! 5! n!

Volumen 3: Complementos II


1) Escribir un programa que determine la mayor de tres cantidades enteras, utilizando
una función que determine la mayor de dos cantidades enteras.
1. funcion maximo ( x:entero, y:entero): entero
2. var max: entero
3. inicio
4. si (x > y) entonces max = x
5. sino max = y
6. retorno max
7. fin maximo
algoritmo calcular_max_tres_enteros
var a,b,c,d: entero
inicio
mostrar “introduzca tres valores enteros”
Leer a,b,c
d = maximo(a,b)
d = maximo(c,d)
mostrar “El maximo es:”, d
fin
2) Escribir una función que calcule el valor de xn siendo x real y n un valor entero
1. funcion potencia(n: entero, x: real): real
2. var y: real
3. i: entero
4. inicio
5. si x = 0
6. entonces y = 0
7. retornar y
8. sino
9. y = 1
10. desde i = 1 hasta i = abs(n) hacer
11. y = y*x
12. fin desde
13. si n > 0
14. entonces retornar y
15. sino retornar y = 1 / y
16. fin si
17. fin si
18. fin funcion

3) Escribir funciones para convertir pies a pulgadas, pulgadas a centímetros y

centímetros a metros.
Escribir un algoritmo que le pida al usuario una medida en píe, lo convierta y lo
muestre en metros.
Se sabe que: 1 píe = 12 pulgadas
1 pulgadas = 2.54 cm
100 cm = 1 metro.
1. funcion pies_a_pulgadas(pies: real): real

2. var pulg: real
3. inicio
4. pulg= 12 * pies
5. retornar pulg
6. fin funcion
7. funcion pulg_a_centimetro(pulg: real): real

8. var cm: real
9. inicio
10. cm = 2.54 * pulg
11. retornar cm
12. fin funcion
13. funcion cm_a_metro(cm: real): real

14. var metro:real
15. inicio
16. metro = cm / 100.0
17. retornar metro
18. fin funcion
19. algoritmo conversion

20. var pies, pulgadas, cms, metros: real
21. inicio
22. mostrar “introduzca la medida en pie”
23. leer pies
24. pulgadas = pies_a_pulgadas(pies)
25. cms = pulg_a_centimetro(pulgadas)
26. metros = cm_a_metro(cms)
27. mostrar pies, “pies es igual a”, pulgadas, “pulgadas”
28. mostrar pies, “pies es igual a”, cms, “centimetros”
29. mostrar pies, “pies es igual a”, metros, “metros”
30.fin

4) Diseñar una función que dado como parámetro de entrada un número entero retorne
su factorial.
La función factorial se define como n!
n! =1 si n = 0
n! = n x (n-1) x (n-2) x...x 3x 2 x 1 si n > 1
Resuelva el problema usando:
a) Una función recursiva.
b) Una función iterativa.
c) Función factorial implementación recursiva:
función factorial (n:entero): entero

{ calculo recursivo del factorial de n }
inicio
si (n = 0)
entonces retornar (1)
sino retornar (n * factorial(n-1))
fin si
fin factorial
d) Función factorial implementación iterativa:
función factorial_iterativa (n:entero): entero

{ calculo iterativo del factorial de n }
var f, i:entero
inicio
f = 1
si (n = 0)
entonces retornar (f)
sino
desde i = 1 hasta n hacer
f = f * i
fin desde
retornar (f)
fin si
fin factorial_iterativo

5) Escribir un procedimiento que tenga como entrada la longitud de una cadena de

caracteres, escriba la cadena en orden inverso.
Ejemplo: Venezuela se obtiene aleuzeneV
El programa debe usar la recursividad para la escritura inversa.
procedimiento invertir_recursivo (n:entero)
var car: char

inicio
si (n <= 1)
entonces
leer car
escribir car
sino
leer car
invertir_recursivo(n-1)
escribir car
fin si
fin invertir_recursivo

1) Escribir una función salario que calcule el salario de un trabajador. Esta función
recibe como parámetros el número de horas trabajadas y el salario por hora.
Las horas extras serán calculadas con un salario/hora 1,5 veces mayor al salario/
hora establecida. Se consideran horas extras las trabajadas por encima de las 40
horas.
Presente el algoritmo para calcular y mostrar el salario de 50 empleados usando la
función salario.
2) Escribir una función que convierta una temperatura dada en grados Celsius a grados
Fahrenheit.
La fórmula de conversión es:
F = (9/5) * C + 32
3) Escribir funciones para:

a) Calcular el área, dada la base y altura del triángulo:
Area_triangulo = (base x altura ) / 2
b) Calcular el perímetro de un triángulo dados sus lados:
Perímetro_triangulo = suma de los tres lados
Presentar el algoritmo que invoca a las funciones y muestra los resultados.
4) Escribir funciones para:

a) Calcular el área de un círculo dado su radio:
Area_circulo = (3 / 4) * 3.1416 * radio * radio
b) Calcular el área de un cuadrado dada la longitud de uno de sus lados:
Area_cuadrado = lado x lado
c) Calcular el área de un rectángulo dada la longitud de dos de sus lados:
Area_rectangulo = lado1 x lado2
d) Calcular el área dada la base y altura del triángulo:
Area_triangulo = (base x altura) / 2:.
El algoritmo debe mostrar un menú que permita seleccionar la figura geométrica a la
cual se desea calcular el área y una opción para salir del programa.

5) Escribir un algoritmo que permita ingresar dos números enteros y calcule las 4
operaciones básicas suma, resta, multiplicación y división, además de calcular la
potencia. Cada una de las operaciones deben implementarse como una función. El
algoritmo debe mostrar los números y los resultados.
6) Escriba un algoritmo que lea dos números x y n, y calcule la suma de la progresión

geométrica:
1 + x + x2 + x3 + ... + xn
Use funciones para devolver la suma y calcular el valor de xn.

7) Escribir un procedimiento que ordene tres números mediante un procedimiento de
intercambio de dos variables, usando el pase de parámetros por referencia.
8) Diseñar un algoritmo que lea las longitudes de los tres lados de un triángulo
(L1,L2,L3) y determine el tipo de triángulo al que corresponde.
Suponga que A detona el mayor de los tres lados y B y C corresponden a los otros
dos lados, entonces:
Si A >= B + C No se trata de un triángulo
Si A =B+C Es un triángulo rectángulo
Si A >B+C Es un triángulo obtusángulo
Si A <B+C Es un triángulo acutángulo
Desarrolle funciones para cada tipo de triángulo, que tomen como parámetros de
entrada los lados del triángulo y devuelvan un valor booleano si el triángulo
pertenece o no a ese tipo.
9) Considerar el siguiente procedimiento llamado Intercambio, que tiene los parámetros

X y Y. Se supone que T es una variable local.
PROCEDIMIENTO Intercambio(X,Y:entero)
inicio
Var T:entero
T = X
X = Y
Y = T
fin
El procedimiento debe usarse en los siguientes enunciados:
I = 1
A = 2
B = 0
Intercambio (I, A)
Escribir I,A,B
¿Cuáles son los resultados del algoritmo?, explique con detalle lo que sucede en
cada caso:

a) La correspondencia entre parámetros formales y actuales se establece por paso

por valor.
b) La correspondencia entre parámetros formales y actuales se establece por paso
por referencia.
10) ¿Cuál es la salida del siguiente algoritmo?
procedimiento listar ( n:entero)
inicio
si (n = 1)
entonces
escribir “listo”
sino
escribir “vuelta”
listar(n-1)
fin si
fin listar
Algoritmo demo
inicio
listar(4)
fin
11) Escribir un procedimiento recursivo que tome como entrada un número entero y
escriba el número invertido.
Dado el número 12345 su inverso es 54321

a) Un procedimiento recursivo.
b) Un procedimiento iterativo.
12) Escribir un algoritmo que llame a una función recursiva para encontrar la suma de
los enteros pares hasta N.
Suma_Pares = 2 + 4 + 6 +...+ (N-2) + N
13) Escribir una función recursiva que permita multiplicar dos enteros m y n por medio
de sumas sucesivas.
14) Escribir una función recursiva que calcule la potencia de entero:

Xn donde x:real
n:entero

15) Escribir una función que dado el entero positivo x devuelva verdadero si y sólo si x
es una potencia de 2.
16) Los números de Fibonnacci son una secuencia de números, donde cada término de
la secuencia se define como:
F (1)= F (2)=1 para n=1 y n=2
F (n)= F (n-1) + F (n-2) para n > 2
Por tanto,
F(3) = F(1) + F(2) = 1 + 1 = 2
F(4) = F(3) + F(2) = 2 + 1 = 3
F(5) = F(4) + F(3) = 3 + 2 = 5
Escribir una función que tome como entrada un entero positivo que indique la
posición del término en la serie y retorne el valor del término en esa posición.

Unidad 5: Estructuras de Datos -

Arreglos
1) Diseñar un algoritmo que lea las notas de una clase de “Introducción a la
Programación” en un vector, calcule el promedio de notas e imprima las notas
mayores al promedio.
1. Algoritmo Calificaciones
2. var
3. MAX = 100 {número máximo de estudiantes}
4. notas: arreglo[1..MAX] de real
5. numero, i:entero
6. suma, promedio:real
7. inicio
8. escribir “Introducir numero de calificaciones”
9. leer numero
10. si numero > MAX
11. entonces “no se puede procesar mas de” MAX “notas”
12. sino
13. suma = 0
14. escribir “Introducir las calificaciones”
15. desde i = 1 hasta numero
16. leer notas[i]
17. suma = suma + notas[i]
18. fin desde
19. promedio = suma / numero
20. escribir “el promedio de las notas es:” promedio
21. escribir “las notas mayores que el promedio son:”
22. desde i = 1 hasta numero
23. si notas[i] > promedio
24. entonces escribir notas[i]
25. fin si
26. fin desde
27. fin si
28. fin Calificaciones
Libro 1: Fundamentos de Programación Unidad 5: Estructuras de Datos - Arreglos 179

2) Diseñar un algoritmo que dados dos vectores ordenados A y B, de tamaño M y N

respectivamente, produzca un tercer vector C ordenado, de tamaño M+N y formado
a partir de los elementos de los vectores A Y B.
Ejemplo:
Vector A: 2 5 7 100 250
Vector B: -4 0 10 98 120 300 310 540
Vector C: -4 0 2 5 7 10 98 100 120 250 300 310 540
El algoritmo es el siguiente:
a) Seleccionar el elemento de valor más pequeño en los vectores A y B,
ubíquelo en el nuevo vector C.
b) Para ello, se compara a[i] y b[j] y se coloca el elemento más pequeño en c[k],
donde i, j , k, son los índices correspondientes en cada uno de los vectores.
c) Se sigue la secuencia de comparaciones hasta que los elementos de uno de
los vectores A ó B se hayan agotado y entonces se copia el resto del otro
vector en el vector C.
1. Algoritmo Mezcla implementado como un procedimiento:
2. Procedimiento Mezcla (A,B,C:arreglos de enteros,

M,N:enteros)
3. {A y B: entrada: Vectores ordenados}
4. {M y N: número de elementos de A y B respectivamente}
5. {C:salida. Vector resultado de la mezcla de A Y B}
6. {El vector C tiene una longitud mínima de M + N}
7. var
8. i, j, k, p:entero
9. inicio
10. i = 1
11. j = 1
12. k = 1
13. mientras (i <= M) && (j <= N) hacer
14. si A[i] <= B[j]
15. entonces
16. C[k] = A[i]
17. i = i + 1
18. sino
19. C[k] = B[j]
20. j = j + 1
21. fin si
22. k = k + 1
23. fin mientras
Unidad 5: Estructuras de Datos - Arreglos Libro 1: Fundamentos de Programación 180

24. { copiar el resto del vector no agotado}
25. si i > M {agotado el vector A copiar B}

26. entonces
27. desde p = j hasta N
28. C[k] = B[p]
29. k = k + 1
30. fin desde
31. sino {j > M agotado el vector B copiar A }
32. desde p = i hasta M
33. C[k] = A[p]
34. k = k + 1
35. fin desde
36. fin si
37. fin procedimiento mezclar
3) Diseñar un algoritmo para sumar el número de elementos positivos y negativos de

una tabla o arreglo.
La matriz es de dimensión MxN y se lee desde el teclado.
1. Algoritmo Suma
2. var
3. M = 10: entero
4. N = 8: entero
5. tabla: arreglo[M,N] de entero
6. SP, SN, i, j:entero
7. inicio
8. { leer elementos de la tabla}
9. escribir “Introducir elementos de la tabla”
10. SP = 0
11. SN = 0
12. desde i = 1 hasta M
13. desde j = 1 hasta N
14. escribir “Introducir elemento (“ i “,” j “)”
15. leer tabla(i,j)
16. si tabla(i,j) > 0
17. entonces SP = SP + tabla(i,j)
18. sino SN = SN + tabla(i,j)
19. fin si
20. fin desde
21. fin desde
22. escribir “la suma de elementos positivos es:” SP
23. escribir “la suma de elementos negativos es:” SN
24. fin

4) Diseñar un algoritmo donde se declare una matriz M de enteros de dimensión 100 x

200, asignándose los siguientes valores:
1 0 1 0 1 0 1 0 …
0 1 0 1 0 1 0 1 …
1 0 1 0 1 0 1 0 …
0 1 0 1 0 1 0 1 …
etc.
1. Algoritmo Inicializar_Matriz
2. var
3. M[100, 200] arreglo de enteros
4. I,j:entero
5. inicio
6. desde i=1 hasta 100 incremento 1
7. si (i mod 2 == 0) {Filas pares comienzan en 0}
8. entonces
9. desde j=1 hasta j = 200 incremento 2
10. M[i,j] = 0
11. M[i,j+1] = 1
12. fin desde
13. sino {Filas impares comienzan en 1}
14. desde j=1 hasta j = 200 incremento 2
15. M[i,j] = 1
16. M[i,j+1] = 0
17. fin desde
18. fin si
19. fin
20. j = 0
21. repetir
22. j = j + 1
23. si f[i,j] = 1
24. entonces
25. escribir “Existe un enlace con la ciudad” j
26. fin si
27. hasta ( j = n)
28.fin

1) Elaborar un algoritmo que llame a las siguientes funciones:
1.1 La función SIGMA que calcula la suma de los n elementos de un vector X donde
X y n son los parámetros de la función.
1.2 La función PROD para calcular el producto de los n elementos de un vector X
donde X y n son los parámetros de la función.
2) Diseñar un algoritmo que lea en un arreglo N números reales, determine el máximo,

mínimo y el promedio. Para calcular estos valores debe hacer uso de funciones que
retornan ese valor.
Las funciones a definirse son:
a) Max_vector: Retorna el valor máximo de un arreglo.
b) Min_vector: Retorna el valor mínimo de un arreglo.
c) Med_vector: Retorna el promedio de un arreglo de reales.
Todas las funciones reciben el vector como parámetro de entrada.
3) Diseñar una función que devuelva VERDAD si dos arreglos dados como entrada son
iguales y FALSO en caso contrario.
4) Se necesita una función para determinar si un valor dado existe en el vector. Asuma
que los valores en el vector no están ordenados.
La función debe aceptar dos parámetros:
• El nombre de un vector.
• El valor que debe buscarse en ese vector.
La función debe regresar:
• 1 si el valor se encuentra en el vector.
• 0 si la búsqueda es infructuosa.
Ni el vector ni el valor deben ser alterados. ¿Qué tipo de parámetros es preferible?
¿Por qué?.
5) Modifique la función anterior asumiendo que el vector está ordenado en forma
creciente.
6) Dado un vector A de n números reales, obtener la diferencia más grande entre dos
elementos consecutivos de ese vector.
7) Dado un vector A de n números reales, obtener la diferencia más grande y la menor
diferencia entre dos elementos consecutivos de ese vector.

8) En todo experimento existe cierta cantidad de incertidumbre asociada con cualquier

medición. Una técnica conocida como ajuste de curvas puede utilizarse para reducir
el error en el análisis de los resultados.
Se supone que una serie de valores reales, ha sido registrada de N repeticiones de
un experimento en particular, los cuales se almacenan en un vector llamado V.
Antes de proceder al análisis de estos resultados experimentales, la siguiente
operación de ajuste simple debe aplicarse a los valores de V:
• Para cada valor, excepto el primero y el último, que deben permanecer sin
cambios, Vi debe reemplazarse por: Vi = (Vi-1 + Vi + Vi+1) / 3
Diseñar un algoritmo para leer las mediciones iniciales e imprimir los valores
observados y los ‘ajustados’.
Los valores ajustados deberán ser almacenados en otro vector.

9) Diseñar un algoritmo que dados dos vectores ordenados A y B de tamaño M y N
respectivamente, produzca un tercer vector C ordenado de tamaño M+N, formado a
partir de los elementos de los vectores A Y B y que no incluya los elementos
repetidos en el vector de salida.
10) La moda de un arreglo de vocales, es la vocal que se repite más frecuentemente. Si
varias vocales se repiten con la misma frecuencia máxima, entonces no hay moda.
Escribir una función que acepte un vector de caracteres y devuelva su moda o una
indicación de que la moda no existe.
11) Diseñar un procedimiento que acepte como parámetro un vector que pueda
contener elementos repetidos. El procedimiento debe reemplazar cada elemento
repetido por -1 y regresar al punto de llamada el vector modificado, además del
número de modificaciones realizadas.
12) Diseñar un algoritmo que lea un vector desordenado A, compuesto de n enteros e
imprima el vector en la misma secuencia, pero ignorando los valores duplicados que
se encuentren en él.
También se necesita saber el número de elementos m que permanecen en él.
Por ejemplo, dado el vector siguiente:
18 32 23 18 75 23 45 18 32 90
compuesto de 10 enteros, el vector comprimido que resulta estará formado por
18 32 23 75 45 90
con m = 6.
13) Dadas las siguientes declaraciones de variables:
a: arreglo[0..9] DE ENTEROS
x, i, k: ENTERO

Donde el vector a se inicializa con los valores: 6, 3, 9, 7, 1, 8, 10, 2, 4 y 5,

determinar el valor de x cuando se ejecutan los siguientes segmentos de código y
comentar qué operación se realizan:
a) x = 0
PARA i = 0 HASTA 9 CON INCREMENTO DE 1
x = x + a(i)
FIN_PARA
b) x = a(0)
SI x < a(i)
ENTONCES x = a(i)
FIN_SI
FIN_PARA
c) k = 0
SI a(k) < a(i)
ENTONCES k = i
FIN_SI
FIN_PARA
14) Diseñar un algoritmo que lea la matriz:
1. 6 8 9 2
2. 5 1 0 8
3. 1 2 6 9
Cree y escriba una nueva matriz de la forma:
3 4 5
4. 5 1
8 1 2
9 0 6
2 8 9
Esto corresponde a la matriz traspuesta de la matriz original.
15) Realizar un procedimiento que acepte como parámetro un vector de elementos
enteros y el tamaño del vector. El procedimiento debe ordenar los elementos y
regresar el vector ordenado por medio del mismo parámetro. ¿Qué tipo de paso de
parámetros se requiere? ¿Por qué?.
Utilice el algoritmo de ordenación por selección, que consiste en buscar el elemento
menor y colocarlo en la primera posición. Luego buscar el segundo elemento más
pequeño y colocarlo en la segunda posición, y así sucesivamente.

Los pasos del algoritmo son:

1. Seleccionar el elemento menor del vector de n elementos.
2. Intercambiar dicho elemento con el primero.
3. Repetir esta operación con los n-1 restantes, seleccionando el segundo elemento.
4. Continuar con los n-2 restantes, y así sucesivamente, hasta que sólo quede el
mayor.
16) Diseñar un algoritmo que dada una matriz cuadrada determine la suma de todos los
elementos que están en la diagonal. Los elementos de la diagonal son los A[i, j] de
la matriz A que cumplen con i=j.
17) Diseñar un algoritmo que dada una matriz cuadrada determine la suma de todos los
elementos que no pertenecen a la diagonal principal.
18) Una agencia de ventas automóviles distribuye 12 modelos diferentes y tiene 8
vendedores.
Diseñar un algoritmo que produzca un informe mensual de:
a) Las ventas por vendedor.
b) Las ventas por modelo.
c) El número de automóviles vendidos por todos los vendedores.
d) El número total de cada modelo vendido por todos los vendedores.
e) El vendedor que más vehículos ha vendido para la entrega del premio al mejor
vendedor.
Asuma que los datos están representados en una matriz, donde las filas representan
a los vendedores y las columnas a los modelos de vehículos.
19) Diseñar diferentes procedimientos que tomen dos matrices cuadradas de dimensión
N y realicen:
a) La suma de dos matrices.
b) La resta de dos matrices.
c) El producto de dos matrices.
20) Un analista de imágenes posee una imagen digitalizada representada en una matriz
bidimensional de enteros, con valores de colores entre 0 y 20, se desea convertirla
a una imagen en blanco y negro y visualizarla por pantalla.
Se debe considerar para convertir lo siguiente:
• Cada elemento (i,j) de la matriz representa un punto de la imagen.
• Al elemento se le asigna el valor negro (20) si la suma del contenido del
elemento (i,j) más el contenido de los elementos inmediatos a la derecha, a la
izquierda, arriba y abajo de éste, al dividirla (la suma) entre 5 es mayor que 10,
de lo contrario se le asigna 0.
Suma = (elem(i,j) + elem(i+1,j) + elem( i -1,,j) + elem(i,j+1) + elem(i,j-1) ) / 5

Considere las condiciones de borde, es decir, cuando la posición del elemento está
en los límites de la matriz.
Diseñar un procedimiento que tome la imagen digitalizada inicial y devuelva la
imagen en blanco y negro.
21) Diseñar un algoritmo dada una matriz de enteros (n x n), donde cada elemento (i,,j)
de la matriz representa la distancia entre las ciudades i, j. Si el contenido es –1,
indica que no existe camino entre esas dos ciudades. El algoritmo debe devolver los
pares de ciudades entre los que la distancia es menor que una distancia dada como
entrada.

Fundamentos de Programación Ejercicios Propuestos
Volumen 4: Ejercicios Propuestos


1) Evalúe las siguientes expresiones:
A = (3*2^5 mod 1 + 8*(3-5) < (2+8-1 mod 1)

A = A o (3+5*8) < 3 y ((-6/3 div 4)*2 < 2)
B = 3 mod 2 div 3
C = (-B*2 <> 8*3 mod 4) y (‘A’>’B’)
A = C o no (3=5) y (8 <> 3+B)

Respuestas de la Unidad 1: Ejercicios Propuestos
1) A = (3*2^5 mod 1 + 8*(3-5) < (2+8-1 mod 1)

A = (3*32 mod 1 + (-16)) < 10
A = -16 < 10
A = Verdadero
2) A = A o (3+5*8) < 3 y ((-6/3 div 4)*2 < 2)

A = Verdadero o 43 < 3 y (0*2 < 2)
A = Verdadero o Falso y Verdadero
A = Verdadero o Falso
A = Verdadero
3) B = 3 mod 2 div 3
B = 1 div 3
B=0
4) C = (-B*2 <> 8*3 mod 4) y (‘A’>’B’)

C = (0 <> 24 mod 4) y Falso
C = Falso y Falso
C = Falso
5) A = C o no (3=5) y (8 <> 3+B)

A = Falso o Verdadero y Verdadero
A = Falso o Verdadero
A = Verdadero

Unidad 2: Conceptos de Diseño

Estructurado
1) Desarrollar un algoritmo que calcule el volumen de un paralelepípedo.
2) Desarrollar un algoritmo que dado un valor entero, que representa un monto en

Bolívares, indique el número de billetes de 5000, 1000 y monedas de 100, 50, 10,
1, que equivalen al monto dado.
3) Desarrollar un algoritmo que dada la temperatura en grados Celsius, escriba en

pantalla la temperatura equivalente en grados Fahrenheit.
La fórmula es: °F = (9 * °C / 5)+32.

Respuestas de la Unidad 2: Ejercicios Propuestos
1) Desarrollar un algoritmo que calcule el volumen de un paralelepípedo.
Algoritmo para Calcular al Volumen de un Paralelepípedo

Var
altura, ancho, profundidad, volumen : real
Inicio
Escribir “Introducir Altura”
Leer altura
Escribir “Introducir Ancho”
Leer ancho
Escribir “Introducir Profundidad”
Leer profundidad
volumen = altura * profundidad * ancho
Escribir “El volumen es: ” volumen
Fin
2) Desarrollar un algoritmo que dado un valor entero, que representa un monto en

Bolívares, indique el número de billetes de 5000, 1000 y monedas de 100, 50, 10, 1,
que equivalen al monto dado.
Algoritmo Calcular cambio

Var
bolivares: real
Inicio
Escribir “Introduce los bolívares”
Leer bolivares
Escribir bolivares div 5000 “billetes de 5000”
bolivares = bolivares mod 5000
Escribir bolivares div 1000 “billetes de 1000”
Escribir bolivares div 100 “monedas de 100”
Escribir bolivares
Fin

3) Desarrollar un algoritmo que dada la temperatura en grados Celsius, escriba en

pantalla la temperatura en grados Fahrenheit, el equivalente es: F = (9C/5)+32.
La fórmula es: °F = (9 * °C / 5)+32
Algoritmo para Calcular dada la temperatura en °C el equivalente en °F

Var
fahrenheit, celsius: real
Inicio
Escribir “Introducir los grados Celsius:”
Leer celsius
fahrenheit = (9*celsius/5)+32
Escribir “La temperatura es: “ Fahrenheit
Fin

Unidad 3: Programación Estructurada.

1) Desarrollar un algoritmo que determine los números primos comprendidos entre 1 y
1000.
2) Desarrollar un algoritmo para determinar el máximo valor entre un conjunto de
números positivos, ingresados a través del teclado. Un número negativo indica que
no existen más números.
3) Desarrollar un algoritmo para determinar cuáles son los múltiplos de 5 comprendidos
entre 1 y N.
4) Desarrollar un algoritmo que al final de curso, que determine cuál es el alumno con
el promedio de notas más alto del semestre. Se sabe que en el semestre están
inscritos 150 alumnos y cursan 5 asignaturas.
5) Calcular la suma de los divisores de cada número ingresado a través del teclado. Se
termina el proceso cuando se ingresa un número negativo ó 0.
6) Se coloca un capital C, a un interés I, durante M años y se desea saber en cuánto
se habrá convertido ese capital en m años, sabiendo que es acumulativo.
Unidad 3: Programación Estructurada. Libro 1: Fundamentos de Programación 197

Respuesta Unidad 3: Ejercicios Propuestos

1) Desarrollar un algoritmo que determine los números primos comprendidos entre 1 y
1000.
Algoritmo para Determinar los números primos entre 1 y 1000

Const
Primero=1
Limite=1000
Var
cont, i, j: entero
primo: boolean
Inicio
Cont = 0
Desde i= primero hasta limite
primo = verdadero
j=2
mientras (i>j) y (primo =verdadero)
Si i mod j = 0
Entonces primo = falso
Sino j = j + 1
Fin si
Fin mientras
Si primo = verdadero
Entonces escribir i” “
Cont = cont + 1
Fin si
Fin desde
Escribir “Entre “primero” y “limite” hay “cont” nº primos”
Fin
Libro 1: Fundamentos de Programación Unidad 3: Programación Estructurada. 198

2) Desarrollar un algoritmo para determinar el máximo valor entre un conjunto de

números positivos ingresados a través del teclado. Un número negativo indica que
no existen más números.
Algoritmo para Determinar el Valor Máximo entre un Conjunto de Números
Positivos
Var
num, max: entero
Inicio
Max = 0
Escribir “Introduzca nº positivos y para acabar introduzca uno negativo”
Leer num
Mientras num >=0 hacer
Si num >max
Entonces max = num
Fin si
Leer num
Fin mientras
Escribir “El mayor número es” max
Fin
3) Desarrollar un algoritmo para determinar cuáles son los múltiplos de 5 comprendidos

entre 1 y N.
Algoritmo Para Determinar los Múltiplos de 5 en un Rango de Números Dado

Var
i: entero
Inicio
Desde i=1 hasta n
Si i mod 5 =0
Entonces escribir i
Fin si
Fin desde
Fin

4) Desarrollar un algoritmo, que al final de curso, determine cuál es el alumno con el

promedio de notas más alto del semestre. Se sabe que en el semestre están
inscritos 150 alumnos y cursan 5 asignaturas.
Algoritmo para Determinar el Alumno con el Promedio de Notas Más Alto del
Semestre
Const
Alumnos=150
Asignaturas=5
Var
Nombre, mejor_alum: cadena
Nota, suma, media, acum: real
I, j: entero
Inicio
Acum = 0
Desde i=1 hasta alumnos
Suma = 0
Escribir “Introduzca el nombre del alumno”
Leer nombre
Desde j=1 hasta asignaturas
Escribir “Introduzca la nota de la asignatura”
Leer nota
Suma = suma + nota
Fin desde
Media = suma / asignaturas
Si media > acum
Entonces acum = media
Mejor_alum = nombre
Fin si
Fin desde
Escribir “El mejor alumno es “mejor_alum
Escribir “Su nota media es “acum
Fin
Libro 1: Fundamentos de Programación Unidad 3: Programación Estructurada. 200

5) Calcular la suma de los divisores de cada número introducido por teclado. Terminará
cuando el número sea negativo ó 0.
Algoritmo Para Calcular la Suma de Los Divisores de un Conjunto de
Números
Var
Numero, i, suma :entero
Inicio
Escribir “Introduce un número y para terminar introduce un número negativo o 0”
Leer número
Mientras numero > 0 hacer
Suma = 0
Desde i=1 hasta numero /2
Si numero mod i =0
Entonces suma = suma + i
Fin si
Fin desde
Suma = suma + numero
Escribir “La suma de los divisores del número es “suma
Leer numero
Fin mientras
Fin
6) Se coloca un capital C, a un interés I, durante M años y se desea saber en cuánto

se habrá convertido ese capital en m años, sabiendo que es acumulativo.
Algoritmo para Calcular Final

Var
I, j, m: entero
c, temporal: real
Inicio
repetir
Escribir “Introduce el capital, el interés y el tiempo”
Leer c, i, m
Hasta (c>0) y ((i<=0)y(i<=100)) y (m >=0)
Desde j=1 hasta m
c = c * (1+I/100)
Fin desde
Escribir “Tienes “c” Bs.”
Fin

Unidad 4: Procedimientos y Funciones

1) Desarrollar un algoritmo calcular los n primeros términos de la serie de Fibonacci.
Los términos de la serie de Fibonacci se definen como sigue:
Fibonacci (1)= Fibonacci (2)=1 para n=1 y n=2
Fibonacci (n)= Fibonacci (n-1) + Fibonacci (n-2) para n > 2
2) Desarrollar un algoritmo que determine cuál es la primera potencia en base 2 mayor
que un número que se pasa como parámetro, devolviendo el valor de dicha potencia
y el exponente al que está elevado.
3) Desarrollar un algoritmo que calcule recursivamente en cuánto se convierte un
capital C al final de N años y a un interés I.
Libro 1: Fundamentos de Programación Unidad 4: Procedimientos y Funciones 203

1) Desarrollar un algoritmo para calcular los n primeros términos de la serie de

Fibonacci:
Los términos de la serie de Fibonacci están definidos como sigue:
Fibonacci (1)= Fibonacci (2)=1 para n=1 y n=2
Fibonacci (n)= Fibonacci (n-1) + Fibonacci (n-2) para n > 2
Algoritmo para Determinar los n Primeros Términos de la Serie de Fibonacci

Var
i, n: entero
Inicio
Escribir “Introduce un número”
Leer n
Desde i=1 hasta n
Escribir “La serie de fibonacci de “i” es “fibonacci (i)
Fin desde
Fin
Funcion fibonacci (num: entero): entero
Inicio
Si (num = 1) o (num = 2)
Entonces retorno 1
Sino
Retorno (fibonacci (num - 1) + fibonacci (num - 2)
Fin si
Fin fibonacci

2) Implementar un algoritmo que indique cuál es la primera potencia en base 2 mayor

que un número que se pasa como parámetro, devolviendo el valor de dicha potencia
y el exponente al que está elevado.
Algoritmo elevar
Var
Numero, resp1, resp2: entero
Inicio
Escribir “Introduce un número”
Leer numero
Comprueba (numero, resp1, resp2)
Escribir “2^”resp1”=”resp2” >”numero
Fin
Procedimiento comprueba (num: entero; ent-sal n: entero; ent-sal pot: entero)
Inicio
n =1
********Valor inical de pot falta****************************
Mientras pot < n hacer
pot = pot *2
n = n+1
Fin mientras
Fin comprueba
3) Implementar un algoritmo que calcule recursivamente en cuánto se convierte un

capital C al final de N años y a un interés I.
Algoritmo
Funcion calculo (c: entero; i: entero; n: entero): real
Inicio
Si m=0
Entonces retorno C
Sino
Retorno (c * (1 + i / 100) + calculo (c, i, n-1)
Fin si
Fin calculo


1) Un multicine tiene 5 salas y cada sala tiene una capacidad de 100 personas
distribuidas en 5 filas de 20 asientos.
Desarrolle un algoritmo que cuando un cliente solicite una entrada para una de las
salas, indique si hay un asiento disponible.
2) Dado el siguiente algoritmo ¿Cuál es la salida que produce?

Algoritmo Principal
Var
Datos: array [1..10] de entero
i: entero
inicio
desde i=1 hasta 10
datos [i] = i
fin desde
P1 (datos,datos[3])
Desde i=1 hasta 10
Escribir datos [i]
Fin desde
Fin
Procedimiento P1 (a: array [1..10] de entero; ent-sal x: entero)

Inicio
x=0
Desde i=1 hasta 10
x = x + a[i]
Fin desde
Fin P1
3) Dada una matriz A de M*N elementos, actualizar la matriz de manera que en la

matriz resultante, los elementos de la diagonal principal sean el resultado de su
valor inicial dividido entre la suma de los elementos que no forman parte de ella.


1) Un multicine tiene 5 salas y cada sala tiene una capacidad de 100 personas
distribuidas en 5 filas de 20 asientos.
Desarrolle un algoritmo que cuando un cliente solicite una entrada para una de las
salas indique si hay un asiento disponible.
Algoritmo Disponibilidad de Asiento en la Sala de Cine

Const
Salas=5
Asientos=20
Filas=5
Var
N_salas,j,k: entero
Marca: boolean
A: array [1..salas,1..asientos,1..filas] de entero
Inicio
Pedir_datos (n_salas)
Mientras n_salas <> 0 hacer
Marca = falso
j=0
k=1
Repetir
Si j > asientos
Entonces j =1
k = k+1
Fin si
Si (j=asientos) y (k>=filas) Entonces
escribir “Sala llena”
Marca = verdadero
Sino
si a [n_salas,j,k]=0 Entonces
a[n_salas,j,k] = 1
Escribir “Asiento”j”fila”k
Marca = verdadero
Sino j = j + 1
Fin si
Fin si
Hasta (a[n_salas,j,k]=1) y (marca=verdadero)
Pedir_datos (n_salas)
Fin mientras

Fin
Procedimiento pedir_datos (ent-sal s: entero)

Inicio
Repetir
Escribir “¿En qué sala quieres entrar?”
Leer s
Hasta (s>=0) y (s<=salas)
Fin pedir_datos
2) Dado el siguiente algoritmo ¿Cuál es la salida que produce?
Algoritmo Principal
Var
Datos: array [1..10] de entero
i: entero
inicio
desde i=1 hasta 10
datos [i] = i
fin desde
P1 (datos,datos[3])
Desde i=1 hasta 10
Escribir datos [i]
Fin desde
Fin
Procedimiento P1 (a: array [1..10] de entero; ent-sal x: entero)

Inicio
X=0
Desde i=1 hasta 10
X = x + a[i]
Fin desde
Fin P1
Salida del Algoritmo: 1, 2, 55, 4, 5, 6, 7, 8, 9, 10.

3) Dada una matriz A de M*N elementos, actualizar la matriz de manera que en la

matriz resultante, los elementos de la diagonal principal sean el resultado de su
valor inicial dividido entre la suma de los elementos que no forman parte de ella.
Algoritmo div_matriz
Var
A: array [1..M,1..N] de real
Suma: real
Inicio
Pedir_datos (a)
Sumar (a,suma)
Escribir (a)
Fin
Procedimiento pedir_datos (matriz: array [1..M,1..N] de real)

Var
I,j: entero
Inicio
Desde i=1 hasta M
Desde j=1 hasta N
Escribir “Introduce el elemento”i”,”j
Leer a[i,j]
Fin desde
Fin desde
Fin pedir_datos
Procedimiento sumar (matriz: array [1..M,1..N] de real; ent-sal s: real)

Var
I,j: entero
Inicio
S=0
Desde i=1 hasta M
Desde j=1 hasta N
Si i< > j
Entonces s = s + matriz [i,j]
Fin si
Fin desde
Fin desde
Fin sumar

Procedimiento escribir (matriz: array [1..M,1..N] de real; s: real)

Var
I,j: entero
Inicio
Desde i=1 hasta M
Desde j=1 hasta N
Si i=j
Entonces escribir a[i,j]/s
Sino escribir a[i,j]
Fin si
Fin desde
Fin desde
Fin escribir


Libro 1 - Fundamentos de Programación PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Libro 1 - Fundamentos de Programación PDF

Загружено:

Авторское право:

Доступные форматы

Fundamentos de

Guía del Estudiante

IBM IT Education Services

IBM ® es una marca registrada por International Business Machines Corporation.

Otras compañías, productos, y nombre de servicios pueden ser marcas registradas o

Trademarks of International Business Machines Corporation

Lotus Script Net.data

Marcas Registradas de otras Compañías

Windows, Microsoft Visual Studio Microsoft Corporation

Sybase Sybase Inc.

Edición Agosto 2007

La información contenida en este documento no ha sido sometida a ninguna prueba

Copyright International Business Machines Corporation, 2007. All rights reserved.

Instrucciones Especiales para la Impresión de este Curso:

Unidad 2: Examen de Autoevaluación 42

Objetivos del Aprendizaje 97

Ejercicios Propuestos 166

Descripción del Curso

Objetivos del Curso

Después de completar este curso, usted estará en la capacidad de:

Cada unidad de este curso es de dos horas académicas de duración.

Libro 1: Fundamentos de Programación Descripción del Curso 1

© Copyright IBM Corp. 2007

Unidad 2: Conceptos de Diseño Incorporado

Aquí se definen los conceptos utilizados para facilitar el entendimiento de un problema.

Unidad 3: Programación Estructurada

Unidad 4: Funciones y Procedimientos

En esta unidad, se estudia el concepto de funciones y procedimientos. Se describe la

Descripción de Unidades Libro 1: Fundamentos de Programación 2

© Copyright IBM Corp. 2007

Unidad 5: Estructura de Datos: Arreglos

Se estudian las estructuras de almacenamiento continuo y su representación en la

Unidad 6: Entrada y Salida

Esta unidad presenta la descripción de los conceptos básicos de entrada y salida en un

Unidad 7: Ejemplos de Programas

Unidad 2: Estructuras de Decisión

Unidad 3: Estructuras de Repetición

Libro 1: Fundamentos de Programación Descripción de Unidades 3

© Copyright IBM Corp. 2007

representada bajo la técnica de Pseudocódigo. También se presentan una serie de

Unidad 6: Estructuras de Repetición (Pseudocódigo)

Unidad 2: Estructuras de Datos - Arreglos

En esta unidad se aprecia la representación de Arreglos unidimensionales y

Volumen 4: Ejercicios Propuestos

Descripción de Unidades Libro 1: Fundamentos de Programación 4

© Copyright IBM Corp. 2007

Volumen 1: Conceptos de Programación

Libro 1: Fundamentos de Programación Descripción de Unidades 5

© Copyright IBM Corp. 2007

Unidad 1: Programas de Computadora

Unidad 1: Programas de Computadora Libro 1: Fundamentos de Programación 7

© Copyright IBM Corp. 2007

Los programas de computadora permiten dar solución a problemas de cualquier nivel,

Generalmente, los programadores utilizan algún lenguaje de programación para

Como cualquier ciencia, la programación requiere de una serie de conocimientos

Este curso introduce al estudiante a los fundamentos de la programación de manera

Para desarrollar programas de computadora existe una gran variedad de lenguajes de

El proceso para desarrollar programas de computadora requiere entender y conceptuar

Libro 1: Fundamentos de Programación Unidad 1: Programas de Computadora 8

© Copyright IBM Corp. 2007

En esta unidad se discuten los conceptos básicos más importantes de la programación

Para procesar la información se requiere del hardware como microprocesador, memoria

Un algoritmo debe tener las siguientes características: