Pseudocódigo - Sub Algoritmos

Sub Algoritmos

Ejercicio 1

-       Leer un número  X entre 1 y 10 y luego leer N números entre 1 y 10 e indicar cuales son coprimos con X.

 

En el problema descripto se pueden identificar problemas más pequeños, es decir para solucionar el ejercicio se deberían solucionar los siguientes subproblemas (1-5):

               1- Leer un número X entre 1 y 10

               2- Leer número N

               3- Leer N números (4- entre 1 y 10) 5-ver si son cooprimos con X

 

Un subalgoritmos o acción es un conjunto de acciones que sirven para resolver un problema.

 

Sintaxis

 

Subalgoritmo <Nombre>

 

Acción/es

 

Fin Subalgoritmo <Nombre>

 

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 al final del algoritmo.

 

Ejemplo

-       Leer un número par e imprimir sus divisores

 

       Algoritmo Ejemplo

              Escribir(‘Ingrese un número par’)

Leer_Par

Para i<-1 hasta N Hacer

       Si (N mod i=0) entonces

              Escribir(i,’Es divisor’)

                             Fin si

              Fin para

       Fin Algoritmo

      

Subalgoritmo Leer_Par

       Leer(N)

       Mientras N mod 2 <> 0 hacer

              Escribir(‘El número debe ser par’)

              Leer(N)

       Fin mientras

Fin Subalgoritmo Leer_Par

 

El algoritmo funciona ejecutando acción por acción, cuando llega al subalgoritmo (o acción) Leer_Par 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. Las variables se comparten entre el algoritmo y los subalgoritmos.

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.

 

 

Veamos el ejemplo planteado al principio

 

El algoritmo, con el uso de subalgoritmos quedaría escrito de la siguiente forma.

 

Algoritmo Ejercicio_1

               Leer_Y_Validar

               X<-Numero

Escribir(‘Ingrese la cantidad de número que quiere ingresar’)

Leer(N)

Para i<-1 hasta N

               Lee_y_Validar

Ver_Cooprimos

Si Son_Coopromos entonces

                              Escribir(‘Los número son cooprimos’)

                              Si no

                              Escribir(‘Los número no son cooprimos’)

                              Fin si

               Fin Para

Fin Algoritmo Ejercicio_1

 

 

Subalgoritmo Leer_y_Validar

               Repetir

                              Escribir(‘Ingrese un número entre 1 y 10’)

                              Leer(Numero)

               Hasta   (Numero<=10)  ^ (Numero>=1)

Fin Subalgoritmo Leer_y_Validar

  

Subalgoritmo Ver_Cooprimos

               Son_Cooprimos<-V

               Si X<Numero entonces

                              Min<-X

               Si no

                              Min<-Numero

               Fin si

               i<-2

Mientras  i<Min ^ Son_Cooprimos Hacer

               Si  Min mod i = 0  Entonces

                              Son_Cooprimos<-F

               Si no

                              i<-i+1

               fin si

Fin Subalgoritmo Ver_Cooprimos


              
Ejercicios Integradores

Ejercicio 1:

Leer un número e indicar si es capicúa

Solución: para saber si un número es capicúa, se puede averiguar de dos formas, 1compara el primer número con el último, si son iguales comparar el segundo con el anteúltimo y así sucesivamente hasta que alguna comparación difiera o se hallan comparado todas las cifras.

2 Otra forma, más sencilla podría ser invertir el número y luego compararlo con el  original.

 

1)

Algoritmo Capicua_1

Escribir (‘Ingrese un número’)

Leer(Numero)

Calcular_Cant_Cifras

Es_Capicua<- V

 

Mientras Cant_Cifras>1  ^  Es_Capicua Hacer

            Hallar_Primera_Cifra

            Hallar_Ultima_Cifra

            Si Primera_Cifra=Ultima_Cifra entonces

                  Cant_Cifras=Cant_Cifras-2

                  Sacar_Primera_Ultima

            Si no

                  Es_Capicua<- F

            Fin si

Fin Mientras

 

Si Es_Capicua entonces

 Escribir(‘Es Capicua’)

Si no

Escribir(‘Es Capicua’)

Fin si

Fin Algoritmo

 

Notar que en mi algoritmo principal se describen sólo los grandes pasos a seguir sin caer en la problemática de resolver cada uno

Ahora sólo quedan diseñar los subalgoritmos, o acciones, para solucionar los subproblemas (grandes pasos) .


Subalgoritmo Calcular_Cant_Cifras

Cant_Cifras<-0

Numero_Aux<-Numero

Mientras Num_Aux>9 Hacer

   Cant_Cifras<-Cant_Cifras+1

   Num_Aux<_Num_Aux div 10

Fin Mientras

Fin Subalgoritmo Calcular_Cant_Cifras

 

Subalgoritmo Hallar_Primera_Cifra

         Base<- 10

         Exp<-Cant_Cifras-1

         Potencia

         Primera_Cifra<-Numero div Resultado

Fin Subalgoritmo Hallar_Primera_Cifra

 

 

Subalgoritmo Hallar_Ultima_Cifra

         Ultima_Cifra<-Nuero mod 10

Fin Subalgoritmo Hallar_Ultima_Cifra

 

Subalgoritmo Sacar_Primera_Ultima

Numero<-Numero div 10

         Exp<-Cant_Cifras-1

         Potencia

         Numero<-Numero Mod Resultado

Fin Subalgoritmo Sacar_Primera_Ultima

 

Subalgoritmo Potencia

Resultado<-1

Para i<-1 hasta Exponente Hacer

   Resultado<-Resultado*Base

Fin para

Fin Subalgoritmo Potencia

 

Nota : El algoritmo sólo funciona con números enteros y positivos.

 

2)

 Algoritmo Capicua_2

Escribir (‘Ingrese un número’)

Leer(Numero)

Invertir_Numero

Si Numero=Numero_Invertido entonces

 Escribir(‘Es Capicua’)

Si no

Escribir(‘Es Capicua’)

Fin si

 

Fin Algoritmo

 

Notar que en este caso se resuelve el problema cambiando de problema, es decir el problema de saber si un número es capicúa lo reduzco al problema de invertir un número

 

Subalgoritmo Invertir_Numero

Numero_Aux<-Numero

Numero_Invertido<- Numero_Aux Mod 10

Mientras Numero_Aux>9 hacer

Numero_Aux<-Numero_Aux div 10

Numero_Invertido<-Numero_Invertido* 10 + Numero_Aux Mod 10

 Fin Mientras

Fin Subalgoritmo Invertir_Numero

 

 

Ejercicio 2:

Desarrollar un algoritmo que resuelva un polinomio de una sola variable

 

Ej. 3x+5x2+9x4

 

Algoritmo Polinomio

Escribir (‘Este algoritmo resuelve un polinomio de una variable evaluada en Valor’)

Escribir(‘Ingrese grado del polinomio’)

Leer(Grado)

Escribir(‘Ingrese Valor de X’)

Leer(X)

Resultado<-0

Para i<-0 hasta Grado hacer

            Base<-X

            Exp<-i

            Potencia

            Escribir(‘Ingrese coeficiente ‘,i)

Leer(Coeficiente)

            Resultado<-Resultado+Coeficiente*Res_Potencia

Fin Para

Escribir(‘El resultado es: ’,Resultado)

Fin Algoritmo