Continuamos con el ejemplo que planteamos en la lección anterior.

-Tenemos el Robot en la posición 2.

a)Miramos la condición que nos pone la estructura Mientras, como no nos encontramos en la posición 3, entramos en el bucle.

b)Nos movemos una posición hacia la derecha (MoverDer).

c)Vamos a la última línea del bucle. (Fin Mientras), la cual nos manda a la primera línea del bucle.

d)Volvemos a mirar si se cumple la condición. Vemos que ya nos encontramos en la tercera posición. Ya no hace falta que entremos en el bucle. Ya podemos seguir con las instrucciones que tenemos después del bucle.

A este proceso que acabamos de realizar le llamaremos Traza. La traza, realizar paso por paso un código, es muy importante en el momento de poder detectar posibles errores en nuestra implementación del código; ya que nos podemos dar cuenta si nuestro código falla o realiza alguna acción que no deseamos. Es muy importante que al realizar la traza hagamos todos y cada uno de los pasos indicados y no demos nada por supuesto. En el momento de realizar la traza debemos actuar como si nosotros fuéramos la máquina que realizará el código.

Imagine que tenemos a nuestro Robot en la plataforma móvil que definimos en lecciones anteriores, con tres posibles posiciones 1 - 2 - 3.

Nuestro Robot lo podemos tener situado en la primera o segunda posición y nosotros queremos que se desplace hasta la tercera posición.

Pasemos a implementar el ejemplo:

Mientras Posición <> 3 hacer
MoverDer
Fin Mientras

Observe el código que hemos propuesto para la resolución de este primer ejemplo con bucles. Vamos a seguir paso a paso cómo miraríamos si hemos realizado bien la solución del código en los dos posibles casos (Robot posicionado en la posición 1 ó en la 2).

-Tenemos el Robot en la posición 1

a)Miraríamos la primera línea, la que marca la condición. La condición nos dice que entremos en el bucle mientras no estemos en la posición 3 (Mientras Posición <> 3 hacer). Como en este caso no estamos en la posición indicada, ya sabemos lo que nos toca, entrar en el bucle.

b)Nos movemos una posición a la derecha (MoverDer).

c)Vamos a la última línea del bucle. (Fin Mientras).

d)Volvemos a mirar si se cumple la condición. Como todavía no se cumple, ya que nos encontramos en la posición 2, entraríamos otra vez dentro del bucle.

e)Nos volveríamos a desplazar una posición a la derecha.

f)Volveríamos al final del bucle donde nos mandaría otra vez a la primera línea de éste para así volver a comprobar la condición.

g)Ahora, como ya nos encontramos en la posición deseada, no entraríamos dentro de nuestro bucle y seguiremos con la instrucción que encontrásemos después de (Fin Mientras); en este caso finalizamos el programa.

Un bucle no es más que una serie de instrucciones que se repiten.

Podemos tener dos tipos de bucles según lo que nos interese comprobar.

- Bucle que se repite mientras se cumple una condición determinada.

- Bucle que se realiza hasta que se cumple la condición que marcamos.

En esta lección nos encargaremos del primer tipo.

A la hora de utilizar un bucle, sea del tipo que sea, debemos ir con cuidado y pensar cuando debe acabar ya que; si no tuviéramos en cuenta esto, podríamos entrar en un bucle sin fin, bucle que no terminaría nunca. Por esto, es de suma importancia que pensemos, antes de hacer nada, en qué momento, cómo, dónde y por qué debe acabar el bucle.

Estructura básica.- En nuestro curso, es la estructura básica de un bucle y se representará de la siguiente manera:

Mientras hacer

Fin Mientras

Explicaremos línea a línea este bucle:

-Primera línea: en esta línea escribiremos la que se debe dar para que se ejecute el bucle. En el momento en que la condición que estamos evaluando sea Falsa, se terminará el bucle y se continuarán ejecutando las instrucciones que aparecerían después de la tercera línea de esta estructura básica.

-Segunda línea: línea o líneas donde escribiremos las instrucciones a efectuar en caso de que la condición sea Verdadera.

-Tercera línea: marca el final del bucle. Podemos decir que nos indica hasta dónde están las líneas que se repiten o justo el final del bucle para poder seguir con las demás instrucciones de nuestro programa.

En esta estructura no tenemos ninguna línea que sea opcional.

Ahora veremos una solución al mismo problema en el que sólo se utilizan 7 líneas.

1.- Si BloqueEncima <> "A" entonces
2.- MoverDer
3.- Si BloqueEncima <> "A" entonces
4.- MoverDer
5.- Fin Si
6.- Fin Si
7.- CogerBloque

1.- Preguntamos si el posible bloque que hay en esta posición es diferente a "A". De esta forma, si el bloque fuera el "A", saldríamos del bucle en la línea 6.

2.- Nos moveríamos una posición a la derecha, con lo que ya estaríamos situados en la segunda posición.

3.- Preguntamos si el posible bloque que hay en esta posición es diferente a "A".

4.- Si estamos en esta línea quiere decir que el bloque "A" no estaba en la primera posición, ni en la segunda; con lo que nos desplazaremos otra posición a la derecha para situarnos en la tercera posición.

5.- Línea que nos indica el final del segundo Si.

6.- Línea que nos indica el final del primer Si.

7.- En esta línea, sería el momento en el que cogemos el bloque que existe en la posición que nos encontramos.

Si se fija en este ejemplo, la instrucción CogerBloque está fuera del Si ya que, lo que hemos conseguido, con todas las instrucciones que tenemos dentro de nuestra estructura condicional, ha sido situar el Robot en la posición en la que se encuentra el bloque A.

Observe que, en este caso, desde un principio preguntamos por diferente (<>) y no por igual (=); con lo que conseguimos que la forma de plantearnos el código sea un poco diferente.

Aquí le muestro una lista de operadores lógicos que podemos utilizar:

- = Igual que

- < Menor que

- > Mayor que

- <> Diferente que

Intente ampliar los ejemplo que hemos dado hasta este momento y buscar una implementación del código lo más sencilla posible. En próximas lecciones, pondremos más ejemplos y algunos ejercicios a realizar.

Vamos a dar dos posibles soluciones para el problema que se nos plantea, en este e-mail y en el siguiente. Recordemos que el Robot siempre partirá de la posición 1 tal y como indica el enunciado.

Primera solución.-

1.- Si BloqueEncima = "A" entonces
2.- CogerBloque
3.- Sino
4.- MoverDer
5.- Si BloqueEncima = "A" entonces
6.- CogerBloque
7.- Sino
8.- MoverDer
9.- CogerBloque
10.- Fin Si
11.- Fin Si

Explicación del ejemplo.-

1.- Miramos si encima de la primera posición, posición en la que sabemos que se encuentra seguro al iniciar el programa, está el bloque A.

2.- Si es así, verdadera lo cogemos. En este caso, hemos terminado el programa. Ya que continuaría con la línea 3, punto donde se separa la parte de la respuesta a la condición verdadera y falsa, y al haberse cumplido la parte Verdadera saltaríamos hasta la línea 11.

3.- Si no se cumple la puesta en la línea 1, continuamos el programa.

4.- Hacemos desplazar al Robot hacia la derecha. Hecho esto, nos encontramos en la posición 2 de nuestra plataforma.

5.- Miramos si encima de esta posición (segunda posición) está el bloque A.

6.- Si es así, verdadera la cogemos. En este caso, hemos terminado el programa; ya que continuaría con la línea 7, punto donde se separa la parte de la respuesta a la condición verdadera y falsa, y al haberse cumplido la parte Verdadera saltaríamos hasta la línea 10.

7.- Si no se cumple la puesta en la línea 5, continuamos el programa.

8.- Hacemos desplazarse el Robot a una posición derecha. Hecho esto, nos encontramos en la posición 3 y última de nuestra plataforma.

9.- Como sabemos seguro que el bloque "A" está en alguna de las 3 posiciones y ya hemos visto que no estaba ni en la 1, ni en la 2. Sin mirar qué bloque hay en esta posición podemos cogerlo.

10.- Fin del segundo Si.

11.- Fin del primer Si.

Observe como dentro de un Si hemos puesto otro Si. Con lo que hemos podido hacer una pregunta después de haber visto que la primera era falsa.

Observe que para este ejemplo hemos necesitado 11 líneas y muchas de estas líneas están repetidas varias veces. Esto no quiere decir que no funcionaría, ya que hemos visto en la traza, ejecución del programa línea a línea, que el Robot al final conseguiría su objetivo. Cuando veamos que una misma instrucción se repite muchas veces nos deberíamos plantear que puede ser que exista alguna otra solución que sea un poco más corta y con menos líneas repetidas.

Ahora que ya sabemos cómo hacer que nuestro Robot se mueva según la posición en la que se encuentra; vamos ha realizar un ejercicio que nos haga lo siguiente: tenemos a nuestro Robot en la plataforma móvil definida anteriormente, pero esta vez con tres posiciones: 1 - 2 - 3. Y encima de una de estas tres posiciones pondremos un bloque (caja) llamada "A". Puede que en alguna de estas posiciones haya un bloque que no se llame "A", si fuera así no deberíamos hacer nada con él.

Lo que queremos que realice nuestro Robot es lo siguiente: el Robot siempre partirá de la posición 1, pero no sabrá dónde está situado el bloque y éste siempre debe estar en una de las 3 posiciones. Nosotros deberemos hacer que nuestro Robot se desplace por la cinta mirando si el bloque se encuentra en esta posición. Si el bloque está en esa posición, debe cogerlo.

Como siempre, vamos a definir las nuevas instrucciones que necesitaremos para solucionar este problema, recuerde que si necesita alguna de las instrucciones definidas anteriormente puede hacerlo. Eso sí, no puede inventarse ninguna instrucción nueva. Es recomendable que vaya haciendo una lista de todas las instrucciones que vamos definiendo.

Nuevas instrucciones:

-BloqueEncima: será el equivalente a hacer que el robot mire arriba y mire el nombre que tiene escrito el bloque.

-CogerBloque: el robot alargará su brazo y cogerá el bloque.

Sería muy recomendable que antes de mirar la solución lo intentara usted solo, para ver si ha comprendido a la perfección todo lo que llevamos de curso.

Una vez visto el ejemplo anterior vamos a plantear otros que nos ayudarán a entender y a familiarizarnos con esta estructura condicional. Con la práctica, podrá ver que esta es una de las estructuras que más se utilizan en programación. En casi todos los programas hay que tomar algún tipo de decisión.

Este es un ejemplo un poco tonto pero nos puede servir para acabar de entender cómo funciona esta estructura condicional.

Imagine que tenemos a nuestro Robot trabajando en una cadena de montaje en una plataforma móvil que tiene dos posiciones posibles: la 1 ó la 2 a derecha e izquierda.

Lo que nosotros queremos que haga el Robot es lo siguiente: si el Robot inicialmente se encuentra en la posición 1 deberá moverse a la 2, y si se encuentra en la posición 2 deberá moverse a la 1.

Para este ejemplo definiremos unas nuevas instrucciones que iremos utilizando en futuros ejemplos:

-MoverDer: moverá el robot a la derecha una sola posición.

-MoverIzq: moverá el robot a la izquierda una sola posición.

-Posición: esta instrucción nos servirá para saber en qué posición se encuentra el robot.

Antes de mirar la solución que yo le propongo estudie una posible solución, piense un poco y no tenga miedo en equivocarse con la solución.

Posible solución Ejemplo 2.- Una posible solución a nuestro programa del Robot que se debe mover de una posición a la otra podría ser la siguiente:

Si Posición = 1 entonces
MoverDer
Sino
MoverIzq
Fin Si

Observe que en este ejemplo lo que hacemos es preguntar si el Robot se encuentra en la posición 1. Si la respuesta es Verdadera haremos que se mueva a la derecha "MoverDer" (con lo que se quedará en la posición 2), mientras que si la respuesta fuera Falsa (cosa que querría decir que está en la posición 2) se movería a la izquierda "MoverIzq" (quedando situado el Robot en la posición 1). Así de fácil podemos hacer que nuestro Robot cambie de posición dependiendo de su posición inicial.

Ahora veremos cómo podemos utilizar esta estructura condicional dentro del caso que hemos citado anteriormente.

Recordemos el problema: tenemos nuestro pequeño Robot que sube una escalera. En un momento determinado, queremos que tome una decisión según el punto en el que se encuentra. La decisión es la siguiente: si se encuentra en el escalón 200 debe detenerse, mientras que si está en cualquier otro sitio debe continuar subiendo.

Ante un problema así, debemos plantearnos cuál es la estructura que debemos utilizar. En este caso, es fácil ya que sólo hemos estudiado una. Cuando tenemos clara la estructura debemos mirar que es lo que debemos poner en cada lugar y cuáles son las instrucciones que debemos utilizar.

Vamos a definir las instrucciones que nos hacen falta para este ejemplo:

-Escalón: nos servirá para saber en qué número de escalón se encuentra nuestro robot.

-Parar: detiene al robot y lo pone en modo de pausa para que "descanse".

Estas "instrucciones" están hechas a medida porque estamos utilizando un pseudo código, pero podrían ser sustituidas por instrucciones reales en el momento en el que nosotros decidiéramos en qué lenguaje realizar nuestro programa.

Una vez hemos definido las instrucciones y mirado cuál es la estructura que queremos utilizar pasaremos a escribir el código. Quiero decir que al principio puede ser que le cueste un poco encontrar una solución lógica. Pero piense que esto, como la mayoría de las cosas, requiere mucha paciencia, mucha práctica y algo de concentración.

Pasemos a implementar el ejemplo:

Si Escalón = 200 entonces
Parar
Sino
LevantaPieIzquierdo
LevantaPieDerecho
Fin Si

Observe detenidamente la implementación del código y mire cuáles serían los pasos que deberíamos seguir cuando se dieran los dos posibles casos de nuestro problema. Recuerde que para un mismo problema pueden existir diferentes soluciones.

Una instrucción condicional es aquella que nos permite "preguntar" sobre el entorno que nos rodea, pudiendo así actuar según la respuesta obtenida. Estas respuestas siempre serán Verdaderas o Falsas, pudiendo así tomar, en un principio, dos caminos diferentes.

Pongamos un pequeño ejemplo. Imagine que tenemos nuestro robot subiendo las escaleras de la Torre Eiffel y le indicamos lo siguiente: si está en el escalón 200 entonces no continúe subiendo, sino continua su ascensión. Como puede ver aquí se nos presenta una condición y, según en el punto de la escalera en la que se encuentre, nuestro robot se parará o continuará subiendo.

Estructura básica de una condición.- En nuestro curso esta estructura condicional se representará de la siguiente manera:

Si entonces

Si no

Fin Si

Le explicaremos línea a línea la estructura condicional anterior:

-Primera línea: aparece parte de la estructura condicional y la que deseamos evaluar.

-Segunda línea: lugar donde pondremos las instrucciones a realizar en caso que la respuesta a la condición sea VERDADERA.

-Tercera línea: parte de la estructura condicional que nos divide la parte de las instrucciones a realizar cuando la condición es verdadera y cuando es falsa.

-Cuarta línea: lugar donde pondremos las instrucciones a realizar en caso que la respuesta a la condición sea FALSA.

-Quinta línea: parte de la estructura condicional que nos indica el final de la misma.

En la siguiente unidad didáctica le explicaremos un ejemplo.

Para solucionar posibles problemas de repetición de la misma instrucción o de códigos interminables, disponemos de diferentes instrucciones que nos permiten reducir el número de líneas de un programa facilitando así la compresión, la modificación del código y un posible error en la ejecución del programa.

Observe una posible solución para nuestro problema. (Piense que para un mismo problema no sólo existe una solución, yo le ofreceré una, pero eso no quiere decir que sea la mejor). Las instrucciones que aparecen en esta solución se irán explicando a lo largo del curso.

Repetir hasta que NúmeroEscalón = 5
LevantePieIzquierdo
LevantePieDerecho
Sume 1 a NúmeroEscalón
Fin Repetir

Lo que hemos creado es una repetición de código hasta que se cumple una determinada condición. Compare las dos posibles soluciones al mismo programa.

Seguramente, al no conocer las instrucciones de la segunda solución, le parecerá mucho más fácil la primera solución, pero estoy seguro que cuando haya realizado alguna lección más del curso comprenderá que la segunda es mucho más fácil de comprender y de modificar que la primera. Ya intentaré demostrárselo a lo largo de todo el curso.

Veremos las estructuras básicas de la programación. Estas estructuras nos ayudarán en el momento en el que nos tengamos que enfrentar a la creación de un programa, ya que nos facilitarán la planificación y la programación del mismo.

En el momento de programar deberá tener en cuenta los siguientes aspectos.

-Estructurar el código para una fácil comprensión en el momento de modificaciones y ampliaciones.

-Poner comentarios en lugares clave para facilitar el entendimiento del código.

-Intentar ahorrar el número de líneas de código, cuantas más líneas inútiles peor será el programa.

-Pensar que el código del programa, muchas veces, no es sólo para nosotros, sino que hay mucha gente a la que le puede interesar nuestro trabajo o deban trabajar con él y ellos deben ser capaces de entender el código.

El por qué de la Metodología.- Mucha gente piensa que estudiar metodología de la programación es una cosa ardua, costosa y muy aburrida. Nosotros intentaremos hacer que esto no sea así y que todo lo que aprenda a partir de este momento le sea de mucha utilidad para la creación de esos programas que tiene en mente.

Ejemplo (Subiendo escaleras).- Imagine que estamos creando un pequeño programa para un robot que debe subir 10 escalones. El robot entiende las siguientes instrucciones LevantePieIzquierdo (para levantar el pie izquierdo y subir un escalón) y LevantePieDerecho (para levantar el pie derecho y subir otro escalón), con lo que podrá ir ascendiendo hasta llegar al final de una escalera.

Si sólo pudiésemos utilizar estas dos instrucciones, para crear un programa para que el robot subiera los 10 escalones, deberíamos hacer un programa con las siguientes líneas de código:

LevantePieIzquierdo
LevantePieDerecho
LevantePieIzquierdo
LevantePieDerecho
LevantePieIzquierdo
LevantePieDerecho
LevantePieIzquierdo
LevantePieDerecho
LevantePieIzquierdo
LevantePieDerecho

Fíjese que en este caso. Hemos tenido que escribir las mismas instrucciones varias veces para que el robot subiera los escalones. ¿Qué hubiese sucedido si el robot en lugar de subir 10 escalones hubiese tenido que subir los 1.665 escalones de la Torre Eiffel? El código hubiese sido interminable, corriendo el peligro de equivocarnos al contar la cantidad de escalones, con lo que el robot no hubiese llegado a la cima de la torre. O incluso, nos podríamos haber equivocado escribiendo dos veces la misma instrucción, con lo que el robot se hubiese tropezado al levantar dos veces el mismo pie.