Introduccin a la programacin

Cmo hablo con la mquina?

Pongamos que, un buen da, ante tus ojos, tienes una maravillosa mquina que la gente llama computador. La miras con cautela (morder?), y lo primero que tus ojos observan, es que consta de varios trozos. Uno de ellos, de verdad, es clavado a la tele de la salita (podr ver la peli de la 2 desde aqu?). Otro de esos trozos recuerda a las mquinas de escribir de nuestra infancia (le podr mandar una carta a mi abuela?; y por dnde meto el papel?). Sin embargo, en un computador "medio", suele haber algo ms, que lo primero que recuerda es a una caja grande de zapatos, con la diferencia de que no tiene zapatos dentro. Se le suele llamar "torre" (pues yo no veo ningn castillo) o, simplemente, caja. Si la abrimos, entre todo el maremgnum de cables existente, podemos ver unas plaquitas muy finas. Un consejo: no las rompas. Tienes ante ti, al cerebro pensante (es un decir) de la mquina, y a todos sus sbditos. Entonces, como eres una persona emprendedora, te preguntas, "y cmo demonios le convenzo para que se ponga la peli de la 2?", "sabr hacer ganchillo?", "podremos hacernos amigos?". Esto ltimo depende de ti, y slo de ti. Porque, lo primero que tienes que tener pero que muy claro es que la mquina har nica y exclusivamente lo que t le digas. Lo segundo, es saber que tu mquina tiene limitaciones (lo siento mucho, pero sin brazos dudo mucho que pueda hacerte la comida) y que est diseada para unas tareas concretas ("pero bueno, puedo o no puedo ver la peli de la 2?!"). Lo tercero: tienes que aprender el lenguaje de la mquina. Porque, claro, si le recitas algn poema, nadie te salvar de su gesto de indiferencia: no te entiende. La pregunta lgica, pues, y cul es el idioma de la mquina? ("que no sabr ruso y mira cmo se lo calla?"). Si eres despierto, habrs observado con especial atencin cuando he dicho que hay un maremgnum de cables en alguna parte. No importa tanto lo de la parte como lo de los cables. Bien, veamos: cables. Y yo para qu quiero un cable? Bueno, s, puedo querer estrangular al perro de la vecina, vale, pero eso no me ayuda a saber cmo hablarle a mi mquina (ni siquiera al perro de la vecina). Por dnde bamos? Ah, s... CABLES. Bueno, ahora que lo pienso, por los cables pasa la corriente. Uuummm... CORRIENTE, s, vamos bien. Y qu le pasa a la corriente? ("ah, yo no s, pregntale a ver"). Pues que, como el dinero, *est* o *no est*. Vale, vamos progresando. Si te fijas ms an, en esas placas que te he sugerido que no rompas, hay dibujitos como los de las "pelis" futuristas con un montn de lneas, y hay como una cajita negra grandota con un montn de patitas ("Agh, por Diox, una cucaracha!, Traedme el insecticida!") Vaya, pero si de esas patitas salen ms de esas lneas! No te engaes: esas lneas son cables, y la cucaracha grande es la que manda. Esa cucarachita est preparada para entender un idioma (no tan rico como el castellano) que le permite hacer sus cuentas, encargarle a alguien que las haga por ella ("tiene una calculadora?"), y, lo ms importante, por medio de esos cables, dar rdenes a diestro y siniestro a sus sbditos y recibir las respuestas de los mismos. Tiene muchas responsabilidades encima, para ser una cosa tan chica. Y suele responder al nombre de "procesador" (aunque no se gira cuando le llamas). Sus colaboradores se encargan (si estn todos lo cables enchufados como toca, cosa que presuponemos) de hacer cuentas, de enviar seales de vdeo a esa cosa "clavada a la tele de la salita" para que puedas ver desde unas tristes letras blancas en fondo negro (aunque tienen su encanto) a la ltima novedad en 3D con muchos colorines, de permitirnos que al pulsar una tecla aparezca por esa pantalla, en fin... todo un mundo! Y el procesador, para que le hablen, simplemente necesita que le digas: "0" o "1". ("Pero bueno, y para esto tanto rollo con que si lenguajes de programacin que si historias?"). Qu significa esto? Por qu, de entre todas las posibles formas de comunicacin, ha ido a elegir la ms estpida? Bueno, en realidad no lo es tanto. Lo que quiere decir es, "0": ausencia de corriente. "1": presencia de corriente. Es la manera ms fcil. Pero esto no acaba aqu. Como podrs imaginar, los 0 y 1 pueden aparecer de muchas maneras. Ah, ah has dado con la clave de todo: 0 y 1 son "el alfabeto", pero todas las formas en que pueden aparecer son sus "palabras" (aunque no te recomendara que asociaras palabra con esto).

Ya est claro: tengo que saber hablar en 0 y 1 si quiero tener algn tipo de relacin con mi computador. Pero no es nada "humano", digamos intuitivo. Lo ideal sera que pudiera hablarle de forma que se parezca ms a mi manera de hablar, puesto que no estamos ahora para ir aprendiendo idiomas tan "exticos". Y entonces llega el ser humano con su ingenio, y decide inventarse un lenguaje ms sencillo con el que hablarle a la mquina: y naci el ensamblador. Pero, para una persona cuyo objetivo ms ambicioso (por ahora) es escribir un "Hola Mundo", resulta demasiado complicado. Por qu? Pues porque requiere conocer a la mquina como a uno mismo, y si uno mismo no llega a conocerse bien, qu me direis de su mquina. As, en un alarde de ingenio, el ser humano repite jugada, y se inventa otros lenguajes que, ahora s, son ms parecidos a nuestra forma de pensar. Estos lenguajes, como todo, hay que aprendrselos, pero tienen una ventaja, y es que hay varios puntos en comn. Todos constan de unos determinados tipos de variables. Una variable es como una caja, donde ahora puedo meter un zapato y maana un tomate. Ahora, yo puedo haber etiquetado mis cajas y decir "aqu slo fruta": ser una variable de tipo FRUTA. O, "aqu slo legumbres": ser una variable de tipo LEGUMBRE. Esto es interesante, porque en el momento en que yo vea FRUTA, ya s que dentro no hay cerveza (y tendr que buscar en otro sitio, jo, qu sed...). Pero no slo eso: yo s que tengo muchas cajas para frutas, pero puedo querer bautizarlas ("t sers la caja de frutas Juana"), y as llamarlas por su nombre. Podr cambiar (o no) su contenido (hoy Juana tiene un meln pero maana le pondr ciruelas), pero NO lo que puede contener: FRUTA. Esto tambin lo tiene en comn los lenguajes de programacin. Slo que sus variables son de otro TIPO. Pueden ser enteros (s, como los nmeros que nos ensearon en la infancia), nmeros con decimales, cadenas de caracteres (no es ms que un caracter detrs de otro) y otros que ahora no comentamos (quedan para ms adelante). Lo normal es declarar las variables al principio de un programa. Declarar no es ms que decir "mira, yo quiero tres variables enteras, y quiero que una se llame Pepi, otra Juani y otra Yoli". A partir de este momento, podrs meter un -4 en Pepi, un 2 en Yoli, y hacer Pepi+Yoli. El resultado ser -2. Vaya, esto se pone interesante. Qu ms cosas me permite hacer un lenguaje de programacin? Pues me permite hacer operaciones conocidas por todos como sumar, restar, multiplicar y dividir. Los lenguajes de programacin, cuentan todos en su haber con un juego de "instrucciones". Una instruccin no es ms que una orden que nosotros le damos a la mquina. Y es que, al fin y al cabo, un PROGRAMA no es ms que una secuencia de instrucciones (escritas en algn lenguaje de programacin) pensado para RESOLVER algn tipo de PROBLEMA. Si no sabemos resolver este problema, no podremos escribir el programa. A ti se te puede ocurrir una manera de resolverlo. A tu vecino, otra. Este METODO con el que resolveis el problema, es lo que se llama ALGORITMO, y es lo que vamos a ver en este cursito cmo se hacen. Un algoritmo no es ms que una secuencia de pasos que, seguidos uno a uno, me permiten resolver un problema. Por ejemplo, cuando quiero ver una pelcula de vdeo, podra hacer: 1. Elijo una pelcula de las de mi coleccin. 2. Compruebo SI TV y vdeo estn conectados a la red (y procedo). 3. SI la TV est apagada, la enciendo, SI NO, pues no. Y lo mismo con el vdeo. 4. Abro el estuche de la pelcula. 5. Saco la pelcula de su estuche. 6. Introduzco la pelcula en el vdeo. Dejo el estuche sobre el vdeo. 7. SI la TV no est en el canal adecuado, la cambio, SI NO, pues no. 8. Cojo los mandos a distancia (el del TV y el del vdeo). 9. Me pongo cmodo. 10. Pulso PLAY en el mando del vdeo.

A qu no se os haba ocurrido? Fijaos bien en unos detalles que son fundamentales y que aparecen en este algoritmo: 1. La descripcin de cada paso no me lleva a ambigedades: los pasos son absolutamente explcitos y no inducen a error. 2. El nmero de pasos es finito. Y es que no puedes tener eternamente pensando a la mquina si pretendes que te d algn resultado en algn momento. Podra poner una definicin rigurosa de lo que es un algoritmo, pero me parece que con esto se coge la idea. Notar tambin que he escrito en maysculas las palabras SI y SI NO. Como podeis imaginar, formar parte de la manera en que se escriben algoritmos. Por ahora, os invito a que describais algortmicamente situaciones cotidianas de vuestra vida. En la prxima entrega har un resumencito escribiendo las cosas de forma algo ms rigurosa (al principio lo que importa es que se entiendan las ideas), completar lo dicho sobre las variables, y seguiremos por esos pecaminosos senderos del mundo de la programacin: las instrucciones de control de un programa.

Las variables, usos y costumbres

La vez anterior nos quedamos hablando de variables, aquellas cajitas donde podemos ir almacenando cosas como lechugas, tomates y tambin... ENTEROS: REALES: Obviamente, dado que la memoria de la mquina es finita (vamos, que por muchos megas, incluso Gigas de RAM, algn da sta se nos acabar), el tamao de los datos que almacenemos tambin ser finito. Esto quiere decir que, por ejemplo, el nmero Pi jams cabr en la memoria de un ordenador. Por tanto, para cada tipo de dato, segn el lenguaje, se especifica cuntas cifras tiene, aunque suele ser unnime. CARACTERES: Estos son los tres tipos de datos bsicos, y son los que yo usar. Como ya coment, las variables se suelen declarar al principio del programa, y esta ser la norma que yo voy a usar; toda variable utilizada, debe haber sido previamente declarada. Para ello, escribir algo como esto: Declaracion de variables: ENTERO: i,j,k REAL: x,y,z CARACTER: a,b,c Fin de la declaracion de variables Esto querr decir que las variables i, j, k sern enteras (con signo), que las variables x, y, z sern reales (con signo) y que las variables a, b, c sern caracteres. Al escribir la declaracin de variables de esta forma, si alguna se nos ha olvidado, es muy fcil incluirla. Una variable, en el momento que la declaramos, est vaca, hueca, sin vida, sentido ni VALOR. Y hasta que dicha variable no tenga valor, lo mejor ser no hacer cosas con ella. Entonces, aqu viene la pregunta: y cmo meto en mi variable un 7? Puedo meter un 23?

Para poder meter cosas en las variables, lo que hacemos es asignarles un valor, es decir, "Pepe es una variable de tipo entero. Si a Pepe le asigno 14, a partir de ahora, poner Pepe es tanto como poner 14". Para ello, nosotros vamos a usar un smbolo, una flechita. Cuando queramos hacer asignaciones, haremos esto: Pepe <- 14 Carolina <- -9.65 Juan <- 'a' Y podemos Pepe <Pepe <Pepe <Pepe <(asignamos un entero) (asignamos un real) (asignamos un caracter)

hacer cuantas asignaciones queramos a nuestra variable. Por ejemplo, si hacemos: 14 4 -3 42

al final, en Pepe tenemos almacenado el valor 42. Lo que no debemos hacer es: Pepe <- 14 Pepe <- 2.5 pues estamos metiendo un valor REAL en una variable que slo quiere ENTEROS. Qu pasar aqu? Pues depende del compilador. Quiz nos trunque los decimales, quiz los redondee, quiz, simplemente, nos d un error y no lo permita. En cualquier caso, si queramos un 2.5 con toda nuestra alma, una variable entera no es lo ms recomendable para guardarlo. "Muy bien, ya s cmo meter cosas en las variables, ahora... qu puedo hacer con mis variables?" Como los caracteres son un tanto especiales, sern tratados aparte, para que no haya confusin. As que, por ahora, nos vamos a entender con las variables numricas. Como obviamente parece, podemos sumar, restar, multiplicar y dividir variables. Si dividimos por una variable que en ese momento valga cero, tendremos un error. Pero, por lo dems, podemos hacer todas estas cosas. Por el mismo motivo que he comentado arriba, es mejor no mezclar enteros con reales al hacer operaciones, a no ser que de verdad uno sepa que quiere mezclarlos y por qu quiere mezclarlos. Para estas operaciones, usaremos la notacin usual que nos ensearon ya desde pequeitos. Entonces, podremos hacer todas estas cosas: Pepe <- 2 Mari <- 3 Juan <- Pepe*Mari Tendremos que en Juan est almacenado el valor 2*3=6 :) Pepe <- 2 Mari <- 3 Juan <- Pepe+Mari Ahora, en Juan est almacenado el valor 2+3=5 :) Pepe <- 2 Mari <- 3 Juan <- Pepe-Mari Y ahora, en Juan est almacenado el valor 2-3=-1 :) Como estos, os podeis poner cuantos ejemplos querais. Adems, los compiladores suelen traer libreras matemticas con muchas funciones ms avanzadas (aunque *todas* esas funciones se consiguen a partir de las cuatro operaciones bsicas), funciones con las que podemos hacer ms operaciones con nuestras variables. Por ejemplo, podemos escribir: Mari <- Pi Pepe <- sin(Mari) Y tendremos en Pepe almacenado el valor sin(Pi)=0

Ms adelante, os pondr como ejercicio implementar alguna funcin matemtica como el seno, la exponencial (u otras), el algoritmo ser muy sencillo, y vereis como todos los clculos no son ms que combinaciones de las cuatro operaciones bsicas que nos ensearon en la escuela. De momento, eso es todo en cuanto a variables numricas. Las variables de tipo carcter son un poco ms especiales, es mejor esperar a tener un poco ms de rodaje en otras cuestiones bsicas.

Estructuras de control; secuenciales y selectivas

Bueno, bueno: ya hemos hablado un poco de variables; qu son, y cosas que podemos hacer con ellas. Tambin hablamos un poco por encima de lo que es un algoritmo, pero an no sabemos cosas sobre ellos. Una posible "definicin rigurosa" sera la siguiente (no hay que tomarla como un dogma de fe): Un algoritmo es una sucesion finita de pasos no ambiguos que se pueden llevar a cabo en un tiempo finito. Sucesin finita es lo contrario de infinita: esto quiere decir que se acaba en algn momento ;) Pasos no ambiguos son pasos tan claros que hasta una mquina los puede entender, de ah la necesidad de la no ambigedad ;) Lo del tiempo finito es una cuestin prctica: no creo que tengamos tanta paciencia (ni que lleguemos vivos, sobre todo) como para ver la salida de un programa que calcule Pi :) No vamos a entrar en filosofas de qu puede ser considerado como un algoritmo, qu no lo es, etc... , no porque no sea interesante en s, sino porque a nosotros lo que nos preocupa en estos momentos es aprender a resolver problemas, y a eso es a lo que vamos. No hay que confundirse: un algoritmo no es lo mismo que un programa, para hacer un programa necesitamos algo ms: unas estructuras de datos. Hay distintas formas de escribir un algoritmo, bien usando un lenguaje especfico de descripcin de algoritmos, bien mediante representaciones grficas. Yo he elegido la primera: el pseudocdigo. Que sea un lenguaje especfico no significa que haya que aprender un idioma nuevo, lo nico que quiere decir es que hay unas cuantas palabras que son clave, y que son las palabras que, de acuerdo a unas reglas muy sencillitas, nos ayudan a describir el algoritmo. La estructura del pseudocdigo es bastante parecida a la de algunos lenguajes de programacin (por ejemplo, el Pascal), por ello me ha parecido la ms recomendable. El pseudocdigo tiene algunas ventajas: Es fcil hacer cambios si nos equivocamos en la lgica del programa Es independiente del lenguaje de programacin que vaya a usarse; un algoritmo que est escrito en pseudocdigo es fcilmente traducible a muchos lenguajes de programacin. Y ya, sin ms prembulos, vamos a lo que nos interesa: nosotros queremos resolver problemas con el ordenador, no es as? Pues veamos con qu herramientas nos podemos defender para escribir nuestros propios algoritmos.

Elementos bsicos para la descripcin de algoritmos

El principio y el fin
Para delimitar el comienzo y el final de un algoritmo, o de un trozo de algoritmo (por ejemplo, en los bucles, y otros, como vamos a ver), haremos lo siguiente: inicio ... Aqui va el algoritmo en cuestion fin Tambin, en vez de inicio y fin se puede usar "empezar" y "fin", o lo que querais, pero siempre quedando clara la intencin. No hay que ser estrictamente riguroso con la aplicacin del "inicio-fin", muchas veces, una buena indentacin hace su papel.

Asignaciones
Sobre las asignaciones ya hablamos la vez pasada, al tratar el tema de las variables, vamos a recordarlo brevemente: Cuando hayamos declarado una variable, llegar un momento en el que querremos que la variable tome algn valor. Por ejemplo, tenemos una variable de tipo entero que se llama I y queremos asignarle el valor 3, entonces, escribiremos: I <- 3

Comentarios
Poner comentarios de lo que vamos haciendo es muy til, sobre todo cuando llega la hora de revisar el algoritmo, si no, ms de una vez nos encontraremos diciendo "uumm... qu demonios haca esto?" No cuesta nada documentar el cdigo y nos ahorrar dolores de cabeza :) La convencin que seguiremos ser poner los comentario entre llaves. As, {esto ser un comentario}

Estructuras de control
Las estructuras de control tienen una finalidad bastante definida: su objetivo es ir sealando el orden en que tienen que sucederse los pasos de un algoritmo. Veamos un ejemplo: supongamos que acabamos de mostrar un mensaje en la pantalla que pregunte al usuario "desea seguir adelante?". Obviamente, de la respuesta del usuario va a depender la siguiente accin del programa. Por ejemplo, si este mensaje se nos presenta tras haber pulsado un botn de cerrar la aplicacin, si nosotros elegimos "S", la aplicacin se cerrar, y si elegimos "No", la aplicacin seguir adelante. El programador tiene que haber escrito cdigo para las dos posibilidades, aunque cuando el programa est funcionando, slo se elegir una. Las estructuras de control son de tres tipos: 1. Secuenciales 2. Selectivas 3. Repetitivas

Estructuras secuenciales
Una estructura de control secuencial, en realidad, no es ms que escribir un paso del algoritmo detrs de otro, el que primero se haya escrito ser el que primero se ejecute (al implementarlo, por ejemplo). Veamos un ejemplo: queremos leer el radio de un crculo, calcular su rea y mostrar por pantalla al usuario el resultado. Declaracion de variables REAL: radio, area fin declaracion de variables inicio mostrar por pantalla 'dame el radio del circulo' leer del teclado la variable radio area <- 3.14159*radio mostrar por pantalla 'el area del circulo es:' mostrar por pantalla el contenido de la variable area fin Notar una cosa: cuando queremos hacer cosas relativas a entrada o salida por algn dispositivo, como el teclado, la pantalla o la impresora, yo pongo cosas como "mostrar por pantalla", o "leer del teclado". Dado que cada lenguaje de programacin tiene sus funciones de entrada/salida, no uso la forma particular de ninguno, simplemente, lo que le diramos al ordenador en caso de que fuera una persona ("oye, por favor, scame esto por impresora"). Por otro lado, cuando queramos decir que nos muestre el contenido de una variable, yo he puesto "mostrar por pantalla el contenido de la variable area", pero poda haber puesto igualmente "mostrar por pantalla area", o cosas similares. Vosotros elegs la forma que os resulte ms clara o ms cmoda, lo importante es que las intenciones sean claras, o, lo que es lo mismo, "no ambiguas" ;) Adems, si os fijais, para que quede claro que una cosa es mostrar por pantalla una cadena, y otra cosa es mostrar por pantalla el valor de una variable, el texto que aparece entre ' ' es una cadena, mientras que el que no aparece entre ' ' no es una cadena, sino que se refiere a una variable.

Ahora vamos a pasar a las estructuras selectivas y a las repetitivas. Para ello, necesitamos primero hablar un poco de... CONDICIONES. La palabra condicin nos sugiere frases como "lo har a condicin de que me dejes tu boli". Analicemos esta frase con un poco de detenimiento. Decimos "lo har", pero, "lo har" siempre, pase lo que pase? o, por el contrario, "lo har" si antes hay algo que debe cumplirse? En la frase est claro que no se ha dicho "lo har" sin ms, si no que hay como una pequea clusula "SI me dejas tu boli". Ya nos ha vuelto a aparecer el SI; esto parece querer decir que debe ser algo importante. Lo que significa "SI me dejas tu boli" es lo siguiente, en caso de que la accin "dejarme tu boli" sea cierta (o verdad, usar ambas palabras), yo "lo har". Pero si la accin "dejarme tu boli" es falsa (o mentira), yo NO "lo har". En esto reside el "quid" de las estructuras que vamos a ver a continuacin: se EVALUA una condicin, y se acta en consecuencia, segn que la condicin sea VERDADERA o FALSA.

Estructuras selectivas
Estas estructuras se utilizan para TOMAR DECISIONES (por eso tambin se llaman estructuras de decisin o alternativas). Lo que se hace es EVALUAR una condicin, y, a continuacin, en funcin del resultado, se lleva a cabo una opcin u otra. Alternativas simples Son los conocidos "si... entonces". Se usan de la siguiente manera (una vez ms, la escritura es ms o menos personal, siempre que las intenciones queden claras para todos): yo quiero evaluar una condicin, y si se cumple (es decir, si es cierta), entonces realizar una serie de pasos. Esto lo podemos escribir as: SI se cumple la condicion, ENTONCES: Hago el paso 1 .... Hago el paso N fin del SI Muy estrictamente, sera: SI se cumple la condicion, ENTONCES: inicio Hago el paso 1 .... Hago el paso N fin fin del SI pero con una buena sangra nos podemos evitar escribir de ms ;) Es importante cerrar el SI, ya que, si no se cumple la condicin, el programa seguir a continuacin de donde termina el SI. Por ejemplo, queremos calcular la raz cuadrada de un nmero; sin embargo todos sabemos (supongo! ;)) que la raz cuadrada de un nmero negativo NO es un nmero real. Esto quiere decir que, tras leer el nmero por teclado, tendremos que ver si es positivo, ya que slo en este caso podremos calcular su raz cuadrada. Veamos como queda: Declaracion de variables REAL: numero, raiz fin declaracion de variables inicio mostrar por pantalla 'introduce un numero' leer del teclado la variable numero SI numero >= 0 ENTONCES: raiz <- raiz_cuadrada(numero) mostrar por pantalla 'la raiz cuadrada es:' mostrar por pantalla raiz fin del SI fin Como extraer una raz cuadrada es una operacin que, en principio, no es elemental, yo he puesto raiz_cuadrada(numero), eso significa que, en alguna parte, tengo definida una funcin que me calcula la raz cuadrada de un nmero. Ya hablaremos de funciones y subrutinas ms adelante, pero hago esta aclaracin para que conste que raiz_cuadrada no forma parte de ningn tipo de especificacin de pseudocdigo ;-)

Sin embargo, hubiera sido bonito haber podido avisar al usuario de que no podamos calcular la raz cuadrada en caso de que el nmero fuera negativo, pero no os preocupeis, para ello tenemos las... Alternativas dobles O el famoso tro "si ... entonces ... sino" ;-D Se usan de esta forma: queremos evaluar una condicin, si es verdad, realizar una serie de pasos, y SI NO es verdad (es decir, si es falsa, si es una puerca mentira cochina... ;) ), entonces realizar otra serie de pasos. Esto lo podemos escribir as: SI se cumple la condicion, ENTONCES: Hago el paso A1 .... Hago el paso AN y SI NO se cumple la condicion, ENTONCES: Hago el paso B1 .... Hago el paso BM fin del SI Con esto, nuestro algoritmo para la raz cuadrada quedara: Declaracion de variables REAL: numero, raiz fin declaracion de variables inicio mostrar por pantalla 'introduce un numero' leer del teclado la variable numero SI numero >= 0 ENTONCES: raiz <- raiz_cuadrada(numero) mostrar por pantalla 'la raiz cuadrada es:' mostrar por pantalla raiz SI NO es numero >=0 ENTONCES: {es decir, si numero es negativo} mostrar por pantalla 'lo siento, no puedo calcular la raiz cuadrada de un numero negativo' fin del SI fin Alternativas mltiples Es muy probable que tengamos la necesidad de incluir en nuestros programas alternativas con muchas opciones posibles. Esto lo podramos hacer a base de anidar "si ... entonces ... si no", pero si es un nmero elevado de alternativas, se hace demasiado farragoso como para resultar inteligibles. Por ejemplo, si queremos hacer un men que d a elegir cuatro opciones, un posible algoritmo sera: {Algoritmo MENU a base de 'si ... entonces ... sino'} Declaracion de variables ENTEROS: opcion fin declaracion de variables inicio mostrar por pantalla 'menu de opciones:' mostrar por pantalla '1. Diccionario de sinonimos' mostrar por pantalla '2. Diccionario de antonimos' mostrar por pantalla '3. Buscar palabra' mostrar por pantalla '4. Salir' leer del teclado la variable opcion SI opcion = 1 ENTONCES {lo que toque a esta opcion} SI NO, ENTONCES SI opcion = 2 ENTONCES {lo que toque a esta opcion} SI NO, ENTONCES SI opcion = 3 ENTONCES {lo que toque a esta opcion} SI NO, ENTONCES SI opcion = 4 ENTONCES {lo que toque a esta opcion}

SI NO, ENTONCES mostrar por pantalla 'opcion incorrecta' fin del SI fin del SI fin del SI fin del SI fin Farragoso, verdad? Para evitar esto (os imaginais que en vez de cuatro fueran 20 las alternativas?), est la estructura "segn sea". La idea es esta; por ejemplo, como en el algoritmo que hemos puesto del men, pedimos al usuario que entre una opcin, y hay cuatro posibilidades, cuatro posibles valores para los que haremos algo. Entonces, SEGUN lo que valga la variable opcin, elegiremos una alternativa de entre todas las posibles. La forma de escribir esto en pseudocdigo es: SEGUN SEA la variable o la expresion HACER VALOR1: {las acciones que toque} ... VALORN: {las acciones que toque} por defecto: {las acciones que toque} fin SEGUN Qu pinta ah ese 'por defecto'? No es ms que una alternativa por si acaso se elige alguna opcin no contemplada entre las que se ofrece. Como ejemplo, vamos a ver nuestro men utilizando la alternativa mltiple SEGUN SEA: {Algoritmo MENU a base de 'segun sea'} Declaracion de variables ENTEROS: opcion fin declaracion de variables inicio mostrar por pantalla 'menu de opciones' mostrar por pantalla '1. Diccionario de sinonimos' mostrar por pantalla '2. Diccionario de antonimos' mostrar por pantalla '3. Buscar palabra' mostrar por pantalla '4. Salir' leer del teclado la variable opcion SEGUN SEA opcion HACER: opcion = 1 : {lo que toque a esta opcion} opcion = 2 : {lo que toque a esta opcion} opcion = 3 : {lo que toque a esta opcion} opcion = 4 : {lo que toque a esta opcion} por defecto: {mostrar un posible mensaje de error} fin SEGUN fin As queda mucho ms claro, no slo para nosotros, si no para cualquier persona que tuviera que leerlo; adems, es una forma ms sencilla de manejar una alternativa mltiple :) Podemos abreviar un poquito el texto; es igualmente vlido poner, dentro del SEGUN, lo siguiente: SEGUN SEA opcion HACER: 1 : {lo que toque a esta opcion} 2 : {lo que toque a esta opcion} 3 : {lo que toque a esta opcion} 4 : {lo que toque a esta opcion} por defecto: {mostrar un posible mensaje de error} fin SEGUN Me quedan las estructuras repetitivas, que las veremos en la prxima entrega, si no esto puede ser mucho trago de golpe O:) En cualquier caso, ya teneis cosas para ir empezando a pensar en la escritura de algoritmos. Yo sugiero los siguientes...

Ejercicios
Sobre estructuras secuenciales
1. 2. 3. 4. 5. Escribid Escribid Escribid Escribid Escribid un un un un un algoritmo algoritmo algoritmo algoritmo algoritmo que que que que que calcule el rea de un tringulo. calcule el rea de un rectngulo. calcule el rea de un trapecio. calcule el precio de un artculo tras aplicarle un 16% de IVA. intercambie el contenido de dos variables.

Sobre estructuras selectivas

Escribid un algoritmo que resuelva una ecuacin de segundo grado, teniendo en cuenta todas las posibles alternativas. 2. Disead un esquema de men de opciones, por ejemplo, un men para seleccionar un libro a leer de entre siete disponibles. 3. Escribid un algoritmo que lea tres nmeros e imprima por pantalla el mayor de ellos. 4. Escribid un algoritmo que lea tres nmeros e imprima por pantalla el menor de ellos. De momento, eso es todo, cuando tengamos las estructuras repetitivas ya podremos hacer muchas ms cosas :) Estoy *especialmente* interesada en el ejercicio 5 de las estructuras secuenciales y en el ejercicio 4 de las selectivas, lo digo por si no podeis hacer toda la faena... ;) 1.

Estructuras de control; repetitivas

Vamos a ver un poco de teora primero, porque si no, no s dnde meterla ni cmo contarla sin que parezca un insulto. Perdonadme que esto sea un peln rollero las primeras 40 lneas (o as), y ya el resto lo explico con ejemplos. No la contara si no fuera necesaria O:)

Estructuras repetitivas
Este tipo de estructuras marcan como orden de ejecucin la reiteracin de una serie de acciones basndose en un bucle. Un BUCLE (loop, en ingls) es un trozo de algoritmo cuyas instrucciones son repetidas un cierto nmero de veces, mientras se cumple una cierta condicin que ha de ser claramente especificada. La condicin podr ser verdadera o falsa, y se comprobar en cada paso oiteracin del bucle. Bsicamente, existen tres tipos de estructuras repetitivas; los bucles "mientras..." (o "while"), los bucles "repetir... mientras que" (o "do... while") y los bucles "desde" (o "bucles for"). Vamos a verlas todas dentro de un ejemplo para clarificar los dos prrafos iniciales, que quedan tan bonitos como oscuros para quien nunca ha visto un bucle (ni es verde ni tiene antenas, lo siento %-D ). Slo un poco de teora ms antes de pasar a los ejemplos para cada una de las estructuras repetitivas; hay que hacer notar que todo bucle consta de tres partes bsicas, a saber: Decisin: donde se evala la condicin y, en caso de ser cierta, se ejecuta el... Cuerpo del bucle: son las instrucciones que queremos ejecutar repetidamente un cierto nmero de veces. Salida del bucle: es la condicin que dice cundo saldremos de hacer repeticiones ("mientras protestes, seguirs fregando platos", en cuanto dejas de protestar, se acab fregar ms platos). Una forma de controlar un bucle es mediante una variable llamada CONTADOR, cuyo valor se incrementa o decrementa en una cantidad constante en cada repeticin que se produzca. Tambin, en los bucles suele haber otro tipo de variables llamadas ACUMULADOR, cuya misin es almacenar una cantidad variable resultante de operaciones sucesivas y repetidas. Es como un contador, con la diferencia que el incremento/decremento es variable. S, s, s... ya s que no me habeis entendido ni jota... ya vamos a por ejemplos, y ah vereis a qu me refiero.

Una situacin real como aplicacin

Vamos a suponer que estamos pensando en un programa que deba REPETIR algunas veces una accin. Por ejemplo, el ordenador se ha portado mal (el gindoze se ha vuelto a colgar, no s, por decir algo };-D ), y, como castigo, le vamos a hacer imprimir por pantalla 300 MILLONES de veces la frase "Prometo ser

bueno O:-)"
Cmo lo hacemos? Escribimos 300.000.000 de veces la instruccin pertinente? Vaya martirio! Ni con "Copy'n'Paste"! Se supone que el castigo es para la mquina, no para uno mismo! Pues bien, las ESTRUCTURAS REPETITIVAS vienen a rescatarnos de la tediosa tarea de repetir cientos de lneas que en unas pocas quedan apaadas.

Estructura MIENTRAS(condicin)
En este tipo de estructura, el cuerpo del bucle (ya sabeis, las acciones que deben ejecutarse repetidas veces) se repite MIENTRAS se cumple una determinada condicin, que especificamos entre parntesis. Su estructura, genricamente, es esta:

mientras(condicin) hacer accin 1 ........ accin N fin mientras

Aplicado a nuestra situacin real, sera:

Declaracin de variables ENTEROS: Contador fin Declaracin variables inicio Contador <- 1 mientras(Contador<=300.000.000) hacer mostrar por pantalla 'Prometo ser bueno O:-)' Contador <- Contador+1 fin mientras fin
Con toda la idea, a la variable que "lleva" (por decirlo de alguna manera) la cuenta de las veces que el bucle se ha ejecutado, la he llamado contador. Si os fijais, ANTES de entrar en el bucle le asigno el valor 1. Recordad que no es recomendable usar variables no inicializadas, no sabemos qu tienen dentro. En cuanto vemos la palabra "mientras", ya sabemos que hemos entrado en el bucle. Estamos en la decisin. EsContador<=300.000.000? Yo creo que s, al menos si es cierto que 1<=300.000.000 Vale, es cierto, as que deben ejecutarse todas las instrucciones del cuerpo del bucle. En nuestro caso, se mostrar por pantalla la frase 'Prometo ser bueno O:-)', y, ATENCION,sumo 1 a la variable Contador. Como Contador vala 1, si ahora le sumo 1, creo que todos estamos de acuerdo en que ahora Contador vale 2. Llegamos al fin del mientras. Eso significa que se han terminado las instrucciones del cuerpo del bucle: debemos volver a evaluar la condicin que tena el "mientras" entre parntesis para ver qu hacemos ahora. Tenemos que ver si Contador<=300.000.000. Ahora, Contador vala 2, y se cumple que2<=300.000.000, con lo que vuelve a mostrarse por pantalla la expresin 'Prometo ser bueno O:-)' y de nuevo se suma 1 a Contador, con lo que ahora, Contador pasa a valer 3. De nuevo llegamos al fin del mientras. [... un buen rato despus...] Ahora Contador vale 300.000.000. Tenemos que ver si Contador<=300.000.000. Como es cierto que 300.000.000<=300.000.000, se muestra por pantalla el mensaje 'Prometo ser bueno O:)', y sumamos 1 a Contador. Ahora, Contador vale 300.000.001. Llegamos (una vez ms) al fin del mientras, por lo que tenemos que volver a evaluar la condicin entre parntesis que acompaa al "mientras".

Hay que ver si Contador<=300.000.000. Pero no es cierto que300.000.001<=300.000.000, es ms bien al revs, o sea, la condicin entre parntesis ES FALSA, ES UNA MENTIRA. Eso qu quiere decir? Pues quiere decir que se acab, que ya no se ejecuta el cuerpo del bucle, sino que hemos llegado al final, a la salida del bucle, con lo cual, el bucle ha terminado. Me podra decir alguien qu hubiera pasado si no incluimos la lnea "Contador <Contador+1" dentro del cuerpo del bucle? Slo adelanto que se llegara a una situacin que debe evitarse por completo; si tenemos suerte, habr un error de desbordamiento, en el peor de los casos, el bucle... completad la frase ;) Una nota importante: Fijaos en una cosa, si, por ejemplo, al empezar nuestro algoritmo, en vez de hacer

Contador <- 1
hubiramos hecho

Contador <- 1.000.000.000.000.000.000

aparte de que tenemos posibilidades de salirnos de rango (vamos a suponer que no fuera as), al entrar en el mientras, la condicin es "Contador<=300.000.000", y Contador es, claramente, mayor estrictamente que 300.000.000 Qu pasara aqu? Pues es sencillo: la condicin es falsa, luego el cuerpo del bucle se ejecuta CERO veces. Y qu utilidad tiene poner un bucle para que luego no se ejecute? En este caso concreto, ninguna, pero puede haber situaciones en las que s nos sea til. De hecho, sucede a menudo :)

Estructura REPETIR... MIENTRAS QUE(condicin)

Aqu, lo que se desea es que un bucle se ejecute AL MENOS UNA VEZ antes de comprobar la condicin de repeticin. La estructura del REPETIR ... MIENTRAS, genricamente, es esta:

repetir accin 1 ........ accin N mientras que(condicin) Notar que no hace falta poner "fin del repetir", puesto que est claro que se acaba donde pone "mientras que(condicin)".
Vamos a ver cmo resolver nuestra situacin REAL con este tipo de estructura:

Declaracin de variables ENTEROS: Contador fin Declaracin variables inicio Contador <- 1 Repetir mostrar por pantalla 'Prometo ser bueno O:-)' Contador <- Contador+1 mientras que(Contador<=300.000.000) fin
Le seguimos la pista igual que se la hemos seguido al anterior caso: empezamos con la asignacin del valor 1 a la variable Contador. Llegamos a repetir, quien NO NOS EXIGE, para su entrada, verificar condicin alguna. Mostramos por pantalla la frase 'Prometo ser bueno O:-)', y sumamos 1 a la variable Contador, con lo que ahora pasa a valer 2. Y AHORA es cuando llegamos a la condicin: es Contador<=300.000.000? Yo dira que s, as que ale, de vuelta a repetir: mostramos por pantalla nuestra frase, sumamos 1 a contador... [... varios minutos despus...] Y ya, por fin, Contador alcanza el valor 300.000.001, con lo que la comparacin dice "MENTIRA!", y se acab repetir esa tarea. Nuevamente, os invito a que me digais qu hubiera pasado si no hiciramos Contador <Contador+1 ... Otra nota importante:

Vamos a remarcar una diferencia IMPORTANTE entre esta estructura y la anterior "mientras". Si al empezar nuestro algoritmo, en vez de hacer

Contador <- 1
hubisemos hecho

Contador <- 1.000.000.000.000.000.000

de nuevo tenemos posibilidades de salirnos de rango, pero va, vamos a poner que esto que no fuera as; la palabra REPETIR no nos est pidiendo nada, as que ejecutamos una vez el cuerpo del bucle. Se nos muestra la frase, se incrementa el contador, y llegamos al mientras. Como la condicin es falsa, no volvemos a ejecutar el bucle. Cul es la diferencia? Pues que con la estructura "mientras", el bucle se ejecutaba CERO veces, sin embargo, con la estructura "repetir...mientras que" el bucle se ejecuta UNA vez. Esta sutil diferencia es la que hace que unas veces se elija al primero y otras al segundo.

Estructura DESDE
Esta estructura hubiera sido la ms adecuada para resolver nuestra situacin real, como veremos a continuacin. La estructura "desde", tiene una pequea peculiaridad, y es que ella solita incrementa (o decrementa) DE UNO EN UNO a la variable que utilicemos como contador. Su estructura es:

desde Contador<-Inicio hasta Contador=Fin [, decrementar,] hacer accion 1 ........ accion N fin desde La palabra "decrementar" entre corchetes significa que es opcional, es decir, que se puede poner o no. Si NO se pone, por defecto se asume que al terminar las acciones del bucle, se har Contador <Contador+1 Si ponemos "decrementar", al terminar las acciones del bucle se har Contador <- Contador-1. Cuidado con esto, pues si no especificamos "decrementar", es ILEGAL escribir desde Contador<-500 hasta Contador=200 hacer as como, si escribimos "decrementar", es igualmente ILEGAL poner desde Contador<-1 hasta Contador=1257 , decrementar, hacer
No se admite otro tipo de incrementos/decrementos (de 2 en 2, de 0.5 en 0.5 o de -10 en -10), para ello ya tenemos las estructuras "mientras" y "repetir...mientras", en las que nosotros elegamos el incremento/decremento. En el lenguaje de programacin Pascal esto tambin sucede as en los bucles FOR. En otros lenguajes, como FORTRAN, BASIC o C, el FOR es mucho ms potente, siendo el caso del lenguaje C el que riza el rizo, pudiendo llegar a hacer verdaderas obras de arte con un "simple" bucle FOR. Bueno, al grano O:) Supongo que la estructura est suficientemente clara, sin embargo, para terminar de clarificarla, vamos a aplicarla a nuestra BIEN conocida situacin REAL:

Declaracin de variables ENTEROS: Contador fin Declaracin variables inicio desde Contador<-1 hasta Contador=300.000.000 hacer mostrar por pantalla 'Prometo ser bueno O:-)' fin desde fin
Umm... lo primero que se observa es que no hace falta asignar el valor 1 a Contador fuera del bucle, puesto que en la parte Contador<-Inicio (Contador<-1, en este caso) ya se asigna automticamente ese valor.

Lo siguiente es, como ya he mencionado, que no hace falta que incrementemos el valor de Contador, puesto que es una accin que se realiza sola en un bucle de este tipo. Por ltimo, como no hemos usado la palabra decremento, se asume entonces que incrementamos de 1 en 1 el valor de la variable Contador. Y cmo se hubiera hecho esto usando decrementos? Pues, por ejemplo, as:

Declaracin de variables ENTEROS: Contador fin Declaracin variables inicio desde Contador<-300.000.000 hasta Contador=1 , decrementar, hacer mostrar por pantalla 'Prometo ser bueno O:-)' fin desde fin
Aunque yo lo he hecho aqu por estar manejando variables de tipo entero, debo decir que es PELIGROSO usar una comparacin de IGUALDAD entre dos nmeros cualesquiera, y que, para evitar que por truncamientos, redondeos o algn otro motivo que lleve a prdidas de decimales en los nmeros, en vez de poner = es mejor poner <= o >=. As, en nuestros dos ejemplos de bucle mientras, la lnea "decisoria" en el bucle (por llamarla de alguna manera) es ms recomendable escribirla as:

desde Contador<-1 mientras Contador<=300.000.000 hacer

o as, en el caso del decremento:

desde Contador<-300.000.000 mientras Contador>=1 , decrementar, hacer

Y con esto queda terminado el captulo de las estructuras bsicas para escribir nuestros algoritmos. Notar que aqu he cambiado la palabra hasta por la palabra mientras. Lo que quiere decir es que, mientras que Contador sea menor o igual que 300.000.000, seguiremos dentro del bucle. "Ah, no, con la paliza que nos has dado, ahora la que no se escapa eres t. A ver, y qu hay de esas variables llamadas 'acumuladores' que has mencionado antes y que no has usado para nada?" Bueno, este... me alegro de que me haga esa pregunta! :-D Voy a poner un ejemplo de un acumulador para que se vea claro para qu sirven. Suponed, por ejemplo, que quiero sumar los primeros 10 nmeros naturales. Una posible solucin sera esta:

Declaracin de variables ENTEROS: i,acum fin declaracin variables inicio acum<-0 desde i<-1 hasta i<=10 hacer acum<-acum+i fin desde mostrar por pantalla acum fin
Probad a seguirle la pista al bucle, y decidme qu sale. Lo sabrais escribir usando las otras dos estructuras repetitivas vistas hoy? Si es as, hacedlo }:-) En el primer paso del bucle, acum vale 0, y le sumamos lo que vale i, que es 1. Vale, ahora acum vale 1. Se incrementa i y volvemos al cuerpo del bucle. Sumamos a acum lo que vale i. Ahora acum vale 1, e i vale 2; tras la suma, acum vale 3. A eso es a lo que me refera antes, unas cuantas (pero cuntas) lneas atrs, cuando deca eso de "ACUMULADOR, cuya misin es almacenar una cantidad variable resultante de operaciones sucesivas y repetidas. Es como un contador, con la diferencia que el incremento/decremento es variable". A diferencia de nuestro ejemplo REAL, en el que el incremento era siempre 1, aqu el incremento primero es 1, luego 2, luego 3... espero que con este ejemplo quede ms claro, y si no, me peds que ponga otro, y otro... hasta que lo entendais.

Otra nota (no s cuntas llevo): podemos anidar los bucles. Esto es: dentro de un bucle, podemos ejecutar otro bucle, con la condicin de que ese otro bucle est COMPLETAMENTE CONTENIDO dentro del primero, si no, el algoritmo no es vlido. Por ejemplo: El caso ms tpico de bucle anidado es querer asignar valores a una matriz. Quien no sepa qu es una matriz, que espere al captulo 7 del curso. Supongamos que nuestra matriz tiene por dimensiones 10 y 12, y queremos asignar valores a cada una de sus componentes. Esto lo haremos as:

Declaracin de variables A: Matriz(1..10,1..12) de ENTEROS ENTEROS: i,j {variables para recorrer la matriz} Fin declaracin de variables Inicio desde i<-1 hasta i<=10 hacer desde j<-1 hasta j<=12 hacer A(i,j)<-i+j fin desde {j} fin desde {i} Fin
Como veis, el bucle que gobierna la variable j est totalmente contenido dentro del bucle gobernado por la variable i, y, por cada iteracin del bucle que dirige i, se ejecutan las 12 repeticiones del bucle dirigido por j. Quin me dice cmo quedar nuestra matriz tras la asignacin de valores que hemos hecho? Para no marearos, tomar las filas con la i, y las columnas con la j, como es usual en la notacin de matrices. Vamos ahora a por lo que a m me gusta... los ejercicios };-D 1. Suponed que teneis un vector de 20 componentes (ver el captulo 7 del curso). Escribid un algoritmo que lo invierta, es decir, la componente 1 pasa a ser la 20, la 2 pasa a ser la 19, la 3 ser la 18... y as con todas. 2. Escribid un algoritmo que muestre por pantalla las tablas de multiplicar del 1 al 10. PISTA: Usad bucles anidados. 3. Escribid un algoritmo que muestre por pantalla la suma de los cuadrados de los N primeros nmeros. 4. Escribid un algoritmo que calcule la media aritmtica de una serie de N nmeros. Eso es todo (ahora s), nos vemos en la prxima entrega, en la que hablaremos de... FUNCIONES Y PROCEDIMIENTOS.