ntroducción a la Metodología de la programación.

Introducción al curso.
El porqué de la Metodología.
Ejemplo. (Subiendo escaleras).

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 muchisima 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
que 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), con
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:

LevantaPieIzquierdo
LevantaPieDerecho
LevantaPieIzquierdo
LevantaPieDerecho
LevantaPieIzquierdo
LevantaPieDerecho
LevantaPieIzquierdo
LevantaPieDerecho
LevantaPieIzquierdo
LevantaPieDerecho
Fíjate que en este caso hemos tenido que escribir las mismas instrucciones varias veces para que
el robot fuera subiendo la escalera. ¿Que 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). Las nuevas
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
condición. Compara las dos posibles soluciones al mismo programa:

LevantaPieIzquierdo
LevantaPieDerecho
LevantaPieIzquierdo Repetir hasta
LevantaPieDerecho que NúmeroEscalón = 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á mucho más fácil la primera solución,
pero estoy seguro que cuando hayas realizado alguna lección más del curso comprenderás que la
segunda es muchisimo más fácil de comprender y de modificar. Ya intentaré demostrártelo a lo
largo de todo el curso.

Estructura condicional.
Introducción al concepto de
condición.
Estructura básica de una
condición.
Funcionamiento
Ejemplos
Ejemplo 1
Ejemplo 2
 Ejemplo 3

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 o líneas donde pondremos las instrucciones a
línea: 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 ejecuta.

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 como 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 cual 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 cuales 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, requieren
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 como 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.
Posición 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 como 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 (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.

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

Observa 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 (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 (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 estado inicial.

Posible solución Ejemplo 3

Vamos a dar dos posibles soluciones para el problema que se nos plantea de coger un bloque
que tenemos colocado en una de las tres posiciones. Antes de nada recordemos que el Robot
siempre partirá de la posición 1.

Pasaremos a ver y comentar la primera de las dos soluciones:

Si BloqueEncima = "A" entonces Miramos si encima de la primera posición está el bloque A.

Si es verdad lo cogemos. En este caso hemos terminado el
CogerBloque
programa.
Sino Si no está el bloque A, continuamos el programa.
Nos movemos una posición a la derecha, ahora estamos en la
MoverDer
plataforma 2.
Miramos si encima de la segunda posición está el bloque A.
Si BloqueEncima = "A" entonces
Si es verdad lo cogemos. En este caso terminaríamos el
CogerBloque
programa.
Sino Si no está el bloque A, continuamos el programa.
Nos movemos una posición a la derecha, ahora estamos en la
MoverDer
plataforma 3.
CogerBloque Como no queda otra posible colocación, cogemos el bloque.
Fin Si Fin del segundo Si.
Fin Si Fin del primer Si.

Observa como dentro de un Sino hemos puesto otro Si, con lo que hemos podido hacer una
pregunta después de haber realizado una instrucción.

Observa 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 conseguiría su objetivo. Cuando veamos que
una misma instrucción se repite muchas veces nos deberíamos pensar que puede ser que exista
alguna otra solución que sea un poco más corta y con menos repetición de instrucciones. No
pienses que esto siempre es así, ya que puede haber casos en los que la repetición de
instrucciones no se pueda evitar.

Ahora veremos un ejemplo en el que solo se utilizan 7 líneas y que en ellas solo se repite una
instrucción 2 veces.

Preguntamos si el bloque es diferente de A. Si

Si BloqueEncima <> "A" entonces
fuera A saldríamos del Si.
Si fuera diferente de A nos moveríamos una posición a la
MoverDer
derecha. Posición 2.
Preguntamos si el bloque es diferente de A. Si
Si BloqueEncima <> "A" entonces fuera A saldríamos del Si.
 Si fuera diferente de A nos moveríamos una posición a la
MoverDer
derecha. Posición 3.
Fin Si Terminamos el segundo Si.
Fin Si Terminamos el primer Si.
Nos encontrásemos en la situación que fuese cogeríamos el
CogerBloque
bloque.

Si te fijas 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, a
sido situar el Robot en la posición en la que se encuentra el bloque A. Observa 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. Mira la lista de operadores lógicos.