Tema 3 Algortmica.

Tema 3.
3. Algortmica y Programacin Estructurada.

3.1 El concepto de algoritmo.

Algoritmo. Secuencia de pasos para realizar cualquier tipo de tarea.

Las etapas de diseo de un algoritmo son:
Definicin. Se especifica cual es el propsito del algoritmo. Esta etapa es de las ms importantes. Si
se esta mal hecha las etapas subsecuentes aunque estn bien estarn mal. Se debe de definir
claramente el problema a resolver y lo que se pretende lograr con su solucin.
Anlisis. Se analiza el problema y sus caractersticas. Se determina las entradas y salidas del
problema. Se investiga si ya se conoce alguna o varias soluciones al problema. Si se conocen varias,
se determina cual es la ms conveniente al problema que estamos tratando. Si no se conoce ninguna o
no nos satisface las soluciones existentes se propone una nueva. Aqu es donde entra la creatividad de
cada persona.
Diseo. En esta etapa se plasma la solucin del problema. Para esto se emplea una herramienta de
diseo. Las ms usuales son el diagrama de flujo y el pseudocdigo. En este curso solo emplearemos
la notacin de pseudocodigo. A continuacin veremos una de las metodologas ms usuales de diseo
de algoritmos.

3.2 Programacin Estructurada.

Programacin Estructurada. Conjunto de tcnicas que permiten disear un programa ms fcil de:
escribir, leer, verificar, depurar y mantener.
Se basa en los siguientes puntos:
Un nmero limitado de estructuras de control.
Diseo descendente.
Descomposicin modular.

3.2.1 Estructuras de control

M. en C. Rafaela Blanca Silva Lpez
Pgina 1
Curso SAI - Introduccin a la Programacin

Las estructuras de control se refiere al conjunto de instrucciones que permiten dirigir el flujo de un
programa, es decir, en que orden se van a ejecutar las instrucciones y cuantas veces se van a repetir.
Su numero debe ser limitado para simplificar la programacin ,mientras mas pequeo pero suficiente
sea la cantidad que se tenga de estructuras de control, programar ser mas fcil que si tenemos un
conjunto grande de instrucciones.
El diseo descendente se refiere al hecho de que un problema lo analizamos por niveles de lo ms
general a lo ms particular. Cada nivel tiene una complejidad menor. Lo vamos descomponiendo en
sus partes por medio de capas. Cada capa es mas simple que la anterior.
A su vez la descomposicin modular se refiere a que un problema lo descomponemos en otros mas
pequeos o mdulos, los cules sean ms fciles de resolver. Esta descomposicin se realiza en base
al diseo descendente. Cada nivel de diseo se realiza en base de mdulos de complejidad decreciente.
Los tipos de estructuras de control son:
Secuenciales.
Selectivas.
Repetitivas.
Las secuenciales implican que las instrucciones de un programa se realizan en orden una a la vez, es
decir, una cosa a la vez y una tras otra. Esto puede representarse por:

Inicio
<Accin 1>
<Accin 2>
<Accin 3>



<Accin n>
Fin

Esto es necesario porque el procesador de una computadora solo puede hacer una cosa a la vez.
Adems que simplifica el anlisis.
Las estructuras de control selectivas sirven para decidir a donde dirigir el flujo de un programa entre
uno o mas caminos de accin. Estas pueden ser de 3 tipos:
Simples.
Dobles.
Mltiples.

La seleccin simple sirve para decidir entre un camino de accin, es decir, hacer o no hacer algo en
base a una condicin. Esquemticamente se puede representar por:

Si (Condicin) entonces
3. Pgina 2 .
Tema 3 Algortmica.
<Accin>
Fin_Si

Si la condicin es cierta se realiza la <Accin> y se continua en la siguiente instruccin del Si. Si la
condicin es falsa no se realiza la <Accin> y se continua en la siguiente instruccin del Si.
La seleccin doble se emplea cuando tenemos 2 caminos de accin. Si una condicin es cierta se hace
una accin. Si es falsa se realiza otra. Despus se continua con la siguiente instruccin del Si.

Si (Condicin) entonces
<Accin 1>
Sino
<Accin 2>
Fin_Si

La seleccin mltiple se emplea cuando tenemos ms de 2 caminos de accin.

Si (Condicin 1) entonces
<Accin 1>
Sino Si (Condicin 2) entonces
<Accin 2>
Sino Si (Condicin 3) entonces
<Accin 3>

Sino Si (Condicin n) entonces

<Accin n>
Sino
<Accin x>
Fin_Si

Se prueba la condicin 1 si es cierta se realiza la <Accin 1>. Si es falsa se pregunta por la condicin
2. Si es cierta se realiza la <Accin 2> . Si es falsa se pregunta por la condicin 3. Si es cierta se
realiza la <Accin 3>. Si es falsa se pregunta sucesivamente por las restantes. Si alguna es cierta se
realiza y si es falsa se pregunta por las dems. Si todas son falsa se realiza la <Accin x>. Si ms de
una es cierta se realiza la primera que se encuentre. El Sino es opcional. Si no se incluye y todas las
condiciones son falsas no se realiza nada.
M. en C. Rafaela Blanca Silva Lpez
Pgina 3
Curso SAI - Introduccin a la Programacin

Se tiene otra estructura de control para la seleccin mltiple. Esta se emplea cuando se implementa un
men. Al realizar un programa es frecuente que se muestre al usuario las opciones que tiene para
ejecutar en un determinado programa. El tiene que seleccionar entre una serie de opciones. Estas a su
vez estn numeradas consecutivamente o en su defecto identificadas con una letra. En cualquier caso
las condiciones que se tiene que probar para ver que opcin se va a ejecutarse es sobre un conjunto
finito de valores. En estas circunstancias se puede usar la instruccin Segn.

Segn (expresin)
caso Val 1:
<Accin 1>
caso Val 2:
<Accin 2>
caso Val 3:
<Accin 3>

caso Val n:
<Accin n>
de otro modo:
<Accin x>
Fin_Segn

La expresin debe de regresar un conjunto finito de valores, por ejemplo los nmeros del 1 al 10 o las
letras de la A a la Z. Se verifica el valor regresado por la expresin con cada uno de los valores
indicados en los casos. A la primera coincidencia se realiza esa <Accin>. Si coincide con ms de uno
se realiza la primera en hallarse. Si no se encuentra el valor se realiza lo que esta en de otro modo, la
<Accin x>. Anlogamente al caso del Si mltiple el de otro modo es opcional. Si no se incluye y no
halla ninguna coincidencia del valor regresado por la expresin. no se hace nada.
Las estructuras de control repetitivas, tambin llamadas ciclos, sirven para repetir una serie de
acciones hasta que se cumpla alguna condicin. Pueden ser de 3 tipos:
Mientras.
Repite.
Desde.

Se pueden esquematizar de la siguiente manera:

Mientras (condicin) hacer
<Acciones>
3. Pgina 4 .
Tema 3 Algortmica.
Fin_Mientras

Mientras la condicin sea cierta se realiza el conjunto de acciones. Cuando sea falsa el ciclo termina.

Repite
<Acciones>
Hasta_que (condicin)

Primero se realiza el conjunto de acciones y despus se pregunta por la condicin. Si la condicin es
cierta el ciclo termina. Si es falsa se repiten las acciones hasta que la condicin sea cierta.

Desde indice=Vi hasta Vf Inc hacer
<Acciones>
Fin_Desde

Se inicializa la variable ndice con el valor Vi , se verifica si es mayor al valor Vf. Si es as el ciclo
termina. Si no se realizan las acciones y se incrementa el ndice en el valor Inc. Posteriormente se
compara el valor del ndice contra el valor Vf. Si es mayor el ciclo termina. Si no se incrementa el
ndice en le valor Inc y se repiten los pasos anteriores hasta que el ndice sobrepase el valor Vf.
Podemos observar que en el caso del ciclo desde es posible calcular cuantas veces se va ejecutar, ya
que se conoce los valores de Vi, Vf e Inc.

NOTA:
El ciclo Repite se ejecuta por lo menos una vez.
El ciclo mientras es posible que no se ejecute.

3.2.2 Programacin Modular

El diseo descendente va muy aunado con la descomposicin modular. Todo esto se resume con la
Programacin Modular.
Programacin Modular: Tcnica de diseo que permite resolver un problema mediante su
descomposicin en problemas ms pequeos o mdulos, los cuales se pueden analizar, disear,
depurar, afinar y programar independientemente uno del otro. Se basa en la organizacin jerrquica de
mdulos con un modulo principal ,o raz.
Un programa modular consta de un programa principal y subprogramas o mdulos. El programa
principal consta de instrucciones fundamentales como son las estructuras de control y llamadas a los
subprogramas. Los subprogramas constas de un conjunto de instrucciones que se ejecutan de una sola
vez y se referencian mediante un nombre por el cual son llamados desde distintos puntos del
programas. Tericamente tienen un solo punto de entrada y un solo punto de salida. Tambin pueden
llamar a otros mdulos.
M. en C. Rafaela Blanca Silva Lpez
Pgina 5
Curso SAI - Introduccin a la Programacin

Por ejemplo, podemos considerar el programa que implemente el trabajo de una agencia matrimonial.
Este programa debe manejar una serie de datos de como es una persona y de como desea a su pareja.
El programa debe de comparar la informacin que tenga de otras personas y reportar la ms
compatible con lo que desea. Lo anterior puede resumir en el siguiente organigrama.
Altas Bajas Cambios
Datos Comparaci n Reporte
Agencia Matrimonial
Punto de Encuentro

El programa se ha dividido en 3 mdulos. El modulo de datos se encarga de manejar la informacin
necesaria de los clientes para alimentrsela al programa. El modulo de Comparacin se encarga de
hacer las comparaciones para hallar las parejas ms compatibles entre si. El modulo de reporte nos da
la lista de las parejas y su grado de compatibilidad. Estos mdulos son independientes uno del otro en
el sentido de que la manera en que trabajen no debe de afectar la manera en que trabajen los dems. La
Forma de manejar los datos no influye en la forma de realizar las comparaciones. La forma de hacer
las comparaciones no debe de influir en la manera de realizar el reporte. El modulo de datos a su vez
se puede dividir en otros 3: Altas, bajas y cambios. El modulo de altas es el que alimenta la
informacin al programa (cuando alguien se inscribe). El modulo de bajas se encarga de sacar del
programa a los que no quieren ya estar (por que ya se casaron o por que no les gusto con quien les
toco). El modulo de cambios es para modificar la informacin del cliente (ya sea por que no le gusten
ya las rubias sino las morenas o por que se halla operado). Si es necesario se pueden hacer mas
divisiones, de tal forma que el programa sea fcil de realizar.
La jerarqua de los mdulos se establece en base a quien puede llamar a quien. Esto tambin define los
niveles de complejidad de los mdulos mientras mas abajo este un modulo ms simple es y viceversa.
Los mdulos al mismo nivel tienen el mismo grado de complejidad. Un modulo no puede llamar a
otro del mismo nivel o de un nivel ms alto, solo puede llamar a mdulos de niveles inferiores.
El hecho de que los mdulos constan de un conjunto de instrucciones que se ejecutan de una vez,
implica que cuando se llama a un modulo el que lo llamo no continua ejecutndose hasta que el
modulo llamado termine de ejecutarse. Por ejemplo. Cuando el modulo principal llama a ejecucin al
modulo de Datos, deja una seal de donde se quedo y busca el cdigo de Datos. Cuando lo encuentra
se ejecuta el cdigo y hasta que no termine el programa principal no puede continuar. Cuando termina
la ejecucin en el programa principal sigue en la instruccin posterior a la llamada al modulo de datos.
Si bien la programacin modular debe de simplificar la elaboracin de un programa, como toda
solucin en ingeniera mete nuevos problemas. La dificultad que introduce en la necesidad de
comunicar los resultados de un modulo a otro. Los datos del mdulo de datos se requieren para el
modulo de comparacin. Los resultados del modulo de comparacin se requieren para el modulo de
reportes.
3.2.3 Comunicacin entre mdulos (Paso de parmetros).

3. Pgina 6 .
Tema 3 Algortmica.
La manera en la que se resuelve esto a nivel terico es mediante el paso de parmetros. Este puede
ser de 2 tipos:
Paso de parmetros por valor.
Paso de parmetros por referencia.
Paso de parmetros por valor. Es solo para parmetros de entrada. El valor de los parmetros con
los que se llama al modulo no se modifica al terminar la llamada.
Paso de parmetros por referencia. Es tanto para parmetros de entrada como de salida. El valor de
los parmetros con los que se llama al modulo si se puede modificar al terminar la llamada.
Por ejemplo:
Altas Bajas Cambios
X=1
Datos
Comparacin Reporte
Agencia Matrimonial
Punto de Encuentro


Si al llamar al modulo de datos la variable X tiene un valor de 1, si el paso de parmetros es por valor
al terminar la llamada X sigue valiendo 1. Esto es por que al realizar la llamada se enva el valor de la
variable y se almacena en una variable distinta. el modulo trabaja con esta copia y por esa razn no se
afecta a la variable con la que se llamo al modulo.
Si el paso de parmetros se realiza por referencia, al terminar la llamada X podra valer 2 o cualquier
otro valor, inclusive 1. En este paso de parmetros se trabaja directamente con la variable con la que
se llama al modulo. Por eso es susceptible de modificarse.
De los 2 pasos de parmetros, obviamente es mas general el de referencia. El paso de parmetros que
emplea un lenguaje de programacin determinado varia con cada lenguaje. Por ejemplo lenguaje
FORTRAN solo tiene paso de parmetros por referencia. PASCAL implementa ambos. Curiosamente
lenguaje C solo tiene paso de parmetros por valor. Lenguaje BASIC no tiene paso de parmetros.
Los tipos de mdulos con los que se cuenta en programacin modular son:
Programa principal.
Funcin.
Procedimiento.
Las caractersticas del modulo principal son:
Es el primero en ejecutarse y el ltimo en terminar.
Puede llamar a otros mdulos pero nadie lo puede llamar a el.
Es nico.
M. en C. Rafaela Blanca Silva Lpez
Pgina 7
Curso SAI - Introduccin a la Programacin

El subprograma o modulo funcin es aquel que solo regresa un valor y requiere 0, 1 o varios
parmetros. Es anlogo a una funcin matemtica. Solo regresan un valor y requieren varios valores.
Por ejemplo:
Y = X
Z = X +Y
W =
La primera funcin regresa un solo valor y requiere un solo parmetro. La segunda regresa un solo
valor y requiere 2 parmetros. La tercera regresa un solo valor y no requiere ningn parmetro. Una
funcin regresa su valor por medio de su nombre. Una funcin puede esquematizarse de la siguiente
manera:

Funcin Nombre(tipo1 p1,tipo2 p2,...,tipo n pn) Tipo
Declaracin de variables
Inicio
cdigo
regresa (expresin)
Fin_funcion

Nombre es el nombre de la funcin. Entre parntesis se incluye la lista de los parmetros, indicando
su tipo y su nombre. Tipo es el tipo de valor que regresa la funcin. En declaracin de variables se
declaran las variables que se requieren para hacer los clculos. Cdigo son todas las instrucciones que
se necesite realizar para el calculo de la funcin. La instruccin regresa indica el valor que va a
regresar la funcin. Este puede ser el resultado de una expresin , como puede ser un a simple
variable, constante o una expresin aritmtica. Esta instruccin a forciori debe de ir por lo menos una
vez.
Para invocarla se hace igual que para una funcin de Librera es decir:
Var Nombre p p pn ( , ,..., ) 1 2 . Se escribe el nombre de la funcin y entre parntesis separados
por comas se escriben los parmetros con los que se llama la modulo. El valor que retorna la funcin
se almacena en su nombre. Este valor a su vez se puede asignar a otra variable como se muestra o se
puede emplear en una expresin aritmtica. Por ejemplo:
Y sqrt x = ( ) o Z sqrt x = + ( ) *2 3
La funcin sqrt(x) es una funcin que evala la raz cuadrada.
Procedimiento es un subprograma que regresa 0, 1, o varios valores y requiere 0, 1, o varios
parmetros. Esto puede representarse:

Procedimiento Nombre(tipo1 p1,tipo2 p2,...,tipo n pn)
Declaracin de variables
Inicio
cdigo
Fin_procedimiento

3. Pgina 8 .
Tema 3 Algortmica.
Nombre es el nombre del procedimiento. Entre parntesis esta la lista de parmetros que requiere. Esta
puede ser opcional. En declaracin de variables se declaran las variables que se requieren para hacer
los clculos. Cdigo son todas las instrucciones que se necesite realizar para los clculos del
procedimiento. Los valores que regresa el procedimiento tiene que hacerse mediante el paso de
parmetros por referencia. Para llamar al procedimiento se puede denotar por:
llama_a Nombre(p1,p2,...,pn).
En ambos casos las variables que se emplean para definir el modulo se denominan parmetros
formales, porque se emplean para definir formalmente el modulo. Estos no pueden cambiar, son los
mismos a lo largo de todo el programa. Los parmetros con los que se llama al modulo se llaman
parmetros reales. Esto es por que estos parmetros pueden cambiar y son con los que realmente se
llama al modulo.
Las variables con las que se define al modulo, los parmetros formales, se dice que son variables
locales porque solo tiene sentido en le modulo donde estn definidas. Las variable globales son
aquellas que tiene sentido en todo el programa.

3.2.4 Constantes y Variables

Constante: Es un valor que no cambia durante la ejecucin de un algoritmo.
Variable: Es un valor susceptible de modificarse en la ejecucin de un algoritmo.
Existen 3 usos comunes de las variables en un algoritmo:
Acumuladores
Contadores.
Centinelas.
Los acumuladores son variables que almacenan resultados parciales de un proceso.
Ejemplo:
sum0
Desde indice=1 hasta 10 hacer
sum sum indice +
Fin_Desde

La variables sum almacena las sumas parciales.
Los contadores son variables que cuentan el nmero de veces que se realiza un proceso. En el ejemplo
anterior ndice es un contador. Los contadores deben de ser enteros.
Los centinelas son variables que determinan cuando se cumple alguna condicin.
Ejemplo:
sum0
indice 0
Repite
sum sum indice +
M. en C. Rafaela Blanca Silva Lpez
Pgina 9
Curso SAI - Introduccin a la Programacin

indice indice 1 +
Hasta_que indice 10

La variable ndice monitorea cuando se alcanza un total de 10 iteraciones.

3.3 Algoritmos elementales.

Disear un algoritmo para resolver una ecuacin de segundo grado. Empecemos a definir claramente
el problema.

3.3.1 Definicin
La ecuacin de segundo grado es: ax
2
+bx+c=0. Resolver la ecuacin implica hallar los valores de x
tales que se cumpla la ecuacin, es decir, que al sustituirlos la ecuacin valga 0.

3.3.2 Anlisis
La ecuacin de segundo grado es ax
2
+bx+c=0 y las soluciones o races de la ecuacin son 2. Esto lo
sabemos por el teorema fundamental del lgebra.
Las entradas son los coeficientes a, b, c. Las salidas son las races x1, x2.
Pasemos a enumerar las posibles soluciones existentes de este problema:
1) Factorizacin.
2) Mtodo grfico.
3) Completar el trinomio cuadrado perfecto.
4) Formula General.

Analicemos cada una de ellas para ver cual es la ms conveniente en nuestro caso.
El mtodo de factorizacin no es general. Solo es aplicable si los coeficientes son enteros.
El mtodo grfico no es muy preciso. Adems piensa en como se podra programar.
Completar el trinomio cuadrado perfecto es general y se puede programar con relativa facilidad.
La formula general es ms simple que completar el trinomio cuadrado perfecto. Adems por ser una
formula es ms sencilla de programar.
Por todo lo anterior nos quedamos con la formula general como la solucin a implementar.

La frmula general es:

x
b b ac
a 1 2
4
2
2
,
=


3. Pgina 10 .
Tema 3 Algortmica.

Se define d=b
2
-4ac como el discriminante de la ecuacin. Para que la ecuacin de segundo grado
tenga solucin real es preciso que el discriminante sea mayor o igual a cero. Si es negativo las races
son complejas.
Por consiguiente s:
d>0 entonces, x
b b ac
a 2
4
2
2
=


d=0 entonces x x
b
a 1 2 2
= =


d<0 entonces x
1
y x
2
son complejas. En este caso se toma como x
b
a 1 2
=

la parte real,
x
d
a 2 2
=

la parte imaginaria

En estas frmula hay que tomar en cuenta que si a=0 las frmulas no son aplicables. Pero la ecuacin
si tiene solucin. Esta es. Si adems b=0, la solucin depende del valor de c. Si c=0 la ecuacin es
valida para todo x y si c 0 la ecuacin no tiene solucin.
1. Inicio
2. Introducir coeficientes a, b y c
3. Verificar el valor de a.
4. Si a=0 y b 0 resolvemos la ecuacin lineal asociada.
5. x
c
b
=


6. Si tambin b=0 verificamos el valor de c.
7. Si c=0 reportamos que la ecuacin es valida para todo x.
8. Si c 0 reportamos que no existe solucin.
9. En Cualquier otro caso aplicamos Calculamos el discriminante.
10. Comprobar el valor de d.Si d es igual a cero se obtienen dos races iguales x x
b
a 1 2 2
= =


11. Si d es mayor que cero se calculan las dos races x1 y x2
12. En caso contrario se calcula la parte real y la parte imaginaria de las races complejas.
13. Fin del algoritmo

3.3.3 Diseo

Tomando es cuenta todo lo anterior es como se diseo la solucin.
M. en C. Rafaela Blanca Silva Lpez
Pgina 11
Curso SAI - Introduccin a la Programacin

Pseudocdigo
Algoritmo Ecuacin_Cuadrtica
variables
real a, b, c, x1, x2
Inicio
leer(a, b, c)
si (a=0) entonces
si (b=0) entonces
si (c=0) entonces
escribe(x = reales)
sino
escribe(No hay solucin)
fin_si
sino
x1=lineal(b, c)
escribe(x=, x1)
sino
llama_a cuadratica(a, b, c, x1, x2, d)
llama_a escribe_sol(x1, x2, d)
fin_si
Fin

Funcin lineal(real a, real b)
Inicio
regresa(-b/a)
Fin_funcion

Procedimiento Cuadratica(real a, real b, real c, real x1,
real x2, real dis)
Inicio
dis b a c = ^ * * 2 4
si (dis<0) entonces
x1=-b/2/a
sino si (dis=0) entonces
3. Pgina 12 .
Tema 3 Algortmica.
x1=-b/2/a
x2=x1
sino
x1=(-b + raizcuadrada(dis))/2/a
x2=(-b - raizcuadrada(dis))/2/a
fin_si
fin_procedimiento

Procedimiento escribe_sol(real x1, real x2, real dis)
Inicio
si (dis>0) entonces
escribe(x1=, x1)
escribe(x2=, x2)
sino si (dis=0) entonces
escribe(x=, x)
sino
escribe("x1=", x1,"+i",abs(x2))
escribe(x2=,x1,-i,abs(x2))
fin_si
fin_procedimiento

La solucin de este problema esta diseada usando la filosofa de la programacin estructurada.
Usamos la programacin modular junto con el diseo descendente para dividir el problema en sus
partes, las cuales son ms manejables. Cada una de las partes se programa con un modulo. Estos
modulo se disean empleando las estructuras de control.
Comenzamos por disear l modulo principal. Esto nos permite definir la secuencia general de pasos a
seguir, sin detenernos en los detalles. Vamos de lo mas general a lo ms particular. Primero nos
interesa lo que hace un modulo, despus nos preocupamos de como hacerlo. l modulo principal de
este programa nos dice que se requieren 3 mdulos adicionales. Una funcin y dos procedimientos.

3.4 Ejemplos:

3.4.1 Problema 1.
Leer tres nmeros del teclado y deducir si se han introducido en orden creciente
3.4.1.1 Pseudocdigo.
Variables N1,N2,N3: enteros
M. en C. Rafaela Blanca Silva Lpez
Pgina 13
Curso SAI - Introduccin a la Programacin

algoritmo creciente
inicio
escribir (ntroducir tres nmeros`)
leer (N1,N2,N3)
si N1 <=N2 y N2<=N3
entonces
escribir (Orden creciente)
sino
escribir (No estan en orden creciente)
fin_si
fin

3.4.2 Problema 2.
Disear el algoritmo para imprimir los nmeros impares menores o iguales que n. Los nmeros
impares son 1,3,5,7,...n
3.4.2.1 Pseudocdigo.
Algoritmo: impares
inicio
leer(n)
desde i <-- 1 hasta n incremento 2 hacer
escribir (i )
fin_desde
fin

3.4.3 Problema 3.
Leer sucesivamente nmeros del teclado, hasta que aparezca un nmero comprendido entre 1 y 5
3.4.3.1 Pseudocdigo.
Algoritmo: Rango
inicio
repetir
escribir(nmero comprendido entre 1 y 5`)
leer (nmero)
hasta que numero >= 1 y numero <= 5
escribir (nmero encontrado)
fin
3. Pgina 14 .
Tema 3 Algortmica.

3.4.4 Problema 4.
Calcular el valor mximo de una serie de 100 nmeros.
Para resolver este problema necesitaremos un contador que cuente de 1 a 100, para contabilizar los
sucesivos nmeros.
El algoritmo que calcule el valor mximo ser repetido y partiremos considerando que el primer
nmero ledo es el valor mximo,por lo cual se realizar una primera asignacin del nmero 1 a la
variable mximo.
leer (numero )
n <-- 1
maximo <-- numero
leer un nuevo nmero, compararlo con el valor mximo, si es inferior implica que el valor mximo es
el antiguo, si es superior implica que el valor maximo es el recientemente ledo,por lo que ste se
convertir en mximo mediante una asignacin, repetir las acciones anteriores hasta que n=100.
3.4.4.1 Pseudocdigo.
Algoritmo: mximo
inicio
Variables n :entero
maximo,numero :real
leer(numero)
n<--1
maximo<-- numero
repetir
n <--n+1
leer(numero)
si numero >maximo entonces maximo <-- numero
hasta_que n=100
escribir (`numero mayor o maximo ` maximo)
fin

3.4.5 Problema 5.
Obtener un algoritmo que permita calcular la tabla de multiplicar mediante bucles anidados desde.
3.4.5.1 Pseudocdigo.
Algoritmo: tablas de multiplicar
inicio
variables i,j,producto:entero
desde i <-- 1 hasta 10 hacer
M. en C. Rafaela Blanca Silva Lpez
Pgina 15
Curso SAI - Introduccin a la Programacin

escribir (`tabla del`,i)
desde j <-- 1 hasta 10 hacer
producto <-- i*j
escribir(i,`por`,j,`=`, i*j producto)
fin_desde
fin_desde
fin

3.4.6 Problema 6.
Se desea disear un algoritmo que escriba los nombres de los das de la semana en funcin del valor
de una variable DIA introducida por teclado.
Los das de la semana son 7 por consiguiente el rango de valores de DIA ser 1..7, y en caso de que
DIA tome un valor fuera de este rango se deber producir un mensaje de error advirtiendo la situacin
anmala.
3.4.6.1 Pseudocdigo.
Algoritmo: das de la semana
inicio
leer DIA
segun_sea DIA hacer
1. escribir (`LUNES`)
2. escribir (`MARTES`)
3. escribir(`MIERCOLES`)
4. escribir (`JUEVES`)
5. escribir(`VIERNES`)
6. escribir (`SABADO`)
7. escribir (`DOMINGO`)
otros escribir( ERROR)
fin_segun
fin

3.4.7 Problema 7.
Se desea un algoritmo que realice la operacin de suma o resta de dos nmeros ledos del teclado en
funcin de la respuesta S/N a un mensaje de peticin de datos.
La tabla de variables es la siguiente :
A,B :reales
CON :caracteres (cadena)
3. Pgina 16 .
Tema 3 Algortmica.
3.4.7.1 Pseudocdigo.
algoritmo Suma_resta
inicio
escribir (`desea suma(S), resta(R)`)
leer CON
si CON=`S`
entonces S <-- A+B
escribir (`Suma=`,S)
sino R<-- A-B
escribir (`Resta=`,R)
fin_si
fin

3.4.8 Problema 8.
Clculo de la suma de los cuadrados de los 100 primeros nmeros naturales. S=1
2
+ 2
2
+3
2
+...100
2.

Variables:
I contador :entero
S sumador :real(o entero largo)
C cuadrados :real(o entero largo)
3.4.8.1 Pseudocdigo.
Algoritmo: Suma_cuadrados
inicio
I <-- 0
S <-- 0
mientras I<100
I <-- I+1
C <-- I*I
S <-- S+C
fin_mientras
escribir (`Suma=`,S)
fin

3.4.9 Problema 9.
Calcular el nmero de elementos negativos, cero y positivos de un vector dado de 60 elementos
3.4.9.1 Pseudocdigo.
M. en C. Rafaela Blanca Silva Lpez
Pgina 17
Curso SAI - Introduccin a la Programacin

Algoritmo: contar
Var P,N,C :enteros
V :array [1..60] de real
inicio
N <-- 0
P <-- 0
C <-- 0
desde i <-- 1 hasta 60 hacer
leer V(i)
segun_sea V(i) hacer
>0 :P <-- P+1
<0 :N <-- N+1
=0 :C <-- C+1
fin_segun
fin_desde
escribir (P,N,C)
fin

3.4.10 Problema 10.
Se dispone de una lista (vector ) de N elementos. Se desea disear un algoritmo que permita insertar el
valor x en el lugar k-simo de la mencionada lista.
Se analizan dos mtodos para la resolucin de este problema.
3.4.10.1 Primer mtodo
3.4.10.1.1 Anlisis
Sea la lista o vector L
L(1) L(2) L(3) L(4)....L(K)...L(N)
Si se desea insertar el valor X en el lugar k-simo,se producir un desplazamiento de los valores de
L(K) L(N) crendose una nueva lista con N+1 elementos.
Para poder escribir X en la posicin de memoria L(K), ser preciso guardar el actual contenido de
L(K) en una posicin auxiliar de memoria P; a su vez , para guardar el valor del elemento L(K) ser
preciso llevar el valor de P a L(K+1) , guardando previamente el valor de L(K+1) en otra posicin
auxiliar Q; y as sucesivamente.
Los pasos a dar son:
1. Lectura del vector L
2. Lectura del nmero de elementos del vector N
3. Lectura de X
4. Lectura de K
3. Pgina 18 .
Tema 3 Algortmica.
5. Guardar el valor de L(K) en la variable P
6. Situar X en la posicin L(K)
7. Repetir las siguientes acciones desde I=1 a N-K
Guardar el contenido de L(k+1) en la variable Q
Poner el contenido de la variable P en L(k+1)
Poner el contenido de la variable Q en P
8. Poner el valor de p en la posicin L(N+1)
9. Escribir el valor L
3.4.10.1.2 Pseudocdigo.
Algoritmo: Insertar 1
var X,P,Q :real
N,I,K :entero
array L: dimension (N) dem real
inicio
leer(X,P,Q,K)
P<-- L(K)
L(K) <-- X
desde I <-- 1 hasta N-K hacer
Q <-- L(K+1)
L(K+1) <-- P
P <--Q
fin_desde
L(N+1) <-- P
**escritura del vector**
escribir (array L)
fin

3.4.10.2 Segundo Mtodo
3.4.10.2.1 Pseudocdigo
algoritmo insertar 2
var N.I,K:entero
X,P;Q: real
array L: dimension (N) de real
inicio
leer(X;P;Q;K)
M. en C. Rafaela Blanca Silva Lpez
Pgina 19
Curso SAI - Introduccin a la Programacin

desde I<-- N hasta K decremento -1 hacer
L(I+1) <-- X
** escribir el vector L**
escribir (L)
fin

3.4.11 Problema 11.
Una empressa tiene 10 almacenes y necesita crear un algoritmo que lea las ventas mensuales de los 10
almacenes. Calcule la media de ventas y obtenga un listado de los almacenes cuyas ventas mensuales
son superiores a la media.
3.4.11.1 Anlisis
El mtodo sita las ventas correspondientes a cada almacn en una matriz Ventas y a partir de esa
operacin realizar las restantes que se piden en el programa. Los pasos a dar son:
1. Lectura de la Matriz Ventas.
2. Clculo de la media de ventas,Media
3. Deducir si Media es mayor que cada una de las ventas mensuales( cada uno de los diez elementos
de la matriz ), en cuyo caso se escribir el nmero del almacn y sus ventas.
4. Fin
3.4.11.2 Pseudocdigo
algoritmo Ventas
inicio
dimensionar la Matriz Ventas con 10 elementos
desde I <-- 1 hasta 10 hacer
leer (Ventas(I))
Suma <-- Suma + Ventas(I)
fin_desde
Media <-- Suma /10
desde I<-- 1 hasta 10 hacer
si Ventas(I) >= Media
entonces
escribir ('Almacen' ,I , 'ventas' Ventas(I))
fin_si
fin_desde
fin

3.4.12 Problema 12.
3. Pgina 20 .
Tema 3 Algortmica.
Se tiene una tabla T de dos dimensiones. Calcular la suma de sus elementos .
Supongamos las dimensiones de T, M y N, y que se compone de nmeros reales
Tabla de variables
I Contador de filas
J Contador de columnas
M Nmero de filas de la tabla T
N Nmero de columnas de la tabla T
T Tabla
S Suma
I,J,M,N Enteros
T,S Reales
3.4.12.1 Pseudocdigo
algoritmo : suma_tabla
inicio
leer(M,N)
dimensionar T(M,N)
**Lectura tabla T**
desde I<-- 1 hasta M hacer
desde J <-- 1 hasta N hacer
leer(T(I,J))
fin_desde
fin_desde
escribir(' La suma de los elementos de la tabla =',S)
fin
M. en C. Rafaela Blanca Silva Lpez
Pgina 21
Curso SAI - Introduccin a la Programacin

3.5 ndice
Tema 3. ..........................................................................................................................................................................1
3. Algortmica y Programacin Estructurada. .............................................................................................1
3.1 El concepto de algoritmo. __________________________________________1
3.2 Programacin Estructurada. _______________________________________1
3.2.1 Estructuras de control..............................................................................................................................1
3.2.2 Programacin Modular............................................................................................................................5
3.2.3 Comunicacin entre mdulos (Paso de parmetros). ..............................................................................6
3.2.4 Constantes y Variables............................................................................................................................9
3.3 Algoritmos elementales. __________________________________________10
3.3.1 Definicin .............................................................................................................................................10
3.3.2 Anlisis .................................................................................................................................................10
3.3.3 Diseo ...................................................................................................................................................11
3.4 Ejemplos: ______________________________________________________13
3.4.1 Problema 1. ...........................................................................................................................................13
3.4.1.1 Pseudocdigo. ..................................................................................................................................13
3.4.2 Problema 2. ...........................................................................................................................................14
3.4.2.1 Pseudocdigo. ..................................................................................................................................14
3.4.3 Problema 3. ...........................................................................................................................................14
3.4.3.1 Pseudocdigo. ..................................................................................................................................14
3.4.4 Problema 4. ...........................................................................................................................................15
3.4.4.1 Pseudocdigo. ..................................................................................................................................15
3.4.5 Problema 5. ...........................................................................................................................................15
3.4.5.1 Pseudocdigo. ..................................................................................................................................15
3.4.6 Problema 6. ...........................................................................................................................................16
3.4.6.1 Pseudocdigo. ..................................................................................................................................16
3.4.7 Problema 7. ...........................................................................................................................................16
3.4.7.1 Pseudocdigo. ..................................................................................................................................17
3.4.8 Problema 8. ...........................................................................................................................................17
3.4.8.1 Pseudocdigo. ..................................................................................................................................17
3.4.9 Problema 9. ...........................................................................................................................................17
3.4.9.1 Pseudocdigo. ..................................................................................................................................17
3.4.10 Problema 10. .......................................................................................................................................18
3.4.10.1 Primer mtodo..............................................................................................................................18
3.4.10.1.1 Anlisis ...................................................................................................................................18
3. Pgina 22 .
Tema 3 Algortmica.
3.4.10.1.2 Pseudocdigo. .........................................................................................................................19
3.4.10.2 Segundo Mtodo..........................................................................................................................19
3.4.10.2.1 Pseudocdigo ..........................................................................................................................19
3.4.11 Problema 11. .......................................................................................................................................20
3.4.11.1 Anlisis ........................................................................................................................................20
3.4.11.2 Pseudocdigo...............................................................................................................................20
3.4.12 Problema 12. .......................................................................................................................................20
3.4.12.1 Pseudocdigo...............................................................................................................................21
3.5 ndice _________________________________________________________22

M. en C. Rafaela Blanca Silva Lpez
Pgina 23