Introduccion A La Programacion de Algoritmos

Introducción a la
Programación:
Algoritmos
Versión de marzo de 2017
Por Laura Kees1
1
Esta obra está bajo Licencia Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional.
2
Esta obra está bajo una Licencia Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional
Tabla de Contenido
1 Introducción ....................................................................................................... 1
2 Metodología de enseñanza/aprendizaje de nuestro espacio curricular ......................... 1
3 Resolución de Problemas ...................................................................................... 1
4 Pseudocódigo – Lenguaje de diseño de Algoritmos................................................... 5
4.1 Sintaxis de un Algoritmo ................................................................................ 5
4.2 Acciones primitivas de manipulación de datos ................................................... 6
4.2.1 Operaciones Aritméticas ......................................................................... 6
4.2.2 Operaciones Relacionales........................................................................ 6
4.2.3 Operaciones Lógicas .............................................................................. 7
4.2.4 Asignación ............................................................................................ 8
4.2.5 Entrada de datos ................................................................................... 8
4.2.6 Salida de datos ..................................................................................... 9
4.2.7 Trazas .................................................................................................. 9
4.3 Acciones para estructurar el flujo de ejecución de instrucciones......................... 10
4.3.1 Secuencia ........................................................................................... 10
4.3.2 Condicional ......................................................................................... 17
4.3.3 Repetición .......................................................................................... 28
5 Métodos para Resolver Problemas ....................................................................... 47
5.1 Descomposición de problema en subproblemas (Modularización) ....................... 48
5.1.1 Definición de Métodos (subAlgoritmos) ................................................... 48
5.1.2 Invocación/llamada a un Método (subAlgoritmo) desde otro algoritmo ...... 49
5.2 Refinamiento paso a paso ............................................................................. 57
5.3 Particularización - Uso específico de ejemplos ................................................. 60
5.4 Similitud entre Problemas ............................................................................. 63
6 Ventajas del lenguaje de diseño .......................................................................... 66
6.1 Programación Estructurada ........................................................................... 66
7 Algoritmo Principal – Interacción con el usuario..................................................... 67
8 Bibliografía ....................................................................................................... 69
1
1 Introducción
Es complejo entender el mundo en el que vivimos si no tenemos cierto conocimiento acerca de

cómo funcionan las computadoras y los programas que las comandan. Interactuamos con ellas
todo el tiempo: cuando buscamos en Internet, cuando chateamos mediante nuestros celulares
y también cuando pagamos el boleto en el transporte público. Las computadoras son una
herramienta esencial en muchas áreas: industria, gobierno, ciencia, educación. En realidad en
casi todos los campos de nuestra vida.
Una computadora es un autómata que ejecuta un proceso de acuerdo a reglas rígidas. Este
proceso es especificado por un programa. Un programa consiste en una secuencia de
instrucciones que ha de ejecutar la computadora. Por lo general, una computadora posee un
repertorio muy reducido de instrucciones, las únicas que es capaz de entender y obedecer. El
poder esencial de las computadoras es su capacidad para ejecutar enormes secuencias de
acciones elementales en tiempos muy reducidos.
La programación es una disciplina con muchas aplicaciones, incluyendo problemas no triviales

cuya resolución constituye un desafío intelectual. En tales casos, la verdadera dificultad no
reside en expresar la solución al problema en términos de instrucciones que entienda la
computadora, sino en la resolución del problema.
Así es que, en la medida que el rango de aplicación de las computadoras ha ido creciendo,
abarcando problemas más grandes y complejos, el énfasis de la programación ha pasado a ser
el diseño de algoritmos. Un algoritmo se define como una secuencia de pasos o acciones que
describe una estrategia de resolución de un problema (o más bien de una clase de problemas).
El objetivo de este material será introducir al alumno en la programación como el arte de

construir y formular algoritmos de una forma metodológica y sistemática.
2 Metodología de enseñanza/aprendizaje de nuestro espacio

curricular
Se encarará la resolución de problemas utilizando Scratch, una plataforma para el desarrollo

de la programación por bloques y continuaremos con la definición de Algoritmos a través de la
presentación de un lenguaje de diseño flexible y natural (pseudocódigo), al que dedicamos
este apunte. Una vez encontrado el algoritmo, este se traducirá a un lenguaje de
programación, más estricto e inflexible, para que pueda ser ejecutado por una computadora y
se pueda controlar su validez.
Se ha elegido el lenguaje de programación Pascal en primer lugar porque, entre los lenguajes
más difundidos, es uno de los que promueve mejores hábitos de programación. La mayor parte
de las características que nombraremos como deseables para lograr un buen estilo de
programación son soportadas por Pascal. Otra ventaja es el hecho de que Pascal no está
orientado a un tipo de aplicación específico, sino que es de propósito general.
Para reconocer la importancia de proceder de acuerdo a una metodología se intentará mostrar

la complejidad inherente a la resolución de problemas, aún para ejemplos sencillos. Así es que
el lenguaje de programación será una herramienta, pero no un fin en sí mismo.
3 Resolución de Problemas
Todo problema puede pensarse como una discrepancia entre un estado actual o inicial y un
estado deseado o final. Para pasar de un estado a otro realizamos determinadas tareas que
2
denominamos acciones. Así es que hallar una solución consiste en determinar la sucesión de
acciones intermedias.
Para hallar soluciones a problemas se requiere habilidad, conocimiento y experiencia.

Aunque a veces es posible hallar la solución de un problema aparentemente difícil de una
forma puramente intuitiva, en general resulta conveniente entrenarnos en el uso de
algunas estrategias y tácticas que nos orienten en la búsqueda de soluciones.
La búsqueda de la solución de un problema es una tarea difícil de sistematizar. Cada

problema puede presentarse en forma aparentemente aislada y frecuentemente no
sabemos cómo encararlo. Sin embargo, existen algunas pautas útiles que pueden
ayudarnos para enfrentar el problema.
Estas pautas son:
 Establecer el problema en forma clara y entenderlo completamente.

 Clarificar cualquier ambigüedad que presente el problema.
 Definir exactamente qué se quiere hacer.
 Especificar con precisión restricciones y condiciones que debe satisfacer la solución.
 Identificar claramente la información disponible.
 Eliminar toda aquella información irrelevante o redundante.
 Explicar toda información implícita en el planteo que pueda resultar útil.
 Encontrar una representación adecuada para esta información.
Estas pautas no deben seguirse necesariamente en el orden expuesto.
Un problema se presenta en general bajo la forma de un enunciado.
La principal dificultad para hallar la solución de un problema, no es la falta de información, sino

mas bien la incapacidad para utilizar convenientemente la información disponible.
El primer paso en la búsqueda de la solución es encontrar una representación adecuada para el

problema, que descarte la información superflua y rescate la que resulte relevante. Esta
técnica para encontrar un planteo más conciso del problema, disminuyendo su complejidad, se
conoce como abstracción. El objetivo de la abstracción es construir una simplificación de
la realidad que rescate únicamente la información relevante para hallar la solución del
problema. Se intenta, de esta manera, construir un modelo simplificado de la realidad.
La resolución de un problema consistirá en hallar un algoritmo o un método 2 que nos

permita pasar de la situación actual a la deseada. Este método permite en realidad
resolver una CLASE de problemas, más que un problema particular.
Definimos algoritmo como una secuencia de pasos o acciones para resolver un

problema.
2
Los métodos que utilizan algoritmos se denominan métodos algorítmicos, en oposición a los
métodos que implican algún juicio o interpretación que se denominan métodos heurísticos. Los
primeros se pueden implementar en computadoras.
3
Situación Secuencia de Situación

inicial Acciones deseada
Gráfico simple de un Algoritmo
Diseñar una estrategia de resolución o algoritmo, nos permite pensar de manera más
abstracta cuáles serían las grandes acciones que deberíamos realizar parar resolver el
problema.
Con el algoritmo diseñado resulta más sencillo pasar luego a un programa.
Un algoritmo es un método para resolver un problema (clase de problemas) mediante

una serie de pasos realizable sin ambigüedad, precisa, definida y finita, que constituye
la solución de un determinado problema y es independiente del lenguaje de
programación a utilizar.
Características de un algoritmo:
 Preciso porque indica el orden de realización en cada paso sin ambigüedades.

 Definido porque si se sigue dos veces (bajo idénticas condiciones) se obtiene igual
resultado cada vez.
 Finito porque tiene un número determinado de pasos, tiene fin (uno solo).
Existe el preconcepto de que los algoritmos están únicamente relacionados con la

Informática y la Programación. Muy por el contrario con esta creencia, en la escuela
primaria se aprendieron algunos algoritmos tales como: el proceso a seguir para realizar
una multiplicación o una división, y el de Euclides, para calcular el máximo común
divisor. Saliendo del campo de las matemáticas, una partitura musical es un algoritmo
así como una receta de cocina, ya que son secuencias de pasos que permiten resolver
problemas, con los que se convive a diario.
EJEMPLO:
Supongamos que nos enfrentamos al problema de buscar el significado de la palabra

lenguaje en un diccionario. Para realizar esta tarea tenemos que partir de dos
supuestos: sabemos leer y contamos con un diccionario. Saber leer implica poder
decidir si dos palabras son iguales. Nuestro dato de partida (estado inicial) es la
palabra a buscar, en este caso particular es lenguaje y nuestro dato a encontrar
(estado deseado) es el significado de dicha palabra o no haber encontrado dicha
palabra. Nos resta especificar el método de búsqueda en el diccionario.
A partir de los supuestos anteriores podemos hallar una solución al problema de una
forma muy rudimentaria y tediosa:
"Podemos comparar la primer palabra del diccionario con ‘lenguaje’, si

coinciden hemos hallado la solución. Si no, consideramos la segunda palabra y
así siguiendo hasta encontrar lenguaje o hasta que se agotó el diccionario (la
palabra no figura)".
Este método es muy ineficiente porque partimos de premisas muy simples. Podemos
simplificar el problema si disponemos de más información. Si sabemos que el
4
diccionario está ordenado alfabéticamente y conocemos el alfabeto, nuestro algoritmo

podría ser descartar por mitades:
"Podemos abrir el diccionario por la mitad -aproximadamente- y comparar

’lenguaje’ con una palabra cualquiera. Pueden darse tres circunstancias:
1) La palabra es igual a ’lenguaje’: EXITO.

2) La palabra es menor: DESCARTAR LA PRIMERA MITAD DEL DICCIONARIO.
3) La palabra es mayor: DESCARTAR LA SEGUNDA MITAD DEL DICCIONARIO.
El proceso se repite nuevamente hasta hallar lenguaje o hasta agotar el diccionario.
Si tenemos conocimiento de la distribución de las palabras en el diccionario, podríamos

descartar una parte de la misma de distinta manera:
"Podemos abrir el diccionario considerando la posición de la L en el alfabeto y

luego buscar secuencialmente primero por hojas y luego, una vez que hemos
localizado la página, avanzar por palabras".
Cada método ha sido una mejora respecto del anterior, pero requiere más información,
supone que sabemos hacer más cosas.
Ahora bien, es claro que cualquiera de los algoritmos sirve no sólo para encontrar el
significado de la palabra lenguaje, sino para cualquier palabra. No sólo podemos hallar
la solución de un problema, sino resolver toda una clase de problemas. Es más, el
mismo método podría ser utilizado para hallar solución a problemas similares, como por
ejemplo buscar en una guía telefónica el número de teléfono de una persona.
El esfuerzo empleado en encontrar un algoritmo se ve compensado por el hecho de que

va a ser utilizado muchas veces.
Aunque el proceso de diseñar programas es esencialmente un proceso creativo, se puede

considerar una serie de fases o pasos comunes, que generalmente deben seguir todos
los programadores.
Las fases de resolución de un problema con computadora son:
 Análisis del problema.

 Diseño del algoritmo.
 Codificación.
 Compilación y ejecución.
 Verificación.
 Depuración.
 Documentación.
Las dos primeras fases conducen a un diseño detallado escrito en forma de algoritmo.
Durante la tercera etapa se implementa el algoritmo en un lenguaje de programación.
La fase de compilación y ejecución requerimos de un programa especial llamado

compilador 3 que traduce el código fuente (escrito en lenguaje de programación) a
código binario/ejecutable (escrito en lenguaje de máquina, por lo que puede ser
entendido por la computadora directamente) y ejecuta el programa.
3
Existen otras opciones de traducción a código binario conocidas como Interpretación sobre las cuales no
ahondaremos en este curso.
5
En las fases de verificación y depuración el programador busca errores de las etapas

anteriores para poder corregirlos. Es importante destacar en este punto que mientras
más tiempo se invierta en la fase de análisis y diseño, se gastará menos en la
depuración del programa. Por último, se debe realizar la documentación del programa.
4 Pseudocódigo – Lenguaje de diseño de Algoritmos
Como vimos en el ejemplo anterior, para definir la estrategia se puede utilizar el

castellano con oraciones que describan un comportamiento específico. A este lenguaje de
diseño a medio camino entre el castellano que usamos cotidianamente y un programa en
un lenguaje de programación lo llamaremos pseudocódigo.
Comparados con los lenguajes naturales, los lenguajes de programación poseen un número
muy reducido de vocablos básicos y las reglas gramaticales son pocas, simples y estrictas.
Así es que el objetivo fundamental de un lenguaje de diseño es que sea comprensible para las
personas que van a interpretar y discutir algoritmos escritos con él, facilitando las
modificaciones y el trabajo de diseño en equipo (el objetivo fundamental de un lenguaje de
programación, en cambio, es ser comprensible para la computadora que va a interpretar y
ejecutar el programa en cuestión). La idea es no sumar a la complejidad del problema, las
limitaciones impuestas por una notación estricta propia de cualquier lenguaje de programación.
Finalmente, para que un algoritmo pueda ser transformado en un programa necesitaremos

definirlo en término de operaciones que la computadora sepa hacer, es aquí cuando traducimos
el algoritmo utilizando un lenguaje de programación.
4.1 Sintaxis de un Algoritmo
Algoritmo Nombre_Algoritmo
Datos: variable Є dominio
….
variable Є dominio
Comienzo
Sentencia1
Sentencia2 Acciones de manipulación de datos y
.… de control del flujo de ejecución.
SentencaN
FinAlgoritmo
Un algoritmo está constituido por dos partes esenciales:
1) Una descripción de los datos que serán manipulados junto con una identificación
del dominio de esos datos (conjunto posible de valores que puede tomar un dato).
2) Una descripción de las acciones a ejecutar (desarrollo). Estas acciones 4 pueden

manipular datos o estructurar el control del flujo de ejecución.
Descripción de Datos
Todo problema hace referencia a una serie de objetos que denominamos datos del problema.
La cantidad de datos viene dada por el problema en particular que se desee resolver.
4
También denominadas sentencias ó instrucciones
6
Para cada dato se debe indicar el dominio al cual pertenece ese dato, o sea el conjunto de
valores que puede llegar a tomar (tipo de dato). Tenemos datos enteros (Z), datos reales
(R), datos de tipo texto o cadenas de caracteres (Texto), datos booleanos o lógicos
(Booleanos), etc.
Para la identificación de los datos es útil usar nombres significativos. Surge aquí el concepto de
variable. Las variables identifican un lugar de memoria que es capaz de almacenar un tipo de
dato específico. Cada dato estará asociado a una variable.
Observación: NO es lo mismo hablar de los valores de los datos que de los datos o
nombres de los datos. Cuando mencionamos valores, estamos usando ejemplos particulares.
Cuando hablamos de nombres de datos estamos haciendo referencia al dato en general, sin
especificar ningún valor en especial, estamos generalizando y usando variables.
Descripción de las Acciones
Existen dos tipos de acciones que es necesario describir:
1) Acciones primitivas5 de manipulación de datos
2) Acciones para estructurar el flujo de ejecución de instrucciones
4.2 Acciones primitivas de manipulación de datos
 Operaciones aritméticas
 Operaciones relacionales
 Operaciones lógicas
 Asignación
 Entrada de datos (por teclado/mouse, por ejemplo)
 Salida de datos (por pantalla)
4.2.1 Operaciones Aritméticas
Son operaciones binarias, que trabajan sobre dos operandos numéricos y devuelven un
resultado numérico.
Operación Operador Ejemplo Resultado
Suma + 8 + 2 10
Resta - 8 -2 6
Producto * 8 * 2 16
División exacta / 7/2 3.5
División entera /e 7 /e 2 3
Resto de división // 7 // 2 1
entera
4.2.2 Operaciones Relacionales
Son operaciones binarias, que trabajan sobre dos operandos del mismo tipo de dato (números,
textos, caracteres, valores lógicos) y devuelven un resultado lógico (booleano).
5
Órdenes/instrucciones básicas y que permiten la construcción de acciones de programación más complejas.
7
Operación Operador Ejemplo Resultado

Menor < 8<8 Falso
Menor o igual <= 8 <= 8 Verdadero
Distinto <> 'A' <> 'a' Verdadero
Mayor > Verdadero > Falso Verdadero
Mayor o igual >= 'Ala' >= 'Alambre' Falso
Igual = 5=5 Verdadero
4.2.3 Operaciones Lógicas
Las operaciones lógicas son: conjunción (Y), disyunción (O) y negación (NO). Son
binarias, trabajan sobre dos operandos lógicos y devuelven un resultado lógico (booleano).
Para determinar los resultados de las distintas operaciones lógicas se utilizan las siguientes
tablas de verdad.
A B AyB A B AoB A NO A
V V V V V V V F
V F F V F V F V
F V F F V V
F F F F F F
Normalmente las operaciones lógicas se usan con operadores de relación y matemáticos para
formar condiciones más complejas. Se usa mucho en programación la escritura de condiciones
como forma de expresar afirmaciones del lenguaje o restricciones.
Ejemplo 1: Mes es un número de mes correcto: (Mes >= 1) Y (Mes <= 12)
Mes ( Mes >= 1 ) ( Mes < = 12 ) ( Mes >= 1 ) Y ( Mes < = 12 )

-2 F V Falso
1 V V Verdadero
9 V V Verdadero
14 V F Falso
Ejemplo 2: Nota es una nota incorrecta: (Nota < 0) O (Nota > 10)
Nota (Nota < 0) (Nota > 10) (Nota < 0) O (Nota > 10)
-2 V F Verdadero
1 F F Falso
9 F F Falso
14 F V Verdadero
Uno de los errores más comunes es: confundirse de operador y utilizar el incorrecto. Por
ejemplo, ¿cómo nos damos cuenta que nos equivocamos si utilizamos la notación (Nota < 0)
Y (Nota > 10) en el caso anterior?
Hacemos una tabla como la anterior y comprobamos los resultados obtenidos.
Nota (Nota < 0) (Nota > 10) (Nota < 0) Y (Nota > 10)
-2 V F Falso
1 F F Falso
9 F F Falso
14 F V Falso
8
Observamos que a la pregunta: ¿-2 es una nota incorrecta? Se contesta Falso y a ¿14 es una
nota incorrecta? Falso. Entonces hay un problema en la expresión lógica, ya que 1 y 9 NO son
notas incorrectas.
Con este ejemplo se comprueba que la construcción de este tipo de tablas ayuda a identificar
errores.
Ejemplo 3:
Nro es un número impar (al dividirlo por dos el resto es distinto de 0): Nro // 2 <> 0
Nro Nro // 2 Nro // 2 <> 0

5 1 Verdadero
2 0 Falso
9 1 Verdadero
14 0 Falso
Ejemplo 4: A, B y C son tres números distintos: (A <> B) Y (B <> C) Y (A <> C)
Ejercicio: ¿Por qué no se consideró solamente la condición (A <> B) Y (B <> C) y por

transitividad se deduce la tercera condición?
4.2.4 Asignación
Es una acción que permite asociar un valor o resultado de una expresión a un dato (variable),
para que el mismo pueda ser usado más adelante.
Sintaxis:
Variable  Expresión
Donde expresión puede ser: una constante (literal), una variable o una expresión
matemática, relacional o lógica.
Funcionamiento:
1) Se evalúa la expresión de la derecha del símbolo de Asignación ()

2) El valor obtenido es almacenado en la variable de memoria indicada a la izquierda.
Ejemplos:
Sentencias de asignación Comentarios

Materia  'Introducción a la programacion' {Materia Є Texto}
Nro  7 {Nro Є Z}
Siguiente  Nro {Siguiente Є Z}
Siguiente  Siguiente + 1 {Siguiente Є Z}
EsPar  (N // 2) = 0 {EsPar Є Booleano}
Cociente  Nro / 2 {Cociente Є R}
4.2.5 Entrada de datos
Es una acción que permite ingresar en memoria un valor ingresado por el usuario (supóngase
por teclado) asociándolo a la variable que figura en la sentencia, para que pueda ser usado
más adelante.
Sintaxis:
9
INGRESAR Variable [, Variable]…
Donde variable es un identificador asociado a un área de memoria. Las variables pueden

ser 1 o más dependiendo de lo que se desee ingresar, pero debe existir al menos una.
Funcionamiento
El valor ingresado por teclado es almacenado en la memoria asociado al identificador de

la variable indicada.
Ejemplos:
Sentencias de entrada de datos Comentarios

INGRESAR Nro El valor ingresado se almacenará en la variable Nro.
El primer valor ingresado se almacena en la variable
INGRESAR base, altura
base y el segundo en la variable altura.
INGRESAR rpta El carácter ingresado se almacena en la variable rpta
4.2.6 Salida de datos
Es una acción que permite mostrar por pantalla valores literales (constantes), valores de
variables o resultados de expresiones.
Sintaxis:
MOSTRAR Constante | Variable | Expresión [, Constante | Variable | Expresión]…
Funcionamiento:
Se muestran por pantalla las constantes, el valor de las variables y/o el resultado de las
expresiones indicadas en la sentencia
Ejemplos:
Sentencias de entrada de datos Salida por pantalla

MOSTRAR 'La edad es:', Edad La edad es 65
MOSTRAR 'Hoy es ', Día, ' de ', Mes Hoy es 1 de enero
MOSTRAR 'El área es = ', base * altura / 2 El área es = 15
MOSTRAR 'LISTADO DE CLIENTES' LISTADO DE CLIENTES
4.2.7 Trazas
Una traza consiste en realizar un seguimiento al algoritmo con distintos valores para las
variables a fin de comprobar el funcionamiento de dicho algoritmo. Para ello se construye una
tabla con tantas columnas como variables existan en el algoritmo y otra para la salida por
pantalla.
Para que realmente la traza sirva, uno debe cumplir al pie de la letra lo indicado en el
algoritmo y olvidar lo que realmente desea hacer. Si una traza da el valor esperado, esto no
indica que el algoritmo funciona bien. Para ello hay que asegurar un conjunto de valores de
prueba que abarquen a todos los casos problemáticos.
Lo que sí se puede asegurar con una traza es que si el resultado no es el esperado, entonces el
algoritmo no funciona.
10
4.3 Acciones para estructurar el flujo de ejecución de instrucciones
Las estructuras de control son formas de especificar el orden en que las instrucciones de un
algoritmo se ejecutarán. Las tres estructuras de control básico son:
 Secuencia
 Condicional
 Repetición
Nota: En lo que sigue, Bloque representa una o más sentencias/instrucciones.
4.3.1 Secuencia
Las acciones se ejecutan una tras otra en el orden en que se encuentran escritas en el
algoritmo.
Sintaxis:
Sentencia1
Sentencia2
…
SentenciaN
Funcionamiento
1) se ejecuta la sentencia1
2) se ejecuta la sentencia2
Así sucesivamente hasta que en el paso enésimo se ejecuta la sentenciaN
Ejemplos de Secuencia
Ejemplo 1: Determinar el área de un triángulo cualquiera, conociendo la base y altura.
Algoritmo AreaDelTriangulo
Datos: B, H Є R {Datos solicitados al usuario – estado inicial}
Area Є R {Dato mostrado al usuario – estado deseado}
Comienzo
MOSTRAR 'Ingrese base y altura del triángulo'
INGRESAR B, H
Area  B * H / 2
MOSTRAR 'El area del triángulo es ', Area
FinAlgoritmo
Ejemplo 2: Expresar en centímetros y pulgadas una cantidad dada en metros.
La solución considera que 1 metro = 100 centímetros y que 1 pulgada = 2.54 centímetros.
11
Algoritmo CambiarUnidadMedida
Datos: Mts Є R {Dato solicitados al usuario – estado inicial}
Cms, Plgs Є R {Datos mostrados al usuario – estado deseado}
Comienzo
MOSTRAR 'Ingrese el valor expresado en metros. '
INGRESAR Mts
{Calcula la cantidad en centímetros y lo asigna a la variable Cms}
Cms  mts * 100
{Calcula la cantidad en pulgadas y lo asigna a la variable Plgs}
Plgs  cms / 2.54
MOSTRAR 'Los metros equivalen a ',Cms, ' centímetros y ', Plgs, ' Pulgadas'
FinAlgoritmo
Ejemplo 3: Determinar la cifra de las unidades de un número natural.
Análisis 1
Puede comprobarse que el dígito de las unidades de un número es igual al resto de la

división del número entre 10. Observar los siguientes ejemplos:
1326 10 425 10 7 10
6 132 5 42 7 0
Podemos concluir entonces que:
unidades  numero // 10
Algoritmo ObtenerUnidades
Datos: Nro Є Z {Dato solicitados al usuario – estado inicial}
Unidad Є Z {Dato mostrado al usuario – estado deseado}
Comienzo
MOSTRAR ' Ingrese un valor entero.'
INGRESAR Nro
Unidad  Nro // 10
MOSTRAR 'El valor correspondiente a la unidad es: ', Unidad
FinAlgoritmo
Análisis 2
El residuo de una división entera puede obtenerse también sin recurrir al operador //, de la
siguiente forma:
unidades  numero - (numero /e 10) * 10
Para el valor 1326, se realizan las operaciones dadas: (1326 – 1320) y se obtiene el dígito 6.
12
Algoritmo ObtenerUnidades_Version2
Datos: Nro Є Z {Dato solicitados al usuario – estado inicial}
Unidad Є Z {Dato mostrado al usuario – estado deseado}
Comienzo
MOSTRAR 'Ingrese un valor entero.'
INGRESAR Nro
Unidad  Nro – (Nro /e 10) * 10
MOSTRAR 'El valor correspondiente a la unidad es: ', Unidad
FinAlgoritmo
Atención! A partir del siguiente ejemplo colocaremos en un primer renglón aquellas

variables que corresponden a datos solicitados al usuario y cualquier restricción sobre dichos
datos se colocará a continuación de ellos. Más adelante, en este mismo documento, se verá
cómo manejar/programar estas restricciones.
En renglones consecutivos listaremos los datos usados para cálculos auxiliares.
Ejemplo 4: Una institución benéfica europea ha recibido tres donaciones en pesos, dólares y
marcos. La donación será repartida en tres rubros: 60% para un centro de salud, 30% para
un comedor de niños y el resto para gastos administrativos.
Determinar el monto en euros que le corresponde a cada rubro.
Considerar que 1 dólar = 15.5 pesos, 1 dólar = 0.51 marcos, 1 dólar = 0.83 euros.
Algoritmo RepartirDonacion
Datos: Pesos, Dolares, Marcos Є R {Restricción: (pesos > 0)Y(Dolares > 0)Y(Marcos > 0)}
Rubro1, Rubro2, Rubro3 Є R
Comienzo
MOSTRAR 'Ingrese valores correspondientes a pesos, dólares y marcos.'
INGRESAR Pesos, Dolares, Marcos
{Conversión de importes a euros}
Euros  (Pesos / 15.5 + Dolares + Marcos / 0.51) * 0.83
{Determinación de importes correspondientes a cada rubro}
Rubro1  Euros * 0.60
MOSTRAR 'El monto en euros para cada rubro es: ', Rubro1, ' ', Rubro2, ' ',Rubro3
FinAlgoritmo
Ejemplo 5: Calcular la suma de los dígitos de un número entero positivo de 3 cifras.

13
Análisis 1: Las cifras pueden ser obtenidas mediante divisiones sucesivas por 10. Considere el
caso de un número Nro igual a 256:
Nro Nro Nro
256 10 25 10 2 10
6 25 5 2 2 0
unidades decenas centenas
unidades  Nro // 10 decenas  Nro // 10 centenas  Nro // 10
Nro  Nro /e 10 Nro  Nro /e 10 Nro  Nro /e 10
Algoritmo SumarDigitos_Version1
Datos: Nro Є Z { Restricción: (Nro >= 0) Y (Nro <=999)}
Suma Є Z
Uni, Dec, Cen Є Z
Comienzo
MOSTRAR 'Ingrese un número positivo de tres dígitos'
INGRESAR Nro
Uni  Nro // 10 {Obtener las unidades}
Nro  Nro /e 10
Dec  Nro // 10 {Obtener las decenas}
Nro  Nro /e 10
Cen  Nro // 10 {Obtener las centenas}
Suma  Uni + Dec + Cen
MOSTRAR 'La suma de los dígitos da: ', Suma
FinAlgoritmo
Análisis 2: Considerando que el número tiene 3 cifras, los dígitos también pueden ser
obtenidos mediante divisiones sucesivas entre 100 y 10. Considere el caso de un número Nro
igual a 256:
256 100 56 10
56 2  centenas unidades  6 5  decenas
Algoritmo SumarDigitos_Version2
Datos: Nro Є Z { Restricción: Nro >= 0 }
Suma Є Z
Uni, Dec, Cen Є Z
Comienzo
MOSTRAR 'Ingrese un valor positivo'
INGRESAR Nro
Cen  Nro /e 100 {Obtener las centenas}
Nro  Nro //100
Dec  Nro /e 10 {Obtener las decenas}
Uni  Nro // 10 {Obtener las unidades}
Suma  Uni + Dec + Cen
MOSTRAR 'La suma de los dígitos da: ', Suma
FinAlgoritmo
Ejemplo 6: Dada la hora actual determinar cuántas horas, minutos y segundos restan para
finalizar el día.
14
Algoritmo CalcularTiempoParaFinalDelDia
Datos: Hor1, Min1, Seg1 Є Z Restricción:{(Hor1 >= 0)Y(Hor1 <= 24),
(Min1 >= 0) Y (Min1 <= 59), (Seg1 >= 0) Y (Seg1 <= 59)}
Hor2, Min2, Seg2 Є Z
SegRes, Resto Є Z
Comienzo
MOSTRAR 'Ingrese hora, minuto y segundo actuales'
INGRESAR Hor1, Min1, Seg1
{Cálculo de la cantidad de segundos que restan para culminar el día}

{60 * 60 * 24 = 86400}
SegRes  86400 - (Hor1 * 3600 + Min1 * 60 + Seg1)
{Descomposición de SegRes en horas, minutos y segundos}
Hor2  SegRes /e 3600
Resto  SegRes //3600
Min2  Resto /e 60
Seg2  Resto // 60
MOSTRAR 'Para el final del día faltan: ', Hor2, ' hs ', Min2, ' min ', Seg2, ' hs'
FinAlgoritmo
Traza:
Hor1 Min1 Seg1 Hor2 Min2 Seg2 SegRes
14 0 0
10 0 0 36000
Ejemplo 7: Sumar dos valores de tiempo dados en horas, minutos y segundos.
Algoritmo SumarDosHorarios
Datos: Hor1, Min1, Seg1, Hor1, Min1, Seg1 Є Z Є Z Restricción:{
(Hor1>=0)Y(Hor1<=24), (Min1>=0) Y (Min1<=59), (Seg1>=0) Y (Seg1 <= 59),
(Hor2 >= 0)Y(Hor2<=24), (Min2>=0) Y (Min2<=59), (Seg2>=0) Y (Seg2<=59)}
Hor3, Min3, Seg3 Є Z
TotalSeg, Resto Є Z
Comienzo
MOSTRAR 'Ingrese hora1, minuto1 y segundo1'
MOSTRAR 'Ingrese hora2, minuto2 y segundo2'
{Determina la cantidad total de segundos entre los dos tiempos}
TotSeg  (Hor1 + Hor2) * 3600 + (Min1 + Min2) * 60 + (Seg1 + Seg2)
{Pasar el total de segundos en horas, minutos y segundos}

Hor3  TotSeg /e 3600
Resto  TotSeg // 3600
Min3  Resto /e 60
Seg3 Resto // 60
MOSTRAR 'La suma da', Hor3, ' hs ', Min3, ' min ', Seg3, ' hs '
FinAlgoritmo
15
Traza:
Hor1 Min1 Seg1 Hor2 Min2 Seg2 Hor3 Min3 Seg3 Resto TotSeg
14 50 40
2 20 5
17 10 45 645 61845
Observación: existe otra forma de encontrar la solución, pero para ella debemos primero
aprender a usar el condicional.
Ejemplo 8: Determinar el porcentaje de varones y mujeres que hay en una clase.
Algoritmo CalcularPorcentajeMujeresYVarones
Datos: Varones, Mujeres Є Z
PorcVar, PorcMuj Є R
Total Є Z
Comienzo
MOSTRAR 'Ingrese los importes correspondientes a cada una de las tres ventas'
INGRESAR Varones, Mujeres
Total  Varones + Mujeres
PorcVar  Varones * 100 / Total
PorcMuj  Mujeres * 100 / Total
MOSTRAR 'El porcentaje de Varones es: ', PorcVar, 'Y el de Mujeres es: ', PorcMuj
FinAlgoritmo
Ejemplo 9: En países de habla inglesa es común expresar la estatura de una persona como
una cantidad entera de pies y una cantidad entera de pulgadas. Así, la estatura de una
persona podría ser 3' 2"(3 pies 2 pulgadas'). Diseñe un algoritmo que determine la estatura
de una persona en metros, conociendo su estatura en el formato inglés. Considere que: 1
pie=12 plg, 1 plg = 2,54 cm, 1m = 100 cm.
Fin-AlgoritmoAlgoritmo ConvertirEstatura
Datos: Pies, Pulgadas Є Z
EstMts Є R
Comienzo
MOSTRAR 'Ingrese los valores correspondientes a pies y pulgadas'
INGRESAR Pies, Pulgadas
EstMts  (pies * 12 + Pulgadas) * 2.54/ 100
MOSTRAR 'La estatura en metros es: ', EstMts
FinAlgoritmo
16
Ejemplo 10: Expresar la capacidad de un disco rígido en megabytes, kilobytes y bytes,

conociendo la capacidad del disco en gigabytes. Considere que: 1 Kb = 1024 bytes, l Mb =
1024 Kb, 1 Gb = 1024 Mb.
Algoritmo ConvertirCapacidad
Datos: CapaGb Є Z
Mb, Kb, Byte Є Z
Comienzo
MOSTRAR 'Ingrese la Capacidad indicada en GB'
INGRESAR CapaGB
Mb  CapaGb * 1024
Kb  Mb * 1024
Byte  Kb * 1024
MOSTRAR 'La capacidad en Mb es: ', Mb
MOSTRAR 'La capacidad en Kb es: ', Kb
MOSTRAR 'La capacidad en Byte es: ', Byte
FinAlgoritmo
Ejemplo 11: Intercambiar los dígitos de las unidades de 2(dos) números naturales.
Algoritmo IntercambiarUnidades
Datos: Nro1, Nro2 Є Z
Unidad1, Unidad2 Є Z
Comienzo
MOSTRAR 'Ingrese los valores de Nro1 y Nro2 respectivamente'
INGRESAR Nro1, Nro2
{Obtener las unidades de cada número}
Unidad1  Nro1 // 10
Unidad2  Nro2 // 10
{Intercambiar los dígitos de las unidades de cada número}
Nro1  Nro1 – Unidad1 + Unidad2
Nro2  Nro2 – Unidad2 + Unidad1
MOSTRAR 'Ahora Nro1 es: ', Nro1, ' y Nro2 es: ', Nro2
FinAlgoritmo
17
4.3.2 Condicional
Hay situaciones en las que hay que considerar alternativas, ya que algunas acciones deben
llevarse a cabo sólo para algunas instancias. El condicional permite que una acción o un
conjunto de acciones (bloque) se ejecute sólo si cumple cierta condición.
Sintaxis
Funcionamiento de SI-ENTONCES
SI condición Se evalúa la condición
ENTONCES Si la condición es verdadera entonces se ejecuta el

Bloque contenido dentro de ENTONCES.
Bloque Luego continúa con la instrucción siguiente a SI-
FINSI ENTONCES-FINSI.
Si la condición es falsa no se ejecuta Bloque y

directamente se continúa con la instrucción siguiente a
SI-ENTONCES-FINSI.
Funcionamiento de SI-ENTONCES-SINO
SI condición Se evalúa la condición
ENTONCES Si la condición es verdadera entonces se ejecuta

Bloque1.
Bloque1
Luego continúa con la instrucción siguiente a SI-
SINO ENTONCES-FINSI (ignorando Bloque2).
Si la condición fue falsa se ejecuta Bloque2.
Bloque2
Luego continúa con la instrucción siguiente a SI-
7FINSI ENTONCES-FINSI (ignorando Bloque1).
Funcionamiento de EN CASO
Si el valor de variable es igual a alguna de las
constantes de la primera lista de constantes (cte11,
EN CASO QUE variable SEA cte12...) entonces se ejecuta el bloque de la derecha
de esa lista (Bloque1). Luego se continúa con la
cte11, cte12... : Bloque1 ejecución de la siguiente sentencia a ENCASO-FINCASO
cte21, cte22... : Bloque2 (Ignorando los bloques contenidos en las siguientes
listas de constantes).
....
Si la variable no es igual a ninguna de las constantes
SINO de la primera lista de constantes, se continúa buscando
coincidencia en la segunda lista de constantes; y así
BloqueX
siguiendo con las demás listas de constantes hasta
FINCASO encontrar coincidencia o estas se agoten.
Si no se obtuvo ninguna coincidencia sobre ninguna las
listas de constantes y existe un SINO, se ejecuta el
bloque (BloqueX) que aparece dentro de SINO. Luego
continúa con la ejecución de la siguiente sentencia a
ENCASO-FINCASO.
18
Observaciones:
La sentencia EN-CASO-DE es equivalente a una larga lista de sentencias SI-ENTONCES

independientes.
EJEMPLOS DE CONDICIONALES
Ejemplo 1: Diseñar un algoritmo que a partir de tres números distintos determine cuál es el
mayor.
Algoritmo ObtenerMayor
Datos: A, B, C {Restricción: (A <> B) Y (B <> C) Y (A <> C)}
Maximo Є Z
Comienzo
MOSTRAR 'Ingrese tres números enteros distintos entre sí'
INGRESAR A, B, C
SI (A > B) Y (A > C)
ENTONCES
Maximo  A
SINO
SI (B > A) Y (B > C)
ENTONCES
Maximo  B
SINO
Maximo  C
FIN-SI
FIN-SI
MOSTRAR 'El Máximo es: ', Maximo
FinAlgoritmo
Algoritmo ObtenerMayor_Version2
Datos: A, B, C {Restricción: (A <> B) Y (B <> C) Y (A <> C)}
Maximo Є Z
Comienzo
MOSTRAR 'Ingrese tres números enteros distintos entre sí'
INGRESAR A, B, C
Máximo  A
SI (B > Máximo)
ENTONCES
Máximo  B
FIN-SI
SI (C > Máximo)
ENTONCES
Máximo  C
FIN-SI
MOSTRAR 'El Máximo es: ', Maximo
FinAlgoritmo
EJERCICIO: Analice ambas versiones de los algoritmos anteriores ¿Funcionan ambos? ¿Cuál
es la diferencia entre ellas? ¿Y si A fuera igual a B?
19
Ejemplo 2: Una tienda ha puesto en oferta la venta al por mayor de cierto producto,
ofreciendo un descuento del 15% por la compra de más de 3 docenas y 10% en caso
contrario. Diseñar un algoritmo que determine el monto de la compra, el descuento, el
monto a pagar.
Algoritmo CalcularImportesVentas
Datos: Docenas Є Z, Precio Є R
MontoPag, MontoDesc, MontoCpra Є R
Comienzo
MOSTRAR 'Ingrese los valores correspondientes a Docenas y Precio'
INGRESAR Docenas, Precio
{Determina el monto de la compra}
MontoCpra  Docenas * Precio
{Determina el monto del descuento}
SI (Docenas > 3) ENTONCES
MontoDesc  MontoCpra * 0.15
SINO
MontoDesc  MontoCpra * 0.10
FIN-SI
{Determina el monto a pagar por la compra}
MontoPag  MontoCpra – MontoDesc
MOSTRAR 'El monto de compra es ', MontoCpra
MOSTRAR 'El monto de descuento es ', MontoDesc
MOSTRAR 'El monto a pagar es ', MontoPag
Fin-Algoritmo
Ejemplo 3: Diseñar un algoritmo que lea un número de tres dígitos y determine si es o no

capicúa. Un número es capicúa si es igual al revés del número.
Observación: como el número tiene tres dígitos, para ser capicúa basta con que el dígito de
las unidades sea igual al dígito de las centenas. Por ejemplo: 353, 878, etc.
Algoritmo EsCapicua
Datos: Numero Є Z {Restricción: (Numero >= 100) Y (Numero <= 999) }
Unidad, Centena Є Z
Comienzo
MOSTRAR 'Ingrese un número'
INGRESAR Numero
{Determina la cifra de las unidades y la cifra de las centenas}
Unidad  Numero // 10 .
Centena  Numero /e 100
{Determina con la cifra de las unidades y la de las centenas si es o no capicúa}
SI (Unidad = Centena)
ENTONCES
MOSTRAR 'El número ES Capicua'
SINO
MOSTRAR 'El número NO es Capicua'
FIN-SI
FinAlgoritmo
20
Ejercicio: hacer una traza con un número capicúa y otra con uno que no lo sea.
Numero Unidad Centena ¿Unidad = Centena? Pantalla
Ejemplo 4: Diseñar un algoritmo que lea tres números y los muestre por pantalla de mayor
a menor y de menor a mayor.
Algoritmo MostrarNumeros
Datos: Nro1, Nro2, Nro3 Є Z
Mayor, Medio, Menor Є Z
Comienzo
MOSTRAR 'Ingrese tres números'
INGRESAR Nro1, Nro2, Nro3
{Determina el menor}
Menor  Nro1
SI (Nro2 < Menor) ENTONCES
Menor  Nro2
FIN-SI
SI (Nro3 < Menor) ENTONCES
Menor  Nro3
FIN-SI
{Determina el mayor}
Mayor  Nro1
SI (Nro2 > Mayor) ENTONCES
Mayor  Nro2
FIN-SI
SI (Nro3 > Mayor) ENTONCES
Mayor Nro3
FIN-SI
{Determina el del medio}
Medio  Nro1 + Nro2 + Nro3 – Mayor – Menor
{Imprimir en orden ascendente}
MOSTRAR 'Orden Ascendente: ', Menor, ' ', Medio, ' ', Mayor
{Imprimir en orden descendente}
MOSTRAR 'Orden Descendente: ',Mayor, ' ', Medio, ' ', Menor
Fin-Algoritmo
21
Ejemplo 6: Diseñar un algoritmo que lea tres longitudes y determine si forman o no un

triángulo. Si es un triángulo determine de que tipo es: equilátero (3 lados iguales), isósceles
(2 lados iguales) o escaleno (3 lados desiguales). Considere que para formar un triángulo se
requiere que: “el lado mayor sea menor que la suma de los otros dos lados”.
Algoritmo Triangulo
Datos: L1, L2, L3 Є R {Restricción: (Li > 0) para i = 1 .. 3 }
Tipo Є Texto
Suma, Mayor Є R
Comienzo
MOSTRAR 'Ingrese las 3 supuestos lados del triángulo'
INGRESAR L1, L2, L3
{Determina el lado mayor}
Mayor  L1
SI (L2 > Mayor)
ENTONCES
Mayor  L2
FIN-SI
SI (L3 > Mayor)

ENTONCES
Mayor  L3
FIN-SI
{Determina la suma de los lados a excepción del lado mayor}
Suma  (L1 + L2 + L3 - Mayor)
{Determina de qué tipo de triángulo se trata}
SI (Mayor < Suma)
ENTONCES
SI ( L1 = L2 ) Y ( L2 = L3 )
ENTONCES
Tipo  'Triángulo equilátero'
SINO
SI ( L1 = L2 ) o ( L1 = L3 ) o ( L2 = L3 )
ENTONCES
Tipo  'Triángulo isósceles'
SINO
Tipo  'Triángulo escaleno'
FIN-SI
FIN-SI
SINO
Tipo  'No es un triángulo'
FIN-SI
MOSTRAR Tipo
FinAlgoritmo
22
Ejemplo 7: Diseñar un algoritmo que reciba tres números enteros y determine el menor
valor positivo. Si los números positivos son iguales, dar como menor a cualquiera de ellos.
Algoritmo ObtenerMenorPositivo
Datos: Nro1, Nro2, Nro3 Є Z
Menor Є Z
Comienzo
MOSTRAR 'Ingrese los tres valores positivos'
INGRESAR Nro1, Nro2, Nro3
{Determina el número menor positivo}
SI (Nro1 > 0)
ENTONCES
Menor  Nro1
SI (Nro2 < Menor) Y (Nro2 > 0)
ENTONCES
Menor  Nro2
FIN-SI
ENTONCES
Menor  Nro3
FIN-SI
SINO
{Acá sólo Nro2 y Nro3 pueden ser positivos}
SI (Nro2 > 0)
ENTONCES
Menor  Nro2
ENTONCES
Menor  Nro3
FIN-SI
SINO
{Acá sólo Nro3 puede ser positivo}
SI (Nro3 > 0)
ENTONCES
Menor  Nro3
SINO
Menor  0 {No se recibió ningún número positivo}
FIN-SI
FIN-SI
FIN-SI
MOSTRAR 'El menor número positivo ingresado es: ', Menor
FinAlgoritmo
23
Ejemplo 5: El promedio de prácticas de un curso se calcula en base a cuatro prácticas

calificadas de las cuales se elimina la nota menor y se promedian las tres notas más altas.
Diseñar un algoritmo que determine la nota eliminada y el promedio de prácticas de un
estudiante.
Algoritmo CalcularPromedioPracticas
Datos: Pc1, Pc2, Pc3, Pc4 Є R {Restricción: (pci >= 0) Y (pci <= 10) para i = 1..4}
PcMenor, Promedio Є R
Comienzo
MOSTRAR 'Ingrese las 4 notas de práctica'
INGRESAR Pc1, Pc2, Pc3, Pc4
{Determina el menor}
PcMenor  nPc1
SI (Pc2 < Menor) ENTONCES
PcMenor  Pc2
FIN-SI
PcMenor  Pc3
FIN-SI
PcMenor  Pc4
FIN-SI
{Determina el promedio}
Promedio  (Pc1 + Pc2 + Pc3 + Pc4 - PcMenor) / 3
MOSTRAR 'El promedio de prácticas es: ', Promedio
FinAlgoritmo
Ejemplo 8: Diseñar un algoritmo para obtener el grado de eficiencia de un operario de una

fábrica de tornillos, de acuerdo a las siguientes condiciones, que se le imponen para un
periodo de prueba:
- Menos de 200 tornillos defectuosos
- Más de 10000 tornillos producidos
El grado de eficiencia se determina de la siguiente manera:

- Si no cumple ninguna de las condiciones, grado 5.
- Si sólo cumple la primera condición, grado 6.
- Si sólo cumple la segunda condición, grado 7.
- Si cumple las dos condiciones, grado 8.
24
Algoritmo CalificarPuntaje_Version1
Datos: TorProd, TorDefect Є Z {Restricción: (TorProd > 0) Y (TorDefect >= 0)}
grado Є Z
Comienzo
MOSTRAR 'Ingrese la cantidad de tornillos producida y el total de defectuosos'
INGRESAR TorProd, TorDefect
SI (TorDefec < 200)
ENTONCES
SI (TorProd > 1000)
ENTONCES
Grado  8
SINO
Grado  6
FIN-SI
SINO {Tiene más de 200 tornillos defectuosos}
SI (TorProd > 1000)
ENTONCES
Grado  7
SINO
Grado  5
FIN-SI
FIN-SI
MOSTRAR 'El grado de eficiencia es: ', Grado
FinAlgoritmo
Algoritmo CalificarPuntaje_Version2
Datos: TorProd, TorDefect Є Z {Restricción: (TorProd > 0) Y (TorDefect >= 0)}
Grado Є Z
Comienzo
MOSTRAR ‘Ingrese la cantidad de tornillos producida y el total de defectuosos’
INGRESAR TorProd, TorDefect
SI (TorDefec < 200) Y (TorProd > 1000)
ENTONCES
Grado  8
SINO
SI (TorDefec < 200)
ENTONCES
Grado  6
SINO
SI (TorProd > 1000)
ENTONCES
Grado  7
SINO
Grado  5
FIN-SI
FIN-SI
FIN-SI
MOSTRAR 'El grado de eficiencia es: ', Grado
FinAlgoritmo
Ejercicio: Hacer trazas con todos los casos posibles de los algoritmos anteriores.
25
Ejemplo 9: Se cuenta con votos obtenidos por Juan, Pedro y María en una elección para
presidente de un club. Para ganar la elección se debe obtener como mínimo el 50% de los
votos más 1. En caso que no haya un ganador se repite la elección en una segunda vuelta.
Van a la segunda vuelta los dos candidatos que obtengan la más alta votación. Se anula la
elección en caso de producirse un empate doble por el segundo lugar o un empate triple.
Diseñar un algoritmo que determine el resultado de la elección.
Algoritmo ObtenerResultadoEleccion
Datos: VotosJuan, VotosPedro, VotoMaria Є Z
{Restricción: (VotosJuan >= 0) y (VotosPedro >= 0) y (VotosMaria >= 0)}
Resultado Є Texto
VotoMin Є Z
Comienzo
MOSTRAR 'Ingrese la cantidad de votos obtenidos por Juan, Pedro y María'
INGRESAR VotosJuan, VotosPedro, VotoMaria
{Determina los votos mínimos necesarios para ganar}
VotoMin  (VotosJuan + VotosPedro + VotosMaria) /e 2 + 1
{Determina el resultado de la elección}
SI (VotosJuan > = VotoMin)
ENTONCES
Resultado 'Gana Juan'
SINO
SI (VotosPedro > = VotoMin )
ENTONCES
Resultado  'Gana Pedro'
SINO
SI (VotosMaria >= VotoMin )
ENTONCES
Resultado  'Gana María'
SINO
SI ( VotosPedro > VotosJuan) Y (VotosMaria > VotosJuan )
ENTONCES
Resultado  'Pasan a la segunda vuelta Pedro y María'
SINO
SI (VotosPedro > VotosMaria ) Y (VotosJuan > VotosMaria )
ENTONCES
Resultado  'Pasan a la segunda vuelta Pedro y Juan'
SINO
SI ( VotosMaria > VotosPedro ) Y ( VotosJuan > VotosPedro )
ENTONCES
Resultado  'Pasan a la segunda vuelta María y Juan'
SINO
Resultado  'Elección anulada'
FIN-SI
FIN-SI
FIN-SI
FIN-SI
FIN-SI
FIN-SI
Mostrar Resultado
FinAlgoritmo
26
Ejemplo 10: Diseñar un algoritmo que reciba un número de mes y devuelva el nombre del
mismo.
Algoritmo NombreDelMes_Version1
Datos: Mes Є Z {Restricción: (Mes >= 1) Y (Mes <= 12) }
NomMes Є Texto
Comienzo
MOSTRAR ‘Ingrese el número de mes’
INGRESAR Mes
SI (Mes = 1) ENTONCES
NomMes  'Enero'
FIN-SI
NomMes  'Febrero'
FIN-SI
NomMes  'Marzo'
FIN-SI
NomMes  'Abril'
FIN-SI
NomMes  'Mayo'
FIN-SI
NomMes  'Junio'
FIN-SI
NomMes  'Julio'
FIN-SI
NomMes  'Agosto'
FIN-SI
NomMes  'Septiembre'
FIN-SI
NomMes  'Octubre'
FIN-SI
NomMes  'Noviembre'
FIN-SI
NomMes  'Diciembre'
FIN-SI
MOSTRAR NomMes
FinAlgoritmo
27
NomMes Є Texto
Comienzo
INGRESAR Mes
NomMes  'Enero'
SINO
NomMes  'Febrero'
SINO
NomMes  'Marzo'
SINO
NomMes  'Abril'
SINO
NomMes  'Mayo'
SINO
NomMes  'Junio'
SINO
NomMes  'Julio'
SINO
NomMes  'Agosto'
SINO
NomMes  'Septiembre'
SINO
NomMes  'Octubre'
SINO
NomMes  'Noviembre'
SINO
NomMes  'Diciembre'
FIN-SI
FIN-SI
FIN-SI
FIN-SI
FIN-SI
FIN-SI
FIN-SI
FIN-SI
FIN-SI
FIN-SI
FIN-SI
MOSTRAR NomMes
FinAlgoritmo
28
NomMes Є Texto
Comienzo
INGRESAR Mes
EN CASO QUE Mes SEA
1: NomMes  'Enero'
2: NomMes  'Febrero'
3: NomMes  'Marzo'
4: NomMes  'Abril'
5: NomMes  'Mayo'
6: NomMes  'Junio'
7: NomMes  'Julio'
8: NomMes  'Agosto'
9: NomMes  'Septiembre'
10: NomMes  'Octubre'
11: NomMes  'Noviembre'
12: NomMes  'Diciembre'
FIN-CASO
MOSTRAR NomMes
FinAlgoritmo
4.3.3 Repetición
La repetición permite que un conjunto de acciones se ejecute más de una vez. Puede
ser que el número de repeticiones sea fijo (REPETIR-DESDE) o dependa de una
condición (REPETIR-MIENTRAS y REPETIR-HASTA).
En general, la definición de una estructura repetitiva consta de:
 El Bloque de acciones/sentencias a repetir.

 La Condición, es decir la expresión que va a servir de finalización del bucle.
 La inicialización de los datos. Antes de ingresar al bucle, considerar
cuidadosamente qué valores inicializarán los datos.
A) REPETICIÓN controlada por una condición (REPETIR-MIENTRAS)
Sintaxis
REPETIR MIENTRAS Condición
Bloque
FIN-MIENTRAS
29
Funcionamiento
1. Se evalúa la Condición
2. Si la Condición es verdadera entonces se ejecuta el Bloque contenido dentro de la
estructura RepetirMientras. Al finalizar la ejecución del Bloque, el control retoma
automáticamente al punto 1. (y así siguiendo hasta que la Condición se evalúe a
Falso).
3. Si la Condición es falsa, no se ingresa a repetir y se continúa con la orden siguiente
al FIN-MIENTRAS.
Observaciones:
 La cantidad de veces que se repite el bloque depende de la condición indicada.

Como antes de entrar a repetir se evalúa primero la condición, el bloque puede
repetirse cero o más veces.
 Hay que asegurarse que la condición sea modificada dentro del bloque a repetir
para garantizar que en algún momento tome el valor FALSO y finalicen las
repeticiones. Caso contrario, se entraría en un bucle infinito.
Ejemplo 1: escribir un algoritmo que muestre todos los números pares menores que un
número dado.
Algoritmo MostrarPares_Version1
Datos: Tope Є Z
Par Є Z
Comienzo
MOSTRAR 'Ingrese el número hasta donde se mostrarán los pares'
INGRESAR Tope
Par  2
REPETIR MIENTRAS (Par < Tope)
MOSTRAR Par
Par  Par + 2
FIN-MIENTRAS
FinAlgoritmo
En la siguiente traza se elige al número 7 como tope y se observa como salida los valores: 2,
4, 6.
Par Tope Par < Tope ? Pantalla

7
2 Sí 2
4 Sí 4
6 Sí 6
8 No
Ejemplo 2: escribir un algoritmo que genere los primeros múltiplos de 3 menores o iguales
a un número dado y calcule e imprima: la suma y el promedio.
30
Bosquejo
Generar el primer número múltiplo de tres
Mientras el número múltiplo de 3 sea menor o igual que el tope dado
Acumular su suma
Contarlo
Generar el siguiente múltiplo de 3
Calcular el promedio.
Mostrar la suma de dichos números y su promedio
Algoritmo MostrarSumaPromedio_Version1
Datos: Tope Є Z
Nro Є Z
CantNros Є Z
Suma, Prome Є R
Comienzo
MOSTRAR 'Ingrese el número Tope! '
INGRESAR Tope
Nro  3
CantNros  0
Suma  0
REPETIR MIENTRAS (Nro <= Tope)
Suma  Suma + Nro {Acumular la suma de los números}
CantNros  CantNros + 1 {Contar que se ha sumado un nro más}
Nro  Nro + 3 {Generar el próximo múltiplo de tres}
FIN-MIENTRAS
Prome  Suma / CantNros {Calcular el promedio}
MOSTRAR 'La suma es ', suma
MOSTRAR 'El promedio es ', prome
FinAlgoritmo
Ejemplo 3: escribir un algoritmo que muestre por pantalla la tabla de multiplicar de un

número dado.
Algoritmo MostrarTablaMultiplicar_Version1
Datos: Tabla Є Z
Nro Є Z
Comienzo
MOSTRAR ‘Ingrese el número de la Tabla de Multiplicar a generar!’
INGRESAR Tabla
Nro  1
REPETIR MIENTRAS ( Nro <= 10 )
MOSTRAR Nro, ' * ' , Tabla, ' = ' Nro * Tabla
Nro  Nro + 1 {Generar el próximo nro}
FIN-MIENTRAS
FinAlgoritmo
Traza: A continuación se muestra la traza para el valor de Tabla = 4.

31
Nro Tabla Nro < Tabla ? Pantalla

4
1 Sí 1*4=4
2 Sí 2*4=8
3 Sí 3 * 4 = 12
4 Sí 4 * 4 = 16
5 Sí 5 * 4 = 20
6 Sí 6 * 4 = 24
7 Sí 7 * 4 = 28
8 Sí 8 * 4 = 32
9 Sí 9 * 4 = 36
10 Sí 10 * 4 = 40
11 No
Ejemplo 4: escribir un algoritmo que permita ingresar números positivos, calcule su suma y
la muestre por pantalla. El proceso finaliza cuando se ingrese el primer valor negativo.
Bosquejo
Ingresar un número
Inicializar la suma en 0
Mientras el número sea positivo
Acumular la suma de dicho número
Ingresar otro número
Mostrar la suma obtenida
Algoritmo MostrarSumaPositivos_Version1
Datos: Nro, Suma Є Z
Comienzo
MOSTRAR 'Ingrese el primer número de la secuencia. Un número<=0 para finalizar'
INGRESAR Nro
Suma  0
REPETIR MIENTRAS (Nro > 0)
Suma  Suma + Nro {Sumar el número ingresado}
MOSTRAR 'Ingrese el siguiente número de la secuencia. 0 para finalizar'
INGRESAR un número en Nro
FIN-MIENTRAS
MOSTRAR 'La suma obtenida es ', suma
FinAlgoritmo
Ejemplo 5: Se arroja una pelota desde una determinada altura. La pelota rebota y en cada
rebote su altura se reduce en 1/3. Conocida la altura desde donde se arroja la pelota
inicialmente, determinar cuántos rebotes se produjeron cuando la pelota lleva a la altura
menor o igual a una altura final dada.
32
Algoritmo Contar_Rebotes
Datos: AlturaIni Є R,
AlturaFin Є R
CantRebotes Є Z
Comienzo
MOSTRAR 'Ingrese la altura inicial y la altura final. '
INGRESAR AlturaIni, AlturaFin
CantRebotes  0
REPETIR MIENTRAS (AlturaIni > AlturaFin)
AlturaIni  AlturaIni – (AlturaIni / 3)
CantRebotes  CantRebotes + 1
FIN-REPETIR
MOSTRAR 'La cantidad de rebotes es: ', CantRebotes
FinAlgoritmo
rebote su altura se reduce en 1/3. Determinar la altura final de la pelota luego de producirse
cierta cantidad de rebotes y conociendo la altura inicial.
Algoritmo DeterminarAltura_Version1
Datos: CantRebotes Є Z,
AlturaIni Є R
AlturaFin Є R
Comienzo
MOSTRAR 'Ingrese la cantidad de rebotes y la altura inicial.'
INGRESAR CantRebotes, AlturaIni
AlturaFin  AlturaIni
REPETIR MIENTRAS (CantRebotes >= 1)
AlturaFin  AlturaFin – (AlturaIni / 3)
CantRebotes  CantRebotes - 1
FIN-REPETIR
MOSTRAR 'La altura final es: ', AlturaFin
FinAlgoritmo
Ejemplo 7: Calcular la sumatoria de 1 + 2 + 3 + … + Tope.

33
Algoritmo CalcularSumatoria_Version1
Datos: Tope Є Z
Suma Є Z
Nro Є Z
Comienzo
MOSTRAR 'Ingrese el nro Tope para la sumatoria. '
INGRESAR Tope
Nro  1
Suma  O
REPETIR MIENTRAS (Nro < = Tope)
Nro  Nro + 1 {Generar el próximo número a sumar}
FIN-MIENTRAS
MOSTRAR 'La sumatoria es: ', suma
FinAlgoritmo
Ejemplo 8: Obtener la cantidad de divisores de un número dado.
Bosquejo
Generar el primer divisor
Inicializar cantidad de divisores en cero
Repetir mientras que divisor sea menor o igual que el número dado
Si el número es divisible por el divisor entonces contar que tiene 1 divisor más
Generar el siguiente divisor
Algoritmo ObtenerDivisores_Version1
Datos: Nro Є Z
CantDiv Є Z
Divi Є Z
Comienzo
INGRESAR Nro
Divi  1 {Generar el primer divisor}
CantDiv  0 {Inicializar cantidad de divisores en cero}
REPETIR MIENTRAS ( Divi <= Nro )
SI ( Nro // Divi = 0)
ENTONCES
CantDiv  CantDiv + 1 {Contar que hay un divisor más}
FIN-SI
Divi  Divi + 1 {Generar el próximo posible divisor}
FINMIENTRAS
MOSTRAR 'La cantidad de divisores es: ', CantDiv
FinAlgoritmo
Ejemplo 9: leer una secuencia de edades de un grupo de personas (el corte de la secuencia
se indica introduciendo un valor negativo) y determinar la máxima edad en la secuencia.
34
Bosquejo
Suponer que edad máxima es cero (Luego se la corrige)
Repetir mientras la edad sea > = 0
Ingresar una edad
Si la edad ingresada es mayor a todas las anteriores, entonces actualizar la edad Mayor
Algoritmo DeterminarEdadMaxima_Version1
Datos: Mayor Є Z
Edad Є Z
Comienzo
Mayor  0
Edad  0
REPETIR MIENTRAS (Edad >= 0)
MOSTRAR 'Ingrese una edad'
INGRESAR Edad
SI (Edad > Mayor)
ENTONCES
Mayor  Edad {Corregir el mayor}
FIN-SI
FIN-MIENTRAS
MOSTRAR 'La edad mayor es: ', Mayor
FinAlgoritmo
En la traza anterior se ingresan las edades 10, 22, 13, 42, 35 y -5 (para finalizar) y se
devuelve como edad mayor al valor 42, la cual es realmente la mayor edad ingresada.
Edad Mayor Edad >= 0 ? Edad > Mayor ?

0 Sí
10 Sí
10
Sí
22 Sí
22
Sí
13 No
Sí
42 Sí
42
Sí
35 No
Sí
-5 No
No
Ejemplo 10: dado un número y una posición dentro de este número, devolver la cifra que
esté ubicada en dicha posición. Suponer que en la posición 1 encuentran las unidades.
Ejemplos:
Dado 3752 y la posición 3 debe devolver 7.
35
Bosquejo
Comenzar por la posición de las unidades
Repetir mientras no se encuentre la posición buscada
Obtener el último dígito
Eliminar el último dígito
Aumentar en uno la posición
Algoritmo DevolverCifraenPosicion_Version1
Datos: Nro, Pos Є Z {Restricción: Pos es una posición válida de Nro }
Dig Є Z
PosDig Є Z
Comienzo
PosDig  1
MOSTRAR 'Ingrese un número y la posición de donde obtener el dígito'
INGRESAR Nro, Pos
REPETIR MIENTRAS (PosDig <= Pos)
Dig  Nro // 10
Nro  Nro /e 10
PosDig  PosDig + 1
FIN-MIENTRAS
MOSTRAR 'El dígito es: ', Dig
FinAlgoritmo
Nro Pos PosDig Dig PosDig <= Pos ?

3752 3
1 1 <= 3 ? Sí
375 2 2
2 <= 3 ? Sí
37 3 5
3 <= 3 ? Sí
3 4 7
4 <= 3 ? No
En la traza anterior se puede ver que dado el número 3752 y la posición 3, se devuelve el
dígito 7 que es el que se encuentra en dicha posición.
B) REPETICIÓN controlada por una condición (REPETIR-HASTA)
Sintaxis
REPETIR
Bloque
HASTA Condición
Funcionamiento
1) Se ejecuta el Bloque que está dentro del repetir.

2) Se evalúa la Condición.
2.a) Si la condición es falsa entonces el control retoma automáticamente al 1er
36
punto (a ejecutar el bloque nuevamente)
2.b) Si la condición es verdadera, se continúa con la orden siguiente al HASTA (fin de

las repeticiones).
Observaciones:
 Siempre Bloque se ejecuta por lo menos una vez, por que primero se entra al Bloque
y luego se evalúa la condición.
 Hay que asegurarse que la condición sea modificada dentro del bloque a repetir
para garantizar que en algún momento tome el valor VERDADERO y finalicen las
repeticiones. Caso contrario, se entraría en un bucle infinito.
Uno de los usos de esta instrucción es para validar datos de entrada.
La sintaxis es la siguiente:
REPETIR
INGRESAR dato
HASTA que dato sea correcto
Ej 1: Validar que el ingreso de un número de mes sea correcto
REPETIR
INGRESAR Mes
HASTA (Mes >= 1 ) Y ( Mes <= 12)
Ej 2: Validar que el ingreso de una nota sea correcta (entre 0 y 100).
REPETIR
INGRESAR Nota
HASTA (Nota >= 0 ) Y ( Nota <= 100)
número indicado por el usuario.
Datos: Tope Є Z
Par Є Z
Comienzo
MOSTRAR 'Ingrese el nro Tope'
INGRESAR Tope
Par  2
REPETIR
MOSTRAR Par
Par  Par + 2
HASTA Par >= Tope
FinAlgoritmo
37
Par Tope Par >= Tope ? Pantalla

7
2 2
4 4 >= 7? No
4
6 6 >= 7? No
6
8 8 >= 7? Sí
En la traza anterior se elige al número 7 como tope y se observa como salida en pantalla los
valores: 2, 4, 6.
¿Qué ocurre con este algoritmo si se ingresa como tope al valor 2?
Esto comprueba que algunas estructuras de control son mejores que otras para determinados
problemas.
Ejemplo 2: Escribir un algoritmo que genere los primeros múltiplos de 3 menores a un

número indicado por el usuario y calcule e imprima: la suma y el promedio.
Datos: Tope Є Z
Nro, CantNros Є Z
Suma, Prome Є R
Comienzo
Nro  3
CantNros  0
Suma 0
INGRESAR Tope
REPETIR
Nro  Nro + 3 {Generar el próximo múltiplo de tres}
HASTA (Nro > Tope)
FinAlgoritmo
Ejercicio: el problema del algoritmo anterior radica en que la suma se acumula sí o sí una vez.
En caso de poner como tope el 2, el algoritmo me estaría devolviendo un valor incorrecto. Es
por esto que hay que tener cuidado en la elección de la sentencia de repetición
¿Cómo podríamos resolver esta situación de modo de transformar el anterior algoritmo a una
versión que resuelva el problema (para todos los valores de Tope que pudiese indicar el
usuario)?.

número ingresado por el usuario.
38
Bosquejo
Generar el primer número de la tabla
Repetir
Mostrar una línea de la tabla de multilplicar
Generar el siguiente número
Hasta que el número sea mayor que 10
Datos: Tabla Є Z
Factor Є Z
Comienzo
MOSTRAR 'Ingrese el nro de Tabla de multiplicar'
INGRESAR Tabla
Factor  1
REPETIR
MOSTRAR Factor, ' * ' , Tabla, ' = ' Factor * Tabla
Factor  Factor + 1 {Generar el próximo nro}
HASTA (Factor > 10)
FinAlgoritmo
A continuación se muestra la traza para el valor de Tabla = 4.
Nro Tabla Nro > 10 ? Pantalla

4
1 1*4=4
2 2 > 10? No
3 2*4=8
3 > 10? No
4 3 * 4 = 12
4 > 10? No
5 4 * 4 = 16
5 > 10? No
6 5 * 4 = 20
6 > 10? No
7 6 * 4 = 24
7 > 10? No
8 7 * 4 = 28
8 > 10? No
9 8 * 4 = 32
9 > 10? No
10 9 * 4 = 36
10 > 10? No
11 10 * 4 = 40
11 > 10? Sí
la muestre por pantalla. El proceso finaliza cuando se ingrese el primer valor negativo.
39
Algoritmo MostrarNumeros _Version2

Datos: Nro, Suma Є Z
Comienzo
suma  0
REPETIR
MOSTRAR 'Ingrese un número. '
INGRESAR Nro
Si (Nro > 0)
ENTONCES
Suma  Suma + Nro
FIN-SI
HASTA (Nro < 0)
FinAlgoritmo
Ejercicio: ¿Por qué se controla que el número ingresado sea positivo en el algoritmo anterior?
Algoritmo Contar_Rebotes_Version2
Datos: AlturaIni Є R,
AlturaFin Є R
CantRebotes Є Z
Comienzo
MOSTRAR 'Ingrese la altura inicial y la altura final. '
INGRESAR AlturaIni, AlturaFin
CantRebotes  0
REPETIR
AlturaIni  AlturaIni – AlturaIni / 3
CantRebotes  CantRebotes + 1
HASTA (AlturaIni <= AlturaFin)
MOSTRAR 'La cantidad de rebotes es: ', CantRebotes
FinAlgoritmo
40
AlturaIni Є R
AlturaFin Є R
Comienzo
MOSTRAR 'Ingrese la cantidad de rebotes y la altura inicial. '
INGRESAR CantRebotes, AlturaIni
REPETIR
AlturaFin  AlturaFin – AlturaFin / 3
CantRebotes  CantRebotes - 1
HASTA (CantRebotes < 1)
FinAlgoritmo
Datos: Tope Є Z
Suma Є Z
Nro Є Z
Comienzo
INGRESAR Tope
Nro  1
Suma  O
REPETIR
Nro  Nro + 1 {Generar el próximo número a sumar}
HASTA (Nro > Tope)
FinAlgoritmo
Ejemplo 8: Obtener la cantidad de divisores de un número ingresado por el usuario.
Bosquejo
Generar el primer posible divisor
Inicializar cantidad de divisores en cero
Repetir mientras que divisor sea menor o igual que el número dado
Si el número es divisible por el divisor entonces contar que tiene 1 divisor más
Generar el siguiente divisor
41
Algoritmo ObtenerDivisores_Version2
Datos: Nro Є Z
CantDiv Є Z
Divi Є Z
Comienzo
INGRESAR Nro
Divi  1 {Generar el primer divisor}
CantDiv  0 { Inicializar cantidad de divisores en cero}
REPETIR
SI (Nro // Divi = 0)
ENTONCES
CantDiv  CantDiv + 1 {Contar que hay un divisor más}
FIN-SI
Nro  Nro + 1 {Generar el próximo divisor}
HASTA ( Divi > Nro )
MOSTRAR 'La cantidad de divisores es: ', CantDiv
FinAlgoritmo
Ejercicio: Hacer una traza para el número 6.
Ejemplo 9: leer las edades de un grupo de personas hasta que se introduzca un valor
negativo y determinar la máxima edad.
Algoritmo DeterminarEdadMaxima_Version2
Datos: Mayor Є Z
Edad Є Z
Comienzo
Mayor  0
REPETIR
MOSTRAR 'Ingrese una edad'
INGRESAR Edad
SI (Edad > Mayor)
ENTONCES
Mayor  Edad {Corregir el mayor}
FIN-SI
HASTA (Edad < 0)
MOSTRAR 'La edad mayor es: ', Mayor
FinAlgoritmo
Ejemplo 10: dado un número y una posición dentro de este número, devolver la cifra que
esté ubicada en dicha posición. Suponer que en la posición 1 encuentran las unidades.
Ejemplos:

42
Bosquejo
Comenzar por la posición de las unidades
Repetir
Aumentar en uno la posición
Hasta que se encuentre la posición buscada
Dig Є Z
PosDig Є Z
Comienzo
PosDig  1
INGRESAR Nro, Pos
REPETIR
Dig  Nro // 10
Nro  Nro /e 10
PosDig  PosDig + 1
HASTA ( PosDig > Pos )
FinAlgoritmo
En la traza anterior se puede ver que dado el número 3752 y la posición 3, se devuelve el
dígito 7 que es el que se encuentra en dicha posición.
Nro Pos PosDig Dig PosDig >Pos ?

3752 3
1
375 2 2 No
37 3 5 No
3 4 7 Sí
C) REPETICIÓN con cantidad conocida de repeticiones (REPETIR-DESDE)
Sintaxis
REPETIR PARA VariableContadora = ValorInicial HASTA ValorFinal

Bloque
FIN-REPETIR
Donde:
 VariableContadora: es una variable de tipo ordinal que es utilizada por la estructura

para controlar la cantidad de repeticiones.
 ValorInicial: es el valor inicial que toma la variable contadora.
 ValorFinal: es el valor al que debe llegar la variable contadora a través de las sucesivas
repeticiones.
43
Tanto el valor inicial como el final pueden ser constantes, variables o expresiones.
Funcionamiento
1) se inicializa a la variable contadora con el valor inicial.
2) se determina si la variable contadora es menor o igual al valor final.
a) Si la variable contadora es menor o igual al valor final entonces se ejecuta el bloque

de órdenes. Luego se incrementa (automáticamente) en uno a la variable contadora y
el control retorna automáticamente al 2° punto (para chequear si se repite
nuevamente)
b) Si la variable contadora no es menor o igual al valor final (es mayor), se continúa

con la orden siguiente al Fin-Repetir (fin de las repeticiones).
Observación: Recordar que cuando finaliza el bucle, la variable contadora del ciclo queda
indefinida, no se puede asegurar cuál es su valor en ese punto.
Datos: Tope Є Z
Nro Є Z
Comienzo
INGRESAR Tope
REPETIR PARA Nro = 1 HASTA (Tope – 1)
SI (Nro // 2 = 0)
ENTONCES
MOSTRAR Nro
FIN-SI
FIN-REPETIR
FinAlgoritmo
Nro Tope Nro <= (Tope - 1) ? Nro // 2 = 0 ? Pantalla

7
1 1 <= 6? Sí 1 // 2 = 0? No
2 2 <= 6? Sí 2 // 2 = 0? Sí 2
3 3 <= 6? Sí 3 // 2 = 0? No
4 4 <= 6? Sí 4 // 2 = 0? Sí 4
5 5 <= 6? Sí 5 // 2 = 0? No
6 6 <= 6? Sí 6 // 2 = 0? Sí 6
7 7 <= 6? No 7 // 2 = 0? No
44
Datos: Tope Є Z
Nro Є Z
Comienzo
INGRESAR Tope
REPETIR PARA Nro = 1 HASTA ((Tope – 1 /e 2)
MOSTRAR Nro * 2
FIN-REPETIR
FinAlgoritmo
Nro Nro <= (Tope - 1) /e 2 ? Tope Pantalla

7
1 Sí 2
2 Sí 4
3 Sí 6
4 No
Ejemplo 2: escribir un algoritmo que genere los primeros múltiplos de 3 menores o iguales
a un número ingresado por el usuario y calcule e imprima: la suma y el promedio.
Bosquejo
Generar todos los números múltiplos de 3 entre 1 y el límite/tope indicado
Para cada uno de estos números generados
Si el número generado es múltiplo de 3
entonces
Acumular su suma
Contarlo
Calcular el promedio.
Mostrar la suma de dichos números y su promedio
45
Datos: Tope Є Z
Nro, CantNros Є Z
Suma, Prome Є R
Comienzo
MOSTRAR 'Ingrese el número Tope! '
INGRESAR Tope
CantNros  0
Suma  0
REPETIR PARA Nro = 1 HASTA Tope
SI (Nro // 3 = 0)
ENTONCES
FIN-SI
FIN-REPETIR
FinAlgoritmo

Bosquejo
Generar los números del 1 a 10
Para cada uno de estos números mostrar una línea de la tabla de multiplicar
Datos: Tabla Є Z
Factor Є Z
Comienzo
MOSTRAR 'Ingrese el nro de Tabla de multiplicar'
INGRESAR Tabla
REPETIR PARA Factor = 1 HASTA 10
MOSTRAR Factor, ' * ' , Tabla, ' = ' Factor * Tabla
FIN-REPETIR
FinAlgoritmo
la muestre en pantalla. El proceso finaliza cuando se ingrese el primer valor negativo.
Este problema no puede resolverse utilizando la estructura REPETIR-PARA ya que no se conoce

de antemano la cantidad de números que se van a ingresar por teclado.
46


de antemano la cantidad de rebotes que se van a producir.
AlturaIni Є R
AlturaFin Є R
iЄZ
Comienzo
MOSTRAR 'Ingrese la cantidad de rebotes y la altura inicial. '
INGRESAR CantRebote, AlturaIni
REPETIR PARA i = 1 HASTA CantRebotes
AlturaFin  AlturaFin – AlturaFin / 3
FIN-REPETIR
FinAlgoritmo
Datos: Tope Є Z
Suma Є Z
Nro Є Z
Comienzo
INGRESAR Tope
Suma  O
REPETIR PARA Nro = 1 HASTA Tope
FIN-REPETIR
FinAlgoritmo
Ejemplo 8: Obtener la cantidad de divisores de un número ingresado por el usuario.
Ejercicio: Hacer!! :)
Ejemplo 9: leer las edades de un grupo de personas hasta que se introduzca un valor
negativo y determinar la máxima edad.
47

de antemano la cantidad de edades que se van a introducir.
Ejemplo 10: Solicitado un número y una posición dentro de este número, devolver la cifra
que esté ubicada en dicha posición. Suponer que en la posición 1 encuentran las unidades.
Ejemplos:
Bosquejo
Repetir desde la posición 1 a la indicada por el usuario
Dig Є Z
PosDig Є Z
Comienzo
INGRESAR Nro, Pos
REPETIR PARA PosDig = 1 HASTA Pos
Dig  Nro // 10
Nro  Nro /e 10
FIN-REPETIR
FinAlgoritmo
Buenas prácticas…
Siempre que se usen repeticiones hay que asegurarse de que el bucle sea finito. En las
repeticiones hay una transferencia de control implícita.
Cada algoritmo tiene un único punto de terminación, lo cual favorece la comprensión del
mismo y es por eso que se prohíbe la transferencia de control explícita y no estructurada.
Algunos de los indicios de una buena programación son:
a) Uso de identación de sentencias para resaltar la estructura de la resolución.

b) Uso de nombres claros y representativos para los datos y algoritmos.
c) Uso de comentarios dentro del algoritmo
5 Métodos para Resolver Problemas
Existen algunos métodos que se utilizan en la elaboración de algoritmos. Entre ellos se pueden
mencionar:
 Descomposición del problema en subproblemas (Modularización)

 Refinamiento paso a paso
 Particularización
48
 Similitud entre problemas
En general se usa una combinación de estos métodos.
Estos métodos no garantizan por sí mismos la correcta confección de un algoritmo, pero su

utilización facilita la elaboración de los mismos.
5.1 Descomposición de problema en subproblemas (Modularización)
Probablemente el principio más conocido para diseñar algoritmos sea la técnica de subdividir y
conquistar. La idea básica consiste en dividir el problema original en dos o más subproblemas
independientes (subtareas).
Es una poderosa estrategia para resolver problemas complejos, donde se descompone el

problema principal (algoritmo principal) en acciones abstractas más generales, más
abarcativas, que nuclean secuencias de instrucciones más simples, y que son incluidas en la
formulación de nuestra solución bajo la forma de métodos (subalgoritmos).
Un método se define con un nombre (identificador), una lista de datos (utilizados para
intercambiar información con los niveles superiores de abstración y que llamaremos
parámetros) y la secuencia de instrucciones que lo componen.
Es importante que cada subproblema identificado resuelva una tarea particular bien
identificada y seleccionar un nombre pertinente para el método que lo resuelva.
La idea de Abstracción se introduce en la resolución algorítmica a través del concepto de

método (subAlgoritmo).
Cuando se divide al problema en subproblemas, se habla de diseño modular. Esta estrategia

mejora la legibilidad, la comprensión y la extensión del algoritmo principal resultante.
5.1.1 Definición de Métodos (subAlgoritmos)
Sintaxis de un SubAlgoritmo
Algoritmo Nombre_Algoritmo
DE: <declaración de variables> Parámetros
DS: <declaración de variables>
DA: <declaración de variables>
Comienzo
Sentencia1
Sentencia2
Acciones de manipulación de datos y
.…
de control del flujo de ejecución.
SentenciaN
FinAlgoritmo
Un subalgoritmo es un algoritmo particular, que necesita intercambiar datos con otros

algoritmos (que lo vayan a utilizar); se hace necesario así, definir alguna forma de hacer este
intercambio de datos. Para ello es que necesitamos discriminar los datos utilizados dentro de
un subalgoritmo en datos de entrada (DE), datos de salida (DS) y datos auxiliares (DA).
Los DE y DS son los que actúan como interfaz para el intercambio de datos entre un método y
el algoritmo que lo vaya a utilizar, y reciben el nombre de parámetros del método.
49
Consideramos DE a los valores que tienen que estar disponibles al momento de invocar/llamar
al subalgoritmo; se utilizan para inicializar dichos datos dentro del subalgoritmo con valores
provistos desde al algoritmo que lo invoca. Los DS son aquellos que el subalgoritmo entrega
como resultado al algoritmo que lo invoca. Los DA son aquellos que no son datos de entrada ni
de salida pero que son útiles para cálculos intermedios que se necesiten en la resolución del
problema. Las modificaciones de los DE dentro del subalgoritmo no son visibles desde el
algoritmo que lo invoca, contrario a lo que sucede con los datos de salida.
La declaración de variables es una secuencia de cero o más declaraciones con la forma:
variable Є dominio {Restricción: …}
Las restricciones sólo aplican para DE, pudiendo no existir.
5.1.2 Invocación/llamada a un Método (subAlgoritmo)

desde otro algoritmo
A. De forma general se puede invocar a un método de la siguiente manera:
NombreMetodo (Datos de entrada, Datos de salida)
Si existe más de un dato de entrada, estos se indican como una lista de nombres separados
entre sí por comas (lo mismo para los datos de salida). Indicaremos los datos de salida con
subrayado. Si no existen datos de salida, no se escribe ninguno (lo mismo para los datos de
entrada).
Este tipo de llamada/invocación no puede formar parte de ninguna de las sentencias vistas. En
efecto, si se utiliza de esta forma, la llamada debe aparecer como una nueva sentencia dentro
del algoritmo, lo cual agrega una línea más de pseudocódigo.
Ejemplos
EsPrimo (Nro, Primo) PrimoSiguiente (Primo, ProxPrimo)
UltimoDiaDelMes (Mes, Año, UltDia) CalcularSumatoria (Tope, Suma)
MostrarSumaPromedio (Tope) MostrarSumaPositivos ()
MostrarTablaMultiplicar (Tabla) ObtenerDivisiores (Nro, Cant)
DiaSiguiente (Dia, Mes, Año, DiaSig, MesSig, AñoSig)
Nota: Este tipo de invocación se corresponde con los métodos denominados Procedimientos
en Pascal.
B. De forma particular nos enfrentamos a una situación:
El algoritmo que se desea invocar tiene un único dato de salida. La llamada a dicho método
podrá tener la siguiente sintaxis:
NombreMetodo (Datos de entrada)
Es decir, esta llamada devuelve un solo dato de salida y no lo explicita entre sus parámetros.
Así es que debemos utilizar esta llamada sí o sí dentro de otra sentencia/expresión. De este
modo la ejecución del método deja un resultado (correspondiente al valor del DS) en el preciso
lugar en que se hizo la invocación dentro de la expresión (no a través de un parámetro). Las
expresiones en las cuales puede utilizarse una llamada a otro algoritmo son:
50
 Sentencia de asignación (lado derecho)

 Expresión condicional (dentro de un condicional o un repetir)
Ejemplos
Primo  EsPrimo(Nro) ProxPrimo  PrimoSiguiente(Primo)
Si EsPrimo(Nro) = verdadero REPETIR MIENTRAS PrimoSiguiente(Primo) < Tope

ENTONCES Primo  Primo + 1
Primo  Verdadero FIN-MIENTRAS
FIN-SI
Suma  CalcularSumatoria(Tope) CantDias  CantidadDiasMes(Mes, Año)
REPETIR MIENTRAS EsPrimo (Nro) = Falso

Nro  Nro + 1
REPETIR FIN-MIENTRAS
Nro  Nro + 1
HASTA EsPrimo(Nro) = Verdadero REPETIR DESDE i = 1 a CantidadDiasMes(Mes, Año)
Cant  Cant + 1
FIN-REPETIR
Cant  ObtenerDivisores(Nro) REPETIR DESDE i = 1 a 12

Cant  Cant + CantidadDiasMes(Mes, Año)
FIN-REPETIR
Nota: Este tipo de invocación se corresponde con los métodos denominados Funciones en
Pascal.
Observaciones para ambos tipos de invocación:
En la invocación a un algoritmo deben coincidir los datos de entrada en cantidad y tipo de

datos, respecto de lo indicado en la definición del mismo (lo mismo para los datos de salida
para el caso de un algoritmo tipo procedimiento).
Los valores ingresados como datos de entrada deben respetar las restricciones indicadas en la
definición del método en cuestión.
Ejemplo 1: escribir un algoritmo que reciba una fecha representada como Dia, Mes y Año y
devuelva VERDADERO o FALSO de acuerdo a si estos datos corresponden a una fecha válida.
Una estrategia útil es asumir que disponemos de un método EsBisiesto que recibe como dato
de entrada un año y devuelve “Verdadero” si el mismo es bisiesto o “Falso” en caso contrario.
Si resuelto nuestro algoritmo principal concluimos que este método nos fue efectivamente útil,
entonces será momento de escribir/definir dicho método.
Bosquejo
Si el día está entre 1 y 31 Y es un mes con 31 días
Entonces la fecha es correcta
Sino Si el día está entre 1 y 30 Y es un mes con 30 días
Sino Si el día está entre 1 y 28 Y es febrero o el día está entre 1 y 29 y febrero es bisiesto
Sino la fecha es correcta
51
Algoritmo Fecha_Correcta
DE: Día, Mes, anio Є Z
DS: Correcta Є Booleano
Comienzo
SI ((dia >= 1) Y (dia <= 31)) Y
((mes = 1) O (mes = 3) O (mes = 5) O (mes = 7) O (mes = 8) O (mes = 10) O (mes = 12))
ENTONCES
EsCorrecta  Verdadero
SINO
SI ((dia >= 1) Y (dia <= 30)) Y ((mes = 4) O (mes = 6) O (mes = 9) O (mes = 7) O (mes = 11))
ENTONCES
SINO
SI (((dia >= 1) Y (dia <= 28)) Y (mes = 2)) O
(((dia >= 1) Y (dia <= 29)) Y ( mes = 2) Y EsBisiesto (anio))
ENTONCES
SINO
EsCorrecta  Falso
FIN-SI
FIN-SI
FIN-SI
FinAlgoritmo
En el siguiente ejemplo, se verá cómo utilizamos este algoritmo para la solución de otro
algoritmo (principal).
Ejercicio: Definir la función Es_Bisiesto.

Un año es bisiesto si cumple una de las siguientes condiciones:
a) El Año es divisible por 4 y no por 100.
b) El Año es divisible por 4 y es divisible por 100, pero no es divisible por 400.
Ejemplo 2: Contar la cantidad de días entre dos fechas. Cada fecha estará representada por
tres datos: día, mes y año.
Una alternativa es intentar inicialmente simplificar el problema. Luego se intentaría extender la

solución al problema general o al menos a una versión más cercana a él. Por ejemplo, se
puede simplificar el problema suponiendo que las fechas pertenecen al mismo mes y al mismo
año. Esta simplificación es muy fuerte pero al menos permite comenzar a diseñar una solución.
Algoritmo DiferenciaDiasDentroMes
DE: Dia1, Dia2 Є Z {Restricción: (Diai >= 1) Y (Diai <= 31) para i = 1 .. 2 }
DS: Difer Є Z
Comienzo
Difer  |Dia2 - Dia1|
FinAlgoritmo FinAlgoritmo
Se intenta ahora extender la solución para considerar fechas de distinto mes, siempre dentro
de un mismo año. Para no complicar todavía demasiado el problema, supongamos que todos
los meses tienen exactamente 30 días y no hay bisiestos.
52
El problema puede visualizarse más claramente a través de un ejemplo:
30/04 01/09
---------#-----|--------------------------|-----------#------
24/04 17/09
Si se analiza el ejemplo podemos ver que el problema puede dividirse en tres subproblemas.
Calcular los días entre el 24/04 y el 30/04, calcular los días entre el 01/09 y el 17/09 y calcular
los días intermedios. Es claro que los dos primeros subproblemas pueden pensarse a partir del
primer algoritmo DiferenciaDiasDentroMes. La tercer subtarea es simple a partir de nuestra
restricción de que todos los meses tienen 30 días.
Asumimos en este punto que disponemos de un método llamado CantidadDiasMes el cual dado
un número de mes devolverá la cantidad de días correspondiente a dicho mes.
Algoritmo DiferenciaDiasEntreFechas_DistintoMesMismoAño
DE: Dia1, Dia2, Mes1, Mes2 ЄZ
{Restricción: (Diai >= 1) Y (Diai <= 31), (Mesi >= 1) Y (Mesi <= 12) para i = 1..2 }
DS: Difer Є Z
DA: Dife1, Dife2, Inter Є Z
Comienzo
Dife1  DiferenciaDiasDentroMes(Dia1, CantidadDiasMes(Mes1))
Dife2  DifierenciaDiasDentroMes(1, Dia2)
Inter  30 * (Mes2 - Mes1 - 1)
Difer  Dife1 + Inter + Dife2
FinAlgoritmo
Ahora es más fácil diseñar un algoritmo que funcione correctamente para fechas de distinto
año, siguiendo el mismo razonamiento. No es tan sencillo en cambio, eliminar la restricción
referida a la cantidad de días de cada mes o a los bisiestos.
Como podremos observar la estrategia de modularización puede simplificar la resolución a

nuestro problema, suponiendo que tenemos disponibles ciertos métodos. También estamos
aplicando aquí la estrategia de refinamiento paso a paso que detallaremos en el siguiente
apartado.
53
Algoritmo DiferenciaDiasEntreFechas
DE: Dia1, Dia2, Mes1, Mes2, Anio1, Anio2 ЄZ
{Restricción: (Diai >= 1) Y (Diai <= 31), (Mesi >= 1) Y (Mesi <= 12) para i = 1..2 }
DS: Difer Є Z
DA: Dife1, Dife2, Inter, MesSigMes1, MesSigMes2, AnioMesSigMes1, AnioMesSigMes2 Є Z
Comienzo
Dife1  DiferenciaDiasDentroMes(Dia1, CantidadDiasMes(Mes1, Anio1))
Dife2  DiferenciaDiasDentroMes(1, Dia2)
{Calcular los días intermedios}
MesSigMes1  SiguienteMes(Mes1)
MesAntMes2  MesAnterior(Mes2)
Si MesSigMes1=1 Entonces
AnioMesSigMes1  Anio1 +1
Si MesAntMes2=12 Entonces
AnioMesAntMes2  Anio2 - 1
Inter  DiasEntre(MesSigMes1, AnioMesSigMes1, MesSigMes2, AnioMesAntMes2)
Difer  Dife1 + Inter + Dife2
FinAlgoritmo
Ejercicio 1: Habiendo resuelto nuestro algoritmo principal ahora es momento de diseñar los
subalgoritmos correspondientes a los métodos que hemos identificado para modularizar el
problema (CantidadDiasMes, SiguienteMes, MesAnterior, DiasEntre).
El algoritmo Algoritmo DiferenciaDiasEntreFechas actúa como Método debido a que no

solicita/muestra datos al usuario, sino que los inicializa/devuelve resultados a través de
parámetros. Es decir, DiferenciaDiasEntreFechas, es un algoritmo diseñado para ser usado por
otros algoritmos (no para ser ejecutado directamente, debido a que necesita que le provean de
datos de entrada).
Así es que finalmente, tenemos que diseñar un algoritmo principal que se encargue de leer los
datos, chequear si son datos válidos, utilizar la función/método DiferenciaDiasEntreFechas
para obtener el resultado y finalmente mostrar dicho resultado:
Algoritmo CalcularDiferenciaDiasEntreFechas
Datos Dias, Dia1, Dia2, Mes1, Mes2, Anio1, Anio2 Є Z
Comienzo
Mostrar 'Ingrese día, mes, año de primer fecha'
Ingresar dia1, mes1, anio1
Mostrar 'Ingrese día, mes, año de segunda fecha'
Ingresar dia2, mes2, anio2
Si EsFechaCorrecta(dia1, mes1, anio) y EsFechaCorrecta(dia1, mes1, anio)
Entonces
Dias  DiferenciaDiasEntreFechas(Dia1, Mes1, Anio1, Dia2, Mes2, Anio2)
Mostrar 'La Cantidad de días en las fechas es: ', Dias
Sino
Mostrar 'Una de las fechas ingresadas no es válida'
FinAlgoritmo
Notar que dejamos la interacción con el usuario (instrucciones INGRESAR y MOSTRAR) en el

algoritmo principal, dejando a los Métodos (subalgoritmos) libres de interacción para que
54
puedan ser reutilizados por cualquier algoritmo que requiera de su funcionalidad simplemente
intercambiando datos a través de los respectivos parámetros.
Nota: Para poder concentrarnos en las diferentes estrategias de resolución de problemas a

partir de este punto dejaremos pendiente (como ejercicio para el alumno) el diseños de los
algoritmos encargados de la interacción con el usuario lo cual será retomado en el apartado
Sintaxis del Algoritmo Principal
Ejemplo 3: Aproximación en Serie. En el siguiente ejemplo veremos cómo evaluar una

función f(x) definida por la expansión en serie infinita:
x1 x3 x5 x7 x9
f(x) = ───── + ───── + ───── + ───── + ───── + ...
1! 3! 5! 7! 9!
La evaluación de una expresión de este tipo consiste en ir calculando cada término de la serie y
acumulándolo a los anteriores. La pregunta obvia es cuándo terminar. Una manera de resolver
este problema sería calcular la función para i términos y para i+1 términos; si la diferencia es
despreciable podemos suponer que hemos alcanzado una aproximación suficientemente buena.
Se tiene que desarrollar varias tareas:

 Calcular potencias de un número.
 Calcular el factorial de un número.
 Acumular términos sucesivos.
 Determinar cuándo terminar dicha expansión.
Es claro que si tratamos de encarar todos estos problemas simultáneamente nos resultaría
difícil ya que perderíamos la idea global.
El punto es ahora definir las condiciones iniciales, la condición de corte y las acciones internas
del bloque repetitivo. En cada paso debemos mantener dos valores: la aproximación anterior y
la actual.
Una versión podría ser:
Algoritmo AproximarSerie
DE: X Є R {Restricción (X > 0)}
DS: F Є R
DA: i Є Z
AproxActual, AproxAnterior, Diferencia Є R
Comienzo
i1
Aprox_Actual  Termino(X, 1)
REPETIR
ii+2
Aprox_Anterior  Aprox_actual
Aprox_Actual  Aprox_Anterior + Termino(X, I)
Diferencia  Aprox_Actual - Aprox_Anterior
HASTA Diferencia sea despreciable
F  Aprox_Actual
FinAlgoritmo
El siguiente paso sería resolver cómo calcular cada término.

55
Aún para ejemplos sencillos es posible encontrar algoritmos más o menos diferentes para
resolver el mismo problema. Otra forma de encarar el mismo problema hubiera sido el hecho
de que cada uno de los términos es estrictamente decreciente. Por lo tanto, luego de calcular
un número grande de términos es posible que el aporte de uno nuevo sea despreciable. A
partir de este hecho un algoritmo podría haber sido:
DE: X Є R {Restricción: X > 0}
DS: F Є R
DA: i Є Z
TЄR
Comienzo
i1
f0
T  Termino(X, 1) {Primer término}
REPETIR
ii+2
ff+T
T  Termino(X, I) {I-ésimo término)
HASTA T sea despreciable
Fin-Algoritmo
Notar que en esta serie no es necesario calcular el primer término como un caso particular, el
algoritmo puede pensarse como:
DE: X Є R {Restricción (X > 0)}
DS: F Є R
DA: i Є Z
TЄR
Comienzo
i1
f0
REPETIR
T  Termino(X, I)
ff+T
ii+2
HASTA T sea despreciable
Fin-Algoritmo
Es importante notar la relación entre la inicialización de los datos y la secuencia de

instrucciones que conforman el bloque repetitivo. Al generalizar el cálculo de cada término, la
acción para incrementar i tuvo que moverse para ser ejecutada posteriormente al cálculo de
cada término. Quedan dos puntos por analizar: el cálculo del i-ésimo término y la definición de
lo que significa que un valor sea despreciable.
Ahora que el algoritmo general está resuelto, podemos ocuparnos de las acciones que
supusimos primitivas y desarrollarlas:
56
Algoritmo Termino
DE: X, I Є Z {Restricción: (X > 0), (I > 0)}
DS: T Є R
Comienzo
T  XI / I!
Fin-Algoritmo
Notar que la expresión anterior no es válida en nuestro lenguaje de diseño ya que se dan las
siguientes circunstancias:
1) El lenguaje no provee factorial como acción primitiva.

2) El lenguaje no provee potencia como acción primitiva.
3) El lenguaje no provee la evaluación de expresiones con operandos que no sean valores
simples.
Por lo tanto debemos reexpresarlo en nuestro lenguaje de diseño como:
Algoritmo Termino
DE: X, I Є Z {Restricción: (X > 0)Y(I > 0)}
DS: T Є R
DS: Pot Є Z
Fact Є Z
Comienzo
Pot  Potencia (X, I)
Fact  Factorial (I)
T  Pot / Fact
FinAlgoritmo
Se acepta el uso de Potencia porque se encontrará su definición en la próxima sección.
Ejercicio: Diseñar el algoritmo Factorial. Recordar que el factorial de un número entero

positivo se define como:
0! = 1
N! = 1 * 2 * 3 * 4 * 5 * .... * N
Por ejemplo:
2! = 1 * 2 = 2
4! = 1 * 2 * 3 * 4 = 24
El hecho de que un valor sea despreciable consiste en que toma un valor por debajo de aquel
que consideramos como despreciable. Por ejemplo, podríamos considerar como despreciable a
un término cuyo valor sea inferior a 0.0001 o permitir tener como dato de entrada dicho valor.
Se elige usar un valor despreciable de 0.0001 en la versión definitiva del algoritmo
AproximarSerie.
57
DE: X Є Z {Restricción: (X > 0) }
DS: F Є R
DA: i Є Z
TЄR
Comienzo
i1
f0
REPETIR
T  Termino(X, I)
f  f +T
ii+2
HASTA T < 0.0001
FinAlgoritmo
Cuando se escribió el algoritmo AproximarSerie se fue refinando la solución, incorporando

detalles en cada refinamiento. Una alternativa hubiera sido escribir otra versión:
Algoritmo AproximarSerie_Versión2
DE: X Є Z {Restricción: X > 0}
DS: F Є R
DA: i, Pot, Fact Є Z
TЄR
Comienzo
i1
f0
REPETIR
Pot  Potencia (X, I)
fact  Factorial ( I)
T  Pot / fact
f  f +T
ii+2
HASTA T < 0.0001
FinAlgoritmo
Esta versión no es menos correcta que la propuesta, pero es menos clara. La lógica del
problema se oscurece incorporando detalles al algoritmo general.
Nuestra propuesta es intentar modularizar nuestros algoritmos de manera tal que cada uno
pueda ser comprendido fácilmente, ya que realiza únicamente una sola tarea bien
determinada.
La técnica de diseño modular, en general, aparece combinada con el refinamiento paso a paso.
5.2 Refinamiento paso a paso
Una jerarquía es un sistema de estratos en el cual los niveles más altos operan con información
general y los más bajos trabajan con los detalles. El método de diseño de algoritmos por
refinamiento paso a paso es un ejemplo de este tipo de estructura jerárquica.
58
Una persona sólo puede concentrarse en una cantidad limitada de acciones o datos. Así es que
esta técnica trata de atemperar la limitación humana de abarcar problemas globalmente.
La estrategia puede ser aplicada en la resolución de problemas partiendo de un vago bosquejo

pasando por un algoritmo preciso hasta llegar a la implementación del mismo. La idea es
generar soluciones cada vez más minuciosas en forma paulatina, de modo que se tendrá que
manejar detalles específicos y complejos sólo en los últimos niveles del diseño.
Dado un algoritmo, cuando se incorporan más detalles generando una nueva versión, se habla
de refinamiento paso a paso.
La relación entre refinamiento paso a paso y diseño modular es muy estrecha y no hay pautas
fijas para decidir cuándo incorporar detalles al algoritmo principal y cuándo resolver los detalles
como subproblemas independientes.
Ejemplo 4: Determinar si un número entero positivo es primo. Recordar que un número es

primo si es divisible únicamente por sí mismo y por la unidad.
Una primera versión para resolver este problema podría ser:
Algoritmo EsPrimo
DE: Nro Є Z
DS: Primo Є Booleano
Comienzo
Suponer que el nro es primo
Probar con divisores distintos de 1 y Nro
SI encontré un divisor
ENTONCES
Suposición equivocada. El nro no es primo!
FinAlgoritmo
Ahora se detallará el problema de cómo buscar un divisor del número Nro.
Algoritmo EsPrimo
DE: Nro Є Z
DA: Div Є Z
Comienzo
Primo  Verdadero {Supongo que el nro es primo}
Div  2 {Genero el primer divisor a probar}
REPETIR MIENTRAS haya divisores para probar y sea primo (no encontré divisores)
Ver si el número Nro es divisible por ese divisor
Obtener el próximo divisor
SI encontré un divisor
ENTONCES
Primo  Falso
FIN-SI
FIN-MIENTRAS
FinAlgoritmo
Esta versión es más refinada que la anterior, pero todavía quedan acciones que no constituyen
primitivas en nuestro pseudolenguaje.
59
La acción de ver si un número es divisible por otro es sencilla si se obtiene el resto de la

división. Si el resto da 0 (cero) entonces el número tiene un divisor y por lo tanto no es primo,
si no se continúa probando hasta que el divisor alcance el valor N.
La acción obtener el próximo divisor es sencilla de formalizar ya que se logra incrementando en

1 al divisor.
Algoritmo EsPrimo
DE: Nro Є Z
DA: Div, Resto Є Z
Comienzo
Div  2
Primo  Verdadero
REPETIR MIENTRAS (Div < Nro) Y (Primo = Verdadero)
Resto  Nro // Div
Div  Div + 1
SI Resto = 0 {Encontré un divisor}
ENTONCES
Primo  Falso {Cambio mi suposición}
FIN-SI
FIN-MIENTRAS
FinAlgoritmo
Ejercicio: El número 1 no es primo, sin embargo los algoritmos anteriores devuelven que el 1
es primo. Arreglar el algoritmo anterior para solucionar dicho inconveniente.
Veamos una manera de resolver el problema en el ejercicio recién planteado.
En el algoritmo anterior se calculó el resto y luego se controlaba si el mismo era nulo.
Resto  Nro // Div

SI Resto = 0
ENTONCES
Primo  Falso
FIN-SI
Así se determinaba si se había encontrado un divisor y entonces el número dado no era primo.
Se puede reemplazar dichas sentencias por una sola:
EsPrimo  (Nro // Div ) <> 0
Y quedaría una versión aún más reducida del algoritmo.

60
Algoritmo EsPrimo
DE: Nro Є Z
DA: Div Є Z
Comienzo
Div  2
Primo  (Nro > 1)
REPETIR MIENTRAS (Div < Nro) Y (Primo = Verdadero)
Primo  (N // Div) <>. 0
Div  Div + 1
FIN-MIENTRAS
FinAlgoritmo
Ejercicio: Diseñar otro algoritmo EsPrimo utilizando la estructura de control REPETIR HASTA.
Controlar que funciona para los casos límite como serían el número 1 y el 2
5.3 Particularización - Uso específico de ejemplos
Tal vez la situación más común entre quienes comienzan a trabajar en programación, es que
no tienen idea acerca de cómo comenzar a resolver un problema aún luego de la fase de
definición del mismo. En este punto ocurre a menudo un bloqueo porque uno se preocupa
demasiado por los detalles de la implementación, antes de haber comprendido un problema
independientemente de su resolución.
Cuando no sabemos cómo encarar la resolución, es probable que nos convenga tomar un
problema específico de la clase, particularizar, y tratar de obtener el mecanismo que permita
resolver la clase completa de problemas.
Ejemplo 5: Dada una fecha, representada por tres datos enteros positivos Día, Mes y Año,
calcular el día siguiente.
En principio, la idea de sumar 1 al día nos parece que será suficiente para resolver el
problema.
Dada la fecha: 16/05/2011 el día siguiente será 17/03/2011.
Pero apenas nos detenemos a pensar un poco más en la resolución encontramos algunas
dificultades.
1) ¿Qué ocurre si queremos calcular el día siguiente para el último día del mes?
Dada la fecha 31/03/2011 el día siguiente será 01/04/2011.
2) ¿Qué ocurre si dicha situación se plantea a fin de año?

Dada la fecha 31/12/2011 el día siguiente será 01/01/2012.
De lo anterior obtenemos las siguientes conclusiones:
a) Si es el último día del mes y el mes es diciembre, entonces el próximo día será 1, el mes
será uno y el año estará incrementado en 1.
b) Si es el último día del mes y el mes no es diciembre, entonces el próximo día será 1, el mes
estará incrementado en uno y el año no varía.
c) Si no es el último día del mes, entonces el próximo día estará incrementado en 1 y el mes y
el año no cambiarán.
61
En el siguiente algoritmo haremos uso de una función denominada UltimoDiaDelMes que luego
pasaremos a detallar.
Bosquejo
Si no es el último día del mes entonces incrementar el día en uno, año y mes iguales
Sino
Si es diciembre entonces poner en 1 el día y el mes e incrementar en uno el año
Sino poner en 1 el día e incrementar el mes, el año queda igual
Algoritmo Dia_Siguiente
DE: Dia, Mes, Año Є: Z
{Restricciones: (Dia >=1) y (Dia <=31) y (Mes >=1) y (Mes <=12)}
DS: NuevoDia, nuevoMes, NuevoAño Є Z
Comienzo
SI UltimoDiaDeIMes(Dia, Mes, Año) = FALSO {Llamada a otra primitiva}
ENTONCES
NuevoDia  Dia + 1
NuevoMes  Mes
NuevoAño  Año
SINO {es el último día del mes}
SI Mes = 12
ENTONCES
NuevoDia  1
NuevoMes  1
NuevoAño  Año + 1
SINO {el mes no es diciembre}
NuevoDia  1
NuevoMes  Mes + 1
NuevoAño  Año
FIN-SI
FIN-SI
FinAlgoritmo
La condición si Dia es el último del mes está bien establecida para todos los meses, excepto
Febrero que tiene 28 ó 29 días en los años bisiestos.
Se sabe que los meses que tienen 30 días son: abril, junio, septiembre y noviembre; el resto
tiene 31 días. Se define ahora la función que evaluará si un día es el último día del mes. En
este caso se está usando también refinamiento paso a paso y modularización.
62
Algoritmo UltimoDiaDelMes
DE: Dia, Mes, Año Є: Z
{Restricciones: (Dia >=1) y (Dia <=31) y (Mes >=1) y (Mes <=12)}
DS: EsUtimo Є Boolean
Comienzo
SI (Dia = 31 Y (Mes = l O Mes = 3 O Mes = 5 O Mes = 7 O Mes = 8 O Mes = 12))
O (Dia = 30 Y (Mes = 4 O Mes = 6 O Mes = 9 O Mes = 11))
O (Dia = 28 Y Mes = 2 Y NO EsBisiesto(Año)) {Llamada a otra primitiva}
O (Dia = 29 Y Mes = 2 Y EsBisiesto(Año))
ENTONCES
EsUtimo  VERDADERO
SINO
EsUtimo  FALSO
FIN-SI
FinAlgoritmo
Ejercicio: Reescribir el algoritmo UltimoDiaDelMes utilizando la estructura selectiva EN CASO.
Ejemplo 6: escribir un algoritmo para calcular Base ^ Exp (léase Base elevado al exponente
Exp), con Base y Exp enteros positivos.
El algoritmo tendrá dos datos de entrada Base y Exp y un dato de salida que llamaremos Pot.
Se toma como ejemplo específico Base = 7 y Exp = 3. Entonces Pot = 7 * 7 * 7. Es decir, Pot
es igual a 3 veces 7. Generalizando, Pot es igual a Exp veces Base.
Pot  1
REPETIR DESDE i = 1 A Exp
Pot  Pot * Base
Pot debe ser inicializado en 1 ya que no es un dato de entrada y el neutro de la multiplicación

es 1.
Algoritmo Potencia
DE: Base, Exp Є Z {Restricciones: (Base >= 0) (Exp >= 0)}
DS: Pot Є Z
DS: i Є Z
Comienzo
SI Base = 0
ENTONCES
Pot  0
SINO
Pot 1
REPETIR DESDE i = 1 A Exp
Pot  Pot * Base
FIN-REPETIR
FIN-SI
FinAlgoritmo
Ejercicio: Confeccionar un algoritmo Potencia utilizando la estructura de control

REPETIR-MIENTRAS
63
Ejercicio: Confeccionar un algoritmo Potencia utilizando la estructura de control

REPETIR-HASTA
5.4 Similitud entre Problemas
Una vez que se comienza a adquirir experiencia en la resolución de problemas, es muy

improbable que un nuevo problema se nos presente en forma totalmente desconectada de los
otros que hemos visto.
Generalmente es conveniente intentar encontrar la afinidad entre el problema nuevo y algún

otro cuyo método de resolución fuese conocido.
Ejemplo 7: Contar los dígitos de un número entero positivo.
Nuevamente se puede tomar un ejemplo concreto e intentar inferir un método. Dado el

número 56329, es claro que tendrá un dígito más que 5632. Ahora, cuántos dígitos tiene
5632? La respuesta es un dígito más que 563 y así podemos seguir razonando en tanto no se
acabe el número.
La idea es ir extrayendo dígitos mientras sea posible, e ir contando el número de extracciones.

Tenemos entonces tres problemas:
1) Cómo extraer los dígitos, para pasar por ejemplo de 56329 a 5632.
2) Cómo contar las extracciones.
3) Cómo decidir que ya no es posible seguir haciendo extracciones y por lo tanto que hemos
terminado.
Se Intenta atacar de a un punto por vez. El bloque principal del algoritmo podría ser:
REPETIR
Extraer un dígito de Nro
Contar la extracción
HASTA que no haya más dígitos
Ahora ya está claro cuál será el proceso de contar y sólo debemos descubrir cómo realizar la
extracción y cuándo terminar. Para ello, recordemos que la división es una operación que
permite obtener dos resultados: el cociente y el resto. En particular, la división por 10 nos
permite ir partiendo un número en 2: el cociente que será aquel número con todos los dígitos
del original excepto el último y el resto que será justamente el último dígito. Por lo tanto, el
proceso de extracción podrá ser expresado:
Algoritmo Contar_Digitos
DE: Nro Є Z
DS: CantDig Є Z
Comienzo
CantDig  0
REPETIR
Nro  Nro /e 10
CantDig  CantDig + 1
HASTA Nro = 0
FinAlgoritmo
Aún para ejemplos sencillos como éste puede hallarse métodos de resolución diferentes.
Otra forma de encarar el problema podría haber sido:

64
Si Nro < 10  CantDig es 1

Y así sucesivamente hasta que el número dado no sea menor que el auxiliar que se va
generando.
El algoritmo puede expresarse como:
Algoritmo ContarDigitos_ V2
DE: Nro Є Z
DS: CantDig Є Z
DA: Pot10 Є Z
Comienzo
Pot10  1
CantDig  0
REPETIR
CantDig  CantDig + 1
Pot10  Pot10 * 10
HASTA Pot10 > Nro
FinAlgoritmo
Notar que la idea ahora es completamente distinta. En lugar de extraer dígitos, se compara el
número con potencias crecientes de 10 hasta llegar a una mayor que el número dado.
Ejercicio: Reescribir el algoritmo ContarDigitos utilizando la estructura de control REPETIR-

MIENTRAS.
Ejercicio: Reescribir el algoritmo ContarDigitos utilizando la estructura de control REPETIR-

DESDE.
Ejemplo 8: Invertir los dígitos de un número entero positivo.
Para este problema se puede usar una estrategia similar a la del problema anterior. Ahora ya
se sabe cómo descomponer un número, para ir tomando cada dígito. En el ejemplo anterior,
esta operación no interesaba, sino que surgió como consecuencia de analizar los resultados de
la división. La idea ahora es ir extrayendo los dígitos, desde los menos significativos hasta los
más significativos e ir componiendo el número progresivamente.
El dígito menos significativo del número dado será el más significativo del número reverso. El
segundo dígito menos significativo será el segundo más significativo y así siguiendo. Por
ejemplo si el número es 4321 el reverso es 1234.
4321  1234 = ((1 * 10 + 2) * 10 + 3) * 10 + 4
Expresado en pasos más sencillos:
0 * 10 + 1 = 1 donde 1 es el último dígito de 4321

65
Notar que al número original se le va extrayendo siempre el último dígito y que se acumula en
el reverso.
Algoritmo Reverso
DE: Nro Є Z {Restricción: Nro > 0}
DS: Reverso Є Z
DA: Dig Є Z
Comienzo
Reverso  0
REPETIR
Dig  Nro // 10
Reverso  Reverso * 10 + Dig
Nro  Nro /e 10
HASTA Nro = 0
FinAlgoritmo
Se podría haber pensado al problema como:
1234 = 1 * 1000 + 2 * 100 + 3 * 10 + 4
y se tendría el siguiente algoritmo:
Algoritmo Reverso_ V2
DE: Nro Є Z
DS: Reverso Є Z
DA: Exp, CantDig, Dig Є Z
Comienzo
CantDig  ContarDígitos(Nro) { Obtener la cantidad de dígitos del nro }
Exp  CantDig - 1
Reverso  0
REPETIR
Dig  Nro // 10
Reverso  Reverso + Dig * Potencia(10, Exp)
Exp  Exp - 1
Nro  Nro /e 10
HASTA Nro = 0
FinAlgoritmo
donde ContarDígitos y Potencia se deben definir a través de sus respectivos Métodos

(modularización)
Ejercicio: Hacer un algoritmo para sumar los dígitos de un número entero positivo. Por
ejemplo, dado el número N = 32537 el algoritmo debe devolver como resultado el valor 20.
Donde 20 se obtiene de hacer 7 + 3 + 5 + 2 + 3.
66
6 Ventajas del lenguaje de diseño
A lo largo de este documento hemos podido desarrollar:
1.- Un lenguaje de diseño de algoritmos que permite:
a) Reflejar claramente la resolución de un problema.
b) Facilitar la comunicación en equipo y definir convenciones de escritura.
c) Permitir que la traducción a un lenguaje de programación sea un proceso sencillo.
2.- Un conjunto de estrategias para encarar la solución de problemas. En particular vimos dos
estrategias muy útiles que normalmente se usan en forma combinada: refinamiento paso a
paso y descomposición de problemas.
Nuestro lenguaje de diseño promueve un estilo de diseño modular.
La idea es precisamente aplicar los conceptos de diseño modular, generando algoritmos

como secuencia de acciones más simples. Estas acciones pueden ser expandidas más
adelante, incorporando detalles, o resueltas individualmente a través de algoritmos que
resuelvan el subproblema.
6.1 Programación Estructurada
La programación modular es uno de los métodos de diseño más flexibles y potentes para
mejorar la productividad de un programa. En programación modular el programa se divide en
módulos (partes independientes), cada una de las cuales ejecuta una única actividad o tarea y
se codifican independientemente de otros módulos. Cada uno de estos módulos se analiza,
codifican y ponen a punto por separado.
Dado que los módulos son independientes, diferentes programadores pueden trabajar
simultáneamente en diferentes partes del mismo programa. Esto reducirá el tiempo de diseño
del algoritmo y posterior codificación del programa. Además, un módulo se puede modificar
radicalmente sin afectar a otros módulos, incluso sin alterar su función principal.
La descomposición de un programa en módulos independientes más simples se conoce también

como el método de divide y vencerás. Se diseña cada módulo con independencia de los demás,
y siguiendo un método ascendente o descendente se llegará hasta la descomposición final del
problema en módulos en forma jerárquica.
La programación estructurada significa escribir un programa de acuerdo a las siguientes reglas:
 El programa tiene un diseño modular.

 Los módulos son diseñados de modo descendente.
 Cada módulo se codifica utilizando las tres estructuras de control básicas: secuencia,
condicional/selección y repetición.
Estas reglas aumentan considerablemente la productividad del programa, reduciendo en

elevado grado el tiempo requerido para escribir, verificar, depurar y mantener los programas.
67
7 Algoritmo Principal – Interacción con el usuario
En términos generales un algoritmo principal tendrá el siguiente formato:
Algoritmo Principal
DA: variable Є dominio
…
variable Є dominio
Comienzo
Ingreso de datos válidos (Lectura)
Llamadas a primitivas (Cálculo)
Salida de resultados por pantalla (Impresión)
FinAlgoritmo
Un algoritmo principal no tiene datos de entrada ni de salida, ya que no recibe ni devuelve

datos en memoria.
Solamente posee datos auxiliares, que son los que se ingresan por teclado y generados por
algún cálculo.
Ejemplo: Obtener el i-ésimo dígito de un número entero positivo.

Se pide diseñar un algoritmo para buscar el i-ésimo dígito de un número entero positivo.
Suponer que se tiene un número entero positivo N en el que los dígitos se numeran de
derecha a izquierda desde 1 en adelante. Por ejemplo, si N=12583 entonces 3 es el primer
dígito y 1 es el quinto. En el caso que Y sea 4, por ejemplo, esperamos que el algoritmo
devuelva 2.
Se definen las acciones primitivas necesarias:
Algoritmo ObtenerDigitoDePosicion
DE: Nro, Pos Є Z {Restricción: Pos es una posición válida dentro de Nro}
DS: Dig Є Z
DA: Pot10 Є Z
Comienzo
Pot10  Potencia (10, pos - 1)
Dig  (Nro / pot10) // 10
FinAlgoritmo
----------------------------------------
Algoritmo Potencia
DE: Base, Exp Є Z
DS: Pot Є Z
DA: i Є Z
Comienzo
Pot  1
REPETIR PARA i = 1 A Exp
Pot  Pot * Base
FIN-REPETIR
Fin-Algoritmo
----------------------------------------
68
Algoritmo ContarDigitos
DE: Nro Є Z
DS: Cant Є Z
Comienzo
Cant  0
REPETIR
Nro  Nro /e 10
Cant  Cant + 1
HASTA Nro = 0
FinAlgoritmo
El algoritmo principal se encarga de leer los datos requeridos, validarlos y mostrar los
resultados, como sigue:
ALGORITMO PRINCIPAL
DA: Num, Pos, Dig, CantDig Є Z
COMIENZO
{Verificar que el número ingresado sea positivo}
REPETIR
LEER Num
HASTA Num >= 0
{Contar la cantidad de dígitos de número ingresado}

CantDig  ContarDigitos (Num)
{Verificar que la posición ingresada pertenezca al número ingresado}

REPETIR
LEER un número en Pos
HASTA (Pos > 0) Y (Pos <= CantDig)
{Obtener el dígito que se encuentra en la posición solicitada}

Dig  ObtenerDigitodePosicion (Num, Pos)
MOSTRAR 'En la posición', Pos, ' del número ’, Num, ' se encuentra el dígito ', Dig
FinAlgoritmo
Con este ejemplo se aprecia cómo se complican los algoritmos cuando se deben ingresar los
datos, validarlos y mostrarlos. Esto se puede evitar en los algoritmos, pero no en los
programas.
Conviene no perder de vista las recomendaciones utilizados para la resolución de problemas,

dividir el problema en subproblemas, partir de un bosquejo inicial e ir refinándolo en sucesivos
pasos y dejar para lo último el diseño del principal, para el manejo de la entrada y salida de
información (interacción con el usuario).
69
8 Bibliografía
 Grogono, Peter (1986). Programación en Pascal. Editorial Addison Wesley.

Introduccion A La Programacion de Algoritmos

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introduccion A La Programacion de Algoritmos

Uploaded by

Copyright:

Available Formats

Introducción a la

Versión de marzo de 2017

Por Laura Kees1

Es complejo entender el mundo en el que vivimos si no tenemos cierto conocimiento acerca de

La programación es una disciplina con muchas aplicaciones, incluyendo problemas no triviales

El objetivo de este material será introducir al alumno en la programación como el arte de

2 Metodología de enseñanza/aprendizaje de nuestro espacio

Se encarará la resolución de problemas utilizando Scratch, una plataforma para el desarrollo

Para reconocer la importancia de proceder de acuerdo a una metodología se intentará mostrar

Para hallar soluciones a problemas se requiere habilidad, conocimiento y experiencia.

La búsqueda de la solución de un problema es una tarea difícil de sistematizar. Cada

Estas pautas son:

 Establecer el problema en forma clara y entenderlo completamente.

Estas pautas no deben seguirse necesariamente en el orden expuesto.

Un problema se presenta en general bajo la forma de un enunciado.

La principal dificultad para hallar la solución de un problema, no es la falta de información, sino

El primer paso en la búsqueda de la solución es encontrar una representación adecuada para el

La resolución de un problema consistirá en hallar un algoritmo o un método 2 que nos

Definimos algoritmo como una secuencia de pasos o acciones para resolver un

Situación Secuencia de Situación

Gráfico simple de un Algoritmo

Con el algoritmo diseñado resulta más sencillo pasar luego a un programa.

Un algoritmo es un método para resolver un problema (clase de problemas) mediante

 Preciso porque indica el orden de realización en cada paso sin ambigüedades.

Existe el preconcepto de que los algoritmos están únicamente relacionados con la

Supongamos que nos enfrentamos al problema de buscar el significado de la palabra

"Podemos comparar la primer palabra del diccionario con ‘lenguaje’, si

diccionario está ordenado alfabéticamente y conocemos el alfabeto, nuestro algoritmo

"Podemos abrir el diccionario por la mitad -aproximadamente- y comparar

1) La palabra es igual a ’lenguaje’: EXITO.

El proceso se repite nuevamente hasta hallar lenguaje o hasta agotar el diccionario.

Si tenemos conocimiento de la distribución de las palabras en el diccionario, podríamos

"Podemos abrir el diccionario considerando la posición de la L en el alfabeto y

El esfuerzo empleado en encontrar un algoritmo se ve compensado por el hecho de que

Aunque el proceso de diseñar programas es esencialmente un proceso creativo, se puede

Las fases de resolución de un problema con computadora son:

 Análisis del problema.

La fase de compilación y ejecución requerimos de un programa especial llamado

En las fases de verificación y depuración el programador busca errores de las etapas

4 Pseudocódigo – Lenguaje de diseño de Algoritmos

Como vimos en el ejemplo anterior, para definir la estrategia se puede utilizar el

Finalmente, para que un algoritmo pueda ser transformado en un programa necesitaremos

4.1 Sintaxis de un Algoritmo

Un algoritmo está constituido por dos partes esenciales:

2) Una descripción de las acciones a ejecutar (desarrollo). Estas acciones 4 pueden

Descripción de las Acciones

Existen dos tipos de acciones que es necesario describir:

1) Acciones primitivas5 de manipulación de datos

2) Acciones para estructurar el flujo de ejecución de instrucciones

4.2 Acciones primitivas de manipulación de datos

4.2.1 Operaciones Aritméticas

Operación Operador Ejemplo Resultado

Operación Operador Ejemplo Resultado

4.2.3 Operaciones Lógicas

Mes ( Mes >= 1 ) ( Mes < = 12 ) ( Mes >= 1 ) Y ( Mes < = 12 )

Hacemos una tabla como la anterior y comprobamos los resultados obtenidos.

Nro Nro // 2 Nro // 2 <> 0

Ejemplo 4: A, B y C son tres números distintos: (A <> B) Y (B <> C) Y (A <> C)

Ejercicio: ¿Por qué no se consideró solamente la condición (A <> B) Y (B <> C) y por

1) Se evalúa la expresión de la derecha del símbolo de Asignación ()

Sentencias de asignación Comentarios

4.2.5 Entrada de datos