SubAlgoritmos o SubProcesos:
Un subproceso es un subprograma, procedimiento o función que realiza una tarea específica y que puede ser definido.

Tanto en entrada de información al subproceso como la devolución de resultados desde la subproceso se realiza mediante parámetros, el cual nos sirve para introducir o modificar información del programa principal.

Sintaxis

SubProceso NombreSubProceso

// ...hacer algo con los argumentos, Acciones

FinSubProceso

Los subprocesos pueden o no tener retorno. En este caso, este subproceso no devuelve nada, los subprocesos que retornan argumentos los veremos más adelante.

Siempre que usemos parámetros estos deben de ser del mismo tipo datos, esto nos dice que la variable del programa, debe de del mismo tipo del parámetro del procedimiento y pasados en el mismo orden en que están colocados en el subproceso.

Nota: Las variables han de definirse en todos los subprocesos, a no ser que pasen y/o entren por referencia o valor desde otro subproceso

Para poder invocar (ejecutar) un subalgoritmo se debe escribir el nombre del mismo como si fuese una acción más.

Un subalgoritmo se puede invocar desde un algoritmo o desde otro subalgoritmo. Los subalgoritmos se escriben antes o después del algoritmo.

Ejemplo:

Elaborar un subAlgoritmo que edite "hola"

SubAlgoritmo ejemploMensaje
	definir nombre como caracter
	Limpiar Pantalla
	escribir "hola.."
	escribir ""
	escribir "cómo te llamas ?" Sin Saltar
	leer nombre
	escribir ""
	escribir "hola ",nombre
	escribir ""
	escribir " para continuar "
	esperar tecla
FinSubAlgoritmo

Algoritmo ejemplo
	ejemploMensaje
FinAlgoritmo
 
                 
             

Regresar



El algoritmo funciona ejecutando acción por acción, cuando llega al subalgoritmo se ejecutan todas las acciones correspondientes a dicho subalgoritmo y luego continua el algoritmo a partir de la acción siguiente a la invocación del subalgoritmo.

El objetivo del uso de subalgoritmos es modularizar un algoritmo, es decir dividir al problema en subpromlemas, resolver el problema con un algoritmo y a los sobproblemas con subalgoritmos. De esta forma cuando resuelvo un problema me abstraigo de los pequeños detalles que no hacen en sí al problema llamando a acciones (Subalgoritmos) que una vez resuelto el problema principal tendré que solucionar.

La ventaja más importante de modularizar es que los subprogramas se pueden reutilizar en el mismo algoritmo o en otros.



En muchos casos, nos encontraremos con tareas que tenemos que repetir varias veces en distintos puntos de nuestro programa. Si tecleamos varias veces el mismo fragmento de programa no sólo tardaremos más en escribir: además el programa final resultará menos legible, será más también será más fácil que cometamos algún error alguna de las veces que volvemos a teclear el fragmento repetitivo, o que decidamos hacer una modificación y olvidemos hacerla en alguno de los fragmentos. Por eso, conviene evitar que nuestro programa contenga código repetitivo.

Una de las formas de evitarlo es usar "subrutinas", una posibilidad que la mayoría de lenguajes de programación permiten, y que en ocasiones recibe el nombre de "procedimientos" o de "funciones" (existe algún matiz que hace que esas palabras no sean realmente sinónimas y que comentaremos más adelante).

PseInt permite definir "subrutinas" (o "funciones") dentro del pseudocódigo, desde la versión del 10 de octubre de 2012. En su caso, se llaman "subprocesos".

Veamos un ejemplo de su uso:

Vamos a empezar por crear un subproceso (o "subrutina", o "procedimiento") q ue escriba 20 guiones, que podríamos utilizar para subrayar textos. Un programa completo que escribiera tres textos y los subrayara podría ser:

            
 Algoritmo SubProcesos01
    Escribir " Primer ejemplo"
    Para x <- 1 Hasta 20 Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""

    Escribir " Segundo ejemplo"
    Para x <- 1 Hasta 20 Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""

    Escribir " Tercer ejemplo"
    Para x <- 1 Hasta 20 Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""
FinAlgoritmo
            
        

Muy repetitivo. Sería un poco más elegante si lo reescribimos así:

            
Algoritmo SubProcesos02
    Escribir " Primer ejemplo"
    Subrayar

    Escribir " Segundo ejemplo"
    Subrayar

    Escribir " Tercer ejemplo"
    Subrayar
FinAlgoritmo

Subproceso Subrayar
    Para x <- 1 Hasta 20 Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""    
FinSubproceso
            
        

Mucho más legible, pero todavía no está tan bien como debería: siempre estamos escribiendo 20 guiones, aunque el texto sea más largo o más corto. En la mayoría de lenguajes de programación se puede indicar detalles adicionales ("parámetros") para que se puedan utilizar desde dentro de esa subrutina. Por ejemplo, en nuestro caso podríamos indicarle qué texto queremos escribir y qué longitud queremos que tenga la secuencia de guiones:

            
Algoritmo SubProcesos03
    EscribirSubrayado(" Primer ejemplo", 16)
    EscribirSubrayado(" Segundo ejemplo", 17)
    EscribirSubrayado(" Tercer ejemplo", 16)
FinAlgoritmo

Subproceso EscribirSubrayado(texto, cantidad)
    Escribir texto
    Para x <- 1 Hasta cantidad Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""    
FinSubproceso
            
        

Eso todavía es un poco redundante: en general, querremos escribir tantos guiones como letras tenga el texto, así que no será necesario indicar ese dato. Desde octubre de 2012, PseInt incluye ciertas funciones predefinidas para manejo de cadenas de texto; una de ellas es "Longitud", que nos indica la cantidad de letras que tiene un texto, de modo que nuestro programa se podría simplificar así:

        
Algoritmo SubProcesos04
    EscribirSubrayado("Primer ejemplo")
    EscribirSubrayado("Segundo ejemplo")
    EscribirSubrayado("Tercer ejemplo")
FinAlgoritmo

Subproceso EscribirSubrayado(texto)
    Escribir texto
    Para x <- 1 Hasta Longitud(texto) Hacer
        Escribir Sin Saltar "-"
    FinPara
    Escribir ""    
FinSubproceso
        
    

Regresar



También podemos crear subprocesos que realicen ciertas operaciones aritméticas y devuelvan un resultado, como las funciones matemáticas que vimos en el tema 10. Se puede hacer con la misma palabra "subproceso" que hemos empleado hasta ahora, pero muchos lenguajes de programación distinguen entre un "procedimiento" o "subrutina", cuando se da una serie de pasos pero no se devuelve ningún valor (como habíamos hecho hasta ahora), y una "función", cuando sí se devuelve un resultado (como haremos en esta ocasión), así que usaremos esta última nomenclatura. Su desarrollo se parece mucho a lo que hemos hecho hasta ahora, con la diferencia de que escogeremos un nombre para la variable que guardará el resultado, así:

        
Funcion resultado <- Maximo( n1, n2)
    Si n1 > n2  Entonces
        resultado <- n1
    Sino
        resultado <- n2
    FinSi
FinFuncion

Algoritmo Funciones01
    Escribir "El máximo de 5 y 12 es:"
    Escribir Maximo(5,12)
    Escribir "El máximo de 25 y 12 es:"
    Escribir Maximo(25,12)
FinAlgoritmo
        
    

Este programa crea una función que calcula cuál es el mayor de los dos números que se le indican como parámetro, y la usa dos veces, para mostrar el máximo de dos valores p refijados.

No sólo podemos devolver valores numéricos; también podemos devolver cadenas (como las funciones que vimos en el apartado 13) o "valores de verdad" (verdadero, falso).

Por ejemplo, podemos crear una función que calcule si un número es primo o no (lo vamos a hacer de la forma más simple pero también de la menos eficiente: aplicar la definición, probando a dividir entre todos los números que hay entre 1 y n; si hemos encontrado dos divisores -o menos, para el número uno-, entonces el número es primo):

        
SubAlgoritmo resultado <- Primo ( num )
    cantidadDivisores <- 0
    Para cont <- 1 Hasta num Hacer
        Si num % cont = 0 Entonces
            cantidadDivisores <- cantidadDivisores + 1
        FinSi
    FinPara
    Si cantidadDivisores <= 2 Entonces
        resultado <- verdadero
    Sino
        resultado <- falso
    FinSi
FinSubAlgoritmo

Algoritmo PrimosDel1Al30
    Para n <- 1 hasta 30
        si Primo(n) Entonces
            Imprimir n
        FinSi
    FinPara
FinAlgoritmo
        
    

Ejemplo no. 1

SubAlgoritmos y SubProcesos con parámetros



Ejemplo no. 2

menú con SubAlgoritmos