Introducción al curso.

En este pequeño 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 facilitaran la planificación y la programación del mismo.
En el momento de programar deberás tener en cuenta:
1.- Estructurar el código para una fácil comprensión en el momento de modificaciones y
ampliaciones.
2.- Poner comentarios en lugares clave para facilitar el entendimiento del código.
3.- Intentar ahorrar el número de líneas de código, cuantas más líneas inútiles, peor será el
programa.
4.- Pensar que el código del programa, muchas veces, no es solo para nosotros, sino que hay
mucha gente a la que le puede interesar nuestro trabajo y ellos deben ser capaces de entender el
código.
El porqué 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 aprendas a partir
de este momento te sea de muchísima utilidad para la creación de esos programas que tienes en
mente.
Si todavía no ves claro el porqué de la metodología mira el siguiente ejemplo, después ya me dirás
qué opinas.
Ejemplo (Subiendo escaleras).
Imagina que estamos creando un pequeño programa para un robot que debe subir 10 escalones.
El robot entiende las siguientes instrucciones LevantaPieIzquierdo (para levantar el pie izquierdo y
subir un escalón) y LevantaPieDerecho (para levantar el pie derecho y subir otro escalón), n lo que
podrá ir ascendiendo hasta llegar al final de la escalera.
Si solo pudiésemos utilizar estas dos instrucciones deberíamos hacer un programa con las
siguientes líneas de código:
LevantaPieIzquierd
o
LevantaPieDerech
o
LevantaPieIzquierd
o
LevantaPieDerech
o
LevantaPieIzquierd
o
LevantaPieDerech
o
LevantaPieIzquierd
o
LevantaPieDerech
o
LevantaPieIzquierd
o
LevantaPieDerech
o

Fíjate que en este caso hemos tenido que escribir las mismas instrucciones varias veces para que
el robot fuera subiendo la escalera. ¿Qué hubiese sucedido si el robot en lugar de subir 10
escalones hubiese tenido que subir la Torre Eifiel?. Pues que 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 escalera. O incluso nos podríamos haber equivocado poniendo dos
veces la misma instrucción, con lo que el robot se hubiese pegado un golpetazo impresionante al
levantar dos veces el mismo pie.
Para solucionar estos problemillas 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.
Observa una solución para nuestro problema. (Piensa que para un mismo problema no solo existe
una solución, yo te ofreceré una, pero eso no quiere decir que sea la mejor). La nueva instrucción
se explicará con detenimiento en lecciones posteriores.

Repetir hasta
que NúmeroEscalón = 10
     LevantaPieIzquierdo
     LevantaPieDerecho
     Suma 1 a NúmeroEscalón
Fin Repetir 
Lo que hemos creado es una repetición de código hasta que se cumple una determinada
condicion. Compara las dos posibles soluciones al mismo programa:
LevantaPieIzquierdo
LevantaPieDerecho
LevantaPieIzquierdo Repetir hasta que NúmeroEscalón
LevantaPieDerecho = 10
LevantaPieIzquierdo      LevantaPieIzquierdo
LevantaPieDerecho      LevantaPieDerecho
LevantaPieIzquierdo      Suma 1 a NúmeroEscalón
LevantaPieDerecho Fin Repetir 
LevantaPieIzquierdo
LevantaPieDerecho
Seguramente si no entiendes el segundo ejemplo te parecerá solución, pero estoy seguro que
cuando hayas realizado alguna lección más del curso comprenderás que la segunda es muchísimo
más fácil de comprender y de modificar. Ya intentaré demostrártelo a lo largo de todo el curso.

Introducción al concepto de condición.

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 Verdadero o Falso, pudiendo así tomar, en un principio, dos caminos diferentes.

Pongamos un pequeño ejemplo. Imagina que tenemos nuestro robot subiendo las escaleras y le
indicamos lo siguiente: Si estás en el escalón 200 entonces no continúes subiendo, sino continua
tu ascensión. Como puedes 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 se representará de la siguiente manera:

Explicaremos línea a línea la estructura condicional:

 Primera En esta línea pondremos la <condición> que nos
línea: interesa evaluar.
Segunda Línea o líneas donde pondremos las instrucciones a
línea: efectuar en caso de que la condición sea
VERDADERA.
Tercera A partir de aquí tendremos las instrucciones que se
línea: ejecutarán cuando la condición sea FALSA.
Cuarta línea: Línea o líneas donde pondremos las instrucciones a
efectuar en caso de que la condición sea FALSA.
Línea que nos indica el final de la estructura
Quinta línea:
condicional.
La tercera y cuarta línea son opcionales, ya que puede haber un momento en el que al mirar una
condición nos interese solo una de las posibles respuestas.
Funcionamiento.
 Ahora veremos los dos casos que se pueden dar con esta estructura básica.
    Veamos los pasos que podemos seguir en caso de que la condición planteada sea Verdadera.

Observa los pasos que seguiríamos, en el

supuesto que la condición fuera Verdadera. En
este caso solo hace tres de las cinco líneas de la
estructura básica.
Observa que las líneas que cambia de color no
se ejecutan.

Siguiendo nuestro ejemplo del Robot, este sería el caso en el que el robot se encontraría en el
escalón 200 y por lo tanto tendría que detener su ascensión.
    Veamos ahora los pasos que podemos seguir en caso de que la condición planteada
sea Falsa.

Observa los pasos que seguiríamos, en el

supuesto que la condición fuera Falsa. En este
caso se pasa por cuatro de las 5 líneas de la
estructura básica.
Observa que la línea que cambia de color no se
ejecuta.

Mirando ahora el ejemplo del Robot, sería el caso en el que el Robot NO se encuentra en el
escalón 200 y que por lo tanto debe continuar ascendiendo por la escalera.
Ejemplo 1. (Subiendo escaleras hasta el escalón 200).
Ahora veremos cómo podemos poner nuestro ejemplo en esta estructura, tal y como lo haríamos si
estuviésemos creando un pequeño algoritmo.
Recordemos el ejemplo: 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 detener el ascenso, 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 solo 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 devolverá el número de escalón en el que
se encuentra en este momento nuestro Robot.
Subir Hará que el Robot continúe su ascensión.
Parar Detendrá el Robot.
Estas "instrucciones" están hechas a medida porque estamos utilizando un pseudocódigo, pero
podrían ser sustituidas por instrucciones reales en el momento en el que nosotros decidiéramos en
que lenguaje realizar nuestro programa.
Una vez hemos definido las instrucciones y mirado cual es la estructura que queremos utilizar
pasaremos a pensar construir el código. Quiero decir que al principio puede ser que te cueste un
poco encontrar una solución lógica. Pero piensa 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
        Subir
Fin Si
Observa detenidamente la implementación del código y mira cuales serían los pasos que
deberíamos seguir cuando se dieran los dos posibles casos de nuestro problema. Recuerda que
para un mismo problema pueden existir diferentes soluciones. 
Ejemplo 2. (Moverse de una posición a otra).
Una vez visto el ejemplo anterior vamos a plantear otros que nos ayudarán a entender y a
familiarizarnos con esta estructura.
Este es un ejemplo un poco tonto pero nos puede servir para acabar de entender cómo funciona
esta estructura condicional.
Imagina que tenemos a nuestro Robot en una plataforma móvil que tiene dos posiciones posibles:
la   1 o la 2 (Observa el dibujo).

Lo que nosotros queremos que haga el Robot es lo siguiente: si el Robot se encuentra en la

posición 1 debe moverse a la 2, y si se encuentra en la posición 2 se deberá mover a la 1.
Para este ejemplo definiremos unas nuevas instrucciones que iremos utilizando en futuros
ejemplos:
MoverDer Moverá el Robot a la derecha una posición.
MoverIzq Moverá el Robot a la izquierda una posición.
Posicion Nos devolverá la posición en la que se encuentra el
Robot en el momento de hacer la "pregunta".
   Antes de mirar la posible solución, piensa un poco y plantéate una posible solución.

Ejemplo 3. (Coger el bloque y moverse).

Ahora que ya sabemos cómo hacer que nuestro Robot se mueva según la posición en la que se
encuentra vamos a 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 (Observa el dibujo).

Y encima de una de estas tres posiciones pondremos un bloque (caja) llamada "A".
Lo que queremos que realice nuestro Robot es lo siguiente: El Robot siempre partirá de la
posición 1, pero no conocerá donde está situado el bloque y este siempre debe estar en una de las
3 posiciones. Nosotros deberemos hacer que es Robot se desplace por la cinta mirando si el
bloque se encuentra en la nueva posición. Si el bloque está en la posición en la que se encuentra
el Robot, este debe cogerlo.
Como siempre vamos a definir las nuevas instrucciones que necesitaremos para solucionar este
problema, recuerda que si necesitas alguna de las instrucciones definidas anteriormente puedes
hacerlo. Eso sí, no puedes inventarte ninguna instrucción nueva. Si no recuerdas las instrucciones
que hemos definido hasta ahora mira la lista de instrucciones.
BloqueEncima Nos devolverá el nombre del bloque que está encima
del Robot.
CogerBloque El Robot cogerá el bloque.
Sería muy recomendable que antes de mirar la solución lo intentaras tu solito.

Intenta 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. Si tiene alguna pregunta no dudes en hacerla.