Algoritmos

INDICE DE CONTENIDO
CAPÍTULO I. CONCEPTOS GENERALES.......................................................................2
1.1 Introducción..............................................................................................................2
1.2 Definición de Lenguaje.............................................................................................2
1.3 Definición de Algoritmo ............................................................................................3
1.4 Tipos de Algoritmos..................................................................................................3
1.5 Lenguajes Algoritmicos. Pseudocódigo....................................................................3
CAPITULO II. ENTIDADES PRIMITIVAS PARA EL DESARROLLO DE ALGORITMOS
...........................................................................................................................................4
2.1 Tipos De Datos ........................................................................................................4
2.2 Expresiones..............................................................................................................4
2.3 Operadores y Operandos.........................................................................................4
2.3.1 Operadores Aritméticos......................................................................................4
2.3.2 Operadores Relaciónales: .................................................................................5
2.3.3 Operadores Lógicos: .........................................................................................5
2.4 Identificadores..........................................................................................................6
2.5 Constantes y Variables.............................................................................................6
2.5.1 Variables............................................................................................................6
2.5.2 Constante...........................................................................................................7
CAPÍTULO III. ESTRUCTURAS ALGORITMICAS...........................................................8
3.1. Estructuras Secuenciales........................................................................................8
3.1.1 Asignación..........................................................................................................8
3.1.2 Entrada...............................................................................................................9
3.1.3 Salida.................................................................................................................9
3.2 Estilo de programación.............................................................................................9
Problemas Secuenciales...........................................................................................10
3.3 Estructuras de Condicionales.................................................................................10
3.3.1 Simples............................................................................................................10
3.3.3 Múltiples...........................................................................................................11
3.3.4 Uso de estructuras selectivas...........................................................................12
Problemas Condicionales..........................................................................................12
3.4. Estructuras Cíclicas o Repetitivas..........................................................................14
3.4.1 Ciclos con un Numero Indeterminado de Iteraciones (Mientras, Hacer-
Mientras)...................................................................................................................15
3.4.2 Uso de estructuras repetitivas..........................................................................15
3.4.3 Hacer - mientras...............................................................................................17
3.4.4 Ciclos con un Numero Determinado de Iteraciones (Para) ............................17
CAPITULO iV. ALGORITMOS DE EJEMPLO...............................................................19
4.1 Ejemplo de uso de contadores y acumuladores.....................................................19
4.2 Uso de distintas estructuras repetitivas..................................................................19
4.3 Obtención de máximos y mínimos..........................................................................21
ANEXO - Convenciones de Pseudocódigo a utilizar ..................................................23

El desarrollo de algoritmos es un tema fundamental en el diseño de programas

por lo cual el alumno debe tener buenas bases que le sirvan para poder desarrollar de
manera fácil y rápida sus programas.

Estos apuntes servirán de apoyo a los alumnos del Curso introductorio de la

Carrera de Analista de Sistemas de la U.T.N., y al estudiante le facilitará desarrollar su
capacidad analítica y creadora, para de esta manera mejorar su destreza en la
elaboración de algoritmos que sirven como base para la codificación de los diferentes
programas que tendrá que desarrollar a lo largo de su carrera.

CAPÍTULO I. CONCEPTOS GENERALES

1.1 Introducción
La computadora no solamente es una maquina que puede realizar procesos
para darnos resultados, sin que tengamos la noción exacta de las operaciones que
realiza para llegar a esos resultados. Con la computadora además de lo anterior también
podemos diseñar soluciones a la medida, de problemas específicos que se nos
presenten. Mas aun, si estos involucran operaciones matemáticas complejas y/o
repetitivas, o requieren del manejo de un volumen muy grande de datos.
El diseño de soluciones a la medida de nuestros problemas, requiere como en
otras disciplinas una metodología que nos enseñe de manera gradual, la forma de llegar
a estas soluciones.
A las soluciones creadas por computadora se les conoce como programas y no
son mas que una serie de operaciones que realiza la computadora para llegar a un
resultado, con un grupo de datos específicos. Lo anterior nos lleva al razonamiento de
que un programa nos sirve para solucionar un problema especifico.
Para poder realizar programas, además de conocer la metodología mencionada,
también debemos de conocer, de manera especifica las funciones que puede realizar la
computadora y las formas en que se pueden manejar los elementos que hay en la
misma.

Computadora: Es un dispositivo electrónico utilizado para procesar información y

obtener resultados. Los datos y la información se pueden introducir en la computadora
como entrada (input) y a continuación se procesan para producir una salida (output).

Proceso de información en la computadora

Datos de Datos de
Proceso
entrada salida

Programa: Es el conjunto de instrucciones escritas de algún lenguaje de programación y

que ejecutadas secuencialmente resuelven un problema especifico.

1.2 Definición de Lenguaje

Lenguaje: Es una serie de símbolos que sirven para transmitir uno o mas mensajes
(ideas) entre dos entidades diferentes. A la transmisión de mensajes se le conoce
comúnmente como comunicación.

La comunicación es un proceso complejo que requiere una serie de reglas

simples, pero indispensables para poderse llevar a cabo. Las dos principales son las
siguientes:
 Los mensajes deben correr en un sentido a la vez.
 Debe forzosamente existir 4 elementos: Emisor, Receptor, Medio de Comunicación
y Mensaje.

2
Lenguajes de Programación
Es un conjunto de símbolos, caracteres y reglas (programas) que le permiten a
las personas comunicarse con la computadora.
Los lenguajes de programación tienen un conjunto de instrucciones que nos
permiten realizar operaciones de entrada/salida, calculo, manipulación de textos,
lógica/comparación y almacenamiento/recuperación.

1.3 Definición de Algoritmo

La palabra algoritmo se deriva de la traducción al latín de la palabra árabe

alkhowarizmi, nombre de un matemático y astrónomo árabe que escribió un tratado
sobre manipulación de números y ecuaciones en el siglo IX.
Un algoritmo es una serie de pasos organizados que describe el proceso que se
debe seguir, para dar solución a un problema especifico.
Es un método para resolver un problema mediante una serie de pasos precisos,
definidos y finitos.
• Preciso: no se presta a interpretaciones ambiguas
• Definido: si se siguen 2 o más veces los pasos, se obtiene el mismo resultado cada
vez
• Finito: tiene comienzo y fin; tiene un número determinado de pasos
Son ejemplos de algoritmos las instrucciones para hacer una receta de cocina, para usar
un electrodoméstico, para obtener el m.c.m. de 2 números, etc.
Los algoritmos se pueden expresar en forma de diagramas, por fórmulas y en
PSEUDOCÓDIGO. Esta última herramienta es la más usada en lenguajes estructurados
( como lenguaje C ).

Preciso
ALGORITMO Definido
↓ Finito
formado por
↓
SENTENCIAS → Acciones que pueden ser ejecutadas

1.4 Tipos de Algoritmos

 Cualitativos: Son aquellos en los que se describen los pasos utilizando palabras.
 Cuantitativos: Son aquellos en los que se utilizan cálculos numéricos para definir
los pasos del proceso.

1.5 Lenguajes Algoritmicos. Pseudocódigo

Mezcla de lenguaje de programación y español (o ingles o cualquier otro idioma)
que se emplea, dentro de la programación estructurada, para realizar el diseño de un
algoritmo. En esencial, el Pseudocódigo se puede definir como un lenguaje de
especificaciones de algoritmos.
Es la representación narrativa de los pasos que debe seguir un algoritmo para
dar solución a un problema determinado. El Pseudocódigo utiliza palabras que indican el
proceso a realizar.

Ventajas de utilizar un Pseudocódigo

 Permite representar en forma fácil operaciones repetitivas complejas
 Es muy fácil pasar de Pseudocódigo a un programa en algún lenguaje de
programación.
 Si se siguen las reglas se puede observar claramente los niveles que tiene cada
operación.

Diseño del Algoritmo

Las características de un buen algoritmo son:
Debe tener un punto particular de inicio.
Debe ser definido, no debe permitir dobles interpretaciones.

3
 Debe ser general, es decir, soportar la mayoría de las variantes que se puedan
presentar en la definición del problema.
Debe ser finito en tamaño y tiempo de ejecución.
Existen varias herramientas para hacerlo, entre ellas Pseudocódigo.

CAPITULO II. ENTIDADES PRIMITIVAS PARA EL DESARROLLO DE ALGORITMOS

2.1 Tipos De Datos

Todos los datos tienen un tipo asociado con ellos. Un dato puede ser un simple
carácter, tal como ‘b’, un valor entero tal como 35. El tipo de dato determina la naturaleza
del conjunto de valores que puede tomar una variable.

2.2 Expresiones
Las expresiones son combinaciones de constantes, variables, símbolos de
operación, paréntesis y nombres de funciones especiales. Por ejemplo:
a+(b + 3)/c
Cada expresión toma un valor que se determina tomando los valores de las
variables y constantes implicadas y la ejecución de las operaciones indicadas.
Una expresión consta de operadores y operandos. Según sea el tipo de datos
que manipulan, se clasifican las expresiones en:
- Aritméticas
- Relaciónales
- Lógicas

2.3 Operadores y Operandos

 Operadores: Son elementos que relacionan de forma diferente, los valores de una o
mas variables y/o constantes. Es decir, los operadores nos permiten manipular valores.

Aritméticos
Tipos de Operadores Relaciónales
Lógicos

2.3.1 Operadores Aritméticos.

Los operadores aritméticos permiten la realización de operaciones matemáticas con los
valores (variables y constantes).
Los operadores aritméticos pueden ser utilizados con tipos de datos enteros o
reales. Si ambos son enteros, el resultado es entero; si alguno de ellos es real, el
resultado es real.

Operando (Operador) Operando

Valor
(constante o variable)

Operadores Aritméticos
+ Suma
- Resta
* Multiplicación
/ División
Mod Modulo (residuo de la división entera)

Ejemplos:
Expresión Resultado
7*2 14
12 mod 7 5
4 +2*5 14

Prioridad de los Operadores Aritméticos

4
 Todas las expresiones entre paréntesis se evalúan primero. Las expresiones con
paréntesis anidados se evalúan de dentro a fuera, el paréntesis mas interno se evalúa
primero.
 Dentro de una misma expresión los operadores se evalúan en el siguiente orden.
1.- ^ Exponenciación
2.- *, /, Multiplicación, división, modulo.
3.- +, - Suma y resta.
 Los operadores en una misma expresión con igual nivel de prioridad se evalúan de
izquierda a derecha.

2.3.2 Operadores Relaciónales:

 Se utilizan para establecer una relación entre dos valores.

 Compara estos valores entre si y esta comparación produce un resultado de certeza
o falsedad (verdadero o falso).
 Los operadores relaciónales comparan valores del mismo tipo (numéricos o
cadenas)
 Tienen el mismo nivel de prioridad en su evaluación.
 Los operadores relaciónales tiene menor prioridad que los aritméticos.

Operadores Relaciónales
> Mayor que
< Menor que
>= Mayor o igual que
<= Menor o igual que
<> Diferente
= Igual
Ejemplos:
Si a = 10, b = 20 y c = 30

a+b>c Falso
a-b<c Verdadero
a-b=c Falso
a*b<>c Verdadero

2.3.3 Operadores Lógicos:

 Estos operadores se utilizan para establecer relaciones entre valores lógicos.

 Estos valores pueden ser resultado de una expresión relacional.

Operadores Lógicos
And Y
Or O
Not Negación

Operador AND Operador OR Operador NOT

Operando1 Operando2 Resultado Operando1 Operando2 Resultado Operando Resultado
V V V V V V T F
V F F V F V F T
F V F F V V
F F F F F F

Ejemplos: Si a = 10, b = 20 y c = 30
(a < b) and (b < c)
V and V

5
Prioridad de los Operadores Lógicos
Not
And
Or

Prioridad de los Operadores en General

1.- ( )
2.- ^
3.- *, /, Mod, Not
4.- +, -, And
5.- >, <, > =, < =, < >, =, Or

Ejemplos:
Si a = 10, b = 12, c = 13 y d =10

1) ((a > b)or(a < c)) and ((a = c) or (a > = b))

F V F F
V F
F

2) not (a = c) and (c > b)

F V
V
V

2.4 Identificadores

Los identificadores representan los datos de un programa (constantes, variables,

tipos de datos). Un identificador es una secuencia de caracteres que sirve para identificar
una posición en la memoria de la computadora, que nos permite acceder a su contenido.

Ejemplo: Nombre
Num_hrs
Calif2

Reglas para formar un Identificador

 Debe comenzar con una letra (A a Z, mayúsculas o minúsculas) y no deben contener

espacios en blanco.
 Letras, dígitos y el carácter guión ( - ) están permitidos después del primer carácter.
 La longitud de identificadores. El nombre de un identificador debe ser descriptivo de
aquello que representa, y considerando además la practicidad de su invocación durante
el desarrollo del algoritmo. Si es muy extenso estaremos más expuestos a errores al
nombrarlo.

2.5 Constantes y Variables

2.5.1 Variables.
Son objetos de un programa cuyo valor puede cambiar durante la ejecución del
mismo. Datos que pueden sufrir modificaciones a lo largo de un programa. El cambio se
produce mediante sentencias ejecutables como por ejemplo la asignación o el ingreso de
datos. Es en realidad una porción (o posición) de memoria con nombre que permite
almacenar temporalmente un dato durante la ejecución de un proceso. Para poder
reconocer una variable en la memoria de la computadora, es necesario darle un nombre
con el cual podamos identificarla dentro de un algoritmo (a esto se lo denomina
Declaración de variables). Al declararlas se reserva una posición de memoria para la
misma, donde se almacenará el valor que toma cada variable en cada momento del
programa. El nombre de la posición es el NOMBRE DE LA VARIABLE y el valor

6
almacenado es el VALOR DE LA VARIABLE. Las variables pueden ser de todos los tipos
de datos conocidos: entero, decimal, carácter, cadena de carácter.

Variables y constantes se unen por medio de los operadores aritméticos,

relacionales y lógicos constituyendo lo que se denomina una EXPRESIÓN.

2.5.2 Constante
Dato invariable a lo largo del programa. Es un valor que no puede cambiar
durante la ejecución del programa; recibe un valor en el momento de la compilación del
programa y este valor no puede ser modificado.

 Literales: es un valor de cualquier tipo que se utiliza como tal

Ejemplo:
sup-triangulo ← base * altura * 1/2
1 y 2 son constantes literales
numéricas: 5 , 3.14 , 4/3
carácter: ‘S’ , ‘N’
cadena: “Positivo”
Nota: las constantes de carácter se escriben entre apóstrofes o comillas simples y las de
cadena entre comillas. De este modo se las diferencia de los nombre de las variables.

 Con nombre o declaradas. Se les asigna un nombre y un valor y no se lo modifica

durante el transcurso del porgrama. En C se acostumbra nombrar esta clase de
constantes con mayúsculas
Ejemplo:
Define constante PI valor 3.14
sup-circulo ← PI * r * r
El uso de constantes literales limita la flexibilidad del programa. Es conveniente el uso de
constantes con nombre.
 Tipeadas. Nos referimos a los textos que aparecen como mensajes de salida en un
programa. Dichos mensajes son inalterables.
Ejemplo: Mostrar ("Hola")

7
 CAPÍTULO III. ESTRUCTURAS ALGORITMICAS

Las estructuras de operación de programas son un grupo de formas de trabajo,

que permiten, mediante la manipulación de variables, realizar ciertos procesos
específicos que nos lleven a la solución de problemas. Estas estructuras se clasifican de
acuerdo con su complejidad en:

Asignación
Secuenciales Entrada
Salida

Simples
Estructuras Condicionales Compuestas
algorítmicas Múltiples

Cíclicas o Repetir hasta (Hacer mientras)

repetitivas Mientras
Para

3.1. Estructuras Secuenciales

La estructura secuencial es aquella en la que una acción (instrucción) sigue a
otra en secuencia. Las tareas se suceden de tal modo que la salida de una es la entrada
de la siguiente y así sucesivamente hasta el fin del proceso. Una estructura secuencial
se representa de la siguiente forma:

Comienzo
Accion1
Accion2
.
.
AccionN
Fin

3.1.1 Asignación
La asignación consiste, en el paso de valores o resultados a una zona de la
memoria. Dicha zona será reconocida con el nombre de la variable que recibe el valor.
variable ← expresión ( puede ser una variable, una constante, una expresión o fórmula
a evaluar)
Ejemplos:
promedio ← suma /5
alumno ← nombre
cantidad-de-notas ← 5

Ejemplo de funcionamiento de la asignación: en las variables transfiero el valor de B a A

20 50

A B
(receptora) (emisora)

A ←B

8
 ASIGNACIÓN: la emisora mantiene su
50 50 valor y la receptora lo modifica, el dato
de la emisora reemplaza al valor anterior
A B

Se pueden asignar operaciones Ej. A← B * 2

La asignación se puede clasificar de la siguiente forma:

 Simples: Consiste en pasar un valor constante a una variable (a←15)
 Contador: Es una variable que se incrementa, cuando se ejecuta, en una unidad o
en una cantidad constante
contador ← contador + 1
multiplo ← multiplo + 3

 Acumulador: Es una variable que se incrementa en una cantidad variable

suma ← suma + numero
Donde “numero” es una variable que recibe distintos valores

Considerar:
 Una variable del lado derecho debe tener valor antes de que la sentencia se ejecute.
Si “numero” no tiene valor antes de: suma ← suma + numero
Se produce un Error LÓGICO. Se dice que “numero” no se ha inicializado.
 A la izquierda de una sentencia de asignación sólo puede haber variables. No puede
haber operaciones.

Nota: la operación de asignación es una operación destructiva debido a que el valor

almacenado en una variable se pierde o destruye y se sustituye por el nuevo valor de
asignación. Ejemplo
numero ← 16
numero ← -23
numero conservará el último valor asignado, en este caso -23

3.1.2 Entrada
La entrada de datos consiste en recibir desde un dispositivo de entrada (p.ej. el
teclado) un valor. Esta operación se representa en pseudocodigo como sigue:
Leer (a )
Leer ( b )
Donde “a” y “b” son las variables que recibirán los valores

3.1.3 Salida
Consiste en mandar por un dispositivo de salida (p.ej. monitor o impresora) un
resultado o mensaje. Este proceso se representa en pseudocodigo como sigue:
Mostrar ( “El resultado es:”, R )
Donde “El resultado es:” es un mensaje que se desea aparezca y R es una variable que
contiene un valor.

3.2 Estilo de programación

Antes de escribir los algoritmos de los ejercicios en Pseudocódigo considerar:

Un programa - Entender
legible y Más fácil de: - Corregir
comprensible - Mantener
Seguir las siguientes sugerencias:

1. SANGRADO O INDENTACIÓN. En cada estructura, y alineando las instrucciones

(sentencias) dentro de cada una de ellas y dentro de todo el algoritmo (Comienzo,
Fin)

9
2. LÍNEAS EN BLANCO. Dejarlas entre partes importantes o que estén lógicamente
separadas. Recomendable luego de cada estructura (Repetitiva o Selectiva), luego de
declaración de variables.
3. COMENTARIOS. Parte importante de la documentación de un programa que permite
mayor comprensión del mismo. (luego lo haremos en C) En Pseudocódigo entre { }
4. NOMBRES SIGNIFICATIVOS DE IDENTIFICADORES. que representen aquello que
estamos tratando. Si son palabras compuestas usar guión común. Todos deben
comenzar con una letra.
5. CADA SENTENCIA EN UNA LÍNEA DISTINTA. Al colocar una nueva sentencia
comenzar una nueva línea, incluso las palabras claves de las estructuras en líneas
separadas.
6. ESPACIOS ENTRE ELEMENTOS DE UNA SENTENCIA. lo hace más legible. Por
ejemplo:
suma ← suma + numero

Problemas Secuenciales

1) Suponga que un individuo desea invertir su capital en un banco y desea saber cuanto
dinero ganara después de un mes si el banco paga a razón de 2% mensual.
Comienzo
Leer ( capital )
ganancia ← capital * 0.02
Mostrar ( ganancia )
Fin

2) Una tienda ofrece un descuento del 15% sobre el total de la compra y un cliente desea
saber cuanto deberá pagar finalmente por su compra.
Comienzo
Leer ( total-compra)
descuento ← total-compra * 0.15
total-a-pagar ← total-compra - descuento
Mostrar ( total-a-pagar )
Fin

3) Un maestro desea saber que porcentaje de hombres y que porcentaje de mujeres hay
en un grupo de estudiantes.
Comienzo
Leer ( nun-hombres )
Leer ( num-mujeres )
total-alumnos ← nun-hombres + num-mujeres
porcen-hombres ← nun-hombres * 100 / total-alumnos
porcen-mujeres ← num-mujeres * 100 / total-alumnos
Mostrar ( porcen-hombres )
Mostrar (porcen-mujeres )
Fin

3.3 Estructuras de Condicionales

Las estructuras condicionales comparan una variable contra otro(s) valor(es),
para que, en base al resultado de esta comparación, se siga un curso de acción dentro
del programa. Cabe mencionar que la comparación se puede hacer contra otra variable o
contra una constante, según se necesite. Existen dos tipos básicos, las simples y las
múltiples.

3.3.1 Simples
Las estructuras condicionales simples se les conoce como “Tomas de decisión”.
Estas tomas de decisión tienen la siguiente forma:

Si <condición> entonces
Acción(es)
Fin-si

10
3.3.2. Dobles
Las estructuras condicionales dobles permiten elegir entre dos opciones o
alternativas posibles en función del cumplimiento o no de una determinada condición. Se
representa de la siguiente forma:

Si <condición>
entonces
Acción(es)
Fin-entonces
Sino
Acción(es)
Fin-si

Donde:
Si ………………… Indica el comando de comparación
Condición………… Indica la condición a evaluar
entonces……..…… Precede a las acciones a realizar cuando se cumple la condición
acción(es)………… Son las acciones a realizar cuando se cumple o no la condición
sino……………… Precede a las acciones a realizar cuando no se cumple la
condición

Dependiendo de si la comparación es cierta o falsa, se pueden realizar una o mas

acciones.

3.3.3 Múltiples
Las estructuras de comparación múltiples, son tomas de decisión especializadas
que permiten comparar una variable contra distintos posibles resultados, ejecutando para
cada caso una serie de instrucciones especificas. La forma común es la siguiente:

LEER (variable)
CON-SELECCIÓN (VARIABLE) HACER
CASO constante1:
Sentencias
ROMPER
CASO constante2:
Sentencias
ROMPER
CASO constanteN:
Sentencias
ROMPER
OTROS CASOS:
Sentencias
FIN-SELECCIÓN

La estructura de selección múltiple sólo compara por igualdad el valor de la

variable con cada una de las constantes de cada caso. Al encontrar una coincidencia
comienza a ejecutar las sentencias en forma secuencial hasta encontrar el fin de la
estructura o una instrucción que rompa la misma.
Puede tener hasta 257 casos.
No puede haber 2 casos con el mismo valor en la constante.
Sólo se pueden utilizar variables de tipo carácter o enteras.
Si la variable que se está seleccionando es de tipo carácter, las constantes de
tipo carácter se colocan entre comillas simples o apóstrofes, para el caso de variables de
tipo enteras, las constantes numéricas se colocan directamente.
Puede contener casos vacíos.

Ejemplo
COMIENZO
I ←1

11
 MIENTRAS ( I < 7 ) HACER
CON-SELECCIÓN ( I ) HACER
CASO 2:
CASO 4:
CASO 6:
MOSTRAR(“I ES PAR”)
ROMPER
CASO 1:
CASO 3:
CASO 5:
MOSTRAR(“I ES IMPAR”)
ROMPER
OTROS CASOS:
MOSTRAR(“I VALE 0”)
FIN-SELECCIÓN
I ←I + 1
FIN-MIENTRAS
FIN

3.3.4 Uso de estructuras selectivas

Razonemos a partir de un ejemplo. Realizar un algoritmo que permita ingresar un

número e informe “Número mayor a cero” o “Número menor o igual a cero” según
corresponda.

Análisis del problema. El algoritmo deberá:

1. Leer el número que ingresa el usuario
2. Seleccionar mediante una condición si ese numero es o no mayor a cero
3. Informar con una de las leyendas enunciadas

Desarrollo del algoritmo en pseudocódigo

COMIENZO
{ declaro las variables a utilizar}
NUMERO
{ Ingreso de datos}
MOSTRAR (“Ingrese un número:”)
LEER (NUMERO)
{ Proceso de selección}
SI ( NUMERO > 0)
ENTONCES
MOSTRAR(“Número mayor a cero”)
FIN-ENTONCES
SINO
MOSTRAR(“Número menor o igual a cero”)
FIN-SI
FIN

Problemas Condicionales

Problemas Selectivos Simples

1) Determinar si un alumno aprueba a reprueba un curso, sabiendo que aprobara si su

promedio de tres calificaciones es mayor o igual a 7; reprueba en caso contrario.
Comienzo
Leer ( nota1 )
Leer ( nota2 )
Leer ( nota3 )

prom ← nota1 +nota2 + nota3 )/3

Si ( prom >= 7 )

12
 entonces
Mostrar ( “alumno aprobado” )
Fin-entonces
si no
Mostrar ( “alumno reprobado” )
Fin-si
Fin

2) En un almacén se hace un 20% de descuento a los clientes cuya compra supere los
$1000 ¿ Cual será la cantidad que pagara una persona por su compra?
Comienzo
Leer ( compra )
Si ( compra > 1000 )
entonces
desc ← compra * 0.20
fin-entonces
si no
desc ← 0
fin-si
tot_pag ← compra - desc
Mostrar ( tot_pag )
fin.

3) Un obrero necesita calcular su salario semanal, el cual se obtiene de la sig. manera:

Si trabaja 40 horas o menos se le paga $16 por hora
Si trabaja mas de 40 horas se le paga $16 por cada una de las primeras 40 horas y $20
por cada hora extra.

Comienzo
Leer (horas-trab )
Si ( horas-trab > 40 )
entonces
horas-extras ← horas-trab - 40
salario-sem ← horas-extras * 20 + 40 * 16
fin-entonces
si no
salario-sem ← horas-trab * 16
Fin-si
Mostrar ( salario-sem )
Fin

4) Que lea dos números y los imprima en forma ascendente

Comienzo
Leer ( num1 )
Leer ( num2 )

Si ( num1 < num2 )

entonces
Mostrar ( num1, num2 )
Fin-entonces
si no
Mostrar ( num2, num1 )
fin-si
fin

5) Hacer un algoritmo que calcule el total a pagar por la compra de camisas. Si se

compran tres camisas o mas se aplica un descuento del 20% sobre el total de la compra
y si son menos de tres camisas un descuento del 10%
Comienzo
Leer ( num_camisas )

13
 Leer ( prec )
tot_comp ← num_camisas * prec
Si ( num_camisas > = 3 )
entonces
tot_pag ← tot_comp - tot_comp * 0.20
fin-entonces
si no
tot_pag ← tot_comp - tot_comp * 0.10
fin-si
Mostrar ( tot_pag )
fin

Problemas Selectivos Compuestos

1) Leer 2 números; si son iguales que los multiplique, si el primero es mayor que el
segundo que los reste y si no que los sume.
Comienzo
Leer ( num1 )
Leer ( num2 )
si ( num1 = num2 )
entonces
resul ← num1 * num2
fin-entonces
si no
si ( num1 > num2 )
entonces
resul ← num1 - num2
fin-entonces
si no
resul ← num1 + num2
fin-si
fin-si
fin

2) Leer tres números diferentes e imprimir el numero mayor de los tres.

Comienzo
Leer ( num1 )
Leer ( num2 )
Leer ( num3 )

Si ( (num1 > num2) and (num1 > num3) )

entonces
mayor ← num1
fin-entonces
si no
Si ( (num2 > num1) and (num2 > num3) )
entonces
mayor ← num2
fin-entonces
si no
mayor ← num3
fin-si
fin-si
Mostrar ( mayor )
fin

3.4. Estructuras Cíclicas o Repetitivas

Se llaman problemas repetitivos o cíclicos a aquellos en cuya solución es
necesario utilizar un mismo conjunto de acciones que se puedan ejecutar una cantidad
especifica de veces. Esta cantidad puede ser fija (previamente determinada por el

14
programador) o puede ser variable (estar en función de algún dato dentro del
programa).Los ciclos se clasifican en:

3.4.1 Ciclos con un Numero Indeterminado de Iteraciones (Mientras, Hacer-

Mientras)
Son aquellos en que el numero de iteraciones no se conoce con exactitud, ya
que esta dado en función de un dato dentro del programa.

 Mientras: Esta es una estructura que repetirá un proceso durante “N” veces, donde
“N” puede ser fijo o variable. Para esto, la instrucción se vale de una condición que es la
que debe cumplirse para que se siga ejecutando. Cuando la condición ya no se cumple,
entonces ya no se ejecuta el proceso. La forma de esta estructura es la siguiente:

Mientras <condición> Hacer

Accion1
Accion2
.
.
AccionN
Fin-mientras

3.4.2 Uso de estructuras repetitivas

Realizar un algoritmo que permita realizar 3 veces lo siguiente: ingresar 2 números

calcular su suma e informar el resultado.
El algoritmo deberá:
1. Leer el número que ingresa el usuario
2. Efectuar la suma y almacenarla
3. Mostrar el resultado almacenado
Para efectuar esto una sola vez bastaría con el siguiente algoritmo:

COMIENZO
{ Ingreso de datos}
MOSTRAR (“Ingrese primer número:”)
LEER (NUMERO1)
MOSTRAR (“Ingrese segundo número:”)
LEER (NUMERO2)
{ Proceso de suma}
RESULTADO ← NUMERO1 + NUMERO2
{ Informe por pantalla}
MOSTRAR (“El resultado de la suma es:”)
MOSTRAR (RESULTADO)
FIN

Pero el algoritmo anterior sólo efectúa una vez la suma de dos números, para que pueda
hacerlo más veces deberíamos repetir las sentencias de entrada, proceso y salida de
datos tantas veces como se solicite.

{ Ingreso de datos}
MOSTRAR (“Ingrese primer número:”)
LEER (NUMERO1)
MOSTRAR (“Ingrese segundo número:”)
LEER (NUMERO2)
{ Proceso de suma}
RESULTADO ← NUMERO1 + NUMERO2
{ Informe por pantalla}
MOSTRAR (“El resultado de la suma es:”)
MOSTRAR (RESULTADO)

Para realizar esto utilizamos una estructura repetitiva que ejecute 3 iteraciones

15
COMIENZO
{ Inicialización de variables }
CONTADOR ← 0
{ la variable contador debe tener valor inicial para que sepa a partir de que valor
comienza a contar}

MIENTRAS ( CONTADOR < 4 ) HACER

{ Ingreso de datos}
MOSTRAR (“Ingrese primer número:”)
LEER (NUMERO1)
MOSTRAR (“Ingrese segundo número:”)
LEER (NUMERO2)
{ Proceso de suma}
RESULTADO ← NUMERO1 + NUMERO2
{ Informe por pantalla}
MOSTRAR (“El resultado de la suma es:”)
MOSTRAR (RESULTADO)
{ cuento la realización de las operaciones 1 vez más }
CONTADOR ← CONTADOR + 1
FINMIENTRAS
FIN

Combinación de estructuras selectivas y repetitivas

Realizar un algoritmo que permita ingresar 5 números e informe cuantos número

ingresados son mayores a cero y cuantos menores a cero.

El algoritmo deberá:
1. Leer el número que ingresa el usuario
2. Comparar el valor del número ingresado con cero, en caso de ser mayor deberá
contar uno más de la cantidad que tenía
3. Comparar el valor del número ingresado con cero, en caso de ser menor deberá
contar uno más de la cantidad que tenía
4. Informar con una de las leyendas enunciadas

Para realizar los pasos 2 y 3 se debe usar estructuras SELECTIVAS. La lectura de

números como las distintas comparaciones se deberán ejecutar 5 veces, por lo tanto es
necesaria una estructura REPETITIVA que abarque esas sentencias. Sólo el informe se
realiza una vez.

COMIENZO
{ Inicialización de variables }
CONTAR ← 0 { variable que contará hasta 5 para controlar la cantidad de
números ingresados }
MAYOR ← 0 { variable que contará la cantidad de números mayores a cero}
MENOR ← 0 { variable que contará la cantidad de números menores a cero}

{ Ingreso de datos y proceso de selección}

MIENTRAS ( CONTAR < 5 ) HACER
MOSTRAR (“Ingrese un número:”)
LEER (NUMERO)
{ Proceso de selección}
{ utilizamos 2 SI pues en caso de ingresarse un CERO no debemos
contarlo}
SI ( NUMERO > 0)
ENTONCES
MAYOR ← MAYOR +1 { cuenta un número más mayor a
cero }
FINSI

16
 SI ( NUMERO < 0)
ENTONCES
MENOR ← MENOR +1 { cuenta un número más menor
a cero } FINSI
CONTAR ← CONTAR +1 { cuenta un número más ingresado }
FINMIENTRAS

{ informe final del proceso }

MOSTRAR(“Los números mayores a cero fueron:” )
MOSTRAR( MAYOR)
MOSTRAR(“Los números menores a cero fueron:”)
MOSTRAR( MENOR)

FIN

3.4.3 Hacer - mientras

Esta es una estructura similar en algunas características, a la anterior. Repite un
proceso una cantidad de veces, pero a diferencia del Mientras, el Hacer - mientras
permite realizar el proceso cuando menos una vez, ya que la condición se evalúa al final
del proceso, mientras que en el Mientras puede ser que nunca llegue a entrar si la
condición no se cumple desde un principio. La forma de esta estructura es la siguiente:

HACER
Accion1
Accion2
.
.
AccionN
MIENTRAS <condición>

3.4.4 Ciclos con un Numero Determinado de Iteraciones (Para)

Son aquellos en que el numero de iteraciones se conoce antes de ejecutarse el
ciclo. La forma de esta estructura es la siguiente:

Para (variable ← desde a hasta incremento) Hacer

Accion1
Accion2 .
AccionN
Fin-para

Donde:
Variable: Variable de control del ciclo ( un contador )
Desde: Limite inferir
Hasta: Limite superior
Incremento: indica de que modo se incrementa la variable de control (de 1 en 1, de 2 en
2, etc.)

En este ciclo la variable de control toma el valor inicial del ciclo y el ciclo se repite
hasta que la variable de control llegue al limite superior. La cantidad de repeticiones que
tenga depende del límite superior y del incremento de la variable

Ejemplo Para - Hacer

1) Calcular el promedio de un alumno que tiene 7 calificaciones en la materia de Diseño
Estructurado de Algoritmos
Comienzo
Sum←0
Leer (Nom)
Para (c ← 1 a 7 ) Hacer
Leer calif

17
 Sum ← sum + calif
Fin-para
prom ← sum /7
Mostrar (prom)
Fin.

2) Leer 10 números y obtener su cubo y su cuarta.

Comienzo
Para ( n ← 1 a 10 ) hacer
Leer ( num )
cubo ← num * num * num
cuarta ← cubo * num
Mostrar ( cubo )
Mostrar ( cuarta )
Fin-para
Fin.

3) Leer 10 números e imprimir solamente los números positivos

Comienzo
Para ( n ← 1 a 10 ) Hacer
Leer ( num )
Si ( num > 0 ) entonces
Mostrar ( num )
fin-si
Fin-para
Fin.

4) Leer 15 números negativos y convertirlos a positivos e imprimir dichos números.

Comienzo
Para ( x ← 1 a 15 ) Hacer
Leer ( num )
pos ← num * -1
Mostrar ( num, pos )
Fin-para
Fin.

5) Suponga que se tiene un conjunto de calificaciones de un grupo de 40 alumnos.

Realizar un algoritmo para calcular la calificación media y la calificación mas baja de
todo el grupo.
Comienzo
sum ← 0
baja ← 9999
Para ( a ← 1 a 40 ) Hacer
Leer ( calif )
sum ← sum + calif
Si ( calif < baja ) entonces
baja ← calif
fin-si
Fin-para
media ← sum / 2
Mostrar ( media, baja )
fin

6) Calcular e imprimir la tabla de multiplicar de un numero cualquiera. Imprimir el

multiplicando, el multiplicador y el producto.
Comienzo
Leer ( num )
Para ( X ← 1 a 10 ) Hacer
resul ← num * x

18
 Mostrar ( num, “ * “, X, “ = “, resul )
Fin-para
fin.

CAPITULO iV. ALGORITMOS DE EJEMPLO

4.1 Ejemplo de uso de contadores y acumuladores

Ingresar 10 números distintos de cero e informar el resultado de la suma de los
positivos y el producto de los negativos

COMIENZO
CONTADOR  0
SUMA  0
PRODUCTO  1

BORRAR PANTALLA
MIENTRAS(CONTADOR<10) HACER
MOSTRAR("Ingrese número:")
LEER(NUM)
{ bucle mientras que valida que el numero no sea cero}
MIENTRAS( NUM = 0) HACER
MOSTRAR("ERROR. Vuelva a ingresar")
LEER(NUM)
FINMIENTRAS

SI(NUM>0)
ENTONCES
SUMA SUMA+NUM
FIN-ENTONCES
SINO
PRODUCTOPRODUCTO*NUM
FINSI

CONTARCONTAR+1
FINMIENTRAS

MOSTRAR("Suma de positivos:", SUMA)

MOSTRAR("Producto de negativos:", PRODUCTO)
FIN

4.2 Uso de distintas estructuras repetitivas

Ingresar 10 números distintos de cero. Sumar los positivos y obtener el producto de los
negativos

1. Uso de la estructura MIENTRAS

COMIENZO
canti0
suma0
prod1

MIENTRAS( canti<10) HACER

MOSTRAR("Ingrese un número")
LEER(num)

MIENTRAS(num=0) HACER
MOSTRAR("Error. Vuelva a ingresar:")
LEER(num)
FINMIENTRAS

19
 SI(num>0)
ENTONCES
Suma suma+num
FIN-ENTONCES
SINO
Prod prod*num
FINSI
canticanti+1
FINMIENTRAS

MOSTRAR("La suma de los positivos es:",suma)

MOSTRAR("El producto de los negativos es:",prod)
FIN

2. Uso de la estructura HACER...MIENTRAS

COMIENZO
canti0
suma0
prod1

HACER
MOSTRAR("Ingrese un número")
LEER(num)

MIENTRAS(num=0) HACER
MOSTRAR("Error. Vuelva a ingresar:")
LEER(num)
FINMIENTRAS

SI(num>0)
ENTONCES
Suma suma+num
FIN-ENTONCES
SINO
Prod prod*num
FINSI
canticanti+1
MIENTRAS( canti<10)

MOSTRAR("La suma de los positivos es:",suma)

MOSTRAR("El producto de los negativos es:",prod)
FIN

3. Uso de la estructura PARA

COMIENZO
suma0
prod1

PARA(canti 0; canti<10;canti canti+1) HACER

MOSTRAR("Ingrese un número")
LEER(num)

MIENTRAS(num=0) HACER
MOSTRAR("Error. Vuelva a ingresar:")
LEER(num)
FINMIENTRAS

20
 SI(num>0)
ENTONCES
Suma suma+num
FIN-ENTONCES
SINO
Prod prod*num
FINSI
FINPARA

MOSTRAR("La suma de los positivos es:",suma)

MOSTRAR("El producto de los negativos es:",prod)
FIN

4. Ingresar números distintos de 0 (no se sabe cuántos). Sumar los positivos y

multiplicar los negativos.

COMIENZO
seguir 'S'
suma0
prod1

MIENTRAS( seguir = 'S' ) HACER

MOSTRAR("Ingrese un número")
LEER(num)

MIENTRAS(num=0) HACER
MOSTRAR("Error. Vuelva a ingresar:")
LEER(num)
FINMIENTRAS

SI(num>0)
ENTONCES
Suma suma+num
FIN-ENTONCES
SINO
Prod prod*num
FINSI
{sentencias de validación de seguir}
HACER
MOSTRAR("Desea continuar(S/N):")
LEER(seguir)
MIENTRAS(seguir<>'S' AND seguir <> 'N')
FINMIENTRAS

MOSTRAR("La suma de los positivos es:",suma)

MOSTRAR("El producto de los negativos es:",prod)
FIN

4.3 Obtención de máximos y mínimos

Se ingresa de 30 alumnos su nombre y promedio. Se pide informar el nombre del
mejor alumno y su promedio

COMIENZO
MEJOR-PROM 0 { variable que guarda el promedio mayor. Como se usa
para comparar debe
tener un valor inicial}
MEJOR-NOMBRE { variable que guarda el nombre del alumno de mejor
promedio}
CUENTA { contador usado como variable de control del para}

21
 { la carga se realiza dentro de una estructura para pues conozco el número de
iteraciones que tendrá el bucle}
PARA (CUENTA 0; CUENTA < 30; CUENTA CUENTA +1) HACER
MOSTRAR("INGRESE NOMBRE DEL ALUMNO:")
LEER(NOMBRE)
MOSTRAR("INGRESE PORMEDIO:")
LEER(PROM)

{ sentencias para validar que el promedio sea un valor correcto}

MIENTRAS(PROM <1 O PROM>10) HACER
MOSTRAR("ERROR. VUELVA A INGRESAR")
LEER(PROM)
FINMIENTRAS

{ compara el promedio ingresado con el mejor promedio almacenado hasta el

momento}
SI (PROM > MEJOR-PROM)
ENTONCES
MEJOR-PROM PROM
MEJOR-NOMBRE NOMBRE
FINSI
FINPARA
{ escribe el informe de datos requeridos por el ejercicio}
MOSTRAR ("EL ALUMNO DE MEJOR PROMEDIO ES:")
MOSTRAR (MEJOR-NOMBRE)
MOSTRAR ("SU PORMEDIO ES :"))
MOSTRAR (MEJOR-PROM)
FIN

22
 ANEXO - Convenciones de Pseudocódigo a utilizar

SENTENCIAS/ PSEUDOCÓDIGO
ESTRUCTURAS
ASIGNACIÓN ←
OPERADORES - (resta) + (suma)
ARITMÉTICOS / (división) ∗ (multiplicación)
Mod (resto de división entre enteros)
OPERADORES < (menor) ≤ (menor o igual)
RELACIONALES > (mayor) ≥ (mayor o igual)
= (igual) < > (distinto)
OPERADORES Y (and)
LÓGICOS O (or)
NO (not)
ENTRADA / SALIDA MOSTRAR (nombre de variable o constante)
LEER (nombre de variable)
ESTRUCTURA SI ( condición )
SELECTIVA SIMPLE ENTONCES
Sentencias
FINSI
ESTRUCTURA SI ( condición )
SELECTIVA COMPUESTA ENTONCES
Sentencias
SINO
Sentencias
FINSI
ESTRUCTURAS MIENTRAS ( condición ) HACER
REPETITIVAS Sentencias
FIN MIENTRAS

HACER
Sentencias
MIENTRAS ( condición )
ESTRUCTURA DE CON-SELECCIÓN ( variable ) HACER
SELECCIÓN MÚLTIPLE CASO constante1:
Sentencias
ROMPER
CASO constante2:
Sentencias
ROMPER
CASO constante3:
Sentencias
ROMPER
OTROS-CASOS:
Sentencias
FIN-SELECCIÓN
MANEJO DE PANTALLA BORRAR PANTALLA
OTRAS NOTAS Las constantes de tipo carácter se colocan entre apóstrofes (comillas
simples) y las constantes de cadena entre comillas. Es para diferenciar las
constantes de las variables
Para salir de una estructura repetitiva antes de que finalice (por su
condición) o alcance el número de iteraciones indicados (en el para)
utilizamos la sentencia ROMPER.
Los comentarios los consignamos entre llaves { .... }

23