Principios de Programación I

Academia de Computación
Centro de Estudios Tecnológicos Industrial y
de Servicios No. 49
Apuntes de Principios de
Programación
Ing. Edgar Paredes Basilio
Apuntes de Principios de Programación
INDICE
EL SOFTWARE Y LA RESOLUCIÓN DE PROBLEMAS................................................................... 2
PASOS NECESARIOS PARA LA RESOLUCIÓN DE UN PROBLEMA ............................................. 2
El Análisis del Problema. ................................................................................................................. 2
Diseño del Procedimiento de Solución. ........................................................................................... 4
Escritura de la solución en un lenguaje: programa.......................................................................... 7
Pruebas y documentación ............................................................................................................. 10
LA PROGRAMACIÓN Y LOS LENGUAJES INFORMÁTICOS ........................................................ 11
¿Por qué la Diversidad de Lenguajes Informáticos? ..................................................................... 11
TIPOS DE LENGUAJES INFORMÁTICOS....................................................................................... 12
Lenguajes de Programación Imperativa ........................................................................................ 12
Lenguajes de Programación Funcional ......................................................................................... 13
Lenguajes de Programación Lógica .............................................................................................. 14
Lenguajes de Programación Orientada a Objetos......................................................................... 15
¿CÓMO CONSTRUIR PROGRAMAS? ............................................................................................ 17
ELEMENTOS DE PROGRAMAS ...................................................................................................... 20
Datos: definiciones y tipos ............................................................................................................. 20
Constantes y variables................................................................................................................... 21
Operadores .................................................................................................................................... 23
Instrucciones.................................................................................................................................. 25
Instrucciones de Entrada y de Salida............................................................................................. 26
Instrucciones Condicionales .......................................................................................................... 26
Instrucciones Repetitivas ............................................................................................................... 27
ESTRUCTURAS BASICAS DE CONTROL ...................................................................................... 27
Reglas generales del pseudocódigo.............................................................................................. 27
Estructura secuencial..................................................................................................................... 28
Estructura condicional.................................................................................................................... 28
Estructura Condicional Simple....................................................................................................... 29
Estructura Condicional Doble ........................................................................................................ 29
Estructura condicional múltiple ...................................................................................................... 30
Estructura repetitiva ....................................................................................................................... 31
Estructura tipo mientras ................................................................................................................. 31
Estructura tipo hasta ...................................................................................................................... 32
Estructura tipo para........................................................................................................................ 33
LA PROGRAMACIÓN ESTRUCTURADA EN LA REPRESENTACION ARBORESCENTE............ 35
Estructura Secuencial .................................................................................................................... 35
Estructura Condicional................................................................................................................... 36
Estructura Condicional Simple....................................................................................................... 36
Estructura Condicional Doble ........................................................................................................ 37
Estructura Condicional Múltiple ..................................................................................................... 38
Estructura Repetitiva...................................................................................................................... 39
Estructura Tipo Hasta .................................................................................................................... 41
Estructura Tipo Para ...................................................................................................................... 42
LA REPRESENTACIÓN ESTRUCTURADA UTILIZANDO DIAGRAMAS N-S DE CHAPIN ............ 46
Estructura Secuencial .................................................................................................................... 46
Estructura Condicional................................................................................................................... 47
Estructura Condicional Simple....................................................................................................... 47
Estructura Condicional Doble ........................................................................................................ 48
Estructura Condicional Múltiple ..................................................................................................... 49
Estructura Repetitiva...................................................................................................................... 49
Estructura Tipo Mientras................................................................................................................ 50
Estructura Tipo Hasta .................................................................................................................... 50
Estructura Tipo Para ...................................................................................................................... 51
Elaboró Ing. Edgar Paredes Basilio
1
Apuntes de Principios de Programación
EL SOFTWARE Y LA RESOLUCIÓN DE PROBLEMAS
Una computadora se compone de dos elementos fundamentales: el hardware (su parte
dura), que constituye su estructura física, y el software (la parte blanda), que son todos
los programas que se ejecutan en la computadora. El hardware por sí solo no es capaz
de hacer que la computadora funcione. Sin el software, una computadora es un montón
de chatarra. El software hace que ésta pueda almacenar y procesar información.
El secreto de la computadora reside en su capacidad para ejecutar las instrucciones que
tiene guardadas. Ahora bien, para obtener la serie de instrucciones necesarias para
resolver un problema se necesita hacer un estudio de éste.
PASOS NECESARIOS PARA LA RESOLUCIÓN DE UN PROBLEMA
La computadora es una máquina capaz de ejecutar un conjunto de instrucciones muy
simples, como operaciones aritméticas, comparaciones, movimiento de información de
un lugar a otro, etc. Además, dichas instrucciones sólo las ejecuta en el momento en
que se le ordene y en la forma en que se le indique.
Se podría afirmar que es «un esclavo» al servicio del hombre, que obedece ciegamente.
Eso sí, su velocidad de operación es muy superior a la humana, nunca acusa cansancio
y tiene muchas menos probabilidades de cometer un error.
Las utilidades de una computadora son, pues, la rapidez y la exactitud en la resolución
de problemas bajo una programación adecuada.
Para efectuar correctamente la labor de programación es necesaria algo más que la
escritura de un programa en un lenguaje determinado. Desde que se enuncia o plantea
un problema, por sencillo que éste sea, hasta que se consigue obtener los resultados
deseados, es necesario pasar por todas y cada una de las siguientes fases:
1) Análisis del problema.
2) Diseño del procedimiento de solución.
3) Escritura de la solución en un lenguaje de programación: programa.
El Análisis del Problema.
El análisis consiste en estudiar el problema planteado para obtener una idea clara y
concisa sobre lo que se desea obtener como resultado, los datos de entrada de los que
se parte y la forma en que estos datos iniciales van a llegar a la computadora.
Igualmente debe estudiarse el tratamiento que se ha de realizar con dichos datos, así
como la información que se desea obtener como resultado y de qué manera debe
presentarse. Es decir, después de analizar el problema, se han de conocer claramente
tres cosas:
Elaboró Ing. Edgar Paredes Basilio
2
Apuntes de Principios de Programación
1) Información de Salida deseada. Para ello se debe responder a ¿Qué se quiere
obtener?
2) Tratamiento que ha de realizarse con estos datos. En este caso, se necesita
responder a la pregunta ¿Cómo se tiene que obtener el resultado?
3) Datos de Entrada de que se dispone. Para poder definir estos datos se debe
responder a la pregunta ¿Qué datos se necesitan?
Esta forma de estudiar y diseñar una solución a un problema dado corresponde a la
programación imperativa. A lo largo de los siguientes capítulos éste enfoque será el que
se desarrolle.
EJEMPLO
Supóngase una empresa en donde inicialmente había unos pocos empleados y en la
que la preparación de las nóminas se realizaba a mano, puesto que no suponía mucho
tiempo. Con el paso de los años, la empresa va creciendo y se necesita ampliar la
plantilla, hasta que llega un momento en que el volumen de datos a manejar para hacer
las nóminas hace imposible su realización sin mecanizar el proceso.
Llegado este momento se debe responder a las tres preguntas anteriores. En este caso
se utilizará un modelo muy básico de nómina.
1. ¿Qué se quiere obtener? El sueldo a percibir por cada empleado.
2. ¿Cómo se puede obtener el resultado? El tratamiento que se les debe dar a los datos
de los empleados para confeccionar el sueldo a percibir es:
Sueldo = Sueldo Base + Complem. + (H. Extras * Precio H. Extra)
En los datos de entrada deben estar disponibles todos y cada uno de los valores
necesarios para realizar el tratamiento.
3. ¿Qué datos se necesitan? Se debe conocer el Sueldo Base de cada empleado, así
como sus Complementos y Número de horas extras del mes.
Después de haber respondido a estas preguntas, se tendrá una idea clara de cuál es el
problema y del camino que se debe seguir para resolverlo.
Elaboró Ing. Edgar Paredes Basilio
3
Apuntes de Principios de Programación
Diseño del Procedimiento de Solución.
Una vez analizado el problema se precisa diseñar un procedimiento de solución.
En la programación imperativa el procedimiento de solución es un algoritmo. Éste se
puede definir como un conjunto finito ordenado de pasos que especifican la secuencia
de operaciones que se han de realizar para resolver un determinado problema.
Es imprescindible que el algoritmo elegido para resolver un problema sea absolutamente
claro, sin ningún tipo de ambigüedad y, además, contemple todas y cada una de las
posibles situaciones que puedan presentarse durante la resolución del mismo.
En general, muchas actividades de la vida cotidiana se pueden describir mediante
algoritmos. Para familiarizarse con ellos, se desarrollan a continuación algunos ejemplos
que ponen de manifiesto la necesidad de las características mencionadas anteriormente.
Ejemplo 1: Si a un experimentado conductor se le preguntase cómo pone en
movimiento su coche, no es difícil pensar que su contestación sería:
«Pues muy fácil, se pone el motor en marcha, se mete la primera y se acelera poco
a poco».
Efectivamente es fácil. Pero ¿qué ocurriría si un individuo que no hubiera conducido
nunca siguiese estas instrucciones?
Elaboró Ing. Edgar Paredes Basilio
4
Apuntes de Principios de Programación
Por ejemplo, si el coche tuviese metida una marcha, al arrancar el motor es posible que
se estrellara contra el de delante o el de atrás. También se han olvidado detalles porque,
por ejemplo, para meter la primera se ha de pisar el embrague y eso es algo que no está
detallado en el algoritmo inicial.
No se han tenido en cuenta ni todas las posibilidades ni todos los detalles que se
pueden presentar para poner el coche en movimiento. Por lo tanto, su algoritmo:
1. Poner el motor en marcha.
2. Meter la primera.
No es adecuado.
El algoritmo siguiente:
1. Inicio del algoritmo.
2. Si no tiene el freno de mano ponerlo.
3. Pisar el embrague con el pie izquierdo y el freno con el pie derecho.
4. Poner punto muerto.
5. Dar a la llave de contacto.
6. Meter la primera.
7. Quitar el freno de mano.
8. Levantar el pie del embrague a la vez que se pisa el acelerador con el pie derecho.
9. Final del algoritmo.
es mucho mejor porque: primero, desglosa el problema en instrucciones simples y
concretas, comprensibles para cualquier persona; y segundo, indica claramente el orden
en que deben ejecutarse todas las posibilidades.
Este ejemplo es un caso típico de un algoritmo con estructura secuencial porque
describe la solución en forma de una secuencia única de pasos.
Ejemplo 2: ¿Qué se hace cuando se efectúa una llamada telefónica?:
1. Inicio del algoritmo.
2. Descolgar el auricular.
3. Esperar la señal de línea.
4. Marcar el número.
5. Si no comunica el teléfono entonces preguntar por la persona buscada; si comunica
llamar en otro momento.
6. Colgar el auricular.
7. Final del algoritmo.
En este algoritmo aparece una novedad respecto al ejemplo primero: en el quinto paso
Elaboró Ing. Edgar Paredes Basilio
5
Apuntes de Principios de Programación
hay una instrucción alternativa que dependiendo de una condición (que esté la persona
buscada) ejecuta una acción u otra.
Por tanto, ha aparecido una estructura condicional que describe las posibles alternativas
del procedimiento.
Ejemplo 3: ¿Qué ocurriría si una persona estuviera esperando una carta urgentemente?
Revisaría varias veces al día su buzón hasta que estuviera la carta.
El algoritmo es:
1. Inicio del algoritmo.
2. Coger las llaves del buzón.
3. Ir al buzón del portal.
4. Abrir el buzón.
5. Si está la carta dentro del buzón, cogerla.
6. Repetir los pasos 2, 3, 4 y 5 hasta que esté la carta.
7. Final del algoritmo.
Un grupo de acciones se repite varias veces hasta que se cumpla la condición. En este
caso se repite la búsqueda de la carta en el buzón hasta que ésta haya llegado. Se
podría afirmar entonces que se está ante una estructura repetitiva.
Después de haber visto las posibles estructuras de las instrucciones de un algoritmo se
puede construir el algoritmo para el problema de la gestión de nóminas:
1. Inicio del algoritmo.
2. Seleccionar un empleado.
3. Sumar su Sueldo Base y sus Complementos.
4. Si ha hecho horas extras entonces sumar las horas extras al valor obtenido en el paso
4, de lo contrario no sumar.
5. Imprimir la nómina del empleado.
6. Repetir los pasos 2, 3, 4 y 5 hasta que no haya más empleados.
7. Final del algoritmo.
Observe que este algoritmo utiliza las estructuras secuencial, condicional (paso 4) y
repetitiva (paso 6).
Elaboró Ing. Edgar Paredes Basilio
6
Apuntes de Principios de Programación
Se puede afirmar que cualquier algoritmo puede ser expresado empleando solamente
estas tres estructuras.
Según se deduce de estos ejemplos, se pueden concretar más formalmente las
características y partes fundamentales que debe tener todo buen algoritmo:
- Un punto de inicio.
- Un punto de finalización.
- Estar bien definido, es decir, si se sigue varias veces el algoritmo con los mismos datos
de entrada, se debe obtener el mismo resultado.
- Tener en cuenta todas las posibles situaciones que puedan plantearse.
- Ser efectivo, esto es, resolver el problema para el que fue diseñado.
- Ser de fácil lectura e interpretación.
- Ser finito, y muy finito terminando en algún punto tanto en su escritura como en su
ejecución.
- Estar escrito en menos instrucciones de las que se ejecutan (gracias a las
instrucciones repetitivas).
- Estar diseñado de forma que sea independiente del lenguaje de programación en que
vaya a ser expresado.
Escritura de la solución en un lenguaje: programa
La computadora ha de ser capaz de entender el algoritmo que se ha escrito. Para ello se
tiene que escribir éste en un lenguaje que la computadora sea capaz de entender. Existe
un gran salto entre el lenguaje que se ha utilizado para escribir el algoritmo y el
lenguaje que la computadora entiende. Para minimizar esta diferencia y ayudar a la
escritura de programas se han creado los lenguajes de alto nivel.
Un lenguaje de alto nivel se encuentra entre el hombre y la computadora, siendo
Elaboró Ing. Edgar Paredes Basilio
7
Apuntes de Principios de Programación
entendible por ambos. Permite escribir un algoritmo en un lenguaje que es entendible
por los humanos y también por la computadora. Existen muchos lenguajes de
programación, pero no todos son de alto nivel. Entre los más conocidos de alto nivel
están: Cobol, Fortran, C, Pascal, Modula 2, etc.
Un algoritmo escrito en un lenguaje de programación es lo que se conoce con el nombre
de programa. Esta es la definición según la programación algorítmica. Ahora bien,
existen otros tipos de programación que se verán más adelante en los que el algoritmo
no es la base de un programa.
Para aumentar la eficacia de la programación se necesita que los programas tengan una
estructura fácil de interpretar, de modo que los haga más comprensibles, manejables,
modificables y fiables.
A este proceso de escritura del algoritmo con un lenguaje de programación se le
denomina codificación. Consiste en escribir un algoritmo (descrito con palabras) en un
lenguaje informático que la computadora es capaz de «comprender» (lenguaje de alto
nivel).
Más adelante se verá cómo la computadora es capaz de «entender» estos lenguajes de
alto nivel, puesto que necesitan de un proceso de traducción que los convierta al lenguaje
máquina, que es el único lenguaje que realmente la computadora entiende.
¿Qué pasos sigue la computadora para ejecutar un programa?
Una vez que el programa ha sido introducido en la computadora y el programador ha
comprobado su corrección es el momento para que la computadora lo traduzca a su
lenguaje y lo ejecute.
Pero ¿qué ocurre?, ¿qué pasos ha de seguir la computadora para ejecutarlo?
Se parte de un programa que está escrito con un lenguaje de alto nivel y se quiere que
la computadora sea capaz de ejecutarlo. Por tanto, el objetivo es conseguir que un
programa entendible para los hombres lo sea para la computadora.
Esto se consigue traduciéndolo al único lenguaje que la computadora entiende: el
lenguaje máquina. Este lenguaje está formado por un conjunto de unos y ceros. Se
verán a continuación los pasos que sigue la computadora hasta conseguir ejecutar el
programa.
La manera de realizar esta traducción es a través de otros programas llamados
intérpretes o compiladores que se encargan de leer el código y de traducirlo al lenguaje
ensamblador.
En el caso de los intérpretes, la traducción se realiza cada vez que se tiene que ejecutar
una orden, y en el caso de los compiladores primero se traducen todas las órdenes y
luego se comienza la ejecución del programa.
El lenguaje ensamblador es un estadio intermedio entre los lenguajes de alto nivel y el
lenguaje máquina. Simplifica la programación al no tener que escribir los programas
directamente en lenguaje máquina, sino que se pueden emplear sencillas
Elaboró Ing. Edgar Paredes Basilio
8
Apuntes de Principios de Programación
instrucciones, formadas por códigos de instrucción y nombres simbólicos para designar
a los datos, que son más comprensibles por los programadores.
Una vez que se tiene el programa traducido a lenguaje ensamblador se necesitan tres
herramientas para convertirlo a lenguaje máquina y ejecutar éste: el Programa
Ensamblador, el Montador y el Cargador.
El Programa Ensamblador se encarga de realizar el proceso de traducción, necesario
para convertir un programa fuente en ensamblador en un programa objeto en lenguaje
máquina, es decir, ceros y unos.
Es conveniente dividir los programas a desarrollar en pequeños módulos que se
codifiquen y se pongan a punto de forma independiente. La ventaja de esta solución
consiste en que no hay que repetir el proceso de ensamblaje de módulos no modificados
y su inconveniente es que la salida producida no es un código que pueda ejecutar la
máquina, puesto que hay que coordinar los distintos módulos entre sí.
El Programa Montador se encarga de coordinar los distintos módulos, creando uno
único que ya es ejecutable por la computadora, puesto que tiene todo lo necesario para
ser cargado en memoria principal.
El Programa Cargador tiene como misión llevar a memoria principal el resultado del
montador, para proceder a su ejecución.
Una vez que el programa y los datos residen en la memoria principal, la secuencia
básica de ejecución del programa se compone de los siguientes pasos, que se repiten
sucesivamente:
- La computadora lee de memoria principal una instrucción o sentencia del programa.
- La unidad de control interpreta la instrucción leída.
- Bajo los mandatos de la unidad de control se ejecuta la instrucción.
Así, la computadora irá recorriendo el programa cargado en memoria y ejecutando las
instrucciones escritas (en código máquina).
Una vez que el programa ha sido introducido en la computadora y el programador ha
comprobado su corrección, es el momento para que la computadora lo traduzca a su
lenguaje y lo ejecute.
Pero, ¿qué ocurre?, ¿qué pasos ha de seguir la computadora para ejecutarlo?
Se parte de un programa que está escrito con un lenguaje de alto nivel y se quiere que la
computadora sea capaz de ejecutarlo. Por tanto, el objetivo es conseguir que un
programa entendible para los hombres lo sea para la computadora.
Elaboró Ing. Edgar Paredes Basilio
9
Apuntes de Principios de Programación
Pruebas y documentación
El hecho de haber diseñado un buen algoritmo y posteriormente haberlo codificado en
un lenguaje de programación no significa que el programa resuelva correctamente el
problema. La experiencia de cualquier programador, por muy experto que sea, lo
demuestra.
Por eso, antes de dar por finalizada cualquier labor de programación, es indispensable
preparar un conjunto de datos de entrada lo más amplio posible, que aplicado al
programa permita la verificación de los resultados. Este proceso se conoce como de
pruebas.
Cuanto más exhaustivas sean las pruebas de un programa, mayor seguridad se tendrá
de que éste funciona correctamente y, por lo tanto, mayores probabilidades habrá de
evitar la ardua tarea de revisar un programa antiguo.
Una vez finalizado y probado un programa, debe procederse al proceso de
documentación. Su objetivo es que cualquier programador sea capaz de entenderlo, e
incluso modificarlo en caso de necesidad, aunque no haya sido el autor del mismo.
Una correcta documentación debe contener:
- Descripción del problema.
- Descripción de los datos de entrada.
- Descripción de los resultados de salida.
- Descripción del algoritmo.
- Listado del programa fuente en su lenguaje de programación.
- El juego de ensayo que haya permitido probar el programa.
Esta documentación se conoce con el nombre de Cuaderno de Carga del programa.
Elaboró Ing. Edgar Paredes Basilio
10
Apuntes de Principios de Programación
LA PROGRAMACIÓN Y LOS LENGUAJES INFORMÁTICOS
Una vez que se ha visto cómo abordar un problema y cómo escribir un algoritmo que lo
modele se verán a continuación las herramientas de que se dispone, los lenguajes de
programación para programar un algoritmo, cómo construir un programa, y cómo
programarlo utilizando pseudocódigo.
¿Por qué la Diversidad de Lenguajes Informáticos?
La primera pregunta que uno se plantea cuando descubre que existe un gran número de
lenguajes de programación es ¿por qué tantos?, ¿por qué no diseñar un lenguaje
estándar aceptado por todos?
Se podría establecer un símil con la Industria Automovilística, ¿por qué hay tantos
modelos y tipos de coches?, ¿por qué no tener un único modelo de cada tipo de coche?
Existen distintos tipos de vehículos porque cada uno de ellos está más capacitado para
satisfacer las necesidades de los usuarios en cada caso, por ejemplo, para transportar
grandes cargas no se empleará un utilitario pequeño, sino que se utilizará un camión de
gran resistencia. Por otro lado, a pocas personas se les ocurriría ir a trabajar a la oficina
en el centro de la ciudad con un camión, sino que utilizarán un coche más pequeño. Se
empleará un vehículo para cada tipo de problema, aquel que se adapte más a las
características del transporte.
También es cierto que los vehículos han ido mejorando sus prestaciones, apareciendo
modelos y tipos distintos que satisfagan más a los usuarios, que les ofrezcan mayor
seguridad, menor consumo, mayor confortabilidad, etc. De ahí que sea imposible que
exista un único vehículo, puesto que para algunos usuarios este vehículo podría ser
demasiado básico y para otro demasiado sofisticado. La diversidad de modelos, por
tanto, también se debe a la diversidad humana.
Por último, no hay que olvidar en ninguno de los dos campos (Informático y
Automovilístico) el aspecto comercial que subyace: los productos se desarrollan para ser
vendidos y cuantos más haya, más posibilidades de venta existen. Realmente, éste es
uno de los factores principales por los que existe una gran diversidad de lenguajes de
programación.
El símil anterior lleva a deducir, en primer lugar, que existen distintos tipos de lenguajes
de programación porque cada uno de ellos está especificado para resolver un grupo de
problemas con características similares.
En segundo lugar, los lenguajes de programación han ido evolucionando hacia una
mayor facilidad, flexibilidad y potencia. Por esto, han ido apareciendo distintos tipos de
lenguajes que ofrecen una funcionalidad mayor y generalmente una filosofía de
programación novedosa.
Por último, las compañías que diseñan software están muy interesadas en tener muchos
lenguajes de programación en el mercado porque esto les reportará más beneficios
económicos. Esta es la tercera razón de por qué existen tantos lenguajes de
programación.
Elaboró Ing. Edgar Paredes Basilio
11
Apuntes de Principios de Programación
TIPOS DE LENGUAJES INFORMÁTICOS
Por ahora, existen cuatro tipos fundamentales de lenguajes de programación:
1. Lenguajes de Programación Imperativa
2. Lenguajes de Programación Funcional
3. Lenguajes de Programación Lógica
4. Lenguajes de Programación Orientados a Objetos
Lenguajes de Programación Imperativa
Supóngase que se quiere escribir un programa que calcule el resultado de elevar un
número A a otro B (AB). Si se supone que B es un número entero, entonces el cálculo
se puede hacer multiplicando el número A por sí mismo tantas veces como indique el
número B.
El algoritmo sería:
1. Inicio del algoritmo.
2. Introducir A y B ( A - Base, B - Potencia).
3. Multiplicar A por A y dejar el resultado en A.
4. Restar 1 a B.
5. Repetir los pasos 3 y 4 hasta que B sea igual a CERO.
6. Mostrar el resultado.
7. Fin del algoritmo.
Los lenguajes de Programación Imperativa son los más difundidos y son adecuados
para resolver aquellos problemas que tienen soluciones expresables en un algoritmo.
Para este tipo de lenguajes un programa se puede expresar como sigue:
Programa = Algoritmo + Estructuras de Datos
Es decir, está compuesto de un algoritmo que represente o describa cómo hay que
resolver el problema y de las estructuras de datos necesarias para almacenar la
información.
En el ejemplo de la gestión de nóminas, el algoritmo describe cómo se tiene que calcular
el valor del sueldo de cada empleado y las estructuras de datos almacenan los valores
necesarios para calcular el sueldo (sueldo base, número de horas extras, etc.).
Las características de estos tipos de lenguajes son las siguientes:
— Procedimentales: en el sentido de que describen cómo se ha de resolver el problema
y no qué problema es.
Elaboró Ing. Edgar Paredes Basilio
12
Apuntes de Principios de Programación
— Deterministas: en el sentido de que se tienen siempre los mismos resultados del
programa para las mismas entradas. Es decir, si se calcula el sueldo para un empleado
varias veces, los resultados de salida siempre serán los mismos, puesto que los datos
de entrada siempre son los mismos.
— Necesitan de la existencia de un proceso que traduzca el código al lenguaje que
entiende la computadora (lenguaje máquina).
— Algorítmicos: como ya se ha visto, expresan cómo resolver el problema mediante un
algoritmo.
Dentro de este grupo están los lenguajes Pascal, Modula-2, ADA, C, Basic, Cobol y
Fortran.
Lenguajes de Programación Funcional
Cuando se quiere resolver un problema con un lenguaje funcional, no se tiene que
construir un algoritmo que exprese cómo se tiene que resolver el problema, sino que se
tienen que describir los elementos (funciones) que van a servir para resolverlo.
Para resolver el problema anterior de la potenciación, se deberían construir únicamente
dos funciones:
La función Potencia y la función Producto.
En pseudocódigo, la definición de estas dos funciones sería:
Potencia de A y B es el Producto de A por la Potencia de A y B-1
Potencia de A y 1 es A
Producto de A y A es A*A
y la descripción de las funciones es:
Potencia(A,B) = Producto[A,Potencia(A,B 1)]
Potencia(A,1)=A
Producto(A,A)=A*A
Es decir, se define la función Potencia(A,B) diciendo que es el Producto de A por la
Potencia de A y B-1. Esta forma de definir un problema es recursiva, porque se expresa
Potencia(A,B) en función de Potencia(A,B-1). Pero ¿cómo se calcula el valor, por
ejemplo, de 43?
Para calcular el valor de 43, se necesita interpretar la frase (llamada a una función)
Potencia(4,3), para ello se deben desarrollar y resolver todas las llamadas recursivas a
la función Potencia y a Producto.
Potencia(4,3)=Producto[4,Potencia(4,2)] = 4 * 16 = 64
Producto[4,Potencia(4,1)] = 4 * 4 = 16
Es como deshacer un ovillo en el que para resolver Potencia(4,3) se necesita primero
Elaboró Ing. Edgar Paredes Basilio
13
Apuntes de Principios de Programación
resolver Potencia(4,2) y así hasta que se llegue a Potencia(4,1) que ya no está definida
recursivamente. Como ya se ha llegado a un valor concreto denominado base de la
recursión [Potencia(4,1)=4] se puede ir hacia atrás e ir resolviendo las llamadas a
funciones que quedaron pendientes. Al llegar a la primera llamada [Potencia(4,3)] se
obtendrá el valor de la potencia.
Un programa, en este caso, puede expresarse del siguiente modo:
Programa = Funciones + Estructuras de Datos
Las características de estos lenguajes son:
— Su base es la recursividad, puesto que las funciones se definen de forma recursiva.
— Las funciones son los elementos principales de los programas.
— Son lenguajes interpretativos: necesitan de un proceso de interpretación (traducción)
para que sea comprensible a la computadora.
— Son lenguajes deterministas: en el sentido de que se tienen siempre los mismos
resultados del programa para las mismas entradas.
Al ser lenguajes con una componente matemática alta su mejor campo de aplicación
es el científico, y por su facilidad de búsqueda es el más usado en Inteligencia
Artificial. Por tanto, su aceptación y utilización es principalmente en entornos de
investigación y docencia.
Los lenguajes más representativos dentro de este grupo son Lisp, Camel y Hope.
Lenguajes de Programación Lógica
En este caso se definen los programas en función de un conjunto de reglas y asertos
(afirmaciones). Para obtener resultados de un programa, se hacen preguntas a la
computadora, y ésta, en función de las reglas y afirmaciones que tiene almacenadas,
responde.
La «inteligencia» de la computadora reside en la manera que tiene de interpretar y
encadenar las conclusiones de las reglas.
Esto se hace con lo que se denomina el motor de inferencia.
Imagínese que se tiene un programa con las siguientes reglas y afirmaciones:
Regla 1.
Regla 2.
Supervisor(x,y) : - jefe(x), empleado(y)
´x´ es Supervisor de ´y´, si ´x´ es jefe e ´y´ es empleado
Supervisor(x,y) : - jefe(x), secretaria(y)
´x´ es Supervisor de ´y´, si ´x´ es jefe e ´y´ es secretaria
Aserto 1. Empleado(Juan)
Aserto 2. Empleado(Luis)
Juan es un empleado
Luis es un empleado
Elaboró Ing. Edgar Paredes Basilio
14
Apuntes de Principios de Programación
Aserto 3. Secretaria(Rosa)
Aserto 4. Jefe(Pedro)
Aserto 5. Jefe(Julio)
Rosa es secretaria
Pedro es Jefe
Julio es Jefe
Se pueden hacer preguntas como:
1. ¿Está Rosa supervisada por Julio? La respuesta sería que SI porque existe una
regla que dice que si alguien es Jefe, supervisa a las secretarias (regla 2), y como Julio
es Jefe (aserto 5) y Rosa es secretaria (aserto 3), el motor de inferencia del lenguaje
deduciría que la respuesta es afirmativa.
2. ¿Quién supervisa a quién? La computadora, de acuerdo a las reglas y afirmaciones
existentes, deduciría que como Pedro y Julio son Jefes supervisan a Juan, Luis y Rosa
que son empleados y secretarias.
Por tanto, un programa se compone de:
Programa = Reglas + Asertos + Estructuras de Datos + Control
El Control lo proporciona el motor de inferencia, que es el que realmente «razona» y
obtiene resultados a partir de las reglas y asertos existentes.
Las características de estos lenguajes son:
— Se describe qué problema ha de resolverse, no cómo resolverlo.
— Son lenguajes conversacionales, es decir, es como si la computadora fuera una
persona a la que se le pregunta de acuerdo a un lenguaje de interrogación definido y
responde con las conclusiones que obtiene.
— Son lenguajes recursivos, la definición de las reglas generalmente se realiza, al igual
que en los lenguajes funcionales, de forma recursiva.
Este tipo de lenguaje informático es muy utilizado en áreas como la Inteligencia
Artificial, puesto que tratan de simular la forma de razonamiento humano. El más
representativo de todos es Prolog, aunque también hay otros como Alice.
Lenguajes de Programación Orientada a Objetos
La Programación Orientada a Objetos constituye otra forma de pensar cómo resolver
algunos de los problemas planteados en el mundo de la Informática. En la programación
orientada a objetos se examina el universo del problema en términos de «entidades» y
de relaciones entre esas «entidades». Estas «entidades» se eligen porque tienen algún
límite fisico o conceptual que los separa del resto del problema.
Por ejemplo, si se está tratando de describir un problema de simulación de un
aparcamiento en la computadora, se tendrán las siguientes entidades independientes
entre sí, los coches, las plazas de aparcamiento y los puestos de «peaje».
Elaboró Ing. Edgar Paredes Basilio
15
Apuntes de Principios de Programación
Las entidades son representadas como objetos en el programa. El objetivo es tener una
correspondencia entre entidades en el problema físico y objetos en el programa. Dentro
de cada objeto está almacenada toda la información representativa del objeto (variables)
y todas las operaciones que se pueden realizar con ese objeto (métodos o funciones). A
esta particularidad se la denomina encapsulación de datos y funciones dentro de un
objeto.
Por ejemplo, el objeto puesto de peaje del ejemplo anterior tendrá como datos: su
Estado (abierto/cerrado/averiado) y el estado del aparcamiento (libre/completo). Como
funciones tendrá todas aquellas que se puedan realizar en la realidad, como: Abrir el
peaje, Cerrar el peaje, Recoger ticket, Dar ticket e Informar del estado del aparcamiento.
Si se quisiera crear un aparcamiento, se debería declarar cuántos objetos se tienen y de
qué tipo son. Suponiendo que se tienen tres peajes, veinte coches y treinta plazas, se
debería declarar la existencia de todos estos objetos. Cada objeto del tipo Puesto de
Peaje tiene una variable del tipo Estado y en cada uno de ellos puede tener un valor
distinto, puesto que aunque sean objetos de igual tipo, el estado en el que se
encuentran sus valores no tiene porqué ser igual.
Cuando se quiera ejecutar una función de un objeto, sólo se tendrá que hacer una
llamada a esa función del objeto mediante el envío de un mensaje al objeto
correspondiente, con el nombre de la función que se desee ejecutar. Si, por ejemplo,
entrara un coche por la puerta de peaje, se debería hacer una llamada a la función Dar
ticket, a continuación hacer otra llamada a Abrir peaje, y por último a Cerrar peaje. Como
ha entrado un coche, se deberá crear otro objeto que almacenase el número de
matrícula del coche, el tipo, etc., todos aquellos datos que encapsulara el objeto Coche.
Una característica importante dentro de estos lenguajes es la herencia, concepto
análogo al de la Biología. Se pueden declarar objetos que sean «hijo» de otro objeto, de
manera que hereden todas las propiedades de su «padre». Así, se define una jerarquía
de herencias que ayudan a describir los problemas. Por ejemplo, se puede definir un
objeto Mamífero, que represente las características comunes de los mamíferos y,
posteriormente, se puede definir un objeto Oso, «hijo» del objeto Mamífero, del que
hereda todas sus características y añade otras propias de oso. De esta forma, se evita la
repetición de las características comunes de los mamíferos en todas las especies que lo
sean.
Un fuerte atractivo de los lenguajes orientados a objetos es que ofrecen una mayor
reutilización. Se facilita la modificación y reutilización de un programa después de
haber sido construido y utilizado.
Por tanto, un programa de este tipo puede expresarse como sigue:
Programa = Objetos + Mensajes
Las características de estos lenguajes son:
— Están orientados a reutilizar el software que desarrollan, con el fin de resultar más
sencilla la modificación de los programas y sobre todo que sean útiles para ser utilizados
Elaboró Ing. Edgar Paredes Basilio
16
Apuntes de Principios de Programación
completa o parcialmente «a posteriori»..
— Son compilativos, es decir, precisan de un proceso de compilación para poder ser
ejecutados.
— Son objetuales no procedimentales, es decir, se basan en los objetos y no en los
procedimientos (algoritmos). A diferencia de los lenguajes imperativos en los que se
trataba de encontrar un método (procedimiento o algoritmo) para resolver el problema,
aquí se trata de encontrar los objetos necesarios para modelizar el problema.
El concepto de objeto es muy similar al de Marco en Inteligencia Artificial, del cual
procede. Uno de los primeros lenguajes orientados a objetos fue Smalltalk. En la
actualidad está más difundido el lenguaje C++, adaptación del lenguaje C a los conceptos
de orientación a objetos.
¿CÓMO CONSTRUIR PROGRAMAS?
En la primera parte se vio una forma de cómo abordar un problema a través de la
computadora, en concreto el enfoque imperativo, y cómo construir un algoritmo que lo
resolviera. Siguiendo esta línea (enfoque imperativo) sólo queda construir el programa
que represente a ese algoritmo.
Supóngase ahora que el problema a resolver es el de calcular el área de una
circunferencia. Lo primero que se tiene que hacer es analizar el problema. Para ello,
como ya se vio, se debe responder a las tres preguntas siguientes:
¿Qué se quiere obtener?
¿Cómo se obtiene el resultado?
¿Qué datos se necesitan?
El área de la circunferencia
Multiplicando P por el cuadrado del radio
El radio de la circunferencia.
Debido a la forma de pensar del ser humano, se debe responder a estas tres preguntas
en el orden en que han sido escritas anteriormente. Sin embargo, el orden en la
computadora es distinto porque necesita primero los datos para luego procesarlos y, por
último, mostrar los resultados. El orden sería el siguiente:
1. Entrada de datos.
2. Proceso de datos.
3. Salida de resultados.
Por tanto, el algoritmo visto desde esta perspectiva es:
1. Pedir el valor del radio.
2. Multiplicar el valor del radio, elevado al cuadrado, por la constante p (área=
p*radio^2).
3. Escribir el valor del área.
Estas acciones, representadas en un formato más cercano a un lenguaje de
programación que al lenguaje humano, serían:
Elaboró Ing. Edgar Paredes Basilio
17
Apuntes de Principios de Programación
1º Pedir_valor( radio );
2º Area = PI * radio2;
3º Escribir_valor( Area );
La primera línea le indica a la computadora que tiene que pedir y recibir el valor del
radio. Este valor será almacenado en una variable llamada radio. Una variable es como
un pequeño cajón que coincide con una dirección de memoria donde se guardan
valores. De manera que radio es el nombre del cajón donde está guardado el valor del
radio. Por lo tanto, cuando se utilice la palabra radio se estará refiriendo al valor que
contiene el cajón con ese nombre.
La segunda línea indica la operación que hay que realizar con los datos: elevar al
cuadrado el valor de radio y multiplicarlo por el valor de la constante PI. Una constante
es otro tipo de cajón para guardar valores, pero que no varían nunca, por ejemplo, el
valor de PI.
Por último, la tercera línea indica a la computadora que muestre de alguna forma, ya
sea por la pantalla o por la impresora, el valor del área calculada.
Una visión más completa del programa, aunque no escrito con las reglas de ningún
lenguaje de programación, sería la siguiente:
Inicio
Variable radio, Area
Constante PI=3.14159
Pedir_valor( radio )
Area = PI x radio2
Escribir_valor( Area )
Final
Obsérvese las partes que componen el programa:
— Declaración de variables y constantes: en esta sección se le indican a la computadora
las variables y constantes que van a existir en el programa. En el ejemplo se han
declarado dos variables (radio y Area) y una sola constante (PI).
— Petición de datos: instrucciones que indican a la computadora que pida y reciba los
valores de los datos, que quedarán en cajones (variables) con sus nombres
correspondientes. En el ejemplo sólo se pide un dato, el radio.
— Proceso: instrucciones que indican a la computadora qué operaciones debe realizar
con los datos y qué nombre debe asociar al resultado. En el ejemplo, el resultado del
proceso queda asociado a la variable Area. Por tanto, en el cajón con el nombre Area se
queda el resultado de la operación PI * radio2. La instrucción que realiza el proceso de
datos es Area = PI * radio2. El signo = tiene aquí el sentido de guardar en la variable de
la izquierda del signo «=» el resultado de la derecha. A esto se le llama asignación.
— Escritura del resultado: instrucciones para mostrar el resultado. Por ejemplo,
Escribir_valor( Area).
Aunque no es objetivo en este momento profundizar en la forma de escribir el problema
Elaboró Ing. Edgar Paredes Basilio
18
Apuntes de Principios de Programación
del ejemplo en un lenguaje de programación, a continuación se muestra cómo quedaría
en un tipo de PASCAL y en C.
Lenguaje PASCAL:
PROGRAM
Const PI=3.14159;
Var radio, Area: INTEGER;
BEGIN
read ( radio );
Area := PI * ( radio ** 2);
write ( Area );
END.
Lenguaje C:
main ()
{
const float PI=3.14159;
int
radio, Area;
scanf (“%d”, &radio );
Area = PI * ( radio * radio);
printf (“%d\n”, Area );
}
Obsérvese que los dos programas tienen muchos puntos en común. Tienen un punto de
inicio (en PASCAL es PROGRAM y en C es main) y de fin (en PASCAL es END y en C
es el corchete }). También se dividen en las mismas tres partes (entrada, proceso y
salida de datos) e incluso el proceso se realiza con una instrucción casi igual (en
PASCAL es Area := PI * (radio ** 2) y en C es Area = PI * (radio * radio)).
Tienen algunas diferencias como, por ejemplo, la forma en que se eleva al cuadrado el
radio es distinta, también lo es la forma de las instrucciones de entrada y de salida de
datos. Pero la mayor diferencia reside en la dificultad de legibilidad, el programa en
PASCAL es más fácil de leer y entender que el de C.
Elaboró Ing. Edgar Paredes Basilio
19
Apuntes de Principios de Programación
ELEMENTOS DE PROGRAMAS
Las computadoras disponen de un repertorio de instrucciones, más o menos amplio,
capaces de realizar operaciones aritméticas, lógicas, de control, de entrada, de salida,
etc. Es preciso dar especificaciones que determinen las instrucciones que se deben de
ejecutar, así como la secuencia en que se aplicarán.
Esto es lo que constituye un programa, es decir, la información comunicada a la
computadora en forma de un conjunto de instrucciones con las que se le dice,
exactamente, lo que debe hacer y cómo debe hacerlo. Recordando siempre que esta
definición corresponde a la programación imperativa. A continuación, se van a describir
los elementos básicos que sirven para escribir programas.
Datos: definiciones y tipos
Si se quiere construir un programa de automatización de nóminas, se necesita
almacenar de alguna manera los nombres de los empleados, sus respectivos DNI´s, si
hicieron horas extras, etc. Todos estos datos han de ser guardados en la computadora
empleando alguna de las formas siguientes.
Caracteres
Un carácter es el elemento más pequeño utilizado en el tratamiento de la información.
Los caracteres pueden ser:
— Alfabéticos: (A, B, ... ,Z, a ,b , ... ,z).
— Numéricos: (0, 1, ... , 9).
— Especiales: (+, -, *, /, ., ;, <, >, ...).
En el ejemplo, el nombre de un empleado estará formado por una secuencia de
caracteres alfabéticos, su DNI por caracteres alfanuméricos (mezcla de caractereres
alfabéticos y numéricos), etc.
Dato
Un dato es un carácter o conjunto de caracteres que representa el valor que toma una
variable con la que opera la computadora.
Existen cuatro tipos de datos simples:
— Alfabéticos: están compuestos por caracteres alfabéticos y el carácter blanco.
Cuando se quiera escribir el nombre de un empleado. la ciudad donde reside, etc., se
emplearán caracteres alfabéticos, puesto que estos datos están formados únicamente
por letras.
Ejemplo:
«Luis Gutiérrez Beltrán»
«México»
Elaboró Ing. Edgar Paredes Basilio
20
Apuntes de Principios de Programación
— Numéricos: están compuestos sólo de caracteres numéricos, el punto decimal y el
signo.
Se emplearán datos numéricos para almacenar el sueldo base de un empleado, el
número de horas extras trabajadas, etc. Es decir, aquellos datos que sólo contengan
números.
Ejemplo:
3.650.000
25
— Alfanuméricos: están compuestos por una mezcla de los dos anteriores (alfabéticos
y numéricos).
Se emplearán cuando el dato a representar no pueda ser definido sólo con números o
con letras. Así, por ejemplo, si se quiere almacenar la dirección completa de un
empleado se necesitará un dato alfabético que corresponde al nombre de la calle y
también un dato numérico del número y piso donde vive la persona.
Ejemplo:
«Fuenterrabía, número 4-7.° Izquierda»
«Raimundo Fernández Villaverde, 115»
— Lógicos y booleanos: en algunos lenguajes de programación se admite también la
utilización de los llamados datos lógicos, cuya característica principal es que únicamente
pueden tomar dos valores: Cierto (True) o Falso (False).
Este tipo de datos se emplea, por ejemplo, cuando se quiere almacenar si un empleado
ha realizado horas extras, puesto que si es así se podrá almacenar como True, que sería
como decir o almacenar Sí, y en caso contrario False que equivale a No.
Constantes y variables
La Constante es un dato cuyo valor permanece inalterado durante la ejecución de un
programa. Se emplea para definir aquellos datos que siempre van a mantenerse
invariables. Por ejemplo, se podría definir como valor constante el valor de PI o el
número de meses que tiene un año.
Ejemplo:
La constante numérica Pi: 3.14
Número de meses de un año: «12»
La Variable es un dato cuyo valor puede ser modificado durante la ejecución del
programa. Una variable es una dirección de memoria y puede verse como una pequeña
caja donde se pueden guardar valores. Estos pueden ser de cualquiera de los tipos
vistos anteriormente (numéricos, alfabéticos, alfanuméricos, etc.). De esta manera, si se
tiene una variable de nombre Sueldo podrá almacenar cualquier valor para el sueldo.
Por tanto, Sueldo es el nombre de la caja donde está guardado el valor del sueldo y
cuando se utilice la palabra sueldo se estará refiriendo al valor que contiene la caja.
Cuando se hace mención a una variable, se está refiriendo a una pequeña zona de la
Elaboró Ing. Edgar Paredes Basilio
21
Apuntes de Principios de Programación
memoria principal (conjunto de posiciones contiguas) donde se va a alojar un valor. Si
este valor se modifica en algún momento del programa, el nuevo valor sustituirá al que
existía anteriormente.
Al conjunto de posiciones contiguas de memoria se le da un nombre para poder
identificarlo (nombre de la variable) y se define su tipo (clase de caracteres que puede
contener). A una variable definida de un determinado tipo, no se le pueden asignar
generalmente valores de otro tipo. Por ejemplo, la variable Sueldo que contiene números
no podría contener el nombre del empleado porque son letras.
El nombre que se le da a una variable lo elige el programador y estará formado por
letras de la A a la Z, números del 0 al 9 y el carácter «-» y no se podrán intercalar
espacios en él.
Dado que en cada programa se utiliza un gran número de variables, es muy importante
que el nombre que se asigne a cada una de ellas recuerde la naturaleza de la
información que va a contener, es decir, sea lo más nemotécnico posible. Por ejemplo, si
una variable va a guardar el total de horas extras trabajadas, se le podría llamar
HorasExtras, o TotalExtras.
Hay que diferenciar claramente entre lo que es el nombre de la variable y su contenido:
el nombre de una variable es un identificativo que se le da a un conjunto de posiciones
contiguas de memoria (es el nombre que se le da a la caja), mientras que el contenido
de una variable es el valor que está almacenado en dichas posiciones (es el contenido
de la caja).
La memoria principal de la computadora se puede comparar, en cierto modo, con los
cajetines de correos que existen en las casas de vecinos. El conjunto de casilleros sería
la memoria principal y cada variable se podría asociar a un casillero. Cuando el cartero
reparte la correspondencia, localiza a cada vecino por el nombre que aparece en cada
cajetín (nombre de la variable) e introduce una carta en él (contenido de la variable).
EJEMPLO:
Supóngase que se tienen tres variables distintas, con los siguientes valores:
TotalSueldo = 0
SueldoBase = 2.000.000
HorasExtras = 300.000
Si se quiere calcular el sueldo de un empleado, se deben sumar los valores de las
variables SueldoBase y HorasExtras y asignar el resultado a la variable TotalSueldo.
TotalSueldo = SueldoBase + HorasExtras.
El estado final de las variables es el siguiente:
TotalSueldo = 2.300.000
SueldoBase = 2.000.000
HorasExtras = 300.000
Como se ve, el valor de TotalSueldo ha variado, puesto que ahora tiene el valor de la
Elaboró Ing. Edgar Paredes Basilio
22
Apuntes de Principios de Programación
suma de las otras dos variables. La única variable que modifica su valor es TotalSueldo,
quedando el valor del resto de las variables inalterado.
Operadores
Para poder realizar operaciones matemáticas, lógicas, etc., con las variables, se
necesita usar los operadores. Principalmente, se utilizan de tres tipos: Aritméticos,
Relacionales y Lógicos.
— Aritméticos: son utilizados para representar operaciones de tipo matemático.
+
*
/
**
Suma
Resta
Multiplicación
División
Potenciación
Cuando se quiera obtener el número de horas extras trabajadas se tendrá que
multiplicar las HorasExtras por el PrecioHora, esto se representa como HorasExtras *
PrecioHora.
La notación no es común a todos los lenguajes de programación, sino que cada uno de
ellos escribe algunos operadores de distinta manera.
— Relacionales: sirven para representar condiciones de comparación entre valores, ya
sean numéricos o alfabéticos.
=
<
<=
>
>=
<>
Igual a
Menor que
Menor o igual que
Mayor que
Mayor o igual que
Distinto de
En el problema pueden ser útiles cuando se quiere expresar, por ejemplo, que a partir
de un determinado SueldoBase, la retención es de un tanto por ciento determinado. Por
ejemplo, cuando el SueldoBase > 2.000.000.
En algunos lenguajes el operador «=» se usa no como operador relacional sino como
operador que asigna un valor a una variable. Por ejemplo, el lenguaje C. De esta forma,
la expresión SueldoBase = 2.000.000 no compara el contenido de la variable
SueldoBase con 2.000.000 sino que asigna ese valor a la variable SueldoBase. El
operador «Igual a» en C es «= =». Si se quisiera realizar esta comparación se debería
escribir la expresión SueldoBase = = 2.000.000.
— Lógicos: se emplean para expresar la lógica de condiciones, que existen en un
problema de cualquier tipo.
Elaboró Ing. Edgar Paredes Basilio
23
Apuntes de Principios de Programación
NOT
AND
OR
-
NO
Y
O
EJEMPLO:
Se podría tener una regla que dijera: si el Sueldo Base no es mayor que 2.000.000 y
además el número de horas que el empleado trabajó no es superior a 100, entonces la
retención fiscal será del 23 %. Para que esta regla se pueda modelizar se ha de recurrir
a los operadores lógicos:
Si ( ( Sueldo Base < 2.000.000) AND ( NOT ( Horas Extras > 100))
Una expresión es una combinación de constantes, variables, operadores y paréntesis.
En una expresión, los operadores se evalúan según el siguiente orden de prioridad:
1. Paréntesis. Si hay paréntesis anidados se procede primero con los más internos.
2. Potenciación.
3. Producto y división.
4. Suma y resta.
5. Operadores Relacionales.
6. Operadores Lógicos.
Aquellos operadores que tienen el mismo orden de prioridad se evalúan de izquierda a
derecha. Ahora bien, la prioridad de los operadores lógicos puede variar de unos
lenguajes de programación a otros.
Evaluación de una expresión en la que se tiene todo tipo de operadores.
EJEMPLO:
Evaluación de una expresión en la que se tiene todo tipo de operadores.
(3*3)>
9>
9>
9>
9>
CIERTO
CIERTO
CIERTO
8
8
8
8
8
AND
AND
AND
AND
AND
AND
AND
AND
(6-1)
(6-1)
5
5
10
10
*2
*2
*2
*2
FALSO
FALSO
FALSO
<8
<8
<8
<8
<8
<8
OR
OR
OR
OR
OR
OR
OR
OR
OR
2**3
2**3
2**3
8
8
8
8
=
=
=
=
=
=
=
8
8
8
8
8
8
8
CIERTO
CIERTO
CIERTO
El resultado final de la evaluación de esta expresión es que es cierta.
Elaboró Ing. Edgar Paredes Basilio
24
Apuntes de Principios de Programación
Instrucciones
Como ya se enunció anteriormente, un algoritmo es un conjunto de acciones que han de
ejecutarse para la resolución de un problema.
A cada una de estas acciones se le denomina Instrucción o Sentencia.
Un programa es el mismo conjunto de instrucciones escritas en un lenguaje de
programación.
Las instrucciones se dividen en los cuatro grupos siguientes:
1. De Asignación.
2. De Entrada y Salida.
3. Condicionales.
4. Repetitivas.
Instrucciones de Asignación
Se utilizan para asignar un valor a una variable. Si la variable tenía previamente otro
valor, éste será sustituido por el nuevo.
Se puede representar una asignación mediante el signo «=», asignando a la variable
situada a la izquierda del signo lo que hay a la derecha del mismo.
Por ejemplo: B = 10 asigna a la variable B el valor 10.
La asignación de un valor se puede realizar mediante:
a) Una constante: por ejemplo, asignar el valor 2500000 a la variable Sueldo-Base.
Sueldo-Base = 2500000
A partir de ese momento, la variable Sueldo-Base tendrá un valor de 2500000.
b) El contenido de otra variable: por ejemplo, asignar el valor que contenga la variable
Total-Sumas a la variable Sueldo, suponiendo la variable Total-Sumas con un valor
inicial de 3575000 y la variable Sueldo con un valor inicial nulo. Sueldo = Total-Sumas
Después de la asignación, el valor de Sueldo será igual que el de Total-Sumas,
3575000.
c) El resultado de evaluar una expresión: por ejemplo, asignar a Total-Sueldo el
resultado de la expresión: Base + Horas-Extras * Precio-Hora.
Total-Sueldo = Base + Horas-Extras * Precio-Hora.
De esta forma, en la variable Total-Sueldo quedará guardado el valor del resultado de la
evaluación de esa expresión. Aunque matemáticamente la expresión, A + 3 = B - 5
sea totalmente correcta, en informática nunca puede aparecer una expresión a la
izquierda del signo « = ». En este lugar sólo debe ir una variable que sea la receptora del
resultado de evaluar la expresión situada a la derecha del signo.
Elaboró Ing. Edgar Paredes Basilio
25
Apuntes de Principios de Programación
Por el contrario, con la expresión:
Sueldo = Sueldo + 150000
desde el punto de vista matemático, se está cometiendo un error ya que ningún número
es igual a el mismo más 150000. Sin embargo, en informática, con tal expresión lo que
se quiere indicar es:
— Realizar la operación situada a la derecha del signo «=», sumando 150000 al
contenido que ya tenía Sueldo.
— Dejar el resultado de nuevo en la variable Sueldo, situada a la izquierda del signo
«=».
Instrucciones de Entrada y de Salida
Una instrucción de entrada implica la introducción de datos en la memoria principal de la
computadora desde dispositivos externos a la misma, por ejemplo, el teclado, un
disquete, disco duro, etc.
En la memoria principal sólo pueden guardarse valores mediante su almacenamiento a
través de variables. Por eso, cualquier operación de entrada lleva consigo la asignación
del valor introducido a una variable a la que poder referirse cuando se necesite.
Así, por ejemplo, si se tuviese el programa de gestión de nóminas, se tendrían que
introducir los datos necesarios para el proceso (Sueldo-Base, Dirección, ...), pues bien,
estos valores deberán ser leídos del teclado y almacenados en las variables (memoria
principal) designadas para tal efecto.
Las instrucciones de salida permiten la presentación de datos desde la memoria central
de la computadora hacia dispositivos externos de salida; por ejemplo, impresora,
pantalla, disquete, disco duro, etc.
Cuando se quieran imprimir las nóminas se deberán leer los valores de las variables que
contengan los datos y enviarlos a los dispositivos de salida, ya sea impresora o pantalla,
mediante instrucciones de salida.
Instrucciones Condicionales
El modo en que una computadora ejecuta las instrucciones contenidas en un programa
es, normalmente, secuencial, es decir, una detrás de otra en el orden en que están
escritas.
Con el fin de poder dotar a los programas de capacidad de decisión sobre los
tratamientos que debe aplicar a cada caso, los lenguajes de programación permiten la
definición de instrucciones de control distintas a la secuencial. Este es el caso de las
Instrucciones condicionales.
Una instrucción condicional es aquella que, bajo la comprobación de veracidad o
falsedad de una condición, ejecuta uno de dos grupos de acciones posibles.
Elaboró Ing. Edgar Paredes Basilio
26
Apuntes de Principios de Programación
En los siguientes apartados se verán los distintos tipos de instrucciones condicionales
existentes.
Instrucciones Repetitivas
Hay ocasiones en que un grupo de instrucciones simples debe repetirse un número
determinado de veces, dependiendo del cumplimiento, o no, de una condición.
En estos casos, se utiliza una instrucción, llamada repetitiva, que controla la ejecución
de este grupo de instrucciones mientras una condición sea cierta.
En el algoritmo que se diseñó inicialmente sobre el problema de las nóminas se tenía una
estructura repetitiva para controlar que se repetirían todas las operaciones de cálculo
(conjunto de instrucciones a repetir) hasta que no quedara ningún empleado (condición
de finalización).
ESTRUCTURAS BASICAS DE CONTROL
El pseudocódigo es una herramienta muy útil utilizada en el diseño de algoritmos para
resolver problemas que, si emplea los principios de la programación estructurada,
permite expresar el flujo de ejecución de las instrucciones de una forma clara, sin
ambigüedad y usando un lenguaje natural.
El pseudocódigo es una forma de describir la solución a un problema de manera que
su traducción posterior a un lenguaje de programación de alto nivel sea sencilla. Trata
de definir la solución del problema en un lenguaje intermedio entre el humano y el de
programación.
Reglas generales del pseudocódigo
No hay una forma estándar de diseñar un pseudocódigo, depende en gran medida del
criterio del programador. A pesar de ello, es aconsejable respetar lo más rigurosamente
posible las siguientes normas de carácter general:
— Todo pseudocódigo comienza con la palabra «Inicio» y termina con la palabra «Fin».
— Cada instrucción se debe escribir en una línea.
— Para su descripción, se utilizan una serie de palabras reservadas: Inicio, fin, si,
entonces, si no, fin-si, mientras, etc.
— Debe escribirse «identado» (tabulado) para mostrar claramente las dependencias de
control dentro de los módulos.
— Cada estructura utilizada tendrá un solo punto de comienzo y un solo punto de fin de
estructura. Algunos autores suelen utilizar un corchete para unir el principio y fin de cada
estructura.
Elaboró Ing. Edgar Paredes Basilio
27
Apuntes de Principios de Programación
— Se escribirá en minúscula, excepto aquellos nombres que elige el programador, como
son los nombres de variables, de ficheros, de módulos, etc., que se escribirán con
mayúsculas.
A continuación se verá en pseudocódigo las tres estructuras básicas de control en las que
se apoya la programación estructurada. No obstante, una descripción detallada de esta
modalidad de programación se verá más adelante.
Estructura secuencial
Se compone de un grupo de acciones que se realizan todas y en el orden en que están
escritas, sin posibilidad de omitir ninguna de ellas.
pseudocódigo
...
Acción_l
Acción-2
...
Acción-n
...
EJEMPLO:
Calcular la suma y el producto de dos números.
La solución es sencilla, lo primero que se tiene que hacer es introducir los números A y
B, después sumarlos, luego multiplicarlos y, por último, presentar los resultados al
usuario en pantalla. Estas acciones se deben ejecutar en ese orden y secuencialmente,
la estructura secuencial expresa perfectamente la solución al problema.
El pseudocódigo siguiendo las reglas descritas anteriormente sería:
Inicio
Introducir A y B
SUMA = A + B
PRODUCTO = A * B
Mostrar SUMA, PRODUCTO
Fin
Después de haber escrito el pseudocódigo se tiene una idea clara de los pasos que
deben seguirse para construir el programa, pero aún tendría que ser codificado en un
lenguaje. Cuanto más detallado sea el pseudocódigo, más sencillo será este proceso.
Estructura condicional
Es la que realiza un conjunto de instrucciones de entre varios posibles, dependiendo del
cumplimiento, o no, de una determinada condición.
Existen tres tipos de estructuras condicionales:
Elaboró Ing. Edgar Paredes Basilio
28
Apuntes de Principios de Programación
— Estructura condicional simple.
— Estructura condicional doble.
— Estructura condicional múltiple.
Estructura Condicional Simple
Aquí se evalúa la condición y, sólo si es cierta, se ejecuta el conjunto de acciones
correspondiente. El no cumplimiento de la condición implica que no se realizará ninguna
de las acciones indicadas.
El pseudocódigo de esta estructura es el siguiente:
...
Si Condición
Entonces
Acción_l
Acción-2
...
Acción-n
Fin_si
...
EJEMPLO:
El problema a resolver es el de introducir un número, que se denominará NUM, por
teclado y, si es mayor de 20, mostrarlo por pantalla.
Inicio
Introducir NUM
Si NUM > 20
Entonces
Mostrar NUM
Fin_si
Fin
En esta ocasión se tiene que si, y sólo si, el valor NUM es mayor de 15, se debe mostrar
el valor NUM; si no se cumple la condición no se mostrará el valor de NUM.
Obsérvese que las instrucciones están tabuladas unos espacios hacia la derecha
respecto a las palabras «Si» y «Fin-si». Esto tiene por función realzar cuáles son las
instrucciones que pertenecen a la estructura. Esta norma de «identación» será para
todas las estructuras condicionales y repetitivas.
Estructura Condicional Doble
En este tipo de estructura se ejecutará un bloque de instrucciones u otro, dependiendo
de la certeza o falsedad de una condición.
El pseudocódigo de esta estructura es como sigue:
Elaboró Ing. Edgar Paredes Basilio
29
Apuntes de Principios de Programación
...
Si Condición
Entonces
Acción_l
Acción-2
...
Acción-n
Si no
Acción_A
Acción-B
...
Acción-Z
Fin_si
...
EJEMPLO:
Decidir cuál de dos valores es el mayor
IInicio
Introducir A y B
Si A > B
Entonces
Mostrar «El mayor es» A
Si no
Mostrar «El mayor es» B
Fin_si
Fin
El problema es sencillo puesto que, dependiendo de la condición A > B, se ejecutará una
instrucción u otra.
La instrucción Mostrar escribiría en la pantalla el texto entrecomillado y a continuación
mostraría el valor de A o B según sea el caso.
Estructura condicional múltiple
En este caso, dependiendo del valor que tome la variable numérica que controla la
condición que vaya a evaluarse, se ejecutará una de las n acciones correspondientes.
El pseudocódigo de esta estructura es el siguiente:
...
Según Número
=1 Acción_l
=2 Acción-2
...
=n Acción-n
Fin_según
...
Elaboró Ing. Edgar Paredes Basilio
30
Apuntes de Principios de Programación
EJEMPLO:
Introducir por teclado un valor numérico, denominado NUM_CARTA, asociado a una
carta (01-12), y mostrar el nombre de la carta asociado a ese número.
Inicio
Introducir NUM_MES
Según NUM_MES Hacer
=1 Mostrar «As»
=2 Mostrar «Dos»
...
=12 Mostrar «Rey»
Fin_según
Fin
En primer lugar, se lee el número de la carta y, a continuación, gracias a la estructura
condicional múltiple, se entra en la instrucción que muestra el nombre de la carta.
Dependiendo del valor de la variable num_carta se mostrará el nombre de la carta.
Estructura repetitiva
Permite la repetición de un bloque de instrucciones dependiendo de la veracidad o
falsedad de una condición. La condición se conoce como Condición de Salida y a estas
estructuras se las denomina también Bucles.
Las estructuras repetitivas pueden ser:
— Estructura tipo Mientras.
— Estructura tipo Hasta.
— Estructura tipo Para.
Estructura tipo mientras
El bloque de acciones se repetirá mientras que la condición sea cierta. La condición se
evalúa al comienzo de la estructura. Esto implica que el bloque de instrucciones puede
no ejecutarse ninguna vez si la condición de salida es inicialmente falsa.
El pseudocódigo de esta estructura es de la siguiente forma:
...
Mientras Condición
Acción_l
Acción-2
...
Acción-n
Fin_mientras
...
EJEMPLO:
Una empresa tiene grabados los datos personales de sus empleados. Se desea imprimir
el nombre de los empleados mayores de 55 años.
Elaboró Ing. Edgar Paredes Basilio
31
Apuntes de Principios de Programación
Inicio
Leer Empleado
Mientras Hay_Empleados
Si Empleado_Edad > 55
Entonces
Mostrar Empleado
Fin_si
Leer Empleado
Fin_mientras
Fin
En primer lugar, se leen los datos de un empleado, a continuación se evalúa la condición
de salida (Hay_Empleados) y se comprueba, con una estructura condicional simple, si la
edad del empleado es mayor de 55 años; si lo es, se muestra el nombre del empleado.
Después se vuelve a leer otro empleado y se retorna a la evaluación de la condición de
salida del bucle, cuya finalización vendrá cuando no existan más empleados.
NOTA: Obsérvese que si en la primera lectura no hay empleados, el bucle Mientras no
se realizará nunca, ya que se comprueba la condición al principio de la estructura
Mientras y, sólo si es cierta, se entra en ella.
Estructura tipo hasta
El bloque de acciones se repetirá hasta que la condición sea cierta.
Dicha condición se evalúa al final de la estructura. Esto implica que el bloque de
instrucciones se ejecutará al menos una vez, aunque la condición de salida ya sea cierta
al entrar en dicha estructura.
La diferencia fundamental entre ambas estructuras repetitivas es que, en el primer tipo,
las acciones del bucle puede que no se realicen nunca si la condición de salida del
mismo es inicialmente cierta. Por el contrario, las acciones del bucle, en el segundo tipo,
se realizarán, al menos una vez, ya que la condición se evalúa después de haber sido
realizadas dichas acciones.
El pseudocódigo para esta estructura es:
...
Repetición
Acción_l
Acción_2
...
Acción_n
Hasta Fin_repetición
...
EJEMPLO:
Visualizar la tabla de multiplicar del número 3
Elaboró Ing. Edgar Paredes Basilio
32
Apuntes de Principios de Programación
Inicio
CONT = 0
Repetir
CONT = CONT + 1
PROD = CONT * 3
Mostrar PROD
Hasta CONT = 10
Fin
Para resolver este problema se necesitan dos variables: CONT que es un contador que
almacenará cuantos números se han visualizado, de ahí que sea la variable que controle
el bucle (condición de salida), y PROD que almacena el valor del número a mostrar y
que corresponde a los números de la tabla.
Estructura tipo para
Si el número de iteraciones (repeticiones) es fijo o se conoce de antemano, se puede
utilizar una estructura tipo Para o Desde en lugar de utilizar una estructura tipo Mientras.
La estructura Para ejecuta las acciones del bucle un número específico de veces y
controla automáticamente el número de repeticiones.
Para dicho control, hay que definir dentro de la estructura el nombre de una variable
numérica, su valor inicial, su valor final y un incremento fijo. Es la propia estructura la
que se encarga de inicializar la variable con el valor indicado, incrementarla en cada
iteración y, cuando sobrepasa el valor final especificado, termina la repetición del bucle.
La evaluación de la condición de salida se hace al comienzo de cada iteración.
El pseudocódigo es como sigue:
...
Para VAR desde V1 hasta V2
incremento V3
Acción_l
Acción-2
...
Acción-n
Fin_para
...
La diferencia fundamental entre los dos tipos de estructuras radica en que en la
estructura Mientras hay que realizar, mediante instrucciones, la inicialización de la
variable que controle el bucle, así como su incremento; y en la estructura Para esto se
hace automáticamente.
EJEMPLO:
Construir un programa en pseudocódigo que calcule y muestre la suma de los números
comprendidos entre 1 y 100, ambos inclusive.
Elaboró Ing. Edgar Paredes Basilio
33
Apuntes de Principios de Programación
Inicio
SUMA = 0
Para NUM desde 1 hasta 100
SUMA = SUMA + NUM
Fin_para
Mostrar SUMA
Fin
Se necesita utilizar dos variables: SUMA en donde se va a calcular la suma de los 100
primeros números, y NUM que es la variable que controla el bucle. Empieza en 1 y llega
hasta 100. Cuando NUM sobrepase el valor 100, indicará que ya se han sumado todos
los números, con lo que el bucle de tipo Para terminará y en SUMA se tendrá el valor
buscado.
Elaboró Ing. Edgar Paredes Basilio
34
Apuntes de Principios de Programación
LA PROGRAMACIÓN
ARBORESCENTE
ESTRUCTURADA
EN
LA
REPRESENTACION
Existen muchas formas de representar las tres estructuras de control ( secuencial,
condicional y repetitiva) de la Programación Estructurada. Una de ellas es el
pseudocódigo que ya se ha descrito anteriormente.
Otra de ellas, que se va a comentar ahora, es utilizando gráficamente representaciones
en forma de árbol para cada una de las modalidades, o variantes, de cada estructura de
control. Este tipo de representación se debe a Y. Tabourier y A. Rotchfield que lo
desarrollaron en el año 1975.
Estructura Secuencial
Se representa gráficamente utilizando varios tratamientos f1, f2,...,fn en secuencia
como se indica en la figura.
Y se representa en forma arborescente con la palabra BLOCK, de la que cuelgan los
tratamientos f1, f2,...,fn como se muestra en la figura.
El ejemplo comentado durante la explicación del pseudocódigo, que calculaba la suma y
el producto de dos números, quedaría como se indica en la figura.
Elaboró Ing. Edgar Paredes Basilio
35
Apuntes de Principios de Programación
Estructura Condicional
Admite tres variantes la «Estructura Condicional Simple», la «Estructura Condicional
Doble» y la «Estructura Condicional Múltiple».
Estructura Condicional Simple
Se representa gráficamente utilizando un predicado p (que es la condición); un
tratamiento f (que se ejecuta si la condición p es cierta) y un reagrupamiento, tal y como
se presenta en la figura.
Y se representa en forma arborescente con la palabra IFTHEN, de la que cuelgan el
predicado p y el tratamiento f que se ve en la figura.
Elaboró Ing. Edgar Paredes Basilio
36
Apuntes de Principios de Programación
El ejemplo en pseudocódigo que leía un número NUM y si era mayor que 20 lo mostraba
por pantalla se representa en la figura.
Estructura Condicional Doble
Se representa gráficamente utilizando un predicado p (que es la condición); dos
tratamientos: f (si la condición es cierta) y g (si la condición es falsa), y un
reagrupamiento como lo muestra la figura.
Elaboró Ing. Edgar Paredes Basilio
37
Apuntes de Principios de Programación
Y se representa en forma arborescente, con la palabra IFTHENELSE de la que cuelgan
p, f y g, como se ve en la figura.
El ejemplo, comentado en pseudocódigo, que calcula el mayor de dos valores, quedaría
como se representa en la figura.
Estructura Condicional Múltiple
Esta estructura es una generalización de la Doble. Se representa con un predicado p
(condición); varios tratamientos f1, f2,...,fn (donde se ejecutaría aquel que cumple la
condición), y un reagrupamiento. La figura presenta esta estructura.
Elaboró Ing. Edgar Paredes Basilio
38
Apuntes de Principios de Programación
Y se representa en forma arborescente con la palabra CASEOF, de la que cuelgan el
predicado p y los tratamientos f1, f2,...,fn, como lo muestra la figura.
El ejemplo de introducir por teclado un valor numérico, denominado NUM_CARTA,
asociado a una carta (01 12), y mostrar el nombre de la carta asociado a ese número
viene representado en la figura.
Estructura Repetitiva
Admite tres variantes «Mientras», «Hasta», y «Para».
Estructura Tipo Mientras
Se representa con un predicado p (condición), que mientras sea cierto ejecuta un
tratamiento f. La figura, muestra esta estructura.
Elaboró Ing. Edgar Paredes Basilio
39
Apuntes de Principios de Programación
Y su representación arborescente es con la palabra DOWHILE, de la que cuelgan el
predicado p, y el tratamiento f, como se muestra en la figura.
El ejemplo de mostrar el nombre de los empleados de una empresa mayores de 55 años
se representaría como se indica en la figura.
Elaboró Ing. Edgar Paredes Basilio
40
Apuntes de Principios de Programación
Estructura Tipo Hasta
Esta estructura se representa con un tratamiento f, que se ejecuta ininterrumpidamente
hasta que un predicado p (condición) sea cierto, tal y como se ve en la figura.
Se representa en forma de árbol con la palabra DOUNTIL de la que cuelga el
tratamiento f, y el predicado p. La siguiente figura muestra dicha estructura.
El diagrama arborescente del programa que muestra por pantalla la tabla de multiplicar
del número 3 se describe en la figura.
Elaboró Ing. Edgar Paredes Basilio
41
Apuntes de Principios de Programación
Estructura Tipo Para
Se representa mediante un tratamiento f, que se repite, y una variable de control Vc que
varía desde un valor inicial Vi hasta un valor final Vf, incrementado en cada bucle con un
valor k, como se presenta en la figura.
Y su representación arbóreamente se realiza con la palabra DOFOR de la que cuelgan
la variable de control (Vc), con su valor inicial (Vi), incremento (k), y su valor final (Vf); y
el tratamiento f. La figura presenta esta estructura.
El programa que obtiene y muestra la suma de los números comprendidos entre 1 y 100
se describe en la siguiente figura.
Como conclusión de este tipo de representación, se va a describir el programa que
Elaboró Ing. Edgar Paredes Basilio
42
Apuntes de Principios de Programación
calcula y muestra los números menor y mayor de todos los leídos, y los números que
son primos.
Interesa señalar que esta representación obliga a un proceso de descomposición del
problema en subproblemas, que se etiquetan con un nombre, hasta que se llega al final
del árbol con todo el problema resuelto. Las figuras muestran esto.
Elaboró Ing. Edgar Paredes Basilio
43
Apuntes de Principios de Programación
Elaboró Ing. Edgar Paredes Basilio
44
Apuntes de Principios de Programación
Las figuras no necesitan ya mucha explicación, simplemente señalar que los árboles se
leen de arriba a abajo y de izquierda a derecha. Así, el árbol del módulo 1 de la figura
3.32 se leería: «Primero, leer un número (NUM); a continuación, realizar el proceso
repetitivo DOWHILE hasta que no haya números que leer, y, finalmente, llamar al
módulo 2 con NUM= -1 para que muestre el valor menor y el mayor de todos los leídos.
El proceso DOWHILE señala que hay que realizar dos acciones: una es preguntar si
NUM_0 y en caso afirmativo efectuar las acciones de llamar a los módulos 2 y 3
respectivamente, y en caso negativo mostrar NUM y el literal «no es un entero positivo»:
la otra es volver a leer otro número NUM.
Es evidente, que la representación arborescente ocupa más papel que el pseudocódigo,
pero tiene la ventaja de que, al ser gráfica, se sigue mejor, y que para modificar el
diagrama simplemente basta con colgar la información nueva de una de las ramas sin
estropear todo lo demás, cosa que es imposible con el pseudocódigo.
Elaboró Ing. Edgar Paredes Basilio
45
Apuntes de Principios de Programación
LA REPRESENTACIÓN ESTRUCTURADA UTILIZANDO DIAGRAMAS N-S DE
CHAPIN
Este método estructurado fue desarrollado en 1973 por Nassi y Schneiderman y
perfeccionado en 1974 por Ned Chapín.
Realmente, al igual que el arborescente, lo que se plantea es una nueva forma de
representar las estructuras de control (secuencial, condicional y repetitiva) utilizando para
ello lo que ellos denominan «organigramas N-S o diagramas de Chapín», que se van a
ver a continuación.
Estructura Secuencial
Se representa, tal y como se muestra en la figura, mediante un rectángulo que incorpora
dentro de él sentencias de asignación, de entrada/salida, la llamada a otro módulo
(función o procedimiento),… En este último caso, se coloca una elipse dentro del
rectángulo con el nombre del módulo llamado.
El ejemplo que calcula la suma y el producto de dos números se representaría como se
indica en la figura.
Elaboró Ing. Edgar Paredes Basilio
46
Apuntes de Principios de Programación
Estructura Condicional
Las tres variantes: «Estructura Condicional Simple», «Estructura Condicional Doble» y
«Estructura Condicional Múltiple» se representarían en este método como sigue:
Estructura Condicional Simple
Se utiliza, como se ve en la figura, un rectángulo dividido en tres triángulos: uno para la
condición (p), otro para cierto (C) y un tercero para falso (F); y en dos rectángulos: uno
para el tratamiento de cierto (f) y otro sombreado (que no hace nada) para cuando la
condición es falsa.
La figura señala que se lea un número NUM y si es mayor que 20 que se muestre en
pantalla.
Elaboró Ing. Edgar Paredes Basilio
47
Apuntes de Principios de Programación
Estructura Condicional Doble
Es muy semejante a la anterior. Se representa, como se muestra en la figura con un
rectángulo dividido en tres triángulos: condición (p), cierto (C) y falso (F); y en dos
rectángulos: uno para el tratamiento de cierto (f) y otro para el tratamiento de falso (g).
La figura describe el programa que lee dos números y muestra el mayor.
El diagrama de la figura indica al ejecutarse los rectángulos 1, 2, 3, 4, 5, 6 y 7 que:
1: A y B son > 0
2: A y C son > 0, pero B no.
3: A es >0, pero B y C no.
4: A no es > 0.
5: A no es > 0, pero D y E si.
6: A no es > 0, pero D si.
7: A y D no son > 0.
Elaboró Ing. Edgar Paredes Basilio
48
Apuntes de Principios de Programación
Estructura Condicional Múltiple
Se utiliza, tal y como se muestra en la figura, un rectángulo dividido en varios triángulos
[uno para la condición (p), y los otros 1, 2,… para las diferentes alternativas] y en varios
rectángulos (cada uno es un tratamiento para cada una de las alternativas).
El problema de mostrar una carta se representaría como se indica en la figura.
Estructura Repetitiva
Las tres variantes «Mientras», «Hasta» y «Para» tienen una representación muy similar.
Consisten en un rectángulo dentro del cual hay otro rectángulo en el que se incorporan
las instrucciones del tratamiento repetitivo (f) y fuera del rectángulo inferior está el
predicado (p).
Elaboró Ing. Edgar Paredes Basilio
49
Apuntes de Principios de Programación
Estructura Tipo Mientras
En la figura se describe el programa que muestra el nombre de los empleados de una
empresa mayores de 55 años.
Estructura Tipo Hasta
Elaboró Ing. Edgar Paredes Basilio
50
Apuntes de Principios de Programación
El programa que describe la tabla de multiplicar por 3 se presenta en la figura.
Estructura Tipo Para
La figura describe el programa que obtiene y muestra la suma de los números
comprendidos entre 1 y 100.
Se va a finalizar este modelo de representación estructurada describiendo, en las figuras
siguientes el programa que calcula y muestra los números primos y el menor y mayor de
todos los números leídos. Se ve que los módulos se representan por un único rectángulo
y cuelgan de una elipse que incorpora el nombre de cada módulo.
Elaboró Ing. Edgar Paredes Basilio
51
Apuntes de Principios de Programación
Elaboró Ing. Edgar Paredes Basilio
52
Apuntes de Principios de Programación
La construcción de un programa utilizando este tipo de diagramas ayuda a ver
claramente la estructura y enlace entre los módulos. Además, como no es fácil introducir
más de 20 símbolos en una página (y no existen conectores de página), se consigue con
ello diseñar módulos cortos (que es uno de los objetivos de la programación
estructurada) por lo que si el programa es grande, con este tipo de representación se
facilita separar una parte del programa para que sea un subprograma; es decir, un
módulo.
Presenta la ventaja, con respecto a la representación arborescente, de que es más
compacta y permite ver de un vistazo todo el programa, pero tiene el inconveniente de
que es muy difícil modificar su contenido, en el sentido, de insertar un conjunto de
diagramas nuevos que modifiquen el anterior.
Elaboró Ing. Edgar Paredes Basilio
53