Programación en Pascal

"SI MANEJAS UN LENGUAJE DE PROGRAMACION, ENTONCES LOS MANEJAS A

TODOS"

Bueno, este es un material con todos los conceptos basicos acerca

del lenguaje y de la manera de programar en Pascal, espero que les
sirva…

Aclaro que este es un material para principiantes, con todos los

conceptos basicos...sirven y ayudan muchisimo para la gente que
esta empezando a programar o que esta estudiando alguna carrera
que involucre la programacion...Mucha suerte gente y miles de
exitos!!!

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.

----------------------------------------
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.