scanf (C 2)

scanf()

            El programa puede desplegar un mensaje en la pantalla para el usuario mediante la instrucción printf((), cuyo formato es (como ya vimos, en parte):

 

printf(‘mensaje”);

 

            Donde valores es un mensaje literal que puede incluir secuencias de escape para incluir valores no fijos o acciones, como ilustran los siguientes ejemplos:

printf(“Hola.”

printf(“%d”, 5);

printf(“%d”, sum);

printf(“La suma es: %d\n\n“, sum);

 

            Para incluir en el mensaje la indicación de que inserte un valor no fijo (o fijo expresado fuera del mensaje) se usa la secuencia “%x”, donde x es una d o una i para los int, una f para los float y los double, y una c para los char. Ya se explicó que la secuencia ‘\n’ indica un salto de línea.

 
            El programa puede pedir valores al usuario desde el teclado mediante la instrucción scanf(), cuyo formato es:

 

scanf(“formatos”, &var1, &var2, …);

            Donde formatos indica una secuencias del tipo ‘%x’ para cada variable a leer, y la lista de variables, separadas por comas y precedidas por el símbolo & son las variables a leer, en ese mismo orden, como ilustran los siguientes ejemplos:

 

scanf(“%d”, num);  // lee en int num

scanf(“%f  %c”, &a, &b);  // lee el flota f y el caracter c

            Dado el siguiente enunciado:

Calcular el área de un triángulo dadas las longitudes de la base y de la altura.

            Podemos proponer el siguiente programa:

// areaTriangulo.c, calcula area de un triangulo dadas la base y la altura

 

#include <stdio.h>

#include <stdlib.h>

 

int main() {

                float b, h, area; // base, altura, área

               

                printf(“Calcula el area de un triangulo, dadas la base y la altura.\n\n”);

 

                printf(“Entre la base y la altura, separadas por espacio, y pulse ENTER: “);

                scanf(‘%f %f”, &b, &h);

 

                area = (b * h)/ 2;

 

                printf(“Area: %f\n\n”, area);

 

                system(“pause’);

                return 0;

}

            Nótese que se ha insertado el comentario que describe el propósito del algoritmo en la primera línea y un comentario para explicar el uso que tienen las tres variables a usar, las cuales se declararon en una sola instrucción Declarar y antes de leer pedir sus valores al usuario (leerlas).

            Nótese que se asigna a la variable area el valor de la expresión que toma los valores de las variables b y h para calcular el valor del área del triángulo. Es notable que este algoritmo vale para valores arbitrarios de las variables b y h.

            Se usaron dos operadores aritméticos para construir la expresión aritmética en la asignación (parte de los paréntesis para aclarar), a saber, * (multiplicación) y / (división). Los otros operadores aritméticos son + (suma), - (menos) y % (módulo o residuo de la división de enteros).

 

ecabrera.marzo.2008

 

Variables (C 1)

Variables

            Una variable es un lugar de la memoria de la computadora en la que el programa puede almacenar un valor de un cierto tipo, el cual está dentro de un cierto rango. Para nombrar una variable se siguen las siguientes reglas:

            . Se inicia con una letra

            . Sólo se usan letras y dígitos

            . Es una sola palabra

            . Se pueden usar letras mayúsculas y minúsculas

 

            Ejemplos de nombres válidos de variables son:

 

A

e

sum

sumaEntero

con1

 

            Ejemplos de nombres no válidos de variables son:

           

5   (no hay letras; empieza con número)

5x  (empieza con número)

sum val (más de una palabra)

 

            Los tipos básicos de variables son:

           

int

float

double

char

 

            Una variable int permite almacenar un número entero (sin parte decimal) positivo, negativo o cero, entre -32768 y 32867, como 5, -14, 0. Una variable float permite guardar un número real (con parte entera y decimal) positivo, negativo o cero, como 5.3, 234,5678, -345678.8765. Una variable char  permite alojar un carácter (símbolo unitario), tal como ‘a’, ‘+’, ‘7’, ‘*’.

            Antes de poder almacenar un valor particular en una variable es necesario declararla, esto es, asignarle un tipo y un nombre válidos, por lo que el programa debe declarar todas las variables que va a utilizar antes de cualquier otra instrucción. Ejemplos de declaración de variables son

 

int  num;  // el número a probar

float x, y;   // los números a intercambiar

double p;  // número primo muy grande

char a, b;  // los caracteres a comparar

            Note que se pueden hacer listas de variables para declarar varias de una vez del mismo tipo. Note el uso de comentarios para explicar el uso que tienen las variables en el programa, lo cual hace más fácil su comprensión por parte de otros lectores.

            La instrucción Asignar se utiliza para asignar un valor a una variable. Su formato es:

var = expresión;

 

Donde var es el nombre de la variable, ya declarada anteriormente, que va a recibir el valor de expresión, que puede ser un valor fijo (constante), el nombre de otra variable, una expresión aritmética, el resultado que retorne una subrutina invocada, entre otras posibilidades.

            Ejemplos de asignaciones de valores a variables son:

a =  5;

b =  a;

s = a + b;

sp = par(7);

 

            A la variable a se le asigna el valor 5. A la variable b se le asigna el valor que tenga la variable a en ese momento (que bien pudiera ser 5, u otro). A la variable s se le asigna el resultado de la suma de los valores que en ese momento tengan las variables a y b. A la variable sp se le asigna el valor que retorne la función par(), luego de recibir el valor fijo 7 y procesarlo.

            Hay que recordar que cuando una variable es declarada no tiene un valor definido y que cuando se le asigna un valor, el valor anterior es remplazado por el recién asignado, por lo que si se desea preservar el anterior, debe copiarse a otra variable antes de la asignación actual.

            Las siguientes asignaciones hacen que la variable a y la variable b quede el mismo valor 6:

a =  5;

b =  6;

a =  b;

b =  a;

 

            Las dos primeras asignaciones colocan un 5 en a y un 6 en b. Pero la tercera asignación remplaza el 5 en a por el 6 que está en b, y la cuarta asignación asigna el actual 6 de a a b: El 5 original en a se pierde.

            Pero las siguientes cinco asignaciones siguientes sí logran intercambiar los valores de las variables a y b, de manera que el 5 colocado originalmente en a queda en b y el 6 originalmente guardado en b queda en a. Y ello es posible gracias a que el valor de a se guarda en la variable temporal t antes de recibir el valor de b:

a =  5;

b =  6;

t =  a;

a =  b;

b =  t;

 

ecabrera.marzo.2008

programa (C 0)

Programa

Existe una amplia gama de problemas computacionales que pueden ser redactados en forma de código simple y que admiten una solución explícita, que llamaremos programas, utilizando el lenguaje C.

Un programa redactado en C tiene el formato:

int main ( ) {

         instrucciones

        return 0;

}

Asumimos que el programa contiene una o más instrucciones imperativas que la computadora ejecutará en forma secuencial, de arriba abajo y de izquierda a derecha, y que podemos insertar comentarios que no se ejecutan

Siempre incluiremos un comentario inicial, que se inicia con dos barras inclinadas, //, que explica brevemente el propósito del programa, por lo que podemos reescribir el formato del programa:

// nombre.c, breve descripción del propósito del programa

int main() {

        instrucciones

       return 0;

}

Para que un programa pueda realizar algo útil el lenguaje C dispone de un montón de recursos reutilizables, llamados librerías, dos de las cuales vamos a incluir regularmente en los programas que siguen. Las librerías se incluyen a nivel global, esto es, antes del cuerpo del programa.

Para incluir una librería se usa el formato:

#include <nombre>

Por tanto, nuestros programas van a seguir el siguiente formato mínimo:

// nombre.c, breve descripción del propósito del programa

#include <stdio.h>

#include <stdlib.h>

 

int main() {

        instrucciones

        return 0;

}

Como nuestros programas serán aplicaciones de consola, es decir, que al ejecutarse se presentarán al usuario como una ventana de fondo negro con texto blanco, que por lo regular se cierra automáticamente, sin que el usuario pueda ver algunos resultados, ampliamos el formato a:

 

// nombre.c, breve descripción del propósito del programa

 

#include <stdio.h>

#include <stdlib.h>

 

 

int main() {

 

 

       instrucciones

       system(“pause”);

      return 0;

}

Esto hará que antes de cerrarse la ventana del programa se despliegue en pantalla (dentro de la aplicación de consola) el mensaje “Press any key to continue” (“Pulse cualquier tecla para continuar”), y no es más que la invocación de la función system() de la librería stdlib.h con el parámetro “pause”.

La instrucción printf() permite al programa desplegar un mensaje en pantalla (dentro de la ventana de la aplicación de consola) y es una función de la librería stdio.h. Su formato es:

printf(“mensaje”);

El mensaje se escribe siempre entre comillas dobles y puede ser literal o incluir algunos caracteres de escape para insertar valores no fijos o acciones en el mensaje. Un ejemplo de programa simple, que ejemplifique lo dicho hasta ahora, podría ser:

// hola.c, despliega “Hola.” en pantalla

#include <stdio.h>

#include <stdlib.h>

int main() {

       printf(“Hola.\n\n”);

       system(“pause”);

      return 0;

}

Note que las secuencias de escape “\n\n” le indican al printf() que luego de desplegar el mensaje “Hola.” salte dos líneas, lo que hará que quede una línea en blanco este mensaje y el que genera system(“pause”); (“Press any key to continue.”).

 

ecabrera.marzo.2008

arreglos (lae 6)

Arreglos

Es posible hacer que una variable admita más de un valor simultáneamente, y para ello la declaramos como un arreglo o vector. Un arreglo se declara de manera similar a una variable escalar (que admite un único valor a la vez), indicando su tipo, nombre, que es un arreglo, y su tamaño máximo:

tipo nombre[tamaño]

El tipo puede ser Entero, Real o Carácter. El nombre sigue las reglas para nombrar una variable escalar. Los corchetes son fijos, el tamaño indica el número máximo de posiciones o valores simultáneos en el arreglo. Se asume que la primera posición en el arreglo es la posición cero. Algunos ejemplos son:

Enteros num[100] // arreglo de cien número enteros

Real val[20] // areglo de 20 números reales

Caracter cad[80] // arreglo de 80 caracteres

Al igual que con las variables escalares, al declarar un arreglo los valores en cada posición están indefinidos, son arbitrarios, por lo que hay que asegurarse de asignarles valores apropiados luego de declarar el arreglo si se quiere garantizar resultados adecuados.

Enunciado:

Retornar los factores de un número entero positivo.

Subalgoritmo:

factores(Enteros f[], nf; Entero n)

    // retorna los factores propios del entero positivo n

    trunca(Entero e; Real n) // retorna la parte entera del número real n

    Enteros div, res, mit // divisores, residuo de n/div, mitad de n

    nf <– 0 // posición en el arreglo y número de factores hallados

    div <– 1

    mit <– trunca(n/2)

       Mientras (div ≤ mit)

             res <– n%div

                   Si (res = 0)

                            f[nf] <– div // div es factor, se guarda en arreglo

                           nf <– nf + 1 // cuenta factor, posición siguiente

                   fin si

               div <– div + 1

       fin mientras

fin factores

El tamaño del arreglo f[] no se especifica porque se asume que al recibirlo como parámetro, se conocerá el tamaño del arreglo del cual recibe sus valores. El parámetro nf sirve para retornar el número de factores encontrados, y n es el número al cual se va a encontrar los factores propios que tenga.

Dentro del Si, que está dentro del Mientras, se hacen dos cosas: Colocar cada valor de div que resulte ser factor de n, y pasara a la siguiente posición en el arreglo f[] incrementando en 1 el valor de nf. Note que esto sólo se hace cuando aparece un factor, mientras que el valor de div incrementa cada vez que se ejecute el Mientras. Podemos redactar un algoritmo que use este subalgoritmo

Algoritmo:

Inicio

// despliega los los factores propios del entero positivo n

factores(Enteros f[], nf; Entero n) // retorna factores propios del entero positivo n

     Enteros num, fac[100], numFac, pos // numero, factores, número de factores, posición en arreglo

     Leer n

     factores(fac[ ], numfac; num))

     pos <– 0

           Mientras (con < numFac)

                Escribir fac[pos]

               pos <– pos + 1

      fin mientras

fin factores

El subalgoritmo factores() es invocado enviándole el arreglo (fac[ ]) para que coloque allí los factores que encuentre para num y el numero de factores (numFac) que encuentre, y el número a encontrar sus factores (num).

Una vez se retorna del subalgoritmo, se usa un Mientras para recorrer el arreglo fac[ ] y desplegar los factores encontrados, usando la variable pos, que va desde cero hasta el número de factores hallados menos uno.

ecabrera.marzo.2008

Mientras (lae 5)

Mientras

            Otra forma de romper el flujo normal de la ejecución del algoritmo es utilizando la instrucción Mientras, que permite que una o más sentencias se ejecuten repetidamente si y mientras cierta condición sea verdadera. Su formato es:

 

Mientras  (condición)

 instrucciones

         fin mientras

 

            Cuando la ejecución llega al Mientras, si la condición es falsa, se ignoran las instrucciones en su interior como si no estuvieran allí, son ignoradas, pero si la condición es verdadera, se ejecutan una y otra vez mientras la condición sea verdadera.

 

Enunciado:

            Desplegar los primeros 9 números naturales.

 

Algoritmo:

 

Inicio nueveNaturales

                // despliega los naturales del 1 al 9

 

Enteros n // los números a desplegar

 

n <– 1

 

Mientras  (n < 10)

             Escribir n

             n <– n + 1

fin mientras

fin nueveNaturales

               

            Se declara el entero n, al cual se asigna 1 inicialmente. Aparece el Mientras, y como 1 es menor que 10, se despliega el 1 guardado en n, y luego se cambia n a 2, puesto que 1 + 1 = 2. A continuación se evalúa nuevamente la condición, que sigue siendo verdadera, puesto que 2 es menor 10.

            De esta manera se despliegan también 2, 3, 4, 5, 6, 7, 8, y 9, pues para todos ellos la condición es verdadera y hay que seguir repitiendo el contenido del Mientras. Pero cuando el valor de n se hace 10, se abandona el ciclo, porque la condición se hace falsa, y el 10 no se despliega.

 

Enunciado:

            Desplegar los factores propios de un número entero positivo.

 

Algoritmo:

 

Inicio factores

                // despliega los factores de un número entero positivo

 

trunca(Entero e; Real n) // retorna la parte entera (trunca parte decimal) del real n

Enteros n, div, res, mit  // el número, divisor, residuo de n/div, mitad de n

 

Leer n

div <– 1

mit <– trunca(n/2)

 

Mientras  (div ≤ mit)

             res <– n%div

             Si (res = 0) Escribir div

             div <– div + 1

fin mientras

fin factores

               

               

            Se declara el subalgoritmo trunca() que retorna la parte entera del número real que recibe: Si recibe un 7.5, retorna un 7, y si recibe un 7.0, retorna un 7. Se usa para probar los divisores para el valor leído de n hasta la mitad de n, puesto que se sabe que ningún factor de n es mayor que la mitad de n.

            Si se lee el número 7 en n , el valor de mit resulta ser 3 y el Mientras se ejecuta para los valores 1, 2 y 3, de los cuales sólo el 1 es factor, por lo que sólo se despliega el 1. Pero si n vale 6, se despliegan el 1, 2 y 3, puesto que mit también vale 3, pero estos valores son todos factores de 6.

 

            ecabrera.marzo.2008

 

Si (lae 4)

Si

            Es posible romper el flujo normal de la ejecución de un algoritmo. Una de ella se logra mediante el uso de la instrucción Si, cuyo formato más simple es:

 

Si (condición) instrucción

 

            Donde Si es fijo, condición es una condición que debe ser verdadera o falsa (entre paréntesis) e instrucción es una instrucción simple, como Asignar, Leer, Escribir, Invocar un subalgoritmo. Su funcionamiento es así:

            Cuando la ejecución del algoritmo se encuentra con el Si, evalúa la condición. Si es verdadera, ejecuta la instrucción que sigue a la condición, pero si es falsa, la ignora, no la ejecuta. Esto implica que la ejecución de la instrucción en el Si está sujeta a la verdad de la condición.

 

Enunciado:

            Determinar si un número entero positivo dado es par.

 

Subalgoritmo:

 

par(Entero sp; Entero n)

                // determina si el entero positivo n es par

               

                Entero res  // residuo de n/2

               

                sp <– 0 // asume que n NO es par

                res <– n%2

                Si (res = 0) sp <– 1

fin par

 

            Este subalgoritmo retorna un 1 (verdadero) si el valor que recibe, n, es par, y retorna un 0 (falso) si no es par, asumiendo que el n NO es par, pues asigna 0 inicialmente a sp, el parámetro de retorno, y siempre se va retornar falso (cero) a menos que se cumpla la condición del Si.

            Se calcula el valor del residuo que deja res al dividirlo por 2, el cual es cero cuando n es par y no es cero cuando el número es impar. Cuando res es cero, entonces se asigna 1 a sp, para indicarlo en el retorno. Por tanto este subalgoritmo retorna un 1 para n = 6 y un cero para n = 7.

            Otro formato de la instrucción Si es el siguiente:

 

                Si (condición)

                                instrucciones

fin si

Funciona exactamente de la misma manera que en el formato anterior, pero ahora no se ejecuta una sola instrucción en caso de ser verdadera la condición, sino las varias instrucciones que se inserten en el cuerpo del Si.

            Otro formato del Si es:

 

            Si (condición)

                                                instrucciones

                                sino

                                                instrucciones

                fin si

 

            Si la condición es verdadera, se ejecutan las instrucciones que siguen inmediatamente a la condición, pero si es verdadera, se ejecutan las están inmediatamente después de la cláusula sino. Note que aquí siempre se ejecuta un grupo de instrucciones o el otro, pero nunca ambos.

 

Enunciado:

            Determinar si un número entero positivo es par.

 

Algoritmo:

 

Inicio siPar

                // determina si el entero positivo n es par

               

                Entero n, sp  // el número a probar, si par (1 = si, 0 = no)

                par(Entero s; Entero n) // determina si el entero positivo n es pas (1 = si, 0 = no)

 

                Leer n

                sp <– par(n)

                                Si (sp = 1)

                                                                Escribir n “es par.”

                                                sino

                                                                Escribir N “NO es par.”

                                fin si

fin siPar

 

            En este algoritmo se declara el subalgoritmo par() porque se usa para determinar si el número leído n es par, lo cual se hace asignando a la variable sp el valor que retorna el subalgoritmo enviándole el valor de n.

            Si el valor retornado por par() es verdadero (1), se ejecuta la instrucción Escribir que está en la parte verdadera del Si (Escribir n “es par.”) y si es falso (0), se ejecuta la parte falsa del Si (Escribir “NO es par.”).

 

            ecabrera.marzo.2008

basura

Basura

            Es sabido que lo que una persona tira como basura, para otra muy bien puede ser de gran utilidad, por lo que el concepto basura puede ser relativo en algunos casos. ¿Pero habrá algún caso en que la basura sea, objetivamente, basura?

            Puede que no, si consideramos el impacto ambiental de muchos de los desperdicios que estamos lanzando los dominicanos en nuestro medio ambiente, en muchos casos de manera innecesaria, creo yo, como buen parte de los envases plásticos.

            En otros tiempos se usaba papel biodegradable para envolver lo que se despachaba en un colmado y las fundas de muchas tiendas, por poner sólo dos ejemplos. Pero al llegar la invasión del plástico, el uso de los vasos desechables y las fundas de plástico se ha generalizado.

            ¿Y a dónde van a parar muchos de estos envases no biodegradables? Una buena parte a las alcantarillas, y de allí una parte al mar. Otra termina en los solares junto a las carreteras, y allí causan una contaminación progresiva.

            ¿Sería mucho pedir tomar medidas simples para reducir significativamente esta contaminación por basura? Quizá podríamos cambiar algunos vasos de plástico por vasos de papel, y hacer lo mismo con las fundas. Aunque sólo fuera esto, podría ser mucho.

            Algunas de las bebidas que ahora vienen en envases plásticos, podrían venir en envases de cristal o de cartón biodegradable, como ocurre en algunos casos con la leche y los jugos. ¿Pero y qué de los pequeños envases, como las gomas de mascar y los caramelos?

            ¿Qué si decidimos, a pesar de que sigamos usando muchos envases no biodegradables, aprendemos a clasificar nuestra basura, de manera que por cada cierta cantidad de bloques de viviendas hayan contenedores etiquetados “Plástico”, “Metal”, “Papel/Cartón”, “Vidrio”, entre otras?

             Más aún, ¿qué si aprendemos a reutilizar los desperdicios orgánicos, no mezclados con los otros desperdicios, para generar energía de biomasa, con digestores, ya hasta obtener subproductos interesantes como el abono procedente del humus?

            Pero quizá me equivoco. Quizá los dominicanos somos incapaces de tomar conciencia colectiva de las riquezas que puede haber en la basura, de cómo contaminamos sin necesidad nuestro ambiente, del enorme ahorro en la generación de energía que podríamos lograr.

ecabrera. marzo.2008

subalgoritmo (lae 3)

Subalgoritmo

            Un algoritmo puede redactarse para ser utilizado por otro, en cuyo caso se le llama subalgoritmo o subrutina. Un subalgoritmo pretende ser una solución general a un solo problema específico, de manera que sea una pieza o parte de la solución de un problema mayor.

            El formato de un subalgoritmo es:

 

nombre (retorno; entrada)

 

                Instrucciones

 

fin nombre

 

 

            Donde nombre es el nombre asignado al algoritmo y que cumple las mismas reglas que un nombre de variable. Entre los paréntesis se colocan los parámetros de retorno y de entrada, y el cuerpo del subalgoritmo son las instrucciones que lo conforman.

            Los parámetros de retorno (si los hay) son variables que corresponden a valores que la subrutina retorna al algoritmo que la invoca, y los de entrada son los que la subrutina recibe. Para ilustrar, consideremos el algoritmo areaTriangulo ya discutido.

            Si nos limitamos a calcular el área de un triángulo, el leer del usuario los valores de la base y la altura, y desplegar el valor del área no es esencial, sino que se puede asumir que los valores de la base y de la altura llegan y que el valor del área se retorna.

            El parámetro de retorno, en este caso es, pues, el área, y los parámetros de entrada son la base  y la altura. Por tanto, podemos redactar el subalgoritmo areaDeTriangulo() así:

 

areaDeTriangulo (Real area; Reales b, h)

                // retorna area de un triangulo dadas la base y la altura

 

                area ß (b*h)/ 2

 

fin nombre

 

            Se asume que los valores de la base y la altura del triángulo llegan al subalgoritmo areaDeTriangulo y que son recibidos en los parámetros b y h. Similarmente, el valor del área del triángulo calculado en el subalgoritmo es retornado en el parámetro area.

            Podemos redactar ahora una versión del algoritmo areaTriangulo en que se asuma la pre-existencia del subalgoritmo areaDeTriangulo():

 

Inicio areaTriangulo

                // calcula area de un triangulo dadas la base y la altura

 

                areaDeTriangulo(Real a; Reales b, h) // calcula area de un triangulo

Reales base, altura, area

 

                Leer base, altura

                area ß areaDeTriangulo(base, altura)

                Escribir area

fin areaTriangulo

 

                Note que la palabra Inicio nos indica que areaTriangulo es un algoritmo, no un subalgoritmo. Note que se ha declarado el subalgoritmo areaDeTriangulo() (un nombre ligeramente distinto para deducir confusión) pues, de manera similar a las variables, es un recurso que se va a utilizar.

            Las variables base, altura y area se declaran en el algoritmo, y luego se piden al usuario los valores de la base y la altura y se guardan en esas variables, pero para calcular el área del triángulo no se hace directamente en el algoritmo, sino que se invoca al subalgoritmo areaDeTriangulo().

            Esto significa que los valores leídos en las variables base y altura se pasan al subalgoritmo areaDeTriangulo(), los cuales son recibidos en los parámetros b y h, respectivamente, y allí se calcula el área, que se guarda en la variable area del subalgoritmo y se retorna a la variable area del algoritmo.

            Note que el valor de la variable base del algoritmo es pasado al parámetro b del subalgoritmo y el valor de la variable altura es pasado al parámetro h del subalgoritmo, por lo que los nombres no tienen que ser iguales para las variables que se pasan y se reciben.

            Sin embargo, pueden usarse los mismos nombres, pues no se confunden ya que cada variable se encuentra en un ámbito distinto, ya sea en el algoritmo, o en el subalgoritmo. Lo que sí tiene que ser iguales son los tipos de las variables correspondientes en el algoritmo y el subalgoritmo.

            ecabrera.marzo.2008

Leer (lae 2)

Leer

            El algoritmo puede desplegar un mensaje en la pantalla para el usuario mediante la instrucción Escribir, cuyo formato es:

 
Escribir valores

 

            Donde Escribir es fijo y valores puede tener uno o más valores fijos o variables, como ilustran los siguientes ejemplos:

 

Escribir “Hola.”

Escribir 5

Escribir sum

Escribir “La suma es: “ sum

 

            El algoritmo puede pedir valores al usuario desde el teclado mediante la instrucción Leer, cuyo formato es:

 

Leer variables

 

            Donde Leer es fijo y variables es una lista de uno o más variables, separadas por comas, cuyos valores serán cambiados a los que suministre el usuario en ese mismo orden, como ilustran los siguientes ejemplos:

 

Leer num

Leer a, b

           

            Dado el siguiente enunciado:

Calcular el área de un triángulo dadas las longitudes de la base y de la altura.

 

            Podemos proponer el siguiente algoritmo:

 

Inicio areaTriangulo

                // calcula area de un triangulo dadas la base y la altura

 

                Reales b, h, area // base, altura, área

               

                Leer b, h

 

                area = (b * h)/ 2

 

                Escribir area

fin areaTriangulo

 

            Nótese que se ha insertado el comentario que describe el propósito del algoritmo en la segunda línea y un comentario en la tercera línea para explicar el uso que tienen las tres variables a usar, las cuales se declararon en una sola instrucción Declarar y antes de leer pedir sus valores al usuario (leerlas).

            Nótese que se asigna a la variable area el valor de la expresión que toma los valores de las variables b y h para calcular el valor del área del triángulo. Es notable que este algoritmo vale para valores arbitrarios de las variables b y h.

            Se usaron dos operadores aritméticos para construir la expresión aritmética en la asignación (parte de los paréntesis para aclarar), a saber, * (multiplicación) y / (división). Los otros operadores aritméticos son + (suma), - (menos) y % (módulo o residuo de la división de enteros).

 

ecabrera.marzo.2008

Variables (lae 1)

Variables

            Una variable es un lugar de la memoria de la computadora en la que el algoritmo puede almacenar un valor de un cierto tipo, el cual está dentro de un cierto rango. Para nombrar una variable se siguen las siguientes reglas:

            . Se inicia con una letra

            . Sólo se usan letras y dígitos

            . Es una sola palabra

            . Se pueden usar letras mayúsculas y minúsculas

 

            Ejemplos de nombres válidos de variables son:

 

A

e

sum

sumaEntero

con1

 

            Ejemplos de nombres no válidos de variables son:

           

5   (no hay letras; empieza con número)

5x  (empieza con número)

sum val (más de una palabra)

 

            Los tipos de variables son:

           

Entero o Enteros

Real o Reales

Caracter o Caracteres

 

            Una variable entera permite almacenar un número entero (sin parte decimal) positivo, negativo o cero, razonablemente pequeño o grande, como 5, 20500, -1456788. Una variable real permite guardar un número real (con parte entera y decimal) positivo, negativo o cero, razonablemente pequeño o grande, como 5.3, 234,5678, -345678.8765. Una variable caracter permite alojar un carácter (símbolo unitario), tal como ‘a’, ‘+’, ‘7’, ‘*’.

            Antes de poder almacenar un valor particular en una variable es necesario declararla, esto es, asignarle un tipo y un nombre válidos, por lo que si algoritmo debe declarar todas las variables que va a utilizar antes de cualquier otra instrucción. Ejemplos de declaración de variables son

 

Entero num  // el número a probar

Reales x, y   // los números a intercambiar

Caracteres a, b  // los caracteres a comparar

            Note que se usa el singular Entero  para declarar la variable num porque es una sola en la lista; mientras que se usa el plural Reales para las variables x y y (separados por comas) porque constituyen una lista de dos variables, y lo mismo ocurre con las variables caracteres a y b.

            Note el uso de comentarios para explicar el uso que tienen las variables en el algoritmo, lo cual hace más fácil su comprensión por parte de otros lectores.

            La instrucción Asignar se utiliza para asignar un valor a una variable. Su formato es:

var ß expresión

 

Donde var es el nombre de la variable, ya declarada anteriormente, que va a recibir el valor de expresión, que puede ser un valor fijo (constante), el nombre de otra variable, una expresión aritmética, el resultado que retorne una subrutina invocada, entre otras posibilidades.

            Ejemplos de asignaciones de valores a variables son:

a <– 5

b <– a

s <– a + b

sp <– par(7

 

            A la variable a se le asigna el valor 5. A la variable b se le asigna el valor que tenga la variable a en ese momento (que bien pudiera ser 5, u otro). A la variable s se le asigna el resultado de la suma de los valores que en ese momento tengan las variables a y b. A la variable sp se le asigna el valor que retorne la función par(), luego de recibir el valor fijo 7 y procesarlo.

            Hay que recordar que cuando una variable es declarada no tiene un valor definido y que cuando se le asigna un valor, el valor anterior es remplazado por el recién asignado, por lo que si se desea preservar el anterior, debe copiarse a otra variable antes de la asignación actual.

            Las siguientes asignaciones hacen que la variable a y la variable b quede el mismo valor 6:

a <– 5

b <– 6

a <– b

b <– a

 

            Las dos primeras asignaciones colocan un 5 en a y un 6 en b. Pero la tercera asignación remplaza el 5 en a por el 6 que está en b, y la cuarta asignación asigna el actual 6 de a a b: El 5 original en a se pierde.

            Pero las siguientes cinco asignaciones siguientes sí logran intercambiar los valores de las variables a y b, de manera que el 5 colocado originalmente en a queda en b y el 6 originalmente guardado en b queda en a. Y ello es posible gracias a que el valor de a se guarda en la variable temporal t antes de recibir el valor de b:

a <– 5

b <– 6

t <– a

a <– b

b <– t

 

ecabrera.marzo.2008