Professional Documents
Culture Documents
-1-
2. La estructura del programa es clara, puesto que las instrucciones estn ms ligadas o
relacionadas entre s.
3. Reduccin del esfuerzo en las pruebas. El seguimiento de los fallos o errores del programa
("debugging") se facilita debido a la estructura ms visible, por lo que los errores se pueden
detectar y corregir ms fcilmente.
4. Reduccin de los costos de mantenimiento de los programas.
5. Programas ms sencillos y ms rpidos (ya que es ms fcil su optimizacin).
6. Los bloques de cdigo son auto explicativos, lo que facilita la documentacin.
7. Los GOTO se reservan para construir las instrucciones bsicas. Aunque no se usan de forma
directa, por estar prohibida su utilizacin, estn incluidas implcitamente en las instrucciones de
seleccin e iteracin.
8. Un programa escrito de acuerdo a estos principios no solamente tendr una mejor estructura
sino tambin una excelente presentacin.
9. La programacin estructurada ofrece estos beneficios, pero no se la debe considerar como una
panacea ya que el desarrollo de programas es, principalmente, una tarea de dedicacin, esfuerzo
y creatividad.
-2-
Un mtodo un poco ms sofisticado es la programacin por capas, en la que los mdulos tienen
una estructura jerrquica en la que se pueden definir funciones dentro de funciones o de
procedimientos.
-3-
escribir ( la suma es:, suma, y el producto es , prod) // se muestra por pantalla un mensaje
//junto a los valores calculados
fin
Inicio
Leer (a,b)
suma a +b
prod a*b
fin
Figura 1
Las dos barras inclinadas // indican que lo que sigue a continuacin de ellas hacia la derecha es
un comentario.
Ej2) Calcular el salario neto de un trabajador, en funcin del nmero de horas trabajadas, precio
de la hora de trabajo. Se considerarn descuentos fijos 20% del salario bruto. El salario neto se
calcula como el salario bruto menos los impuestos.
-4-
Ingresar nombre, precio hora y cantidad de horas, mostrar por pantalla nombre, salario bruto y
neto.
Pseudocdigo:
Algoritmo Calcula_salarios
Var:
real: precioHora, salBruto, salNeto, impuesto
cadena: nombre
real: cantHoras
Inicio:
// se solicita el ingreso de datos desde el teclado
//declaracin de variables
Palabras reservadas de esta estructuras son: si entonces fin-si, si entonces si-no fin-si,
Segn-sea caso de.
Estas estructuras establecen distintas posibilidades o caminos a seguir segn el resultado de una
expresin.
-5-
Evala una expresin, si esta es verdadera ejecuta la accin o acciones especificadas, si es falsa
no realiza ninguna accin, es decir se saltean las instrucciones asociadas al si, y se prosigue con
la programacin.
Es decir la estructura alternativa simple si-entonces ejecuta una o varias acciones cuando se
cumple determinada condicin.
Palabras reservadas de esta estructura: si entonces fin-si
Pseudocdigo
Inicio
Escribir(ingresar nombre,
cantidad horas trabajadas,
monto por hora)
Leer (nombre,
precioHora, cantHora)
Escribir (nombre,
salBruto, salNeto)
fin
Figura 2
-6-
sentencia1
sentencia2
sentenciaN
fin-si
sentencia4
sentencia5
Observar que en el pseudocdigo las acciones que siguen a la palabra reservada, entonces, y las
que sigue al si-no, se encuentran indentadas en relacin a las palabreas reservadas si y fin-si.
Esta forma de escribir aumenta la legibilidad de la estructura y este es el medio ms idneo para
representar algoritmos.
En la figura 3, se muestra el diagrama de flujo, de esta estructura de seleccin simple.
fin-si
si-no fin-si
fin-si
sentencia 7
sentencia 8
.
En la figura 4, se muestra el diagrama de flujo de esta estructura de seleccin doble.
-7-
Este tipo de estructura se utiliza cuando el problema se presenta naturalmente dividido claramente
en dos posibilidades, por ejemplo preguntarse si un nmero es primo o no lo es, determinar si un
nmero es par o impar, y cuestiones de este tipo.
falsa
Expresin lgica
verdadera
Sentencia1
Sentencia2
sentenciaN
Sentencia4
Sentencia5
Figura 3
Por ejemplo:
1) Desarrollar un algoritmo que permita determinar si un nmero ingresado por teclado es
positivo o negativo.
Claramente en este requerimiento, el nmero ingresado o es positivo o es negativo, no hay
otra posibilidad, el problema podra ser el ingreso del nmero 0, por lo tanto se puede
implementar un filtro para impedir el ingreso de este elemento, lo cual se puede hacer por
codificacin o desplegando un mensaje en pantalla, que advierta al usuario que no debe
ingresar el nmero 0.
Una codificacin posible es:
-8-
Algoritmo ClasificaNum
Var:
entero: num
verdadera
falsa
Expresin lgica
Sentencia1
Sentencia2
Sentencia4
Sentencia5
Sentencia 7
Sentencia 8
Figura 4
inicio:
mostrar ( ingresar un nmero entero que no sea 0)
leer ( num)
si num > 0 entonces
mostrar ( el numero ingresado es positivo)
si-no
mostrar (el numero ingresado es negativo)
fin si
fin
EXPLICACION:
-9-
EXPLICACION:
En la seccin de declaracin de variables, se declara una sola variable de tipo entero
llamada num.
En la seccin de inicio (donde comienza la ejecucin) la funcin estndar mostrar ( )
despliega una cadena de caracteres (conjunto de caracteres) en la pantalla. A continuacin
la funcin estndar leer () permite guardar el dato ingresado desde el teclado en la variable
entera num.
- 10 -
verdadera
falsa
Expresin lgica
Sentencia1
Sentencia2
Sentencia4
Sentencia5
Sentencia 7
Sentencia 8
Figura 5
- 11 -
Esta expresin requiere una variable, que solo puede ser entera o de tipo carcter, con la cual se
controla cual es el camino que se va a elegir. Segn el valor que asuma esta variable, ser el
- 12 -
inicio
Mostrar (Ingresar un
nmero entero que no
sea 0)
Ingresar (num)
falso
num > 0
verdadero
Mostrar (l nmero
ingresado es
positivo)
fin
Figura 6
- 13 -
camino lgico que se seguir. Tambin es posible que el contenido de esta variable no sea igual
a ninguno de los valores que expresamente se indique en los casos, en esta situacin, el flujo del
programa realiza las acciones asociadas al si-no, si esta palabra reservada se decide usar.
La codificacin en pseudocdigo es:
- 14 -
op1
si-no
opcion
accion1
accion2
op2
opN
accion3
accion4
accion6
accion7
accionN1
accionN2
Figura 7
EXPLICACION:
Se declara una variable entera llamada opcin. Los valores posibles para esta variable son: 1, 2,
3, 4, 5, 6 y 7. Si el usuario llegase a introducir un valor distintos de estos, se ejecutara la accin
correspondiente al si-no, es decir se mostrara por pantalla el mensaje ERROR. Por ejemplo si el
usuario introduce por teclado el entero5 entonces se mostrar por pantalla el mensaje: JUEVES, y
luego terminar el programa.
En la figura 8 se muestra el diagrama de flujo.
Ej2) Se desea implementar un algoritmo que permita ingresar por teclado un nmero
comprendido entre 1 y 10 (inclusive) y que el algoritmo determine si el nmero entero ingresado
es par o impar. Luego de la comprobacin se mostrar por pantalla un mensaje indicando si el
nmero fue par o impar. Si el nmero que se ingresa no est comprendido en el intervalo cerrado
que se pide, terminar el programa indicando por pantalla tal situacin.
Una posible codificacin puede ser la siguiente:
Pseudocdigo
Algoritmo ParImpar
Var:
entero: dato
- 15 -
inicio
Figura 8
Mostrar (ingresar un
nmero entero entre 1
y 7)
Leer (opcin)
1
si-no
opcion
Mostrar
(RROR)
Mostrar
(DOMINGO)
2
6
Mostrar
(LUNES)
Mostrar
(SABADO)
Mostrar
(MARTES)
Mostrar
(VIERNES)
Mostrar
(MIERCOLES)
Mostrar
(JUEVES)
fin
- 16 -
inicio:
mostrar ( ingresar un nmero entero entre 1 y 10)
leer (dato)
si dato > = 1 y dato < = 10 entonces
segn-sea dato hacer
caso 1, 3, 5, 7, 9: mostrar (impar)
caso 2, 4, 6, 8, 10: mostrar (par)
fin-segn
si-no
mostrar(error)
fin-si
fin
EXPLICACION:
Se declara una sola variable entera, dato. Se usa la funcin mostrar ( ) para desplegar por pantalla
un mensaje que solicita el ingreso de un nmero entero en el intervalo cerrado de 1 a 10.
La funcin leer ( ) permite capturar el ingreso del usuario y guardar ese calor en la variable dato.
A continuacin hay una estructura selectiva doble, esta estructura lo que permite es procesar el
programa si el nmero introducido est dentro del intervalo pedido, para ello se construye la
siguiente expresin:
dato > = 1 y dato < = 10
la expresin completa da verdadera cuando dato es mayor o igual 1 y a su vez (
simultneamente) dato es menor o igual a 10.Obeservar que dato se compara dos veces ( una
vez por cada extremo del intervalo), entre ambas comparaciones se encuentra el operador y (
conjuncin). Este operador binario, da como resultado verdadero cuando ambas partes son
verdaderas, caso contrario, es decir una de las partes de la comparacin o ambas partes de la
comparacin son falsas, el resultado final del operador y da falso.
Entonces, habiendo introducido un nmero vlido, se pasa a la estructura de seleccin mltiple
segn-sea caso fin-segn. El caso de aplicacin de esta estructura, es poco comn. Se utilizan
dos casos, en uno de ellos se colocan todos los valores impares separados por coma, y en el otro
caso se colocan los nmeros pares del intervalo separados por coma.
Es importante destacar el anidamiento de estructuras, que tiene este ejercicio, lo cual lo hace muy
interesante para el anlisis. El siguiente cdigo:
Si .. entonces
Segn-sea . hacer
//
Fin-segn
Fin-si
Representa un anidamiento, hay una estructura dentro de otra. No es un anidamiento doble.
Cantidad de estructuras en cascada (cualquiera sea su tipo) -1 = numero de anidamientos.
- 17 -
Ej3) Se desea implementar un algoritmo que permita ingresar por teclado un nmero comprendido
entre 1 y 7 (inclusive) correspondiente al da de la semana (1 representa Domingo). El algoritmo
determinar si el nmero entero ingresado est o no en el intervalo vlido. Luego de la
comprobacin se mostrar por pantalla un mensaje indicando mediante una cadena de caracteres
el da que representa el nmero ingresado. Si el nmero que se ingresa no est comprendido en
el intervalo cerrado que se pide, terminar el programa indicando por pantalla tal situacin.
Una posible codificacin puede ser la siguiente:
Pseudocdigo
Algoritmo Dia_Semana
Var:
entero: dia
inicio:
mostrar ( ingresar un nmero que represente da de la semana)
leer (dia)
segn-sea dia hacer
caso 1: mostrar (domingo)
caso 2: mostrar (lunes)
caso 3: mostrar (martes)
caso 4: mostrar (mircoles)
caso 5: mostrar (jueves)
caso 6: mostrar (viernes)
caso 7: mostrar (sbado)
si-no: mostrar (error)
fin-segn
fin
EXPLICACION:
Se declara una sola variable entera, dia. Se usa la funcin mostrar ( ) para desplegar por pantalla
un mensaje que solicita el ingreso de un nmero entero en el intervalo cerrado de 1 a 7.
La funcin leer ( ) permite capturar el ingreso del usuario y guardar ese valor en la variable da.
Entonces, habiendo introducido un nmero, se pasa a la estructura de seleccin mltiple segnsea caso fin-segn. Se utilizan 7 casos, uno por cada da de la semana y un si-no para que entre
por este punto de bifurcacin, cuando el nmero ingresado no est comprendido entre 1 y 7.
- 18 -
Pseudocdigo
Algoritmo Procesa_numero
Var:
entero: dato
inicio:
mostrar ( ingresar un nmero entero entre 1 y 10)
leer (dato)
si dato > = 1 y dato < = 10 entonces
si dato mod 2 = 0 entonces
mostrar (el nmero ingresado es par y est en el intervalo de 1 a 10)
si-no
mostrar (el nmero es impar y est comprendido en el intervalo de 1 a 10)
fin-si
si-no
mostrar(error)
fin-si
fin
Ej2) Se desea implementar un algoritmo que permita ingresar por teclado tres nmeros A, B, C
enteros y que muestre por pantalla el nmero ms grande.
Una posible codificacin puede ser la siguiente:
Pseudocdigo
Algoritmo Muestra _mayor
Var:
entero: A, B, C, Mayor
inicio:
mostrar ( ingresar tres nmeros enteros)
leer (A, B, C)
si A > B entonces
si A > C entonces
mayor A
si-no
mayor C
fin-si
si-no
si B > C entonces
mayor B
si-no
mayor C
fin-si
fin-si
mostrar (el mayor nmero es: , mayor)
fin
- 19 -
Ej3) Implementar un programa que permita mostrar por pantalla un men con las opciones: 1
sumar, 2 multiplicar. Se tomar desde el teclado dos nmeros enteros. El usuario ingresar un
entero correspondiente a la operacin que quiere realizar.
Una posible codificacin puede ser la siguiente:
Pseudocdigo
Algoritmo Menu_suma_mul
Var:
entero: dato1, dato2, opcin, resul
inicio:
mostrar ( que operacin desea realizar: 1 suma- 2 multiplicar)
leer (opcion)
segn-sea opcion hacer
caso 1: mostrar (ingresar dos nmeros enteros para sumar)
leer ( dato1, dato2)
resul dato1 +dato2
mostrar (la suma es : , result)
caso 2: mostrar (ingresar dos nmeros enteros para multiplicar)
leer ( dato1, dato2)
result dato1 * dato2
mostrar (la multipliocacion es:, result)
si-no: mostrar (error)
fin-segn
fin
Ej4) Implementar un programa que permita determinar si dos nmeros ingresados por teclado
estn ordenados en forma creciente. Mostrar un mensaje por pantalla de esta situacin se da.
Una posible codificacin puede ser la siguiente:
Pseudocdigo
Algoritmo Determina_orden
Var:
entero: dato1, dato2
inicio:
mostrar ( ingresar dos nmeros enteros)
leer (dato1, dato2)
si dato1 < > dato2 entonces
si dato1 < dato2 entonces
mostrar (los nmeros fueron ingresados en forma ordenada de menor a mayor)
si-no
mostrar (los nmeros fueron ingresados en forma ordenada de mayor a menor)
fin-si
si-no
mostrar (los nmeros ingresados son iguales)
- 20 -
fin-si
fin
Ej5) Implementar un programa que permita leer 4 nmeros enteros por teclado, y muestre su
promedio por pantalla.
Una posible codificacin puede ser la siguiente:
Pseudocdigo
Algoritmo DeterminaPromedio
Var:
entero: dato1, dato2, dato3, dato4
real: prom
inicio:
mostrar ( ingresar cuatro nmeros enteros)
leer (dato1, dato2, dato3, dato4)
prom dato1 +dato2+dato3 +dato4
mostrar (el promedio es:, prom)
fin
Ej6) Realizar un algoritmo que determine si dos nmeros introducidos por teclado uno de ellos es
divisor del otro.
Una posible codificacin puede ser la siguiente:
Pseudocdigo
Algoritmo Determina_Divisibilidad
Var:
entero: dato1, dato2
inicio:
mostrar ( ingresar dos nmeros enteros)
leer (dato1, dato2)
si dato1 > dato2 entonces
si (dato1 mod dato2) = 0 entonces
mostrar (los nmeros son divisibles)
si-no
mostrar (los nmeros no son divisibles)
fin-si
si-no
si (dato2 mod dato1) = 0 entonces
mostrar (los nmeros son divisibles)
si-no
mostrar (los nmeros no son divisibles)
fin-si
fin-si
fin
- 21 -
Es necesario conocer alguna manera de detener la repeticin, ya sea que se conozca el nmero
de notas a procesar, para este ejemplo, o por medio de una expresin o condicin que se va
modificando dentro del bloque de sentencias que forman el bucle. De lo contrario la iteracin no
acabara nunca.
- 22 -
- 23 -
..
repetir
// sentencia1
// sentenciaN
hasta que <expresin>
sentncia1
sentenciaN
falsa
expresin
verdadera
Figura 9
Un uso muy frecuente de este tipo de estructura, es la validacin de datos. Por ejemplo un
programa necesita procesar edades, entonces se solicita el ingreso de la edad, y mediante una
estructura repetir/hasta-que se solicita ingresos de nmeros que representen una edad vlida, es
decir si el usuario introduce 999, el programa desplegar un mensaje de error por pantalla y
solicitar un nuevo ingreso de dato, y seguir en esta situacin hasta que se introduzca un valor
de edad vlido, por ejemplo un nmero entero comprendido entre 1 y 120.
- 24 -
EXPLICACION:
Este ejercicio tiene algunas cuestiones interesantes. Tiene dos estructuras repetir/hasta-que
anidadas. La estructura repetir (hasta-que ms externa, es la que controla que se sumen los
primeros 10 nmeros enteros positivos. La estructura repetir/hasta-que interna controla que el
nmero ingresado sea mayor a 0, es decir que sea positivo. Si el nmero que se introduce no es
mayor a 0, entonces la condicin de la estructura repetitiva es falsa y el bucle se repite, es decir
se pide un nuevo ingreso de dato desde el teclado; si por el contrario el dato introducido es mayor
a 0, la condicin es verdadera y por lo tanto el bucle no se repite, se prosigue con el aumento del
contador, la acumulacin en la variable suma.
Otro aspecto interesante es que utiliza dos variables con funciones especficas, cont como
contador, y suma como acumulador.
Ejemplo 2) Se desea implementar un programa que permita ingresar solo letras maysculas. El
programa mostrar por pantalla las 20 primeras letras maysculas introducidas por teclado.
Una posible codificacin podra ser:
Algoritmo MuestraMaysculas
Var:
entero: cont
caracter: letra
inicio:
cont 0
repetir
cont cont + 1
repetir
mostrar ( ingresar letra mayscula)
- 25 -
leer (letra)
hasta-que (letra > = A y letra <= Z)
mostrar (letra)
hasta-que cont > = 20
fin
EXPLICACION:
Para realizar este programa necesitamos dos variables de distinto tipo, una de tipo entero: cont,
para contar la cantidad de letras mostradas por pantalla (deben ser 20); otra, de tipo carcter para
guardar el ingreso que realice el usuario desde el teclado.
Hay dos estructuras repetir/hasta-que anidadas, esto significa que una se ejecuta dentro de la
otra. La estructura repetir/hasta-que externa, es la que permite que se muestren las 20 letras por
pantalla. La estructura repetir/hasta-que interna, es la que valida que el carcter ingresado por
teclado sea una letra mayscula, en esta estructura la expresin que controla la iteracin es una
expresin de tipo y and. Recordemos que esta expresin solo da un resultado booleano
verdadero, cuando ambas partes de la comparacin son verdaderas.
La expresin: letra > = A y letra <= Z, establece un intervalo cerrado. Si el usuario introduce
una letra mayscula, entonces esta expresin da como resultado verdadera y el bucle interno no
se repite, si por el contrario, el usuario introduce una letra minscula, est estar fuera del
intervalo y la expresin dar un resultado booleano falso, con lo cual el bucle se repite. Adems si
el usuario ingresa un carcter que no sea letra (ni mayscula ni minscula) el bucle interno se
repite, y como puede apreciarse el contador (variable cont) no se incrementa.
Ejemplo 3) Desarrolla un algoritmo que permita calcular el factorial de un nmero N que responde
a la frmula:
N! = N * (N-1) * (N-2) 2* 1
3! = 3 * 2 * 1 = 6
5! = 5 * 4 * 3 * 2 * 1= 120
Solo existe el factorial de nmeros enteros igual o mayor que 0
El factorial de un nmero es otro nmero.
Por convencin matemtica el factorial de 0! Es 1, y el factorial de 1! Tambin es 1.
Una posible codificacin podra ser:
Algoritmo CalculaFactorial
Var:
entero: num, cont
real: fact
inicio:
mostrar ( ingresar un nmero a calcular su factorial) // no se realiza la validacin
ingresar ( num)
si num = 0 o num =1 entonces
- 26 -
fact 1
si-no
fact num
cont num-1
repetir
fact fact * cont
cont cont -1
hasta-que cont < =1
fin-si
mostrar (El factorial de: ,num, es: fact)
fin
EXPLICACION:
En este ejercicio se ha omitido la validacin del dato de entrada, es decir no se verifica que el
usuario ingrese un nmero mayor o igual a cero. El usuario no puede ingresar un nmero
negativo, en primer lugar porque no existe el factorial de un nmero negativo y en segundo lugar
el algoritmo calculara cualquier cosa.
El factorial del nmero que ingrese el usuario se calcula y guarda en la variable real fact, no se
utiliza un entero, porque el tipo de dato real puede almacenar valores o cifras ms grandes que los
enteros (recordar que el tipo de dato real, no solo es para valores decimales, tambin es
especfico de los enteros grandes).
La estructura de seleccin doble se la utiliza para diferenciar el caso en el cual el usuario
introduzca el 1 el nmero 0, en ambos casos por convencin matemtica su factorial es igual a
1, por lo tanto no hay que realizar clculo alguno. Para cualquier otro nmero, debe emplearse la
frmula matemtica ya mencionada.
Dentro del si-no, est la iteracin para realizar el clculo que implica la expresin matemtica del
factorial de un nmero.
El mismo algoritmo puede ser realizado con un contador que se incrementa en lugar de usar
decrementos.
La expresin matemtica es:
5!= 1 * 2 * 3 * 4 *5= 120
La versin con contador que se incrementa es:
Algoritmo CalculaFactorial
Var:
entero: num, cont
real: fact
inicio:
mostrar ( ingresar un nmero a calcular su factorial) // no se realiza la validacin
ingresar ( num)
si num = 0 o num =1 entonces
fact 1
si-no
- 27 -
fact 1
cont 1
repetir
fact fact * cont
cont cont +1
hasta-que cont > num
fin-si
mostrar (El factorial de: ,num, es: fact)
fin
- 28 -
falsa
verdadera
sentencia1
sentenciaN
Figura 10
Existen dos cuestiones particulares: ejecucin de un bucle cero veces y ejecucin de bucles
infinitos.
EJECUCION DE UN BUCLE CERO VECES:
Como lo primero que ocurre en una estructura mientras/fin-mientras es la evaluacin de la
expresin, si esta llegar a ser falsa la primera vez que se ingrese a esta estructura, entonces las
sentencias asociadas al bucle, nunca se ejecutaran.
Por ejemplo:
..
inicio
dato1 5
dato2 1
mientras dato2 > dato1 hacer
leer ( t)
mostrar (t)
dato2 dato2 + 1
fin-mientras
..
Las sentencias:
leer ( t)
mostrar (t)
dato2 dato2 + 1
no se ejecutan nunca, pues dato1 contiene el entero 5 y dato2 contiene el entero 1, claramente
dato2 NO ES MAYOR que dato1. No hay iteracin.
BUCLES INFINITOS
Algunos bucles no tienen fin, porque as se los elabora. Esto depender de los requerimientos del
problema a resolver.
- 29 -
Un bucle que nunca se termina se denomina bucle infinito o sin fin. Los bucles sin fin no
intencionados son perjudiciales para la programacin y se deben evitar siempre.
Un ejemplo de bucle infinito es el siguiente:
.
inicio
dato1 5
dato2 1
mientras 1 hacer
leer ( t)
mostrar (t)
dato2 dato2 + 1
mostrar (dato2)
fin-mientras
..
La expresin asociada al mientras en este ejemplo es 1. El nmero 1 (uno) es siempre verdadero,
por lo tanto este bucle no acaba nunca.
NOTA IMPORTANTE:
Las pruebas o test en la expresiones booleanas es conveniente que sean mayor o menor que ( >
>) en lugar de pruebas de igualdad o desigualdad. Son ms seguras, y en especial en un
lenguaje en particular, en especial si las variables involucradas son de tipo real.
- 30 -
Ejemplo 2) Se desea implementar un programa que permita obtener el producto de dos nmeros
enteros positivos, ingresados por teclado, mediante el algoritmo de sumas sucesivas. El programa
mostrar por pantalla el producto.
2x3= 2 + 2+ 2+ 2
=6
2x3=3+3
=6
Una posible codificacin podra ser:
Algoritmo CalculaProducto
Var:
entero: A,B, acum
inicio:
mostrar ( ingresar dos nmeros enteros positivos)
leer (A,B)
acum 0
mientras A < > 0 hacer
acum acum + B
A A -1
fin-mientras
mostrar ( acum)
fin
Ejemplo 3) Se desea implementar un programa que permita obtener el cociente de dos nmeros
enteros positivos, ingresados por teclado, mediante el algoritmo de restas sucesivas. El programa
mostrar por pantalla el producto.
Se muestra el algoritmo con ejemplos numricos:
a)
10 / 5
Primera resta 10-5 =5
N =1
Segunda resta 5-5 = 0
N = N +1 = 2
Por lo tanto cociente es 2 ( el valor de N) y el resto es 0
b)
10/4
10 > 4 Primera resta
acum = 1
10 - 4 = 6
- 31 -
En cualquiera de las dos formas, v es una variable entera, que debe ser declarada en el programa
en la seccin var. Los valores vi y vf son los valores inicial y final que tomar automticamente la
variable v. En el formato de esta estructura hay que elegir entre incrementar o decrementar la
variable de control v. No puede ocurrir al mismo tiempo ambas situaciones.
- 32 -
Se puede obviar la palabra inc cuando el incremento sea de1. Cuando se desee decrementar la
variable de control de la estructura siempre deber aparecer la palabra dec (aunque el
decremento sea en 1).
En la estructura para/desde, paso, representa el valor a sumar o restar del valor inicial de la
variable de control de la estructura, en nuestro caso de la variable v.
La presentacin de algunas situaciones aclarar lo expresado anteriormente.
desde v 1 hasta 5
// acciones
..
fin-desde
hacer
En este caso la variable v se inicializa en 1, y luego de ejecutar todas las sentencias que
estn comprendidas dentro de la estructura (bucle), automticamente la variable v se
incrementa en 1. Cuando iteracin tras iteracin, la variable de control v alcance el valor v
= 6 no se realizan ms iteraciones, y se prosigue con la prxima instruccin que est a
continuacin del fin-desde.
desde v 5 hasta 9
// acciones
..
fin-desde
hacer
Tiene el mismo efecto, que el caso anterior. El bucle se repite 5 veces, la variable de
control se inicializa en 5, y bucle tras bucle se va indexando de 1, cuando v = 10 se saltea
el bucle de la estructura desde y se prosigue con la prxima instruccin despus del findesde.
- 33 -
iteracin. En este caso la variable v toma los valores 10,8, 6, 4 y 2 por lo tanto el bucle se
repite 5 veces.
Es importante recalcar que el pseudocdigo no es un lenguaje estandarizado. Eso significa que
diferentes autores podran dar otras estructuras de control o bien usar estas mismas estructuras,
pero con una notacin diferente. Sin embargo, las funciones matemticas y lgicas toman el
significado usual que tienen en matemtica y lgica, con las mismas expresiones.
inicio
suma 0
cant 1
mientras cant <= 10 hacer
leer ( dato)
suma suma + dato
cant cant + 1
fin-mientras
mostrar ( suma)
..
b) Usando estructura repetir/hasta-que
inicio
suma 0
cant 1
repetir
leer ( dato)
suma suma + dato
cant cant + 1
hasta-que cant >10
mostrar ( suma)
..
c) Usando la estructura desde/fin-desde
inicio
suma 0
desde cant 1 hasta 10 hacer
leer ( dato)
suma suma + dato
- 34 -
fin-desde
mostrar ( suma)
..
a)
b)
Figura 11
- 35 -
b)
a)
Figura 12
inicio
leer (N)
leer ( dato)
mayor dato
desde cant 2 hasta N hacer
leer ( dato)
si mayor < dato entonces
mayor dato
fin-si
fin-desde
mostrar ( mayor)
fin
Ejercicio 2)
Se dispone de una lista de N nmeros ingresados por teclado, se desea determinar y mostrar por
pantalla el valor del nmero mayor y del menor que se hayan ingresado al mismo tiempo.
Una posible codificacin podra ser:
Algoritmo DeterminaMayor_Menor
Var
entero: N, cant
real: dato, mayor, menor
- 36 -
inicio
leer (N)
leer ( dato)
mayor dato
menor dato
desde cant 2 hasta N hacer
leer ( dato)
si mayor < dato entonces
mayor dato
fin-si
si menor > dato entonces
menor dato
fin-si
fin-desde
mostrar ( mayor, menor)
fin
Ejercicio 3)
Se leen desde el teclado 100 nmeros, se desea determinar y mostrar por pantalla la media de los
nmeros positivos y la media de los nmeros negativos que se hubiesen ingresado, al mismo
tiempo.
Una posible codificacin podra ser:
Algoritmo DeterminaMedia_Positivos_Negativos
Var
entero: cantP, cantN, total
real: dato, sumaPos, sumaNeg
inicio
cantP 0
cantN 0
sumaPos 0
sumaNeg 0
desde total 1 hasta 100 hacer
leer ( dato)
si dato > 0 entonces
cantP cantP+1
sumaPos sumaPos + dato
fin-si
si dato < 0 entonces
sumaNeg sumaNeg + dato
cantN cantN + 1
fin-si
fin-desde
mostrar ( la media de los valores negativos es: ,sumaNeg/cantN)
mostrar ( la media de los valores positivos es:, sumaPos/cantN)
fin
- 37 -
- 38 -
Ejemplo 3)
Realizar 50 ingresos de caracteres por teclado. Si el carcter ingresado, es una minscula
mostrarla por pantalla, si la letra es mayscula convertirla a minscula para luego mostrarla por
pantalla.
Una codificacin puede ser:
Algoritmo MuestraMinsculas
Var
caracter: dato
entero: cont
inicio
cont 0
repetir
leer ( dato)
si (dato > = a y dato < = z) entonces
mostrar ( dato)
fin-si
si (dato > = A y dato < = Z) entonces
dato dato + 32
mostrar (dato)
fin-si
cont cont +1
hasta-que cant > = 50
fin
EXPLICACION:
Los caracteres se almacenan en memoria mediante una codificacin en 0 y 1. A cada carcter le
corresponde un nmero entero que se representa en cdigo ASCII.
La tabla ASCII, contiene nmeros enteros con los que se corresponden las letras minsculas, las
maysculas, los nmeros (de 0 a 9), los signos de puntuacin, etc.
Las letras maysculas les corresponden nmeros enteros consecutivos, la letra A mayscula le
corresponde el nmero 65, la letra B el 66, la letra C el 67 y as hasta llegar a la letra Z mayscula.
A las letras minsculas, tambin les corresponden nmeros enteros consecutivos. La letra a
minscula le corresponde el nmero 97, la letra b el 98, la letra c el 99 y as hasta llegar a la letra
z minscula.
Para la misma letra, mayscula y minscula, existe una constante igual a 32. Es decir entre la A y
la letra a minscula existen 32 posiciones de la tabla. Lo mismo ocurre para la letra B y b.
Cuando la letra se coloca entre comillas simple, se est haciendo referencia al nmero entero que
representa su codificacin en ASCII. Por lo tanto no es necesario recordar la constante 32, basta
con saber la siguiente relacin
Var
- 39 -
entero: cont
.
cont a A // cont contiene 32
cont t T // cont contiene 32
y as para cualquier letra mayscula y minscula.
Entonces, cuando la estructura selectiva si/si-no detecta en la expresin que el carcter ingresado
es una letra mayscula, entonces a su valor entero ASCII le suma 32 para convertirla en la misma
letra pero en su forma minscula.
Todos los caracteres que no sean minsculas o maysculas ( se convierten) se cuentan como
ingreso vlido para alcanzar la cifra 50.
Ejemplo 4)
Realizar ingresos de caracteres por teclado y mostrarlos por pantalla. El programa termina, con la
primer vocal ( sea mayscula sea minscula) que se ingrese.
Una codificacin puede ser:
Algoritmo MuestraCaracter
Var
caracter: dato
lgico: flag // bandera
inicio
flag verdadero
mientras flag = verdadero hacer
leer ( dato)
segn-sea dato hacer
caso a : flag falso
caso A : flag falso
caso e : flag falso
caso E : flag falso
caso i : flag falso
caso I : flag falso
caso o : flag falso
caso O : flag falso
caso u : flag falso
caso U : flag falso
fin-segun
si flag = verdadero entonces
mostrar ( dato)
fin-si
fin-mientras
fin
- 40 -
Ejemplo 5)
Ingresar 3 nmeros desde el teclado, los nmeros representan dimensiones de los lados de un
tringulo. El programa mostrar por pantalla un mensaje indicando si el tringulo es equiltero ( 3
lados iguales), issceles ( dos lados iguales) o escaleno (3 lados distintos). El programa termina
cuando se introduzca la palabra salir.
Una codificacin puede ser:
Algoritmo Clasifica_triangulos
Var
Real: lado1, lado2, lado3
Cadena: clave
inicio
clave XXX
mientras no (clave = salir) hacer
leer ( lado1, lado2, lado3)
si (lado1 =lado2) y (lado2 = lado3) entonces
mostrar ( equiltero)
si-no
si ( lado1 < > lado2) y ( lado2 < > lado3) entonces
mostrar ( escaleno)
si-no
mostrar ( issceles)
fin-si
fin-si
mostrar ( para terminar introduzca la palabra salir en minscula)
leer( clave)
fin-mientras
fin
Bibliografa obligatoria:
Fundamentos de programacin. Algoritmos, Estructuras de datos y Objetos, Luis
Joyanes Aguilar. Mc Graw Hill. Tercera edicin. Captulo 5 (pginas 163 a 203).
- 41 -