Seudocodigo - Version Revisada

SEUDOCDIGO
Edicin revisada

Material para la materia
"Programacin de computadoras"

Licenciatura en Ciencias de la Computacin
Universidad de Sonora

M.C.C. Edelmira Rodrguez Alcntar
L.M. Irene Rodrguez Castillo

2
I INTRODUCCIN ................................................................................................................... 6
II OPERACIONES BSICAS .................................................................................................. 6
II.1 IDENTIFICADORES ................................................................................................................ 7
II.2 TIPOS DE DATOS ................................................................................................................... 8
II.3 DECLARACIN DE VARIABLES ............................................................................................. 9
II.4 DEFINICIN DE CONSTANTES ............................................................................................... 9
II.5 ESCRITURA DE DATOS ........................................................................................................ 10
II.6 LECTURA DE VARIABLES .................................................................................................... 12
II.7 PRIMER ALGORITMO SECUENCIAL .................................................................................... 13
II.8 OPERADORES ARITMTICOS .............................................................................................. 15
II.9 OPERADORES ARITMTICOS MOD Y DIV ........................................................................ 19
II.10 OPERADORES RELACIONALES .......................................................................................... 20
II.11 OPERADORES LGICOS .................................................................................................... 21
II.12 LEYES DE DEMORGAN ..................................................................................................... 23
III SELECCIN ...................................................................................................................... 25
III.1 SELECCIN SIMPLE ........................................................................................................... 25
III.2 SELECCIN DOBLE ............................................................................................................ 27
III.3 SELECCIN MLTIPLE ...................................................................................................... 35
IV CICLOS ............................................................................................................................... 42
IV.1 CICLO MI ENTRAS HACER ................................................................................................ 42
IV.1.1 VARIANTES DEL USO DEL CICLO ...................................................................................... 52
IV.2 CICLO PARA HACER......................................................................................................... 55
IV.3 CICLO HACER MI ENTRAS ................................................................................................ 62

3
Lista de Figuras

Fig. II-1: Comunicacin usuario-mquina. (a) La mquina enva un mensaje al usuario.
(b) El usuario introduce datos a la mquina 10

Fig. II-2: Bosquejo de un algoritmo . 13

Fig. II-3: Funcionamiento de los operadores DIV y MOD 15

Fig. II-4: Dividiendo el nmero 65398 en sus dgitos componentes 20

Fig. II-5: Leyes de DeMorgan 23

Fig. III-1: Formato de la seleccin simple 25

Fig. III-2: Formato de la seleccin doble 28

Fig. III-3: Formato para la seleccin mltiple 35

Fig. IV-1: Estructura del ciclo mientras-hacer 42

Fig. IV-2: Formato para el ciclo para-hacer 55

Fig. IV-3: Formato para el ciclo para-hacer donde el contador se incrementa desde el
valor_inicial hasta el valor_final 56

Fig. IV-4: Formato para el ciclo para-hacer donde el contador se decrementa desde el
valor_inicial hasta el valor_final 56

Fig. IV-5: Aproximacin del rea bajo la curva f(x) con rectngulos inferiores 60

Fig. IV-6: Estructura del ciclo hacer-mientras. 62

4
Lista de Ejemplos

Ejemplo 1. Solicitar y leer 3 datos de diferente tipo e imprimirlos. ...................................................................... 13
Ejemplo 2. Calcular el rea de un tringulo dadas la base y la altura. ................................................................. 17
Ejemplo 3. Calcular el rea de un crculo................................................................................................................ 18
Ejemplo 4. Uso de los operadores MOD y DIV. ...................................................................................................... 19
Ejemplo 5. Separar un nmero entero en sus dgitos correspondientes. .............................................................. 19
Ejemplo 6. Encontrar el menor de dos nmeros. .................................................................................................... 25
Ejemplo 7. Determinar si un nmero entero dado es par. ..................................................................................... 26
Ejemplo 8. Contratacin de un empleado................................................................................................................ 26
Ejemplo 9. Encontrar el mayor de dos nmeros dados. ......................................................................................... 28
Ejemplo 10. Encontrar el mayor de tres nmeros dados. ...................................................................................... 29
Ejemplo 11. Contratacin de un empleado.............................................................................................................. 32
Ejemplo 12. Contratacin de un empleado.............................................................................................................. 33
Ejemplo 13. Dado un nmero entero entre 1 y 7 indquese a que da de la semana corresponde. ..................... 33
Ejemplo 14. Piedra, papel y tijeras (juego). ............................................................................................................ 36
Ejemplo 15. El juego del 7. ........................................................................................................................................ 38
Ejemplo 16. Promedio de calificaciones de un grupo de 10 alumnos. ................................................................... 44
Ejemplo 17. Encontrar el mayor de 8 nmeros. .................................................................................................... 45
Ejemplo 18. Sumar los nmeros pares en el intervalo [1,100]. ............................................................................. 46
Ejemplo 19. Sumar los nmeros pares y los impares (por separado) en el intervalo [1,100]. ............................ 46
Ejemplo 20. Leer un conjunto de n nmeros y contar los nmeros pares que aparezcan. ................................. 48
Ejemplo 21. Multiplicar los nmeros impares en el intervalo [1,10]. .................................................................... 48
Ejemplo 22. Clculo del valor de t a partir de la serie infinita dada. ................................................................... 49
Ejemplo 23. Encontrar el factorial de n. ................................................................................................................. 51
Ejemplo 24. Indicar si un nmero entero positivo dado es primo. ........................................................................ 53
Ejemplo 25. Promedio de calificaciones usando un valor centinela. ..................................................................... 54
Ejemplo 26. Promedio de calificaciones usando un carcter como centinela. ...................................................... 54
Ejemplo 27. Calcular el factorial de un nmero n. ................................................................................................ 57
Ejemplo 28. Simular el lanzamiento de una moneda. ............................................................................................. 58
Ejemplo 29. Generar n trminos de la Sucesin de Fibonacci. ............................................................................. 58
Ejemplo 30. Determinar si un nmero entero positivo dado es primo. ................................................................ 59
Ejemplo 31. Calcular una integral numrica inferior. .......................................................................................... 60
Ejemplo 32: Adivinar el nmero mgico (juego). ................................................................................................... 62
Ejemplo 33: Piedra, papel o tijeras (juego). ............................................................................................................ 64

5
Lista de Tablas

Tabla 1: Operadores aritmticos. ............................................................................................................................. 15
Tabla 2: Precedencia de los operadores aritmticos elementales. ......................................................................... 16
Tabla 3: Operadores de relacin o relacionales. ..................................................................................................... 21
Tabla 4: Tabla de verdad del operador lgico AND. .............................................................................................. 22
Tabla 5: Tabla de verdad para el operador lgico OR. .......................................................................................... 22
Tabla 6: Tabla de verdad del operador lgico NOT. .............................................................................................. 22
Tabla 7: Precedencia de los operadores. .................................................................................................................. 23
Tabla 8: Reglas del juego PPT. ................................................................................................................................. 36

6
I Introduccin

Cuando se desea solucionar un problema particular es esencial tener una completa
comprensin del mismo y planear una estrategia para atacarlo.

La solucin de cualquier problema de cmputo involucra la ejecucin de una serie de
acciones en un orden determinado. Un algoritmo es un procedimiento para resolver un problema
en trminos de las acciones a realizar y el orden en que deben ejecutarse estas acciones.

Cuando queremos resolver un problema por medio de la computadora, debemos
plantearlo primero en nuestras palabras para asegurarnos de comprenderlo antes de pasarlo a un
lenguaje de programacin especfico donde se nos pedir que, adems de especificar las acciones
que resolvern el problema y el orden en que se ejecutarn, cuidemos las reglas de ortografa y
sintaxis del lenguaje particular (por ejemplo, Pascal, C, Basic, etc.). En este trabajo se presenta
una tcnica para describir los pasos que llevarn a la resolucin de un problema: el seudocdigo.
ste, tiene la ventaja de ser un lenguaje intermedio entre el lenguaje natural y un lenguaje de
computadoras, es decir, por un lado es lo suficientemente parecido al lenguaje natural (espaol
en este caso) por lo que no se tienen dificultades de comprensin; y por otro, requiere de la
utilizacin de ciertas reglas que nos ayudan a expresar las ideas en una forma lgica sin cuidar
los detalles sintcticos de un lenguaje de programacin. As pues, u|n algoritmo en seudocdigo
no se ejecuta por mquina alguna, nicamente nos servir para ordenar nuestras ideas. El
seudocdigo que utilizaremos aqu nos servir para aprender la lgica de la programacin
estructurada utilizada por el lenguaje C de forma que los algoritmos desarrollados sean
codificados en este lenguaje de forma casi inmediata. Se utiliza el lenguaje C como base en el
desarrollo de algoritmos en seudocdigo, debido a que es el primer lenguaje de programacin
que se ensea a los alumnos de la Licenciatura en Ciencias de la Computacin en la Universidad
de Sonora, y pretendemos que este trabajo sirva de apoyo en ese curso.

En el captulo II se presentan los elementos bsicos de la programacin en seudocdigo:
los tipos de datos que utilizaremos, la forma de declararlos, las operaciones aritmticas
elementales y las operaciones de lectura y escritura de datos, as como algunos operadores
adicionales.

En el captulo III, se introduce la programacin estructurada estudiando las estructuras de
seleccin (simple, doble y mltiple) y en el captulo IV se presentan las estructuras de repeticin
(mientras-hacer, para-hacer y hacer-mientras).

II Operaciones bsicas

Cuando utilizamos la computadora para resolver un problema, generalmente debemos
proporcionarle los valores a partir de los cuales queremos que nos arroje una solucin. Estos
valores son llamados la entrada del programa. Los valores que se generan como resultado de

7
operar con los valores de entrada son llamados la salida del programa. Hay un conjunto de
operaciones que se consideran bsicas para manejar los valores de entrada y de salida de forma
que resuelvan nuestros problemas. Una vez conocidos estos elementos estaremos en condiciones
de escribir nuestro primer algoritmo en seudocdigo. Estas operaciones bsicas son: Declaracin
de variables, definicin de constantes, lectura y escritura de datos, as como las operaciones
aritmticas, relacionales y lgicas que se pueden utilizar.

Hablaremos primero de la estructura de los datos que se utilizarn, es decir, la forma de
representar la informacin real del problema para que pueda ser almacenada y manipulada por la
computadora.

Los datos pueden presentarse de dos maneras en un algoritmo: en forma variable y en
forma constante. En ambos casos, se tienen tres atributos:
1.Nombre o identificador. Permite identificar un dato para diferenciarlo de otros y
manipularlo.
2.Contenido. Es el valor que contiene el dato.
3.Tipo. Tipo de dato asociado.

La diferencia entre un dato variable y uno constante est relacionada con su contenido: en
el primer caso ste puede ser modificado en el transcurso del algoritmo y en el segundo, una vez
que se ha asignado un valor no puede ser modificado.

En el resto de captulo se describe cada uno de los puntos mencionados.

II.1 Identificadores

Los nombres usados para hacer referencia a las variables, constantes, funciones, etiquetas y otros
objetos definidos en un programa se conocen como identificadores. Para crear un identificador,
se deben tomar en cuenta las siguientes reglas
:
1.nicamente pueden utilizarse letras del alfabeto ingls (a...z, A...Z), dgitos (0...9) y/o el
carcter de subrayado (_).
2.Puede iniciarse con letra o el carcter de subrayado (es decir, no puede iniciarse un
identificador con un dgito).

Es importante observar que no se permiten espacios formando parte del identificador. El
hecho de que se utilice el alfabeto ingls significa que no se permiten letras acentuadas ni la .

Ejemplos de identificadores vlidos:

suma_enteros
x

En seudocdigo no existen reglas especficas para la nomenclatura de identificadores, sin embargo, convendremos
en utilizar las presentadas en esta seccin por compatibilidad con el lenguaje C.

8
resp_usuario
_c1
c2
c_1

Ejemplos de identificadores no vlidos (los caracteres no permitidos son encerrados en
crculos):

suma enteros problema: el espacio
ao problema: la
calificacin problema: la letra acentuada
2C problema: iniciar con un dgito

La informacin de entrada, de salida y la generada durante el proceso de solucin debe
almacenarse y ser accesible en el momento que sea requerida a travs de las variables y/o
constantes que tendrn asociado un tipo de dato. Los diferentes tipos de datos aceptados se
mencionan en la siguiente seccin.

II.2 Tipos de datos

Los datos pueden ser numricos o alfanumricos. Los datos numricos pueden ser enteros o de
punto flotante (valores reales). Es importante entender el porqu se diferencia entre estos dos
tipos de datos. La razn es que un valor de punto flotante ocupa el doble, o ms, de espacio de
memoria que un entero (esto se debe a que un valor real contiene parte entera y parte decimal
mientras que un entero slo requiere una de las partes). As que, por razones de optimizacin de
memoria, se hace la distincin entre ellos. En los datos de tipo alfanumrico (formados por
caracteres alfabticos y/o numricos) se distingue entre los que requieren un nico carcter y los
que requieren de una cadena de caracteres. As pues, se diferenciar, por lo pronto, entre cuatro
tipos de datos: entero, real, caracter y cadena (de caracteres).

Ejemplos
- entero 1, 4, -6, 342, -32021, 0
- real -238.423, 2.0, 3.1542, 0.00001
- caracter 'a', '{', '*', '9', ' ' (espacio en blanco)
- cadena "Hola", "Universidad de Sonora", "Mi telfono es 52 (662) 259-21-55"

Ntese que los datos de tipo caracter se escriben entre apstrofes (o comilla simple)
mientras que los de cadena se escriben entre comillas (dobles).

Para poder utilizar una variable en un algoritmo es necesario declararla y en caso de
utilizarse una constante con nombre, debemos definirla. Estas operaciones se vern en las
secciones II.3 y II.4, respectivamente.

9

II.3 Declaracin de variables

Cuando declaramos una variable, le estamos anunciando a la computadora qu tipo de datos
vamos a almacenar en dicha variable. El formato para la declaracin de variables es:

tipo_de_dato identificador

donde, tipo_de_dato puede ser uno de los mencionados en la seccin anterior (entero, real,
caracter o cadena).

Por ejemplo, supongamos que requerimos la edad de una persona en aos y que para ello,
usamos el identificador edad. La declaracin del identificador se har como sigue:

entero edad

Si requerimos conocer el peso de un objeto, es posible usar el identificador peso y
declararlo de la siguiente manera:

real peso

Si preguntamos al usuario si quiere terminar el programa y esperamos una respuesta que
puede ser 's' o 'n' (que represente si o no, respectivamente), declaramos un identificador de tipo
caracter, como por ejemplo:

caracter resp

Si requerimos conocer el nombre del usuario, podemos declarar un dato de tipo cadena de
caracteres de la forma siguiente:

cadena nombre_usuario

Se sugiere usar identificadores que estn relacionados con lo que representarn en el
algoritmo, por ejemplo, si se quieren declarar una variable para almacenar una calificacin es
posible usar uno de los identificadores siguientes: calif o calificacion; esto har que el algoritmo
sea ms claro.

II.4 Definicin de constantes

Cuando un valor constante se presenta en un algoritmo es posible utilizarlo con nombre o sin l.
Las constantes sin nombre se usan tal cual en cualquier operacin. Sin embargo, algunos valores
constantes se utilizan repetidamente en algn proceso o son muy largos, lo cual hace tedioso o
complicado su uso. Con afn de evitar tales molestias, que adems hacen nuestro algoritmo
propenso a errores, es posible asignarle un nombre a un valor constante que nos permita hacer

10
referencia a dicho valor mediante tal identificador. Esta operacin es conocida como definicin
de constantes y su formato es como sigue:

constante tipo_de_dato identificador = valor

donde constante indica que el valor del identificador ser constante, es decir, que no podr
modificarse durante el resto del algoritmo.

Por ejemplo, para definir una constante que contenga el valor de t, podemos utilizar la
siguiente instruccin:

constante real PI=3.141593

Para efectos de claridad, utilizaremos letras maysculas para los identificadores de datos
constantes, con esto podremos diferenciarlos de los identificadores de las variables a primera
vista.

La interaccin usuario-mquina se desarrolla mediante el envo de mensajes por parte de
la mquina y de la introduccin de informacin (datos) por parte del usuario (ver la Fig. II-1).
Los mensajes de la computadora tienen el propsito de guiar al usuario en el uso del programa
para lo cual pueden utilizarse mensajes descriptivos del funcionamiento del mismo, de solicitud
de informacin y/o de presentacin de resultados. El usuario proporciona informacin en
respuesta a los mensajes de la mquina.

Esta interaccin requiere de dos operaciones: la escritura de datos y la lectura de variables
las cuales se vern en las secciones II.5 y II.6, respectivamente.

II.5 Escritura de datos

Esta operacin permite a la mquina presentar datos al usuario. Estos datos pueden ser
constantes (con nombre o sin l) o variables. El formato que usaremos es el siguiente:

Mensaje
[A travs de un
dispositivo de salida]
(a)
(b)
Datos
[A travs de un
dispositivo de entrada]
Fig. II-1: Comunicacin usuario-mquina. (a) La mquina enva un mensaje al usuario. (b) El usuario
introduce datos a la mquina.

11
escribir dato
donde escribir especifica la operacin a realizar y dato contiene la informacin que se desea
presentar al usuario.

Por ejemplo, si se desea presentar el mensaje "Hola, UniSon", se utiliza la siguiente
instruccin

escribir Hola, UniSon

en este caso la informacin presentada es una cadena constante sin nombre.

Suponiendo que tenemos los siguientes datos

entero edad

la operacin

escribir edad

imprimir el contenido de la variable edad y

escribir PI

imprimir el contenido de la constante PI.

Es posible enviar varios datos con la misma instruccin para lo cual es necesario
separarlos con comas. Por ejemplo, la instruccin

escribir Hola, UniSon, Soy alumno de primer ingreso

est enviando dos cadenas "Hola, UniSon" y "Soy alumno de primer ingreso". Esto es
equivalente a utilizar dos instrucciones de escritura; es decir,

escribir Hola, UniSon
escribir Soy alumno de primer ingreso

tiene el mismo efecto que la sentencia compuesta anterior.

Puede combinarse la impresin de datos variables y constantes. Por ejemplo,

escribir "Tu edad es", edad

est imprimiendo la cadena constante "Tu edad es" y el contenido de la variable edad.

12

II.6 Lectura de variables

Es la operacin mediante la cual se captura, o se recibe, la informacin proporcionada por
el usuario. El formato es el siguiente

leer variable

donde leer indica la operacin a realizar y variable es el nombre de la variable donde se
almacenar la informacin leda. Por ejemplo, si el usuario proporcionar la edad de una persona
(y declaramos la variable edad para recibirla) esta informacin puede ser capturada por el
algoritmo mediante la instruccin

leer edad

Generalmente, la lectura de variables va precedida de algn mensaje indicando al usuario
la informacin que se est esperando, es decir, la lectura de variables va precedida de una
operacin de escritura. Por ejemplo:

escribir Cuntos aos tienes?
leer edad

Cuando se requiera leer varios valores puede usarse una instruccin de lectura para cada
uno de ellos, o bien, utilizar slo una instruccin de lectura separando con comas las variables
donde se almacenarn los datos.

Por ejemplo, el bloque de instrucciones siguiente

escribir Teclea dos calificaciones
leer c1
leer c2

y el siguiente

escribir Teclea dos calificaciones
leer c1,c2

son equivalentes.

Tambin es posible solicitar la informacin por separado, por ejemplo,

escribir Teclear la calificacin 1
leer c1
escribir Teclear la calificacin 2
leer c2

En este momento, tenemos los elementos necesarios para presentar nuestro primer

13
algoritmo secuencial.

II.7 Primer algoritmo secuencial

La estructura general de los algoritmos que aqu se desarrollan constan de 3 partes: en la primera
se definen los datos de tipo constante, en la segunda se declaran los datos de tipo variable y en la
tercera, se enlistan las instrucciones que se realizarn. El formato mencionado se ilustra en la
Fig. II-2. Todos los algoritmos llevarn, a manera de ttulo, un encabezado con el nmero de
algoritmo y una breve descripcin. Todo lo dems estar delimitado por las instrucciones inicio y
fin con las cuales se indica dnde comienza y dnde termina el algoritmo, respectivamente.
Todas las instrucciones que conforman el algoritmo estn desfasadas un espacio a la derecha con
respecto a los delimitadores (inicio y fin) lo cual mejora la legibilidad del algoritmo. A este
espacio se le llama sangra.

La parte de la definicin de constantes y la declaracin de variables que conforman el
algoritmo en la Fig. II-2 se encuentran entre corchetes lo cual significa que no necesariamente se
utilizarn, es decir, es posible que no se requieran estas operaciones y en tal caso se omiten. El
Ejemplo 1 presenta un algoritmo sencillo que ilustra la utilizacin de este formato.

Ejemplo 1. Solicitar y leer 3 datos de diferente tipo e imprimirlos.

La informacin requerida pueden ser el nombre del usuario (cadena), su edad (entero) y
su peso (real). Para ilustrar el hecho de que es posible realizar las mismas instrucciones de
diferentes maneras se presentan tres versiones de este algoritmo.

En la primera versin, Algoritmo 1a, se solicitan y se leen por separado cada uno de los
datos y se imprimen utilizando slo una instruccin de escritura.

Algoritmo 1a: Lectura e impresin de datos del usuario.
inicio
cadena nombre
entero edad
real peso

escribir Cul es tu nombre?
leer nombre
leer edad
Algoritmo #. Descripcin.
inicio
[definicin de constantes]
[declaracin de variables]

instrucciones a realizar
fin

Fig. II-2: Bosquejo de un algoritmo.

14
escribir Cunto pesas?
leer peso

escribir Hola,nombre,tienes, edad,aos y pesas, peso , kilos
fin

En el Algoritmo 1b, la edad y el peso del usuario se solicitan y leen con una sola
instruccin de escritura y una de lectura, respectivamente. El resto de las instrucciones son
idnticas a las presentadas en el Algoritmo 1a.

Algoritmo 1b: Lectura e impresin de datos del usuario.
inicio
cadena nombre
entero edad
real peso

leer nombre
escribir Cuntos aos tienes y cunto pesas?
leer edad,peso

escribir Hola,nombre,tienes,edad,aos y pesas,peso,kilos
fin

En el Algoritmo 1c, se solicitan y se leen los datos por separado y se imprimen utilizando
varias instrucciones de escritura.

Algoritmo 1c: Lectura e impresin de datos del usuario.
inicio
cadena nombre
entero edad
real peso

leer nombre
leer edad
escribir Cunto pesas?
leer peso
escribir Hola,nombre
escribir Tienes, edad, aos
escribir Pesas, peso , kilos
fin

Existen muchas maneras de escribir algoritmos que respondan adecuadamente a la misma
necesidad, en realidad es cuestin de estilo del programador.

Los algoritmos presentados hasta aqu son sumamente sencillos, tiles nicamente con
fines ilustrativos del esquema que se utilizar en la escritura de algoritmos. Generalmente, se
desarrolla un algoritmo para que resuelva algn problema a travs de la realizacin de la
manipulacin de los valores de entrada. Por ello es necesario conocer la forma en que se operar
con dichos valores en un algoritmo. El resto del captulo se dedica a la presentacin de las
operaciones aritmticas, relacionales y lgicas que usaremos para la manipulacin de los datos

15
de entrada en nuestros algoritmos.

II.8 Operadores aritmticos

Las operaciones aritmticas que manejaremos en seudocdigo son: suma, resta, multiplicacin,
divisin y asignacin. En la Tabla 1 se enlistan las operaciones bsicas y el operador que se
utiliza para indicarla.
Tabla 1: Operadores aritmticos.
Operacin Operador
Suma +
Resta

Multiplicacin *
Divisin real /
Divisin entera DIV
Divisin mdulo MOD
Asignacin '=

Todos los operadores se aplican en forma binaria (con dos operandos) y utilizan
operandos constantes o variables a la izquierda y derecha del operador, segn se requiera,
excepto para el operador de asignacin, el cual requiere de su lado izquierdo una variable.

El operador de asignacin toma su nombre debido a que asigna el valor de la derecha a la
variable de la izquierda, tal como se indica en el formato siguiente

variable =
constante
variable
operacin
funcin

Por ejemplo,

x=2 asigna el valor constante 2 a x
x=y asigna el valor de la variable y a x
x=2+y asigna el resultado de la suma de 2 y el valor de la variable y a x
x=aleatorio(1,5) asigna el valor regresado por la funcin aleatorio() a x (un valor al azar de 1 a 5)
letra='a' asigna el carcter 'a' a letra
cad="Irene" asigna la cadena "Irene" a cad

Los operadores + y tambien pueden ser aplicados en forma monaria, es decir, con un
operando. Regularmente los operadores monarios se anteponen a su operando.

Las operaciones deben escribirse en forma lineal, es decir, en una sola lnea. Por ejemplo,
si se tiene la frmula

b a
x
1 1
+ =

16

debe transformarse para que tome la forma

b a x / 1 / 1 + =

Hay ocasiones en que la transformacin no es tan directa. Por ejemplo, la ecuacin
c x
b a
2
+
=

debe ser transformada para que ocupe una nica lnea pero la divisin entre 2 y la multiplicacin
por c estn afectando al factor a+b. Por lo tanto, ste deber presentarse en la expresin entre
parntesis tal como se muestra a continuacin:

2 / * ) ( c b a x + =
o bien,
c b a x * 2 / ) ( + =

Para que seamos capaces de hacer la transformacin correctamente es necesario conocer
la precedencia de los operadores (es decir, saber que operador se ejecuta primero). En la Tabla 2
se muestra la precedencia de los operadores mencionados, los que estn ms arriba en la tabla
tienen mayor precedencia, los que tienen la misma precedencia se muestran en el mismo rengln
separados por comas. Cuando en una expresin se tienen operadores de la misma precedencia se
van ejecutando de izquierda a derecha, excepto con los operadores monarios y el operador de
asignacin. Si se desea modificar la precedencia, se utilizan los parntesis.

Tabla 2: Precedencia de los operadores aritmticos elementales.
Operadores Asociatividad
() Izquierda a derecha
+ , (monario) Derecha a izquerda
* , /, DIV, MOD Izquierda a derecha
+ , - (binario) Izquierda a derecha
= Derecha a izquerda

Por ejemplo, la expresin
ab
a
a
x
+
+
=
2
5 2

se transforma en

) * 2 / /( ) * 5 2 ( b a a a x + + =

donde los operadores de suma (+) estn aplicndose como binarios y el operador de resta est
siendo utilizado como monario.

17
A continuacin se presenta un par de ejemplos donde se ilustra el uso de algunos de los
operadores aritmticos presentados en esta seccin.

Ejemplo 2. Calcular el rea de un tringulo dadas la base y la altura.

Supngase que se desea encontrar el rea de un tringulo utilizando la frmula
2
bh
A =

para lo cual es necesario conocer los valores de la base y la altura, as que se solicitan al usuario
y, una vez realizadas las operaciones indicadas, se obtiene el valor deseado. Se requieren 3
variables: una para almacenar el valor de la base, otra para el valor de la altura y una ms para
almacenar el resultado de la operacin. Sean las variables mencionadas base, altura y area,
respectivamente. Entonces, la expresin anterior se transforma en

area=base*altura/2

En el Algoritmo 2a se presentan las instrucciones que se requieren para resolver este
problema.

Algoritmo 2a: rea de un tringulo.
inicio
real area,base,altura

escribir Cul es la longitud de la base?
leer base
escribir Cul es la altura?
leer altura
area=base*altura/2

escribir El rea del tringulo es,area
fin

Observamos que la variable area slo se utiliza como auxiliar para almacenar el resultado
de la operacin realizada. Podemos utilizar la expresin de la operacin directamente en la
instruccin de escritura con lo cual nos ahorramos una variable. As, la sentencia de impresin
queda como sigue:

escribir El rea del tringulo es, base*altura/2

En el Algoritmo 2b se incluyen las modificaciones mencionadas.

Algoritmo 2b: rea de un tringulo.
inicio
real base,altura

escribir Cul es la longitud de la base?

18
leer base
escribir Cul es la altura?
leer altura

escribir El rea del tringulo es, base*altura/2
fin

Ejemplo 3. Calcular el rea de un crculo.

Ahora se desea obtener el rea de un crculo mediante la ecuacin
2
r A t =

El usuario debe proporcionar el valor del radio ( r ) y el valor aproximado de t que se
desee utilizar. Si se utilizan las variables radio y pi, respectivamente, la ecuacin anterior se
transforma en
area = pi * radio * radio

A continuacin se muestran dos versiones de implementacin. En el Algoritmo 3a se
utilizan 3 variables, una para el radio, otra para el valor de t y una ms para el resultado.

Algoritmo 3a: rea de un crculo.
inicio
real radio, pi,area

escribir Valor del radio=
leer radio
escribir Valor de pi=
leer pi
area= pi*radio*radio

escribir El rea del crculo con radio,radio, es,area
fin

En el Algoritmo 3b se considera el valor de t como constante de forma que solamente se
solicita el valor del radio.

Algoritmo 3b: rea de un crculo.
inicio

real radio,area

escribir Valor del radio="
leer radio
area= PI*radio*radio

escribir El rea del crculo con radio,radio,es,area
fin

En la siguiente seccin presentaremos dos operadores aritmticos adicionales que sern

19
muy tiles en la solucin de problemas en secciones posteriores.

II.9 Operadores aritmticos MOD y DIV

Estos operadores aritmticos se utilizan para realizar divisiones con enteros cuyo resultado es
tambin un entero. El operador DIV obtiene la parte entera del cociente y el operador MOD
obtiene el residuo de la divisin entera. Por ejemplo:

x= 7 DIV 3 asigna 2 a x
x= 7 MOD 3 asigna 1 a x

En la Fig. II-3 se ilustra el funcionamiento de estos operadores.

En los siguientes ejemplos se utilizan estos operadores a manera de ilustracin.

Ejemplo 4. Uso de los operadores MOD y DIV.

Se solicita al usuario que proporcione dos valores enteros y se opera con ellos utilizando
los operadores MOD y DIV mostrando el resultado.

Algoritmo 4: Usando los operadores de divisin entera.
inicio
entero x,y

escribir Escribe un nmero entero
leer x
escribir Escribe un nmero entero
leer y

escribir El cociente de la divisin entera de", x , "entre",y, "es",x DIV y
escribir "El residuo de la divisin entera de", x , "entre",y, "es",x MOD y
fin

Ejemplo 5. Separar un nmero entero en sus dgitos correspondientes.

Para empezar, se debe leer el nmero entero que se desea descomponer, x. Supngase que
los dgitos se numeran de izquierda a derecha como d1, d2, d3, d4 y d5 respectivamente. El
dgito d1 se obtendr al dividir a x entre 10000 con el operador DIV. Para obtener el resto de los
dgitos es necesario eliminar a d1 de x para lo cual se calcula el residuo de la divisin de x entre
1
2
7 3
7 DIV 3
7 MOD 3
Fig. II-3: Funcionamiento de los operadores DIV y MOD.

20
10000 con el operador MOD y como este valor se utilizar para obtener otro dgito, se puede
almacenar en x. Luego, se calcula la divisin entera de x entre 1000 para obtener d2. Para obtener
d3, primero se actualiza el valor de x al dividirla entre 1000 con el operador MOD. El proceso se
repite hasta obtener el dgito d5. Una vez obtenidos los cinco dgitos se mandan a imprimir. En la
Fig. II-4 se ilustra con un ejemplo el mtodo descrito y en el Algoritmo 5 se presentan las
instrucciones referidas.

Algoritmo 5: Separacin de un entero en dgitos.
inicio
entero x,d1,d2,d3,d4,d5

escribir Escribe un nmero entero de cinco cifras"
leer x

d1=x DIV 10000
x=x MOD 10000

d2=x DIV 1000
x=x MOD 1000

d3=x DIV 100
x=x MOD 100

d4=x DIV 10
d5=x MOD 10

escribir 1er. dgito :", d1
escribir 2do. dgito :", d2
escribir 3er. dgito :", d3
escribir 4to. dgito :", d4
escribir 5to. dgito :", d5
fin

II.10 Operadores relacionales

Los operadores relacionales sirven para formar expresiones lgicas, es decir, expresiones cuyo
valor es VERDADERO o FALSO. A estos valores se les conoce como valores de verdad o de
certeza. Por ejemplo, consideremos la expresin

b a <

Fig. II-4: Dividiendo el nmero 65398 en sus dgitos componentes.
8
d5
d4
98
9
10
d3
398
98
3
100
d1
65398
5398
6
10000
d2
5398
398
5
1000

21
cuyo valor de verdad puede ser VERDADERO o FALSO dependiendo de los valores de a y de b,
as pues, si a=4 y b=10 la expresin toma el valor VERDADERO mientras que si a=5 y b=1, toma
el valor FALSO.

Otro ejemplo del uso de los operadores relacionales se muestra en la expresin

' ' f a >

donde se compara el contenido de una variable con respecto a un carcter. La variable a puede
ser de tipo entero o caracter, en ambos se utiliza para la comparacin el orden establecido en la
tabla de cdigos ASCII. As pues, si a='c', la expresin anterior es FALSO, en cambio si a='r', es
VERDADERO; si a=20, la expresin es FALSO pues el ASCII de 'f' es 102.

En la Tabla 3 se muestran los operadores relacionales.

Tabla 3: Operadores de relacin o relacionales.
Smbolo
matemtico
Nombre Smbolo en
seudocdigo
< Menor que <
s
Menor o igual que <=
> Mayor que >
>
Mayor o igual que >=
= Igualdad lgica ==
=
Desigualdad lgica NOT=

As pues, una expresin como a=b se transforma en a NOT= b y, una como asb se
transforma en a<=b.

Una expresin como las anteriores se conoce como expresin lgica simple. Mediante
operaciones entre expresiones lgicas simples se obtienen expresiones lgicas compuestas. En la
seccin siguiente presentaremos los operadores que utilizaremos para formar estas ltimas.

II.11 Operadores lgicos

Una expresin lgica compuesta se forma utilizando operadores relacionales y los operadores
lgicos AND, OR y NOT. Los operadores AND y OR requieren dos operandos lgicos, mientras
que el operador NOT requiere un solo operando; dichos operandos generalmente se obtienen
como resultado de evaluar expresiones lgicas simples, y dan como resultado otro valor de
verdad.

En la Tabla 4 se muestran los valores de verdad para el operador AND aplicado a los
valores x y y, donde f representa un valor FALSO y v, VERDADERO.

22
Por ejemplo, considere la expresin compuesta

a>b AND c<=d

Cuando a=10, b=3, c=1 y d=1, el trmino a>b toma el valor VERDADERO, adems c<=d es
VERDADERO, as que la expresin compuesta es VERDADERO.

Tabla 4: Tabla de verdad del operador lgico AND.
x y x AND y
f f f
f v f
v f f
v v v

En la Tabla 5, se muestran los valores de verdad para el operador OR.

Tabla 5: Tabla de verdad para el operador lgico OR.
x y x OR y
f f f
f v v
v f v
v v v

Por ejemplo, considere la expresin

a==1 OR b NOT= 0

Cuando a=7 y b=15, la expresin a==1 es FALSO, b NOT= 0 es VERDADERO y la expresin
compuesta toma el valor VERDADERO; por el contrario, cuando a=6 y b=0, es FALSO.

En la Tabla 6 se muestran los valores de verdad del operador NOT.

Tabla 6: Tabla de verdad del operador lgico NOT.
x NOT x
f v
v f

Por ejemplo, la expresin
NOT(a<6)
es VERDADERO cuando a=10 y cuando a=1, es FALSO.

23

II.12 Leyes de DeMorgan

Las leyes de DeMorgan hacen posible escribir una expresin lgica compuesta de dos
formas diferentes y, sin embargo, ser equivalentes. Esto debe tenerse en cuenta al comparar los
algoritmos realizados por diferentes personas, pues es muy posible que difieran en apariencia
pero que ambos estn escribiendo correctamente las instrucciones requeridas para resolver la
situacin planteada. En la Fig. II-5 se muestran las leyes de DeMorgan, donde x1 y x2 son
expresiones lgicas simples o compuestas.

Por ejemplo:
NOT( x+y>0 AND x>=0 ) NOT(x+y>0) OR NOT (x>=0)

Note que utilizamos parntesis en cada expresin donde se aplica una operacin NOT
para indicar que sta ser evaluada despus de la expresin que aparece dentro de ellos; pero no
utilizamos parntesis para indicar que la suma debe realizarse antes de la comparacin en la
expresin x+y>0. Esto se debe a que el operador + tiene mayor precedencia que >.

En la Tabla 7 se muestra un resumen de las precedencias de los operadores presentados
hasta el momento.
Tabla 7: Precedencia de los operadores.
Operadores
()
NOT , + , - (monario)
* , / , MOD , DIV
+ , - (binario)
< , <= , > , >=
NOT=
AND
OR
=

Con esto terminamos de presentar los elementos bsicos de la programacin en
seudocdigo.

Los algoritmos vistos hasta aqu constan de instrucciones que se ejecutan de manera
secuencial, es decir, se inicia con la ejecucin de la primera instruccin, seguida de la ejecucin
NOT(x1 AND x2) NOT x1 OR NOT x2

NOT(x1 OR x2) NOT x1 AND NOT x2

Fig. II-5: Leyes de DeMorgan.

24
de la segunda, etc., adems, cada una de las instrucciones se ejecuta una nica vez. Esta forma de
programar es til cuando se consideran problemas un tanto sencillos pero en general es necesario
tener mecanismos que permitan decidir entre la ejecucin de una instruccin (o un conjunto de
instrucciones) y otra, as como para permitir que se ejecuten en ms de una ocasin. Esto es lo
que permiten hacer las estructuras de control: elegir qu instrucciones se van a ejecutar cada vez.
Hay tres tipos de estructuras de control: la secuenciacin (vista en el Captulo II), la seleccin y
la repeticin. Estos ltimos dos temas se presentarn en los captulos III y IV, respectivamente.

25
Seleccin

La seleccin es una estructura de control que permite seleccionar el curso de ejecucin de
algunas instrucciones del programa en base al cumplimiento de alguna condicin. Existen tres
tipos de seleccin: simple, doble y mltiple. En las siguientes secciones se estudia cada una de
ellas.

II.13 Seleccin simple

La seleccin simple es una estructura de control que permite decidir si se ejecuta o no, un
conjunto de instrucciones. Dicha estructura se vale de una expresin lgica (simple o compuesta)
llamada condicin para decidir el flujo de acciones que se ejecutarn. El formato de la seleccin
simple se muestra en la Fig. III-1.

El flujo de acciones toma la siguiente lnea: Si condicin es VERDADERO, entonces se
ejecuta el bloque de instrucciones dentro de la estructura, en caso contrario se ignora. El fin del
bloque de instrucciones a ejecutar cuando condicin es VERDADERO se especifica con la
sentencia fin si.

A continuacin presentamos algunos ejemplos que ilustran el uso de esta estructura.

Ejemplo 6. Encontrar el menor de dos nmeros.

Supngase que se tienen dos valores almacenados cada uno en las variables a y b,
respectivamente; y se desea compararlos de forma que se imprima el menor de ellos. Las
instrucciones que se requieren para identificar si el menor es a son las siguientes:

si a<b entonces
escribir el menor es, a
fin si

Para identificar si el menor es b, es necesario modificar la condicin y la instruccin de
escritura. Los cambios realizados se muestran a continuacin:

si a>b entonces
escribir el menor es, b
fin si

En el Algoritmo 6 se muestran las instrucciones para resolver este problema
si condicin entonces
Bloque de instrucciones a realizar si la condicin es verdadera
fin si
Fig. III-1: Formato de la seleccin simple.

26
considerndose adems la posibilidad de que los valores dados sean iguales, incluyendo para
esto, otra seleccin con la condicin a==b.

Algoritmo 6: Encontrar el menor de dos nmeros dados.
inicio
real a, b

escribir Valor de a
leer a
escribir Valor de b
leer b
si a<b entonces
escribir El menor es,a
fin si
si a>b entonces
escribir El menor es,b
fin si
si a==b entonces
escribir Son iguales
fin si
fin

Ejemplo 7. Determinar si un nmero entero dado es par.

Almacenaremos el nmero en cuestin en la variable n. Para identificar si n es par
utilizaremos el operador MOD ya que si n MOD 2 da como resultado el valor 0, entonces la
divisin de n entre 2 tiene residuo cero, lo cual significa que n es par; de aqu que si la condicin
n MOD 2 == 0 es VERDADERO, n es par; pero si n MOD 2 NOT= 0, entonces n es impar. En el
Algoritmo 7 se muestra el proceso completo.

Algoritmo 7: Paridad de un nmero entero.
inicio
entero n

escribir n=
leer n
si n MOD 2 == 0 entonces
escribir El nmero,n,es par
fin si
si n MOD 2 NOT= 0 entonces
escribir El nmero,n,es impar
fin si
fin

Ejemplo 8. Contratacin de un empleado.

Suponer que se aplican dos exmenes a un aspirante a trabajador y que slo si obtiene
calificicacin mayor de 80 en ambas, se contrata. Suponer que los resultados de las calificaciones
estn almacenados en las variables c1 y c2. Esta situacin podra plantearse como se muestra en
el Algoritmo 8, donde una vez obtenidas las calificaciones c1 y c2, se procede a examinarlas para

27
enviar el mensaje correspondiente segn el caso. El problema especifica que slo en el caso de
que ambas calificaciones sean mayores de 80 se contratar al aspirante; as pues, el operador
AND es el que se adecua a esta situacin. Tambin hay que mandar un mensaje en el caso en que
no sea aceptado, es decir, la situacin contraria que queda expresada en la segunda seleccin en
el algoritmo. Ntese que es necesario el uso de parntesis pues el operador NOT tiene mayor
precedencia que el operador AND (vase la Tabla 7).

Algoritmo 8: Para un empleado y dos calificaciones dadas, se contrata si obtuvo ms de 80 en ambas.
inicio
real c1, c2

escribir Calificacin 1=
leer c1
escribir Calificacin 2=
leer c2
si c1>80 AND c2>80 entonces
escribir Contratado
fin si
si NOT(c1>80 AND c2>80) entonces
escribir NO contratado
fin si
fin

Para plantear la situacin en que no se contrata a la persona, puede utilizarse tambin la
condicin equivalente c1<=80 OR c2<=80, lo cual se deduce de una de las leyes de DeMorgan
ilustradas en la Fig. II-5, ya que

NOT(c1>80 AND c2>80) NOT(c1>80) OR NOT(c2>80) c1<=80 OR c2<=80

Obsrvese que en los ltimos dos ejemplos se han utilizado dos selecciones simples cuyas
condiciones son complementarias, es decir, cuando una es FALSO la otra es VERDADERO, y
viceversa; con lo cual, aseguramos que solamente uno de los dos bloques ser ejecutado. Esta
situacin puede plantearse de forma ms compacta utilizando una seleccin doble, sta ser
presentada en la siguiente seccin.

II.14 Seleccin doble

La seleccin simple est limitada a especificar las acciones a realizar cuando la condicin lgica
es VERDADERO, pero no especifica qu hacer cuando es FALSO. La seleccin doble considera
ambos casos, pues especifica las operaciones a realizar para cada uno de los valores de la
condicin lgica. La primera parte de la seleccin doble contina siendo igual a la simple, es
decir, si la condicin lgica es VERDADERO, se realizan las operaciones especificadas por el
primer bloque de instrucciones, pero si la condicin es FALSO se realizan las instrucciones
indicadas en el segundo bloque cuyo inicio se indica con las palabras si no. El fin de la seleccin
es determinada por la instruccin fin si. El formato se ilustra en la Fig. III-2.

28

Los siguientes ejemplos ilustran el uso de esta estructura de control.

Ejemplo 9. Encontrar el mayor de dos nmeros dados.

Se tienen dos valores almacenados, a y b, y se deben comparar para identificar cul de
ellos es el mayor. En el Ejemplo 6 se analiz un problema similar. En esta seccin se resolver
utilizando una seleccin doble tal como se muestra en el Algoritmo 9a y en el Algoritmo 9b.

Algoritmo 9a: Encontrar el mayor de dos nmeros dados.
inicio
real a,b

escribir Valor de a=
leer a
escribir Valor de b=
leer b
si a>b entonces
escribir El mayor es,a
si no
escribir El mayor es,b
fin si
fin

Obsrvese que el caso de que la condicin a>b sea FALSO incluye la igualdad. Es decir,
si a es igual a b se escribir un letrero indicando que el mayor es b. Si nos interesa identificar el
caso en que son iguales podemos utilizar el Algoritmo 9b.

Algoritmo 9b: Encontrar el mayor de dos nmeros dados.
inicio
real a,b

leer a
leer b
si a>b entonces
si no
si a<b entonces
si no
escribir "Son iguales"
si condicin entonces
Bloque de instrucciones a realizar si la condicin es verdadera.
sino
Bloque de instrucciones a realizar si la condicin es falsa.
fin si
Fig. III-2: Formato de la seleccin doble.

29
fin
fin si
fin

Obsrvese que en caso de que la condicin a>b sea FALSO, an es necesario considerar dos casos:
a<b y a==b. Por ello se utiliza de nuevo una seleccin doble. A esta forma de programar se le
conoce como anidamiento. En general, es posible anidar tantas sentencias de seleccin (simple
o doble) como sean necesarias.

Ejemplo 10. Encontrar el mayor de tres nmeros dados.

En este problema se tienen 3 valores de entrada: a, b y c. Es necesario compararlos entre
s para obtener el mayor de ellos. Hay varias formas de hacer un algoritmo que resuelva este
problema. Se presentarn cuatro de ellas. En el Algoritmo 10a se utilizan 10 estructuras de
seleccin simple, tres de ellas estn comparando cada uno de los valores para encontrar el mayor
absoluto, una para verificar si ocurri la igualdad y el resto para buscar el mayor cuando hay dos
nmeros iguales.

Algoritmo 10a: Encontrar el mayor de tres nmeros dados.
inicio
real a,b,c

leer a
leer b
escribir Valor de c=
leer c
si a>b AND a>c entonces
fin si
si b>a AND b>c entonces
fin si
si c>a AND c>b entonces
escribir El mayor es,c
fin si
si c==a AND c==b entonces
escribir Son iguales"
fin si
si a==b AND a>c entonces
fin si
si a==b AND a<c entonces
fin si
si a==c AND a>b entonces
fin si
si a==c AND a<b entonces
fin si
si b==c AND b>a entonces

30
fin si
si b==c AND b<a entonces
fin si
fin

Considrese el caso donde se est buscando determinar si el mayor es el valor a. La
estructura de la seleccin se utiliza de la manera siguiente

si a>b AND a>c entonces
fin si

Obsrvese que esta expresin es equivalente a la utilizacin de dos estructuras de seleccin
simple anidadas. Es decir, la expresin anterior es equivalente a:

si a>b entonces
si a>c entonces
fin si
fin si

En el Algoritmo 10b, se presenta otra versin para resolver el problema de encontrar el
mayor de tres nmeros dados, utilizando anidamiento de estructuras de seleccin.

Algoritmo 10b: Encontrar el mayor de tres nmeros dados.
inicio
real a,b,c

leer a
leer b
leer c
si a>b entonces
si a>c entonces
fin si
fin si
si b>a entonces
si b>c entonces
fin si
fin si
si c>a entonces
si c>b entonces
fin si
fin si
si a==b entonces
si b==c entonces
escribir Son iguales"
fin si

31
fin si
si a==b entonces
si a>c entonces
fin si
fin si
si a==b entonces
si a<c entonces
fin si
fin si
si a==c entonces
si a>b entonces
fin si
fin si
si a==c entonces
si a<b entonces
fin si
fin si
si b==c entonces
si b>a entonces
fin si
fin si
si b==c entonces
si b<a entonces
fin si
fin si
fin

En el Algoritmo 10c se muestra una versin con anidamiento de selecciones dobles. Se
busca determinar primero el caso en que se da la igualdad de los tres valores dados. En caso de
que no se cumpla la condicin de igualdad se procede a buscar cul es el mayor (incluyendo el
caso en que haya dos iguales).

Algoritmo 10c: Encontrar el mayor de tres nmeros dados.
inicio
real a,b,c

leer a
leer b
leer c
si a==b AND a==c entonces
sino
si a>=b AND a>=c entonces
si no
si b>=c entonces
si no

32
fin si
fin si
fin si
fin

El Algoritmo 10d utiliza una variable auxiliar, mayor, inicializada con el valor de uno de
los valores considerados, en este caso a, despus procede a hacer las comparaciones de mayor
con los otros dos valores, b y c, por separado, y, si es necesario, modifica el valor de mayor.

Algoritmo 10d: Encontrar el mayor de tres nmeros dados.
inicio
real a,b,c,mayor

leer a
leer b
leer c
si a==b AND b==c entonces
si no
mayor=a
si b>mayor entonces
mayor=b
fin si
si c>mayor entonces
mayor=c
fin si
escribir "El mayor es ", mayor
fin si
fin

Se aplican dos exmenes a un trabajador. Slo si obtiene ms de 80 en ambos, se
contrata. Considere el problema del Ejemplo 8 con la variante de que esta vez se utiliza seleccin
doble. En el Algoritmo 11 se presenta esta nueva versin.

Algoritmo 11: Para un empleado y dos calificaciones dadas, se contrata si obtuvo ms de 80 en ambas.
inicio
real c1, c2

escribir Calificacin 1
leer c1
leer c2
si c1>80 AND c2>80 entonces
escribir Contratado
si no
fin si
fin

33


Se aplican dos exmenes a un aspirante a trabajador y slo si obtiene calificacin mayor
de 80 en al menos uno de ellos ser contratado. En este caso el operador lgico requerido es el
operador OR, tal como se muestra en el Algoritmo 12a.

Algoritmo 12a: Para un empleado y dos calificaciones dadas, se contrata si obtuvo ms de 80 en al menos
uno de los exmenes.
inicio
real c1, c2

leer c1
leer c2
si c1>80 OR c2>80 entonces
escribir Contratado
si no
fin si
fin

En el Algoritmo 12b, se muestra una segunda implementacin utilizando una variante de
la seleccin doble donde se invierte el orden de los mensajes enviados al usuario.

Algoritmo 12b: Para un empleado y dos calificaciones dadas, se contrata si obtuvo ms de 80 en al menos
uno de los exmenes.
inicio
real c1, c2

leer c1
leer c2
si c1<=80 AND c2<=80 entonces
escribir NO Contratado
si no
escribir Contratado
fin si
fin

Ejemplo 13. Dado un nmero entero entre 1 y 7 indquese a que da de la semana corresponde.

Considerar que los das de la semana se numeran a partir del lunes. Se presentan dos
versiones de un algoritmo que plantea esta situacin. En el Algoritmo 13a, se utilizan varias
selecciones simples cada una de las cuales considera un posible caso. As, se considera que la
variable dia, donde se almacen el valor ledo, puede tomar cualesquiera de los valores 1, 2, ..., 7
y se considera, adicionalmente, el caso en que dia tom un valor diferente a los especificados.

34
Este ltimo caso es necesario pues an cuando al usuario se le solicita un valor entre 1 y 7, es
posible que proporcione un valor que no est en el rango mencionado (por error o de forma
intencional), en este caso, hay que enviar un mensaje al usuario indicando cul es la situacin.

Algoritmo 13a: Da de la semana.
inicio
entero dia

escribir Escribe un nmero entre 1 y 7
leer dia
si dia==1 entonces
escribir Lunes
fin si
si dia==2 entonces
escribir Martes
fin si
si dia==3 entonces
escribir Mircoles
fin si
si dia==4 entonces
escribir Jueves
fin si
si dia==5 entonces
escribir Viernes
fin si
si dia==6 entonces
escribir Sbado
fin si
si dia==7 entonces
escribir Domingo
fin si
si dia<1 OR dia>7 entonces
escribir Valor fuera de rango
fin si
fin

En el Algoritmo 13b, se plantea la situacin de manera diferente: se consideran varias
estructuras de seleccin dobles anidadas, cada una considerando una posibilidad para el valor de
la variable dia. En la seleccin ms interna se considera la situacin en que el valor dado por el
usuario no ha sido ninguno de los considerados en el rango deseado, y por lo tanto, se enviar un
mensaje al usuario mencionando el error cometido.

Algoritmo 13b: Da de la semana.
inicio
entero dia

leer dia
si dia==1 entonces
escribir Lunes
si no
si dia==2 entonces
escribir Martes
si no
si dia==3 entonces

35
escribir Mircoles
si no
si dia==4 entonces
escribir Jueves
si no
si dia==5 entonces
escribir Viernes
si no
si dia==6 entonces
escribir Sbado
si no
si dia==7 entonces
escribir Domingo
si no
escribir Valor fuera de rango
fin si
fin si
fin si
fin si
fin si
fin si
fin si
fin

Ntese la diferencia entre ambas versiones del algoritmo 13: en la ejecucin del
Algoritmo 13a, se deben revisar cada una de las condiciones para ver si se cumplen de forma
individual as que se realizan 8 comparaciones. En cambio, en Algoritmo 13b se revisan las
diferentes condiciones hasta que una de ellas es verdadera de tal forma que se realizan a lo ms 7
comparaciones.

Existe una estructura que simplifica mucho el uso de la seleccin simple y doble cuando
se tienen casos como el del ltimo ejemplo, nos referimos a la seleccin mltiple presentada en
la siguiente seccin.

II.15 Seleccin mltiple

Cuando se tienen que revisar mltiples comparaciones de equivalencia como en el Ejemplo 13,
es mejor utilizar la seleccin mltiple pues, como mencionamos, simplifica el procedimiento. El
formato a utilizar se muestra en la Fig. III-3.

seleccion variable_selectora
valor
1
: Bloque de instrucciones a realizar si variable_selectora vale valor
1

valor
2
2
.

valor
n
n

[en otro caso:
Bloque de instrucciones a realizar si variable_selectora toma un valor diferente.]
fin seleccion

Fig. III-3: Formato para la seleccin mltiple.

36

Donde variable_selectora puede ser de tipo entero o caracter nicamente.

Se muestra un listado con los posibles valores de variable_selectora (valor
1
, valor
2
, ...,
valor
n
) acompaados por el bloque de instrucciones que se realizarn en cada caso. As, si
variable_selectora toma valor valor
1
se ejecutar el bloque de instrucciones que se encuentra
indicado, y as sucesivamente. Cuando variable_selectora toma un valor diferente a los de la
lista se ejecutar el bloque de instrucciones por defecto. Cabe aclararse que esta ltima seccin
de la estructura es opcional, es decir, puede omitirse, en cuyo caso no se ejecutar accin alguna
cuando variable_selectora toma un valor no considerado en la lista.

La implementacin del algoritmo 13 utilizando seleccin mltiple se presenta en el
Algoritmo 13c.

Algoritmo 13c: Da de la semana.
inicio
entero dia

leer dia
seleccion dia
1: escribir Lunes
2: escribir Martes
3: escribir Mircoles
4: escribir Jueves
5: escribir Viernes
6: escribir Sbado
7: escribir Domingo
en otro caso: escribir Valor fuera de rango
fin seleccion
fin

Ejemplo 14. Piedra, papel y tijeras (juego).

Para este juego se requieren dos jugadores. Cada uno de ellos debe seleccionar una de las
opciones (piedra, papel o tijeras) de forma independiente. Las reglas del juego para determinar
quin gana segn la seleccin hecha por cada jugador se presentan en la Tabla 8. En caso de que
ambos seleccionen la misma opcin se declara un empate.
Tabla 8: Reglas del juego PPT.
J uegan Regla Ganador
Piedra Papel El papel cubre a la piedra Papel
Piedra Tijeras La piedra rompe las tijeras Piedra
Papel Tijeras Las tijeras rompen el papel Tijeras

Para desarrollar un algoritmo que implemente este juego es necesario que cada jugador
seleccione su opcin sin que el otro se entere. Dado que esto no es posible, uno de los jugadores
ser la misma mquina que elegir su opcin sin considerar la opcin del usuario y sin
mostrrsela para que ste no acte en consecuencia. As pues, al usuario se le preguntar por la

37
opcin que desea seleccionar mientras que la mquina deber hacer la eleccin al azar.
Al usuario se le muestra una lista con las opciones: piedra, papel y tijeras; y un nmero
asociado a cada opcin: 1, 2 y 3, respectivamente. Se le pide que proporcione el nmero que
corresponde a su eleccin (al listado de opciones se le llama men). Para simular la eleccin de
la mquina se utilizar la funcin aleatorio(1,3) y cada uno de los valores se hace corresponder
con una opcin: piedra, papel o tijeras. De esta manera, ya se tienen las elecciones de los dos
jugadores y nicamente es necesario considerar las reglas del juego para elegir un ganador o
declarar empate. El Algoritmo 14 contiene las instrucciones para implementar el juego.

Algoritmo 14: Piedra, papel y tijeras.
inicio
entero jugador, maquina

(* seleccin de la mquina *)
maquina=aleatorio(1,3)

(* seleccin del usuario *)
escribir Teclea el nmero que corresponde a tu seleccin
escribir 1) Piedra
escribir 2) Papel
escribir 3) Tijeras
leer jugador

escribir "El jugador eligi ", jugador
escribir "La mquina eligi ", maquina

si maquina==jugador entonces
escribir Empate
si no
seleccion jugador
1: (* piedra *)
seleccion maquina
2: (* papel *)
escribir Gana la mquina
3: (* tijeras *)
escribir Gana el jugador
fin seleccion
2: (* papel *)
seleccion maquina
1: (* piedra *)
3: (* tijeras *)
fin seleccion
3: (* tijeras *)
seleccion maquina
1: (* piedra *)
2: (* papel *)
fin seleccion
en otro caso: escribir Seleccin del jugador no vlida
fin seleccin
fin si
fin

38

Nota: Cuando se requiere incluir comentarios aclarativos o notas personales en el algoritmo se utilizan los
smbolos "(*" y "*)" para delimitarlos. En el Algoritmo 14 se utilizaron en repetidas ocasiones, esto favorece
la claridad del algoritmo.

Se ha presentado nicamente una versin de un algoritmo que implemente esta situacin,
pero es posible presentar varias versiones alternativas. Como ejercicio, se deja al lector que
realice al menos una de ellas, por ejemplo, sin utilizar seleccin mltiple.

Ejemplo 15. El juego del 7.

En este juego participa un jugador y se requieren dos dados. El jugador tira ambos dados
y suma las caras superiores. Previamente, se hace una apuesta sobre lo que ser la suma de los
dados (abajo de 7, 7 arriba de 7). En caso de que haya apostado a que la suma sera abajo del
siete y acert, gana la suma apostada. Lo mismo cuando apost arriba del 7. En caso de que haya
elegido el 7 y acierta, gana el triple de la apuesta. Obsrvese que no importan las combinaciones
de nmeros obtenidos sino la suma de los mismos. En caso de no acertar, pierde la cantidad
apostada. Obviamente, las probabilidades siempre estn en contra del jugador (sobre todo si elige
el 7).

Para la elaboracin del algoritmo que implemente este juego se requiere simular el
lanzamiento de dos dados, para lo cual se utilizar la funcin aleatorio() dos veces, una por cada
dado y se sumarn los resultados obtenidos

dado1 = aleatorio (1,6)
dado2 = aleatorio (1,6)
suma_dados = dado1 + dado2

Obsrvese que no es correcto utilizar la funcin aleatorio(1,12) pues aunque se estaran
considerando los valores 1, 2, ..., 12, el 1 no es un valor que pueda obtenerse al lanzar dos dados.
Es posible utilizar la expresin aleatorio(1,11)+1 con lo cual estaramos obteniendo valores del 2
al 12 pero dicha expresin no simulara el lanzamiento de dos dados puesto que la probabilidad
de ocurrencia de cada resultado se ve afectada.

Es necesario considerar las variables que representen la apuesta, la seleccin del usuario,
los dados y la suma de los dados. Se presentan tres versiones de implementacin del juego. De
nuevo, es posible desarrollar versiones distintas que sean igualmente vlidas. En el Algoritmo
15a se presenta una de las versiones consideradas.

Algoritmo 15a: Juego del 7.
inicio
entero jugador, dado1, dado2, suma_dados
real apuesta, capital

(* simulando los dados *)
dado1=aleatorio(1,6)

39
suma_dados=dado1+dado2

escribir Capital=
leer capital

escribir Cunto apuestas?
leer apuesta

si apuesta <= capital entonces
escribir Teclea el nmero que corresponde a tu seleccin:
escribir 1) Abajo del 7
escribir 2) 7
escribir 3) Arriba del 7
leer jugador

escribir Cay , dado1, y , dado2
si jugador==1 AND suma_dados<7 entonces
escribir Ganaste , tu capital es ahora de, capital + apuesta
si no
si jugador==2 AND suma_dados==7 entonces
escribir Ganaste , tu capital es ahora de , capital + 3*apuesta
si no
si jugador==3 AND suma_dados>7 entonces
escribir Ganaste , tu capital es ahora de , capital + apuesta
si no
escribir Perdiste , tu capital es ahora de , capital - apuesta
fin si
fin si
fin si
si no
escribir No puedes apostar ms de lo que tienes...
fin si
fin

En el Algoritmo 15b, se agrupan los casos en que el usuario gana, pues en ambos casos se
realiza la misma operacin. Adems, se eliminan dos variables, dado1 y dado2, al observar que
slo se utilizan para obtener el valor suma_dados.

Algoritmo 15b: Juego del 7.
inicio
entero jugador, suma_dados

suma_dados=aleatorio(1,6)+aleatorio(1,6)
escribir Capital=
leer capital

leer apuesta

escribir Teclea el nmero que corresponde a tu seleccin:
escribir 2) 7

40
leer jugador

escribir Suma de los dados: , suma_dados

si jugador==1 AND suma_dados<7 OR jugador==3 AND suma_dados>7 entonces
escribir Ganaste , tu capital es ahora de , capital + apuesta
si no
si jugador==2 AND suma_dados==7 entonces
escribir Ganaste , tu capital es ahora de , capital + 3*apuesta
si no
escribir Perdiste , tu capital es ahora de , capital - apuesta
fin si
fin si
si no
fin si
fin

En el Algoritmo 15c se utiliza una seleccin mltiple que considera todas las
posibilidades para la opcin del usuario y en cada caso se determina quien gana utilizando la
seleccin doble.

Algoritmo 15c: Juego del 7.
inicio
entero jugador, suma_dados,dado1,dado2

suma_dados=dado1+dado2
escribir Capital=
leer capital
leer apuesta
escribir 2) 7
leer jugador
escribir Suma de los dados: , suma_dados
seleccion jugador
1: si suma_dados<7 entonces
escribir Ganaste"
capital = capital+apuesta
si no
escribir Perdiste"
capital = capital-apuesta
fin si
2: si suma_dados==7 entonces
escribir Ganaste"
capital = capital+3*apuesta
si no
escribir Perdiste"

41
fin si
3: si suma_dados>7 entonces
escribir Ganaste"
capital = capital+apuesta
si no
escribir Perdiste "
fin si
en otro caso:
escribir "Seleccin incorrecta"
fin seleccion
escribir "Tu capital es de ",capital
si no
fin si
fin

Con esto, termina el tema de la seleccin. En el siguiente captulo se presentan las
distintas formas de repeticin de instrucciones dentro de un algoritmo.

42
III Ciclos

Una de las caractersticas de las computadoras es su capacidad para ejecutar una tarea en
repetidas ocasiones con gran velocidad, precisin y fiabilidad. Las tareas repetitivas son algo que
los humanos encontramos difciles y tediosas de realizar. En esta seccin se presentan las
estructuras de control iterativas o repetitivas que realizan la repeticin de acciones. Estas
estructuras controlan el nmero de veces que una sentencia o lista de sentencias se ejecuta.

Las sentencias que se repiten forman un bloque que se llama el cuerpo del ciclo y cada
repeticin del cuerpo del ciclo se llama una iteracin del ciclo.

En este captulo se vern tres tipos de ciclos: mientras-hacer, para-hacer y hacer-
mientras.

III.1 Ciclo mientras hacer

Este ciclo se vale de una condicin (expresin lgica) para controlar la repeticin del cuerpo del
ciclo. Esta condicin se encuentra antes del cuerpo del ciclo lo cual significa que debe evaluarse
la condicin previamente para saber si el cuerpo del ciclo se ejecutar. El formato se muestra en
la Fig. IV-1. Si la condicin es verdadera, se ejecutan las instrucciones que conforman el cuerpo
del ciclo hasta que se encuentra la seal de finalizacin: fin mientras. En ese momento, el control
regresa al inicio del ciclo, es decir, a la evaluacin de la condicin. Cuando la condicin es falsa
no se ejecuta el cuerpo del ciclo y se rompe. Obsrvese que si la condicin es falsa durante la
primera evaluacin entonces no se ejecuta el cuerpo del ciclo ni una vez.

Cuando se sabe de antemano el nmero de veces que se repetir la ejecucin del ciclo, se
utiliza una variable que "cuente" el nmero de veces que se ha ejecutado, a este tipo de variables
se les llama contadores. As pues, cuando el contador utilizado alcance un cierto valor,
determinado de antemano, el ciclo se rompe. Por ejemplo, el siguiente segmento de cdigo

entero c
c=1
mientras c<=5 hacer
escribir "Hola, mundo."
c=c+1
fin mientras

utiliza la variable c como contador el cual se inicializa en 1 y se incrementa de uno en uno con la
mientras condicin hacer
bloque de instrucciones a realizar si condicin es verdadera.
fin mientras
Fig. IV-1: Estructura del ciclo mientras-hacer.

43
operacin c=c+1 hasta alcanzar el valor 6 que hace que la condicin controladora del ciclo sea
falsa y el ciclo se rompe, as, se imprimirn los mensajes siguientes

Hola, mundo.
Hola, mundo.
Hola, mundo.
Hola, mundo.
Hola, mundo.

Este ciclo se repite en cinco ocasiones. Cabe hacer notar que el control del ciclo est
determinado por 3 operaciones sobre el contador: inicializacin, condicin e incremento, los
cuales pueden manipularse para que se repitan el mismo nmero de veces aunque los valores
generados para el contador sean diferentes. As, el segmento anterior puede cambiarse por el
siguiente

entero c
c=15
mientras c<=27 hacer
escribir "Hola, mundo."
c=c+3
fin mientras

y obtener el mismo resultado (salida). Obsrvese que en este caso, el contador se inicializa en 15,
se incrementa de 3 en 3 con la operacin c=c+3 y se rompe el ciclo cuando sobrepasa el valor 27.
En general, un contador se incrementa con la operacin

contador = contador +constante

donde constante es un valor entero distinto de cero (negativo o positivo).

Es importante mencionar que el uso de los contadores no se restringe a ser controladores
del ciclo sino que puede ser necesario, debido a las caractersticas del problema, contar la
ocurrencia de algn suceso. Por ejemplo, considrese el siguiente segmento de cdigo en el que
se tiene un ciclo controlado por c1 donde en cada iteracin se lee un valor y se revisa si es cero
en cuyo caso, se incrementa el valor de un contador, c2.

entero c1,c2
real num
c1=0
c2=0
mientras c1<=5 hacer
escribir "proporciona un valor"
leer num
si num==0 entonces
c2=c2+1
fin si
c1=c1+1
fin mientras
escribir "Nmero de ceros capturados=",c2

44
Otro tipo de variable comnmente utilizada en los ciclos son los acumuladores, estos
almacenan los valores acumulados de un conjunto de datos, comnmente generados durante las
iteraciones del ciclo. Por ejemplo, en el siguiente segmento de cdigo

entero c
real suma,num
c=0
suma=0
mientras c<=5 hacer
escribir "proporciona un valor"
leer num
suma=suma+num
c=c+1
fin mientras
escribir "La suma es ",suma

se utiliza la variable c como contador, en el cuerpo del ciclo se solicita un valor al usuario, num,
el cual una vez ledo se acumula en una variable del tipo acumulador, suma, obsrvese que el
valor almacenado en suma no se pierde sino que se ve incrementado por num. El valor inicial del
acumulador generalmente es cero porque este valor no altera el resultado de la suma
. Al
romperse el ciclo, en suma se tiene la suma de todos los valores que proporcion el usuario.

En general, la operacin de acumulacin tiene la siguiente forma

acumulador = acumulador + variable

donde variable es el valor acumulado, este valor puede ser negativo o positivo.

En el Ejemplo 16 se ilustra el funcionamiento de esta estructura de control utilizando un
contador y un acumulador.

Ejemplo 16. Promedio de calificaciones de un grupo de 10 alumnos.

Supngase que se tiene una calificacin por alumno, para obtener el promedio es
necesario sumarlas y dividirlas entre el nmero de alumnos (10 en este caso). As, se requiere
una variable para acumular las calificaciones, suma, y otra para contar el nmero de alumnos que
se han considerado, c, la cual tambin controla el ciclo; adems, se requiere una variable auxiliar
con el propsito de leer la calificacin del alumno en turno, calif. El Algoritmo 16 muestra una
propuesta para resolver este problema. Es necesario inicializar la variable que contendr la suma
en 0, tambin la variable contadora debe tener el valor inicial 0 pues no se ha ledo valor alguno.
La condicin de ejecucin del ciclo queda determinada por la variable c ya que mientras tome un
valor menor que 10, debe repetirse la ejecucin del cuerpo del ciclo. Las instrucciones que
forman parte del cuerpo del ciclo son: la solicitud y la lectura del valor de la calificacin del
alumno en cuestin, una vez obtenido ste se acumula en la variable suma y se incrementa en
uno el valor del contador, c. Se repite el proceso hasta que c sea mayor o igual a 10. Una vez

El valor inicial de un acumulador depender del uso que se le de en el algoritmo.

45
terminado el proceso de repeticin, se utiliza la variable suma para calcular el promedio que se
presenta para ser visualizado por el usuario.

Algoritmo 16: Promedio de grupo.
inicio
real prom,calif,suma ,c

suma=0
c=0
mientras c<10 hacer
escribir Calificacin =
leer calif
suma=suma+calif
c = c+1
fin mientras
prom=suma / c
escribir El promedio es,prom
fin

Se deja como ejercicio al lector modificar el algoritmo 16 para que se verifique que cada
calificacin dada est en rango vlido, por ejemplo de 0 a 100, antes de acumularla y contarla.

Ejemplo 17. Encontrar el mayor de 8 nmeros.

Es posible utilizar 8 variables, una para cada nmero y despus proceder a compararlos
de una manera similar a la empleada en el Algoritmo 8. Es obvio, que usar este procedimiento
resulta poco prctico sobre todo si aumenta el nmero de datos a comparar. En casos como stos
el uso de ciclos simplifica el proceso. Procederemos de la siguiente manera: El mayor de los
nmeros encontrados en cada iteracin se almacena en una variable auxiliar declarada para ello,
mayor. Se utiliza un contador, contador, que controle el nmero de iteraciones del ciclo, 8 en
este caso, adems se requiere una variable, num, para guardar el nmero ledo en cada vuelta. El
Algoritmo 17 ilustra las acciones realizadas.

Obsrvese que es necesario leer el primer nmero antes del ciclo para que ste sea
considerado como el mayor hasta el momento. En el cuerpo del ciclo, cada vez que se lee un
nmero, num, se compara con mayor, en caso de que ste sea mayor, se modifica el valor
guardado en mayor sustituyndolo con num. Finalmente, el valor mayor encontrado es
presentado como salida del programa.

Algoritmo 17: El mayor de 8 nmeros.
inicio
entero num, mayor,contador
escribir Nmero ="
leer num
mayor = num
contador = 1
mientras contador<8 hacer
escribir Nmero"
leer num
si num > mayor entonces

46
mayor= num
fin si
contador = contador+1
fin mientras
escribir El mayor es",mayor
fin

Ejemplo 18. Sumar los nmeros pares en el intervalo [1,100].

Se presentan dos versiones de un algoritmo que resuelva este problema. El Algoritmo 18a
presenta una versin donde se requiere de una variable contadora, i, que tomar valores de 1 al
100. Adems, se requiere una variable acumuladora, suma, en donde se acumular el valor del
contador cada vez que ste sea par. Finalmente, una vez terminado el ciclo se imprime el valor
almacenado en suma.

Algoritmo 18a: Sumar los pares en el intervalo [1,100].
inicio
entero suma, i

suma=0
i=1
mientras i<=100 hacer
si i MOD 2 == 0 entonces
suma=suma+i
fin si
i = i+1
fin mientras
escribir La suma es",suma
fin

El Algoritmo 18b utiliza una variable para controlar el ciclo, i, la cual se inicializa en 2 y
se incrementa de 2 en 2 hasta alcanzar el lmite mximo permitido, 100. En este caso, i siempre
toma un valor par, por lo que no es necesario hacer la verificacin antes de acumularlo como en
la versin anterior.

Algoritmo 18b: Suma los pares en el intervalo [1,100].
inicio
entero suma, i

suma=0
i=2
mientras i<=100 hacer
suma=suma+i
i = i+2
fin mientras
escribir La suma es",suma
fin

Ejemplo 19. Sumar los nmeros pares y los impares (por separado) en el intervalo [1,100].

En la versin presentada por el Algoritmo 19a, son necesarias dos variables, suma_pares

47
y suma_impares, una para sumar los pares y la otra para los impares. Se utiliza un contador, c,
para que tome todos los valores posibles en el rango dado. Al igual que en el Algoritmo 19a, es
necesario revisar la paridad del contador para saber si su valor se acumula a la suma de los pares
o de los impares. Finalmente, cuando el ciclo se rompe, se imprimen los resultados obtenidos.

Algoritmo 19a: Suma de pares e impares [1,100].
inicio
entero suma_pares,suma_impares,c

suma_pares=0
suma_impares=0
c=1
si c MOD 2== 0 entonces
suma_pares=suma_pares+c
sino
suma_impares=suma_impares+c
fin si
c = c+1
fin mientras
escribir La suma de los pares es",suma_pares
escribir La suma de los impares es",suma_impares
fin

En el Algoritmo 19b se presenta otra versin, en sta se utilizan dos ciclos, el primero
para calcular la suma de los pares y el segundo para la suma de los impares. Ambos ciclos, se
controlan con el contador, c, ya que son independientes. En el primer ciclo, c se inicializa en dos
y se incrementa de dos en dos para recorrer todos los nmeros pares en el intervalo dado. En el
segundo, c se inicializa en 1 y se incrementa de dos en dos para recorrer todos los impares en el
intervalo dado. En cada caso se realiza la acumulacin correspondiente.

Algoritmo 19b: Suma de pares e impares [1,100].
inicio
entero suma_pares,suma_impares,c

suma_pares=0
c=2
suma_pares=suma_pares+c
c = c+2
fin mientras
escribir La suma de los pares es",suma_pares

suma_impares=0
c=1
mientras c<100 hacer
suma_impares=suma_impares+c
c = c+2
fin mientras
escribir La suma de los impares es",suma_impares
fin

48

Ejemplo 20. Leer un conjunto de n nmeros y contar los nmeros pares que aparezcan.

Se requiere solicitar al usuario el nmero de datos que se leern, n, y con la ayuda de un
contador, c, en un ciclo se leern los n datos proporcionados por el usuario, uno a la vez. Cada
nmero ledo se revisa para ver si es par en cuyo caso se incrementa un contador, pares que
previamente fue inicializado en cero. Al finalizar el ciclo se imprime el valor del contador, pares.

Algoritmo 20: Sumar los pares.
inicio
entero num,c,n,pares

escribir "Cuntos nmeros quieres leer?"
leer n
si n<=0 entonces
escribir Debe ser un valor positivo.
si no
c=1
pares=0
mientras c<=n hacer
escribir "Nmero="
leer num
si num MOD 2==0 entonces
pares=pares+1
fin si
c = c+1
fin mientras
escribir Se leyeron,pares,"pares"
fin si
fin

Ejemplo 21. Multiplicar los nmeros impares en el intervalo [1,10].

En la versin presentada en el Algoritmo 21a, se requiere del uso de un contador, c, que
tome los valores del 1 al 10. Tambin se necesita una variable donde almacenar el resultado de la
multiplicacin realizada hasta el momento, resultado. La variable resultado se inicializa en uno
porque servir para calcular el valor parcial de la multiplicacin, ya que es el neutro
multiplicativo, y no debe tomar el valor cero que hara que el resultado fuera siempre cero. Una
vez en el ciclo, se revisa si el valor del contador es impar en cuyo caso se multiplica por el valor
obtenido hasta el momento para el resultado. Cuando se han revisado todos los valores en el
rango especificado, se tendr en resultado el valor deseado por lo que se presenta en la
impresin.

Algoritmo 21a: Multiplicar los impares [1,10].
inicio
entero resultado,c

resultado=1
c=1
mientras c<10 hacer

49
si c MOD 2==1 entonces
resultado = resultado *c
fin si
c = c+1
fin mientras
escribir Resultado= ,resultado
fin

En el Algoritmo 21b se inicializa el contador, c, en 1 y se incrementa de 2 en 2 hasta
alcanzar el mximo valor en el rango dado. El valor del contador es el que se multiplica en cada
iteracin con el valor de resultado para obtener el valor resultado deseado, ya que ste, toma
todos los valores impares de 1 al 10.

Algoritmo 21b: Multiplicar los impares [1,10].
inicio
entero resultado,c

resultado=1
c=1
mientras c<10 hacer
resultado = resultado *c
c = c+2
fin mientras
escribir Resultado=,resultado
fin

Ejemplo 22. Clculo del valor de t a partir de la serie infinita dada.

La serie infinita que se requiere es

+ + + =
11
4
9
4
7
4
5
4
3
4
4 t

Para comprender la situacin, hagamos un anlisis. Obsrvese que
- El numerador es constante e igual a 4 en cada trmino.
- El denominador tiene la forma 2k-1 para k=1,2,3, ...
- El signo de los trminos (positivo o negativo) se alterna iniciando en positivo.

El nmero de trminos utilizados para la aproximacin, n, ser proporcionado por el
usuario. Si n es el nmero de trminos que se desea utilizar y si k es el contador de trminos que
se han generado, entonces, k tambin nos servir para obtener el denominador, pues cuando k=1,
se obtiene el primer factor, 4/1, si k=2 se obtiene el trmino 4/(2(2)-1)=4/3, etc. Por tanto, cada
uno de los trminos tendr la forma 4/(2k-1) donde k es un contador que toma valores desde 1
hasta n. Por otro lado, obsrvese que los trminos con posicin par se restan, mientras que los
trminos con posicin impar se suman. Por ejemplo, si k=1, el signo es positivo, si k=2, el signo
es negativo, etc.

50
Las variables que se requieren son un contador, k, el nmero de trminos a considerar, n,
una variable para el acumulador, pi, y una variable para calcular el denominador, den. Todas son
enteras excepto pi, pues se estn acumulando fracciones las cuales dan como resultado un valor
real. En el Algoritmo 22a se muestra una versin que resuelve el problema.

Algoritmo 22a: Serie para calcular una aproximacin al valor de pi.
inicio
real pi
entero n,k,den

escribir Cuntos trminos de la serie deseas utilizar?
leer n
si n<1 entonces
escribir El nmero de trminos debe ser mayor o igual a 1
si no
pi=4
k=2
mientras k<=n hacer
den=2*k-1
si k MOD 2 == 0 entonces
pi = pi - 4/den
si no
pi = pi + 4/den
fin si
k = k+1
fin mientras
escribir Pi=,pi
fin si
fin

En el Algoritmo 22b se parte de que + + + =
11
4
9
4
7
4
5
4
3
4
4 t es equivalente a
+ + + + + + = ) ( ) ( ) ( 4
11
4
9
4
7
4
5
4
3
4
t para utilizar una variable auxiliar signo que tomar los
valores de 1 -1 dependiendo del trmino generado. Se utilizar esta variable de la siguiente
manera
signo*4/(2k-1)

con lo cual obtenemos el trmino a acumular. En cada iteracin se modifica el valor de la
variable signo multiplicandolo por 1, para alternar los signos. El trmino as obtenido se
acumula en pi.

Algoritmo 22b: Serie para calcular una aproximacin al valor de pi.
inicio
real pi
entero n,k,signo

escribir Cuntos trminos de la serie deseas utilizar?"
leer n
si n<1 entonces
escribir El nmero de trminos debe ser mayor o igual a 1"
sino
pi=4
k=2
signo=-1

51
mientras k<=n hacer
pi = pi + signo*4/(2*k-1)
signo=signo*(-1)
k = k+1
fin mientras
escribir Pi=",pi
fin si
fin

Ejemplo 23. Encontrar el factorial de n.

En primer lugar, hay que recordar la frmula para obtener el factorial de un nmero

>
=
=
1 , 5 4 3 2 1
0 , 1
!
n si n
n si
n

Obsrvese que el factorial para un nmero negativo no est definido y deber considerarse este
hecho en el algoritmo. En el Algoritmo 23 se muestra una propuesta de solucin. Se utiliza una
variable, contador, para controlar el ciclo y como auxiliar en el clculo del factorial, f, ya que
cada valor de contador ser un trmino del producto acumulado en cada iteracin del ciclo.

Algoritmo 23: Factorial de n.
inicio
entero f,n,contador

escribir n=
leer n
si n<0 entonces
escribir El factorial no est definido para valores negativos
sino
f=1
contador=2
mientras contador<=n hacer
f=f*contador
fin mientras
escribir El factorial de",n, es ,f
fin si
fin

Un error tpico en el diseo de una sentencia mientras-hacer es que el cuerpo del ciclo no
contenga una sentencia que modifique la situacin de la condicin que lo controla. El siguiente
segmento de cdigo ejemplifica esta situacin:

contador =1
mientras contador <3 hacer
escribir Contador = , contador
fin mientras
contador=contador +1

En este caso, la variable contador nunca cambia su valor en el cuerpo del ciclo por lo que

52
la condicin siempre ser verdadera. De este modo, se obtiene un ciclo que se repite
infinitamente. Debe tenerse cuidado de que el cuerpo del ciclo siempre contenga las
instrucciones necesarias para que la condicin que controla el ciclo sea, en algn momento, falsa
y el ciclo se rompa. Otro caso es que el valor del contador cambie pero que est alternando su
valor mediante una operacin de inicializacin dentro del cuerpo del ciclo como en el siguiente
bloque de instrucciones

mientras c<10 hacer
c=1
escribir "Contador=", contador
c=c+1
fin mientras

Suponiendo que la condicin es verdadera en la primera evaluacin el valor del contador,
c, se inicializa en 1. Dentro del cuerpo del ciclo, se imprime y se incrementa para tomar el valor
2, despus se evala la condicin del ciclo que es verdadera de nuevo y se inicializa en uno otra
vez con lo cual el valor del contador estar alternando entre 1 y 2 y la condicin nunca ser falsa,
es decir, ser un ciclo infinito.

III.1.1 Variantes del uso del ciclo

Puesto que el cuerpo del ciclo mientras-hacer utiliza una condicin para controlar la
repeticin, es posible utilizar una variable que tome valores VERDADERO o FALSO como
controlador del flujo de acciones. Este tipo de variable se conoce como booleana y se declara de
la siguiente manera:

booleano identificador

donde, identificador es el nombre de la variable booleana. Por convencin se utilizarn
maysculas para especificar los posibles valores de una variable booleana.

La forma de controlar el ciclo mientras-hacer mediante una variable booleana
(comnmente llamada indicadora o bandera) es asignar un valor inicial VERDADERO a dicha
variable y hacer que la condicin que controle el ciclo sea precisamente que la variable tome el
valor VERDADERO y en algn momento de la ejecucin del cuerpo del ciclo modificar el valor de
la bandera a FALSO con lo cual se romper el ciclo o viceversa (se inicializa como FALSO, la
condicin sera que la bandera tomara el valor FALSO y en algn momento se cambia a
VERDADERO para que el ciclo se rompa).

En el siguiente segmento de cdigo ilustramos la situacin antes mencionada. Se leern
datos de tipo caracter mientras el carcter ledo no sea el '0' (recurdese que al trabajar con
caracteres constantes es necesario utilizar los apstrofes). La variable digito_leido es de tipo
booleano y se inicializa en VERDADERO, se usa como condicin del ciclo que digito_leido==
VERDADERO con lo cual aseguramos que se ejecutar el cuerpo del ciclo al menos en una

53
ocasin, dentro del cuerpo del ciclo se lee un carcter y si se trata del '0' se cambia digito_leido a
FALSO con lo cual se rompe el ciclo.

caracter dato
booleano digito_leido

digito_leido=VERDADERO
mientras digito_leido==VERDADERO hacer
escribir Teclea un carcter
leer dato
si dato == '0' entonces
digito_leido=FALSO
fin si
fin mientras

En el Ejemplo 24, se indica si un nmero es primo utilizando una bandera.

Ejemplo 24. Indicar si un nmero entero positivo dado es primo.

Se pretende revisar a todos los posibles divisores de un nmero dado n, se utilizar una
bandera, primo, inicializada en VERDADERO que indicar con esto que el nmero n es
efectivamente primo. En el proceso de revisin, realizado en un ciclo, se toman todos los
posibles divisores de n, que son 2, 3, ..., n-1, y en el momento en que se encuentre uno que sea
divisor de n, se modifica el valor de la bandera a FALSO, luego ya fuera del ciclo se imprime un
mensaje dependiendo del valor de la bandera. Si la bandera tiene el valor VERDADERO se
imprime que el nmero es primo, de lo contrario se imprime que no es primo.

Algoritmo 24: Nmero primo.
inicio
booleano primo
entero n,contador

primo=VERDADERO
escribir "Nmero: "
leer n
si n>=1 entonces
contador=2;
mientras contador<=n-1 AND primo==VERDADERO hacer
si n MOD contador == 0 entonces
primo=FALSO
fin si
contador=contador+1
fin mientras
si primo==VERDADERO entonces
escribir "El nmero es primo"
si no
escribir "El nmero no es primo"
fin si
si no
escribir "El valor dado debe ser positivo"
fin si
fin

54
Comnmente, no se conoce de antemano el nmero de veces que se va a ejecutar el
cuerpo de un ciclo. Esto puede suceder cuando el usuario est capturando valores en cada
iteracin y no sabe cuntos son exactamente o bien cuando los datos siguientes depende de los
resultados obtenidos en la iteracin previa. Para estos casos, es posible aleccionar al usuario para
que proporcione un valor que indicar que la lectura de los datos ha terminado, es decir, existir
un valor que actuar como centinela para terminar el ciclo. En el Ejemplo 25 se presenta esta
situacin.

Ejemplo 25. Promedio de calificaciones usando un valor centinela.

Dentro de un ciclo se leer una calificacin a la vez la cual se acumula en suma y se
incrementa el valor del contador. Cuando se solicita la calificacin al usuario se le instruye para
que, en caso de que no haya otra calificacin, introduzca el -1 como centinela. La condicin de
continuacin del ciclo es que la calificacin proporcionada sea distinta del valor centinela. Por lo
tanto, cuando el usuario proporcione el valor -1 se romper el ciclo y se calcular el promedio si
se ejecut el cuerpo del ciclo al menos en una ocasin. En este caso, -1 es un buen valor
centinela puesto que se considera que no hay calificaciones negativas. Pudo utilizarse en su lugar
cualquier valor que est fuera del rango considerado como vlido. Es una buena prctica de
programacin indicar el valor centinela en cada mensaje de solicitud de datos adecuado.

Algoritmo 25: Uso de un valor centinela (promedio de calificaciones).
inicio
real calif,suma
entero contador

contador =0
suma = 0
escribir Escribe una calificacin [para terminar, teclea un -1]
leer calif
mientras calif NOT= -1 hacer
si calif>=0 AND calif<=100 entonces
contador =contador +1
suma = suma + calif
fin si
escribir Escribe la siguiente calificacin [para terminar, teclea un -1]
leer calif
fin mientras
si contador>0 entonces
escribir El promedio es, suma/contador
fin si
fin

Tambin puede utilizarse un carcter como valor centinela. En el Ejemplo 26 se utiliza de
esta manera el ciclo mientras-hacer.

Ejemplo 26. Promedio de calificaciones usando un carcter como centinela.

Dentro de un ciclo se lee una calificacin a la vez, se acumula en suma y se cuenta con

55
contador. En esta ocasin, el ciclo est controlado por la condicin resp=='s', previamente se ha
inicializado la variable resp con el carcter proporcionado por el usuario como respuesta a la
pregunta hay alguna calificacin? [s/n]. Obsrvese que se han indicado como parte del mensaje
los valores esperados para la respuesta los cuales pueden ser 's' o 'n'. El valor de la variable resp
se actualiza dentro del cuerpo del ciclo al preguntarle al usuario hay otra calificacin? [s/n] con
lo cual damos pie a que en algn momento se rompa el ciclo al proporcionar el usuario algn
valor distinto de 's'.

Algoritmo 26: Uso de un carcter como valor centinela.
inicio
real calif,suma
caracter resp
entero contador

contador =0
suma = 0
escribir Hay alguna calificacin? [s/n]
leer resp
mientras resp=='s' OR resp=='S' hacer
escribir Escribe la siguiente calificacin
leer calif
suma = suma + calif
fin si
escribir Hay otra calificacin? [s/n]
leer resp
fin mientras
fin si
fin

Aunque el ciclo mientras-hacer nos ha sido til cuando se conoce de antemano el nmero
de veces que se ejecutar, existe otro ciclo ms adecuado para esos casos, el ciclo para-hacer
que se presenta en la seccin siguiente.

III.2 Ciclo para hacer

Este ciclo se utiliza cuando se sabe de antemano el nmero de veces que se va a repetir el ciclo.
Se utiliza una variable, contador, para controlar el ciclo mediante las operaciones de
inicializacin, condicin e incremento. El formato para este ciclo se muestra en la Fig. IV-2.

para inicializacin ; condicin ; incremento hacer
Bloque de instrucciones a realizar si condicin es verdadera
fin para

Fig. IV-2: Formato para el ciclo para-hacer.

56
Primero, se inicializa la variable controladora del ciclo en la operacin inicializacin,
despus se evala condicin, si sta es verdadera se ejecuta el cuerpo del ciclo, luego se modifica
el valor de la variable controladora del ciclo en la operacin incremento, en ese momento, el
control se regresa a evaluar condicin. Cuando la condicin es falsa, el ciclo se rompe.

Una forma de utilizar este ciclo es la mostrada a continuacin:

donde contador se inicializa con valor_inicial y se incrementa en el valor constante ejecutando l
cuerpo del cicloientras la condicin contador<=valor_final sea verdadera.

Otra manera de utilizarlo, sera

donde contador se inicializa con valor_inicial y se decrementa en el valor constante ejecutando
el cuerpo del ciclo mientras la condicin contador>=valor_final sea verdadera.

En el caso en que se conoce el nmero de veces que se repetir el ciclo, es equivalente la
utilizacin de los ciclos mientras-hacer y para-hacer puesto que la secuencia en que se realizan
las operaciones de inicializacin, evaluacin de la condicin e incremento es la misma. En los
siguientes bloques de cdigo se ilustra esto,

c=valor_inicial
mientras c<=valor_final hacer
...
c=c+incremento
fin mientras

es equivalente a

para c=valor_inicial ; c<=valor_final ; c=c+incremento hacer
...
fin para

En el Ejemplo 27 se presenta un algoritmo para calcular el factorial de un nmero dado,
n, el cual se present en la seccin anterior (ver el Ejemplo 23), con las dos versiones de ciclo
vistas hasta el momento para efectos de comparacin.

para constador=inicializacin ; contador<=valor_final ; contador = contador + constante hacer
Bloque de instrucciones a realizar si contador<=valor_final es verdadera
fin para

Fig. IV-3: Formato para el ciclo para-hacer donde el contador se incrementa desde el valor_inicial hasta el valor_final.
para constador=inicializacin ; contador>=valor_final ; contador = contador - constante hacer
Bloque de instrucciones a realizar si contador>=valor_final es verdadera
fin para

Fig. IV-4: Formato para el ciclo para-hacer donde el contador se decrementa desde el valor_inicial hasta el valor_final.

57

Ejemplo 27. Calcular el factorial de un nmero n.

En el Algoritmo 27a se presentan las instrucciones necesarias para encontrar el factorial
de un nmero utilizando el ciclo para-hacer. El valor del contador, contador, se inicializa en 2 y
se incrementa de uno en uno hasta alcanzar el valor final, n.

Algoritmo 27a: Factorial de n usando el ciclo para-hacer.
inicio
entero f,contador,n

escribir n=
leer n
si n<0 entonces
si no
f=1
para contador = 2; contador<=n ; contador=contador+1 hacer
f=f*contador
fin para
escribir El factorial de,n,es,f
fin si
fin

En el Algoritmo 27b, se presentan las instrucciones necesarias para obtener el factorial de
un nmero utilizando el ciclo mientras-hacer. Se utiliza un contador, contador, el cual se
inicializa en 2 y se incrementa de uno en uno hasta alcanzar el valor n.

Algoritmo 27b: Factorial de n usando el ciclo mientras-hacer.
inicio
entero f,n,contador

escribir n=
leer n
si n<0 entonces
sino
f=1
contador=2
mientras contador<=n hacer
f=f*contador
fin mientras
escribir El factorial de",n, es ,f
fin si
fin

Obsrvese que la nica diferencia entre estos algoritmos es precisamente el conjunto de
instrucciones para obtener el valor del factorial que son equivalentes como se haba mencionado.

A continuacin se presentan algunos ejemplos utilizando el ciclo para-hacer.

58

Ejemplo 28. Simular el lanzamiento de una moneda.

Lanzar la moneda 100 veces y contar el nmero de veces que cay cara y el nmero de
veces que cay cruz. La simulacin del lanzamiento de una moneda se realiza utilizando la
funcin aleatorio(1,2), en caso de que la funcin regrese un 1, se considera que se obtuvo una
cara y se cuenta su ocurrencia utilizando el contador, num_caras; en caso contrario, se considera
que cay una cruz y se cuenta por separado, utilizando el contador num_cruces. En el Algoritmo
28 se representa esta situacin. Para simular el nmero de lanzamientos de la moneda se utiliza
un ciclo para-hacer controlado por un contador, contador, el cual toma valores desde 1 hasta
100 incrementndose de 1 en 1; as, el ciclo se repetir 100 veces.

Algoritmo 28: Lanzamientos a cara o cruz.
inicio
entero contador,num_caras,num_cruces,lanz

num_caras=0
num_cruces=0
para contador = 1; contador<=100 ; contador=contador+1 hacer
lanz=aleatorio(1,2)
si lanz==1 entonces
num_caras=num_caras+1
si no
num_cruces=num_cruces+1
fin si
fin para
escribir Nmero de caras =,num_caras
escribir Nmero de cruces=,num_cruces
fin

Ejemplo 29. Generar n trminos de la Sucesin de Fibonacci.

La Sucesin de Fibonacci inicia con los valores 0 y 1 y obtiene el siguiente valor de la
sucesin sumando los ltimos dos valores obtenidos, as, por ejemplo, los primeros 8 trminos de
la serie son 0, 1, 1, 2, 3, 5, 8, 13.

El algoritmo requiere una variable, n, que contenga el nmero de trminos deseados.
Tambin se requieren dos variables, penultimo y ultimo, que almacenen los ltimos dos valores
obtenidos de la sucesin. Adems, se utiliza una variable auxiliar, sig, para almacenar el
siguiente valor obtenido. El valor sig se obtiene sumando los valores de penultimo y ultimo.
Inicialmente, penultimo=0 y ultimo=1, as que restan por obtener n-2 trminos. En el Algoritmo
29 se presentan las instrucciones requeridas para resolver este problema.

Algoritmo 29: Sucesin de Fibonacci.
inicio
entero sig,ultimo,penultimo,n,contador
escribir Cuntos trminos de la sucesin quieres obtener?

59
leer n
si n>=1 entonces
penultimo=0
escribir penultimo
si n>1 entonces
ultimo=1
escribir ultimo
para contador = 3 ; contador<=n ; contador=contador+1 hacer
sig=ultimo+penultimo
escribir sig
penultimo=ultimo
ultimo=sig
fin para
fin si
si no
escribir "Se requiere un valor entero positivo"
fin si
fin

Ejemplo 30. Determinar si un nmero entero positivo dado es primo.

Recurdese que un nmero es primo cuando solamente es divisible entre 1 y entre s
mismo. As, si encontramos que existe al menos un divisor adicional, sabremos que el nmero
considerado no es primo. En el Algoritmo 30, se lee un nmero, n. Se parte de la suposicin de
que n es primo, para lo cual se utiliza una bandera, primo, que se inicializa en VERDADERO. Se
consideran como posibles divisores todos los valores enteros entre 2 y n-1, por lo cual se utiliza
un ciclo para-hacer, para generar estos valores con un contador. En caso de que se encuentre un
divisor entre stos, se cambia el valor de la bandera a FALSO y se hace que el contador tome el
valor n para obligar a que se rompa el ciclo pues con ese valor la condicin controladora ser
falsa. El valor de la bandera al finalizar el ciclo determina el mensaje enviado al usuario.

Algoritmo 30: Primo.
inicio
booleano primo
entero n,contador

escribir Nmero=
leer n
si n>=1 entonces
primo=VERDADERO
para contador=2; contador<=n-1; contador=contador+1 hacer
si n MOD contador ==0 entonces
primo=FALSO
contador=n
fin si
fin para
si primo==VERDADERO entonces
escribir El nmero es primo
si no
escribir El nmero no es primo
fin si
si no
escribir El valor dado debe ser positivo
fin si

60
fin

Es posible modificar el Algoritmo 30 considerando que los posibles divisores de un
nmero n se encuentran en el rango de nmeros enteros entre 2 y la raz cuadrada de n.
Obviamente, la modificacin mencionada slo afecta al rango de repeticiones del ciclo. Para
obtener la raz cuadrada de un nmero se utiliza la funcin

y=sqrt(x)

donde, x es el valor del cual se quiere obtener la raz cuadrada y y es la variable que recibir el
resultado en valor absoluto. As, el ciclo quedara

para contador=2; contador<=sqrt(n); contador=contador+1 hacer
...
fin para

En el siguiente ejemplo, se calcula la integral de una funcin f(x) en el intervalo [a,b] con
el mtodo de aproximaciones utilizando rectngulos inferiores.

Ejemplo 31. Calcular una integral numrica inferior.

Utilizar la funcin 1 ) (
2
+ = x x f en el intervalo [a,b] dado. Para resolver el problema
debemos recordar como se calcula una integral numrica inferior. En la Fig. IV-5 se visualiza la
particin del intervalo [a,b] en n subintervalos, cada uno stos tiene un ancho de dx=(b-a)/n. Para
obtener la aproximacin al rea bajo la curva se emplean rectngulos formados por las
particiones hechas y se suma el rea de cada uno de ellos. El rea de cada rectngulo es igual a la
altura del rectngulo por la longitud de la base. La altura es igual al valor de la funcin en x,
donde x=a+i*dx con i=0,1,...,n-1 y la base es dx. Obsrvese que el valor de la aproximacin es
mejor conforme hacemos que n tome un valor mayor.

En los Algoritmos (31a) y (31b) se leen los valores extremos del intervalo, a y b, adems
Fig. IV-5: Aproximacin del rea bajo la curva f(x) con rectngulos inferiores.

61
del nmero de particiones requeridas. Se espera que a<=b y que n>0, si esto sucede entonces se
procede a calcular la aproximacin de la integral. Para esto, se calcula la longitud de la particin,
dx, como la longitud del intervalo [a,b] entre el nmero de particiones. Utilizaremos una
variable, x, que tome como valor todos los puntos iniciales de los subintervalos. x ser el valor en
que evaluaremos la funcin para encontrar la altura de cada rectngulo. Inicialmente le
asignamos a x el valor a y en cada iteracin se incrementa en dx, para que tome el valor del
punto inicial del siguiente subintervalo. Para simular la suma de las reas de cada rectngulo se
utiliza un acumulador, integral, inicializado en cero, y cuyo valor se incrementa en el rea de
cada rectngulo calculada como el producto de la funcin evaluada en x por dx.

En el Algoritmo 31a se utiliza un ciclo controlado por un contador, i, con valores de 1 a
n, para hacer que el ciclo se repita n veces.

Algoritmo 31a: Integral inferior.
inicio
real x,dx,a,b,integral
entero n,i

escribir Lmite inferior del intervalo=
leer a
escribir Lmite superior del intervalo=
leer b
escribir Nmero de particiones=
leer n

si n>0 AND a<=b entonces
dx=(b-a)/n
x=a
integral=0
para i=1; i<=n; i=i+1 hacer
integral = integral + (x*x+1)*dx
x=x+dx
fin para
escribir La integral de f(x)=x^2+1 evaluada de,a,a,b,es,integral
si no
escribir Error: Los lmites del intervalo o el nmero de particiones es incorrecto.
fin si
fin

En el Algoritmo 31b se utilizan como controlador del ciclo a la variable x. El punto
inicial del ltimo subintervalo se encuentra en b-dx, por lo cual el ciclo debe terminar cuando x
tome el valor b.

Algoritmo 31b: Integral inferior.
inicio
real x,dx,a,b,integral
entero n

escribir Lmite inferior del intervalo=
leer a
escribir Lmite superior del intervalo=
leer b
escribir Nmero de particiones=

62
leer n

si n>0 AND a<=b entonces
integral=0
dx=(b-a)/n
para x=a; x<b; x=x+dx hacer
integral = integral + (x*x+1)*dx
fin para
escribir La integral de f(x)=x^2+1 evaluada de,a,a,b,es,integral
si no
escribir Error: Los lmites del intervalo o el nmero de particiones es incorrecto.
fin si
fin

En la siguiente seccin, se presenta la tercera, y ltima, estructura de repeticin: el ciclo
hacer-mientras. Este es una versin modificada del ciclo mientras-hacer.

III.3 Ciclo hacer mientras

Este ciclo se utiliza cuando se sabe que el cuerpo del ciclo se va a ejecutar al menos una vez. La
condicin se evala al finalizar de ejecutarse las instrucciones que conforman el cuerpo del ciclo,
si es verdadera, se repite la ejecucin desde donde lo indica la palabra clave hacer, en caso
contrario, se rompe el ciclo. Obsrvese que la nica diferencia entre el ciclo mientras-hacer visto
en la seccin IV.2 es el momento en que se realiza la evaluacin de la condicin. El formato del
ciclo hacer-mientras es mostrado en la Fig. IV-6.

A continuacin se presentan algunos ejemplos donde se utiliza este ciclo.

Ejemplo 32: Adivinar el nmero mgico (juego).

Se considera un valor oculto al usuario (llamado el nmero mgico) en un rango
determinado. El juego consiste en que el usuario tratar de adivinarlo. Se tiene un ciclo que se
repetir mientras el usuario no haya adivinado el valor oculto. En el cuerpo del ciclo se le pide al
usuario que proporcione el valor que cree que es el nmero mgico, usuario, y si no lo adivina se
le proporcionan pistas sobre si el nmero mgico es mayor o menor al valor proporcionado y se
actualiza el rango de valores donde el usuario puede buscar, utilizando las variables linf y lsup.
En el Algoritmo 32 se muestra una posible implementacin en seudocdigo. En dicho algoritmo
el rango de valores para el nmero mgico es del 1 al 20.

Algoritmo 32: Nmero mgico.
hacer
bloque de instrucciones a realizar
mientras condicin
Fig. IV-6: Estructura del ciclo hacer-mientras.

63
inicio
entero num_magico, usuario,linf,lsup
linf=1
lsup=20
num_magico= aleatorio(1,20)
hacer
escribir Cul crees que es el nmero mgico? [", linf, "," ,lsup, "]
leer usuario
si num_magico<usuario entonces
escribir El nmero mgico es menor.
lsup=usuario
fin si
si num_magico>usuario entonces
escribir El nmero mgico es mayor.
linf=usuario
fin si
mientras num_magico NOT= usuario
escribir ADIVINASTE!!
fin

Un uso comn que se le da a este ciclo es para controlar que el usuario proporcione la
informacin adecuada. As, por ejemplo, si queremos asegurarnos de que se proporcione una
respuesta adecuada a una pregunta dada, utilizaremos este ciclo como "filtro" para que no se deje
continuar el algoritmo hasta que se proporcione la respuesta correcta. Una situacin como la
mencionada se muestra en el Algoritmo 33. En ste se solicita una respuesta que indique si se
desea iniciar el juego, si la respuesta dada no es una 's' o 'S' o 'n' o 'N' se escribe un mensaje y se
repite la solicitud y lectura de la respuesta, ya que la condicin del ciclo hacer-mientras as lo
indica. Una vez proporcionada la respuesta esperada se rompe el ciclo y se procede a revisar si la
respuesta fue 's' o 'S' para iniciar el juego o, en caso contrario, despedirse del usuario.

Algoritmo 33: Respuesta correcta.
inicio
caracter resp

hacer
escribir Quieres iniciar el juego? (s/n)
leer resp
si resp NOT='s' AND resp NOT= 'n' entonces
escribir Se espera una <s> o una <n>
fin si
mientras resp NOT= 's' AND resp NOT= 'n' AND resp NOT= 'S' AND resp NOT= 'N'
si resp=='s' entonces
escribir Comenzamos...
si no
escribir Adis
fin si
fin

En ocasiones pueden presentarse problemas en donde deba darse al usuario una lista de
opciones en un men, como en los Algoritmos 14 y 15, permitiendo que elija una de ellas para
que se realice algn proceso despus. A menudo, el men va acompaada de una opcin de
salida del algoritmo, de tal manera que todo el cuerpo del algoritmo pueda ejecutarse
repetidamente hasta que el usuario decida salir del mismo. A continuacin presentamos un

64
ejemplo de este tipo de problema.

Ejemplo 33: Piedra, papel o tijeras (juego).

Jugar hasta que el usuario decida salir y al terminar que se indique el nmero de juegos
ganados por la mquina y por el jugador, as como el nmero de empates. En este ejemplo
utilizaremos el Algoritmo 14 modificndolo para que se repita todo el cuerpo del algoritmo hasta
que el jugador decida terminar. Para esto, agregaremos una opcin al men, salir, que ser la
opcin que indicar que deber romperse el ciclo y terminar. Para indicar el nmero de juegos
ganados por el jugador, la mquina y los empates utilizamos tres contadores que se incrementan
en uno segn sea el caso. Ver el Algoritmo 34a.

Algoritmo 34a: Piedra, papel y tijeras.
inicio
entero jugador, maquina, ganados_jugador, ganados_maquina, empates

ganados_jugador=0
ganados_maquina=0
empates=0
hacer
(* seleccin de la mquina *)
maquina=aleatorio(1,3)

hacer
escribir 1) Piedra
escribir 2) Papel
escribir 3) Tijeras
escribir 4) Salir
leer jugador
mientras jugador<1 OR jugador>4

escribir "El jugador eligi ", jugador
escribir "La mquina eligi ", maquina

si maquina==jugador entonces
escribir Empate
empates=empates+1
si no
seleccion jugador
1: (* piedra *)
seleccion maquina
2: (* papel *)
ganados_maquina=ganados_maquina+1
3: (* tijeras *)
ganados_jugador=ganados_jugador+1
fin seleccion
2: (* papel *)
seleccion maquina
1: (* piedra *)

65
3: (* tijeras *)
escribir Gana la mquinar
fin seleccion
3: (* tijeras *)
seleccion maquina
1: (* piedra *)
2: (* papel *)
fin seleccion
4: (* fin del juego*)
escribir Juegos ganados por el usuario=,ganados_jugador
escribir Juegos ganados por la mquina=,ganados_maquina
escribir Empates=,empates
fin seleccion
fin si
mientras jugador NOT= 4
fin

Obsrvese el segmento siguiente:

hacer
escribir 1) Piedra
escribir 2) Papel
escribir 3) Tijeras
escribir 4) Salir
leer jugador
mientras jugador<1 OR jugador>4

El uso del ciclo hacer-mientras obliga a que el usuario proporcione un valor en el rango de
opciones presentadas ya que si jugador es menor que 1 o mayor que 4 se repetir la solicitud y
lectura de una seleccin para el usuario.

En algunas situaciones el ciclo hacer-mientras se adapta mejor a las necesidades del
algoritmo que resuelve un problema. Ilustraremos esto con el Ejemplo 23 donde se plantea el
problema de calcular el promedio de calificaciones utilizando un valor centinela. Presentamos de
nuevo el Algoritmo 25 descrito en la seccin II.2.1, al que renombramos como Algoritmo 34b.

Algoritmo 34b: Uso de un valor centinela (promedio de calificaciones).
inicio
real calif,suma
entero contador

contador =0
suma = 0
escribir Escribe una calificacin [para terminar, teclea un -1]
leer calif
mientras calif NOT= -1 hacer

66
suma = suma + calif
fin si
leer calif
fin mientras
fin si
fin

Ntese que la solicitud y la lectura de la calificacin se ejecuta tanto fuera como dentro
del ciclo, lo que significa que debe realizarse por lo menos una vez y por lo tanto lo ideal sera
utilizar un ciclo hacer-mientras en este caso, como se muestra en el Algoritmo 34c.

Algoritmo 34c: Uso de un valor centinela (promedio de calificaciones).
inicio
real calif,suma
entero contador

contador =0
suma = 0
hacer
leer calif
suma = suma + calif
fin si
mientras calif NOT= -1
fin si
fin

A manera de resumen mencionaremos los usos ms frecuentes de cada ciclo:
- El ciclo mientras-hacer se utiliza cuando alguna operacin a realizar repetidamente necesita
supervisin previa ya que la revisin de la condicin que lo controla se ejecuta antes que el
cuerpo del ciclo. Es ideal utilizarlo si no se conoce el nmero de repeticiones necesarias para
el proceso.
- El ciclo para-hacer se utiliza cuando tenga que repetirse la ejecucin de un proceso un
determinado nmero de veces. Este ciclo est controlado con una operacin de inicializacin,
condicin e incremento, aplicadas a un contador.
- Se utiliza el ciclo hacer-mientras cuando la ejecucin de un proceso deber realizarse por lo
menos una vez ya que la revisin de la condicin que lo controla se ejecuta despus del
cuerpo del ciclo.

Aunque estos son los usos ms comunes, cada ciclo puede adaptarse para que funcione de
manera equivalente a otro cualquiera.

Hasta aqu se han presentado los elementos bsicos de la programacin en seudocdigo. Se

67
espera que este trabajo sirva de base para la enseanza-aprendizaje de cualquier lenguaje de
programacin estructurado, en especial el lenguaje C.

68
Bibliografa

- Schildt, Herbert: 2001. C, Manual de Referencia. Osborne - McGraw-Hill. 4a. edicin.

- Joyanes A., L. Fundamentos de Programacin - Algoritmos y Estructura de Datos. Mc-
Graw Hill/Interamericana de Espaa, S.A.U., Espaa, 1996. 2a. Edicin.

- Deitel, Harvey M.; Deitel, Paul J. Cmo programar en C/C++. Prentice Hall. 1995. 2a.
edicin.

Seudocodigo - Version Revisada

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Seudocodigo - Version Revisada

Caricato da

Copyright:

Formati disponibili

SEUDOCDIGO

El valor inicial de un acumulador depender del uso que se le de en el algoritmo.

Potrebbero piacerti anche