Introducción a la programación

Bueno, bueno: ya hemos hablado un poco de variables; qué son, y cosas que podemos hacer con ellas. También hablamos un poco por encima de lo que es un algoritmo, pero aún no sabemos cosas sobre ellos. Una posible "definición rigurosa" sería 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.

Sucesión finita es lo contrario de infinita: esto quiere decir que se acaba en algún momento ;)

Pasos no ambiguos son pasos tan claros que hasta una máquina los puede entender, de ahí la necesidad de la no ambigüedad ;)

Lo del tiempo finito es una cuestión práctica: 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 filosofías 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 más: unas estructuras de datos.

Hay distintas formas de escribir un algoritmo, bien usando un lenguaje específico de descripción de algoritmos, bien mediante representaciones gráficas.

Yo he elegido la primera: el pseudocódigo. Que sea un lenguaje específico 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 pseudocódigo es bastante parecida a la de algunos lenguajes de programación (por ejemplo, el Pascal), por ello me ha parecido la más recomendable.

El pseudocódigo tiene algunas ventajas:

  • Es fácil hacer cambios si nos equivocamos en la lógica del programa
  • Es independiente del lenguaje de programación que vaya a usarse; un algoritmo que esté escrito en pseudocódigo es fácilmente traducible a muchos lenguajes de programación.

Y ya, sin más preámbulos, 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 básicos para la descripción 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

También, en vez de inicio y fin se puede usar "empezar" y "fin", o lo que querais, pero siempre quedando clara la intención. No hay que ser estrictamente riguroso con la aplicación del "inicio-fin", muchas veces, una buena indentación 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 algún 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, más de una vez nos encontraremos diciendo "uumm... ¿qué demonios hacía esto?"

No cuesta nada documentar el código y nos ahorrará dolores de cabeza :) La convención 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 señalando 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 acción del programa. Por ejemplo, si este mensaje se nos presenta tras haber pulsado un botón de cerrar la aplicación, si nosotros elegimos "Sí", la aplicación se cerrará, y si elegimos "No", la aplicación seguirá adelante. El programador tiene que haber escrito código para las dos posibilidades, aunque cuando el programa esté funcionando, sólo 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 más que escribir un paso del algoritmo detrás 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 círculo, 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 algún 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 programación tiene sus funciones de entrada/salida, no uso la forma particular de ninguno, simplemente, lo que le diríamos al ordenador en caso de que fuera una persona ("oye, por favor, sácame 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 podía haber puesto igualmente "mostrar por pantalla area", o cosas similares. Vosotros elegís la forma que os resulte más clara o más cómoda, lo importante es que las intenciones sean claras, o, lo que es lo mismo, "no ambiguas" ;)

Además, 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 condición nos sugiere frases como "lo haré a condición 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 más, si no que hay como una pequeña cláusula "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 acción "dejarme tu boli" sea cierta (o verdad, usaré ambas palabras), yo "lo haré". Pero si la acción "dejarme tu boli" es falsa (o mentira), yo NO "lo haré".

En esto reside el "quid" de las estructuras que vamos a ver a continuación: se EVALUA una condición, y se actúa en consecuencia, según que la condición sea VERDADERA o FALSA.

. Estructuras selectivas

Estas estructuras se utilizan para TOMAR DECISIONES (por eso también se llaman estructuras de decisión o alternativas). Lo que se hace es EVALUAR una condición, y, a continuación, en función del resultado, se lleva a cabo una opción u otra.

Alternativas simples

Son los conocidos "si... entonces". Se usan de la siguiente manera (una vez más, la escritura es más o menos personal, siempre que las intenciones queden claras para todos): yo quiero evaluar una condición, 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, sería:

 SI se cumple la condicion, ENTONCES:
  inicio
    Hago el paso 1
    ....
    Hago el paso N
  fin
 fin del SI 

pero con una buena sangría nos podemos evitar escribir de más ;)

Es importante cerrar el SI, ya que, si no se cumple la condición, el programa seguirá a continuación de donde termina el SI.

Por ejemplo, queremos calcular la raíz cuadrada de un número; sin embargo todos sabemos (¡supongo! ;)) que la raíz cuadrada de un número negativo NO es un número real. Esto quiere decir que, tras leer el número por teclado, tendremos que ver si es positivo, ya que sólo en este caso podremos calcular su raíz 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 raíz cuadrada es una operación que, en principio, no es elemental, yo he puesto raiz_cuadrada(numero), eso significa que, en alguna parte, tengo definida una función que me calcula la raíz cuadrada de un número. Ya hablaremos de funciones y subrutinas más adelante, pero hago esta aclaración para que conste que raiz_cuadrada no forma parte de ningún tipo de especificación de pseudocódigo ;-)

Sin embargo, hubiera sido bonito haber podido avisar al usuario de que no podíamos calcular la raíz cuadrada en caso de que el número fuera negativo, pero no os preocupeis, para ello tenemos las...

Alternativas dobles

O el famoso trío "si ... entonces ... sino" ;-D

Se usan de esta forma: queremos evaluar una condición, 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 raíz cuadrada quedaría:

 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 múltiples

Es muy probable que tengamos la necesidad de incluir en nuestros programas alternativas con muchas opciones posibles. Esto lo podríamos hacer a base de anidar "si ... entonces ... si no", pero si es un número 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 sería:

 {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 "según sea". La idea es esta; por ejemplo, como en el algoritmo que hemos puesto del menú, pedimos al usuario que entre una opción, y hay cuatro posibilidades, cuatro posibles valores para los que haremos algo.

Entonces, SEGUN lo que valga la variable opción, elegiremos una alternativa de entre todas las posibles.

La forma de escribir esto en pseudocódigo 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 más que una alternativa por si acaso se elige alguna opción no contemplada entre las que se ofrece.

Como ejemplo, vamos a ver nuestro menú utilizando la alternativa múltiple 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 más claro, no sólo para nosotros, si no para cualquier persona que tuviera que leerlo; además, es una forma más sencilla de manejar una alternativa múltiple :)

Podemos abreviar un poquito el texto; es igualmente válido 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 próxima 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. Escribid un algoritmo que calcule el área de un triángulo.
  2. Escribid un algoritmo que calcule el área de un rectángulo.
  3. Escribid un algoritmo que calcule el área de un trapecio.
  4. Escribid un algoritmo que calcule el precio de un artículo tras aplicarle un 16% de IVA.
  5. Escribid un algoritmo que intercambie el contenido de dos variables.

. Sobre estructuras selectivas

  1. Escribid un algoritmo que resuelva una ecuación de segundo grado, teniendo en cuenta todas las posibles alternativas.
  2. Diseñad 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 números e imprima por pantalla el mayor de ellos.
  4. Escribid un algoritmo que lea tres números e imprima por pantalla el menor de ellos.

De momento, eso es todo, cuando tengamos las estructuras repetitivas ya podremos hacer muchas más 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... ;)

COMPARTE ESTE ARTÍCULO

ENVIAR A UN AMIGO
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN GOOGLE +
SIGUIENTE ARTÍCULO

HAY 2 COMENTARIOS
  • Anónimo dijo:

    Muy pero Muy interesante el articulo, solo que tengo una critica. Explican todo muy bien, pero donde se supone que tenemos que hacer los ejercisios, en que programa!!! en un notepad?? en un Word¡?¡ en un Exel?? en Dreamweaver?, en una hoja?? Aguardo su respuesta!! Gracias.

  • [email protected] dijo:

    En fortran !Ordenacionde vectores por el metodo de la Burbuja Program Ordena_burbuja integer,dimension(100)::x integer::i,j,k,n integer::temp print*,"Ingrese la cantidad de datos al vector" read*,n print*,"Ingrese datos al vector" read*,(x(i),i=1,n) print* !usando el algoritmo de ordenacion por la burbuja Do i=1,n-1 Do j=1,n-1 if (x(j)>x(j+1)) then temp=x(j) x(j)=x(j+1) x(j+1)=temp end if end do end do Print*,"Vector ordenado" Print*,(x(k),k=1,n) end program ordena_burbuja !Ordenacionde vectores por el metodo de seleccion Program Ordena integer,dimension(100)::x integer::i,j,min,n integer::temp print*,"Ingrese la cantidad de datos al vector" read*,n print*,"Ingrese datos al vector" read*,(x(i),i=1,n) print* !usando el algoritmo de ordenacion por seleccion Do i=1,n-1 min=i Do j=i+1,n if (x(j)<x(min)) then min=j end if temp=x(i) x(i)=x(min) x(min)=temp end do end do Print*,"Vector ordenado" Print*,(x(i),i=1,n) end program ordena atte William

Conéctate o Regístrate para dejar tu comentario.