Estructuras de Control de Programa (Segunda parte)

Iteraciones o bucles de programa

dolist

Sintaxis

(dolist (lista-inicializacion) (cuerpo))

dolist toma una lista de inicialización y un cuerpo.La lista de inicialización contendrá una variable que tomara los elementos de una lista para cada iteración, la lista de elementos, y una variable que se devolverá como resultado.

(elemento lista-elementos resultado)

En el cuerpo se iterará para cada elemento de la lista, y se irá almacenando cada uno de esos valores en la variable elemento.

Un ejemplo:

> (set 'resultado 1)
1

> (set 'lista-elementos '(2 3 5 7 11 13 17 19 23))

> (dolist (elemento lista-elementos resultado)
            (set 'resultado (* elemento resultado))) ;multiplica cada elemento de la lista y acumula en resultado

Hay que tener en cuenta que "resultado", contendrá el valor devuelto al finalizar el bucle. Si se omite el argumento "resultado" se devolverá NIL al terminar el proceso.

dotimes

Es similar a dolist, solo que la variable iteradora sera siempre un numero natural, comenzando por cero (naturales incluido el cero).

La sintaxis es:

(dotimes (lista-inicializacion) (cuerpo))

Donde (lista-inicializacion) tiene la forma:

(variable-iteradora valor-maximo resultado)

El cuerpo se evaluara sucesivamente, comenzando la variable iteradora con un valor de 0 (cero), hasta alcanzar a valor-maximo menos uno. Como en el caso anterior, si se omite el argumento "resultado" se devolverá NIL al finalizar el bucle.

Ejemplo:

> (dotimes (i 10) (format t "~s" i))
0123456789
NIL

Format imprime el valor de la variable cada vez que se evalúa el cuerpo: "~s" toma el valor de la variable y lo imprime en pantalla.

Para que quede mas lindo, imprimimos uno debajo del otro y con tabulación:

> (dotimes (i 10) (format t "~% ~14t ~s" i))

"~%" equivale a "enter"
"~14t" es la tabulacion
"~s" es la variable que se imprime

Supongamos que deseamos obtener la sumatoria de (2 * i) desde 6 hasta 23 inclusive,

hacemos asi:

> (set 'sumatoria 0)

> (dotimes (i 18 sumatoria) (set 'sumatoria (+ sumatoria (* 2 (+ i 6)))))
522

loop

La forma mas facil de hacer un bucle es haciendo un loop. Para poder salir del bucle es necesario usar un (return). (return) me sirve para salir de cualquier iteraccion, obviamente hay que usarlo siempre y cuando se cumpla una determinada condicion, usando un "if" o "when", por ejemplo.

(set 'x 2)

(loop
   (set 'funcion (expt (+ 1 (/ 1 x)) x))                                ;aplica la funcion
   (format t "~8t x: ~s ~% ~8t y: ~s" x funcion)                ;muestra el valor de funcion
   (set 'x (+ x 1))                                                            ;incrementa x en uno
   (when (not (y-or-n-p "¿Desea calcular un nuevo valor?")) (return)))

La función "y-or-n-p" devuelve T (verdadero) cuando se presiona la tecla "y" y NIL (falso) cuando se presiona "n". En nuestro caso, sale del bucle, aplicando "return" cuando se presiona "n", pues esta precedido de la funcion "not" que niega el valor lógico.

do

Es la iteración mas complicada. Sirve para poder utilizar varias variables iteradoras a la vez, cada una con su propio incremento.

Su sintaxis es:

(do ((lista-inicializacion-1)
     (lista-inicializacion-2)
         ...........
     (lista-inicializacion-n))

    (condicion (expresiones-verdad))

    (expresiones-falso))

Cada lista-inicializacion-i contiene una variable-iteradora, el valor-inicial para esta variable y una funcion que incrementará ese valor:

    (variable-iteradora-i  valor-inicial  funcion-incremento)

Ejemplos de lista-inicializacion-i:

(i 1 (+ i 1))                          ;i comienza en 1 y se va incrementando en 1
(valor 7 (+ valor 4))             ;valor comienza en 7 y se va incrementando en 4
(colores '("azul" "verde" "rojo" "amarillo" "marron" "naranja") (rest colores))
                                              ;mi-lista comienza con una lista de colores
                                              ;rest va eliminando con cada iteración el primer elemento de la lista

En la primera iteracion las variables-iteradoras toman el valor-inicial. Luego se evalúa la "condicion". Si la condicion es T (verdadera) evalua las "expresiones-verdad" y termina el bucle. Si la condicion es NIL (falso), evalua las "expresiones-falso" e incrementa cada una de las variables-iteradoras, y se vuelve a evaluar "condicion".

Ejemplo de do:

(do
 ((i 1 (+ i 1))
  (colores '("azul" "verde" "rojo" "amarillo" "marron" "naranja") (rest colores)))

 ((null colores) (format t "~% ~%¡Listo, barrilete cósmico!"))

 (format t "~% ~10t El color ~s es ~10t ~s" i (first colores)))

Si la lista aun no esta vacía, se imprime el primer elemento de la lista que aun queda. :-)