jueves, 21 de marzo de 2013

Bucle for

El bucle for o ciclo for es una estructura de control en la que se puede indicar el número minimo de iteraciones. Está disponible en casi todos los lenguajes de programación imperativos.

Elementos del bucle


   {\color{Sepia}      \mathit{ para }} \;
   {\color{OliveGreen} \mathit{ i }} \;
   {\color{BlueViolet} \mathit{ \gets }} \;
   {\color{OliveGreen} \mathit{ x }} \;
   {\color{Sepia}      \mathit{ hasta }} \;
   {\color{OliveGreen} \mathit{ n}} \;
   {\color{Sepia}      \mathit{ a \; incrementos \; de }} \;
   {\color{OliveGreen} \mathit{ s }} \;
   {\color{Sepia}      \mathit{ hacer }}

   {\color{BlueViolet} \mathit{ instrucciones }}

   {\color{BlueViolet}      \mathit{ fin \; para }}
  • 'Variable de control': prácticamente un mandato impuesto por el uso habitual es utilizar la letra i Iterador como variable de control, o bien sus sucesoras en caso de bucles anidados. El uso de esta letra críptica quizás a primera vista es sin embargo una excelente forma de aportar agilidad de lectura al código por su uso tan extensivo. Como raras veces los bucles anidados superan las tres dimensiones (por una sencilla cuestión de explosión exponencial), las letras i, j y k suelen ser las únicas relacionadas con este uso. En C se define en el primer parámetro de la instrucción junto con la inicialización (opcional).
  • Inicialización de la variable de control: en pseudolenguaje se pide explicitarlo (es la sección := ValorInicial), sin embargo, otros lenguajes más permisivos como C no lo requieren de forma obligatoria. De todos modos, la práctica de utilizar variables de control que no se inicializan en el bucle no es recomendada para la legibilidad del código. En C se define en el primer parámetro del bucle junto con la variable de control.
  • Condición de control: en pseudolenguaje se ve representado por el valor final que puede tomar la variable de control (la sección A ValorFinal). En C es el segundo parámetro y puede ser cualquier condición (ni siquiera es obligación que esté la variable de control, aunque una vez más, esto no se considera una buena práctica).
  • Incremento: en pseudolenguaje se toma por defecto el valor 1, aunque puede explicitarse por medio de la sentencia PASO = ValorPaso cualquier número entero (léase bien entero, o sea que técnicamente podemos decrementar). En C es el último parámetro.
  • Cuerpo: es lo que se hará en cada iteración, pueden ser una o más instrucciones. En pseudolenguaje pesa la restricción de no poder alterar el valor de la variable de control; esto no es requerido en C, pero no se considera una buena práctica.

Usos

Su uso principal se orienta a los vectores, pudiendo modificar, agregar, eliminar o consultar datos que se encuentren según el índice. Por esto último, una condición mínima del vector es que debe ser ordenado, por que si se intenta leer un dato inexistente, esto genera un error de programación.

For en pseudolenguaje

La principal diferencia de un bucle PARA con respecto a los bucles MIENTRAS Y REPETIR, es que puede determinarse al comienzo del bucle cuántas veces se iterará el mismo, lo cual muchas veces puede redundar en una optimización del código por parte de los compiladores. Los condicionales constituyen junto con los bucles los pilares de la programación estructurada, y su uso es una evolución de una sentencia de lenguaje ensamblador que ejecutaba la siguiente línea o no en función del valor de una condición.
El bucle PARA se ha convertido en el bucle más ampliamente utilizado en la programación, ya que con la evolución de los lenguajes la mayoría de las condiciones de fin

MIENTRAS NoFinDeTabla(tabla) HACER
 PróximoRegistro(tabla)
 HacerAlgo(ElementoActual(tabl
FIN MIENTRAS
 
Es lo mismo decir:
PARA i := 0 a CantidadRegistros(tabla) - 1, PASO = 1
 PróximoRegistro(tabla)
 HacerAlgo(ElementoActual(tabla))
FIN PARA
 
Otro uso común es utilizar los bucles PARA para recorrer vectores de dos o más dimensiones, en cuyo caso se anidan estas iteraciones.
PSEUDOLENGUAJE
Vector a[3][4][2]. // Estamos indicando un vector de 3 dimensiones y 24 elementos en total.
PARA i:= 0 A 2 HACER
  PARA j:= 0 A 3 HACER
    PARA k:= 0 A 1 HACER
      HacerAlgo(a[i][j][k])
    FIN PARA
  FIN PARA
FIN PARA

Ejemplo de PARA en pseudocódigo

PARA VariableControl := ValorInicial A ValorFinal, PASO = Incremento 
  Cuerpo
 FIN PARA
donde VariableControl, ValorInicial, ValorFinal y Paso son enteros. La(s) instrucción(es) del cuerpo se ejecutará(n) (ValorFinal - ValorInicial + 1) veces, o sea que va desde ValorInicial a ValorFinal inclusive.

Ejemplo en C++

int main()
{
  int vector[10], i;
  for(i = 0; i < 10; i++)
  {
   vector[i] = i;
  }
}
En la definición del for, tenemos que la variable de control i se inicializa en un valor 0, luego se entrega la condición de control que debe ser falsa durante su ejecución, para completar el ciclo; y por último, tenemos el incrementador en una unidad.
Si por ejemplo en la condición colocamos i < 11, entonces el ciclo for se ejecutará desde [0...10], lo cual, al intentar acceder al elemento vector[10], esto generará error, ya que el vector (por definición) va desde [0..(n-1)].

Ejemplo anterior escrito en Léxico

tarea
{
los objetos vector[10], i son cantidades
variando i desde 0 hasta 9 haga
         copie i en vector[i]
}

Bucle Por Cada (For Each)

Este bucle es una evolución del concepto del bucle Para en algunos lenguajes. Se utiliza para recorrer estructuras repetitivas de datos de forma más simple y ágil. El bucle For Each puede describirse genéricamente (en pseudolenguaje) de la siguiente manera:
POR CADA elemento DE tipo EN conjunto HACER
  Cuerpo
FIN FOR EACH
  • Elemento: es el nombre de la variable u objeto que toma el elemento iterado en el cuerpo del bucle.
  • Tipo de Dato: es el tipo de variable o la clase a la que pertenece el objeto que se quiere iterar.
  • Conjunto: es la estructura de datos que se quiere iterar. El uso más típico es con vectores o -en programación orientada a objetos- clases del tipo Colección.
  • Cuerpo: es lo que se hará en cada iteración, pueden ser una o más instrucciones. Si bien no se impone una obligación al respecto, lo más común es que en este Cuerpo exista alguna operación sobre el elemento iterado.

Necesidad de una nueva estructura de control

Esta estructura surge como una innovación en los lenguajes para permitir un código más ágil y legible en una situación que es una de las principales causas del uso del bucle PARA: aplicar la misma operación sobre todos los elementos de un vector, y no necesitar conocer la posición del elemento en el vector. Esta estructura con el bucle PARA se resuelve de la siguiente manera:
Con el bucle POR CADA esto se reduce a:
POR CADA x DE tipo EN Vector HACER
 x = AlgunaOperación(x)
FIN PARA
Las ventajas de utilizar la estructura POR CADA son las siguientes:
  1. No es necesario llamar a una función que obtenga el tamaño del vector
  2. No es necesario utilizar la incómoda notación de subíndices para referirnos al valor en cuestión, sobre todo teniendo en cuenta que si utilizamos esta estructura es porque no necesitamos el valor del índice.
  3. Nos permite hacer un chequeo en tiempo de compilación sobre el tipo de dato que representa el elemento.
El bucle POR CADAo no es un sustituto del PARA, es una mejora para el muy frecuente caso anteriormente mencionado. La diferencia esencial entre el bucle PARA y el POR CADA es que en el primero guía su iteración por una variable que se incrementa hasta cierto punto de corte; en cambio en el segundo lo que guía la iteración es el recorrido de todos los elementos de un vector. Ciertamente podemos transformar cualquier POR CADA en un PARA, pero transformar un bucle PARA en un bucle POR CADA requeriría inicializar y controlar manualmente las variables de control, con lo cual se perdería nuevamente legibilidad en el código. Por tanto, cuando en un lenguaje se nos da la posibilidad de utilizar ambas estructuras, la elección del POR CADA debe hacerse en aquellos casos para los que fue pensado: aplicar la misma operación a todos los elementos de un vector sin importar el orden en que se hagan; si bien no es necesario que la variable elemento sea utilizada en el cuerpo del bucle, su ausencia denota con seguridad una mala elección de estructura de control.

miércoles, 20 de marzo de 2013

Bucle (programación)

Un bucle o ciclo, en programación, es una sentencia que se realiza repetidas veces a un trozo aislado de código, hasta que la condición asignada a dicho bucle deje de cumplirse.
Generalmente,un bucle es utilizado para hacer una acción repetida sin tener que escribir varias veces el mismo código, lo que ahorra tiempo, deja el código más claro y facilita su modificación en el futuro.
El bucle y los condicionales representan la base de la programación estructurada. Es una evolución del código ensamblador, donde la única posibilidad de iterar un código era establecer una sentencia jump (que en los lenguajes de programación fue sustituida por el "ir a" o GOTO).
Los tres bucles más utilizados en programación son el bucle while, el bucle for y el bucle repetir.
Ejemplo en código C de sentencias repetidas:
    int var=0;


      //código que puede ser sustituido por un bucle
      var = var + 2; //var igual a 2 (puede ser sustituido por var+=2)
      var = var + 2; //var igual a 4
      var = var + 2; //var igual a 6
      var = var + 2; //var igual a 8
      var = var + 2; //var igual a 10
      // fin de código  que puede ser sustituido por un bucle

    printf("el resultado es %i", var );

Ejemplo con un bucle:
          int var=0;

          //Código para el bucle
          int i;
          
          // este es el Bucle for
          for(i=0;i<10;i+=2)
          { 
             var += 2;          
          }

   
          printf("el resultado es %i", var);


Algunos lenguajes de programación tienen sentencias que permiten "escapar" de los bucles sin llegar a la condición de fin, como el romper o el devolver.
Ejemplo escapando de un bucle en Visual Basic 1:
     Dim h&, var&
     var = 0

     'Codigo del Bucle
     do
        var = var + 2

        if var = 10 then    'Codigo para salir del bucle
           goto escape
        end if
     loop
 
  escape:
     print "El resultado es " & var

Ejemplo escapando de un bucle en Visual Basic 2:
     Dim h&, var&
     var = 0

     'Codigo del Bucle
     do
        var = var + 2

        if var = 10 then    'Codigo para salir del bucle
           exit do
        end if
     loop
 
     print "El resultado es " & var

Ejemplo escapando de un bucle en Delphi:
var
  iConta: Byte;

for iConta := 1 to 15 do 
  if iConta = 10 then   //Se sale al llegar el contador a 10
    break;

domingo, 17 de marzo de 2013

Estructuras de control

En lenguajes de programación, las estructuras de control permiten modificar el flujo de ejecución de las instrucciones de un programa.
Con las estructuras de control se puede:
  • de acuerdo a una condición, ejecutar un grupo u otro de sentencias (If-Then-Else y Select-Case)
  • Ejecutar un grupo de sentencias mientras exista una condición (Do-While)
  • Ejecutar un grupo de sentencias hasta que exista una condición (Do-Until)
  • Ejecutar un grupo de sentencias un número determinado de veces (For-Next)
  • Etc
Todas las estructuras de control tienen un único punto de entrada y un único punto de salida. Las estructuras de control se puede clasificar en : secuenciales, iterativas y de control avanzadas. Esto es una de las cosas que permite que la programación se rija por los principios de la programación estructurada.
Los lenguajes de programación modernos tienen estructuras de control similares. Básicamente lo que varía entre las estructuras de control de los diferentes lenguajes es su sintaxis, cada lenguaje tiene una sintaxis propia para expresar la estructura.
Otros lenguajes ofrecen estructuras diferentes, como por ejemplo los comandos guardados.

Tipos de estructura de control

Algunas estructuras de control en el lenguaje Java

Antecedentes

El término "estructuras de control", viene del campo de la ciencia computacional. Cuando se presentan implementaciones de Java para las estructuras de control, nos referimos a ellas con la terminología de la Especificación del lenguaje Java, que se refiera a ella como instrucciones.

Ejecución secuencial

Pero por lo general las instrucciones se ejecutan una después de la otra, en el orden en que están escritas, es decir, en secuencia. Este proceso se conoce como ejecución secuencial.

Transferencia de control

En Java, como en otros lenguajes de programación por excelencia como C y/o C++, el programador puede especificar que las siguientes instrucciones a ejecutarse tal vez no sea la siguiente en secuencia. Esto se conoce como transferencia de control. Hay que tener en cuenta que la instrucción goto es una palabra reservada pero no se utiliza ni se recomienda. Un programa bien estructurado no necesita de esta instrucción.

De selección

Las estructuras de control de selección, ejecutan un bloque de instrucciones u otro, o saltan a un subprograma o subrutina según se cumpla o no una condición.

Estructura de control

Las estructuras de control, denominadas también sentencias de control, permiten tomar decisiones y realizar un proceso repetidas veces. Se trata de estructuras muy importantes, ya que son las encargadas de controlar el flujo de un programa, según los requerimientos del mismo.

Selección if simple

Se trata de una estructura de control que permite redirigir un curso de acción según la evaluación de una condición simple, sea falsa o verdadera.
Si la condición es verdadera, se ejecuta el bloque de sentencias 1, de lo contrario, se ejecuta el bloque de sentencias 2.
   IF (Condición) THEN
      (Bloque de sentencias 1)
   ELSE
      (Bloque de sentencias 2)
   END IF
Se pueden plantear múltiples concisiones simultáneamente, si se cumple la (Condición 1), se ejecuta (Bloque de sentencias 1) en caso contrario se comprueba la (Condición 2), si es cierta se ejecuta (Bloque de sentencias 2), y así sucesivamente hasta n condiciones, si ninguna de ellas es cumple se ejecuta (Bloque de sentencias else).
   IF (Condición 1) THEN
      (Bloque de sentencias 1)
   ELSEIF (Condición 2) THEN
      (Bloque de sentencias 2)
 
   .....
 
   ELSEIF (Condición n) THEN
      (Bloque de sentencias n)
   ELSE
      (Bloque de sentencias ELSE)
   END IF

Select-Case

Esta sentencia permite ejecutar una de entre varias acciones en función del valor de una expresión. Es una alternativa a if then else cuando se compara la misma expresión con diferentes valores.
  • Se evalúa la expresión, dando como resultado un número.
  • Luego, se recorren los "Case" dentro de la estructura buscando que el número coincida con uno de los valores.
  • Es necesario que coincidan todos sus valores.
  • Cuando se encuentra la primera coincidencia, se ejecuta el bloque de sentencias correspondiente y se sale de la estructura Select-Case.
  • Si no se encuentra ninguna coincidencia con ningún valor, se ejecuta el bloque de sentencias de la sección "Case Else".
   SELECT (Expresión)
      CASE Valor1
         (Bloque de sentencias 1)
      CASE Valor2
         (Bloque de sentencias 2)
      CASE Valor n
         (Bloque de sentencias n)
      CASE ELSE
         (Bloque de sentencias "Else")
   END SELECT

Estructuras de control iterativas

Las estructuras de control iterativas o de repetición, inician o repiten un bloque de instrucciones si se cumple una condición o mientras se cumple una condición.

Do-While

Mientras la condición sea verdadera, se ejecutarán las sentencias del bloque.
   DO WHILE (Condición)
      (Bloque de sentencias)
   LOOP
que también puede expresarse:
   WHILE (Condición)
      (Bloque de sentencias)
   WEND

Do-Until

Se ejecuta el bloque de sentencias, hasta que la condición sea verdadera
   DO
      (Bloque de sentencias)
   LOOP UNTIL (Condición)

For-Next

La sentencia For da lugar a un lazo o bucle, y permite ejecutar �un conjunto de sentencias cierto número de veces.
  • Primero, se evalúan las expresiones 1 y 2, dando como resultado dos números.
  • La variable del bucle recorrerá los valores desde el número dado por la expresión 1 hasta el número dado por la expresión 2.
  • El bloque de sentencias se ejecutará en cada uno de los valores que tome la variable del bucle.
   FOR (Variable) = (Expresión1) TO (Expresión2) STEP (Salto)
      (Bloque de sentencias)
   NEXT

Estructuras anidadas

Las estructuras de control básicas pueden anidarse, es decir pueden ponerse una dentro de otra.

Estructura For-Next dentro de una estructura If-Then-Else

   IF A > B THEN
      FOR X = 1 TO 5
         (Bloque de sentencias 1)
      NEXT
   ELSE
      (Bloque de instrucciones 2)
   END IF

Estructura If-Then-Else dentro de estructura For-Next

   FOR x = 10 TO 20 STEP 2
      IF A == C THEN
       (Bloque de instrucciones)
      ELSE
       (Bloque de instrucciones)
      END IF
   NEXT

Estructura For-Next que está dentro de estructura Do-While

 DO WHILE A > 0
    FOR X = 1 TO 10
       (Bloque de instrucciones)
    NEXT
    A = A - 1
 LOOP

viernes, 15 de marzo de 2013

Pseudocódigo

En ciencias de la computación, y análisis numérico el pseudocódigo (o falso lenguaje) es una descripción informal de alto nivel de un algoritmo informático de programación, compacto e informal, que utiliza las convenciones estructurales de un lenguaje de programación verdadero , pero que está diseñado para la lectura humana en lugar de la lectura mediante máquina, y con independencia de cualquier otro lenguaje de programación. Normalmente, el pseudocódigo omite detalles que no son esenciales para la comprensión humana del algoritmo, tales como declaraciones de variables, código específico del sistema y algunas subrutinas. El lenguaje de programación se complementa, donde sea conveniente, con descripciones detalladas en lenguaje natural, o con notación matemática compacta. Se utiliza pseudocódigo pues este es más fácil de entender para las personas que el código de lenguaje de programación convencional, ya que es una descripción eficiente y con un entorno independiente de los principios fundamentales de un algoritmo. Se utiliza comúnmente en los libros de texto y publicaciones científicas que se documentan varios algoritmos, y también en la planificación del desarrollo de programas informáticos, para esbozar la estructura del programa antes de realizar la efectiva codificación. No existe una sintaxis estándar para el pseudocódigo, aunque los cincos IDE's que manejan pseudocódigo tengan su sintaxis propia. Aunque sea parecido, el pseudocódigo no debe confundirse con los programas esqueleto que incluyen código ficticio, que pueden ser compilados sin errores. Los diagramas de flujo y UML pueden ser considerados como una alternativa gráfica al pseudocódigo, aunque sean más amplios en papel.

Aplicación

Muchas veces, en los libros de texto y publicaciones científicas relacionadas con la informática y la computación numérica, se utilizan pseudocódigo en la descripción de algoritmos, de manera que todos los programadores puedan entenderlo, aunque no todos conozcan el mismo lenguaje de programación. Geneneralmente, en los libros de texto, hay una explicación que acompaña la introducción que explica las convenciones particulares en uso. El nivel de detalle del pseudocódigo puede, en algunos casos, acercarse a la de formalizar los idiomas de propósito general. Un programador que tiene que aplicar un algoritmo específico, sobre todo uno desfamiliarizado, generalmente comienza con una descripción en pseudocódigo, y luego "traduce" esa descripción en el lenguaje de programación meta y lo modifica para que interactúe correctamente con el resto del programa. Los programadores también pueden iniciar un proyecto describiendo la forma del código en pseudocódigo en el papel antes de escribirlo en su lenguaje de programación, como ocurre en la estructuración de un enfoque de Top-down y Bottom-up arriba hacia abajo.

Sintaxis

En la actualidad y por lo general, el pseudocódigo, como su nombre lo indica, no obedece a las reglas de sintaxis de ningún idioma en particular ni es de forma estándar sistemática, a pesar de que cualquier escritor en particular vaya a pedir prestado las estructuras de control general, la sintaxis y el estilo, por ejemplo, de algún lenguaje de programación convencional. Pero en caso de que se quiera ejecutar, se debe llevar a forma tipo, para que no genere mensajes de error. Las fuentes populares incluyen la sintaxis de Pascal, BASIC, C, C++, Java, Lisp, y ALGOL. Por lo general, se omiten las declaraciones de variables. A veces, las llamadas a funciones, los bloques de código y el código contenido dentro de un loop se remplazan por una sentencia de una línea en lenguaje natural.
Dependiendo del escritor, el pseudocódigo puede variar mucho en su estilo, yendo desde en un extremo, una imitación casi exacta de un lenguaje de programación real, hasta al acercarse a una descripción en prosa de formato de pseudocódigo en el otro extremo.
Este es un ejemplo de pseudocódigo (para el juego matemático bizz buzz):

Pseudocódigo estilo Fortran:
programa bizzbuzz
hacer i = 1 hasta 100 
    establecer print_number a verdadero
    si i es divisible por 3
        escribir "Bizz"
        establecer print_number a falso
    si i es divisible por 5
        escribir "Buzz" 
        establecer print_number a falso
    si print_number, escribir i
    escribir una nueva línea
fin del hacer







Pseudocódigo estilo Pascal:
procedimiento bizzbuzz
para i := 1 hasta 100 hacer
    establecer print_number a verdadero;
    Si i es divisible por 3 entonces
        escribir "Bizz";
        establecer print_number a falso;
    Si i es divisible por 5 entonces
        escribir "Buzz";
        establecer print_number a falso;
    Si print_number, escribir i;
    escribir una nueva lína;
fin


Pseudocódigo estilo C:
subproceso funcion bizzbuzz
para (i <- 1; i<=100; i++) {
    establecer print_number a verdadero;
    Si i es divisible por 3
        escribir "Bizz";
        establecer print_number a falso;
    Si i es divisible por 5
        escribir "Buzz";
        establecer print_number a falso;
    Si print_number, escribir i;
    escribir una nueva línea;
}

 

 

Características y partes

Las principales características de este lenguaje son:
  1. Se puede ejecutar en un ordenador (con un IDE como por ejemplo SLE, LPP, PilatoX, Maruga Script, Seudocodigo o PSeInt.)
  2. Es una forma de representación sencilla de utilizar y de manipular.
  3. Facilita el paso del programa al lenguaje de programación.
  4. Es independiente del lenguaje de programación que se vaya a utilizar.
  5. Es un método que facilita la programación y solución al algoritmo del programa.
Todo documento en pseudocódigo debe permitir la descripción de:
  1. Instrucciones primitivas.
  2. Instrucciones de proceso....
  3. Instrucciones de control.
  4. Instrucciones compuestas.
  5. Instrucciones de descripción.
Estructura a seguir en su realización:
  1. Cabecera.
    1. Programa.
    2. Módulo.
    3. Tipos de datos.
    4. Constantes.
    5. Variables.
  2. Cuerpo.
    1. Inicio.
    2. Instrucciones.
    3. Fin.

Definición de datos del pseudocódigo

La definición de datos se da por supuesta, sobre todo en las variables sencillas, si se emplea formaciones: pilas, colas, vectores o registros, se pueden definir en la cabecera del algoritmo, y naturalmente cuando empleemos el pseudocódigo para definir estructuras de datos, esta parte la desarrollaremos adecuadamente.

Funciones y operaciones

Cada autor usa su propio pseudocódigo con sus respectivas convenciones. Por ejemplo, la instrucción "reemplace el valor de la variable x por el valor de la variable y" puede ser representado como:
  • asigne a x\, el valor de y\,

   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ y; }}

   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ := }} \;
   { \color{OliveGreen} \mathit{ y; }}

   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ = }} \;
   { \color{OliveGreen} \mathit{ y; }}
Las operaciones aritméticas se representan de la forma usual en matemáticas.

   { \color{Gray}  \mathit{ \{ Esto \; es \; un \; comentario \; normalmente \; matem \acute{a} tico \} }}

   { \color{OliveGreen} \mathit{ volumen }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{Plum}  \mathit{ \pi }}
   { \color{OliveGreen} \mathit{ r }} {}^2
   { \color{OliveGreen} \mathit{ h }}

   { \color{Gray}  \mathit{ // y \; este \; es \; otro \; comentario \; normalmente \; de \; texto // }}

   { \color{OliveGreen} \mathit{ hipotenusa }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   \sqrt{
      { \color{OliveGreen} \mathit{ a }} {}^2 \;
      { \color{BlueViolet}  \mathit{ + }} \;
      { \color{OliveGreen} \mathit{ b }} {}^2 \;
   }

   { \color{OliveGreen} \mathit{ resultado }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{Tan}   \mathit{ sin }}
   (
      { \color{OliveGreen} \mathit{ a }}
   )

Estructuras de control

En la redacción del pseudocódigo se utiliza tres tipos de estructuras de control: las secuenciales, las selectivas y las iterativas.

Estructuras secuenciales

Las instrucciones se siguen en una secuencia fija que normalmente viene dada por el número de renglón. Es decir que las instrucciones se ejecutan de arriba hacia abajo. Las instrucciones se ejecutan dependiendo de la condición dada dentro del algoritmo.

   { \color{BlueViolet}  \mathit{ instrucci \acute{o} n_1; }}

   { \color{BlueViolet}  \mathit{ instrucci \acute{o} n_2; }}

   { \color{BlueViolet}  \mathit{ instrucci \acute{o} n_3; }}

   \cdots

   { \color{BlueViolet}  \mathit{ instrucci \acute{o} n_n; }}

Estructuras selectivas

Las instrucciones selectivas representan instrucciones que pueden o no ejecutarse, según el cumplimiento de una condición.
Diagrama de flujo que muestra el funcionamiento de la instrucción condicional.


   { \color{Sepia} \mathit{ Si }} \;
   { \color{OliveGreen} \mathit{ condici \acute{o} n }} \;
   { \color{Sepia} \mathit{ Entonces }}

   { \color{BlueViolet}  \mathit{ instrucciones; }}

   { \color{Sepia} \mathit{ Fin \; Si }}
La condición es una expresión booleana. Instrucciones es ejecutada sólo si la condición es verdadera.

Selectiva doble (alternativa)

La instrucción alternativa realiza una instrucción de dos posibles, según el cumplimiento de una condición.
Diagrama de flujo que muestra el funcionamiento de la instrucción condicional.


   { \color{Sepia} \mathit{ Si }} \;
   { \color{OliveGreen} \mathit{ condici \acute{o} n }} \;
   { \color{Sepia} \mathit{ Entonces }}

   { \color{BlueViolet}  \mathit{ instrucciones_1; }}

   { \color{Sepia} \mathit{ Si \; no \; Entonces }}

   { \color{BlueViolet}  \mathit{ instrucciones_2; }}

   { \color{Sepia} \mathit{ Fin \; Si }}
La condición es una variable booleana o una función reducible a booleana (lógica, Verdadero/Falso). Si esta condición es cierta se ejecuta Instrucciones1, si no es así, entonces se ejecuta Instrucciones2.

Selectiva múltiple

También es común el uso de una selección múltiple que equivaldría a anidar varias funciones de selección.

   { \color{Sepia} \mathit{ Si }} \;
   { \color{OliveGreen} \mathit{ condici \acute{o} n_1 }} \;
   { \color{Sepia} \mathit{ Entonces }}

   { \color{BlueViolet}  \mathit{ instrucciones_1; }}

   { \color{Sepia} \mathit{ Si \; no \; si }} \;
   { \color{OliveGreen} \mathit{ condici \acute{o} n_2 }} \;
   { \color{Sepia} \mathit{ Entonces }}

   { \color{BlueViolet}  \mathit{ instrucciones_2; }}

   { \color{Sepia} \mathit{ Si \; no \; si }} \;
   { \color{OliveGreen} \mathit{ condici \acute{o} n_3 }} \;
   { \color{Sepia} \mathit{ Entonces }}

   { \color{BlueViolet}  \mathit{ instrucciones_3; }}

   \cdots

   { \color{Sepia} \mathit{ Si \; no \; Entonces }}

   { \color{BlueViolet}  \mathit{ instrucciones_n; }}

   { \color{Sepia} \mathit{ Fin \; Si }}
En este caso hay una serie de condiciones que tienen que ser mutuamente excluyentes, si una de ellas se cumple las demás tienen que ser falsas necesariamente, hay un caso si no que será cierto cuando las demás condiciones sean falsas.
En esta estructura si Condición1 es cierta, entonces se ejecuta sólo Instrucciones1. En general, si Condicióni es verdadera, entonces sólo se ejecuta Instruccionesi

Selectiva múltiple-Casos

Una construcción similar a la anterior (equivalente en algunos casos) es la que se muestra a continuación.

   { \color{Sepia} \mathit{ Seg\acute{u}n }} \;
   { \color{OliveGreen} \mathit{ variable }}
   { \color{Sepia} \mathit{ Hacer }}

  { \color{Sepia} \mathit{ caso }} \; 
  { \color{OliveGreen} \mathit{ valor_1; }}

  { \color{BlueViolet}  \mathit{ instrucciones_1; }}

  { \color{Sepia} \mathit{ caso }} \; 
  { \color{OliveGreen} \mathit{ valor_2; }}

  { \color{BlueViolet}  \mathit{ instrucciones_2; }}

  { \color{Sepia} \mathit{ caso }} \; 
  { \color{OliveGreen} \mathit{ valor_3; }}

  { \color{BlueViolet}  \mathit{ instrucciones_3; }}

  \cdots

  { \color{Sepia} \mathit{ De \; Otro \; Modo}}

  { \color{BlueViolet}  \mathit{ instrucciones_n; }}

  { \color{Sepia} \mathit{ Fin \; Seg\acute{u}n }}
En este caso hay un Indicador es una variable o una función cuyo valor es comparado en cada caso con los valores "Valori", si en algún caso coinciden ambos valores, entonces se ejecutarán las Instruccionesi correspondientes. La sección en otro caso es análoga a la sección si no del ejemplo anterior.

Estructuras iterativas

Las instrucciones iterativas representan la ejecución de instrucciones en más de una vez.

Bucle mientras

El bucle se repite mientras la condición sea cierta, si al llegar por primera vez al bucle mientras la condición es falsa, el cuerpo del bucle no se ejecuta ninguna vez.
Diagrama de flujo que muestra el funcionamiento de la instrucción mientras


   { \color{Sepia} \mathit{ Mientras }} \;
   { \color{OliveGreen} \mathit{ condici \acute{o} n }} \;
   { \color{Sepia} \mathit{ Hacer }}

   { \color{BlueViolet}  \mathit{ instrucciones; }}

   { \color{Sepia} \mathit{ Fin \; Mientras }}

Bucle repetir

Existen otras variantes que se derivan a partir de la anterior. La estructura de control repetir se utiliza cuando es necesario que el cuerpo del bucle se ejecuten al menos una vez y hasta que se cumpla la condición:

   { \color{Sepia} \mathit{ Repetir }}

   { \color{BlueViolet}  \mathit{ instrucciones; }}

   { \color{Sepia} \mathit{ Hasta \; Que }} \;
   { \color{OliveGreen} \mathit{ condici \acute{o} n }}
La estructura anterior equivaldría a escribir:

   { \color{BlueViolet} \mathit{ instrucciones; }}

   { \color{Sepia} \mathit{ Mientras }} \;
   { \color{BlueViolet}  \mathit{ \neg }}
   (
      { \color{OliveGreen} \mathit{ condici \acute{o} n }}
   ) \;
   { \color{Sepia} \mathit{ Hacer }}

   { \color{BlueViolet}  \mathit{ instrucciones; }}

   { \color{Sepia} \mathit{ Fin \; Mientras }}

Bucle hacer

El Bucle hacer se utiliza para repetir un bloque de código mientras se cumpla cierta condición.


   {\color{Sepia}      \mathit{ Hacer }} \;

   {\color{BlueViolet} \mathit{ instrucciones; }} \;

   {\color{Sepia} \mathit{ Mientras}} \;
   {\color{OliveGreen} \mathit{ condici \acute{o} n }}

Bucle para

Una estructura de control muy común es el ciclo para, la cual se usa cuando se desea iterar un número conocido de veces, empleando como índice una variable que se incrementa (o decrementa): Plantilla:Definiciones
la cual se define como:

   { \color{OliveGreen} \mathit{ i}} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ x}}

   { \color{Sepia} \mathit{ Mientras }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ \leq }} \;
   { \color{OliveGreen} \mathit{ n }} \;
   { \color{Sepia} \mathit{ Hacer }}

   { \color{BlueViolet}  \mathit{ instrucciones; }}

   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ + }} \;
   { \color{OliveGreen} \mathit{ z; }}

   { \color{Sepia} \mathit{ Fin \; Mientras }}

Bucle para cada

Por último, también es común usar la estructura de control para cada. Esta sentencia se usa cuando se tiene una lista o un conjunto L y se quiere iterar por cada uno de sus elementos:

   { \color{Sepia} \mathit{ Para \; Cada }} \;
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \in }} \;
   { \color{OliveGreen} \mathit{ L }} \;
   { \color{Sepia} \mathit{ Hacer }}

   { \color{BlueViolet}  \mathit{ instrucciones; }}

   { \color{Sepia} \mathit{ Fin \; Para \; Cada }}
Si asumimos que los elementos de L son L_0,L_1,\dots,L_n, entonces esta sentencia equivaldría a:

   { \color{Sepia} \mathit{ Para }} \;
   { \color{OliveGreen} \mathit{ i}} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ 0}} \;
   { \color{Sepia} \mathit{ Hasta }} \;
   { \color{OliveGreen} \mathit{ n}} \;
   { \color{Sepia} \mathit{ Con \; Paso }} \;
   { \color{OliveGreen} \mathit{ 1}} \;
   { \color{Sepia} \mathit{ Hacer }}

   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \gets}} \;
   { \color{OliveGreen} \mathit{ L_i }}

   { \color{BlueViolet}  \mathit{ instrucciones; }}

   { \color{Sepia} \mathit{ Fin \; Para }}
Que es lo mismo que:

   { \color{Sepia} \mathit{ Para }} \;
   { \color{OliveGreen} \mathit{ i}} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ 0}} \;
   { \color{Sepia} \mathit{ Hasta }} \;
   { \color{OliveGreen} \mathit{ n}} \;
   { \color{Sepia} \mathit{ Hacer }}

   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \gets}} \;
   { \color{OliveGreen} \mathit{ L_i }}

   { \color{BlueViolet}  \mathit{ instrucciones; }}

   { \color{Sepia} \mathit{ Fin \; Para }}

Sin embargo, en la práctica existen mejores formas de implementar esta instrucción dependiendo del problema. Es importante recalcar que el pseudocódigo no es un lenguaje estandarizado. Eso significa que diferentes autores podrían dar otras estructuras de control o bien usar estas mismas estructuras, pero con una notación diferente. Sin embargo, las funciones matemáticas y lógicas toman el significado usual que tienen en matemática y lógica, con las mismas expresiones.

El anidamiento

Cualquier instrucción puede ser sustituida por una estructura de control. El siguiente ejemplo muestra el pseudocódigo del ordenamiento de burbuja, que tiene varias estructuras anidadas. Este algoritmo ordena de menor a mayor los elementos de una lista L.

\begin{array}{l}
{ \color{Sepia} Procedimiento } \;
{ \color{BlueViolet} Ordenar } \; (
{ \color{OliveGreen} L} \; ) \\
 \left \updownarrow
 \begin{array}{l}
 { \color{Gray} // Comentario: \; L=(L_1,L_2,\dots,L_n) \; es \; una \; lista \; con \; n \; elementos // } \\
 { \color{OliveGreen} k } \;
 { \color{BlueViolet} \gets } \;
 { \color{OliveGreen} 0;} \\
 { \color{Sepia} Repetir } \\
 \left \updownarrow
 \begin{array}{l}
 { \color{OliveGreen} intercambio } \;
 { \color{BlueViolet} \gets } \;
 { \color{OliveGreen} Falso;} \\
 { \color{OliveGreen} k } \;
 { \color{BlueViolet} \gets } \;
 { \color{OliveGreen} k + 1;} \\
 { \color{Sepia} Para } \;
 { \color{OliveGreen} i} \;
 { \color{BlueViolet} \gets } \;
 { \color{OliveGreen} 1} \;
 { \color{Sepia} Hasta } \;
 { \color{OliveGreen} n - k} \;
 { \color{Sepia} Con Paso } \;
 { \color{OliveGreen} 1} \;
 { \color{Sepia} Hacer } \\
 \left \updownarrow
 \begin{array}{l}
 { \color{Sepia} Si } \;
 { \color{OliveGreen} L_i } \;
 { \color{BlueViolet} > } \;
 { \color{OliveGreen} L_{i+1} } \;
 { \color{Sepia} Entonces } \; \\
 \left \updownarrow
 \begin{array}{l}
 { \color{BlueViolet} intercambiar } \; (
 { \color{OliveGreen} L_i , L_{i+1} } \; ) \\
 { \color{OliveGreen} intercambio } \;
 { \color{BlueViolet} \gets } \;
 { \color{OliveGreen} Verdadero;} 
 \end{array}
 \right . \\
 { \color{Sepia} FinSi } \; \\
 \end{array}
 \right . \\
 { \color{Sepia} FinPara } \\
 \end{array}
 \right . \\
{ \color{Sepia} Hasta \; Que } \;
 { \color{OliveGreen} intercambio } \;
 { \color{BlueViolet} = } \;
 { \color{OliveGreen} Falso;}
\end{array}
\right . \\
{ \color{Sepia} FinProcedimiento } \; \\
\end{array}
En general, las estructuras anidadas se muestran indentadas, para hacer más sencilla su identificación a simple vista. En el ejemplo, además de la indentación, se ha conectado con flechas los pares de delimitadores de cada nivel de anidamiento.

Desarrollo de algoritmos

Con este pseudocódigo se puede desarrollar cualquier algoritmo que:
  • Tenga un único punto de inicio.
  • Tenga un número finito de posibles puntos de término.
  • Haya un número finito de caminos, entre el punto de inicio y los posibles puntos de término.

Funciones y procedimientos

Muchas personas prefieren distinguir entre funciones y procedimientos. Una función, al igual que una función matemática, recibe uno o varios valores de entrada y regresa una salida mientras que un procedimiento recibe una entrada y no genera ninguna salida aunque en algún caso podría devolver resultados a través de sus parámetros de entrada si estos se han declarado por referencia (ver formas de pasar argumentos a una función o procedimiento).
En ambos casos es necesario dejar en claro cuáles son las entradas para el algoritmo, esto se hace comúnmente colocando estos valores entre paréntesis al principio o bien declarándolo explícitamente con un enunciado. En el caso de las funciones, es necesario colocar una palabra como regresar o devolver para indicar cuál es la salida generada por el algoritmo. Por ejemplo, el pseudocódigo de una función que permite calcular a^n (un número a elevado a potencia n).


   { \color{Sepia} \mathit{ Funci \acute{o} n }} \;
   { \color{BlueViolet}  \mathit{ potencia }} \;
   (
      { \color{OliveGreen} \mathit{ a,n}}
   )

   { \color{Gray} \mathit{
      // Comentario: \; Este \; algoritmo \; calcula \; a^n \; con \;
      a \; y \; n \; n \acute{u} meros \; naturales // }}

   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ n; }}

   { \color{OliveGreen} \mathit{ r }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{Plum}  \mathit{ 1;}}

   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ a; }}

   { \color{Sepia} \mathit{ Mientras }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ > }} \;
   { \color{Plum}  \mathit{ 0 }} \;
   { \color{Sepia} \mathit{ Hacer }}

   { \color{Sepia} \mathit{ Si }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet} \mathit{ % }} \;
   { \color{Plum}  \mathit{ 2}}
   { \color{BlueViolet}  \mathit{ \neq }} \;
   { \color{Plum}  \mathit{ 0}}
   { \color{Sepia} \mathit{ Entonces }} \;
   { \color{Gray} \mathit{
      //\; Si \; i \; es \; impar \; (% \; es \; resto)}}

   { \color{OliveGreen} \mathit{ r }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ r }} \;
   { \color{BlueViolet}  \mathit{ * }} \;
   { \color{OliveGreen} \mathit{ x; }}

   { \color{Sepia} \mathit{ FinSi }}

   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ * }} \;
   { \color{OliveGreen} \mathit{ x; }}

   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ / }} \;
   { \color{Plum}  \mathit{ 2; }} \;

   { \color{Sepia} \mathit{ FinMientras }}

   { \color{Sepia} \mathit{ Escribir }} \;
   { \color{OliveGreen} \mathit{ r; }}

   { \color{Sepia} \mathit{ FinFunci \acute{o} n }}
Un ejemplo de procedimiento seria el algoritmo de Ordenamiento de burbuja, por el que partiendo de una lista de valores estos se ordenan, nótese que en un procedimiento, no se calcula el valor de una función, sino que se realiza una acción, en este caso ordenar la lista.

   { \color{Sepia} \mathit{ Procedimiento }} \;
   { \color{BlueViolet}  \mathit{ DeLaBurbuja }} \; 
   (
      { \color{OliveGreen}  \mathit{ a }}
      { \color{Plum}   \mathit{ {}_0 }} ,
      { \color{OliveGreen}  \mathit{ a }}
      { \color{Plum}   \mathit{ {}_1 }} ,
      { \color{OliveGreen}  \mathit{ a }}
      { \color{Plum}   \mathit{ {}_2 }} ,
      \ldots,
      { \color{OliveGreen}  \mathit{ a }} {}_(
      { \color{OliveGreen}  \mathit{ {}_n }}
      { \color{BlueViolet}   \mathit{ {}_- }}
      { \color{Plum}   \mathit{ {}_1}} {}_)
   )

   { \color{Sepia} \mathit{ Para }} \;
   { \color{OliveGreen} \mathit{ i}} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{Plum}  \mathit{ 2}} \;
   { \color{Sepia} \mathit{ Hasta }} \;
   { \color{OliveGreen} \mathit{ n}} \;
   { \color{Sepia} \mathit{ Hacer }}

   { \color{Sepia} \mathit{ Para }} \;
   { \color{OliveGreen} \mathit{ j}} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{Plum} \mathit{ 0}} \;
   { \color{Sepia} \mathit{ Hasta }} \;
   { \color{OliveGreen} \mathit{ n }} \;
   { \color{BlueViolet}  \mathit{ - }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{Sepia} \mathit{ Hacer }}

   { \color{Sepia} \mathit{ Si }} \;
   { \color{OliveGreen} \mathit{ a }}    {}_(
   { \color{OliveGreen} \mathit{ {}_j }} {}_) \;
   { \color{BlueViolet}  \mathit{ < }} \;
   { \color{OliveGreen} \mathit{ a }} {}_(
   { \color{OliveGreen} \mathit{ {}_j }}
   { \color{BlueViolet}  \mathit{ {}_+ }}
   { \color{Plum}  \mathit{ {}_1}} {}_) \;
   { \color{Sepia} \mathit{ Entonces }}

   { \color{OliveGreen} \mathit{ aux }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ a }}    {}_(
   { \color{OliveGreen} \mathit{ {}_j }} {}_) \;

   { \color{OliveGreen} \mathit{ a }}    {}_(
   { \color{OliveGreen} \mathit{ {}_j }} {}_) \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ a }} {}_(
   { \color{OliveGreen} \mathit{ {}_j }}
   { \color{BlueViolet}  \mathit{ {}_+ }}
   { \color{Plum}  \mathit{ {}_1}} {}_)

   { \color{OliveGreen} \mathit{ a }} {}_(
   { \color{OliveGreen} \mathit{ {}_j }}
   { \color{BlueViolet}  \mathit{ {}_+ }}
   { \color{Plum}  \mathit{ {}_1}} {}_) \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ aux }}

   { \color{Sepia} \mathit{ Fin } { Si }}

   { \color{Sepia} \mathit{ Fin } { Para }}

   { \color{Sepia} \mathit{ Fin } { Para }}

   { \color{Sepia} \mathit{ Fin } { Procedimiento }}

Ventajas del pseudocódigo sobre los diagramas de flujo

Los pseudocódigos presentan los siguientes beneficios:
  1. Ocupan mucho menos espacio en el desarrollo del problema.
  2. Permite representar de forma fácil operaciones repetitivas complejas.
  3. Es más sencilla la tarea de pasar de pseudocódigo a un lenguaje de programación formal.
  4. Si se siguen las reglas de identación se puede observar claramente los niveles en la estructura del programa.
  5. En los procesos de aprendizaje de los alumnos de programación, éstos están más cerca del paso siguiente (codificación en un lenguaje determinado, que los que se inician en esto con la modalidad Diagramas de Flujo).
  6. Mejora la claridad de la solución de un problema.