Capítulo 1

.
Introducción

Comenzaremos por dar algunas definiciones básicas que nos ayudarán a comprender el alcance de este trabajo.

Problema – Situación planteada que queremos resolver.
Algoritmo – Secuencia finita de acciones con las que podemos resolver el problema.

Según el Teorema de la Programación Estructurada todo problema computacional puede resolverse mediante la aplicación de tres tipos de acciones fundamentales que llamaremos "Estructuras de Control de Flujo de Datos".

Estas acciones son las siguientes:

• Ejecutar una acción, luego otra, luego otra,... (lo llamamos acción simple)
• Decidir entre ejecutar una u otra acción en función de que se cumpla o no una determinada condición (lo llamamos acción condicional)
• Ejecutar repetidas veces la misma acción mientras se cumpla una determinada condición (lo llamamos acción iterativa).
  

Estructuras de Control de Flujo de Datos

Acción Simple

Esta es la más básica de las estructuras. Se considera acción simple a las acciones de leer (por teclado o desde un archivo), escribir (por pantalla, impresora o en un archivo) y asignar. Graficamente lo representamos de la siguiente manera:

Lectura (o entrada) – Leemos (por teclado) un valor y lo almacenamos en la variable a.

Asignación – Asignamos el valor de la variable a a la variable b.

Escritura (o salida) – Mostramos (por pantalla o impresora) la frase “Hola Mundo” seguida del valor que contenga la variable b.

Variables y Tipos de Datos

Una variable representa un espacio de memoria (RAM) en el cual podemos almacenar temporalmente valores.

Podemos tener valores numéricos, alfanuméricos, lógicos y definidos por el programador. Es decir: valores de diferentes tipos (de datos).

Si hablamos del valor 123 estamos hablando de un valor numérico entero. Podemos decir entonces que 123 es un entero. En cambio, si hablamos del valor 12.3 estamos hablando de un valor numérico real.

También podemos hablar del valor “Hola Mundo”. En este caso estamos hablando de un valor alfanumérico. Decimos que este valor es una cadena de caracteres o simplemente una cadena.

Otro valor alfanumérico podría ser "123 Hola Mundo 456" que contiene caracteres letras y números. Es alfanumérico.

Obviamente no es lo mismo el valor “123” que 123. El primero es un valor alfanumérico (está encerrado entre comillas) mientras que el segundo es un entero.

Otro tipo de datos es el dato lógico o booleano. Los datos booleanos solo pueden contener valores lógicos: verdadero o falso (true o false).

Resumiendo lo anterior diremos que podemos tener variables de diferentes tipos de datos. Los tipos de datos pueden ser numéricos, alfanuméricos, booleanos o definidos por el programador (pero esto lo veremos más adelante).

Las variables se identifican con un nombre (o identificador). El nombre de la variable debe comenzar con una letra. No puede tener espacios ni caracteres especiales.

Nombres válidos son:

• fechaNac
• fecNac
• f
• iFechaNac

Nombres incorrectos son:

• fecha nacimiento // no puede haber un espacio
• fecha-nacimiento // el caracter " - " se utiliza para restar
• 12fecha // debe comenzar con una letra
• fecha+nacimiento // el caracter " + " se utiliza para sumar
  

Comenzando a Programar

Con lo estudiado hasta aquí estamos en condiciones de resolver el siguiente problema.


Problema 1.0
Se requiere un programa que permita ingresar el nombre de una persona y que luego escriba la leyenda “Hola Mundo” seguida del nombre ingresado.

Análisis
Primero emitimos un mensaje indicando al usuario que debe ingresar su nombre (utilizamos la acción simple escritura). Para leer el nombre utilizamos la acción simple de lectura. El usuario ingresa por teclado su nombre, lo leemos y lo almacenamos en la variable nom. Luego utilizamos la acción simple de escritura para mostrar la cadena “Hola Mundo” seguida del valor que contiene la variable nom. Las letras C y F encerradas en un círculo indican donde comienza y donde finaliza el programa.


Codificación del Algoritmo

El gráfico que acabamos de analizar representa el algoritmo que resuelve el problema planteado.

Para que una computadora pueda interpretar y ejecutar este algoritmo debemos codificarlo en algún lenguaje de programación. En este apunte utilizaremos el lenguaje de programación Pascal.

Para programar en Pascal tenemos que escribir el código fuente (sentencias e instrucciones que veremos a continuación) en un archivo de texto con extensión .pas.

problema1.0.pas

   1:
   2:var nom:string[20];
   3:begin
   4:   // escribe este mensaje por pantalla
   5:   write('Ingrese su nombre: ');
   6:
   7:   // lee un valor y lo guarda en la variable nom
   8:   // (el usuario debe escribir su nombre por teclado)
   9:   readln(nom);
  10:
  11:   // escribe (en pantalla) la cadena 'Hola Mundo'
  12:   // seguida del valor que contiene la variable nom
  13:   writeln('Hola Mundo ',nom);
  14:end.
  15:

El código comienza con la definición de la variable nom. Pascal es un leguaje fuertemente tipado por lo que todos los recursos que vayamos a utilizar en el programa (variables, funciones, etc) deben ser previamente especificados, indicando explicitamente su tipo de datos. En el caso de la variable nom su tipo de datos es string (alfanumérico, cadena de caracteres). En particular lo definimos como string[20] (arbitrareamente) por lo tanto en la variable nom podremos almacenar cadenas de a lo sumo 20 caracteres.

Luego, podemos ver que el programa está encerrado entre las palabras begin y end. Se dice que begin-end encierran un bloque de código. Cada sentencia termina con “punto y coma” salvo el end final que termina con “punto”.

Dentro del código podemos escribir comentarios para ayudarnos a comprender mejor el programa. Los comentarios deben comenzar con “doble barra”.

No es una buena práctica utilizar caracteres especiales dentro de un archivo de código. Es decir: no debemos usar acentos ni "eñes" en los comentarios ni en ninguna parte del código fuente.


Nota: el código anterior es compatible con Free Pascal (http://www.freepascal.org/). Difiere en algunos detalles con Borland Turbo Pascal. En este apunte utilizaremos Free Pascal.

Para editar y compilar el programa vamos a necesitar utilizar una herramienta de desarrollo: Una IDE ("Entorno Integrado de Desarrollo"). Utilizaremos EditPad PRO + FreePascal.


Acción Condicional o Estructura de Decisión

La estructura de decisión permite decidir entre ejecutar un conjunto de acciones u otro en función una expresión lógica. Es decir: una expresión que tenga valor de verdad.

Representamos la acción condicional de la siguiente manera:

Cuando el algoritmo (o programa) llega a una acción condicional debe evaluar la expresión lógica (ubicada en la parte superior). Si esta tiene valor de verdad true (verdadero) entonces se ejecutan las acciones que se encuentran en la parte izquierda de la estructura. Si la expresión resulta false (falsa) entonces se ejecutan las acciones ubicadas a la derecha.


Problema 1.1
Leer un valor e indicar si el valor ingresado es mayor que 10.

Análisis
Leemos el valor en la variable v. Luego con una acción condicional evaluamos si el valor de v es mayor que 10. Si resulta verdadero (esto depende de lo que ingrese el usuario) entonces se ejecuta la parte izquierda de la estructura y se muestra un mensaje indicando que el valor ingresado es mayor que 10.

Si la condición resulta falsa entonces podemos asegurar que el valor NO es mayor que 10. Pero no sabemos si es menor o igual. Esto lo estudiaremos en el próximo problema.

problema1.1.pas

   1:
   2:var v:integer;
   3:begin
   4:   // leemos un valor por teclado
   5:   writeln('Ingrese un valor: ');
   6:   readln(v);
   7:
   8:   // si v (el valor leido) es mayor que 10 entonces
   9:   if( v>10 ) then begin
  10:      writeln('El valor mayor que 10');
  11:   end else begin // si v no es mayor que 10...
  12:      writeln('El valor NO es mayor que 10');
  13:   end;
  14:end.
  15:

La acción condicional se codifica con la sentencia if (ver línea 9). Esta sentencia evalúa la expresión lógica ubicada dentro de los paréntesis y decide (en función de que resulte true o false) que bloque de código ejecutar. Si la expresión v>10 resulta verdadera entonces se ejecuta la línea 10, si no (else) se ejecuta la línea 12.

Notemos que tanto la línea 10 como la línea 12 están encerradas en bloques begin-end. Por eso hablamos de "bloques de código". Dentro un bloque de código puede haber más de una instrucción como veremos en los próximos ejemplos.


Problema 1.2
Idem anterior pero indicar si el valor ingresado es mayor, menor o igual que 10.

Análisis
Para resolver este problema leemos v y preguntamos si es mayor que 10. Si resulta verdadero entonces podemos mostrar ese resultado. Si no es mayor entonces puede ser igual o menor. Tenemos que preguntar por alguna de estas posibilidades. Preguntamos si v=10. Si es verdadero entonces ya sabemos que se ingresó el valor 10. Si es falso entonces (como no es mayor ni es igual) resulta que v es menor que 10.

Utilizamos estructuras de desición anidadas (o "ifes" anidados).

problema1.2.pas

   1:
   2:var v:integer;
   3:begin
   4:   write('Ingrese un valor: ');
   5:   readln(v);
   6:   if( v>10 ) then begin // es mayor
   7:      writeln('El valor mayor que 10');
   8:   end else begin // es igual
   9:      if( v=10 ) then begin
  10:         writeln('Es igual a 10');
  11:      end else begin // es menor
  12:         writeln('Es menor que 10');
  13:      end;
  14:   end;
  15:end.
  16:

En este problema vemos estructuras de desición anidadas (o "ifes anidados") pero aún así los bloques de código encerrados en los if-else tienen una única acción. El if de la línea 6 encierra una única acción writeln. Su else encierra una única acción if que a su vez encierra una única acción, tanto por verdadero (línea 10) como por falso (línea 12).


Problema 1.3

Leer tres valores numéricos. Indicar cual es mayor, medio y menor.
Nota: se asume que los tres valores serán diferentes.

Análisis
Leemos los tres valores y comenzamos a comparar. Preguntamos si a>b. Si esto se verifica entonces preguntamos si a>c. Si esto también se verifica resulta que a>b y a>c. No hay dudas de que a es el mayor. Luego tenemos que comparar b y c para ver cual esta en segundo y en tercer lugar.

Si resulta que a>b pero no se verifica que a>c (o sea que c es mayor que a) será c el mayor, a el medio y b el menor.

Por otro lado, si no se verifica que a>b preguntamos si b>c. Si esto es así entonces el mayor será b (ya que b es mayor que a y b es mayor que c). Preguntamos si a>c y ya podremos deducir cual está en segundo y tercer lugar.

Para finalizar, si es falso que b>c entonces el mayor será c, medio b y menor a.

problema1.3.pas

   1:
   2:var a,b,c:integer;
   3:begin
   4:   write('Ingrese tres valores: ');
   5:
   6:   // lee los 3 valores numericos 
   7:   // separados por espacio en blanco
   8:   readln(a,b,c);
   9:
  10:   if( a>b ) then begin
  11:      if( a>c ) then begin
  12:         writeln('Mayor:',a);
  13:         if( b>c ) then begin
  14:            writeln('Medio:',b);
  15:            writeln('Menor:',c);
  16:         end else begin
  17:            writeln('Medio:',c);
  18:            writeln('Menor:',b);
  19:         end;
  20:      end else begin
  21:         writeln('Mayor:',c);
  22:         writeln('Medio:',a);
  23:         writeln('Menor:',b);
  24:      end;
  25:   end else begin
  26:      if( b>c ) then begin
  27:         writeln('Mayor:',b);
  28:         if( a>c ) then begin
  29:            writeln('Medio:',a);
  30:            writeln('Menor:',c);
  31:         end else begin
  32:            writeln('Medio:',c);
  33:            writeln('Menor:',a);
  34:         end;
  35:      end else begin
  36:         writeln('Mayor:',c);
  37:         writeln('Medio:',b);
  38:         writeln('Menor:',a);
  39:      end;
  40:   end;
  41:end.
  42:

En este código vemos bloques if-else con más de una instrucción. El if de la línea 10 tiene una única instrucción (un if que comienza en la línea 11 y finaliza en la línea 24). El if de la línea 11 tiene dos instrucciones: un writeln y un if que a su vez tiene dos instrucciones por verdadero (líneas 14 y 15) y otras dos por falso (líneas 17 y 18).


Operadores Lógicos

Una proposición es una expresión que tiene valor de verdad (true o false). Es decir: puede verificarse o no.

Los siguientes ejemplos son proposiciones y por lo tanto tienen valor de verdad.

• “Una semana tiene 7 días” (true)
• “7 es número primo” (true)
• “2 es mayor que 5” (false)
• “4 = 2+3” (false)

Podemos utilizar operadores lógicos para realizar operaciones entre proposiciones y así obtener nuevas proposiciones con sus correspondientes valores de verdad.

Los operadores lógicos son: AND, OR y NOT.

Las siguientes tablas muestran el valor de verdad de la proposición que resulta luego de operar dos proposiciones p y q con los diferentes operadores lógicos.

Veamos otra solución para el problema 1.3 (versión 2)

Análisis
La solución es similar: varios if anidados, pero en este caso utilizamos operadores lógicos para evaluar más de una condición en un mismo if.

Comenzamos preguntando si a>b AND a>c para asegurarnos de que a es el mayor valor. Teniendo esto seguro (entramos por la parte izquierda de la estructura) tenemos que ver cual es el valor medio y cual es el menor.

Si a no es el mayor (ingresamos por la parte derecha de la estructura) preguntamos si b es el mayor (b>a AND b>c). Si esto es así entonces comparamos a con c para ver quien está en segundo y tercer lugar. Si no (si b no es el mayor) entonces por descarte el mayor será c. Luego también comparamos a y b para ver quien es medio y menor.

Otra diferencia con la solución anterior es que en este caso estamos utilizando tres variables temporales: mayor, medio y menor para asignar los valores a medida que podemos deducir que posición tienen. Luego simplemente mostramos el valor de estas variables para informar los resultados.

problema1.3v2.pas

   1:
   2:var a,b,c,mayor,medio,menor:integer;
   3:begin
   4:   write('Ingrese tres valores: ');
   5:   readln(a,b,c);
   6:
   7:   // pregunto si a es el mayor
   8:   if( (a>b) AND (a>c) ) then begin
   9:      mayor:=a;
  10:      // como a es el mayor, comparo b con c
  11:      if( b>c ) then begin
  12:         medio:=b;
  13:         menor:=c;
  14:      end else begin
  15:         medio:=c;
  16:         menor:=b;
  17:      end;
  18:   end else begin
  19:      // a no es el mayor, pregunto si el mayor es b
  20:      if( (b>a) AND (b>c) ) then begin
  21:         mayor:=b;
  22:         // el mayor es b, comparo a con c
  23:         if( a>c ) then begin
  24:            medio:=a;
  25:            menor:=c;
  26:         end else begin
  27:            medio:=c;
  28:            menor:=a;
  29:         end;
  30:      end else begin
  31:         // el mayor no es a ni es b. Entonces es c
  32:         mayor:=c;
  33:         // solo queda comparar a con b
  34:         if( a>b ) then begin
  35:            medio:=a;
  36:            menor:=b;
  37:         end else begin
  38:            medio:=b;
  39:            menor:=a;
  40:         end;
  41:      end;
  42:   end;
  43:
  44:   // muestro los resultados obtenidos
  45:   writeln('Mayor: ', mayor);
  46:   writeln('Medio: ', medio);
  47:   writeln('Menor: ', menor);
  48:end.
  49:

Acción iterativa o Estructura de Repetición

La tercer y última estructura de control de flujo de datos es la estructura de repetición (o iterativa). Existen tres estructuras interativas: while, repeat-until y for.

El while, lo representamos de la siguiente manera:

Decimos que mientras se verifique la condición indicada en la parte superior de la estructura se repetirán las acciones que se encuentran dentro del cuerpo principal de la misma (secuencialmente).

Como existe la posibilidad de que la condición no se cumpla al momento de llegar al while y que no se ingrese al ciclo ni siquiera la primera vez se dice que el while es una estructura repetitiva de 0-n (cero a ene) ya que puede iterar desde cero hasta n veces.


Problema 1.4
Imprimir por pantalla los primeros n números positivos (el valor n se ingresa por teclado).

Análisis
La estrategia para solucionar este problema consiste utilizar una variable i con el valor inicial 1 (primer número positivo) e ir mostrando e incrementando su valor mientras este sea menor o igual al valor ingresado por el usuario (n).

Supongamos que el usuario ingresa un valor n=3. Al llegar al ciclo de repetición la condición "i es menor o igual a n" resultará verdadera ya que i vale 1 (dado que lo asignamos antes de ingresar al ciclo) y n vale 3 (es lo que estamos asumiendo). Entonces el programa ingresa al ciclo y muestra el valor de la variable i. A continuación vemos la asignación i <-- i+1. Esto debe leerse así: “a i le asigno el valor que i tenía más 1”. Es decir que si i valía 1 entonces ahora a i le asignamos 1 (lo que tenía) +1 dejando su valor en 2. Es decir: incrementamos el valor de i. Como no hay mas acciones para ejecutar dentro del ciclo, el próximo paso es volver a evaluar la condición para ver si se continúa verificando.

En la siguiente iteración i vale 2 y n vale 3. Todavía se verifica que "i es menor o igual a n". Se vuelve a ingresar al ciclo y se imprime el valor de i (2). Luego se incrementa i y así hasta que no se cumpla la condición.

problema1.4.pas

   1:
   2:var i,n: integer;
   3:begin
   4:   // leo un valor por teclado
   5:   write('Ingrese un valor: ');
   6:   readln(n);
   7:
   8:   // inicializo la variable i con el valor 1
   9:   i:=1;
  10:
  11:   // itero mientras que i sea menor o igual a n
  12:   while( i<=n ) do begin
  13:
  14:      // muestro el valor de i
  15:      writeln(i);
  16:
  17:      // incremento el valor de i
  18:      i:=i+1;
  19:   end;
  20:end.
  21:

Ciclo repeat-until

Lo representamos así:

El ciclo repeat-until es un ciclo de 1 a n. Para ingresar al ciclo no hay condición por lo tanto las acciones que se encuentran dentro del ciclo se realizarán al menos una vez. Luego de la última acción (en este caso acción3) se evalúa la condición que se encuentra en la parte posterior de la estructura.

El ciclo iterará hasta que se verifique la condición ("repeat-until" significa "repetir-hasta").

Tenemos que tener clara la diferencia entre el ciclo while y el ciclo repeat-until. El primero repite mientras, en cambio el segundo repite hasta que se cumpla la condición.


Veamos como podemos resolver el problema 1.4 utilizando un ciclo repeat-until en lugar de un ciclo while.

Basicamente la diferencia está en la condición del ciclo. Antes iteraba "mientras que i sea menor o igual que n". Ahora itera "hasta que i sea mayor que n".

problema1.4v2.pas

   1:
   2:var i,n: integer;
   3:begin
   4:   write('Ingrese un valor: ');
   5:   readln(n);
   6:   i:=1;
   7:
   8:   repeat
   9:      writeln(i);
  10:      i:=i+1;
  11:   until( i>n );
  12:end.
  13:

Ciclo for.

Este es otro ciclo iterativo de 0 a n iteraciones. Se representa así:

El ciclo for funciona con una variable de control (en el gráfico es la variable i) que toma un valor inicial (h) y un valor final (t). La variable de control se incrementa automaticamente en cada iteración tomando el valor h en la primer iteración, h+1 en la segunda y t en la última. Así, el ciclo dará exactamente t-h+1 iteraciones.

Como vemos en el gráfico tenemos dos opciones para representarlo. Podemos utilizar cualquiera de las dos.

Veamos como lo aplicamos en el problema 1.4

Vemos que en este caso el uso de un ciclo for simplifica la solución del problema. Simplemente leemos el valor n y luego entramos en un ciclo for con la variable i incrementándose desde 1 hasta n.

Dentro del ciclo solo tenemos que mostrar el valor de i. Ya no es necesario incrementarla porque el mismo ciclo la incrementa automaticamente.

problema1.4v3.pas

   1:
   2:var i,n: integer;
   3:begin
   4:   write('Ingrese un valor: ');
   5:   readln(n);
   6:   for i:=1 to n do begin
   7:      writeln(i);
   8:   end;
   9:end.
  10:

Contadores y Acumuladores

Para explicar estos temas analizaremos el siguiente problema.


Problema 1.5
Leer un conjunto de valores que corresponden a las edades de un grupo de personas, indicar:

a - Cuantas personas (sus edades) se ingresaron.
b - Cuantas son mayores de edad (21 años o más).
c - Edad promedio de las personas.

El conjunto de valores finaliza cuando se ingresa una edad menor que cero.

Análisis
La estructura principal de este algoritmo consiste en un ciclo repetitivo que itera mientras la edad leida (e) sea mayor o igual que cero (ya que se ingresará un valor negativo para indicar el fin de datos). Se lee la edad antes de ingresar al while y antes de cerrarlo.

Para calcular cuantas personas se ingresaron (punto a) utilizamos la variable cantPersonas. Esta variable se inicializa con cero (cantPersonas:=0) antes de ingresar al while, y dentro del while (por cada iteración) la incrementamos asignándole el valor que tenía más 1. (cantPersonas:=cantPersonas+1).

La variable cantPersonas incrementa su valor en 1 por cada iteración del while. A su vez, el while itera tantas veces como edades válidas de personas se ingresen. Decimos entonces que cantPersonas es un contador que cuenta (en este caso) la cantidad de personas cuyas edades se ingresaron. O bien: cantPersonas es el contador de personas.

Es muy importante notar que el contador debe inicializarse en cero ya que para incrementar su valor hacemos referencia al valor que tenía más 1. En el momento inicial (primera iteración) debe valer cero.

Para calcular cuantas personas son mayores de 21 años (punto b) utilizamos otro contador (mayores) solo que antes de incrementarlo preguntamos si la edad leida es mayor o igual que 21.

Para calcular el promedio de las edades grupo (punto c) necesitamos dos datos: la cantidad de edades ingresadas y la sumatoria de las edades. La cantidad de edades ingresadas ya la tenemos en la variable cantPersonas. Por lo tanto necesitamos obtener la sumatoria de las edades. Para esto utilizamos un acumulador.

A la variable sumEdades (que inicializamos en cero) le incrementamos su valor en cada iteración del while. Pero no lo incrementamos en 1. Le asignamos lo que tenía más el valor de la variable e (la edad).

Decimos entonces que sumEdades es un acumulador que acumula (en este caso) las edades leidas. O simplemente: sumEdades es el acumulador de edades.

Al finalizar el while tenemos en cantPersonas la cantidad de personas del conjunto, en mayores la cantidad de personas mayores de 21. Luego a edadProm le asignamos sumEdades/cantPersonas para calcular la edad promedio del conjunto.

problema1.5.pas

   1:
   2:var e,mayores,cantPersonas, sumEdades:integer;
   3:    edadProm:real;
   4:begin
   5:   mayores:=0;
   6:   cantPersonas:=0;
   7:   sumEdades:=0;
   8:
   9:   write('Ingrese Edad:');
  10:   readln(e);
  11:
  12:   while( e >= 0 ) do begin
  13:      // contador de edades ingresadas
  14:      cantPersonas:=cantPersonas+1;
  15:
  16:      // acumulador de edades
  17:      sumEdades:=sumEdades+e;
  18:
  19:      if( e >= 21 ) then begin
  20:         mayores:=mayores+1;
  21:      end;
  22:
  23:      write('Ingrese Edad:');
  24:      readln(e);
  25:   end;
  26:
  27:   edadProm:=sumEdades/cantPersonas;
  28:   writeln('Cantidad de Personas: ',cantPersonas);
  29:   writeln('Mayores de 21: ',mayores);
  30:   writeln('Edad Promedio: ',edadProm);
  31:end.
  32:

Resumiendo, decimos que una variable es un contador cuando incrementamos su valor en una unidad.

cont:=cont+1

Decimos que una variable es un acumulador cuando incrementamos su valor en una cantidad variable.

acum:=acum+n

donde n es una variable cuyo valor puede variar.


Nomenclatura

Pascal es un lenguaje de programación "insensible" a las mayúsculas y minúsculas por lo tanto podemos escribir código Pascal en mayúscula, en minúscula o con combinaciones de mayúsculas y minúsculas.

Las variables (o identificadores) también son "insensibles" por lo que la variable a es la misma que la variable A. La variable fechanacimiento es la misma que FECHANACIMIENTO y la misma que fechaNacimiento.

Sin embargo en este trabajo utilizaremos la siguiente convensión de nomenclatura:

Todas las palabras reservadas de Pascal (while, for, repeat-until, if, etc) las escribiremos en minúscula.

Todos los nombres de variables deben comenzar con minúscula. Si el nombre de la variable está compuesto por más de una palabra entonces la primer inicial irá en minúscula pero las iniciales siguientes deben ir en mayúscula.

Por ejemplo:

• fechaNacimiento
• fecNac
• nomPersona
• edad
• legajo
• legajoEmpleado

.
Algoritmos y Estructuras de Datos UTN - UBA.