1.

Programación Estructurada

1.1 Definición de Algoritmo

Para la mayoría de las personas que han tenido contacto con una computadora, la
conciben como una herramienta que permite lograr cosas tan fascinantes como vuelos
espaciales, control sobre plantas nucleares, diagnósticos médicos, diseños, accesos
eficientes a grandes bancos de información remotos, simulación de generaciones de virus
y en algunos casos hasta entretenimiento y diversión.

Las computadoras digitales aun las más modernas y complejas, pueden ser vistas como un
gran conjunto de piezas. De una manera simple cada una de estas piezas representa
información en forma de conjuntos de bits, cada bit (dígito binario) puede estar en una de
dos posiciones o dicho de otra manera puede tener cualquiera de dos valores 0 ó 1.
Cualquier computadora tiene un conjunto muy reducido de operaciones triviales que puede
realizar, como son: corrimientos, comparaciones, sumas, etc., pero entonces, ¿cuál es la
distancia entre las operaciones triviales con bits y las increíbles hazañas que realizan las
computadoras?

La respuesta a la pregunta anterior es el proceso y el algoritmo que lo controla y provoca

para que tenga lugar. Para definir estos dos conceptos hagamos una analogía del arte de
la programación con el arte de la cocina.

Suponga que una persona desea comer su pastel favorito. Para solucionar este problema,
conviene dividirlo en pequeños subproblemas entre los que podrían encuentrarse:
conseguir la receta, obtener los ingredientes, elaborar el pastel, obtener compañía y
comerlo. Dependiendo del tamaño de cada uno de estos ‘pequeños subproblemas’ se
requerirá o no dividirlo en más subproblemas. Por ejemplo, conseguir la receta podría ser
resuelto de una manera simple si ésta se encuentra accesible en un librero al cual se tiene
acceso fácilmente, pero podría suceder que es una receta secreta y para conseguirla se
tiene que hacer un largo viaje a tierras extrañas, entrar a un castillo encantado, y
convencer a una bruja que la entregue.

Considere a la cocina (o a una computadora), que por si sola no puede realizar pasteles (ni
lograr cosas tan fascinantes como las que se mencionaron). Se puede observar también
que este 'hardware' (i.e., la cocina) tiene un conjunto muy limitado de 'operaciones' como
son batir, abrir la puerta del horno, medir tiempo y cantidades, que directamente tampoco
pueden hacer pasteles.

Como se sabe el proceso de cocinar pasteles (salida) es algo más complejo que se realiza
de ingredientes (entradas del proceso), de acuerdo a una receta (algoritmo), con ayuda de
utensilios, horno, cocinero, etc., (hardware).
 fig.1 Proceso y algoritmo para crear un pastel

De esta forma puede considerarse a las recetas como objetos mágicos que sirven para
convertir los ingredientes en pasteles con ayuda de las habilidades del hardware de la
cocina.

Las instrucciones elementales de una receta deben ser realizadas a la medida de las
capacidades del hardware y también deben ser apropiadas para el nivel de comprensión
del lector potencial o usuario del algoritmo. Estas acciones básicas deben ser precisas, no
ambiguas y tomar una cantidad acotada de tiempo.

Debido a las dos primeras características anteriores una receta de cocina no es un

algoritmo computacionalmente hablando.

Un algoritmo se define como un conjunto finito de reglas que producen una

secuencia de operaciones para resolver un tipo específico de problemas con las
siguientes cinco características principales: finito, preciso, eficaz, cero o más
entradas y una o más salidas.

2
Consideraciones acerca de los algoritmos:

1. ¿Es correcto?
2. ¿Qué tan bueno es el resultado producido?
3. ¿Cuál es el ‘costo’ de la ejecución?

La sociedad actual se basa en el petróleo y en una nueva comodidad, inteligencia artificial,

que no tiene forma material, debido a que fluye información como una realidad física de
vibraciones de un cable.

Se ha comentado que los algoritmos contienen instrucciones elementales que prescriben

las acciones básicas a ser ejecutadas. Comentemos ahora la forma en que esas
instrucciones están arregladas (ordenas) en el algoritmo. La ejecución de un algoritmo
puede pensarse que es llevada a cabo por un pequeño robot o procesador. El procesador
recibe ordenes para ejecutar esto y aquello (instrucciones). El orden en el cual esas
acciones se ejecutan es crucial. El algoritmo debe contener las instrucciones de control
para meter al procesador esta o aquella dirección, diciendo que hacer en cada paso y
cuando debe parar y decir 'estoy listo'.

La programación requiere de instrucciones que sean cercanas tanto al hombre como a la

máquina, de tal forma que sea posible establecer una comunicación entre los humanos y
entre los humanos y las computadoras, los elementos básicos de este tipo de lenguaje
contiene a las llamadas estructuras de control. La forma más común y práctica de
representarlas es por medio del pseudocódigo. Otros mecanismos que se han utilizado
para representar algoritmos son los diagramas de flujo.

El azúcar, la harina, los huevos, etc., son los objetos manipulados por nuestra receta.
Como podemos observar estos elementos no solo constituyen las entradas y salidas del
algoritmo, sino también son construidos y usados durante su ejecución. Los algoritmos
generalmente operan sobre datos, pero estos no son masas amorfas de información sino
que involucran importantes relaciones entre sus datos.

1.2 Conceptos elementales de la programación

orientada a objetos
Por programar se entiende un proceso mental complejo dividido en varias etapas. La
finalidad de la programación es comprender con claridad el problema que va a resolverse o
simularse por medio de la computadora, y entender también con detalle cuál es el
procedimiento mediante el cual la máquina llegará a la solución deseada.

La codificación constituye una etapa necesariamente posterior a la programación y

consiste en describir, en el lenguaje de programación adecuado, la solución ya encontrada
o sugerida, por medio de la programación. Es decir, primero se programa la solución de un
problema, y después hay que traducirla para que la computadora pueda entenderla.

Programar requiere de:

3
• Talento
• Creatividad
• Inteligencia
• Lógica
• Experiencia
• Habilidad para construir y analizar abstracciones

Dentro de la historia del software se han tenido presentes dos características:

1. Los sistemas son más grandes y complejos

2. La evolución de los lenguajes de programación

Esta evolución de la tecnología del software puede verse representada por una estructura
de capas, en donde cada una de las capas continua siendo funcional.

Cuando la computación se encontraba en su infancia, muchos programas fueron escritos

en lenguajes ensamblador por un solo individuo. Cuando los programas empezaron a ser
más complejos, los programadores encontraron difícil recordar toda la información
necesaria para desarrollar o mantener los sistemas.

La introducción de lenguajes de alto nivel resolvió algunas dificultades. Simultáneamente

las expectativas de resolver problemas más complejos se incrementó. Así, empezaron a
formarse grupos de programadores que trabajaban juntos. Cuando esto paso, un
fenómeno interesante fue observado: Una tarea que tomaba 2 meses a un programador
no podía completarse en un mes por dos programadores.

La razón de este comportamiento no lineal fue la complejidad. Se ha observado que esta

complejidad se deriva de:

• complejidad del dominio del problema

• dificultad en el manejo del proceso de desarrollo
• flexibilidad del software

Las formas que se han utilizado para tratar la complejidad de los sistemas son:

• Procedimientos
• Módulos
• Objetos

La programación orientada a objetos permite organizar programas de forma parecida a

como los objetos del mundo real se organizan, es una forma de concebir un programa de
computadora. Modela una aplicación como una colección de objetos que se comunican
entre sí para alcanzar una meta común.

Tiene sus orígenes en la simulación, de hecho el primer lenguaje orientado a objetos fue
Simula, esto se debe a que en simulación generalmente se modela una aplicación como un
conjunto de entidades.

4
El lenguaje que se utiliza influye directamente la forma en que puede realizarse la
abstracción del mundo, y es a través de esta abstracción lo que permite resolver el
problema deseado.

Ejemplo: Inuiktitut el lenguaje de los Inuits tiene varias palabras para distintos tipos de
nieve –wet, fluffly, heavi, ici y otros. Por su propio lenguaje los inuits tienden a ser más
perceptivos a la nieve que los que viven en climas templados. Aunque no existan
diferencias entre los ojos de unos y de otros.

Este tipo de situaciones también resultan verdaderos en los lenguajes de programación,

aunque para un compilador la diferencia entre un lenguaje orientado a objetos sólo sea la
adición de unas cuantas palabras clave y tipos de enunciados.

El primer principio para resolver un problema en forma orientada a objetos es: siempre
que se necesita realizar alguna tarea, lo primero que hay que hacer es encontrar un objeto
que lo realice.

Un objeto es un elemento independiente de un programa de computadora, que representa

un grupo asociado de características y está diseñado para realizar tareas específicas.
También se les conoce como instancias. Dicho en otras palabras es algo que es
identificable. Tiene forma, textura y cierto comportamiento. Por ejemplo una silla, un libro
o un lápiz.

Un objeto es diferente a una variable, ya que las variables por lo general solamente
permiten representar la estructura de datos de un objeto y no su comportamiento.

Seguramente estará de acuerdo en que el mundo está lleno de objetos.

La programación orientada a objetos es un tipo de programación que ofrece una forma de

modularizar programas estableciendo áreas de memoria particionadas para los datos y
para los procedimientos que pueden ser usadas como plantillas para producir copias en
demanda de tales módulos. Así, un objeto es considerado como un área particionada de la
memoria de la computadora.

Esencialmente, el método de programación orientada a objetos particiona la memoria de la

computadora permitiendo que cada módulo u objeto funcione relativamente independiente
del resto.

Las áreas de memoria no sólo sirven para almacenar datos sino también código en forma
de procedimientos ejecutables.

Un objeto es código y datos, es decir una forma de datos activos.

Una clase es un concepto que nos permite describir un conjunto de objetos similares.

5
Todos los objetos son instancias de una clase. El método invocado por un objeto en
respuesta a un mensaje está determinado por la clase del receptor. Todos los objetos de
una clase dada utilizan el mismo método en respuesta a mensajes similares.

Mensajes y métodos: una acción es inicializada transmitiendo un mensaje a un agente

(objeto) responsable de la acción. El mensaje codifica la petición de la acción y por
información adicional (argumentos) necesarios para llevar a cabo la acción. El receptor es
el agente al que se envía el mensaje. Si el receptor acepta el mensaje acepta la
responsabilidad de llevar a cabo la acción indicada. En respuesta al mensaje, el receptor
ejecuta algún método para satisfacer la petición.

Las tres propiedades principales que caracterizan a un lenguaje orientado a objetos son:

• Encapsulación: combinación de una estructura de datos con las funciones (acciones o

métodos) dedicadas a manipular los datos.
• Herencia: construcción de nuevas clases a partir de clases base definidas
anteriormente, posiblemente redefiniendo o añadiendo nuevos datos o acciones. Esto
crea una jerarquía de clases.
• Polimorfismo: respuesta a una acción de distinta manera.

Herencia

Las clases pueden organizarse dentro de un árbol jerárquico. Los datos y el

comportamiento asociados con las clases que se encuentran más arriba en el árbol pueden
accederse y usarse por las clases de más abajo. Se dice que tales clases heredan el
comportamiento de sus clases padres.

Las clases pueden organizarse en una estructura jerárquica de herencias. Una subclase
hereda los atributos de una superclase del árbol. Una superclase abstracta es una clase
que es utilizada solo para crear subclases en las cuales no hay instancias directas.

Método de encadenamiento: La búsqueda para encontrar un método que debe invocarse

en respuesta a un mensaje dado comienza con la clase del receptor. Si no se encuentra un
método apropiado, la búsqueda pasa a la superclase de esta clase. La búsqueda continua
hacia arriba de la cadena de superclases hasta que el método es encontrado o la cadena
se termina. En el primer caso el método se ejecuta y en el segundo se produce un
mensaje de error.

Reduciendo la interdependencia entre los componentes del software, la programación

orientada a objetos permite el desarrollo de sistemas de software reusable. Tales
componentes pueden crearse y probarse en unidades independientes aislados de otras
partes del software de aplicación.

Los componentes del software reusable permiten al programador tratar con problemas en
un nivel de abstracción superior.

6
Polimorfismo

Cuando dos objetos responden a un mensaje dado utilizando diferentes métodos se

conoce como polimorfismo.

Ventajas:

• Pueden expresarse conceptos abstractos claramente y combinarlos con otros

• La encapsulación evita que un pequeño cambio tenga efectos masivos
• No es necesario considerar cuantas implementaciones de una función miembro dada
existan (polimorfismo), de esta forma el mantenimiento resulta más sencillo
• Pueden compartirse tanto estructuras de datos como procedimientos por medio de la
herencia
• Claridad
• Promueve el reuso (construcción de librerías)

1.3 Definición de clase y enunciados elementales

Una clase tiene la siguiente forma:

clase nombre
{
principal
comienza
enunciados
termina
}

El nombre de una clase y de una variable se forma de la siguiente manera:

Una letra seguida de cero o más letras, dígitos, $ o _

Lo anterior se puede expresar como:

<letra> <letra|dígito|$|_>*

Un enunciado en su forma más simple permite que una variable almacene un valor
especifico ya sea que se exprese explícitamente o a través de una operación.

A esta operación se le conoce como asignación y se expresa en pseudocódigo mediante el

siguiente símbolo:

Si se desea que una variable "a" contenga el valor de 5, se expresa explícitamente como:

a 5

7
Tipos de datos primitivos y expresiones

Los tipos de datos elementales son:

Tipo de datos elemental En pseudocódigo

entero int
real real
booleano bool
caracter char

Las operaciones que pueden realizarse dependen del tipo de dato. Para los tipos de datos
numéricos son:

Operación Símbolo Prioridad

suma + 1
resta - 1
multiplicación * 2
división / 2
potenciación ^ 3
división entera div 2
módulo mod 2

Las prioridades se alteran con el uso de paréntesis. Cuando existen operadores con la
misma prioridad entonces se aplica la regla de asociatividad de izquierda a derecha.

Las operaciones que pueden realizarse sobre los booleanos son:

Operación Símbolo
AND &
OR |
NOT ¬

Ejemplo:

/**
*Suma el entero 5 y el entero 7
**/
class Suma5y7
{
principal
comienza
int a 5 //en la variable a se almacena el valor de 5
int b 7 //en la variable b se almacena el valor de 7
int c a + b //en c se almacena la suma de a con b
termina
}

8
Sin embargo, el algoritmo anterior carece de algo muy importante la comunicación
con el usuario, dicho de otra forma el resultado de la suma no se muestra.

En muchas ocasiones también es necesario que el usuario establezca comunicación

con la máquina y para esto existen las operaciones de entrada y salida.

Operaciones de entrada salida

En pseudocódigo la operación que permite establecer comunicación al usuario con

la máquina es:

lee nombreVariable

La instrucción anterior hace que a la variable nombrada se le asigne el valor que el

usuario proporcionó.

La operación contraria es:

escribe nombreVariable

la cual permite comunicar el valor de la variable al usuario. Cuando se desea que

la máquina comunique algo al usuario de manera predefinida, el conjunto de
símbolos se encerrara entre comillas. Al conjunto de símbolos se le conoce como
cadena y puede incluir dígitos y otros símbolos. Las clase cadena se estudiara más
adelante.

Por ejemplo, la siguiente clase escribe “buenos días”

/**
* Da los buenos días al usuario a través de la pantalla
**/
class Saludo
{
principal
comienza
escribe “buenos días”
termina
}

Ejemplos:

1. Escribir un programa que permita sumar dos números enteros proporcionados

por el usuario:

/**
* Suma dos enteros proporcionados por el usuario, el resultado lo
* imprime en pantalla
**/
clase suma2Enteros

9
{
principal
comienza
int a, b, c
escribe “De un valor entero”
lee a
escribe “de otro valor entero”
lee b
c a + b
escribe “La suma de”
escribe a
escribe “con”
escribe b
escribe “es”
escribe c
termina
}

En algunas ocasiones se desea que la operación de salida (escribe) concatene

cadenas con valores de variables, y así se utiliza el operador de concatenación
(“+”). El ejemplo anterior podría entonces escribirse como:

/**
* Suma dos enteros proporcionados por el usuario, el resultado lo
* imprime en pantalla. Versión más compacta que la clase anterior
**/
clase suma2Enteros
{
principal
comienza
int a, b, c
escribe “De un valor entero”
lee a
escribe “de otro valor entero”
lee b
c a + b
escribe “La suma de” + a + “con” + b + “es” + c
termina
}

Lo cual es más claro y más compacto.

2. Calcular el IVA de un producto

/**
* Calcula el IVA de un producto. El usuario deberá proporcionar el
valor * del producto
**/
class CalculaIVA
{
principal
comienza
real precio, iva
escribe “Dame el valor del producto”
lee precio
iva precio * 0.15
escribe “El IVA de un producto de $“ + precio + “ es “ + iva
termina

10
}

En algunas ocasiones existen valores que no cambian frecuentemente o son fijos,

como el caso del IVA o el valor de π (pi). En estos casos es conveniente utilizar
constantes. Las constantes son valores de variables que no pueden ser
reasignados es decir durante el programa no está permitido cambiar su valor. En
pseudocódigo se empleara palabra clave const seguida del tipo y nombre de la
constante, el símbolo de asignación y de su valor. Así el ejemplo anterior quedaría
como:

/**
* Calcula el IVA de un producto. El usuario deberá proporcionar el
valor * del producto. Se utiliza una constante entera
**/
class CalculaIVA
{
principal
comienza
const int costoIVA 0.15
real precio, iva
escribe “Dame el valor del producto”
lee precio
iva precio * costoIVA
escribe “El IVA de un producto de $“ + precio + “ es “ + iva
termina
}

3. Si ahora se desea calcular el IVA y el costo total del producto podríamos

escribir la siguiente clase:

/**
* Calcula el IVA y el costo total de un producto. El usuario deberá
* proporcionar el valor del producto. Se utiliza una constante
**/
class CalculaIVA
{
principal
comienza
const int costoIVA 0.15
real precio, iva, costo
escribe “Dame el valor del producto”
lee precio
iva precio * costoIVA
total precio + iva
escribe “El IVA de un producto de $“ + precio + “ es “ + iva
escribe “y su costo total es de $ “ + total
termina
}

4. Suponga que se desea calcular el costo de peaje de camiones. Los camiones

que llegan a una cabina de peaje deben pagar $5.00 por eje mas $10.00 por
cada tonelada del peso total del camión.

Entradas: número de ejes, peso total en toneladas

Procesamiento: número de ejes * $5.00 + peso total en toneladas * $10.00

11
 Salidas: costo

/**
* Calcula la cuota de peaje que deberá pagar un camión con base
* a su peso
**/
class peaje
{
principal
comienza
const real costoEje 5
const real costoTonelada 10
int numEjes, numToneladas
escribe “Proporcione el número de ejes del camión”
lee numEjes
escribe “¿Cuántas toneladas son?”
lee numToneladas
costo numEjes * costoEje + numToneladas * costoTonelada
escribe “El peaje del camión es de $” + costo
termina
}

Algunas reglas:

1. Los nombres de variables y algoritmos deberán ser significativos

2. Estrictamente prohibido utilizar del lado derecho de una expresión una variable
que no haya sido inicializada previamente, i. e., del lado derecho de una
expresión siempre deberán aparecer variables que tengan un valor
determinado o bien un valor
3. Los nombres de las clases deberán ser diferentes a los de cualquier variable
que se utilice en el algoritmo

1.4 Elementos de programación

El orden en que los enunciados se ejecutan en un algoritmo se conoce como flujo

de control.

A menos que se especifique lo contrario la ejecución de un programa se realiza de

manera lineal, de tal forma que se inicia en la primera sentencia y se procede a
ejecutar la siguiente, y así sucesivamente hasta que se encuentra la última
sentencia. Esta estructura de control se conoce como secuenciación.

Es posible alterar el flujo de control a través de otras estructuras de control, las

cuales pueden clasificarse en dos categorías: selección e iteración.

Las estructuras de selección a veces llamadas condicionales permiten discriminar

qué sentencia se ejecutara después. En pseudocódigo se estudiarán las siguientes:
si-entonces-otro y el si-entonces. La decisión entre qué sentencia ejecutar está

12
basada en una expresión booleana (aquella que al ser evaluada produce un valor
de verdadero o un valor de falso).

Las estructuras iterativas o repetitivas permiten que una sentencia se ejecute

varias veces dependiendo de una expresión booleana. En pseudocódigo se
estudiarán las siguientes:

• para
• mientras
• repite

Estructuras de control

Secuenciación

La secuenciación sirve para indicar que después de la acción e1 continua la acción

e2. En psudocódigo se expresa como

e1
e2

Ejemplos de secuenciación:

Todos los ejemplos que se han visto hasta ahorita son de secuenciación.

1. Calcular el área y la circunferencia de un círculo.

Entrada: radio del círculo

Procesamiento: area π* radio2 circunferencia 2*π*radio
Salida: area y circunferencia

/**
* Calcula el círculo y la circunferencia dado el radio
**/
clase Circulo
{
principal
comienza
const pi 3.1416
real radio, area, circunferencia
escribe “Proporcione el radio del circulo”
lee radio
area pi * radio ^ 2
circunferencia 2 * pi * radio
escribe “Un círculo con radio “ + radio
escribe “tiene area de “ + area
escribe “y una circunferencia de “ + circunferencia + “unidades”
termina
}

13
2. Intercambiar los valores de dos variables tipo carácter

/**
* Intercambia los valores de dos variables proporcionadas por el
usuario
**/
clase Intercambia
{
principal
comienza
char valor1, valor2, temp
escribe “Proporcione el primer carácter”
lee valor1
escribe “Proporcione el segundo carácter”
lee valor2
temp valor1
valor1 valor2
valor2 temp
escribe “Ahora el primer carácter vale” + valor1
escribe “y el segundo vale “ + valor2
termina
}

Selección

La selección permite tomar diferentes caminos dependiendo de una cierta

condición. En pseudocódigo se estudiaran 2 enunciados diferentes:

si c1
e1

si c1
e1
otro
e2

Por ejemplo considere la siguiente secuencia de enunciados:

e1
e2
si c1
e3
e4
e5

si c1 tiene un valor verdadero entonces se realizaran los siguientes enunciados y

en ese orden:
e1, e2, e3, e4, e5

si c2 tiene un valor falso entonces se realizan los siguientes enunciados:

e1, e2, e4, e5

Considere a continuación un ejemplo que utiliza un enunciado de selección con

bifurcación:

14
e1
e2
si c1
e3
otro
e4
e5
e6

si c1 tiene un valor verdadero entonces se realizaran los siguientes enunciados y

en ese orden:
e1, e2, e3, e5, e6

si c2 tiene un valor falso entonces se realizan los siguientes enunciados:

e1, e2, e4, e5, e6

Expresiones booleanas:

Una expresión booleana es una expresión que al evaluarla resulta en un valor

verdadero o en un valor falso.

Se pueden formar a través de los siguientes operadores relacionales:

Símbolo Significado
= igual
<> desigual
< menor
<= menor o igual
> mayor
>= mayor o igual

Por ejemplo, suponga los siguientes valores:

int a 5
int b 10

Al evaluar las siguientes expresiones se obtienen los siguientes valores:

Expresión Valor
a=b falso
a <> b verdadero
a<b verdadero
a <= b verdadero
a>b falso

15
a >= b falso

Las expresiones booleanas también se pueden formar usando los operadores

lógicos AND (&), OR (|) y NOT (¬). Por ejemplo la siguiente expresión

(a = b) & ( a < b)

tiene un valor de falso cuando a tiene un valor de 5 y b un valor de 10.

Ejemplos de selección:

1. Determinar cuando una persona es joven. Se considera joven cuando tiene

menos de 21 años de edad
/**
* Determina si una persona es joven (menor de 21 años)
**/

clase SiempreJoven
{
principal
comienza
const int joven 21 //Declaración de la constante joven
int edad
escribe “Proporcione su edad”
lee edad
si edad < joven
escribe “La juventud es un tesoro divino, disfrútala”
escribe “La edad es un estado mental”
termina
}

2. Determinar el mayor de 2 números enteros:

/**
* Determina el mayor de dos enteros
**/
clase MayorDeDosNumeros
{
principal
comienza
int a, b, mayor
escribe “Dame dos números”
lee a, b
si a > b
mayor a
otro
mayor b
escribe “El mayor entre “ + a + “ y “ + b + “es: “ + mayor
termina
}

16
2. Encontrar el menor de 3 números enteros

/**
* Determina el menor de tres números enteros
**/
clase MenorDeTresNumeros
//versión 1
//La idea es determinar el menor de dos números y después comparar ese
//resultado con el tercer número
{
principal
comienza
int a, b, c, menor, menor1
escribe “Dame tres números”
lee a, b, c
si a < b
menor1 a
otro
menor1 b
si menor1 < c
menor menor1
otro
menor c
escribe “El menor entre “ + a + “ + “ + b + “ y “, c,
escribe “es: “ + menor
termina
}

/**
* Determina el menor de tres números enteros
**/
clase MenorDeTresNumeros
//versión 2
principal
comienza
int a, b, c, menor
escribe “Dame tres números”
lee a, b, c
si a < b entonces
si a < c
menor a
otro
menor c
otro // b < a
si b < c
menor b
otro
menor c
escribe “El menor entre “ , a, “ , “, b, “ y “, c, “es: “, menor
termina
}

/**
* Determina el menor de tres números enteros
**/
clase MenorDeTresNumeros
//versión 3
comienza
int a, b, c, menor
escribe “Dame tres números”
lee a, b, c

17
 si a < b & a < c
menor a
otro
si a < b & a > c
menor c
otro
si a > b & b < c
menor b
otro
menor c
escribe “El menor entre “ , a, “ , “, b, “ y “, c, “es: “, menor
termina
}

/**
* Determina el menor de tres números enteros
**/
clase MenorDeTresNumeros
//versión 4
principal
comienza
int a, b, c, menor
escribe “Dame tres números”
lee a, b, c
Menor a
si b < menor
menor b
si c < menor
menor c
escribe “El menor entre “ , a, “ , “, b, “ y “, c, “es: “, menor
termina
}

3. Determinar si tres números enteros datos forman un triángulo

/**
* Determina si se forma un triángulo
**/
clase triangulo
{
principal
comienza
int a, b, c
escribe “Favor de dar 3 números en orden”
lee a, b, c
si (a*a + b*b = c*c)
escribe “Los lados si forman un triángulo rectángulo”
otro
escribe “Esos datos no describen un triángulo”
termina
}

Considere otra versión del algoritmo anterior:

/**
* Determina si se forma un triángulo
**/
clase Pitágoras
{
principal

18
comienza
int a, b, c
escribe “Favor de dar 3 números en orden”
lee a, b, c
escribe a + “ , “ + b + “ y “ + c
si ¬ (a*a + b*b = c*c)
escribe “ no ”
escribe “forman un triángulo rectángulo”
termina
}

4. Calcular el salario diario de un empleado con base en lo siguiente:

a) Por cada hora de trabajo recibe $17.50, si está dentro de su jornada de 8
horas
b) Por cada hora extra recibe 1.5 veces el costo de hora de trabajo dentro de
la jornada laboral normal

/**
* Determina el salario de un trabajador
**/
clase Salario
{
principal
comienza
const real costoHora 17.5
const real sobrePago 1.5
int numHoras
escribe “Proporciona el número de horas trabajadas”
lee numHoras
si numHoras <= 8
paga numHoras * costoHora
otro
paga 8 * costoHora + (numHoras-8) * sobrePago * costoHora
escribe “El salario correspondiente a “ + numHoras + “ es “ + paga
termina
}

5. Determinar la calificación final alfabética de un alumno conforme el programa

de estudios.

Recordando las equivalencias:

10 - 8.5 M
8.4 – 7.0 B
6.9 – 6.0 S
5.9 – 0.0 N

/**
* Determina la calificación alfabética dada la calificación numérica
**/
clase Equivalencia
{
comienza
real califNumerica
char califAlfabetica

19
 escribe “Proporcione la calificación final”
lee califNumerica
si califNumerica <= 10 & califNumerica >= 8.5
califAlfabetica ‘M’
otro si califNumerica <= 8.4 & califNumerica >= 7.0
califAlfabetica ‘B’
otro si califNumerica <= 6.9 & califNumerica >= 6.0
califAlfabetica ‘S’
otro
califAlfabetica ‘N’
escribe califNumerica + “ es equivalente a “ + califAlfabetica
termina
}

Iteración

Existen tres tipos de enunciados iterativos:

• para
• mientras
• repite

para

El para permite escribir una iteración que se realizará de acuerdo al valor inicial de
una variable y hasta que dicha variable alcance un valor final.

para variable valorInicial hasta valorFinal, incremento

e1

Ejemplos:

1. Escribir un algoritmo para imprimir los números del 1 al 100

/**
* Imprime los números del 1 al 100
**/
clase Imprime1-100
{
principal
comienza
para i 1 hasta 100, 1
escribe i
termina
}

Debido a que muchas veces el incremento es 1 se obviara, es decir no se pondrá.

2. Escribir un algoritmo para calcular la suma de los números enteros entre 1 y

100

/**

20
 * Determina la suma de los números del 0 al 100
**/
clase Suma
{
principal
comienza
int suma 0
para i 0 hasta 100
suma suma + i
escribe "La suma entre 1 y 100 es " + suma
termina
}

Es posible combinar las estructuras de control utilizando para tal fin la

secuenciación, la selección y la iteración.

3. Imprimir los pares entre 1 y 100

/**
* Imprime los pares comprendidos entre 1 y 100
**/
clase ImprimePares1-100
{
principal
comienza
para i 1 hasta 100
si i mod 2 = 0 entonces
escribe i
termina
}

Otra versión:

/**
* Imprime los pares comprendidos entre 1 y 100
**/
clase ImprimePares1-100
{
//En esta versión el para inicia con el primer para
//y se incrementa de dos en dos
principal
comienza
para i 2 hasta 100, 2
escribe i
termina
}

4. Imprimir los múltiplos de 5 entre un límite inferior y un límite superior

/**
* Imprime los números múltiplos de 5 comprendidos entre un
* límite inferior y un límite superior
**/
clase ImprimeMultiplos5
{
principal
comienza
int limInf, limSup

21
 escribe “Proporcione el límite inferior y el límite superior”
lee limInf, limSup
para i limInf hasta limSup
si i mod 5 = 0 entonces
escribe i
termina
}

5. Imprimir las tablas de multiplicar del 0 al 10

/**
* Imprime las tablas de multiplicar del 0 al 10
**/
clase TablasMultiplicar
{
principal
comienza
para i 0 hasta 10
para j 1 hasta 10
escribe i + “*” + j + “=” + i*j
termina
}

6. Determinar el factorial de un número

/**
* Determina el factorial de un número proporcionado por el usuario
**/
clase Factorial
{
principal
comienza
int n, fact
escribe “Dame un número”
lee n
fact 1
para i 1 hasta n
fact fact * i
escribe “El factorial de “ + n + “ es “ + fact
termina
}

7. Algoritmo de Ada Byron para x3 calculado a través de diferencias

03 = 0
13 = 1
23 = 8=1+7
33 = 27 = 8 + 19 = 8 + (7 + 12)
43 = 64 = 27 + 37 = 27 + (19 + 18)
53 = 125 = 64 + 61 = 64 + (37+24)
63 = 216 = 125 + 91 = 125 + (61 + 30)
73 = 343 = 216 + 127 = 216 + (91 + 36)

clase AdaCubo
{

22
principal
comienza
int result 0, prim 1
escribe “Dame un número”
lee n
para i 1,n
comienza
result +=prim
prim += 6*i
termina
escribe n + “al cubo es:“ + result
termina
}

Bloques de enunciados

Se puede reemplazar un solo enunciado con un bloque de enunciados. Un bloque

de enunciados es una lista de sentencias encerradas entre comienza y termina.
El uso o no de bloques de enunciados depende de lo que se desee hacer en cada
situación.

8. Escribir un algoritmo para imprimir los números z, comprendidos entre 0 y 50,

que cumplen la expresión:

z2 = x2 + y2

donde z, x e y son números enteros positivos.

/**
* Imprime los cuadrados perfectos entre 0 y 50
**/
clase CuadradosPerfectos
{
principal
comienza
int x, y, z
escribe “Los cuadrados perfectos entre 0 y 50 son”
para x 0 hasta 50
para y 0 hasta 50
comienza
z (x^2 + y^2)^(1/2)
si (z <= 50) & (z^2 = x^2 + y^2) entonces
escribe “x = “, x, “ y = “, y, “ z = “, z
termina
termina
}

mientras

La estructura del mientras es:

mientras c1
e1

23
en donde e1 se ejecutara mientras la condición c1 sea verdadera.

Ejemplos:

1. Escribir un algoritmo para imprimir los números del 1 al 100

/**
* Imprime los números entre 1 y 100
**/
clase Imprime1-100
{
//versión mientras
principal
comienza
int i 1
mientras i <= 100
comienza
escribe i
i++
termina
termina
}

2. Determinar si un número es primo

/**
* Determina si un número dado es primo o no
**/
clase DeterminaPrimo
{
principal
comienza
int num
escribe “Escribe un numero”
lee num
int i 2
mientras num mod i <> 0 & i < num
i++
si i = num entonces
escribe num + “ es un número primo”
otro
escribe num + “ no es primo”
termina
}

repite

La estructura del repite es:

repite
e1
mientras c1

24
donde el enunciado e1 se ejecuta y después se evalúa la condición c1, si la
condición es verdadera el flujo de control se pondrá al inicio del repite es decir se
ejecutará nuevamente el enunciado e1 y si es falso terminara.

Ejemplos:

1. Escribir un algoritmo para imprimir los números del 1 al 100

/**
* Imprime los números comprendidos entre 1 y 100
**/
clase Imprime1-100
{
//versión repite
principal
comienza
int i 1
repite
escribe i
i++
mientras i <= 100
termina
}

2. Invertir los dígitos de un entero.

/**
* Invierte los dígitos de un entero
**/
clase InvierteEntero
{
principal
comienza
int num
escribe “Escribe un entero”
lee num
repite
escribe num mod 10
num num div 10
mientras num != 0
termina
}

3. Invertir los dígitos de muchos enteros

/**
* Invierte los dígitos de los enteros dados por el usuario
* Pregunta al usuario si desea continuar
**/
clase InvierteMuchosEnteros
{
principal
comienza
int num
char deseo //Sirve para leer la entrada del usuario
repite
escribe “Escribe un entero”

25
 lee num
repite
escribe num mod 10
num num div 10
mientras num != 0
escribe “Deseas continuar (s/n)?”
lee deseo
mientras deseo <> ‘n’
termina
}

Ejercicios:

1. ¿Cuál es la salida de los siguientes segmentos de código?

Considere que:

int i 6
int j 9

a)
si i < j entonces
escribe “hola”

b)
si i < j/2 entonces
escribe “hola”

c)
si i < j entonces
escribe “hola”
si j > 7 entonces
escribe “adios”
otro
escribe “que tal”

2. ¿Qué está mal en el siguiente segmento de código? Escriba un segmento que

produzca la salida correcta

si total = MAX entonces

si total < suma entonces
escribe “ total igual a MAX y menor que suma”
otro
escribe “total no es igual a MAX”

3. ¿Cuál es la salida de los siguientes segmentos de código?

a)
para i 1 hasta 10, 1

26
 escribe i

b)
para i 1 hasta 10*2, 1
escribe i

c)
para i 10 hasta 1, -1
escribe i

d)
para i -2 hasta 10
escribe i

e)
int i 1
repite
escribe i
i++
mientras i < 10

f)
int i 10
repite
i--
escribe i
mientras i < 10

g)
int i 1
mientras i <= 10
comienza
escribe “hola”
i++
termina

h)
int i 1
mientras i > 10
escribe “El país de nunca jamás”

i)
int i 20
mientras i > 10
escribe “El país de nunca jamás”

4. Escribir un algoritmo que imprima los múltiplos de un número X proporcionado

por el usuario comprendidos entre un límite inferior y un límite superior
5. Escribir un algoritmo para imprimir los números que no sean múltiplos de un
números X comprendidos entre un límite inferior y un límite superior
6. Escribir un algoritmo para intercambiar tres valores, utilizando el mínimo de
asignaciones

27
7. Escribir un algoritmo para sumarlos números pares entre 1 y 100
8. Escribir un algoritmo que calcule el promedio de los números pares pares entre
1 y 100
9. Escribir un algoritmo para calcular el promedio de pares entre un límite inferior
y un límite superior

1.5 Buenas prácticas de programación

1. Modularidad a través del diseño top-down
2. Modificable (uso de constantes)
3. Interfaz con el usuario
entrada interactiva (letreros)
salida
con datos de entrada
etiquetada
4. Programación libre de errores
de entrada
lógicos

Ventajas de la modularidad:

Contrucción
Depuraci´n
Fácil de leer
Fácil de modificar
Eliminación de código redundante
Desarrollo independiente de módulos

Estilo:

• Extenso uso de módulos

• Evitar uso de variables globales
• En general las funciones NO deben:
♦ asignar valores a variables globales
♦ realizar funciones de E/S
• Manejo de errores
• Uso de nombres significativos de variables y módulos
• Documentación que pueda leerse, usarse y modificarse por otros
♦ Documentación del programa
♦ Documentación general

Documentación del programa:

Comentario principal del programa debe contener:

propósito
autor y fecha

28
 breve descripción de los algoritmos y estructuras de datos globales
descripción de cómo usar el programa
descripción de variables globales
comentarios acerca de que tipo de datos espera el programa
Miniencabezado en cada módulo similar al del programa
Comentarios en el cuerpo de cada módulo explicando lo importante y confuso del
programa

Documentación general:

Diseño modular del programa

Pseudocódigo
Listada
Manual de usuario
Ejemplos y corridas

29