20-ago-2011
ca0z
Baneado ;(
Aprende a Programar Facil
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.

--------------------------------------------------------------------------------------------------------------------------

Definición de procedimiento
...

Un procedimiento es un grupo de sentencias que realizan una tarea concreta. En lugar de reescribir el código completo de esa tarea cada vez que se necesite, unicamente se hace una referencia al procedimiento.

Por ejemplo, es muy común que se quiera visualizar un título determinado varias veces en un programa, para evitar teclear ese título en nuestro programa fuente todas las veces que sea necesario creamos un procedimiento llamado "Titulo" que se encargará de escribirlo.

Una vez creado un procedimiento actuará como una instrucción más de Turbo Pascal, y para ejecutarlo unicamente teclearemos el nombre de dicho procedimiento.

Para poder ejecutar un procedimiento es necesario declararlo en el programa que se este utilizando.


Creación de los procedimientos

El primer paso para crear un procedimiento es saber que queremos que haga. Una vez definiendo este punto declaramos el procedimiento despues de haber declarado variables y constantes, antes del cuerpo del programa principal. La palabra reservada para su declaración es Procedure seguida del nombre del procedimiento. Vamos a crear un procedimiento encargado de escribir en pantalla el enunciado "Programa de Turbo Pascal":

PROCEDURE Titulo;
BEGIN
WriteLn ('Programa de Turbo Pascal');
END;


Uso de los procedimientos

Una vez declarado el procedimiento es posible utilizarlo como una instrucción de Turbo Pascal. Al uso de un procedimiento se le conoce como llamada al procedimiento.

El siguiente programa ilustra el uso o la llamada al procedimiento creado anteriormente:

PROGRAM Procedimientos;

PROCEDURE Titulo;
BEGIN
WriteLn ('Programa de Turbo Pascal');
END;


BEGIN
WriteLn ('Programa ejemplo del uso de procedimientos');
Titulo;
{Llama al procedimiento}
WriteLn;
Titulo;
{Vuelve a llamar al procedimiento}
END;
Variables locales y globales


En Turbo Pascal cada identificador tiene un campo de acción, solo dentro de éste campo es posible utilizarlo. Los ejemplos más claros son las variables, que pueden ser globales o locales. La diferencia estriba en que una variable global puede ser utilizada por cualquier parte del programa, incluyendo a todos los procedimientos, en cambio una variable local puede ser utilizada unicamente por el procedimiento en el que esta declarada, el programa principal y los otros procedimientos la toman como inexistente. Ejemplo:

PROGRAM Variables;
VAR
Hola : String;

PROCEDURE prueba;
VAR
Adios : String;
BEGIN
{En esta sección si es posible usar la variable Hola}
Adios := 'Adios, que les vaya bien';
WriteLn (Adios);
END;

BEGIN
{En esta sección no se reconoce a la variable Adios}
Hola := 'Hola, bienvenidos al programa';
WriteLn (Hola);
WriteLn (Adios);
{Al compilar el programa se generará un error ya que la variable Adios es inexistente en esta sección, para eliminar el problema quites esta linea}
prueba;
END.

Es posible darle el mismo nombre a una variable local y a una global en el mismo programa, pero entonces el procedimiento no podrá utilizar la variable global ya que le da preferencia a las locales sobre las globales. Por ejemplo:

PROGRAM Variables_2;
VAR
Saludo : String;

PROCEDURE Mensaje;
VAR
Saludo : String;
BEGIN
Saludo := 'Este mensaje solo es válido para el procedimiento "Mensaje"';
WriteLn('Saludo');
END;

BEGIN
Saludo := 'Primer saludo (Global)';
WriteLn (Saludo);
Mensaje;
WriteLn (Saludo); {Se escribirá el mensaje "Primer saludo"}
END.
Parámetros


Para poder pasar información entre el programa principal y procedimientos, o entre los mismos procedimientos usamos los parámetros, que son los canales de comunicación de datos.

Los parámetros son opcionales y si no se necesitan no se deben usar. Para utilizarlos es necesario declararlos son la siguiente sintaxis:

PROCEDURE nombre (lista de parámetros);

La lista de parámetros esta compuesta de los nombres de los mismos y del tipo de datos que representan, los del mismo tipo se separan con comas "," y cada tipo diferente se separa con punto y coma ";". Ejemplo:

Procedure Ejemplo(a, b : Integer; c, d : String);

Para llamar a un procedimiento que utiliza parámetros se pueden utilizar como tales otras variables o constantes, siempre y cuando sean del mismo tipo que los declarados. Ejemplo:

Ejemplo(1, 2, 'Hola', 'Adios');

Ejemplo de un programa con procedimiento que utiliza un parámetro.

PROGRAM Parametros;
VAR
Saludo : String;

PROCEDURE Imprime_5 (a : String);
VAR
Contador : Integer;
BEGIN
FOR contador := 1 to 5 DO
{Imprime 5 veces la cadena almacenada }
WriteLn(a);
{en la variable "a", que es la información}
END;
{que llega como parámetro }

BEGIN
Saludo := 'Bienvenidos al programa';
Imprime_5 (Saludo);
{llama al procedimiento Imprime_5, usando como}
{parámetro la variable Saludo }
Imprime_5 ('Fin');
{Utiliza la cadena "fin" como parámetro }
END.

Es válido crear un procedimiento que llame a otro procedimiento siempre y cuando el procedimiento llamado haya sido declarado antes del que lo usará.

Definición de las funciones...

Las funciones son, al igual que los procedimientos, un conjunto de sentencias que se ejecutan constantemente, la diferencia entre éstas y los procedimientos es que las funciones regresan un valor. La declaración de las funciones se realiza de la siguiente forma:

FUNCTION nombre(parámetros) : tipo_de_datos;

A continuación se escribe el contenido de la función como una sentencia normal (sencilla o compuesta), normalmente terminando con la igualación de la función al valor que regresará. Ejemplo:

FUNCTION Promedio (a, b : Real) : Real; {Promedio de dos números reales}
BEGIN
Promedio := (a + b) / 2;
END;
Uso de las funciones


Como las funciones devuelven un valor específico la forma más usual de utilizarlas es por medio de asignaciones de una variable a la función. Ejemplo:

PROGRAM Funciones;
VAR
X, Y, Z : Real;

FUNCTION Promedio (a, b : Real) : Real;
{Promedio de dos números reales}
BEGIN
Promedio := (a + b) / 2;
END;

BEGIN
X := 5.89;
Y := 9.23;
Z := Promedio (X, Y);
{Iguala Z al valor devuelto por la función Promedio}
WriteLn('El promedio de ',X,' y ',Y,' es: ',Z);
END.
Procedimieto HALT


El procedimiento HALT ya se habia revisado anteriormente, pero se tomó como una instrucción, siendo que es realmente un procedimiento predefinido de Turbo Pascal que nos permite terminar nuestro programa en cualquier punto del mismo.

El procedimiento EXIT provoca la salida del procedimiento que se está ejecutando y nos regresa al lugar de donde fue llamado.

Procedimientos INC y DEC

El procedimiento INC incrementa en 1 el contenido de cualquier variable de tipo entero, es lo mismo en un programa teclear:

Variable := Variable + 1;

o telcear:

Inc(Variable);

El procedimiento DEC decrementa en 1 el valor de cualquier variable de tipo entero que se le indique, se usa igual que INC:

DEC (Variable);

--------------------------------------------------------------------------------------------------------------------------



Problemas Resueltos:


--------------------------------------------------------------------------------------------------------------------------

☺Escribir un programa en Pascal que sume dos números:

a = 4 b = 3

PROGRAM EJER01;
var a,b,c:INTEGER;

BEGIN

{Empezamos con lo básico, un programa que escribe la suma de 2 numeros en pantalla}

a:=4;
b:=3;

{Se asigna un valor cualquiera a las variables "a" y "b"}

c:=a+b;

WRITE (c); {Muestra en pantalla el valor de la suma}
END.


PROGRAM EJER1B;
USES CRT; {Lo usamos para poder borrar la pantalla}
VAR a,b,c:INTEGER;

BEGIN
ClrScr; {Limpiamos la pantalla}

WRITELN ('Este programa suma dos numeros:');
WRITELN (' ');
WRITE ('Introduzca un numero: '); READLN (a);
WRITE ('Introduzca otro numero: ' ); READLN (b);
WRITELN (' ');
c:=a+b;

WRITE ('EL RESULTADO ES: ');
WRITE (c);

END.


☺Escribir un programa en Pascal que sume, reste, multiplique y divida dos números:

--------------------------------------------------------------------------------------------------------------------------

x = 10 y = 2

PROGRAM EJER02;
USES CRT; {Nos va a permitir limpiar la pantalla junto con ClrScr}
VAR x,y:INTEGER;
VAR suma,rest,mult,divi:INTEGER;


BEGIN
x:=10;
y:=2;

suma:=x + y;
rest:=x - y;
mult:=x * y;
divi:=x div y;

{Con estas 4 variables realizamos las cuatro operaciones aritméticas fundamentales: suma, resta, multiplicación y división}

ClrScr; {Limpia la pantalla}

WRITE ('SUMA:'); WRITELN (suma);
WRITE ('RESTA:'); WRITELN (rest);
WRITE ('MULTIPLICACION:'); WRITELN (mult);
WRITE ('DIVISION:'); WRITE (divi);

END.


PROGRAM EJER2B;
USES CRT;
VAR x,y:REAL;
VAR suma,rest,mult:REAL;
VAR divi:REAL;

{suma, resta, multiplica y divide 2 numeros reales}

BEGIN
WRITELN ('Este programa suma, resta, multiplica y divide:');
WRITELN ('Escriba dos numeros reales');
WRITELN (' ');


Read(x);
Read(y);

suma:=x + y;
rest:=x - y;
mult:=x * y;
divi:=x / y;

ClrScr;

WRITE ('SUMA:'); WRITELN (suma:3:0);
WRITE ('RESTA:'); WRITELN (rest:3:0);
WRITE ('MULTIPLICACION:'); WRITELN (mult:3:0);
WRITE ('DIVISION:'); WRITE (divi:5:2);

END.


PROGRAM EJER02;
USES CRT;
VAR x,y:INTEGER;
VAR suma,rest,mult,divi:INTEGER;
BEGIN
x:=10;
y:=2;

suma:=x + y;
rest:=x - y;
mult:=x * y;
divi:=x div y;

ClrScr;

WRITE('SUMA:'); WRITELN(suma);
WRITE('RESTA:'); WRITELN(rest);
WRITE('MULTIPLICACION:'); WRITELN(mult);
WRITE('DIVISION:'); WRITELN(divi);
END.


☺Escribir un programa en Pascal que calcule el área de un rectángulo:

--------------------------------------------------------------------------------------------------------------------------

lado1 = 3 lado2 = 4
área del rectángulo=lado1 * lado2

PROGRAM EJER03;
USES CRT;
VAR lado1,lado2:INTEGER;
VAR area:INTEGER;

BEGIN

{Este programa nos va a servir para calcular el area de un rectángulo}

{Damos valores para las variables}
lado1:=3;
lado2:=4;

area:=lado1*lado2; {Calculamos el area}

ClrScr;

WRITE ('AREA DEL RECTANGULO: '); WRITE (area); {Lo mostramos en pantalla}
END.



PROGRAM EJER3B;
USES CRT;
VAR lado1,lado2:REAL;
VAR area:REAL;

BEGIN
{Este programa calcula el area de un rectangulo}

ClrScr;

WRITELN ('Escriba los lados del rectangulo');

Read(lado1);
Read(lado2);
WRITELN (' ');

area:=lado1*lado2;

WRITE ('AREA DEL RECTANGULO:'); WRITE (area:5:2);
END.


☺Escribir un programa en Pascal que calcule el área de un triángulo:

--------------------------------------------------------------------------------------------------------------------------

base = 7 altura = 4 área del triángulo = (base * altura)/2


PROGRAM EJER04;
USES CRT;
VAR base,altura:REAL;
VAR area:REAL;
BEGIN
base:=7;
altura:=4;

area:=(base * altura) / 2;

ClrScr;

WRITE ('AREA DEL TRIANGULO: '); WRITE (area:5:2);
{:5:2 sirve para dar el formato de salida al numero, 5 posiciones y 2 decimales}
END.


PROGRAM EJER4B;
USES CRT;
VAR base,altura:REAL;
VAR area:REAL;
BEGIN
{Este programa sirve para calcular el area de un triangulo}

ClrScr;
WRITELN ('PARA CALCULAR EL AREA DE UN TRIANGULO:');
WRITELN (' ');
WRITE ('ESCRIBE LA BASE: '); READLN (base);
WRITE ('ESCRIBE LA ALTURA: '); READLN (altura);
WRITELN (' ');

area:=(base * altura) / 2;

WRITE ('EL AREA DEL TRIANGULO ES: '); WRITE (area:5:2);
END.


☺Escribir un programa que calcule la longitud y el área de una circunferencia:

--------------------------------------------------------------------------------------------------------------------------

radio = 4 longitud de la circunferencia = 2 * PI * radio
área de la circunferencia = PI * radio2

PROGRAM EJER05;
USES CRT;
VAR radio:REAL;
VAR longitud,area:REAL;

BEGIN
radio:=4;
longitud:=2*3.1416*radio;

area:=3.1416*radio*radio;

ClrScr;

WRITE ('LONGITUD DE LA CIRCUNFERENCIA:'); WRITELN (longitud:5:2);
WRITE ('AREA DE LA CIRCUNFERENCIA:'); WRITE (area:5:2);
END.

--------------------------------------------------------------------------------------------------------------------------


☺Escribir un programa en Pascal que calcule la velocidad de un proyectil que recorre 2 Km en 5 minutos. Expresar el resultado en metros/segundo.

Velocidad = espacio/tiempo

PROGRAM EJER06;
USES CRT;
VAR espacio,tiempo:REAL;
VAR velocidad:REAL;

BEGIN
espacio:=2;
tiempo:=5;

velocidad:=(espacio*1000)/(tiempo*60);

ClrScr;

WRITE ('VELOCIDAD DEL PROYECTIL:');
WRITE (velocidad:5:2); WRITE ('m/s');
END.


PROGRAM EJER6B;
USES CRT;
VAR espacio,tiempo,espacio2,tiempo2:REAL;
VAR velocidad,velocidad2:REAL;
BEGIN
{Este programa calcula la velocidad de un cuerpo}

ClrScr;

WRITE ('Para calcular la velocidad debe escribirlo en unidades ');
WRITE ('del sistema internacional');
WRITELN (' ');
WRITE ('Escriba el espacio recorrido: '); READLN (espacio);
WRITE ('Escriba el tiempo transcurrido: '); READLN (tiempo);
WRITELN (' ');

velocidad:=(espacio)/(tiempo);

WRITE ('VELOCIDAD DEL PROYECTIL: ');
WRITE (velocidad:5:2); WRITELN (' m/s');

WRITELN (' ');
WRITELN ('Si lo desea en Km/h introduzca los datos: ');
WRITELN (' ');
WRITE ('Escriba el espacio recorrido: '); READLN (espacio2);
WRITE ('Escriba el tiempo transcurrido: '); READLN (tiempo2);
WRITELN (' ');

velocidad2:=(espacio2)/(tiempo2);

WRITE (velocidad2:5:2); WRITE (' Km/h ');
END.


PROGRAM EJER06;
USES CRT;
VAR espacio,tiempo:REAL;
VAR velocidad:REAL;

BEGIN
espacio:=2;
tiempo:=5;

velocidad:=(espacio*1000)/(tiempo*60);

ClrScr;

WRITE('VELOCIDAD DEL PROYECTIL:');
WRITE(velocidad:5:2); WRITE(' m/s');
END.


--------------------------------------------------------------------------------------------------------------------------

☺Escribir un programa en Pascal que calcule el volumen de una esfera:

radio = 3 volumen de la esfera = 4/3 * PI * radio3

PROGRAM EJER07;
USES CRT;
VAR radio:REAL;
VAR volumen:REAL;
BEGIN
radio:=3;
volumen:=(4/3)*3.1416*(radio*radio*radio);

ClrScr;

WRITE ('VOLUMEN DE LA ESFERA:'); WRITE(volumen);
END.


PROGRAM EJER7B;
USES CRT;
VAR radio:REAL;
VAR volumen:REAL;
BEGIN
{Este programa calcula el volumen de una esfera}

ClrScr;

WRITELN ('PARA CALCULAR EL VOLUMEN DE LA ESFERA ESCRIBA EL RADIO: ');
READLN (radio);

volumen:=(4/3)*3.1416*(radio*radio*radio);

WRITE ('VOLUMEN DE LA ESFERA: '); WRITE(volumen:5:2);
END.


PROGRAM EJER07;
USES CRT;
VAR radio:REAL;
VAR volumen:REAL;
BEGIN
radio:=3;

volumen:=(4/3)*3.1416*(radio*radio*radio);

ClrScr;

WRITE('VOLUMEN DE LA ESFERA: '); WRITE(volumen);
END.


--------------------------------------------------------------------------------------------------------------------------

☺Escribir un programa en Pascal que evalúe la siguiente expresión:

(a+7*c)/(b+2-a)+2*b a = 3,b = 6,c = 4

PROGRAM EJER08;
USES CRT;
VAR a,b,c:REAL;
VAR resultado:REAL;
BEGIN
a:=3;
b:=6;
c:=4;

resultado:=(a+7*c)/(b+2-a)+2*b;

ClrScr;

WRITE ('RESULTADO:'); WRITE (resultado:5);
END.

PROGRAM EJER8B;
USES CRT;
VAR a,b,c:REAL;
VAR resultado:REAL;

BEGIN
{Este programa calcula una expresion algebraica}

ClrScr;

WRITELN ('Este programa sirve para calcular la siguiente expresion:');
WRITELN ('(a+7*c)/(b+2-a)+2*b');
WRITELN (' ');
WRITE ('Introduzca a: '); READLN (a);
WRITE ('Introduzca b: '); READLN (b);
WRITE ('Introduzca c: '); READLN (c);

resultado:=(a+7*c)/(b+2-a)+2*b;
WRITELN (' ');
WRITE ('RESULTADO: '); WRITE (resultado:5:2);

END.


PROGRAM EJER08;
USES CRT;
VAR a,b,c:REAL;
VAR resultado:REAL;
BEGIN
a:=3;
b:=6;
c:=4;

resultado:=(a+7*c)/(b+2-a)+2*b;

ClrScr;

WRITE('RESULTADO: '); WRITE(resultado:5);
END.

--------------------------------------------------------------------------------------------------------------------------

☺Escribir un programa en Pascal que evalúe la siguiente expresión:


(a+7*c)/(b+2-a)+2*b a = 3,b = 6,c = 4

PROGRAM EJER08;
USES CRT;
VAR a,b,c:REAL;
VAR resultado:REAL;
BEGIN
a:=3;
b:=6;
c:=4;

resultado:=(a+7*c)/(b+2-a)+2*b;

ClrScr;

WRITE ('RESULTADO:'); WRITE (resultado:5);
END.

PROGRAM EJER8B;
USES CRT;
VAR a,b,c:REAL;
VAR resultado:REAL;

BEGIN
{Este programa calcula una expresion algebraica}

ClrScr;

WRITELN ('Este programa sirve para calcular la siguiente expresion:');
WRITELN ('(a+7*c)/(b+2-a)+2*b');
WRITELN (' ');
WRITE ('Introduzca a: '); READLN (a);
WRITE ('Introduzca b: '); READLN (b);
WRITE ('Introduzca c: '); READLN (c);

resultado:=(a+7*c)/(b+2-a)+2*b;
WRITELN (' ');
WRITE ('RESULTADO: '); WRITE (resultado:5:2);

END.


PROGRAM EJER08;
USES CRT;
VAR a,b,c:REAL;
VAR resultado:REAL;
BEGIN
a:=3;
b:=6;
c:=4;

resultado:=(a+7*c)/(b+2-a)+2*b;

ClrScr;

WRITE('RESULTADO: '); WRITE(resultado:5);
END.

--------------------------------------------------------------------------------------------------------------------------

☺Escribir un programa en Pascal que evalúe la siguiente expresión:


(a+5) * 3 / 2 * b - b a = 3,b = 6

PROGRAM EJER09;
USES CRT;
VAR a,b:REAL;
VAR resultado:REAL;

BEGIN
a:=3;
b:=6;

resultado:=((a+5)*3) / (2*b-b);

ClrScr;

WRITE ('RESULTADO: '); WRITE(resultado:5:2);
END.


PROGRAM EJER9B;
USES CRT;
VAR a,b:REAL;
VAR resultado:REAL;

BEGIN
{Este programa calcula el resultado de una expresion algebraica}

ClrScr;

WRITE ('PARA CALCULAR LA SIGUIENTE EXPRESION: ');
WRITELN ('((a+5)*3) / (2*b-b)');
WRITELN (' ');
WRITE ('Escriba a: '); READ (a);
WRITE ('Escriba b: '); READ (b);
WRITELN (' ');

resultado:=((a+5)*3) / (2*b-b);

WRITE ('RESULTADO: '); WRITE(resultado:5:2);
END.

--------------------------------------------------------------------------------------------------------------------------

☺Escribir un programa en Pascal que evalúe la siguiente expresión:

(-b + √(b2-4*a*c)/(2*a)
(es la solución positiva de una ecuación de 2º grado)

PROGRAM EJER10;
USES CRT;
VAR a,b,c:REAL;
VAR resultado:REAL;

BEGIN
a:=6;
b:=6;
c:=1;

resultado:=(-b+sqrt(sqr (b) - 4*a*c))/(2*a);

ClrScr;

WRITE ('RESULTADO:'); WRITE(resultado:5:2);
END.



PROGRAM EJER10B;
USES CRT;
VAR a,b,c:REAL;
VAR resultado:REAL;

BEGIN
{Calcula la incognita positiva de una ecuacion de 2º grado}

ClrScr;

WRITE ('Para calcular la incognita positiva de una ecuacion');
WRITE (' de segundo grado escriba todas las variables:');
WRITELN (' ');
WRITELN (' ');

WRITE ('Escriba a: '); READLN (a);
WRITE ('Escriba b; '); READLN (b);
WRITE ('Escriba c; '); READLN (c);
WRITELN (' ');

resultado:=(-b +sqrt(sqr (b) - 4*a*c))/(2*a);

WRITE ('RESULTADO: '); WRITE(resultado:5:2);

END.

--------------------------------------------------------------------------------------------------------------------------

☺Escribir un programa en Pascal que calcule el área y el volumen de un cilindro:

A = (2 * (PI * r2)) + ((2 * PI * r) * h)
V = (PI * r2) * h

PROGRAM EJER11;
USES CRT;
VAR radio,altura:REAL;
VAR area,volumen:REAL;

BEGIN
radio:=3;
altura:=6;

area:= (2 * (3.1416 * radio * radio)) + ((2 * 3.1416 * radio) * altura);
volumen:= (3.1416 * radio * radio) * altura;

{podriamos cambiar "radio*radio" por "sqr(radio)" para hacer el cuadrado del radio}

ClrScr;

WRITE ('AREA DEL CILINDRO:'); WRITE (area); WRITELN (' m2');
WRITE ('VOLUMEN DEL CILINDRO:'); WRITE (volumen); WRITE (' m3');
END.


PROGRAM EJER11B;
USES CRT;
VAR radio,altura:REAL;
VAR area,volumen:REAL;

BEGIN
{Calcula el area y el volumen de un cilindro}

ClrScr;

WRITELN ('CALCULA EL AREA Y VOLUMEN DE UN CILINDRO');
WRITELN (' ');

WRITE ('Escriba el radio: '); READLN (radio);
WRITE ('Escriba la altura: '); READLN (altura);
WRITELN (' ');

area:= (2 * (3.1416 * radio * radio)) + ((2 * 3.1416 * radio) * altura);
volumen:= (3.1416 * radio * radio) * altura;

WRITE ('AREA DEL CILINDRO: '); WRITE (area:5:2); WRITELN (' m2');
WRITE ('VOLUMEN DEL CILINDRO: '); WRITE (volumen:5:2); WRITE (' m3');
END.


PROGRAM EJER11;
USES CRT;
VAR r,h:REAL;
VAR a,v:REAL;
BEGIN

{AREA Y VOLUMEN DE UN CILINDRO}

ClrScr;

WRITE('RADIO DEL CILINDRO: '); READLN(r);
WRITE('ALTURA DEL CILINDRO: '); READLN(h);

a:=(2*(3.1416*sqr(r))) + ((2*3.1416*r)*h);
v:=(3.1416*sqr(2))*h;

ClrScr;

WRITE('AREA DEL CILINDRO: '); WRITELN(a:5:2);
WRITE('VOLUMEN DEL CILINDRO: '); WRITELN(v:5:2);
END.

--------------------------------------------------------------------------------------------------------------------------


Lista de Operadores usados en Pascal




_____________________ Barra Separadora Barata _____________________



_____________________ Barra Separadora Barata _____________________




_____________________ Barra Separadora Barata _____________________




_____________________ Barra Separadora Barata _____________________



_____________________ Barra Separadora Barata _____________________



_____________________ Barra Separadora Barata _____________________




_____________________ Barra Separadora Barata _____________________




_____________________ Barra Separadora Barata _____________________



_____________________ Barra Separadora Barata _____________________



_____________________ Barra Separadora Barata _____________________




_____________________ Barra Separadora Barata _____________________



_____________________ Barra Separadora Barata _____________________




_____________________ Barra Separadora Barata _____________________



_____________________ Barra Separadora Barata _____________________



_____________________ Barra Separadora Barata _____________________



_____________________ Barra Separadora Barata _____________________



_____________________ Barra Separadora Barata _____________________




_____________________ Barra Separadora Barata _____________________



Bueno, a continuacon dejo algunos videos que pueden ayudar a entender un poco mas este lenguaje de programacion:







link: http://www.youtube.com/watch?v=JoF5rfzzo_o





link: http://www.youtube.com/watch?v=tsDfG...eature=related






link: http://www.youtube.com/watch?v=R0HXd...eature=related





link: http://www.youtube.com/watch?v=gq723...eature=related





link: http://www.youtube.com/watch?v=LihWE...eature=related





link: http://www.youtube.com/watch?v=iqUfB...eature=related





link: http://www.youtube.com/watch?v=NnmZQ...eature=related





link: http://www.youtube.com/watch?v=F1ohJ...eature=related





link: http://www.youtube.com/watch?v=-JA4P...eature=related





link: http://www.youtube.com/watch?v=1G2yC...eature=related


Bueno gente, espero que les sirva, mas a los que se estan iniciando en la programacion, creo este material les viene de pelos, comenten, acepto criticas constructivas, siempre y cuando sean con respeto

Aprende a Programar Facil


21-ago-2011
Ale Magno
Helper
Re: Aprende a Programar Facil
Gracias por el aporte
22-ago-2011
snjorge72
Premium User
Re: Aprende a Programar Facil
¿.....?

Necesitás estar Registrado para dejar comentarios en Aprende a Programar Facil

Información del Post