Subalgoritmos

Muchas veces es ms elegante y barato mejorar un algoritmo que comprar una computadora ms rpida.
Los dilemas algortmicos estn presentes en todas las actividades humanas y resolverlos en forma rpida
y eficiente puede ser un desafo entretenido si gustamos de la lgica y la matemtica.
R. Baeza-Yates

Programacin modular
La experiencia ha demostrado que un problema complejo se resuelve mejor si se lo divide en sub-problemas de
menor complejidad, es decir, dado un problema se debe pensar en sub-problemas que constituyan mdulos
separados que luego se ensamblen para construir el algoritmo que resuelva el problema de origen.
Las caractersticas de dichos mdulos son:
cada uno de estos mdulos debe ser independiente de los otros,
cada mdulo debe estar definido en s mismo, con sus entradas, sus acciones, y sus resultados; se los
puede probar en forma independiente y

permite que, diferentes diseadores del programa puedan trabajar simultneamente en cada uno de ellos.
Estos mdulos luego son ensamblados adecuadamente para lograr la resolucin del problema inicial.

Dado que los mdulos son independientes se los puede modificar sin afectar a los otros.
Por otro lado, el concepto de modularizacin se puede asociar al concepto de reuso. En la resolucin de problemas
complejos se pueden utilizar partes de otros problemas previamente resueltos, esto es, reutilizar soluciones ya
conocidas, testeadas con anterioridad.
Un algoritmo o parte de l que puede ser reutilizado en otros contextos de problemas algortmicos recibe el
nombre de mdulo o rutina. Una rutina, segn el diccionario de la Real Academia Espaola, es una secuencia
invariable de instrucciones que forma parte de un programa y se puede utilizar repetidamente.
Una buena parte del tiempo empleado en resolver problemas se usa en identificar rutinas y reutilizarlas en forma
apropiada.
Cada mdulo es parte de un algoritmo general, por lo cual lo denominaremos subalgoritmo.

Concepto de Subalgoritmo
Un subalgoritmo define una tarea que realiza algo especfico y puede ser reutilizada en otros contextos de
resolucin de problemas algortmicos.
Algunos mdulos son tan comunes que estn incluidos en los lenguajes de programacin. Son las denominadas
funciones internas, tales como sin( ), cos( ), abs( ), las cuales son suministradas en forma de biblioteca o paquetes
de mdulos reutilizables.
Como se mencion cada subalgoritmo puede desarrollarse en forma independiente de los restantes. Tiene una
zona de ingreso de datos y otra de salida de resultados.
Los esquemas que se muestran a continuacin representan dos posibles estructuras equivalentes de diseo de
algoritmos utilizando subalgoritmos. Notar que es lo mismo pensar y escribir primero los subalgoritmos, y luego
utilizarlos en el algoritmo principal, o primero pensar y escribir el algoritmo principal proponiendo los
subalgoritmos, y luego escribir cada uno de ellos. Es decir, es indistinto el orden en que se piensan y escriben el
algoritmo y subalgoritmos que componen el mismo.

Ing. L. Angelone

Pgina 1

En general se diferencian dos tipos de subalgoritmo, acorde a las tareas que desarrollan, ellos son los
subalgoritmos funcin y los subalgoritmos subrutina, que veremos a continuacin.

Subalgoritmo funcin
Este tipo de subalgoritmos se implementan cuando la tares a desarrollar devuelven un nico resultado, en general
son clculos. Responden al concepto matemtico de funcin de una o ms variables.
Ejemplos de este tipo de subalgoritmos son las funciones internas, tales como sin( ), cos( ), abs( ), hallar el
mximo de un conjunto de nmeros, etc.
Un subalgoritmo funcin es un subalgoritmo que recibiendo o no datos devuelve un nico resultado.
Una funcin es un objeto del ambiente, con nombre, tipo y valor nico. El tipo se asocia al valor que retorna la
funcin cuando es evaluada con un conjunto dado de valores de sus argumentos.
Sintaxis de la declaracin de funciones
funcin <nombre de la funcin>(<lista de parmetros>): <Tipo de resultado>
var
<declaracin de variables>
Inicio
Cuerpo <acciones>
Devolver (<constante, variable o expresin>)
fin funcin
Nombre de funcin: el nombre de una funcin sigue la misma regla de los nombres de variables, es decir, debe ser
un identificador vlido.
Tipo de resultado: seala el tipo de informacin que devuelve la funcin.
Lista de parmetros: contiene las variables que pasan informacin necesaria para que la funcin ejecute el
conjunto de acciones. Cada variable de la lista debe tener una declaracin de tipo dentro del parntesis. Puede que
no haya lista de parmetros; en dicho caso se escribe el parntesis vaco.
Declaracin de variables: en este lugar se deben declarar aquellas variables que se usarn en la funcin, salvo las
que estn declaradas en la lista de parmetros. Estas variables son llamadas locales dado que su alcance se
restringe a la funcin. Cuando se abandona la funcin dichas variables no pueden ser accedidas, son locales a la
funcin.
Cuerpo de la funcin: lo constituye el conjunto de acciones a realizar por la funcin.
Retornar el resultado: el nico resultado que devuelve la funcin puede ser un valor constante, o una variable o
una expresin vlida, la cual debe colocarse entre parntesis al lado de la accin Devolver. Cuando se ejecuta esta
accin se devuelve el control del algoritmo al lugar donde se ha llamado la funcin.

Ing. L. Angelone

Pgina 2

Ejemplos de subalgoritmos funcin

A continuacin veremos algunos ejemplos de funciones y su utilizacin.
n

Ejemplo 1: definicin de la funcin y = x donde el exponente n es de tipo entero

funcin potencia ( real x, entero n):real
var
entero i, real y
inicio
y 1
Repetir Para i<-1 hasta abs(n) hacer
y y * x
finpara
si n < 0 entonces
y 1 / y
fin si
devolver (y)
fin funcin

Cmo usar/llamar/invocar una funcin?

A este tipo de subalgoritmo se lo puede llamar o invocar desde cualquier expresin, desde una asignacin, desde
una decisin, o una salida de datos.
Debe cumplirse que el valor calculado que devuelve la funcin en su nombre sea recibido en un contenedor vlido
respecto de su tipo de dato.
Ejemplo 2: Escribir un algoritmo que utilice la funcin del ejemplo anterior para calcular las 10 primeras
potencias de un valor x de tipo real que primero deber ser ingresado por teclado.
Veremos 2 maneras de llamar a la funcin potencial. Modo 1, desde una accin de escribir. Modo 2, asignando el
resultado de la funcin a una variable del mismo tipo.
Modo 1

Modo 2

Algortimo calcul_potencia
var
entero n, real w
inicio
escribir(Evala la funcin y=w^n)
escribir (Ingrese valor de n)
leer (n)
escribir (Ingrese valor de w)
leer(w)
escribir(El valor es:, potencia(w,n))
fin

Algortimo calcul_potencia
var
entero n, real w,z
inicio
escribir(Evala la funcin y=w^n)
escribir(Ingrese valor de n)
leer(n)
escribir(Ingrese valor de w)
leer(w)
z <- potencia(w,n)
escribir (El valor es :, z )
fin

En este ejemplo se muestran dos formas posibles de utilizacin de la funcin potencia: en el modo 1 la funcin
potencia es empleada directamente dentro de la accin escribir, mientras que en el modo 2 el valor devuelto por la
funcin potencia es asignado en la variable real z y es el valor almacenado en z el que luego se muestra.
Diferentes formas de invocar/llamar a un subalgoritmo funcin

Asignando el resultado de la funcin a una variable, como es el Modo 2.

Dentro de una accin Escribir, como es el Modo 1.

Como parte de una expresin, por ej. Z 2*potencia( w, 7)/ 10.

Dentro de una condicin, pro ej. Mientras potencia(w,n) < 100 hacer .

Ing. L. Angelone

Pgina 3

Veamos otros ejemplos.

Ejemplo 3: Desarrollar un subalgoritmo para el clculo del factorial de un nmero entero n.
funcin FACTORIAL ( entero n):real
var
entero i,f
inicio
f 1
Repetir Para i<-1 hasta abs(n) hacer
f f * i
finpara
devolver (f)
fin funcin

Ejercicio 4: Realizar un subalgoritmo que verifique si una fecha es vlida o no.

Esta funcin de tipo booleana, necesita recibir 3 parmetros (da, mes y ao) y devuelve verdadero o falso. Debe
considerarse que el ao pueda ser bisiesto.
funcin Validacin-de-fecha (entero dia, mes, anio): boolean var
boolean correcta, bisiesto
inicio
bisiesto falso
Si (MOD(anio, 4)== 0) .AND. (MOD(anio,100)<>0).OR.(MOD( anio,400==0)
entonces bisiesto verdadero
fin si
correcta verdadero
Segn sea mes hacer
1,3,5,6,8,10,12:Si dd>31 entonces correcta falso
finsi
4,7,9,11: Si dia > 30 entonces correcta falso
finsi
2: Si bisiesto entonces Si dia > 29 entonces correcta falso
finsi
sino
Si dia>28 entonces correcta falso
finsi
fnsi
otros valores: correcta falso
finsegn
devolver (correcta)
fin de la funcin Validacin-de-fecha

Subalgoritmo subrutina
El empleo de los subalgoritmos funcin estn limitados a los casos donde el resultado debe ser expresado por un
nico valor. Sin embargo, en ciertas ocasiones se necesita que el subalgoritmo devuelva ms de un valor (por
ejemplo races de un polinomio) o no devuelva nada (una impresin), en este caso se introduce una nueva idea de
subalgoritmo que se denomina subrutina.
En general se piensa en una subrutina cuando la tarea a desarrollar es un proceso que no necesariamente tenga un
resultado, tales como impresin, ordenamiento, bsqueda de informacin, dibujo de figuras o interfaces, entre
otros.
Una subrutina es un subalgoritmo que recibiendo o no datos permite devolver varios resultados, un resultado o
ninguno.

Ing. L. Angelone

Pgina 4

Sintaxis de la declaracin de subrutinas

subrutina <nombre de la subrutina>(E:<lista de parmetros de entrada>, S: <lista de parmetros de salida>)
var
<declaracin de variables locales>
inicio
cuerpo <acciones>
fin subrutina
Nombre de la subrutina: el nombre de las subrutinas siguen las mismas reglas de los nombres de las variables.
Lista de parmetros: contiene las variables que pasan alguna informacin que necesita la subrutina para ejecutar
sus acciones y aquellas variables en las cuales se almacenarn los resultados. Cada variable de la lista debe tener
una declaracin de tipo dentro del parntesis. Adems, se debe escribir la letra E y dos puntos antes de la lista de
parmetros de entrada (datos), y S y dos puntos antes de la lista de los parmetros de salida (resultados). En algn
caso puede que no haya lista de parmetros en cuyo caso se escribe el parntesis vaco.
Declaracin de variables locales: se deben declarar aquellas variables que se usarn en la subrutina, salvo las que
estn declaradas en la lista de parmetros.
Cuerpo de la funcin: lo constituye el conjunto de acciones a realizar por la subrutina.
Retornar el resultado: la subrutina no retorna en una accin Devolver como la funcin, pues puede devolver ms
de un valor, o slo uno o ninguno, y lo hace a travs de sus parmetros de salida.
Cuando un algoritmo llama a una subrutina lo hace escribiendo el nombre de la misma seguido de los argumentos
(datos y variables resultados) como si se tratase de una accin ms.
Al aparecer el nombre de la subrutina se establece la correspondencia entre argumentos y parmetros y se ejecutan
las acciones indicadas en el cuerpo de la subrutina. Cuando finaliza el subalgoritmo, el algoritmo que realiz la
llamada contina en la accin inmediatamente siguiente a aquella en la cual figura el nombre de la subrutina. A
continuacin veremos algunos casos que ejemplifican este mecanismo.
Veamos algunos ejemplos de subalgoritmos subrutina.
n

Ejemplo 5: Realicemos la funcin x pero como subrutina

subrutina XalaN ( E: real x, entero n; S: real y)
var
entero i
inicio
y 1
Repetir para i<-1 hasta abs (n) hacer
y y * x
finpara
si n < 0 entonces
y 1 / y
finsi
fin subrutina

Cmo usar/llamar/invocar una subrutina?

A una subrutina se la llama desde una lnea del algoritmo / desde una sentencia en un programa.
Ejemplo 6: Escribir un algoritmo que utilice la funcin del ejemplo anterior para calcular las 10 primeras
potencias de x. El valor de x deber ser ingresado por teclado, siendo x un valor real.
Algortimo calcul_potencia
Var
entero n, real x, r
inicio
escribir (Tabla y = x ^ n )
escribir (Ingrese valor de x)
leer (x)
Repetir para i<-1 hasta 10 hacer
XalaN ( x, i, r )
escribir (x ^, i,:, r
finpara
fin

Ing. L. Angelone

Pgina 5

Notar que existe una nica forma de invocar a las subrutinas, y esto es: escribiendo el nombre de la subrutina
seguido de los argumentos entre parntesis, como si fuera una accin ms - tales como el Leer(..) o el Escribir(...).

Subrutinas que no devuelve ningn resultado.

Para desarrollar este tema veremos algunos ejemplos que mostrarn su uso.
Ejemplo 7: Escribir un subalgoritmo subrutina que muestre un encabezado
subrutina Encabezado( )
inicio
escribir (*******************************)
escribir (
INFORMATICA I
')
escribir (*******************************)
fin subrutina

Ejemplo 8: Escribir un subalgoritmo subrutina que muestre una lnea de 25 asteriscos

subrutina TrazalineaI ( )
var i: entero
inicio
Repetir Para i <- 1 hasta 25 hacer
escribir (*)
finpara
fin subrutina

Entonces la subrutina Encabezado( ) se podra escribir utilizando TrazalineaI, resultando:

subrutina Encabezado ( )
inicio
TrazalineaI ( )
escribir (
TrazalineaI ( )
fin subrutina

INFORMATICA I

')

Ejemplo 9: Escribir un subalgoritmo subrutina que muestre una lnea de asteriscos de longitud a requerimiento del
usuario.subrutina TrazalineaII ( E: entero long)
var entero i
inicio
repetir para i=1 hasta
escribir (*)
finpara
fin subrutina

long

hacer

Entonces el Subrutina Encabezado( ) se podra escribir utilizando TrazalineaII, resultando:

subrutina Encabezado ( )
inicio
TrazalineaII ( 25 )
escribir (
INFORMATICA I
TrazalineaII ( 25 )
fin subrutina

')

Ejemplo 9: Escribir un subalgoritmo subrutina que muestre una lnea de de longitud y carcter a requerimiento del
usuario
subrutina TrazalineaIII (E: entero long, char simb)
var entero i
inicio
Repetir para i <-1 hasta long hacer
escribir ( simb )
finpara
fin subrutina

Ing. L. Angelone

Pgina 6

Entonces el Subrutina Encabezado( ) se podra escribir utilizando TrazalineaIII, resultando:

subrutina encabezado ( )
inicio
TrazalineaIII ( 25, * )
escribir (
INFORMATICA I
Trazalinea III ( 25, * )
fin subrutina

')

Un caso especial: los parmetros de entrada tambin son de salida.

Lo veremos a travs de un ejemplo
Ejemplo 10: desarrollar una subrutina que permita realizar el intercambio de los valores de 2 variables numricas.
subrutina intercambio ( E/S: real a, b)
var
real aux
inicio
aux a
a b
b aux
fin subrutina

Ejemplo 11: desarrollar un algoritmo para ordenar tres nmeros reales utilizando la subrutina intercambio.
Algoritmo ordenar
var
real x, y, z
inicio
escribir (Ingrese tres nmeros reales )
leer (x, y, z)
si x > y entonces intercambio (x, y)
fin si
si y > z entonces intercambio (y, z)
fin si
si x > y entonces intercambio (x, y)
fin si
escribir (x, y, z)
fin

Parmetros y argumentos en los subalgoritmos

Las variables que aparecen en el enunciado de un subalgoritmo conforman la lista de parmetros. Las
correspondientes a la llamada al subalgoritmo se denominan argumentos, los cuales contienen los valores
necesarios para evaluar el subalgoritmo en ese momento.
Los argumentos pueden ser constantes, variables, expresiones, valores de funciones y hasta nombres de funciones
o subrutinas.
Los parmetros slo deben ser variables, pues reciben los datos que se envan en la llamada y variables donde se
depositan los resultados.
Cada vez que un subalgoritmo es llamado desde el algoritmo o desde otro subalgoritmo, se establece una
correspondencia entre los argumentos y los parmetros de tipo posicional, es decir, el primer argumento se
corresponde con el primer parmetro, el segundo con el segundo y as sucesivamente. Debe darse tambin la
consistencia de tipos entre el argumento y su correspondiente parmetro. Si esto no se cumple, el compilador
detectar el error. Y la ltima correspondencia, es de cantidad, si el subalgoritmo tiene n parmetros implica que
al llamarlo debe tener n argumentos.

Ing. L. Angelone

Pgina 7

Ejemplo 12: parmetros y argumentos en la funcin Cuenta

funcin Cuenta( real x1, x2, t) : real
var
real z
inicio
x1, x2, t son los parmetros
x1 x1 *100
z ( x1 + x2 ) * t
devolver (z)
fin funcin

x, y, tiempo son los argumentos

La utilizacin o llamada a la funcin podra ser de la siguiente manera:
temp x * y * tiempo + Cuenta( x, y, tiempo)

En este caso la correspondencia entre argumentos y parmetros es x con x1, y con x2, tiempo con t
temp x * y * tiempo + Cuenta(1.5*x, (x+z)*2.5, tiempo)

lista de argumentos,
(antes de establecer la
correspondencia con los parmetros, formales se deben
resolver evaluar las expresiones: 1.5*x y , (x+yz)*2.5

Como conclusin podemos decir que los parmetros van con las definiciones de los subalgoritmos y los
argumentos con las llamadas a los mismos.
Ejemplo 13: parmetros y argumentos en la subrutina divisin
subrutina divisin (E: entero dividendo,divisor; S: entero cociente, resto)
inicio
cociente dividendo div divisor
lista de parmetros:
resto dividendo mod divisor
fin subrutina divisin
dividendo, diviso y cociente.

La utilizacin o llamada a la subrutina podra ser de la siguiente manera:

divisin (m,n,p,q )

lista de argumentos: m, n, p y q
En este caso la correspondencia entre argumentos y parmetros es m con dividendo, n con divisor, p con cociente,
q con resto.
divisin (m*n-4, n+1, s, t )

lista de argumentos (antes de establecer la

correspondencia con los parmetros se deben
resolver las expresiones.)
En este caso la correspondencia entre argumentos y parmetros es m*n-4 con dividendo, n+1 con divisor, s con
cociente, t con resto. Se debe notar que los 2 ltimos argumentos deben se variables pues reciben informacin
desde la subrutina.

Ing. L. Angelone

Pgina 8

Memoria para los subalgoritmos

Siempre que un subalgoritmo es llamado se crea un espacio de memoria RAM temporal para cada uno de los
parmetros por valor y variables locales del mismo. Cada parmetro es inicializado con el valor del parmetro
actual correspondiente en el enunciado de llamada. Despus de esta inicializacin, la computadora ejecuta el
cuerpo del subalgoritmo.
Las celdas de memoria del subalgoritmo pueden ser pensadas como espacios temporales de escritura, porque
cuando el procesador deja el subalgoritmo, stas celdas de memoria, son liberadas y sus contenidos se pierden.
Aclaracin: la palabra temporal aqu tiene significado de poco tiempo, momentneo.
Parmetros formales y actuales con igual nombre.
Ya sabemos que las variables que usa un subalgoritmo residen en memoria, de tipo RAM, y con ellas trabaja el
procesador en la ejecucin del programa.
Cuando se llama a un subalgoritmo, el procesador le dispone de un sector de memoria distinto al del programa
llamador. Por ello el subalgoritmo tiene su propio segmento de memoria para colocar los parmetros formales y
toda otra variable que necesite.
Qu pasa cuando en el algoritmo existen variables cuyos nombres coinciden con algunas del
subalgoritmo?
La respuesta es simple: no hay problema. Esto es debido a que estn en lugares de memoria distintos, en distintos
mbitos.
Por esta misma razn los nombres de los parmetros y los argumentos pueden ser distintos o no. Veamos un
ejemplo con la funcin potencia ya definida.
Algoritmo
Variables

real funcin Potencia ( x , n )

var
entero x, n, i
real y
inicio
y1
Repetir Para i<- 1 hasta abs (n) hacer

real x
entero i

Comienzo
Leer( x, i )
Escribir ( Potencia ( x ,i ) )
Fin

yy*x
finpara
Si n < 0 entonces y 1 / y
fin si
Devolver(y)
fin funcin

Memoria RAM

RAM programa

Ing. L. Angelone

RAM subprograma
x

Pgina 9

Variables locales y globales

Variables globales o externas: son aquellas que se declaran en el algoritmo que llama al subalgoritmo, y su uso no
slo abarca al algoritmo sino que tambin pueden ser utilizadas en el subalgoritmo.
En este caso las subrutinas y funciones "ven" las variables globales y pueden usarlas sin necesidad de declararlas,
las usan directamente desde la RAM del algoritmo.
Variables locales o internas: Las variables cuya validez alcanza slo al subalgoritmo son locales a l.
Es decir, son aquellas variables que se declaran en el subalgoritmo. Su uso se limita al subalgoritmo, y una vez
que ste retorna al algoritmo que lo llam, dichas variables quedan indefinidas y desaparecen. Los parmetros
formales tambin son variables locales.
Si se vuelve a llamar al subalgoritmo, las variables locales no tienen porque conservar los valores que tuvieran
antes.
Veamos un ejemplo:
Algoritmo "A"
var
real x,y,z
Comienzo
x 2
z
10
y
B ( x )
Escribir ( x, y, z )
fin.

Funcin B( real h): real

var real r,x
Comienzo
z z + h
x 7
r z + x
B r
retornar

Cmo funciona este algoritmo?

El algoritmo tiene 3 variables x, y, z . Se le asignan valores a: x y z , pero el valor de y se obtiene al llamar a
la Funcin B . Notemos que la variable z aparece en la Funcin pero no est declarada en ella.
Realicemos la prueba de escritorio:
La variables z es modificada por la funcin ya que la misma es una variables global.
Por lo tanto se imprime 2
19
12
Notamos que :
- los nombres de los parmetros y los argumentos no tienen porque ser iguales.

x, y , z son variables globales

h, r , x son variables locales ,z es una variable global que es usada por la funcin.
existen dos variables x distintas una est definida en la memoria que tiene asignado el algoritmo y la otra
(local a la funcin) est definida en la memoria que tiene asignado el subalgoritmo funcin. Por lo tanto,
al estar en lugares distintos, no son iguales.

Si se desea que un conjunto de variables tenga "visibilidad "en todo el programa ( algoritmo principal y
subalgoritmos ) las variables deben definirse como globales. En este caso se trabaja sobre una nica
posicin de memoria y todos los mdulos miran a esa posicin al referenciar el nombre de la variable
global. Este tipo de proceso debe usarse en casos muy especficos, pues el abuso genera programas
difciles de mantener, o resultados no deseados.

Ing. L. Angelone

Pgina 10

Realicemos la resolucin de un sistema de 2 ecuaciones con 2 incgnitas.

Ejemplo 14: Realizar un algoritmo que reciba como datos los coeficientes a1,a2,b1,b2,c1 y c2 de un sistema de
2x2 de ecuaciones, llame a un subalgoritmo RESOLVER para resolverla, y luego imprima el sistema con sus
soluciones correspondientes.
Resolucin
Datos: a1, a2, b1, b2, c1, c2 coeficientes de un sistema de ecuaciones
Resultados: x , y solucin del sistema
Proceso de resolucin :
Usando el mtodo de Cramer
D= Discriminante = a1 * b2 - a2 * b1 Si es distinto de 0 tenemos soluciones
DX = Discriminante X = c1 * b2 - c2 * b1
DY = Discriminante Y = a1 * c2 - a2 * c1
Por lo tanto la solucin del sistema es
x = DX / D
y = DY / D
Algoritmo " Resolucin de sistema de 2x2 "
var real a1, a2, b1, b2, c1, c2 , x , y
Comienzo
Leer (a1, a2, b1, b2, c1, c2)
RESOLVER ( a1, a2, b1, b2, c1, c2, x, y
Escribir ("El sistema ", a1, "x + ",b1,
Escribir ( "
" , a2 ,"x + ",b2,
Imprimir ( "tiene solucin x =", x , "
fin.

)
" y = ", c1)
" y = ", c2)
y =", y)

Subrutina RESOLVER (E: real a1,a2,b1,b2,c1,c2; S: real sol1,sol2)

var real D,DX,DY
Comienzo
D= a1 * b2 - a2 * b1
DX = c1 * b2 - c2 * b1
DY = a1 * c2 - a2 * c1
sol1 = DX / D
sol2 = DY / D
fin subrutina

Notemos que :
- a1, a2, b1, b2, c1, c2 , x , y son variables globales, pero ninguna es usada como tales en el subrutina, ya que
ste tiene var a1, a2, b1, b2, c1, c2, sol1, sol2, D , DX y DY que son variables locales a l.
- a1, a2, b1, b2, c1, c2 del algoritmo no son las mismas que las del subrutina.
- sol1 y sol2 son variables de salida de resultados, y dichos resultados son tomados por x e y respectivamente
del algoritmo.
Otra forma ( no conveniente ) de resolucin del subrutina sera usando a : a1, a2, b1, b2, c1, c2 como variables
globales , a saber :
Subrutina RESOLVER
var real D,DX,DY
Comienzo
D= a1 * b2 DX = c1 * b2
DY = a1 * c2
sol1 = DX /
sol2 = DY /
fin subrutina

Ing. L. Angelone

(S: real sol1,sol2)

a2 * b1
- c2 * b1
- a2 * c1
D
D

Pgina 11

Pasaje de informacin entre argumento y parmetro

Como ya mencionamos, cada vez que un algoritmo llama a un subalgoritmo, se establece una correspondencia
automtica entre los argumentos y los parmetros correspondientes.
En el pasaje de estos parmetros se distinguen bsicamente dos formas: pasaje por valor y pasaje por
referencia.
Pasaje de parmetros por valor: es la forma ms simple de pasar los datos, donde los parmetros reciben como
valores iniciales una copia temporal de los valores de los argumentos, y con estos valores comienza a ejecutar el
subalgoritmo. Por ejemplo a1, a2, b1, b2, c1, c2 del ejercicio anterior. Es decir el argumento y el parmetro
correspondiente estn en distintas reas de memoria.
Pasaje de parmetros por referencia: en lugar de pasar el valor del argumento como valor inicial para su respectivo
parmetro, el pasaje de parmetros por referencia, tambin llamado por direccin, establece una conexin directa
a travs de su direccin de memoria. Se podra describir esta conexin dibujando una flecha por cada argumento
encuntrala cual apunta al lugar de memoria del argumento correspondiente.
Es decir, que toda operacin que tenga en cuenta los parmetros, en realidad se realiza con los argumentos.
Para distinguir este tipo de pasaje nosotros usamos S en la lista de parmetros.
Un ejemplo de pasaje por referencia son las variables sol1 y sol2 con x e y.
Se puede concluir que en las funciones, si tiene parmetros, stos sern pasados por valor por la definicin de
funcin, nunca existir ningn parmetro pasado por referencia.
En cambio, en los subrutinas, los parmetros de entrada estarn pasando por valor y los de salida por referencia.

Introduccin al concepto de recursividad.Algunos programas de programacin permiten el uso de una

tcnica especial denominada recursividad.
Esta tcnica consiste en la llamada al subalgoritmo dentro del mismo, es decir, el subalgoritmo se autollama.
Por ejemplo, para calcular el factorial de un nmero n:

n!= 1 * 2 * 3 * 4 * .... * n , adems 0!= 1

Considerando que el orden de los factores no altera el producto, podemos escribir el clculo

n!= n * (n 1) * ... * 2 * 1
Viendo la frmula del factorial podemos utilizar factorial ( n) = n * factorial ( n 1) donde se utiliza la
funcin factorial para calcular el nuevo factorial.
Comencemos a construir, en forma recursiva, el factorial (n)

factorial (1) = 1* factorial (0)

factorial (2) = 2 * factorial (1)
factorial (3) = 3 * factorial (2)
.

factorial (n) = n * factorial (n 1)

factorial (n) = n * ((n 1) * factorial (n 2))
factorial (n) = n * ((n 1) * ((n 2) * factorial (n 3)))
.

factorial (n) = n * (n 1) * (n 2) * .... * 3 * 2 *1

Ing. L. Angelone

Pgina 12

Por lo cual, la funcin factorial (n) puede calcularse usando la frmula:

si n = 0

factorial (n)
n * factorial (n 1) si n <> 0
El subalgoritmo factorial (n) construido en forma recursiva, resulta:
Funcin factorial ( n : entero) : entero
inicio
Si n=0 entonces Devolver(1)
Sino Devolver(n*factorial(n-1))
finsi
fin

En muchos casos, sin embargo, la solucin recursiva no es la mejor, porque una simple solucin puede obtenerse
utilizando un esquema de repeticin o una frmula matemtica.

Ing. L. Angelone

Pgina 13

Men
Hasta ahora realizamos los algoritmos por separado sin ningn nexo de unin entre ellos.
Generalmente esto no sucede as, en problemas ms complejos aparecen relaciones entre distintos algoritmos, y se
debe realizar uno que indique cul es el que deseamos ejecutar en ese instante, el algoritmo principal. Gracias a la
existencia de subalgoritmos, esto es posible.
Un men consiste en presentar en pantalla una ventana con una serie de opciones a realizar,
cada una de las cuales realiza una operacin determinada.
En cada opcin podremos colocar la llamada a un subalgoritmo, que cuando se termina de ejecutar, el algoritmo
vuelve de nuevo a presentar el men del que haba partido.
A veces los mens se presentan anidados, es decir, alguna de las opciones del men, al ser seleccionada, hace que
aparezca otro men, dando lugar a nuevas posibilidades de eleccin.
Los mens permiten ejecutar ms de un programa, sin necesidad de tener que escribir su nombre, cada vez que se
desea ejecutarlo. Simplemente, le indicaremos mediante una variable la opcin deseada.
La seleccin de opciones del algoritmo generalmente se realiza con la estructura de seleccin mltiple Segn sea.
La idea es:
Repetir
Escribir ( Men de opciones)
Escribir ( 1: Ingresar un nuevo artculo )
Escribir ( 2: Buscar precio por artculo )
Escribir ( 3: Modificar precios )
Escribir ( 4: Dar de baja un artculo)
Escribir ( 0: FIN )
Escribir ( Ingrese su opcin)
Leer ( opcin )
Segn sea opcin hacer
1: INGRESO
2: BUSQUEDA
3: MODIFICAR
4: SACAR

Donde INGRESO, BUSQUEDA, MODIFICA Y SACAR son llamadas a subrutinas.

De esta manera el algoritmo principal queda entendible, y se saca del mismo todo proceso extra.
Esta es una forma de modularizar un problema.

Ing. L. Angelone

Pgina 14

Veamos a continuacin un ejemplo donde se resuelve aplicando el esquema de men.

Ejemplo 15: Sea una fbrica de motores que trabaja todos los das del ao, excepto los feriados nacionales, y
lo hace en tres turnos: Maana (M), Tarde (T) y Noche (N).
La fbrica necesita registrar toda la produccin del ao pasado ingresando los datos que constan en una serie
de registros impresos. En cada registro se consigna Fecha de fabricacin (una cadena de caracteres con el
formato: dd/mm/aa), Cantidad fabricada y Turno de fabricacin
El programa deber ofrece el siguiente men de opciones:
1.- Agregar nuevo Feriado
2.- Insertar nuevo Ticket
3.- Salir

Opcin 1:
Se deber registrar un nuevo feriado con la Fecha y con el Nombre del Feriado, siempre y
cuando ste no exista.
Opcin2:
Al ingresar los datos de un nuevo registro se deber validar que la fecha no corresponda a algn
feriado. Si correspondiera a un feriado, se deber reingresar la fecha hasta que sea vlida.
Para cada fecha, se deber registrar por separado la cantidad producida en cada turno. Se sabe que
puede haber ms de un registro con la mismo fecha y del mismo turno. En ese caso se deber
sumar al anterior.
Opcin3:
Finalizar la ejecucin del programa
El algoritmo/programa principal slo deber manejar el men de opciones e invocar a los subalgoritmos
necesarios.
Los datos pueden ser pensados segn el siguiente ejemplo:
FERIADOS 2012

MOTORES TURNOSRegistros ao 2012

FechaNombre
01/01/20120
FERIADOS 2012
5Primero
de
Fecha Nombre
Ao01/05/201205Da
del
01/01/2012 Primero de Ao
Trabajador20/06/201205Da
Da del Trabajador
de la01/05/2012
Bandera
20/06/2012 Da de la Bandera

FechaMaanaTardeNoche
02/01/201205
MOTORES TURNOS Registros ao
2012
120015

03/01/2012050036
10/02/20120
Fecha
Maana Tarde Noche
548251312/02/20120512554908/03/2
02/01/2012
12
0
15
012059582009/03/2012051026583
03/01/2012
0 
0 
3


10/02/2012
12/02/2012
08/03/2012
09/03/2012

48
12
95
102

25
55
82
65

13
49
0
83

A continuacin se desarrolla el algoritmo principal y los subalgoritmos correspondientes.

Algoritmo motores

type
m0: array[365] string

m1: array[365,3] entero

m2: array[365,2] string

var
entero opcion
m0 motores0
Ing. L. Angelone

Pgina 15

m1 motores1
m2 feriados
inicio
Repetir
escribir(1.- Agregar nuevo feriado)
escribir(2.- Insertar nuevo Ticket)
escribir(3.- Salir)
escribir(Ingrese su Opcin)
Repetir mientras (opcion<1) OR (opcion>3)
escribir(La opcin elegida no es correcta.
Por favor ingrese nuevamente su eleccin)

leer(opcion)
fin mientras
Segn sea opcion hacer

1:
2:
3:

agregar_feriado(feriados)
insertar_ticket( motores0, motores1)
fin

fin_segun
hasta_que (opcin==3)
fin
subrutina agregar_feriado (E/S m2 feriados)

var
string fecha_feriado
string nombre_feriado
entero i
inicio
repetir
escribir(Ingrese Fecha [dd/mm/aa])
leer(fecha_feriado)
hasta_que feriado_existente(fecha_feriado)=1
escribir(Ingrese el nombre del feriado)
leer(nombre_feriado)
i=1
Repetir mientras (feriados[i,1]<>) y (i<366) hacer
i=i+1
fin_mientras
feriados[i+1,1] = fecha_feriado
feriados[i+1,2] = nombre_feriado
fin_subrutina

funcion feriado_existente (string fecha): boolean

var
entero i
boolean b
inicio
b=0
i=0
Repetir
i=i+1
if feriados[i,1]=fecha entonces
b=1
fin_si
Ing. L. Angelone

Pgina 16

hasta_que (b=1) o (i=365)

Devolver(b)
fin_funcion

Subrutina ingresar_ticket(E/S m0 motores0, E/S m1 motores1)

var
string fecha
entero cant_motores, posicion
char turno
inicio
repetir
escribir(Ingrese Fecha de Fabricacin)
leer(fecha)
hasta_que feriado_existente(fecha)=0
repetir
escribir(Ingrese Cantidad de Motores fabricados)
leer(cant_motores)
hasta_que cant_motores>0
repetir
escibir(Ingrese Turno)
leer(turno)
hasta_que (turno=M) o (turno=T) o (turno=N)
posicin=buscar_fecha(motores0, fecha)
motores0[posicin] = fecha
segn_sea turno
M: motores1[posicin,1] = motores1[posicin,1] + cant_motores
T:
N:

motores1[posicin,2] = motores1[posicin,2] + cant_motores

motores1[posicin,3] = motores1[posicin,3] + cant_motores

fin_segun
fin_subrutina

funcion buscar_fecha(motores0: m0, fecha: cadena): entero

var
entero i
inicio
i=0
repetir
i=i+1
hasta_que (motores0[i] = fecha) o (motores0[i]=)
devolver(i)
fin_funcion

Bibliografa
Joyanes Aguilar, L. Fundamentos de Programacin. Algoritmos, estructuras de datos y objetos (2009) 3ra Edicin
McGraw-Hill.
Lage F., Cataldi, Z., Salgueiro, F., (2008) Fundamentos de Algoritmos y Programacin, Editorial NUEVA
LIBRERA.
Ing. L. Angelone

Pgina 17