Logotipo de Orbis Sapientia Elearning Services

Servicios de formación. Especialistas en E-learning.

Progreso de Tema:

Pseudocódigo

El pseudocódigo es lo que se llama un lenguaje algorítmico mediante el cual podemos describir, en un formato más cercano a un lenguaje de programación, un algoritmo. De esta forma, es más fácil solucionar un problema.

Podemos verlo como una mezcla entre nuestro lenguaje natural y uno de programación (aunque es independiente de cualquier lenguaje de programación) pues se acerca más, ya que utilizamos entidades clásicas de éstos.

No utiliza una sintaxis estándar aunque hay algunas como CEE o C En Español que dota de una estructura que seguir y buenas prácticas. En este caso hacemos que sea más o menos dependiente de un lenguaje de programación pero aún así sigue siendo trasladable a otros lenguajes. El estilo de un programador que crea un pseudocódigo también puede hacer que varie bastante respecto a otro.

Así pues nos encontramos con que existen una serie de, podríamos decir, palabras clave que se utilizan con bastante frecuencia. Unas son del estilo Si, No, Si No, Si No Si, Fin Si, Entonces, Según, Caso, De Otro Modo, Fin Según, Mientras, Fin Mientras, Hasta Que, etc. Otras son verbos que indican acciones: Hacer, Repetir, Escribir, Leer, etc.

Elementos comunes

Todo algoritmo representado en pseudocódigo, conlleva una estructura que, aún insistiendo en que no hay un estándar, si que nos encontramos con unos elementos comunes que podemos considerar “estándar de facto”. Como hemos mencionado, vamos a utilizar aquí, CEE. Esa estructura de divide en los siguientes elementos:

En la cabecera hemos de indicar el nombre dado al algoritmo, usando esa misma palabra. Ejemplo:

algoritmo MiPrimerProgramaHolaMundo

Aquí vamos a incluir en el orden indicado, los siguientes puntos:

  1. Constantes. Indicamos el área de las constantes con el identificador constantes. El identificador o nombre de cada constante lo pondremos en mayúsculas y seguiremos una sintaxis como esta:
    constantes
    
    NOMBRE_CONSTANTE = Valor
    
    Ejemplo:
    PI = 3.141592
    
    Otro ejemplo con dos constantes en una misma línea:
    IVA = 21, DESCUENTO = 5
    
  2. Tipos de datos. Indicamos el área de los tipos de datos con el identificador: tipos_de_datos. Se trata de representar tipos de datos creados por el programador, como las enumeraciones de C o las clases de Java.
    tipos_de_datos
    
    /* Iniciamos un comentario de varias líneas.
    Primero, indicamos que hay que crear un tipo de dato nuevo de tipo enumerado.
    Segundo, señalamos la necesidad de crear una variable de ese tipo nuevo.
    Finalizamos el comentario de varias líneas */
    enumerado estado {ALTA = 0, BAJA = 1, INACTIVO = -1}
    forista estado /* Indicamos que aquí va una variable del tipo que acabamos de crear. */
    estado = INACTIVO
  3. Variables. Todas las declaraciones de variables se encuentran en la misma área, bajo el identificador: variables. Para declararlas debemos hacerlo de la siguiente forma:
    variables
    
    tipo_de_la_variable nombreVariable = valor_de_la_variable /* El valor debe ser del tipo que indicamos. */
    
    /* Ejemplos: */
    entero notaMedia = 9.5
    cadena materia = "Matemáticas"
    entero notaLengua = 9, notaMatematicas = 10

Observamos que en la sección de declaración, podemos encadenar la declaración de varias constantes separándolas por coma (,). Lo mismo podemos aplicar a las variables.

Aquí indicaremos todos los procesos que se llevarán a cabo en el programa que siempre estarán entre las palabras inicio y fin.

inicio
...
... procesos del programa
...
fin

Los procesos que podemos encontrarnos en el cuerpo pueden ser de muy diferentes tipos. Más abajo los vemos con más detalle.

Procesos o instrucciones comunes en el cuerpo

Se dividen en tres categorías: primitivas, de control y subalgoritmos.

Las primitivas indican procesos o instrucciones básicas como mostrar un dato, solicitarlo y asignarlo a una variable.

Las de control hacen que el flujo normal del programa, cambie en su dirección dependiendo de una o más condiciones.

Las de subalgoritmos se llaman así porque realmente lo que ocurre, es que indican que en lugar donde aparecen, se ejecuta otro programa que soluciona otro problema (algoritmo) y que podría ser independiente.

Instrucciones en el cuerpo: primitivas

Una asignación es almacenar un valor en una variable, bien directamente o bien como resultado de una expresión (como el resultado de un cálculo).

A diferencia de la asignación que hacemos cuando declaramos una constante o una variable, la sintaxis usa en pseudocódigo CEE otro operador: . Sintaxis:

variable  valor

Ejemplos:

area  PI * radio ** 2
saludo  "Bienvenido "
areaRectangulo  base * altura
estaLogado  verdadero
media  totalNotas / numeroNotas

Instrucción en la cual indicamos que una determinada información se ha de enviar a un dispositivo de salida: pantalla, impresora, fichero, etc. La sintaxis CEE es fácil:

escribir(información)

/* Ejemplos: */
escribir("Hola Mundo")
escribir("El resultado es: ", resultado)
escribir(700 * 21 / 100)

Con las instrucciones de entrada guardamos en una o más variables la información que pueda venir de alguna entrada como el teclado, el ratón, ficheros, bases de datos, etc. Esta sería la sintaxis:

leer(variables)

/* Ejemplos */
leer(precio)
escribir("Indique su nombre por favor:")
leer(nombre)
leer("Introduzca su edad", edad)

Instrucciones en el cuerpo: de control

Las instrucciones selectivas son aquellas que nos permiten elegir diferentes direcciones del flujo del programa, de entre aquellos posibles caminos que existan. Por ejemplo: comprobamos la edad de un usuario para saber si es o no mayor de edad. Si es mayor de edad se realizarán unos procesos, si no es así, se realizarán otros.

Otra posibilidad muy común es que simplemente necesitemos que, aparte de que se vayan ejecutando las instrucciones del programa en el flujo normal, algunas se ejecuten, solamente si se dan ciertas condiciones.

Instrucción selectiva simple

Indica que cierto código se ejecutará solamente si se cumplen una o más condiciones:

si(condiciones)
...
... instrucciones que se ejecutan si se cumplen las condiciones
...
fin_si

Instrucción selectiva doble

Si nos encontramos con que aparte de ejecutarse el código normal del programa, tenemos que elegir entre dos conjuntos de instrucciones dependiendo de unas condiciones:

si(condiciones)
...
... instrucciones si se cumplen las condiciones
...
sino
...
... instrucciones si no se cumplen las condiciones
...
fin_si

Instrucción selectiva múltiple SI

Si necesitamos controlar el flujo de nuestro programa para que tenga la posibilidad de ir por diferentes caminos según diferentes condiciones:

si(condiciones)
...
... instrucciones si se cumplen las condiciones
...
sino si(condiciones)
...
... instrucciones si se cumplen estas condiciones
...
sino si(condiciones)
...
... instrucciones si se cumplen estas condiciones
...
sino si...n(condiciones)
...
... instrucciones si se cumplen estas condiciones (lo repetiremos las veces que necesitemos)
...
sino
...
... instrucciones si no se cumplen ninguna de las anteriores condiciones
...
fin_si

Instrucción selectiva múltiple SEGÚN

Permite dotar de varias posibilidades o caminos al flujo normal del programa pero esta vez, en vez de estar basados en condiciones, están basados en valores literales concretos. Según un valor X, haz tal cosa:

segun_sea(variable)
   valor1: código para este valor
   valor2: código para este valor
   valorn: código para este valor
   sino:  código si variable no tiene ninguno de los valores controlados
fin_segun_sea

Donde variable puede ser eso mismo o bien el resultado de una instrucción (como realizar un cálculo).

Anidamiento de instrucciones

Podemos encontrarnos con que necesitamos proveer de diferentes caminos de flujo de un programa pero dentro de uno de estos caminos, necesitamos volver a ofrecer otras posibilidades. Esto se consigue anidando o incluyendo instrucciones selectivas, unas dentro de otras:

si(condición)
   segun_sea(variable)
       valor1:código
       valor2:código
   fin_segun_sea
fin_si

Como puede verse, es suficiente con añadir, con la sintaxis conocida, la instrucción selectiva necesitada.

Las instrucciones repetitivas cambian el flujo normal de ejecución de un programa de tal manera que se repetirán una serie de instrucciones mientras se cumpla una determinada condición o condiciones. Un ejemplo clarificador: imprimir por pantalla del 1 a 1000; ¿realizamos mil instrucciones escribir(número)?

Evidentemente no. Dispondremos unas instrucciones que nos permitan que se ejecute la instrucción de salida escribir mil veces, cambiando en cada una de ellas el número a imprimir.

Estas instrucciones llamadas bucles, pueden ser representadas en pseudocódigo CEE de diferentes formas:

Mientras

Instrucción repetitiva clásica donde se ejecutarán un determinado número de instrucciones mientras se cumplan una o más condiciones. Sintaxis:

mientras(condición)
...
... código que se repetirá
...
fin_mientras

Ojo, se empezarán a repetir las instrucciones o código que están dentro, siempre y cuando se cumpla la condición. Si la condición no se cumple nunca, nunca se entrará dentro.

Hacer… mientras

Esta instrucción repetitiva es igual que la anterior pero se diferencia en un importante detalle: el código que se ejecutará de forma repetitiva, se ejecutará al menos una vez aunque no se cumpla la condición. Esto es debido a que la condición se comprueba al final. Sintaxis:

hacer
...
... código que se ejecuta de forma repetida
...
mientras(condición)

Para

Esta instrucción repetitiva se basa también en ejecutar un determinado código hasta que se cumpla cierta o ciertas condiciones. Sin embargo, en este caso se trata de que esa o esas condiciones hagan que las intrucciones se ejecuten un número determinado de veces. Es decir, se basan más en repetir N veces. Trabajamos con valores numéricos en las condiciones. Ejemplos: imprimir 20 copias de una factura, generar 10 filas de una tabla, generar un listado de los usuarios de una base de datos, etc. Sintaxis:

para variable  valor_inicial hasta valor_final incremento valor_incremento hacer
...
... código que se ejecutará repetidamente
...
fin_para

Utilizamos variable para disponer de algo que nos permita empezar a contar desde un punto. De ahí lo de valor_inicial.

Con hasta especificamos hasta cuanto queremos contar. Cuando variable alcance el valor_final, dejaremos de repetir la ejecución del código indicado.

Cada vez que se haga un ciclo de repeticiones, variable se incrementará (o decrementará) con el valor indicado después de incremento en valor_incremento.

Finalmente, con hacer indicamos que las siguientes instrucciones o código, han de repetirse.

Anidamientos

Como con otras instrucciones de tipo bloque (se caracterizan por una palabra que indica su inicio y otra que marca su final), se pueden anidar o incluir dentro de otras. Como antes, basta con incluirla en el bloque de la forma adecuada.

Podemos anidar cualquier tipo de instrucción de bloque, tanto selectivas como repetitivas, sin ningún problema, siempre y cuando sean parte de la solución del algoritmo.

/* Veamos un ejemplo completo */
algoritmo Imprimir_numeros_pares_hasta_20

constantes
   LIMITE = 20
   DIVISOR_PAR = 2

variables
   entero contador
   entero resto

inicio
   para contador 0 hasta LIMITE incremento 1 hacer
      resto  contador mod DIVISOR_PAR
      si(resto == 0)
         escribir(contador, "ES PAR")
      sino
         escribir("ES IMPAR")
      fin_si
   fin_para
fin

Este tipo de instrucciones cambian también el flujo normal, tanto del programa, como de otras instrucciones que modifican también el flujo normal: selectivas y repetitivas.

Permanecen en algunos lenguajes de programación como un remanente de los principios del desarrollo o programación.

Se insiste mucho en evitar su uso por motivos de legibilidad del código. Hoy día, no son necesarias en absoluto pero como podemos encontrarlas, son estas:

Interrumpir

Esta instrucción termina un bloque de instrucción repetitiva (bucle). Donde se encuentre, inmediatamente para la ejecución del código que se repite y continúa la ejecución normal del flujo del programa en la siguiente línea que está fuera de la instrucción de repetición.

mientras(condición)
...
... código que se repite
interrupir /* El resto del código no se repetirá. Se sale del bloque mientras en este punto */
...
fin_mientras

Continuar

La instrucción continuar también se usa en el bloque de una instrucción repetitiva.

El funcionamiento normal del bloque de una instrucción repetitiva, hace que se ejecuten una o más instrucciones que están dentro del bloque de manera continua hasta que se deja de cumplir una condición. El funcionamiento es más o menos:

  1. ¿Se cumple la condición?
  2. Si se cumple la condición de la instrucción repetitiva, ejecutamos todas las instrucciones del bloque.
  3. Terminadas de ejecutar las instrucciones del bloque repetitivo, se vuelve a comprobar si la condición se sigue cumpliendo.
  4. Si se sigue cumpliendo, vuelve a ocurrir lo mismo hasta que la condición deja de cumplirse.

Si se emplea la instrucción continuar, se interrumpirá el ciclo de repetición; no se llegarán a ejecutar todas las instrucciones del bloque de repetición y se iniciará un nuevo ciclo de repetición desde cero. Se volverá a comprobar si la condición se cumple y se ejecutará todo de nuevo. Es como interrumpir pero no sale del bloque de repetición, solamente sale de una de las repeticiones, la finaliza antes de terminar y comienza otra nueva. Ejemplo:

/* Utilizamos el mismo ejemplo donde se imprimen los pares que hay hasta el número 20 */
algoritmo Imprimir_numeros_pares_hasta_20

constantes
   LIMITE = 20
   DIVISOR_PAR = 2

variables
   entero contador
   entero resto

inicio
   para contador 0 hasta LIMITE incremento 1 hacer
      resto  contador mod DIVISOR_PAR
      si(resto != 0)
         continuar
      fin_si
      escribir(contador, "ES PAR")
   fin_para
fin

Ir_a

Esta instrucción se utiliza para llevar el flujo del programa a una determinada etiqueta (un identificador seguido de dos puntos) que puede estar en cualquier parte del programa representado por pseudocódigo.

Por regla general, las instrucciones de control de salto no se recomiendan, pero esta aún menos. Sintaxis:

algoritmo XXXXXXXXX
...
... /* todo el código que fuera aquí */
...
inicio
...
... /* todo el código que fuera aquí */
...
ir_a nuevoFlujo /* ... interrumpir el flujo del programa aquí y llevarlo a partir de la etiqueta nuevoFlujo */
...
... /* código que se ejecutaría normalmente */
...
nuevoFlujo: /* Ésta es la etiqueta nuevoFlujo */
   ...
   ... /* Código que se ejecutará si se llega a la instrucción ir_a */
   ...
fin

Volver

Es quizá, la única instrucción de control de salto adecuada pues se utiliza en funciones y procedimientos para, indicar que el procedimiento ha finalizado y el programa ha recuperado su flujo normal y además, en el caso de las funciones permitirá devolver un valor, un dato que podrá ser utilizado en el código del flujo normal del programa. Sintaxis:

volver dato /* El dato puede ser literal o como resultado de una operación */

La mayoría de lenguajes de programación que disponen de funciones, hacen uso de una forma u otra de esta instrucción (puede tener otro nombre desde luego), tal como ocurre con Java, PHP, etc.

Resumiendo, son instrucciones a evitar, salvo que alguna (probablemente volver) venga impuesta por la propia sintaxis del lenguaje de programación elegido. Descartar su uso hace que ganemos en: legibilidad, menor cantidad de errores, refactorización y mantenimiento de nuestro código en general.

Instrucciones en el cuerpo: llamadas a subalgoritmos

Las instrucciones de llamadas a subalgoritmos permiten ejecutar un programa especial que puede ser llamado desde otro programa. Llamemos a este tipo de programa, subprograma. Un subprograma resolverá como siempre un problema (será hecho siguiendo un algoritmo al fin y al cabo) pero, en este caso, resolverá un problema pero de tal modo que permitirá a otro programa utilizar esa solución como parte de su propio algoritmo. Para poder llamar a uno de estos subprogramas, disponemos de estas instrucciones de llamadas a subalgoritmos en pseudocódigo.

 

Los procedimientos son como miniprogramas que nos permiten solucionar problemas muy concretos.

Podemos llamarlos y ejecutarlos desde otros programas que necesiten de su trabajo. Cuando los llamamos, el programa principal pasa el control a este subprograma o procedimiento. Una vez que el procedimiento realiza su labor y termina, devuelve el control al programa principal que sigue ejecutando el código según el flujo normal de éste.

A veces, el procedimiento puede que necesite datos que vengan del programa que lo ha llamado. Estos son los argumentos o parámetros del procedimiento.

La estructura del pseudocódigo del procedimiento es muy similar al empleado para realizar el algoritmo de un programa.

Una de las diferencias es que no utilizamos la palabra clave algoritmo, sino procedimiento.

La otra diferencia es que tras el identificador o nombre del procedimiento, aparecen unos paréntesis en cuyo interior, pueden aparecer otros nombres separados por coma (los argumentos o parámetros del procedimiento que puede aceptar).

En el siguiente esquema de sintaxis podemos apreciar esas diferencias. Igualmente nos daremos cuenta que al igual que un algoritmo normal, disponemos en la cabecera de un área para constantes, tipos de datos y variables. Si aparecen, se tratarán de constantes, tipos de datos y variables locales al procedimiento; son del procedimiento y no serán visibles o alcanzables desde fuera (desde el programa o algoritmo que llame al procedimiento). Solamente las podrá usar el propio procedimiento.

/* Cabecera */
procedimiento nombreDelProcedimiento(listaDeParámetros)

/* Declaraciones */
constantes
...
tipos_de_datos
...
variables
...

inicio
...
fin

Hay que tener claro que lo que hacemos más arriba es declarar el algoritmo del procedimiento, cómo funciona. No indicamos cómo llamarlo para que trabaje. Eso lo tenemos que hacer en el programa principal o algoritmo o bien desde otro procedimiento.

algoritmo XXXXXXXXXXX

constantes
...
tipos_de_datos
...
variables
...

inicio
...
/*
En el lugar que necesitemos ejecutar el procedimiento, lo llamamos dentro del cuerpo del algoritmo (entre inicio y fin)
Para llamar al procedimiento que necesitamos, escribimos su nombre con los paréntesis, indicando el o los parámetros que sean necesarios.
*/
nombreProcedimiento(parametro1, parametro2)
...
fin

Las funciones son prácticamente iguales a los algoritmos salvo por un importante detalle: una vez terminado su trabajo, devolverán al programa o algoritmo que la ha llamado, un valor o dato que podrá ser aprovechado por éste.

La sintaxis de las funciones y procedimientos es muy similar:

tipoDatoDevueltoPorLaFuncion funcion nombreDeLaFuncion(listaDeParámetros)

/* Declaraciones */
constantes
...
tipos_de_datos
...
variables
...

inicio
...
volver dato
fin

Podemos observar que en la sintaxis las diferencias son:

  • Uso de la palabra clave funcion en lugar de procedimiento.
  • Indicación del tipo de dato del valor devuelto por la función, antes de la palabra clave funcion.
  • Uso de la instrucción volver más el dato u operación que devuelve un dato, al final del código del cuerpo de la función. Recordemos que volver termina la ejecución de código (de la función en este caso) y en las funciones, además, devuelve un dato.

Para llamar o usar una función en un algoritmo o programa lo haremos de igual forma que un procedimiento pero teniendo en cuenta que la función devuelve un dato.

algoritmo XXXXXXXXXXX

constantes
...
tipos_de_datos
...
variables
cadena valorDevueltoPorFuncion
...

inicio
...
/*
En el lugar que necesitemos ejecutar la función, la llamamos dentro del cuerpo del algoritmo (entre inicio y fin)
Para llamar a la función que necesitamos, escribimos su nombre con los paréntesis, indicando el o los parámetros que sean necesarios.
Debemos recordar que devuelve un dato que deberemos recoger de algún modo: lo más normal, una variable.
*/
valorDevueltoPorFuncion  nombreFuncion(parametro1, parametro2)
...
fin

Para profundizar más sobre pseudocódigo es altamente recomendable utilizar la herramienta y leer el libro que se indican más abajo con el fin de aumentar conocimientos (y retenerlos).

Igualmente, intentar crear nuestros propios algoritmos en pseudocódigo para resolver algunos problemas, nos ayudará a mejorar en nuestro aprendizaje.

PSeInt

La herramienta PSeInt es una sensacional herramienta que además de ayudarnos con el pseudocódigo, nos enseña en el proceso, tanto este cuasi-lenguaje como a dar nuestros primeros pasos con la programación. Por si fuera poco, permite convertir el pseudocódigo a algunos lenguajes de programación como C y otros. Además, es un proyecto de software libre. Esta es la página del programa: http://pseint.sourceforge.net/ .

Recomendamos

Te recomendamos que te leas el libro Diseño de Algoritmos en Pseudocódigo y Ordinogramas que también usa CEE, está creado por Carlos Pes y distribuido bajo licencia Creative Commons .

";}
X