Manual de Pascal

Programacin estructurada en Pascal
ENTREGA NUMERO 1
MANUAL DE PROGRAMACIN BSICA
LENGUA1E DE PROGRAMACIN
PASCAL
Vladimir Rodrguez 1
Vladimir Rodrguez 2
PRIMERA PARTE
Conceptos bsicos de programacin
Vladimir Rodrguez 3
Introduccin:
Existe un gran nmero de personas que escriben a foros y blogs en la WE en la bsqueda de distintos
manuales o tutoriales que ense!en a programar desde cero" o sea" que alguien que no sepa nada en absoluto sobre la
programaci#n sea capas de aprender con solo leer$ En efecto" eso es posible y es a lo que apunta este tutorial$
%eben saber que la base para ser un buen programador es la pr&ctica$ %eber&n traba'ar muc(o y realizar
muc(os programas" por m&s tontos e inser)ibles que parezcan" cada )ez que aprendan un concepto nue)o$
Encontrar&n )arios e'ercicios en este tutorial que les ayudar&n a solidificar lo que (ayan aprendido (asta el momento$
*uiero reafirmar la importancia de la pr&ctica$ +os lengua'es de programaci#n tienen reglas muy estructuradas
sobre sintaxis y sem&ntica as como tambi,n muc(as palabras que uno debe ir aprendiendo y comprendiendo en
profundidad$ -ambi,n est& el (ec(o de que uno debe desarrollar una forma de pensar y analizar los problemas
demasiado l#gica para lograr resol)erlos creando programas de computadora$
.!adir, tambi,n que el gran conocimiento de matem&tica facilitar& muc(o el desarrollo de soft/are" pero sin
embargo" si no se entienden demasiado con esta materia podr&n aprender a programar" pero nunca ol)iden que la
matem&tica y la programaci#n est&n profundamente ligadas$
0na )ez (ayan ledo completamente este tutorial ser&n capaces de crear aplicaciones b&sicas en el lengua'e
1ascal" aunque estas podr&n tener una gran comple'idad$ El ob'eti)o de este texto no es que ustedes salgan
programando soft/are para )ender ni nada por el estilo" es que aprendan a programar de la nada" es introducirlos al
mundo de la programaci#n estructurada$ -eniendo estos conocimientos en mente" ustedes ser&n capaces de aprender
luego un lengua'e muc(o m&s moderno y comple'o con mayor facilidad que si lo intentaran a(ora" sin saber nada$
Espero que les sea de muc(a utilidad$ .nte cualquier duda o aporte que tengan pueden escribirme a mi casilla
de correo2 mstr)ladi3(otmail$com y les responder, en bre)e$ %esde ya muc(as gracias por leer este tutorial$
Vladimir Rodrguez 4
Nociones sobre Lenguaje de Programacin:
5upongo que cualquiera que se a)enture a leer este manual es porque sabe lo que es usar una computadora y
por ende" lo que es un programa de computadora" tambi,n conocido como aplicacin$ 5in embargo estoy seguro de
que a la mayora de las personas que 6saben7 lo que es un programa" si se les pidiera que le explicaran a alguien que
'am&s (a )isto una computadora" sin tener una enfrente" lo que es un programa no sabran como (acerlo$ En realidad
es muy sencillo de definir2 Un programa es un conjunto de instrucciones bien detalladas que la computadora seguir
al pie de la letra" nada m&s$ 0n programador es quien escribe ese con'unto de instrucciones que ser&n interpretadas y
seguidas por un procesador$
%ic(o as suena muy f&cil$ 0no escribe instrucciones que ser&n seguidas al pie de la letra por la computadora$
5in embargo este es el gran problema que (ace que uno como programador tenga que romperse la cabeza pensando
en como (acer que una computadora realice tal o cual acci#n y como tomar en cuenta todas las )ariantes que puede
(aber acerca de una misma situaci#n$
.(ora bien" si uno como programador (a de escribir instrucciones" 8c#mo lo (ace9
Es aqu donde entran en 'uego los lengua'es de programaci#n$ Existen de dos tipos2 Lenguajes de bajo nivel
y Lenguajes de alto nivel$ +os primeros se escriben en el )e'o y querido c#digo binario el cual est& constituido
nicamente por 0 y 1 y es lo nico que un procesador :;10< puede entender e interpretar$ -ambi,n se conocen como
lenguaje de mquina$ ;reo que todo el mundo est& de acuerdo en que programar as es una tortura" es in(umano y
sumamente tedioso y aburrido$ = pensar que en principio todo se (aca as y muc(as cosas an se (acen as$
>racias a la necesidad de poder crear aplicaciones de computadora de una forma m&s f&cil y entendible es que
nacen los +engua'es de .lto ?i)el" que se parecen m&s a los (ablados por los seres (umanos y por tanto son muc(o
m&s comprensibles para nosotros$ 5in embargo" como di'e antes" una ;10 solo entiende el lengua'e de m&quina y por
ende no uno de alto ni)el$ .qu entra en 'uego un programa muy especial2 el compilador$ 0n compilador es una
aplicaci#n que se encarga de 6traducir7 ese c#digo de alto ni)el parecido a un lengua'e (umano a lengua'e de
m&quina para que pueda ser interpretado por una 0nidad ;entral de 1roceso :;10<$ 8= entonces como se programa
un compilador9 ;omo )en" a )eces (ay que seguir luc(ando con el c#digo binario$
+engua'es de alto ni)el muy nombrados son2 ;" ;@@" ;As(arp" 1ascal" 1B1" Ca)a" B-D+" orland" Ruby"
entre muc(simos otros m&s$
%ado que lo escrito en el lengua'e de alto ni)el :c#digo fuente del programa< ser& luego traducido por un
compilador a E y 1" debe (acerse respetando una sintaxis y una sem&ntica bien establecidas" sin excepciones$
?osotros especficamente en este manual aprenderemos las nociones b&sicas de la programaci#n estructurada" c#mo
se estudia un problema dado y se comienza a crear el programa que lo resuel)e" entre muc(as otras cosas$ -odo lo
(aremos con el lengua'e 1ascal" que (oy en da solo es usado con fines acad,micos de aprendiza'e" y debo decir que
realmente funciona para ese fin$
Vladimir Rodrguez F
Instalando el ambiente de desarrollo Free-Pascal:
1ara traba'ar con 1ascal utilizaremos el compilador GreeA1ascal 2$2$2$ Este programa debe ser descargado
desde este enlace o desde la p&gina oficial de Gree 1ascal2
(ttp2HHsourceforge$netHpro'ectsHfreepascalHfilesHWin32H2$2$2HfpcA2$2$2$i3IJA/in32$exeHdo/nload$
0na )ez descargado el instalador e'ecutar el mismo y seguir los siguientes pasos2
?ota2 En las im&genes se obser)a la )ersi#n 2$E$2 y no la 2$2$2" sin embargo los pasos de instalaci#n son los
mismos$
1resionar en ?ext$
5eleccionar un directorio de instalaci#n$
Es recomendable aceptar el directorio que
aparece por defecto :C:\FPC\2.x.x<$
.pretar el bot#n ?ext$
En la siguiente )entana" se seleccionan los
componentes del compilador que )an a ser
instalados$ 5e recomienda seleccionar Full
Instalation$ En caso de que dispongan de
poco espacio en su disco duro" pueden
seleccionar Minimal Instalation
.pretar el bot#n ?ext
Vladimir Rodrguez J
?ext otra )ez$
.sociar todos los tipos de arc(i)os que ofrece" sobre
todo los que terminan con la extensi#n .pas y luego apretar el
bot#n ?ext$
1resionar en Knstall y esperar a que termine de instalar
todos los arc(i)os$ Esto a )eces puede tardar bastante a pesar
de que el copilador pesa muy poco$
.pretar el bot#n ?ext y luego en Ginis($
5i llegaron (asta aqu sin errores" el compilador qued# instalado$

Vladimir Rodrguez L
Verificando instalacin
.(ora debemos )erificar si el compilador qued# correctamente instalado$
+o que (aremos es e'ecutar el compilador desde la lnea de comandos de la siguiente manera2
El primer paso es reiniciar la computadora para que todas las modificaciones realizadas por el programa
instalador tengan efecto$ :Es posible que alcance con salir de la sesi#n y )ol)er a entrar<
.cceder al tem del men inicioM Inicio Ejecutar
Escribir
6cmd7 sin
comillas y
apretar la
tecla
ENTER.
En la consola escribir fpc y apretar la
tecla ENTER" como en la figura2
5i todo est& bien debera salir un mensa'e similar al siguiente2
1ara terminar presione enter )arias )eces (asta que termine de desplegar$
Vladimir Rodrguez I
5i en lugar del mensa'e anterior" aparece un mensa'e que indica que el comando fpc no es )&lido" significa que
algo andu)o mal en la instalaci#n$ 1ueden probar a reiniciar la computadora y )ol)er a realizar este paso de
)erificaci#n$ 5i siguen teniendo problemas" les recomiendo desinstalar el compilador y )ol)er a comenzar de nue)o la
instalaci#n$
5i probaron reinstalar y sigue sin funcionar este paso de )erificaci#n" ser& necesario realizar alguna
configuraci#n adicional" como les explico a continuaci#n2
En primer termino" )erifiquen la existencia de la carpeta C:\FPC\2.2.2\BIN\I386_WIN32$ 1ueden
(acerlo utilizando el explorador de Windo/s" accediendo por Mi PC" luego Disco X: :donde N es la unidad de disco
duro< y as sucesi)amente$ -ambi,n pueden )erificarlo por el siguiente comando en la consola %O52
dir C:\FPC\2.2.2\BIN\I386_WIN32
5i esa carpeta no existe" estamos en problemas$ +a instalaci#n no copi# los arc(i)os necesarios" quiz&s no
tengan los permisos requeridos para la instalaci#n$ Kntenten )ol)er a instalar$
5i la carpeta existe" )erifiquen que en la misma (ay un arc(i)o de nombre fpc.exe$ 5i este arc(i)o existe"
solamente (ay que decirle al sistema donde puede encontrarlo :se supone que la instalaci#n lo (ace autom&ticamente"
pero por alguna raz#n no funcion#<$ 1rocedan de la siguiente manera2
1$ .ccedan Mi Pc Panel de ontrol !istema
2$ 5eleccionen la pesta!a "#an$ado
3$ .ccionen el bot#n %ariables de entorno
4$ En la lista superior pulsen nue#a e ingresen estos )alores2
o nombre2 path
o )alor2 %path%;C:\FPC\2.2.2\BIN\I386_WIN32
F$ %ar aceptar en todas las )entanas$
Knsisto que el paso anterior no debera ser necesario" ya que el instalador se encarga de realizarlo" sin embargo
algunos usuarios (an reportado ese problema$
1or m&s informaci#n )er2 Knstalling under %O5 or Windo/s en el sitio de Gree 1ascal$
Corrigiendo un Bug y configurando para comenzar:
.l intentar compilar por primera )ez :ya )eremos como se (ace esto< el compilador indica un error illegal
parameter -Opentium3.
Este es un error que sorprende bastante ya que )iene por defecto" pero bueno" es as$ 1or suerte es bien sencillo de
solucionar$
.l abrir por primera )ez el ambiente de desarrollo K%E )allan al men
OptionsCompiler
En el cuadro de texto Aditional Compiler Args" cambiar -Opentium3
por -Oppentium3
Vladimir Rodrguez P
1ulsar el bot#n
OK
.cceder al men2
OptionsSave
+uego cerrar y
)ol)er a abrir el K%E$
;on esto queda
solucionado$ En caso de
presentar problemas con
esto en)enme un eAmail
a
mstr)ladi3(otmail$com
y les responder, en bre)e
para ayudarles a solucionarlo$
Configuracin de Range Checking e Integer Overflow:
Bace falta a!adir una ltima configuraci#n antes de comenzar a programar" y esta consta de (acer que el
compilador siempre (aga un c(equeo de que nuestros )alores no se )an fuera del rango que deben tener$ Esto lo
entender&n en m&s profundidad cuando comencemos a traba'ar con arreglos" pero es con)eniente tenerlo configurado
desde a(ora para e)itarse muc(os problemas$
%eben ir al men Options Compiler y all presionar sobre la pesta!a Generate Code$ En el
cuadro Code generation marcar&n las opciones Range checking e Integer overflow checking
tras lo cual dar&n OQ$

.(ora s" ya estamos listos para comenzar a programar$ RRR.delanteSSS
Vladimir Rodrguez 1E
NUESTRO PRIMER PROGRAMA: ~HOLA MUNDO!!!
.l abrir el ambiente de desarrollo K%E )emos una pantalla azul" realmente espantosa" pero es a la que nos
debemos acostumbrar si queremos aprender a programar de )erdad$ Existen compiladores m&s bonitos" pero no son
de licencia free y por tanto no los usaremos aqu$
1or defecto" la primera )ez que se abre el K%E lo (ace con una (o'a en blanco cuyo ttulo ser&
6noname&'.pas7$ El bot#n )erde en la esquina superior izquierda de la pantalla es para cerrar el arc(i)o actualmente
abierto" luego )eremos como traba'ar con )arios a la )ez$ +a flec(ita )erde en la esquina superior derec(a es para
maximizar y minimizar la )entana que contiene dic(o arc(i)o$ En el borde derec(o y tambi,n aba'o tenemos barras
de desplazamiento para mo)ernos a tra),s del c#digo que escribiremos$ .ba'o" a la izquierda de la barra de
desplazamiento )emos las coordenadas de nuestra posici#n2 fila:columna" o sea" d#nde est& nuestro cursor$
1ara cada e'emplo de programa escrito aqu analizaremos casi lnea por lnea lo que significa cada cosa para
que se entienda$ En principio uno se dedica a copiar programas (ec(os sin entender nada y poco a poco )a
aprendiendo (asta que se (ace capaz de crear los propios$ .(ora crearemos un programa muy simple que lo nico
que (ar& es imprimir en la pantalla el cl&sico texto ((()ola mundo***2
1 PROGRAM HolaMundo;
2
3 BEGIN
4 write(`Hola mundo!!!');
5 END.
5iempre la primera lnea de un programa debe comenzar con la palabra reser)ada 1RO>R.D :detallaremos
lo que significa que una palabra sea reser)ada m&s adelante< seguida por un nombre para el programa
:identificador<" en este caso HolaMundo$ +uego de eso debe ir un punto y coma :M< para finalizar la primera lnea$
+os puntos y comas funcionan como separadores y son los que indican que (a finalizado una sentencia
:instrucci#n<$ 5iempre luego de una instrucci#n )a un punto y coma para finalizarla$
En la segunda lnea no (emos escrito nada" esto es simplemente por una cuesti#n de legibilidad del c#digo$
En la tercera lnea indicamos que comienza el c#digo del programa mediante la palabra reser)ada E>K?$
Esto no es una sentencia" por lo cual no debe finalizar con punto y coma" solo indica que a partir de all estar&n las
instrucciones a seguir$
En la cuarta lnea indicamos al programa mediante el procedimiento write :que en ingl,s significa escribir<
que imprima en la pantalla el texto Hola mundo!!! 5iempre luego de un procedimiento write debe
colocarse entre par,ntesis lo que queremos escribir en la pantalla" en este caso un texto especfico$ 5iempre que
queramos que un texto aparezca en pantalla tal cual nosotros lo escribimos aqu debemos indicarlo colocando dic(o
texto entre comillas simples como se )e en el e'emplo$ ;omo write implica una instrucci#n" luego de finalizada
colocamos un punto y coma$ ?otar que dic(a instrucci#n la (emos colocado m&s (acia la derec(a que el resto del
c#digo$ Esto no afecta en nada al programa" al igual que en la segunda lnea que qued# )aca" sino que lo (ace m&s
legible$ . esta acci#n se la llama Kndentaci#n y es muy importante$ +uego detallaremos este aspecto al traba'ar con
programas comple'os y que lle)an un c#digo m&s largo$
+a quinta y ltima lnea indica la finalizaci#n del programa mediante la palabra reser)ada END seguida
inmediatamente por un punto :$<$ Esa es la nica palabra que terminar& con un punto indicando el fin de la aplicaci#n$
.(ora debemos compilar nuestro
programa$ 1ara ello pueden ir al men
Compile Compile o presionar Alt+F9$ 5e
les pedir& un nombre para el arc(i)o" el cual
no podr& contener espacios ni caracteres
especiales y debe terminar con la extensi#n
.pas$ +uego de eso comenzar&
inmediatamente el proceso de compilaci#n$ 5i
ustedes no (an tenido errores de sintaxis" o
sea" si (an respetado el lugar adecuado para
cada palabra reser)ada y no ol)idaron ningn
punto y coma o colocaron alguno donde no
iba" aparecer& un cartel con el mensa'e
Compile successful: Press any
key.
Esto (abr& creado un e'ecutable
:arc(i)o de extensi#n exe" dic(a extenci#n
pro)iene de la palabra 6e+ecutable7 que en
ingl,s significa ejecutable< en el mismo
directorio en el que (an guardado el arc(i)o
Vladimir Rodrguez 11
.pas$ 0n arc(i)o pas contiene el c#digo fuente que ustedes (an escrito$ 1or defecto el K%E guarda un arc(i)o en el
directorio X:\fpc\2.2.2\bin\i386-win32" pero ustedes pueden especificar cualquier otro$ Es con)eniente
que si (acen esto ninguna carpeta de su direcci#n posea m&s de oc(o caracteres como nombre ni tampoco caracteres
especiales o de espacio$
.(ora pueden abrir su arc(i)o e'ecutable (aciendo doble clic sobre ,l$ -ambi,n pueden e'ecutar su programa
mediante el men Run Run o presionando Ctrl+F9$ En este e'emplo especfico" como en muc(os otros que
)eremos" al correr su programa no llegar&n ni a leer el texto que aparece ya que se cerrar& inmediatamente$ Esto no es
ningn error" los programas que escribiremos finalizar&n luego de terminar sus instrucciones$ ;laro que
aprenderemos a crear aplicaciones donde uno puede seleccionar cuando salir$
5i lo e'ecutaron desde el K%E simplemente )allan al men Debug User screen o presionen
Alt+F5$ %e este modo )er&n lo que apareci# en la pantalla al e'ecutar el programa$ +uego presionen cualquier tecla
para )ol)er al K%E$ +a otra opci#n es e'ecutar su programa desde la lnea de comandos2 Kr a Inicio Ejecutar y
escriban cmd para abrir la lnea de comandos$ En ella deben escribir la direcci#n en la que est& el e'ecutable que (an
creado y escribir el nombre exacto del mismo" que ser& id,ntico al que ustedes usaron al guardar el arc(i)o $pas de
c#digo fuente$ En mi e'emplo yo guard, mi c#digo fuente con el nombre HolaMundo.pas con lo cual (abr, creado
un e'ecutable HolaMundo.exe$
1ara todo aquel que no lo sepa" al abrir la lnea de comandos aparece un directorio del sistema por defecto$
1ara cambiar de directorio en %O5 se usa el comando cd :c(ange directory< seguido de la direcci#n del nue)o
directorio2
.l presionar enter luego de escribir esa instrucci#n quedaremos posicionados en el directorio donde alo'amos
nuestro programa$ Ob)iamente si nosotros creamos otro directorio para traba'ar con nuestras aplicaciones pascal
especificaremos la ruta de dic(o directorio$ 0na )ez estamos en el directorio correcto escribimos el nombre de
nuestro programa y damos enter$ Enseguida se e'ecutar& y podremos )er sus resultados2
%el mismo modo podemos compilar nuestros programas desde la lnea de comandos$ ?os posicionamos en el
directorio donde radica nuestro c#digo fuente y escribimos la instrucci#n fpc HolaMundo.pas para este caso" de lo
contrario la instrucci#n es fpc ?ombre%el.rc(i)o$pas donde ?ombre%el.rc(i)o ser& el nombre con el cual
guardamos nuestro c#digo fuente$
Write y Writeln:
.(ora )eremos un programa que imprimir& dos frases de texto" una en una lnea y la otra deba'o2
1 PROGRAM SalidaEstandar;
2
3 BEGIN
4 writeLn(`Hice mi primer programa en Pascal.');
5 write(`Logr el clsico Hola mundo.')
6 END.
.l igual que antes en la primera lnea escribimos PROGRAM seguido de un identificador para el programa"
finalizando la lnea con un punto y coma$
En la lnea 3 indicamos el inicio de las instrucciones$ En la cuarta lnea utilizamos el procedimiento
writeLn para imprimir un texto en pantalla$ Este procedimiento funciona exactamente igual que write$ +a
diferencia entre la una y la otra es que write imprime algo en pantalla y de'a el cursor 'usto al final de esa lnea$
%e modo contrario" writeln imprime un texto y lo de'a al inicio de la lnea siguiente$ .s" con el e'emplo anterior
obtenemos como salida2
Hice mi primer programa en Pascal.
Logr el clsico Hola mundo.
?oten que la ltima sentencia no finaliza con punto y coma$ Esto es porque al final del programa cuando
dictas la ltima instrucci#n no (ace falta separarla de ninguna otra y es posible omitir el punto y coma" sin embargo
no est& mal si lo colocan$
;omo ya (abr&n notado" al ir escribiendo c#digo el K%E ir& coloreando las palabras$ .quellas que son
reser)adas ser&n de color blanco :/riteln y readln son reser)adas pero no se colorean" lo mismo suceder& con otras
tantas<" el texto que ser& impreso tal cual" o sea" el que est& entre comillas simples" se )e en celeste" lo dem&s se )e
amarillo" y as suceder& con otras cosas$
+os procedimientos write y writeln imprimen informaci#n en pantalla" en lo que llamamos salida
estndar" o sea" la salida de la lnea de comandos$ +lamamos salida ya que es informaci#n entregada por el
programa$ %el mismo modo la llamaremos entrada estndar cuando sea usada para ingresar informaci#n al
programa$
1ascal no es un lengua'e que diferencie entre maysculas o minsculas en su c#digo fuente" por lo cual
escribir writeln, WRITELN, WrItElN o como sea" es exactamente igual$ +o mismo sucede con los
identificadores" si ustedes llaman a su programa 5.+K%.E5-.?%.R" salidaestandar" 5ali%aes-andar o como sea"
da exactamente lo mismo$ Esto se aplica para las dem&s palabras reser)adas$ ?oten que si en un texto que se
imprimir& en pantalla ustedes cambian las maysculas y las minsculas s se )er&n las diferencias$
Introduccin a las variables:
Duy bien" (asta a(ora )imos dos e'emplos de programas que e'ecutan una o dos instrucciones para mostrar
informaci#n en pantalla$ 5in embargo" normalmente (ace falta ingresar informaci#n a un programa para que con ella"
este realice una o )arias tareas$ . continuaci#n )eremos el e'emplo de un programa que pedir& a un usuario que
ingrese su nombre y luego le saludar& nombr&ndolo2
1 PROGRAM EjemploVariable;
2
3 Var
4 nombre: String;
5
6 BEGIN
7 write(Ìngresa tu nombre: `);
8 readln(nombre);
9 writeln(`Hola `,nombre);
10 END.
Bemos comenzado como siempre escribiendo PROGRAM seguido de un identificador para nuestro programa y
un punto y coma$
En la tercera lnea )emos la palabra reser)ada VAR" la cual indica que a continuaci#n se declarar&n todas las
)ariables que usar& nuestro programa en sus tareas$ 0na )ariable guarda informaci#n de algn tipo especfico y luego
usa esta para realizar diferentes acciones" incluso modificar su )alor$ ?osotros podremos modificar el contenido de
una )ariable siempre que queramos :detallaremos esto m&s adelante< y en cualquier momento dentro de nuestro
programa$
1ara declarar una )ariable" luego de la palabra V.R" le damos un nombre :identificador< a la )ariable y
definimos de qu, tipo ser&$ +a sintaxis para (acerlo es la siguiente2
NombreDeLaVariable: tipo;
en nuestro e'emplo" en la lnea 4 (emos declarado una )ariable llamada nombre del tipo string" o sea" una )ariable
que contendr& cadenas de caracteres$ tring es una palabra reser)ada de pascal y corresponde a un tipo primiti)o
del mismo$ -odo lo que sea del tipo 5tring almacenar& cadenas de caracteres$ ?osotros no usaremos muc(o este tipo
en general ya que no resulta muy til a los efectos de este manual" pero an as sir)e conocerlo$
En la lnea J indicamos el inicio del programa$ ;omo )en" la declaraci#n de )ariables se (ace antes de iniciar
el programa$ Esto es porque el compilador primero asigna la memoria R.D que necesitar& para almacenar cada
)ariable y luego comienza con la e'ecuci#n del programa$ +as )ariables declaradas se guardan en celdas de memoria
aunque no se usen" por lo cual no con)iene declarar )ariables inser)ibles$
En la lnea L usamos write para imprimir un mensa'e al usuario y de'ar el cursor a continuaci#n del
mensa'e" ya que all se escribir& el nombre$ En la octa)a lnea utilizamos el procedimiento rea!ln para leer
informaci#n de la entrada est&ndar e indicamos entre par,ntesis que dic(a informaci#n debe ser almacenada en la
)ariable nombre :la informaci#n se leer& al presionar enter<$ 5iempre luego del procedimiento read o readln se
especifica entre par,ntesis la o las )ariables que guardar&n la informaci#n leda" de lo contrario" el programa no
guardar& ningn registro de la informaci#n administrada por el usuario y continuar& su curso$
En la no)ena lnea utilizamos el procedimiento writeln al cual le pasamos dos campos de informaci#n esta
)ez" primero el texto que debe imprimir y luego" separado por una coma" el nombre de la )ariable cuya informaci#n
queremos que aparezca en pantalla$ ;uando uno necesita imprimir )arias cosas con un solo procedimiento write o
writeln debe separar los campos con una coma$ En este caso" un campo contiene el texto y el otro la )ariable
nombre$ ;uando se especifica el nombre de una )ariable dentro de un campo de estos procedimientos" lo que
aparecer& en pantalla es el contenido de la )ariable$ En este caso la )ariable nombre guardar& la palabra que nosotros
escribamos y luego ser& lo que aparezca en pantalla al imprimir su contenido$
E'emplo de e'ecuci#n2
Ingresa tu nombre: Vladimir
Hola Vladimir
.l igual que con write y writeln" la diferencia entre read y readln es que la primera lee
informaci#n de la entrada est&ndar y de'a el cursor al final de la lnea en que la informaci#n fue ingresada$ +a
segunda de'a el cursor 'usto al inicio de la lnea siguiente$ 1ueden probar a escribir el programa anterior
intercambiando estas funciones para )er el resultado y comprenderlo me'or$
?otas2 ?o declarar una )ariable luego de la palabra V.R es un error de sintaxis$
?o usar los dos puntos :2< para luego indicar el tipo de la )ariable es un error de sintaxis$
%os )ariables no pueden llamarse de la misma manera ni tampoco pueden llamarse igual que el programa"
dic(o de otra manera" no pueden repetirse dos identificadores" eso es un error de sintaxis$
Ejemplo de asignacin: ;on el siguiente programa )eremos como usar )ariables num,ricas y c#mo asignarle
un )alor especfico a una )ariable as como tambi,n a realizar operaciones entre ellas calculando el &rea de un
tri&ngulo2
1 PROGRAM AraTriangulo;
2
3 Var
4 base, altura: integer;
F area: real;
6
7 BEGIN
I Write(Ìngresa la base: `);
P Readln(base);
1E Write(Ìngresa la altura: `);
11 Readln(altura);
12
13 area:= base*altura/2;
14
1F Writeln(Èl rea del tringulo es: `,area:1:2);
1J END.
Este programa utiliza tres )ariables2 base" altura y area" para calcular el &rea de un tri&ngulo$ +a
base y la altura del mismo son ingresadas por el usuario" y el )alor de area se asigna dentro del programa$
Esta )ez tenemos dos )ariables del tipo integer" o sea que almacenar&n nmeros enteros y una del tipo
real" o sea que almacenar& nmeros reales$ ;omo )en es posible declarar m&s de una )ariable del mismo tipo en
una sola sentencia" simplemente separ&ndolas por comas :"< y asignando el tipo al final" como (emos (ec(o en la
lnea 4$ 1uede" si se desea" declararse cada )ariable por separado$
En la lnea I imprimimos una instrucci#n para el usuario y en la lnea P indicamos al programa que lea de la
entrada lo que el usuario ingrese y lo guarde dentro de la )ariable base$ En la lnea 1E imprimimos otra instrucci#n al
usuario y en la 11 leemos un )alor y lo guardamos en la )ariable altura$
En la lnea 13 de nuestro programa le asignamos a la )ariable area mediante el uso del smbolo de asignaci#n
::< el )alor del resultado de multiplicar el )alor de base por el )alor de altura y di)idirlo entre 2$ O sea" estamos
multiplicando ambas )ariables ya que contienen nmeros$ El smbolo para multiplicar es el asterisco :T< y para la
di)isi#n la barra :H<$
En la lnea 1F usamos writeln a la cual le pasamos dos campos de informaci#n" uno con el texto a
imprimir y otro con la )ariable cuyo )alor debe mostrarse con modificadores de decimales :ya explicar, esto<$ Este
programa podra (aberse (ec(o sin la )ariable area y la lnea 1F quedara as
Writeln (Èl rea del tringulo es: `,base*altura/2:1:2);
;omo )en" es posible colocar expresiones en los campos de write y writeln$
+os nmero enteros no contienen cifras despu,s de la coma y los reales s pueden contenerlas$ +a )ariable
area es del tipo real por lo cual al imprimir su contenido este se mostrar& con )alores decimales y exponente en base
1E$ 1or e'emplo si su )alor es FE" se imprimir& as F$EEEEEEEEEEEEEEE@EE1$ Esto equi)ale a Fx1E
1
$ +os
modificadores :#:$ indican en su primer )alor el nmero mnimo de caracteres que toleraremos en el resultado :1< y
el segundo )alor indica cuantas cifras luego de la coma queremos que aparezcan :2<$ ;on esto" el )alor anterior se
)er& como FE$EE$
Leer ms de una variable a la vez:
El programa anterior podra (aber sido escrito de la siguiente manera2
1 PROGRAM AraTriangulo;
2
3 Var
4 base, altura: integer;
F area: real;
6
7 BEGIN
I Write(Ìngresa base y la altura separadas por un espacio: `);
P Readln(base,altura);
10
11 area:= base*altura/2;
12
13 Writeln(Èl rea del tringulo es: `,area:1:2);
14 END.
Vladimir Rodrguez 1F
;omo pueden obser)ar b&sicamente es lo mismo" con la nica diferencia crucial de que esta )ez" en la lnea P"
indicamos al programa mediante el procedimiento readln que lea dos )ariables a la )ez$ Esto siempre es posible$
5olo deben colocarse entre los par,ntesis los nombres de las )ariables a leer separados por comas$ 1ueden ser
)ariables de distinto tipo$ En este caso especfico ambas son integer$ ;uando se ingresen los datos para la entrada
est&ndar deben separarse por un espacio$ 5i el usuario ingresa solo un dato ,ste se asignar& a la primera )ariable que
aparezca dentro de los par,ntesis y el programa quedar& esperando el siguiente )alor$
%el mismo modo pueden imprimirse )arias )ariables a la )ez ingresando los nombres de cada )ariable
separados por comas dentro de los par,ntesis de un procedimiento write o writeln.
Ejercicio: Realicen un programa que calcule el &rea y el permetro de un rect&ngulo$ Recuerden que el &rea de
un rect&ngulo se calcula como baseàltura y su permetro como base`2+altura`2$ El programa recibir& de la
entrada est&ndar la base y la altura y mostrar& como salida un mensa'e con el &rea y otro" deba'o" con el permetro$
Estos mensa'es deben estar separados al menos por una lnea en blanco de los mensa'es de instrucciones para el
usuario$
E'emplo de e'ecuci#n2
Ingrese la base: 10
Ingrese la altura: 6
El rea de rectngulo es: 60
El permetro del rectngulo es: 32
%eben ser capaces de realizar este e'ercicio antes de continuar$ 5i desean saber la soluci#n escrbanme a
mstr)ladi3(otmail$com $
Vladimir Rodrguez 1J
Introduccin a la compatibilidad de tipos:
En el e'emplo anterior tenemos dos )ariables del tipo integer :enteros< y una del tipo real :reales<$ 0na
)ariable integer no puede contener reales pero una real s puede contener enteros$ 5i en el e'emplo anterior el usuario
ingresa para base un nmero real no entero :por e'emplo 1$F< el programa intentar& guardar este )alor en una )ariable
entera y no podr& por lo cual se producir& un error en tiempo de ejecucin que (ar& que el programa finalice
abruptamente$ 5i base fuera del tipo real y se le pasara un )alor integer :por e'emplo 4< no (abra problema ya que el
programa transformar& el entero a real" o sea el 4 ser& 4$E$ Esto no afecta la informaci#n ya que 4 y 4$E son
exactamente el mismo )alor" pero no (ay forma de pasar un real a entero sin modificar este de alguna manera" ya sea
trunc&ndolo :de'ar un 1$F en 1< o redonde&ndolo de alguna forma$
5i la )ariable area en nuestro programa fuera tambi,n del tipo entero" tendramos un error en tiempo de
compilacin al intentar asignarle el )alor de multiplicar base por altura y di)idir esto entre dos" ya que la operaci#n
:H< de)uel)e como )alor un real$ El compilador detectara esto y cancelara su tarea indicando que (ay un error en la
compatibilidad de tipos ya que se quiere asignar un real a un entero$
%el mismo modo" si a )ariables reales o enteras se les asigna una cadena de caracteres como entrada"
tendremos un error en tiempo de ejecucin ya que )alores num,ricos no son compatibles con cadenas de caracteres$
+o m&s con)eniente para el programa anterior sera declarar todas las )ariables como reales$ Esto soluciona el
problema de la compatibilidad de tipos num,ricos" aunque an tenemos el problema de si el usuario ingresa un
car&cter que no sea un nmero en las entradas de este programa$ . la tarea de detectar todas las posibles situaciones
que puede enfrentar nuestro programa al ser usado y sus consecuencias se le llama Captura de errores y es una de
las tareas m&s difciles ya que es f&cil que se nos pase por alto algn caso" y m&s an cuando nuestro programa es
muy comple'o$ . medida que a)ancemos )eremos c#mo enfrentar estas situaciones$
Vladimir Rodrguez 1L
Errores en tiempo de Ejecucin y errores en tiempo de Compilacin:
+uego de escribir el c#digo siempre intentamos compilarlo para generar nuestro e'ecutable y )er los
resultados de nuestro traba'o$ Dientras el programa se compila decimos que estamos en tiempo de compilaci#n$ +os
errores que pueden sufrirse aqu son generalmente de sintaxis y de compatibilidad de tipos$ ;uando (ay un error en
tiempo de compilaci#n el compilador se detiene y nos indica el lugar donde encontr# el error proporcion&ndonos
adem&s alguna informaci#n acerca de por qu, se produ'o$ Estos son los errores m&s f&ciles de arreglar ya que son
detectables f&cilmente$
.(ora bien" que un programa compile perfectamente no nos dice que no tenga errores$ ;uando e'ecutamos un
programa decimos que estamos en tiempo de e'ecuci#n$ +os errores en tiempo de e'ecuci#n pro)ocan que el
programa se cuelgue" termine inesperadamente perdi,ndose toda la informaci#n que tenamos o que muestre
resultados inesperados$ Estos errores son los menos deseados y los m&s difciles de detectar ya que se deben a errores
en nuestras instrucciones al programa$
Veamos un e'emplo sencillo" un programa que di)ide dos nmeros2
1 PROGRAM dividir;
2
3 Var
4 a, b: real;
5
6 BEGIN
L Write(Ìngrese un nmero: `);
I Readln(a);
P Write(Ìngresa otro nmero: `);
1E Readln(b);
11
12 Wtieln(Èl resultado de la divisin es: `,a/b:1:2);
13 END.
5upongamos que sabemos que nuestros usuarios solo ingresar&n nmeros a nuestro programa$ 8;u&l sera el
problema entonces9 Ese programa compila perfectamente y solo ingresar&n nmeros" no (abra error posible$ 1ero
8qu, pasa si cuando se ingresa el )alor para b el usuario ingresa el )alor E9 5upongamos que la e'ecuci#n fue as2
Ingrese un nmero: 5
Ingrese otro nmero: 0
8*u, debera mostrar nuestro programa9 .l llegar a la lnea 12 (e intentar la di)isi#n de a/b" o sea 5/0" no
podr& ya que la di)isi#n entre E no est& definida matem&ticamente y el programa producir& un error y se terminar& su
e'ecuci#n$ +o correcto sera que si el usuario ingresa un E para la )ariable b el programa nos muestre un mensa'e de
error y nos )uel)a a pedir un nue)o )alor$ ;uando )eamos estructuras de control )eremos como tomar distintos
caminos segn las condiciones que se dan$
Vladimir Rodrguez 1I
Palabras reservadas:
+as palabras reser)adas por 1ascal son aquellas que indican alguna funci#n especfica del lengua'e" como por e'emplo"
write indica que algo se desplegar& en pantalla y readln que el usuario ingresar& alguna informaci#n$ *ue una palabra sea
reser)ada indica que esta no puede utilizarse como identificador" o sea" uno no puede crear un programa llamado Writeln o Var" o
una )ariable llamada Readln$ 0tilizar palabras reser)adas indebidamente es un error de sintaxis$
Be aqu una lista de casi todas las palabras reser)adas en pascal2
AND
ARRAY
BEGIN
CASE
CONST
DIV
DO
DOWNTO
ELSE
END
FILE
FOR
FUNCTION
GOTO
IF
IN
LABEL
MOD
NIL
NOT
OF
OR
PACKED
PROCEDURE
PROGRAM
RECORD
REPEAT
SET
THEN
TO
TYPE
UNTIL
VAR
WHILE
WITH
ABS
ARCTAN
BOOLEAN
CHAR
CHR
COS
DISPOSE
EOF
EOLN
EXP
FALSE
GET
INPUT
INTEGER
LN
MAXINT
NEW
NIL
ODD
ORD
OUTPUT
PACK
PAGE
PRED
PUT
READ
READLN
RESET
REWRITE
ROUND
SIN
SQR
SQRT
SUCC
TEXT
TRUE
TRUNC
UNPACK
WRITE
WRITELN
Vladimir Rodrguez 1P
Identificadores:
;omo ya (emos )isto" utilizamos identificadores para nombrar a nuestro programa y a nuestras )ariables$ En
efecto" un identificador es un nombre que nosotros asignamos a nuestros ob'etos en el programa para identificarlos
luego mediante ese nombre$ 0saremos identificadores para nombrar #ariables" constantes" tipos" parmetros"
,unciones" procedimientos y punteros entre otras cosas$
0n identificador puede ser cualquier cadena de caracteres alfanum,ricos o de subrayado que comience al
menos con una letra$ ?o puede contener espacios ni caracteres especiales as como tampoco puede ser igual a una
palabra reser)ada$
%e este modo" identificadores )&lidos pueden ser2 Abuela, ABuela2,
Ejemplo_de_identificador, E2B214, etc$
Kdentificadores in)&lidos podran ser2 1Abuela, Abuela 2, Ejemplo de Identificador,
Abk$, Variable(), pascal, var, program, etc$
Tipos de datos:
Ordinales2 5on aquellos que" dado un elemento" podemos saber cual es el siguiente yHo el anterior adem&s de
que poseen una cantidad finita de elementos$ 1or e'emplo dado un nmero entero sabemos que el siguiente es ese
nmero m&s uno y el anterior es el nmero menos uno$ %ado el F su predecesor es el 4 y su sucesor es el J$
Knteger ?meros enteros" sin ninguna cifra decimal$
;(ar ;aracteres$
oolean Valores l#gicos" pueden )aler -rue o Galse$
Enumerados %efinido por el programador$
5ubrango %efinido por el programador$
1ara estos tipos llamados Ordinales tenemos tres funciones predefinidas por 1ascal que suelen ser tiles2
Pred(valor_de_tipo_ordinal) %e)uel)e el predecesor para cualquier )alor de tipo ordinal excepto si ,ste es
el primero de todos$ En este caso tenemos un error en tiempo de e'ecuci#n$
Succ(valor_de_tipo_ordinal) %e)uel)e el sucesor para cualquier )alor de tipo ordinal excepto si ,ste es el
ltimo de todos$ En este caso tenemos un error en tiempo de e'ecuci#n$
Ord(valor_de_tipo_ordinal) %e)uel)e el ordinal para cualquier )alor de tipo ordinal$ =a (ablaremos de esto
m&s tarde" al igual que de las dos funciones anteriores$
Reales2 5olo tenemos el tipo real para esta categora$ +as funciones anteriores no funcionan con )alores de
tipo real ya que es imposible saber" dado un real" cual es su sucesor o su predecesor$
Estructurados2 Gorman estructuras de datos" en general" bastante comple'as$
5tring ;adena de caracteres$
.rray -ablas de datos :5tring es un array de caracteres<$
Record Registros de datos$
Gile 5ecuencias de datos :?o traba'aremos con este tipo<$
5et ;on'untos de datos$
1unteros2 Bablaremos de ellos al final de este tutorial$
?otas2 El mayor entero posible es identificado por la palabra reser)ada D.NK?-" la cual es una constante
:(ablaremos de estas m&s adelante<$
Operadores en pascal:
Veamos los operadores aritm,ticos de 1ascal" los cuales son usados para crear expresiones matem&ticas y
realizar c&lculos2
Operador Expresin Significado Descripcin
T
.T . por Realiza el producto de .
por $ . y pueden ser
reales o enteros$ asta con
que uno sea real para que
el resultado sea un real$
/
.H . di)idido Realiza la di)isi#n entre .
y $ %e)uel)e como
resultado un real$
DIV
. di) . di)idido :di)isi#n
entera<
Realiza la di)isi#n entera
entre . y $ %e)uel)e
como resultado el
cociente" por tanto . y
(an de ser enteros$
MOD
. mod Resto de . di)idido
:di)isi#n entera<
Realiza la di)isi#n entera
entre . y y de)uel)e
como resultado el resto$ .
y deben ser enteros$
+
.@ . m&s Realiza la suma de . m&s
$ asta con que uno de
los sumandos sea real para
que de)uel)a un real$
-
.A . menos Realiza la resta de .
menos $ asta con que
uno de los restando sea
real para que de)uel)a un
real$
Precedencia de operadores: %ada una expresi#n matem&tica donde se combinen )arios de estos operadores"
al igual que en el &lgebra comn" se realizar&n primero los productos :T<" las di)isiones :di)<" :mod< y :H< y luego las
sumas :@< y restas :A<$ 1ara quebrar esta precedencia de qui,n )a primero que qui,n" se utilizan los par,ntesis$
E'emplo2 A+B*C En este caso aparece primero la suma y luego un producto$ 5in embargo el producto
tiene precedencia ante la suma y se e)aluar& primero T; para luego sumar ese resultado con .$ 5i se quisiera
realizar primero la suma (abra que utilizar par,ntesis y escribir aquella expresi#n como (A+B)*C$ .(ora s se
realizar& primero la suma y luego el producto ya que los par,ntesis tienen la precedencia absoluta excepto si existen
funciones que deben e)aluarse dentro$
Funciones matemticas de pascal:
1ascal nos pro)ee de )arias funciones matem&ticas predefinidas para realizar algunos c&lculos comunes$ En
los siguientes e'emplos la letra % simbolizar& un nmero o expresi#n del tipo adecuado para la funci#n en cuesti#n2
ABS(x) ;alcula el )alor absoluto de N$ N debe ser integer o real$ El resultado es del mismo tipo
que N$
SQR(x) ;alcula el cuadrado de N$ N debe ser integer o real$ El resultado es del mismo tipo que
N$
SQRT(x) ;alcula la raz cuadrada de N siendo N un real o entero mayor o igual que E$ El
resultado es un del tipo real$
SIN(x) ;alcula el seno de N expresado en radianes$ N debe ser integer o real$ El resultado es
del tipo real$
ARCTAN(x) ;alcula el arco tangente de N$ N debe ser integer o real$ El resultado es del tipo real$
EXP(x) ;alcula la exponencial de N :e
x
donde eU 2$L1I2I1IV<$ N debe ser integer o real$ El
resultado es del tipo real$
LN(x) ;alcula el logaritmo neperiano :base e< de N siendo N mayor que cero$ N debe ser
integer o real$ El resultado es del tipo real$
TRUNC(x) 5uprime la parte decimal de N de'ando solo el )alor anterior a la coma$ N debe ser real$
El resultado es del tipo integer$
ROUND(x) Redondea el )alor de N al entero m&s pr#ximo$ N debe ser real$ El resultado es del tipo
integer$
ORD(x) Obtiene el nmero de orden de N dentro de un con'unto de )alores definidos por su tipo$
N debe ser de un tipo ordinal$ El resultado es de tipo integer$
CHR(x) %e)uel)e el caracter cuyo nmero ordinal es N$ El tipo de N debe ser integer$ El
resultado es de tipo c-ar$
Un ejemplo del uso de DIV y MOD. Introduccin a los comentarios:
5e nos plantea el siguiente problema$ %ado un nmero entero de cuatro cifras que ser& ledo desde la entrada
est&ndar se nos pide que (agamos la suma de sus cifras$ 1or e'emplo" si el usuario ingresa el nmero FJ4I el
programa debe realizar la suma de F@J@4@I y mostrar el resultado$ 5e asume que el usuario ingresar& efecti)amente
un nmero de cuatro cifras$
1 {El siguiente programa desglosar un nmero de cuatro cifras
2 en sus cuatro nmeros distintos, uno por cada cifra y realizar
3 la suma entre ellas}
4 PROGRAM SumaCifras;
5
6 Var
7 numero: integer; //El valor que ser ledo.
8 c1, c2, c3, c4: integer;//Una variable para cada cifra.
9
10 BEGIN
11 write('Ingresa un nmero de cuatro cifras: ');
12 readln(numero); //Leemos el nmero de 4 cifras.
13
14 (*Asignamos a cada variable el valor de la cifra que le corresponde*)
15 c1:= numero mod 10;
16 c2:= (numero mod 100) div 10;
17 c3:= (numero mod 1000) div 100;
18 c4:= numero div 1000;
19
20 //Mostramos el resultado al usuario.
21 write('El resultado de sumar ',c4,'+',c3,'+',c2,'+',c1,' es: '
,c1+c2+c3+c4);
22 END.
Este es nuestro primer programa en el que )emos el uso de comentarios$ +os comentarios son anotaciones
(ec(as por el propio programador para ir explicando lo que se )a realizando en su c#digo$ Esto es debido a que
normalmente el soft/are se desarrolla en equipo y resulta imprescindible que otros lean el c#digo que uno escribe y
sean capaces de entenderlo$ +os comentarios son omitidos por el compilador por lo cual no afectan en absoluto al
funcionamiento del programa" solo son una documentaci#n explicati)a$ Existen dos tipos de comentarios" los
comentarios multilnea y los comentarios de ,in de lnea$ +os primeros pueden abrirse con y cerrarse con ] tal como
se )e en las primeras tres lneas de nuestro programa" o abrirse con (` y cerrarse con `) tal como se )e en la lnea 14
de nuestro programa$ 0n comentario multilnea puede ocupar una o m&s lneas de c#digo" tantas como sea necesario$
+os comentarios de fin de lnea se abren con // y no requieren ningn smbolo de cierre ya que" como su nombre lo
indica" finalizan al terminar la lnea en que aparecen$ 1odemos )erlos en las lneas L" I" 12 y 2E de nuestro e'emplo$
En el K%E se )er&n de color gris$
.(ora miremos un poco la l#gica de nuestro programa" como usando mod y di# solamente" puede desglosarse
un nmero en sus respecti)as cifras$
En la lnea 12 leemos de la entrada est&ndar un )alor y lo guardamos dentro de numero$ +uego" en la lnea
1F" mediante el smbolo de asignaci#n := le damos a c1 el )alor de la primera cifra de nuestro nmero$ G'ense que
si uno tiene un nmero de m&s de una cifra y lo di)ide entre 1E" el resto de esa di)isi#n ser& la primera cifra si leemos
de derec(a a izquierda$ -eniendo por e'emplo el 14FJ" si di)idimos ese nmero entre 1E :di)isi#n entera" sin lle)arlo
a decimales< obtenemos como resto el J y como resultado el 14F$
En la lnea 13 obtenemos el resto de di)idir nuestro nmero entre 1EE" eso da como resultado el entero
formado por las dos primeras cifras :de derec(a a izquierda< y luego :notar que esta operaci#n est& entre par,ntesis
para que se realice primero< mediante di# obtenemos el cociente de di)idir ese nmero entre 1E$ 1or e'emplo" si
tenemos 14FJ y lo di)idimos entre 1EE" el resultado es 14 y el resto FJ$ -eniendo el resto" al di)idirlo entre 1E
tenemos como resultado el F y como resto el J$ %e este modo en las lneas 1L y 1I obtenemos las ltimas dos cifras
de nuestro nmero$
.(ora las )ariables c1, c2, c3 y c4 contienen cada una los )alores de una cifra de nuestro )alor inicial$
En la lnea nmero 21 mostramos mediante el procedimiento write los resultados de nuestro programa$
Introduccin a las constantes:
.l igual que podemos definirnos )ariables" que son ob'etos cuyos )alores )an cambiando a lo largo del
programa" tambi,n podemos definirnos constantes" que ser&n ob'etos cuyo )alor no cambiar& nunca a lo largo del
programa$ Veremos un e'emplo en el cual intentar, (acerles entender la necesidad de las constantes$
El siguiente programa pedir& como entrada en reales el precio sin KV. de cinco productos que est&n a la )enta
en un almac,n$ +uego mostrar& el precio de dic(os productos con el KV. agregado$
1 PROGRAM preciosIVA;
2
3 Const
4 iva= 23;
5
6 Var
7 harina, leche, azucar, sal, arroz: real;//Precios de los productos.
8 porcentaje: real; //Para calcular cuanto se debe sumar al precio.
9
10 BEGIN
11
12 //Mostramos mensajes al usuario y leemos los datos desde la entrada.
13 write('Precio HARINA : ');
14 readln(harina);
15 write('Precio LECHE : ');
16 readln(leche);
17 write('Precio AZUCAR : ');
18 readln(azucar);
19 write('Precio SAL : ');
20 readln(sal);
21 write('Presto ARRZ : ');
22 readln(arroz);
23
24 //Dejamos una lnea en blanco.
25 writeln;
26
27 //Calculamos el porcentaje de IVA para harina.
28 porcentaje:= harina*iva/100;
29 //Mostramos el nuevo precio al usuario.
30 writeln('HARINA + IVA : ',harina+porcentaje:2:2);
31
32 //Calculamos el porcentaje de IVA para leche.
33 porcentaje:= leche*iva/100;
35 writeln('LECHE + IVA : ',leche+porcentaje:2:2);
36
37 //Calculamos el porcentaje de IVA para azucar.
38 porcentaje:= azucar*iva/100;
40 writeln('AZUCAR + IVA : ',azucar+porcentaje:2:2);
41
42 //Calculamos el porcentaje de IVA para sal.
43 porcentaje:= sal*iva/100;
45 writeln('SAL + IVA : ',sal+porcentaje:2:2);
46
47 //Calculamos el porcentaje de IVA para arroz.
48 porcentaje:= arroz*iva/100;
50 writeln('ARROZ + IVA : ',arroz+porcentaje:2:2);
51 END.
ien" en la lnea 3 )emos la palabra reser)ada const" que indica que desde all se declarar&n constantes$ +a
sintaxis para declaraci#n de constantes es
NombreDeLaConstante& 'alor; donde valor representa un )alor de algn tipo primiti)o de pascal
:integer. real. c-ar. string entre algn otro<$ El nombre de la constante es un identificador$ En este caso" en la lnea 4
del programa (emos declarado la constante iva y le (emos dado el )alor 23" que representa el 23W que )ale el KV.
en mi pas$ ?otar que las constantes se declaran antes que las )ariables$
+uego" en las lneas L y I declaramos las )ariables del programa" una para el precio de cada producto y una
para calcular el porcenta'e de KV. que le corresponde al precio de cada producto para luego sum&rselo al mismo$
En las lneas 13 a 22 inclusi)e" mostramos mensa'es al usuario y leemos los )alores de las entradas para cada
producto$
+uego" en la lnea 2F indicamos mediante el procedimiento writeln que queremos de'ar una lnea en
blanco$ Esto se (ace llamando al procedimiento sin pasarle campos entre par,ntesis$
En la lnea 2I calculamos el porcenta'e de KV. para la (arina asignando este )alor a la )ariable porcentaje$
Esta operaci#n es simple$ 5i uno tiene un )alor y quiere saber un porcenta'e de ese )alor simplemente multiplica
dic(o )alor por el porcenta'e que quiere obtener y di)ide el resultado entre 1EE$ 1or e'emplo" si tenemos el nmero
2LI y queremos saber el 1FW de ese nmero simplemente realizamos la operaci#n 2LIx1FH1EE lo cual nos dara 41"L$
Ese )alor corresponde al 1FW de 2LI$ %e este modo calculamos el porcenta'e de KV. para cada producto
multiplicando su precio por el )alor de la constante iva y di)idiendo entre 1EE$
En la lnea 3E mostramos un mensa'e al usuario y el precio de la (arina m&s el porcenta'e de KV. del mismo"
en este caso m&s un 23W$
Repetimos esto (asta el final de la aplicaci#n$
?otar que siempre usamos la )ariable porcentaje para calcular el 23W de cada precio$ El smbolo de
asignaci#n :2U< borra el contenido anterior de la )ariable y asigna el nue)o" o sea" la sobrescribe$
.(ora )eamos el mismo programa pero sin el uso de la constante iva2
1 PROGRAM preciosIVA;
2
3 Var
4 harina, leche, azucar, sal, arroz: real;//Precios de los productos.
5 porcentaje: real; //Para calcular cuanto se debe sumar al precio.
6
7 BEGIN
8
9 //Mostramos mensajes al usuario y leemos los datos desde la entrada.
10 write('Precio HARINA : ');
11 readln(harina);
12 write('Precio LECHE : ');
13 readln(leche);
14 write('Precio AZUCAR : ');
15 readln(azucar);
16 write('Precio SAL : ');
17 readln(sal);
18 write('Precio ARRZ : ');
19 readln(arroz);
20
22 writeln;
23
24 //Calculamos el porcentaje de IVA para harina.
25 porcentaje:= harina*23/100;
27 writeln('HARINA + IVA : ',harina+porcentaje:2:2);
28
29 //Calculamos el porcentaje de IVA para leche.
30 porcentaje:= leche*23/100;
32 writeln('LECHE + IVA : ',leche+porcentaje:2:2);
33
34 //Calculamos el porcentaje de IVA para azucar.
35 porcentaje:= azucar*23/100;
37 writeln('AZUCAR + IVA : ',azucar+porcentaje:2:2);
38
39 //Calculamos el porcentaje de IVA para sal.
40 porcentaje:= sal*23/100;
42 writeln('SAL + IVA : ',sal+porcentaje:2:2);
43
44 //Calculamos el porcentaje de IVA para arroz.
45 porcentaje:= arroz*23/100;
47 writeln('ARROZ + IVA : ',arroz+porcentaje:2:2);
48 END.
Esta )ersi#n funciona exactamente igual a la anterior" con la diferencia de que en el c#digo" donde antes
tenamos el identificador iva a(ora (ay un 23$
.(ora imaginen la siguiente situaci#n2 el )alor de KV. cambia en un momento dado y se les pide que
reestructuren su programa para el nue)o )alor de KV.$ 5i ustedes (icieron su programa tal como esta ltima )ersi#n
deber&n buscar en su c#digo cada una de las )eces en que usaron el 23 para calcular el porcenta'e de KV. y cambiarlo
por el nue)o )alor" mientras que en la )ersi#n con constante solo es ir a donde est& declarada iva y modificar a( su
)alor con lo cual no sera necesario tocar m&s nada del c#digo$ Esta acci#n puede realizarla (asta alguien que no (aya
sido el propio programador" mientras que en el c#digo sin constante" si uno no fue quien program# deber& primero
sentarse a leer y entender el c#digo (asta que pueda efecti)amente (acer una bsqueda de los lugares donde se realiz#
el c&lculo del KV. para poder modificarlos$
En este e'emplo no resulta difcil modificar todos los 23 que (ay" pero imaginen una base de datos de un
supermercado en el cual (ay miles de productos y precios diferentes$ 85era me'or buscar y cambiar todos y cada uno
de los )alores en que usamos el 23" o sera me'or declarar una constante y solo cambiar un 239 ?ormalmente los
c#digos son muy extensos y complicados" por lo cual una tarea de re)isi#n total y bsqueda ex(austi)a sera muy
tediosa y difcil" adem&s de que es muy probable que se nos pase por alto alguna expresi#n a modificar$ El uso de
constantes es muy recomendable cuando se )a a usar un mismo )alor muc(as )eces$
?ota2 ?o puede usarse una constante a la izquierda de una asignaci#n$ 1or e'emplo sera err#neo escribir
i'a:& #(; ya que iva no puede ser modificada$ Esto es un error de sintaxis$
Booleanos:
El tipo boolean resulta muy extra!o al principio$ 5olo contiene dos )alores posibles2 True y /alse$ O sea" una
)ariable del tipo boolean solo puede ser )erdadera o falsa$ .unque en principio uno no puede imaginarse para qu,
puede ser)ir una )ariable de este tipo" realmente resultar&n muy tiles m&s adelante" cuando tengamos que comenzar
a darle condiciones a nuestro programa para que tome distintos caminos de e'ecuci#n$
?o es posible (acer write ni read de una )ariable boolean.
Algunas notas:
El punto y coma acta como separador$ ?osotros acostumbramos a escribir una instrucci#n por lnea por una
cuesti#n de legibilidad del c#digo" sin embargo al compilador eso no le importa al igual que tampoco la sangra
:indentaci#n< que de'emos$ %e este modo resultar& lo mismo escribir
Writeln(`Hola mundo');
Readln(variable);
que escribir
writeln(`Hola mundo'); readln(variable);
Ejercicios: .ntes de continuar deber&n ser capaces de realizar la gran mayora de los e'ercicios que
aparecer&n en los linXs a continuaci#n$ Estos los dirigir&n a una p&gina de Gacultad de Kngeniera y los e'ercicios
est&n pensados para reforzar todo lo que yo ya les (e explicado (asta aqu$ +a mayora se resuel)e de forma din&mica
con la p&gina WE con lo cual ustedes podr&n )erificar sus resultados al instante$ Reitero" traten de resol)er la mayor
parte de esos e'ercicios antes de continuar o de lo contrario no podr&n desempe!arse bien en los temas que trataremos
en lo que sigue del tutorial$

Prctico 1: (ttp2HH///$fing$edu$uyHincoHcursosHprog1HpmHfield$p(pH1racticosH1ractico1
Prctico 2: (ttp2HH///$fing$edu$uyHincoHcursosHprog1HpmHfield$p(pH1racticosH1ractico2
En caso de tener problemas con estos enlaces o con las p&ginas a las que estos los lle)an en)enme un eAmail a
mstr)ladi3(otmail$com y les ayudar, a la bre)edad$
SEGUNDA PARTE
Seleccin y Repeticin
Introduccin:
En esta secci#n del tutorial aprenderemos a usar secuencias de selecci#n para indicarle al programa qu,
camino (a de tomar en funci#n de ciertas condiciones dadas as como tambi,n aprenderemos secuencias de repetici#n
para indicarle al programa que debe )ol)er a e'ecutar cierto fragmento de c#digo una cantidad de )eces dada" o no$ Es
aqu donde la programaci#n comienza a complicarse un poco y comenzamos a tener )erdaderos dolores de cabeza
cuando nuestros programas no (acen lo que nosotros queremos$
Es muy comn que" en las secuencias de repetici#n" nunca se den las condiciones necesarias para finalizar la
repetici#n y nuestro programa entre en un bucle infinito :loop< y quede colgado realizando la misma tarea (asta que
nosotros lo cerremos o se bloquee el sistema$ -ambi,n es muy comn que ol)idemos alguna condici#n necesaria para
que el programa tome un camino especfico y por lo tanto funcione err#neamente" o que ni se nos (aya cruzado por la
cabeza que el usuario podra (aber ingresado tal o cual instrucci#n y esto genere muc(os errores en la e'ecuci#n de
nuestro programa$
1or estos moti)os es que cuando uno crea un programa debe probarlo con la peor intenci#n posible para
detectar la mayora de los errores que puedan aparecer$ %edicar, una secci#n entera para (ablar de la prueba de
programas$
El ambiente de desarrollo K%E de Gree 1ascal tiene incluido un depurador :debugger<$ Esta es una (erramienta
que nos permitir& )er la e'ecuci#n de nuestro programa paso a paso y )isualizar en una peque!a )entana los )alores
que nuestras )ariables )an tomando para as" poder detectar errores que de otro modo sera casi imposible$
.prenderemos a usar esta (erramienta en la p&gina 42 de este tutorial$ ;on)iene leerla cuando lleguen a ella" pero si
necesitan encontrar algn error en los programas que )an desarrollando l,anla cuando quieran$
Seleccin. Instruccin IF.THEN e IF.THEN.ELSE:
;omo ya (emos )isto que se )uel)e necesario tomar distintos caminos segn lo requieran las circunstancias$
1or e'emplo" en nuestro programa que di)ida dos cifras :p&gina 1I< (aca falta mostrar un mensa'e de error al
usuario en caso de que este ingresara como segundo )alor un E ya que esto causara un error en tiempo de e'ecuci#n"
y en caso contrario simplemente mostrar el resultado de la di)isi#n$
.qu entra en 'uego la instrucci#n de selecci#n if.then que en ingl,s significa :siVentonces<$ 5u sintaxis
es la siguiente2
If condicin then
Instruccin;
5upongo que debo decir que KG" -BE? y E+5E son palabras reser)adas$
Veamos un e'emplo sencillo en el cual un programa pedir& que se ingrese una edad a un usuario y si esta es
mayor a FE a!os le dir& que es un )ie'o$
1 PROGRAM viejo;
2
3 Var
4 edad: integer; //Variable para guardar la edad.
5
6 BEGIN
7 //Mostramos mensaje y leemos la edad.
8 write('Ingrese su edad: ');
9 readln(edad);
10
11 //Mostramos lo mismo que ya ingres.
12 writeln('Usted tiene ',edad,' aos.');
13
14 //Si tiene ms de 50 aos le decimos viejo.
15 If edad>50 then
16 writeln('Usted es un viejo');
17
18 END.
+o nico nue)o en este programa est& en la lnea 1F" en la instrucci#n if$ ;omo )emos" en la lnea nmero P
el usuario ingresa un nmero entero que corresponder& a su edad$ En la lnea 1F decimos si edad es mayor a 50
entonces.$ +a condici#n edad>50 es un booleano que )aldr& true si edad resulta ser mayor a FE o ,alse en caso
contrario$ +a lnea 1J se e'ecutar& solo si se cumple la condici#n" si no ser& salteada completamente$ Es posible
colocar expresiones matem&ticas dentro de las condiciones$
.(ora )eamos un e'emplo con el mismo programa pero que existan dos caminos posibles a tomar$ 5i el
usuario tiene m&s de FE a!os le diremos )ie'o y si no le diremos que es 'o)en2
1 PROGRAM viejo;
2
3 Var
4 edad: integer; //Variable para guardar la edad.
5
6 BEGIN
7 //Mostramos mensaje y leemos la edad.
8 write('Ingrese su edad: ');
9 readln(edad);
10
11 //Mostramos lo mismo que ya ingres.
12 writeln('Usted tiene ',edad,' aos.');
13
14 //Si tiene ms de 50 aos le decimos viejo.
15 If edad>50 then
16 writeln('Usted es un viejo')
17 else
18 Writeln(Ùsted es joven');
19
20 END.
Este programa es esencialmente igual al anterior con la excepci#n del else en la instrucci#n if$ Esto
significa que si se cumple la condici#n se realizar& la primera instrucci#n :la que est& antes del else< y en caso
contrario se e'ecutar& lo que est& luego del else$
Vean que luego de que escribimos if.then la siguiente lnea est& corrida unas columnas (acia la derec(a" o
sea tiene m&s sangra que todo lo dem&s$ Esto es lo que" como ya di'e" llamamos indentaci#n$ Es para de'ar el c#digo
m&s legible" de este modo se entiende bien que la instrucci#n de la lnea 1J corresponde al IF y la de la lnea 1I
corresponde al else$
?otar que la instrucci#n de la lnea 1J no termina en punto y coma$ Esto se debe a que si as fuera estaramos
quebrando el If" o sea" estaramos diciendo que (asta a( llega esa instrucci#n y luego )endr& otra por separado" pero
sin embargo lo que )iene es un else que es parte del if y por tanto corresponde a la misma sentencia$ En todas las
instrucciones del tipo if.then.else nunca colocar un punto y coma antes del else$
Anidacin de la instruccin If.then:
Es posible colocar un if dentro de otro if$ . esto se lo conoce como anidaci#n y se usa a muy menudo$ 5in
embargo (ay que tener muc(o cuidado de (acerlo bien o podra darse que nosotros creemos que el programa tomar&
cierto camino cuando en realidad no lo (ar&$ Veremos un e'emplo de eso luego del de a continuaci#n2
Veamos un e'emplo en el que se nos pedir& la edad dos )eces$ 5i ingresamos una edad mayor a FE y otra
menor nos dir& que somos )ie'os '#)enes$
1 PROGRAM anidacion;
2
3 Var
4 edad1, edad2: integer;
5
6 BEGIN
L Write(Ìngresa tu edad: `);
I Readln(edad1);
P Write(Ìngresa tu edad nuevamente: `);
1E Readln(edad2);
11
12 If edad1>50 then
13 If edad2<50 then
14 Writeln(Ères un viejo joven');
15
16 END.
;omo )emos" nuestro programa nos pide el ingreso de nmeros enteros que corresponden a nuestra edad$ En
la lnea 12 decimos si el valor en edad1 es mayor a 50 entonces si el valor en edad2
es menor a 50 escribe Ères un viejo joven'$
Anidacin de un if.then con un if.then.else:
Es posible (acer todas las anidaciones que se quieran" sin embargo como ya di'e antes" debemos tener
cuidado$ .qu dar, un e'emplo de una anidaci#n que nosotros podramos interpretar de forma err#nea$
1 PROGRAM anidacion2;
2
3 Var
5
6 BEGIN
L Write(Ìngresa tu edad: ');
I Readln(edad1);
P Write(Ìngresa nuevamente tu edad: `);
1E Readln(edad2);
11
12 If edad1>50 then
13 If edad1=edad2 then
14 Writeln(Ères un viejo')
1F else
1J Writeln(Ères joven');
17
18 END.
En este e'emplo uno podra interpretar que si tenemos m&s de FE a!os y adem&s ingresamos las dos )eces la
misma edad aparecer& el mensa'e YEres un )ie'oZ" y si edad1 era menor a FE nos aparecer& el mensa'e YEres 'o)enZ$
5in embargo no es as" esa instrucci#n se fi'ar& si nuestra edad es mayor a FE y solo si eso es cierto luego )er& si
ambas edades eran iguales" si es as aparecer& el mensa'e YEres un )ie'oZ y si no aparecer& el mensa'e YEres 'o)enZ$ +a
correcta indentaci#n de esa instrucci#n es la siguiente2
If edad1>50 then
If edad1=edad2 then
Wirteln(Ères un viejo')
else
Writeln(Ères un joven');
;omo )en" solo se e'ecutar& esto si edad1>50 resulta ser true$
+a forma correcta de escribir esta instrucci#n para obtener el resultado que interpret&bamos anteriormente
sera2
If edad1>50 then
begin
If edad1=edad2 then
Wirteln(Ères un viejo');
end
else
Writeln(Ères un joven');
;omo )en" (emos encerrado entre begin y end la segunda instrucci#n if$ Esto (ace que todo lo que est,
dentro del &rea abarcada por esas dos palabras sea como una sola instrucci#n para el programa" a pesar de que all
dentro podemos poner todas las que queramos$ %e no (acer esto" el else formara parte del segundo if y no del
primero$ %ebemos recordar que un else cierra siempre al if que se encuentre m&s pr#ximo a ,l$ 1ara quebrar esto
debemos usar begin y end$
+os delimitantes begin y end se usan para indicar que al tomar cierto flu'o de e'ecuci#n dada una condici#n
el programa debe efectuar muc(as instrucciones$ ?o ser)ira de muc(o que por cada if que usemos solo podamos
dictar una instrucci#n$ +a sintaxis gen,rica sera la siguiente2
If condicion then
begin
Instruccion1;
Instruccion2;
.
.
.
InstruccionN;
end
else
begin
Instruccion1;
Instruccion2;
.
.
.
InstruccionN;
end;
Vean que tambi,n es posible usar los delimitantes begin y end para la instrucci#n else del if$ Estos
begin y end forman lo que llamamos bloques de instrucciones y difieren del begin y end principales ya que
estos forman un nico bloque que es el programa completo$ +uego de un end )a enseguida un punto y coma que
indica el final del bloque y no un punto como en el caso del end principal$ ?otar que el end anterior al else no
finaliza con punto y coma$ Esto se debe a lo que ya expliqu, antes$ Recordar que nunca" antes de una instrucci#n
else que forma parte de un if debe ir colocado un punto y coma$
Condiciones compuestas:
Basta a(ora (emos )isto como dada una condici#n especfica el programa tomar& un camino u otro para
realizar sus tareas$ 5in embargo normalmente deben cumplirse )arias condiciones para que un programa tome un
camino u otro$ .qu entramos a componer condiciones" o sea" a decir cosas como2 5i pasa tal cosa y tal otra (as esta
tarea o si pasa tal otra cosa (as esta$
.prenderemos a usar los operadores booleanos para componer condiciones$
Veamos un e'emplo parecido al anterior2
1 PROGRAM anidacion2;
2
3 Var
5
6 BEGIN
L Write(Ìngresa tu edad: ');
I Readln(edad1);
P Write(Ìngresa nuevamente tu edad: `);
1E Readln(edad2);
11
12 If (edad1>50) and (edad1=edad2) then
13 Writeln(Ères un viejo')
14 else
1F Writeln(Ò eres joven o mentiroso');
16
17 END.
.qu )emos que en la instrucci#n KG (ay dos condiciones entre par,ntesis unidas por la palabra reser)ada
.?%$ Esto significa que se e'ecutar& la instrucci#n del KG si ambas condiciones son )erdaderas" o sea" si se cumple a
la )ez que edad1>50 y que edad1=edad2$ asta con que una de ellas sea falsa para que no se e'ecute la
instrucci#n del KG y se pase a la del E+5E$ En ese caso no sabremos si sucedi# porque el usuario era 'o)en o si era un
mentiroso que ingres# dos edades diferentes$
Estas composiciones son e)aluadas por Gree 1ascal con el m,todo conocido como circuito corto$ Esto es que"
si la primera condici#n del .?% es falsa" ya no se e)aluar& la segunda porque aunque esta fuera )erdadera la
condici#n total resulta falsa$ .s nacen las tablas de )erdad$ .?% en ingl,s significa =$
5i nosotros quisi,ramos (aber dic(o que se e'ecute el KG si la primera condici#n la otra eran )erdaderas
deberamos (aber usado el operador OR$ Este es )erdadero si al menos una de las condiciones es )erdadera$ -ambi,n
se e)ala por circuito corto" o sea" si la primera condici#n es )erdadera ya no se e)aluar& la segunda porque aunque
resulte falsa la condici#n total OR ser& )erdadera$
Tablas de verdad2
AND
Expresin1 Expresin2 Expresin1 AND Expresin2
-R0E -R0E -R0E
-R0E G.+5E G.+5E
G.+5E -R0E G.+5E
G.+5E G.+5E G.+5E

OR
Expresin1 Expresin2 Expresin1 OR Expresin2
-R0E -R0E -R0E
-R0E G.+5E -R0E
G.+5E -R0E -R0E
G.+5E G.+5E G.+5E
Existe tambi,n el operador booleano ?O- que niega una condici#n" o sea" da el )alor opuesto a esta$ En
principio uno se pregunta para que ser)ira algo como eso$ D&s adelante cuando comencemos a traba'ar con la
)ariables boolean )eremos el uso de este operador$ Veamos su tabla2
NOT
Expresin NOT Expresin
-0RE G.+5E
G.+5E -R0E
Operadores relacionales: 5on los que comparan dos expresiones2
Operador Expresin comparativa Significado
U . U . es igual a
[ . [ . es mayor que
\ . \ . es menor que
[U . [U . es mayor o igual a
\U . \U . es menor o igual a
\[ . \[ . es distinto de
Un ejemplo matemtico: ien$ Baremos un programa en el cual aplicaremos casi todo lo dado (asta a(ora$
5e nos pide realizar un programa que calcule las races de polinomios de segundo grado cuyos coeficientes ser&n
ingresados por el usuario" y muestre en pantalla los mensa'es correspondientes$
1or si alguno de ustedes no est& bien familiarizado con polinomios explicar, bre)emente lo que es uno de
segundo grado$
0n polinomio es una funci#n matem&tica con una nica inc#gnita X la cual est& ele)ada a distintos
exponentes en los diferentes t,rminos de la ecuaci#n$ 1ara que se )ea me'or" un polinomio de segundo grado tiene la
forma aX
2
+ bX + c donde a, b y c son nmeros reales$ 1or e'emplo" un polinomio podra ser 2X
2
+ 4X + 2$ +os
nmeros que acompa!an a las X :a" b y c< son llamados coeficientes$
+as races de un polinomio son aquellos )alores de X que (acen que la ecuaci#n sea nula" o sea" que )alga E$
En el e'emplo que tenemos all" una raz de ese polinomio es A1$ 5i cambiamos la inc#gnita N por A1 efecti)amente
)emos que todo se anula2
2T:A1<
2
@ 4T:A1< @ 2 U 2T1 ] 4 @ 2 U 2 ] 4 @ 2U A2 @ 2 U E$
%ado un polinomio de segundo grado puede suceder que tenga dos races diferentes" una nica raz :llamada
raz doble< o que no tenga raz$ 1ara (allar las races de un polinomio aX
2
+ bX + c se usa la conocida f#rmula de
ascaras2
-b\(b
2
-4à`c)
2à
El t,rmino ba'o la raz cuadrada (b
2
-4à`c) es llamado discriminante ya que de ,l depende si el polinomio
tiene dos races" una sola o no tiene$ 5i el discriminante es mayor que E efecti)amente tendremos dos races distintas
ya que por la forma de la f#rmula tenemos un que di)ide la f#rmula en dos partes" por un lado resol)emos la
ecuaci#n con el signo de @ luego de ]b" y luego resol)emos la f#rmula con el signo de ] luego del ]b2
-b+\(b
2
-4à`c) -b-\(b
2
-4à`c)
2à 2à
Esto dar& dos resultados diferentes" cada uno correspondiendo a una raz$
5i el discriminante es nulo" o sea igual a E" la raz cuadrada de E es igual a E" por tanto sera estpido separar
en dos la ecuaci#n ya que (acer ]b@E o ]bAE da exactamente igual" por lo cual el resultado ser& nico$ En este caso
tenemos una nica raz doble$
5i el discriminante es menor que E no podremos (allar su raz cuadrada ya que no existe raz de un nmero
negati)o$ En este caso la f#rmula no puede resol)erse y decimos que no existen races reales$ En este caso pueden
(allarse races comple'as" pero eso no lo (aremos a(ora ya que tiene sentido solo para aquellos que se lle)en bien con
las matem&ticas$
Duy bien" teniendo cierto conocimiento sobre el problema comencemos a plantearnos como lo resol)eremos
para programarlo$ El usuario ingresar& en la entrada est&ndar los coeficientes a, b y c de nuestro polinomio$ -eniendo
esos )alores primero debemos )erificar que el )alor a sea distinto de E ya que de ser as no estaramos enfrent&ndonos
a un polinomio de segundo grado sino a uno de grado uno o cero$
+uego deberemos e)aluar el discriminante y segn lo que este de c#mo resultado tomaremos tres caminos
distintos para mostrar los resultados al usuario$
1 PROGRAM polinomio;
2
3 Var
4 a, b, c: real; //Los coeficientes del polinomio.
5 discriminante: real; //El discriminante.
6 raiz1, raiz2: real; //Las races del polinomio.
7
8 BEGIN
9 //Pedimos al usuario el ingreso de datos y leemos los mismos.
10 write('Ingrese los coeficientes separados por espacio: ');
11 readln(a,b,c);
12
13 //Verificamos que el coeficiente a sea no nulo.
14 If a=0 then
15 writeln('Usted no ha ingresado un polinomio de segundo grado.')
16 else
17 begin
18 //Calculamos el discriminante.
19 discriminante:= sqr(b)-4*a*c;
20
21 //Tomaremos los tres caminos segn el valor discriminante.
22 If discriminante=0 then
23 begin
24 //El polinomio tiene una nica raz.
25 raiz1:= -b/(2*a);
26 writeln('El polinomio tiene una raz doble: ',raiz1:2:2);
27 end
28 else
29 If discriminante>0 then
30 begin
31 //El polinomio tiene dos races.
32 raiz1:=(-b+sqrt(discriminante))/(2*a);
33 raiz2:=(-b-sqrt(discriminante))/(2*a);
34
35 writeln('El polinomio tiene dos races reales:
',raiz1:2:2,' y ',raiz2:2:2);
36 end
37 else
38 writeln('No existen races reales.');
39 end; //Fin de la instruccin ELSE del IF principal.
40 END.
Duy bien" como primera cosa les dir, que a pesar de la explicaci#n que yo pueda dar aqu ser& con)eniente
que ustedes mismos estudien este programa para comprenderlo bien$ ?o es para nada complicado pero puede resultar
confuso gracias a las anidaciones que se (an (ec(o de las funciones KGV-BE?VE+5E$
En las lneas 4" F y J declaramos todas las )ariables necesarias para que nuestro programa funcione
correctamente$
En la lnea nmero 11 leemos los tres coeficientes a la )ez$ +uego tenemos un KGV-BE?VE+5E principal
que" si el coeficiente a es igual a cero mostrar& un mensa'e de error al usuario y solo en caso contrario pasar& a
realizar todas las dem&s tareas en su instrucci#n else$ En ese caso calculamos primero el discriminante ya que de ,l
depender&n los caminos a tomar$ Obser)ar que al (acerlo :en la lnea 1P< usamos la funci#n sqr que calcula el
cuadrado de un nmero$ En )ez de eso podramos (aber puesto b*b que es lo mismo$
5i el discriminante es igual a E mostraremos al usuario la raz doble" sino" si el discriminante es mayor que E
calculamos y mostramos ambas races" y en caso contrario le diremos al usuario que no existen races reales$
Es importante que entiendan el uso de los begin y end en este programa$ Recuerden que estos delimitan
bloques de programa los cuales son )istos como una nica instrucci#n$ 5i escribiera el c#digo anterior a partir del
primer KG de modo que en cada sentencia tu)i,ramos una nica instrucci#n quedara as2
If condicion1 then
Instruccion1
Else
Begin
//Aqu debera estar el clculo del discriminante.

If condicion2 then
Instruccion2
Else
If condicion3 then
Instruccion3
Else
Instruccion4;
End;
Esto" si tom&ramos todo lo que est& entre el E>K? y el E?% que )emos all como una nica instrucci#n
quedara simplemente como
If condicion1 then
Instruccion1
Else
Instruccion2;
donde la Instruccion2 sera todo el enorme bloque entre el E>K? y E?%$
Instruccin de seleccin CASE.ELSE:
+a instrucci#n ;.5E que )eremos a continuaci#n podra considerarse como la forma correcta de escribir una
enorme cantidad de KG anidados$ Veamos primero un e'emplo anidando KG en el cual el programa despliega al usuario
)arias opciones y dependiendo de lo que ,ste seleccione ser& lo que (ar&2
1 PROGRAM menu;
2
3 Var
4 opcion: char;
5 numero: integer;
6
7 BEGIN
8 writeln('1--> Muestra un mensaje en pantalla');
9 writeln('2--> Ingresar un nmero');
10 writeln('3--> Ingresar un caracter');
11
12 write('Ingrese una opcion y presione ENTER: ');
13 readln(opcion);
14
15 writeln;
16
17 If opcion='1' then
18 writeln('MENSAJE DESPLEGADO')
19 else
20 if opcion='2' then
21 begin
22 write('Ingrese un nmero entero: ');
23 readln(numero);
24 writeln('Ha ingresado ',numero,'.');
25 end
26 else
27 if opcion='3' then
29 begin
30 write('Ingrese un caracter: ');
31 readln(opcion);
32 writeln('Ha ingresado ',opcion);
33 end
34 else
35 writeln('ERROR. No existe la opcin ',opcion);
36 END.
En este e'emplo traba'aremos por primera )ez con una )ariable del tipo c-ar" o sea que contendr& caracteres"
no una cadena como el tipo string sino uno solo$ Esto es por un simple moti)o$ .l ser del tipo c-ar cualquier smbolo
que ingresemos ser& ledo sin problemas$ ?osotros mostramos las opciones del men con nmeros" entonces uno
podra decir que para leer la opci#n que el usuario ingrese podramos (aber declarado una )ariable integer o real" sin
embargo de (acerlo as" si el usuario en )ez de ingresar un nmero ingresa una letra el programa dar& un error en
tiempo de e'ecuci#n al intentar almacenar una letra en una )ariable num,rica y se cerrar&$ 5in embargo" al ser del tipo
c-ar" si el usuario ingresa una letra esta se leer& sin problemas y podremos desplegar al usuario un mensa'e de error
que indique que (a seleccionado una opci#n incorrecta" y de ser posible pedirle que lo intente de nue)o$
?otar como en las condiciones de los KG comparamos el car&cter ledo en la )ariable opcion con un car&cter
escribiendo este entre comillas simples$ Es importante saber que si el usuario ingresa un 1 en su entrada" nosotros
leeremos el car&cter 1 y ?O el nmero 1$ El car&cter 1 es como una letra o un smbolo" no es un nmero que se puede
sumar o restar" es un smbolo$ %el mismo modo que uno no puede sumar letras" a@b por e'emplo" no se pueden sumar
caracteres num,ricos$ ?o es lo mismo 1 que Y1Z$ El primero es un nmero y el otro un car&cter$ Y1Z@Z2Z equi)ale a la
cadena Y12Z" y 1@2 es igual a 3$ Esta diferencia resulta esencial" es importante que lo comprendan$
?o (e puesto comentarios en este programa aprop#sito para que ustedes lo lean y entiendan por s solos$
&sicamente decimos" si el usuario ingresa el 1 muestra un mensaje, sino, si el
usuario ingresa el 2 pide que ingrese un numero y mustraselo, sino, si el
usuario ingresa el 3 pdele que ingrese un carcter y mustraselo, sino dile
que lo que ha ingresado no es una opcin correcta.
.(ora )eamos el mismo programa usando la instrucci#n ;.5E2
1 PROGRAM menu;
2
3 Var
4 opcion: char;
5 numero: integer;
6
7 BEGIN
8 writeln('1--> Muestra un mensaje en pantalla');
9 writeln('2--> Ingresar un nmero');
10 writeln('3--> Ingresar un caracter');
11
12 write('Ingrese una opcion y presione ENTER: ');
13 readln(opcion);
14
15 writeln;
16
17 Case opcion of
18 '1': writeln('MENSAJE DESPLEGADO');
19 '2': begin
20 write('Ingrese un nmero entero: ');
21 readln(numero);
22 writeln('Ha ingresado ',numero,'.');
23 end;
24 '3': begin
25 write('Ingrese un caracter: ');
26 readln(opcion);
27 writeln('Ha ingresado ',opcion);
28 end;
29 else
30 writeln('ERROR. No existe la opcin ',opcion);
31 end; //De la instruccin CASE.
32 END.
Basta la lnea 1J nuestros e'emplos son exactamente iguales$ .(ora" en la lnea 1L en )ez de tener un KG
tenemos la declaraci#n de la instrucci#n ;.5E$ 5u sintaxis es la siguiente2
Case variable of
Etiqueta1: instruccion1;
Etiqueta2: instruccion2;
...
EtiquetaN: instruccinN;
Else
Intruccion_por_defecto;
End;
Esta instrucci#n se fi'ar& en el )alor de la )ariable colocada entre la palabra ;.5E y la palabra OG" en nuestro
e'emplo se trata de la )ariable opcion$ +uego tomar& el camino en el cual el )alor de la )ariable sea igual al de la
etiqueta$ El E+5E al final indica lo que se debe (acer si la )ariable no corresponde con ninguna de las etiquetas
anteriores$ Este E+5E puede ir o no$ 5i no est& no se e'ecutar& nada y se continuar& con lo que (aya deba'o en el
c#digo" pero no (abr& error$ En este caso (emos usado el E+5E par decir al usuario que no ingres# nada de lo
esperado$ ?otar que antes de este E+5E s debe ir un punto y coma que cierre la instrucci#n anterior" no como en el
caso de los E+5E que se usan en una instrucci#n KG$
5iempre al final de la instrucci#n ;.5E debe ir un E?% que finalice en punto y coma para indicar el final de
esta instrucci#n$ ?o colocarlo es un error de sintaxis$
?otar que las instrucciones para cada etiqueta pueden ser bloques de instrucciones delimitados por sus
respecti)os E>K? y E?%$
Es importante saber que las etiquetas representan los )alores que debe tomar la )ariable del encabezado del
;.5E para que el programa tome tal o cual camino$ Es posible indicar m&s de un )alor a la )ez en una misma
etiqueta" simplemente separando cada )alor por una coma2
Case variable of
Valor1, valor2: instruccion1;
Valor3, valor4, valor5: instruccion2;
. . .
ValorI, valorN: instruccionJ;
KD1OR-.?-E2 +a )ariable del encabezado del ;.5E debe ser de un tipo OR%K?.+" o sea integer. c-ar.
enumerado. boolean o subrango.
Ejercicio: Este es un simple e'ercicio para que usen ;.5E$ *uiero que en un solo programa 'unten los
siguientes e'emplos que )imos (asta a(ora2 el programa BolaDundo de la p&gina 11" el del ^rea de un -ri&ngulo de
la p&gina 1F" el que di)ida dos cifras de la p&gina 1I (abi,ndolo modificado para que muestre un error si se ingresa
la segunda cifra igual a E" y el programa que desglosaba un nmero de cuatro cifras de la p&gina 22 modificado para
que muestre un error si el usuario ingresa un nmero in)&lido" o sea" uno que sea menor a 1EEE o mayor a PPPP$ 5u
programa debe mostrar un men como el siguiente2
1) Hola Mundo
2) Calcular el rea de un Tringulo
3) Dividir dos nmeros reales
4) Sumar los dgitos de un nmero de cuatro cifras
Seleccin:
;uando el usuario eli'a una opci#n su programa (abr& de realizar las tareas pertinentes y en caso contrario notificar
el error$ ?o continen (asta no lograr (acer esto$
Secuencia de repeticin FOR:
.dem&s seleccionar distintos caminos dadas ciertas condiciones" muc(as )eces (ace falta repetir ciertas tareas
segn otras condiciones$ 1or e'emplo" en nuestro programa de polinomios de segundo grado sera con)eniente que si
el usuario ingresa el coeficiente a nulo" adem&s de mostrar el mensa'e de error" el programa )uel)a a pedir que se
ingresen los coeficientes" o si en nuestro programa de la instrucci#n ;.5E" el usuario ingresara una opci#n que no
est& en el men adem&s de notific&rselo sera correcto )ol)er a pedir que ingrese una$
Existen tres estructuras de repetici#nM la que )amos a )er a continuaci#n llamada GOR" y otras dos que
)eremos luego llamadas WBK+EV%O y RE1E.-V0?-K+$
GOR :que en ingl,s significa 1.R. o 1OR< repite una tarea una cantidad especfica de )eces" ni mas ni
menos$ 5u sintaxis es la siguiente2
For variable:= valor_inicial to valor_final do
Instruccin;
1or e'emplo" si quisi,ramos imprimir la letra . unas 1E )eces la declaraci#n del GOR sera algo as2
For i:=1 to 10 do
Write(À');
En este caso )eramos una salida como esta2 AAAAAAAAAA
+a )ariable en el encabezado del GOR debe ser declara 'unto con todas las )ariables del programa$ Esta
)ariable es conocida como #ariable de control del GOR y debe ser de un tipo ordinal$ %e m&s est& decir que el )alor
final debe ser del mismo tipo que el inicial :por e'emplo puede ser for i:= à' to `z' do)$ 5u )alor es
inicializado con el valor_inicial del encabezado del GOR$
+a )ariable de control comienza )aliendo 1" el programa imprime una ." luego la )ariable aumenta su )alor a
2 y se imprime la segunda .$ .s (asta que la )ariable alcanza el )alor final$ Esto es muy importante ya que es lo m&s
comn usar la )ariable de control del GOR dentro de las instrucciones que este realiza$ %ebo a!adir que si el GOR (a
de realizar m&s de una instrucci#n en su e'ecuci#n debemos encerrar estas entre un E>K? y un E?%$
Resulta ob)io que GOR" -O y %O son palabras reser)adas de 1ascal$
Veamos un e'emplo en el cual usamos la )ariable de control del GOR$ Kmprimiremos en pantalla los 1E
primeros nmero pares a partir del E sin incluir a este2
1 PROGRAM pares;
2
3 Var
4 i: integer;
5
6 BEGIN
7 write('Los 10 primeros pares son: ');
8
9 For i:=1 to 20 do
10 If i mod 2= 0 then
11 write(i,' ');
12 END.
En la lnea L mostramos al usuario un mensa'e$ En la no)ena lnea comienza la declaraci#n del GOR donde
inicializamos i en 1 y continuaremos (asta que )alga 2E$ El KG en la lnea 1E se encarga de )er si el )alor actual de i
es par" o sea si el resto de di)idirlo entre 2 es igual a E$ En ese caso imprimimos su )alor y un espacio" sino no
(acemos nada y esperamos la siguiente iteraci#n$
.l proceso de repetir )arias )eces un mismo segmento de c#digo se lo llama iteraci#n$ ?uestro GOR iterar& 2E
)eces$
Es importante 'am&s modificar la )ariable de control mientras se est& e'ecutando el GOR" o sea" no (acer por
e'emplo i:= 10 dentro del GOR ya que eso produce errores muy inesperados y dependen muc(o del compilador
usado para crear el programa$ 1uede usarse el )alor de la )ariable de control para todo lo que se necesite" incluso
incluirlo en expresiones y condiciones" pero nunca modificarlo$
.(ora )eamos el mismo programa" pero solo que esta )ez le pediremos al usuario que ingrese cuantos
nmeros pares quiere )isualizar2
1 PROGRAM PrimerosPares;
2
3 Var
4 i, pares: integer;
6 BEGIN
7
8 write('Cuantos pares quieres visualizar? ');
9 readln(pares);
10
11 writeln;
12 write('Los primeros ',pares,' pares son: ');
13
14 pares:= pares*2;
15
16 For i:=1 to pares do
17 If i mod 2= 0 then
18 write(i,' ');
19 END.
En la lnea I mostramos el mensa'e al usuario para" en la siguiente lnea" pedirle que ingrese cu&ntos pares
desea )er$
En la lnea 11 usamos el procedimiento writeln sin par&metros para que imprima una lnea en blanco$ En la
lnea 12 mostramos un mensa'e al usuario$
En la lnea 14 (ay algo nue)o$ . la )ariable pares le asignamos su )alor anterior multiplicado por 2 ya que si
el usuario desea )er" por e'emplo" los diez primeros pares nosotros deberamos iterar del 1 al 2E$ Esto de asignar a
una )ariable un )alor que depende de su )alor anterior es muy comn en la programaci#n$ . dic(as )ariables se las
conoce como acumuladores$ Esto lo )eremos en m&s detalle cuando traba'emos con WBK+E y RE1E.-$
En la lnea 1J cambiamos el )alor final del encabezado del GOR por la )ariable pares$ Esto es lo m&s comn
en el uso de esta instrucci#n$ ?o (ace falta indicar un )alor nosotros mismos" sino que podemos colocar nombres de
)ariables" constantes o incluso expresiones matem&ticas siempre y cuando el tipo de la )ariable de control y el del
)alor final sean el mismo y estos sean ordinales$
Anidacin del FOR:
Veamos un e'emplo donde el usuario ingresar& un nmero que indicar& el largo del lado de un cuadrado y
dibu'aremos este con el car&cter T2
1 PROGRAM Cuadrado;
2
3 Const
4 caracter= '*';
5
6 Var
7 i, j, lado: integer;
8
9 BEGIN
10 write('Ingresa el largo del lado: ');
11 readln(lado);
12
13 writeln;
14
15 For i:=1 to lado do
16 begin
17 For j:=1 to lado do
18 write(caracter);
19
20 writeln;
21 end;
22 END.
+o interesante en este programa es analizar lo que sucede desde la lnea 1F en adelante$ -enemos dos GOR"
uno dentro de otro$ +o primero a resaltar es el uso de dos )ariables de control diferentes" una para cada GOR$ 5i
us&ramos la misma )ariable para ambos uno modificara la del otro y se ocasionara un caos$ 5i quieren prueben este
programa as como est& y luego con la misma )ariable de control$ Es probable que el compilador los rega!e por eso y
se produzca un error en tiempo de compilaci#n$
Veamos" cuando i )ale 1 entramos al GOR principal$ .ll tenemos otro GOR el cual se e'ecutar& (asta el final
antes de )ol)er al primer GOR$ ;uando j )ale 1 imprimimos un T :est& definido en la constante caracter<$ +uego j
)ale 2 y se imprime un segundo T en la misma lnea ya que estamos usando un procedimiento write$ .s
continuamos (asta que se imprimen tantos T en una lnea como lo indique la )ariable largo$ .(ora pasamos a la lnea
2E del programa donde est& writeln para escribir una lnea en blanco" o sea" para ba'ar un rengl#n$ .(ora i )ale 2$
Vol)emos a entrar en el GOR principal y el GOR de dentro )uel)e a comenzar con j en 1$ Kmprime los T" se ba'a un
rengl#n y as (asta que i sea igual al )alor de la )ariable lado$
?otar que la instrucci#n writeln de la lnea 2E est& dentro del GOR principal pero no forma parte del GOR
interno$
Otra forma del GOR es la siguiente2
For variable:=valor_inicial downto valor_final do
Instruccin;
Esto funciona exactamente igual a la forma anterior del GOR con la diferencia de que valor_inicial es
mayor que valor_final$ O sea que la )ariable de control ir& decreciendo en )ez de aumentar$ 1or e'emplo2
For i:=20 downto 1 do
Instruccion;
En este caso i comenzar& )aliendo 2E" luego 1P" luego 1I" y as (asta llegar al 1$
?O-.52 ?unca asuman el )alor que tendr& la )ariable de control una )ez finalizado el GOR$ En este e'emplo
de GOR que )a de 2E a 1 uno podra decir que i )ale 1 al final" pero esto puede no ser as y depende del compilador$
5i )an a )ol)er a usar esta )ariable deber&n inicializarla ustedes mismos con el )alor apropiado$
. continuaci#n les planteo una serie de e'ercicios de aplicaci#n del GOR y algunos temas ya )istos$ 1or fa)or"
no continen si no son capaces de resol)er estos e'ercicios$ 5i realmente se trancan con alguno en)enme un eAmail a
mstr)ladi3(otmail$com explic&ndome cual e'ercicio les est& dando problemas y les ayudar, o les en)iar, la soluci#n$
Ejercicio 1: %eterminen cu&les de los siguientes fragmentos de c#digo producen la misma salida2
a< FOR i:=1 TO 3 DO
FOR j:= i+1 TO 3 DO
write(i,j)
b< FOR i:=1 TO 3 DO
write (i, i+1)
c< FOR i:=1 TO 4 DO
IF (i=1) OR (i=4) THEN
write(i)
ELSE
write(i,i)
Ejercicio 2: Escriban un programa que lea desde el teclado un )alor entero n$ . continuaci#n" el programa
deber& leer n enteros y luego desplegar el mayor y el menor de ellos$
E'emplo de entrada2
n=8
Ingrese 8 enteros: 5 12 36 4 21 95 12 18
E'emplo de salida2
El mayor entero ingresado es: 95
El menor entero ingresado es: 4
Ejercicio 3: Escriban un programa que lea de la entrada est&ndar F )alores positi)os" todos menores que JE y
produzca una gr&fica de barras (orizontales similar a la que se muestra en el e'emplo para estos datos2
E'emplo de entrada2
Ingrese 5 valores: 5 12 17 35 8
E'emplo de salida2
*****
************
*****************
***********************************
********
Ejercicio 4: Escriban un programa que lea de la entrada est&ndar un car&cter c y un entero n$ El programa
debe desplegar un tri&ngulo de n lneas formado por el car&cter c segn se muestra en el siguiente e'emplo2
E'emplo de entrada2
n=8
c=$
E'emplo de salida2
$$$$$$$$
$$$$$$$
$$$$$$
$$$$$
$$$$
$$$
$$
$
DEBUGER
.ntes de continuar quiero que aprendan a usar el %E0>ER :depurador< de Gree 1ascal para que puedan testear sus
programas cuando tengan problemas con ellos$
1rimero que nada necesitar&n )er la )entana watches que es la que les mostrar& los )alores que tomen sus )ariables$ 1ara
acceder a ella )allan al men Debug Watches$ %eber&n disminuir el tama!o de la )entana de su c#digo para poder )er ambas
a la )ez$ 1ara ello selecci#nenla para que quede acti)a y presionen Ctrl+F5" el borde quedar& )erde$ 1ueden mo)erla con las flec(as
de direcci#n y cambiar su tama!o manteniendo presionada Shift cuando presionen una flec(a$ ;uando (ayan a'ustado el tama!o a
uno que les sir)a deben agregar a la )entana W.-;BE5 las )ariables que necesitan )er$ 1ara ello )allan al men Debug Add
watch o presionen Ctrl+F7$ En el cuadro de di&logo ingresen el nombre de la )ariable a obser)ar y esta aparecer& en la )entana
W.-;BE5$ .greguen tantas )ariables como quieran$
.(ora deben e'ecutar su programa paso a paso$ 1ara ello" una )ez compilado" )allan al men R0? y eli'an 5-E1 OVER$
.(ora su programa comenzar& pero estar& detenido$ 1resionen F7 o F8 para a)anzar una lnea$ El programa solo a)anzar& al
presionar una de estas teclas$ +a diferencia entre una y otra es que F8 no entrar& en los procedimientos y funciones :lo )eremos
luego< y F7 si lo (ar&$
;ada )ez que a)ancen )er&n como se modifican sus )ariables$
-ambi,n pueden ir )iendo la pantalla de salida mientras usan el debuger" para ello )ayan al men Debug Output y
les aparecer& la salida$ %eber&n a'ustar el tama!o de cada )entana para que puedan )er todas a la )ez$
Secuencia de repeticin WHILE.DO:
Bemos )isto la repetici#n GOR que se e'ecutaba una cierta cantidad de )eces estipulada" ni m&s ni menos$ 5in
embargo" aunque GOR resulta muy til para muc(as tareas" (ay cosas que necesitan una repetici#n que est,
controlada por una o m&s condiciones$
1or e'emplo" imaginen un programa que pide un c#digo de entrada a un usuario$ El usuario tiene F intentos
posibles para introducir el c#digo correcto$ 5i el usuario se equi)oca el programa le notifica el error" indica cuantos
intentos le quedan y le )uel)e a pedir el c#digo$ 5i el usuario acierta antes de que se le acaben los intentos el
programa ya no le pedir& el c#digo y continuar& su curso$ 5i el usuario gast# todos sus intentos sin adi)inar el
programa se cerrar&$
.qu tenemos una repetici#n que puede detenerse por dos cosas" que el usuario acierte el c#digo o que gaste
sus intentos$ Es imposible saber en qu, intento el usuario acertar& el c#digo por lo cual una instrucci#n GOR no
ser)ira$ Veremos este e'emplo utilizando la secuencia WBK+EV%O :DKE?-R.5VB.5<$
Veamos antes que nada su sintaxis2
While condicion do
Instruccin;
Esto significa" mientras se cumpla la condici#n e'ecuta tu instrucci#n$ 0na )ez (ec(a la instrucci#n" while
regresar& a su encabezado y )ol)er& a )erificar la condici#n$ 5i esta sigue siendo )erdadera )ol)er& a e'ecutarse$ En
caso contrario saltear& la instrucci#n y el programa continuar& su curso$ ?o est& de m&s decir que la condici#n puede
ser compuesta y que la instrucci#n puede ser un bloque de instrucciones delimitado por E>K? y E?%$
Veamos el e'emplo del c#digo a adi)inar2
1 PROGRAM codigo;
2
3 Const
4 max_intentos= 5;
5 codigo_secreto= 107;
6
7 Var
8 codigo_ingresado, intento: integer;
9 adivino, perdio: boolean;
10
11 BEGIN
12 //Inicializamos los booleanos en false.
13 adivino:= false;
14 perdio:= false;
15
16 intento:=0; //Todava no ha intentado adivinar.
17
18 While (not adivino) and (not perdio) do
19 begin
20 writeln('Intentos restantes: ',max_intentos-intento);
21
22 intento:= intento+1; //Aumentamos 1 al intento actual.
23
24 write('INGRESE CDIGO DE ACCESO: ');
25 readln(codigo_ingresado); //Leemos el cdigo.
26
27 If codigo_ingresado=codigo_secreto then
28 adivino:= true
29 else
30 writeln('ERROR. CDIGO INCORRECTO.');
31
32 writeln;
33
34 If (not adivino) and (intento=max_intentos) then
35 perdio:= true;
36
37 end; //Del WHILE.
38
39 If adivino then
40 writeln('Felicidades. Adivin.')
41 else
42 writeln('No acert el cdigo en ',max_intentos,' intentos.');
43
44 END.
%efinimos para este programa" dos constantes" una llamada max_intentos que contiene la cantidad m&xima
de intentos que el usuario tiene para adi)inar el c#digo y otra llamada codigo_secreto que contiene el )alor num,rico
que el usuario debe adi)inar$ +uego declaramos las )ariables codigo_ingresado que ser& la que guardar& el )alor que
el usuario ingrese y otra llamada intento que dir& la cantidad de )eces que el usuario (a intentado adi)inar (asta el
momento$
En este e'emplo )emos por primera )ez uno de los usos de las )ariables booblean$ En este caso declar, dos"
una llamada adivino que indicar& el momento en el cual el usuario adi)ine el c#digo" y otra llamada perdio que
indicar& si el usuario (a gastado todos sus intentos sin adi)inar el c#digo$
;omenzamos inicializando ambos booleanos con el )alor ,alse ya que el usuario ni (a adi)inado ni (a
perdido$ -ambi,n inicializamos la )ariable intento con el )alor E ya que el usuario an no (a comenzado$ Es
importante siempre inicializar las )ariables con los )alores apropiados y no asumir que ya lo tienen$ Es comn que
uno suponga que el )alor de intento sea E ya que no se le asign# nada (asta el momento" pero esto no es as" depende
muc(o del compilador que se use$
;uando uno declara una )ariable de algn tipo" esta puede tomar un )alor cualquiera al azar que es
desconocido por el usuario :basura<$ Bay compiladores que las inicializan con algn )alor especfico$ 5in embargo" al
crear un soft/are" nunca sabemos en el futuro cuando deberemos modificarlo o si debemos pasarle nuestro c#digo a
algn otro programador para que ,l traba'e con este$ 5i la otra persona usa un compilador diferente entonces el
programa probablemente no funcione como debe$
SIEMPRE INICIALIZAR LAS VARIABLES!!!
En la lnea 1I comienza el encabezado del WBK+E cuyas instrucciones estar&n en un bloque que )a desde el
E>K? de la lnea 1P (asta el E?% de la lnea 3L$
Veamos el encabezado del WBK+E ya que all las condiciones est&n dadas por los booleanos$ While (not
adivino) and (not perdio) do es equi)alente a decir While (adivino= false) and (perdio=
false) do" o sea" estamos diciendo" Mientras adivino es falsa y perdio es falsa has :y all
comienzan todas las instrucciones<$ ?otar que la condici#n es una condici#n compuesta y que ser& )erdadera en tanto
ambas condiciones comprendidas entre el operador .?% sean )erdaderas" o sea" cada condici#n es )erdadera si los
booleanos son falsos$ Esto es confuso" pero analcenlo por un minuto$ ?otros estamos preguntando 8adivino es
falsa9 5i es as la respuesta es 5K" entonces pregunta 8perdio es falsa9 5i esta respuesta tambi,n es 5K la condici#n
es )erdadera$ +a condici#n" no las )ariables$
;uando uno est& preguntado por el )alor de un booleano no (ace falta escribir esto como una comparaci#n$
G'ense que el encabezado del WBK+E no est& escrito como la segunda alternati)a que d" o sea" si uno quisiera decir
WHILE (variable= true) DO solo debe escribir WHILE (variable) DO$ 0sar el nombre de un booleano
en una condici#n ya es preguntar por si es -R0E$ %el mismo modo si uno quiere preguntar por si es G.+5E" como
en nuestro programa" debe anteponer el operador ?O- antes del nombre del booleano$
ien" nuestro WBK+E funcionar& en tanto ambos booleanos sean G.+5E" basta que uno no lo sea para que la
condici#n .?% sea falsa y por tanto no se e'ecute el WBK+E$ ;omo nosotros inicializamos ambos booleanos con
G.+5E sabemos que la primera )ez que el programa llegue al WBK+E su condici#n ser& )erdadera y por tanto se
e'ecutar& al menos una )ez$
.nalicemos todo el bloque que compone al WBK+E$ +o primero que (acemos es mostrar al usuario un
mensa'e que indica sus intentos restantes$ Este nmero es restar el intento actual menos max_intentos$
En la lnea 22 aumentamos en 1 el )alor de intento ya que el usuario intentar& adi)inar$ Esta es la idea de
acumulador que nombr, anteriormente$ +a instrucci#n intento:= intento+1 asigna a la )ariable intento su
)alor anterior m&s uno$ 5i intento )aliera I esa instrucci#n equi)aldra a decir intento:= 8+1$ Este es el
procedimiento general para usar contadores" por e'emplo un programa que cuente la cantidad de palabras en un texto"
los caracteres" etc$
En las lneas 24 y 2F mostramos al usuario el mensa'e que le indica que ingrese un c#digo y luego lo leemos$
Este es ingresado como un entero$ 5i el usuario ingresa otros smbolos que no sean num,ricos nuestro programa se
cerrar& abruptamente$ D&s adelante )eremos como recibir una cadena de caracteres num,ricos y pasar estos a
nmeros enteros o reales para lograr un )erdadero control de errores por parte del usuario$ 5in embargo eso no es
pertinente en este momento y asumimos que siempre recibiremos un entero en la entrada est&ndar$
En la lnea 2L usamos un KG para decir que si el c#digo ingresado por el usuario es igual al que deba adi)inar"
la )ariable booleana adivino cambie su )alor a -R0E$ 5i esto sucediera" cuando el WBK+E )uel)a a su encabezado
para e)aluar la condici#n esta ser& falsa y ya no se e'ecutar&$ En caso de que el usuario no adi)ine" el KG pasar& a su
instrucci#n E+5E en donde imprimimos un mensa'e al usuario que le notifica de su error$ +uego damos una
instrucci#n de salto de lnea$
En la lnea 34 tenemos una instrucci#n KG que en caso de que el usuario no (aya adi)inado el c#digo y (aya
alcanzado el m&ximo nmero de intentos cambiamos el )alor de la )ariable perdio a -R0E$ G'ense que el KG tiene
una instrucci#n compuesta$ -al )ez alguno de ustedes se pregunte 8por qu, no simplemente cambias el )alor de
perdio a -R0E cuando el usuario (aya alcanzado el nmero m&ximo de intentos9 Entonces yo preguntara 8que
pasara si el usuario adi)ina 'usto en el ltimo intento9 .n as se encendera la )ariable perdio aunque no (aya
perdido :llamo encender a que su )alor sea -R0E<$ En ese caso perdio y adivino seran -R0E y eso estara mal$
.qu termina el bloque del WBK+E y el programa )ol)er& a la lnea 1I para e)aluar de nue)o la condici#n de
iteraci#n$ 5i esta es falsa entonces se saltear& todo el bloque y pasar& directo a la lnea 3P" sino )ol)er& a entrar en el
bloque del WBK+E$
=a fuera del WBK+E simplemente )erificamos con un KG cu&l fue el moti)o por el que salimos del WBK+E y
notificamos al usuario de ello$
El uso que dimos aqu de las )ariables booleanas es conocido como 0anderas 0ooleanas ya que nuestras
)ariables se encender&n cuando se cumpla alguna condici#n y nos a)isar&n algo$ 5era como le)antar una bandera
para indicarle algo a alguien$ El uso de banderas booleanas es muy comn aunque en principio uno no lo crea$ .
medida que la pr&ctica en programar es mayor se comprende me'or a los booleanos y su uso aumenta$ =o en
particular (ago muc(o uso de ellos" llegando incluso a abusarme un poco" cosa que no es aconse'able ya que el
c#digo puede )ol)erse confuso$
Duy bien" a(ora que ya conocen el uso de WBK+E es (ora de darle pr&ctica$ *uiero que modifiquen el
programa del tri&ngulo para que cuando el usuario ingrese base o altura con un )alor nulo o negati)o el programa le
notifique su error y )uel)a a pedrselo$ .suman que el usuario siempre ingresa nmeros reales en la entrada" no se
preocupen toda)a por si ingresa otros caracteres$
-ambi,n modifiquen el programa que efectuaba una di)isi#n entre dos nmeros de modo que si el usuario
ingresa el )alor del cociente como E el programa se lo indique y )uel)a a pedrselo$
Bagan lo mismo con el programa que desglosaba un nmero de cuatro cifras$ 5i el usuario ingresa un nmero
in)&lido )uel)an a pedrselo (asta que sea )&lido$
Un pequeo juego: +os tres e'ercicios anteriores corresponden a modificar c#digos ya (ec(os por m y a reA
modificar lo que ya (aban (ec(o en los e'ercicios anteriores" que aunque no es del todo f&cil es m&s sencillo que
dise!ar un programa desde E$ .(ora les plantear, un peque!o 'uego para que lo (agan$ 1odr&n usar todo lo que
(emos )isto (asta el momento$ Este 'uego se centrar& en el uso del WBK+E$ El problema es el siguiente2
0n 'ugador deber& adi)inar en un m&ximo de 1F intentos un nmero entre 1 y 1EE$ 5i el 'ugador adi)ina" el
programa se lo notificar& y terminar& su e'ecuci#n" en caso contrario el 'ugador recibir& una pista para )ol)er a
intentar adi)inar$ El 'uego le dir& si el nmero que debe adi)inar es mayor o menor que el que (a ingresado y el
'ugador )ol)er& intentarlo$
En cada caso el 'uego deber& mostrar al 'ugador el nmero de intento actual y cuantos restantes le quedan$
;uando el usuario pierda" el programa deber& mostrar cu&l era el nmero que deba adi)inar$ 5iempre
asumiremos que recibiremos un entero desde la entrada$
El nmero a ser adi)inado ser& generado al azar por el 'uego :ya explicar, esto a continuaci#n<$
E'emplos de e'ecuci#n2
Ejemplo 1:
Dispones de 15 intentos para adivinar.
1)--> 98
Muy bien!!! Has adivinado!!!
Ejemplo 2:
1)--> 99
Lo siento, no has acertado.
El nmero que debes adivinar es menor.
2)--> 80
El nmero que debes adivinar es mayor.
3)--> 85
Muy bien!!! Has adivinado!!!
Ejemplo 3:
1)--> 60
El nmero que debes adivinar es menor.
. . .
15)--> 13
Lamentablemente has perdido. El nmero era 10.
Generar nmeros aleatorios: 1ara obtener un nmero al azar se utiliza la funci#n random$ 5u sintaxis es la
siguiente2
Random(x) donde N es un entero que marca el nmero m&ximo que se puede generar$ Random(x)
de)ol)er& un nmero aleatorio entre E y NA1$ 1or e'emplo" si escribimos random(50) obtendremos un nmero al
azar entre E y 4P inclusi)e$
Veamos un e'emplo sencillo en el que el usuario ingresa cu&l es el tope y el programa le de)ol)er& un nmero
aleatorio entre 1 y el nmero ingresado$ .sumimos que el usuario ingresar& un entero mayor que 12
1 PROGRAM funcion_random;
2
3 Var
4 x, valor_aleatorio: integer;
5
6 BEGIN
7 randomize;
8
9 write('Ingrese un valor: ');
10 readln(x);
11
12 valor_aleatorio:= random(x) + 1;
14 writeln('El nmero obtenido entre 1 y ',x,' es:
',valor_aleatorio);
15 END.
ien" este programa es bien sencillo de entender$ -enemos dos )ariables" x y valor_aleatorio$ +a
primera ser& leda desde la entrada y guardar& el )alor ingresado por el usuario$ +a segunda guardar& el nmero al
azar obtenido por la funci#n random$
+o primero a notar es que en la lnea L (acemos una llamada al procedimiento randomize$ Este no lle)a
par&metro alguno" simplemente indica que luego en algn momento del programa ser& utilizada la funci#n random$
5i no (acen esto no podr&n usar esta funci#n y tendr&n un error en tiempo de compilaci#n$
En la lnea 1E obtenemos el )alor de N$ En la lnea 12 asignamos a valor_aleatorio el )alor obtenido
por random(x) m&s 1$ 81or qu, m&s 19 5i random:x< genera un nmero aleatorio entre E y NA1 pero nosotros
queremos uno entre 1 y N solo basta sumar uno al resultado$ 1or e'emplo" si (ici,ramos random(10) podramos
obtener los nmeros E" 1" 2" 3" 4" F" J" L" I o P$ 5i quisi,ramos un nmero entre 1 y 1E basta sumar uno al )alor
sorteado$ 5i sale el E" al sumar 1 obtenemos el 1$ 5i sale P" al sumar 1 obtenemos el 1E" o sea" corremos todo el
inter)alo un lugar a la derec(a$
.(ora s" ya deberan ser capaces de crear el 'uego del .di)inador$
-oda duda que les sur'a deben en)i&rmela a mstrvladi@hotmail.com $
?O-.52 En el e'emplo que traba'amos" nosotros usamos un KG para decidir si cambi&bamos el )alor de un
booleano a -R0E$ 5in embargo no es necesario (acerlo as" la siguiente instrucci#n If
codigo_ingresado=codigo_secreto then
adivino:= true
equi)ale a escribir adivino:= codigo_ingresado=codigo_secreto$ %e este modo estamos diciendo que
adivino es true si se cumple la condici#n codigo_ingresado=codigo_secreto$ 5i esto no es as el booleano
ser& G.+5E$ Esto es exactamente igual que la instrucci#n con KG$
Secuencia de repeticin REPEAT.UNTIL:
Esta secuencia funciona de forma muy similar al WBK+E" tanto as que algunos se preguntan cual es su
)erdadero prop#sito$ 5in embargo a )eces resultar& til utilizar RE1E.- y otras )eces ser& me'or utilizar WBK+E$ +a
sintaxis de esta instrucci#n es la siguiente2
REPEAT
Instrucciones;
UNTIL condicion;
;omo primera diferencia notoria entre el WBK+E y el RE1E.- es que el primero )erifica sus condiciones al
inicio y el segundo lo (ace al final$ +a instrucci#n RE1E.- realizar& todas las instrucciones comprendidas entre la
palabra RE1E.- y la palabra 0?-K+" no (ace falta colocar E>K? y E?% para delimitar el bloque$
5i tradu',ramos al espa!ol" esta funci#n significa RE1K-EVB.5-. *0EV a diferencia del WBK+E que
repeta mientras que una condici#n fuera )erdadera" RE1E.- lo (ace (asta que esa condici#n sea )erdadera" o sea"
sigue iterando mientras su condici#n es falsa" no como WBK+E que lo (aca mientras era )erdadera$
;omo diferencia esencial" sabemos que RE1E.- se e'ecutar& siempre al menos una )ez ya que )erificar& su
condici#n de iteraci#n al final" no como WBK+E que podra no e'ecutarse nunca$ Esto es lo que nos dice cuando
con)iene usar uno u otro$ 5i sabemos que nuestro bloque de c#digo siempre se e'ecutar& al menos una )ez es
con)eniente usar un RE1E.- en )ez de un WBK+E" sin embargo no es incorrecto (acerlo aunque s aconse'able$
Centinela: Veremos a(ora" aunque sin usar RE1E.- un e'emplo de iteraci#n por centinela$ 0n centinela es
un )alor que tomar& nuestra )ariable para indicar el fin de la iteraci#n" algo as como una bandera booleana" pero
aplicado a otras )ariables$ Ve&moslo para comprenderlo me'or$ El siguiente programa ir& leyendo de la entrada
est&ndar una serie de nmeros enteros positi)os (asta que se ingrese un negati)o$ En ese caso ya no se leer&n m&s
nmeros y luego se mostrar& la suma de todos los nmeros ingresados :excepto el negati)o<2
1 PROGRAM centinela;
2
3 Var
4 numero, suma : integer;
5
6 BEGIN
7 (* lectura inicial *)
8 ReadLn(numero);
9
10 (* inicializacin *)
11 suma:= 0;
12
13 while numero > 0 do
14 begin
15 (* acumulacin *)
16 suma:= suma + numero;
17 (* siguiente lectura *)
18 ReadLn(numero);
19 end;
20
21 (* mostrar resultado *)
22 WriteLn('La suma de los nmeros es: ', suma);
23 END.
ien" en la lnea I leemos el primer )alor que debemos sumar$ En la lnea 1E inicializamos la )ariable suma
con el )alor E ya que an no (a sumado nada$
En la lnea 13 comienza el WBK+E solo si el nmero que ingresamos es mayor que E" en caso contrario no se
e'ecutar&$ .qu )emos por qu, es me'or utilizar un WBK+E que un RE1E.-" ya que si el usuario ingresa como
primer )alor un nmero negati)o ya no (abr& nada para sumar$
En caso de entrar en el WBK+E aumentamos el )alor de la )ariable suma sumando su )alor anterior al )alor
del nmero ledo" o sea" al )alor de numero$ En la lnea 1I )ol)emos a leer un nmero y el WBK+E )ol)er& a su
encabezado$ 5i el nue)o nmero ledo es mayor que E ya no (abr& iteraci#n y en caso contrario s$
+uego de (aber salido del WBK+E mostramos al usuario el resultado de la suma$
ien" esto era para mostrar la idea de centinela$ En este caso nuestro centinela es cualquier nmero negati)o
ingresado por el usuario ya que ,ste ser& el que detenga la iteraci#n del WBK+E$ Veremos muc(os m&s e'emplos de
centinelas de aqu en adelante$
Ejercicio: Duy bien" a(ora quiero que modifiquen el programa de la p&gina 44 cambiando la instrucci#n
WBK+E por un RE1E.-$
Un ejemplo ms complejo. Contador de palabras:
.(ora )eremos un e'emplo de programa que cuente la cantidad de palabras en una lnea de texto que ser&
ingresada por el usuario$ %ic(o texto debe terminar con un espacio y un punto s o s :centinelas<2
1 PROGRAM cuenta_palabras;
2
3 Const
4 ESPACIO= ' ';
5 FIN= '.';
6
7 Var
8 caracter: char; //Caracter ledo.
9 cantidadPalabras: integer;//Cantidad de palabras contadas.
10
11 BEGIN
12 //Salteamos todos los espacios al inicio del texto.
13 Repeat
14 read(caracter)
15 Until caracter <> ESPACIO;
16
17 //En cada iteracin consumiremos una palabra.
18 While caracter <> FIN do
19 begin
20 //Leemos caracteres hasta encontrar un espacio.
21 Repeat
22 read(caracter);
23 Until caracter = ESPACIO;
24
25 //Aumentamos en 1 el contador.
26 cantidadPalabras:= cantidadPalabras + 1;
27
28 //Salteamos los espacios que separan las palabras.
29 Repeat
30 read(caracter)
31 Until caracter <> ESPACIO;
32 end; //Del While.
33
34
35 writeln('La cantidad de palabras en el texto es:
',cantidadPalabras);
36 END.
+es de'ar, como tarea que estudien este c#digo (asta que lo entiendan completamente$ G'ense como
implementamos distintos RE.1E.- dentro de un WBK+E y como usamos el procedimiento RE.% para siempre ir
leyendo sobre la misma lnea$ ?o ol)iden las constantes declaradas al inicio del programa$ +os comentarios son su
gran gua y eso es algo muy importante para un programador$ 5i deben traba'ar con el c#digo de su compa!ero de
traba'o deber&n ser capaces de entender sus c#digos basados en que saben la tarea que desempe!a su programa" las
)ariables que declar# tienen nombres mnemot,cnicos y sus comentarios indican bien cada acci#n aunque sin
extenderse o abusar de ellos$ -odo esto es realmente muy importante que aprendan a implementarlo$
1or si alguno de ustedes no lo sabe" un nombre mnemot,cnico es aquel que ayuda a saber el prop#sito de una
)ariable" por e'emplo" en este programa la )ariable que guarda el )alor de cuantas palabras se cuentan se llama
cantidadPalabras$ ien poda (aberse llamado cont que es una abre)iaci#n de contador o podra (aber tenido
cualquier otro nombre$ 0sen nombres mnemot,cnicos aunque sean largos" esto ayuda a prescindir un poco de los
comentarios y a que el c#digo sea m&s entendible
Ejemplo de captura de error:
En el siguiente e'emplo )eremos un programa simple que le pedir& al usuario que ingrese un )alor entero$ En
esta ocasi#n )eremos como leer estos )alores como caracteres y luego si son correctos pasarlos a enteros tal como
debera ser$ 1rimero )eamos algo que debera (aber nombrado ya (ace bastante pero sin embargo decid aplazarlo
(asta a(ora$
En la 2E nombr, por a( algo as como el ordinal de un elemento$ +os tipos ordinales de 1ascal son aquellos
que est&n acotados" o sea" que tienen un inicio y un final$ -al es el caso del tipo integer" que est& acotado
inferiormente por el )alor A32LJI y superiormente por D.NK?- que )ale 32LJL$ ?inguna )ariable del tipo integer
puede exceder estos )alores$ 5i (an acti)ado el range checking tal como se los indiqu, al inicio del tutorial
deberan recibir un error en tiempo de compilaci#n al intentar guardar en una )ariable entera algn )alor fuera del
inter)alo _A32LJI" 32LJL`" de lo contrario el error lo obtendr&n en tiempo de e'ecuci#n$
-enemos el tipo c-ar que contiene todos los caracteres existentes$ Ob)iamente este tipo es acotado ya que
tiene una cantidad finita de elementos$
El tipo real no es acotado ya que posee una cantidad infinita de elementos$ ?unca se puede determinar el
siguiente a un real$ 8;u&l nmero es el siguiente a 1$F9 8-al )ez el 1$J9 ?o porque antes est& el 1$FF" pero antes de
ese est& el 1$F1" pero antes est& el 1$FE1" y as podramos continuar infinitamente$ 5iempre entre dos nmeros reales
cualesquiera (ay infinitos reales$ Esto en matem&ticas es llamado densidad de los reales$
+o importante aqu es (ablar del ordinal de un car&cter$ +os caracteres est&n todos incluidos" para Gree 1ascal
:existen otras tablas<" en una tabla llamada -abla .scii$ Esta tabla le asigna a cada car&cter un )alor num,rico segn
su posici#n$ 1ara )er la tabla .scii en el K%E simplemente )ayan al men Tool Ascii table$
En esa imagen el cursor est& posicionado sobre el smbolo @$ ;omo )emos" a este car&cter le corresponde el
)alor J4$ Ese )alor es el ordinal de @$ 5i nosotros tenemos un car&cter cualquiera y queremos saber su ordinal
debemos usar la funci#n ord$ 1or e'emplo si escribi,ramos ord(@) obtendramos el entero J4$ . la in)ersa tenemos
la funci#n chr que dado un entero nos de)uel)e su correspondiente car&cter en la tabla$ 5i escribi,ramos chr(64)
obtendramos como )alor de)uelto el car&cter @$
+a funci#n OR% transforma un car&cter en entero" o sea" de un tipo c-ar obtenemos un tipo integer$ Esto es lo
que usaremos para" dado un car&cter num,rico" obtener el entero de ese car&cter" o sea" dado el car&cter Y1Z obtener el
nmero 1$
5in embargo no es tan f&cil" obser)en ustedes en la tabla que al car&cter YEZ le corresponde el entero 4I ya que
est& en la posici#n 4P de la tabla :la primera posici#n es la EE<$ .l car&cter Y1Z le corresponde el entero 4P y as
sucesi)amente$ 1or lo tanto si nosotros ley,ramos un car&cter de la entrada est&ndar" suponiendo que el usuario
ingres# el Y1Z" al (acer OR%:Y1Z< obtendramos el nmero 4P y no el nmero 1$
8. alguno de ustedes se les ocurre como" dado un car&cter num,rico" obtener su )alor en entero9 O sea" si me
dan el Y2Z obtener el 2" si me dan el YIZ obtener el I" y as$
;omo pueden obser)ar" los lugares de la tabla est&n ordenados ascendentemente" por lo cual si al YEZ le
corresponde el 4I" al Y1Z le corresponde el 4P" al Y2Z el FE y as (asta el YPZ que le corresponde el FL$ 8Entonces que
pasa si al ordinal de cualquier car&cter num,rico le resto el ordinal de YEZ9 1or e'emplo" si me dan el YEZ" resto ese
ordinal con el ordinal de YEZ2
Ord(`0')-Ord(`0')= 48 - 48= 0. Obtu)e el entero E$ .(ora si me dieran el car&cter Y1Z y a su
ordinal le resto el ordinal de YEZ2
Ord(`1')-Ord(`0')= 49 - 48= 1$ Obtu)e el entero 1$ %e tener el YPZ y restarle su ordinal al ordinal
de E tendra2
Ord(`9')-Ord(`0')= 57 - 48= 9$ Obtu)e el entero P$
?O-.2 El ordinal de un entero es el mismo entero2 Ord(57)= 57$
El ordinal de un boolean es 1 para -R0E y E para G.+5E$
Vladimir Rodrguez FE
Vayamos al e'emplo entonces$ +e pediremos al usuario que ingrese un entero" pero lo leeremos como caracter$
5i los caracteres ledos difieren de los num,ricos le diremos al usuario que (ay error" sino" transformaremos los
caracteres a enteros$ 1ara este programa usaremos la funci#n )*LN que es -R0E cuando el cursor de la entrada
est&ndar est& en el fin de la lnea y G.+5E en caso contrario$
1 PROGRAM enteros;
2
3 Var
4 car: char; //Caracter ledo.
5 entero: integer; //Guardar el valor en entero.
6 error: boolean; //TRUE si el usuario no ingresa un entero.
7
8
9 BEGIN
10 primera_vez:= true;
11
12 //Mostramos un mensaje al usuario y leemos la entrada.
13 write('Ingrese un entero: ');
14 read(car);
15 //Damos la condicin de error.
16 error:= (ord(car)<48) or (ord(car)>57);
17
18 If not error then
19 entero:= ord(car)-ord('0');
20
21 //Leemos hasta el fin de lnea o hasta que haya error.
22 while (not eoln) and (not error) do
23 begin
24 //Leemos el siguiente caracter.
25 read(car);
26
27 //Verificamos que el caracter sea uno numrico.
28 error:= (ord(car)<48) or (ord(car)>57);
29
31 entero:= (entero*10)+(ord(car)-ord('0'));
32 end;
33
35 writeln('El entero ingresado es: ',entero)
36 else
37 writeln('No ha introducido un entero.');
38
39 END.
;omo primer ejercicio tienen que entender este programa y modificarlo para que funcione con RE1E.-$
No continen hasta no ser capaces de resolver todos estos ejercicios.
Ejercicio2: %eterminen cu&les de los siguientes segmentos de c#digo producen la misma salida al ser
e'ecutados2
a) b)
i := 1; i := 1;
j := 2; j := 1;
REPEAT WHILE (i <= 3) AND (j <= 2) DO
Write(i, j); BEGIN
i := i + 1; Write(i, j + 1);
j := j + 1 i := i + 1;
UNTIL j <= 3; j := j + 1
END;
c)
i := 1;
REPEAT
Write(i, i + 1);
i := i + 1
UNTIL i <= 3;
Vladimir Rodrguez F1
Ejercicio3: 5e desea tener un programa que calcule el saldo de una cuenta$ 5upongan que los datos son ledos
de la entrada est&ndar y que constan de renglones" cada uno de los cuales contiene una letra en la primera columna"
seguida de un )alor real$ El ltimo rengl#n contiene nicamente la letra 1 en la columna uno$ El primer rengl#n
contiene la letra " y el saldo anterior de una cuenta de c(eques$ +os dem&s renglones contienen la letra 2 y el importe
de un dep#sito o la letra R y el importe de un retiro$ Escriban un programa que determine el saldo exacto de la cuenta
despu,s de procesar las transacciones$ .sumimos que las entradas ser&n siempre correctas$
Ejemplo3
A 1200.35
D 64.12
R 390.00
R 289.67
D 13.02
R 51.07
X
El saldo final es 546.75
Ejercicio4: %ado un fragmento de texto que debe ser ledo de la entrada est&ndar" todo en una lnea" y
terminado por el caracter 4 :centinela<" determine y ex(iba las consonantes y )ocales que aparecen duplicadas en
forma contigua$ 1or e'emplo" el texto 5llama al c-ico que lee46 tiene una consonante doble :ll< y una )ocal doble
:ee< y se debera desplegar2 5ll ee6$ :-odas las letras son minsculas<$
Ejercicio5: Realicen las funciones de una calculadora simple$ +os datos de entrada ser&n una secuencia de
dgitos enteros y los operadores @" T" H y A" seguida de un signo U$ Bagan caso omiso de los espacios en blanco$ +os
operadores se aplican en el orden en que aparecen en los datos de entrada" o sea que ol)dense de la precedencia" y
producen resultados enteros" o sea" si bien se ingresa el operador de la di)isi#n con el smbolo H" el comportamiento es
el de 27%$ .suman que se ingresa al menos un nmero$
Ej. de entrada: 4 + 3 / 2 * 8 - 4 =
Ej. de salida: 20
;omo )en" las operaciones se fueron realizando en el orden en el que aparecan$ 1rimero 4@3 que es L" eso lo
di)idimos entre 2 :di)< que es 3" luego eso multiplicado por I que es 24 y luego eso menos 4 que es 2E$ 0na
)erdadera calculadora (abra (ec(o primero 3H2 que con %KV da 1 y luego eso por I que da I$ +uego (ara 4@IA4 que
es igual a I$ 5in embargo programar eso requiere m&s (erramientas de las que poseen$
Ejercicio6 (DIFICIL): Escriban un programa que lea una letra y una oraci#n de la entrada est&ndar :de una
sola lnea<" y calcule la cantidad de palabras que terminan con la letra y est&n en la oraci#n dada$ .suman que la
oraci#n siempre terminar& con un punto y que las palabras estar&n separadas solo por espacios :no (abr& comas ni
nada de eso<$ .suman tambi,n que la oraci#n tendr& siempre al menos una palabra$
Ejemplos3
Letra: s
Oracin: La cualidad indispensable para un buen cocinero es la puntualidad
pero es tambin la de los invitados.
Salida: 4
Letra: r
Oracin: Un discpulo de quien jams se pide nada que no pueda hacer nunca
hace todo lo que puede.
Salida: 1
Letra: o
Oracin: No basta tener buen ingenio lo principal es aplicarlo bien.
Salida: 4
Dodifiquen su programa para que cuente las palabras que comienzan con la letra dada$
Este es un ejercicio que los -ar pensar 8 luc-ar muc-o. 7ntenten -acerlo bajo todos los medios posibles.
Todo lo dado -asta a-ora basta 8 sobra para lograrlo. !i no logran reali$arlo escrbanme 8 les en#iar9 la solucin
para que la estudien. pero no tiene caso leer un programa 8a -ec-o si ustedes no intentan reali$arlo primero
poniendo todas las ganas de aprender. Este manual es para ustedes 8 requiere todo su es,uer$o. No -a8 otro medio
para aprender a programar. Mi es,uer$o ,ue escribir esto. ustedes practiquen 8 practiquen. preg:ntenme sus dudas a
mi cacilla de correo 8 sigan intentando. ;os ,rutos se #ern al ,inal.
TERCERA PARTE
Introduccin a los TIPOS definidos por el programador.
Subrangos y Arreglos.
Introduccin:
Basta a(ora (emos )isto" en las dos primeras partes de este tutorial" como crear programas que puedan (acer
una cosa u otra en funci#n de ciertas condiciones" como (acer que repitan ciertas instrucciones tambi,n de forma
condicional" entre otras cosas$ En todos esos programas (emos usado )ariables de distintos tipos" sin embargo
siempre (an sido tipos primiti#os de 1ascal" o sea" los que ya est&n predefinidos por el lengua'e$ 5in embargo es
posible que el programador defina tipos propios que pueden contener datos m&s comple'os que simples nmeros"
caracteres o cadenas$
Ob)iamente esto no es totalmente libre" pero dada nuestra imaginaci#n podemos crear tipos realmente muy
comple'os y que contengan muc(a informaci#n$ +os posibles tipos que podemos crear son2 5ubrangos" .rreglos"
;on'untos" Enumerados" Registros y 1unteros$ -odos excepto 1unteros" al igual que los tipos primiti)os"
corresponden a tipos est&ticos de 1ascal$ Esto significa que declarada una )ariable de uno de esos tipos se asignar& de
la memoria el espacio suficiente para albergar el mayor )alor posible$ Este espacio de memoria estar& en uso aunque
nosotros no usemos la )ariable declarada o aunque usemos solo una parte de la informaci#n que esta pueda guardar$
Este espacio de memoria se asigna ya al compilar el programa" o sea" en tiempo de compilaci#n$
+os 1unteros corresponden a un tipo din&mico$ Esto es que" podremos pedir memoria cuando la necesitemos y
de)ol)erla cuando ya no la usemos$ Este ser& el ltimo tema de este tutorial$
Subrangos:
Duy bien" el primer tipo a definir por el usuario que )eremos es llamado subrango$ Este es el tipo m&s
sencillo de declarar$ ;onsiste en crear un 5ubrango de uno de los tipos primiti)os ordinales de 1ascal$ 1or e'emplo"
un 5ubrango de los enteros podran ser los naturales" ya que estos son lo enteros de E en adelante :algunos los toman
de 1 en adelante<$
+os tipos se declaran antes que las )ariables pero luego que las constantes$ 1ara ello debemos indicar
mediante la palabra reser)ada TYPE que (aremos declaraci#n de tipos$ Veamos un e'emplo de declaraci#n de
subrangos2
Type
Naturales= 0..MAXINT;
Mes= 1..12;
Decimal= 0..9;
Minusculas= 'a'..'z';
Digito= '0'..'9';
Mayusculas= 'A'..'Z';
.qu (emos declarado seis tipos 5ubrango diferentes$ ;omo )en la sintaxis es bien sencilla" luego de la
palabra TYPE se declaran todos los tipos necesarios de esta manera2
Identificador= valor_inicial..valor_final;
En este e'emplo tenemos el tipo Naturales que contendr& )alores enteros entre E y D.NK?-$ +uego est&
el tipo Mes que contendr& enteros entre 1 y 12$ Decimal contendr& )alores entre E y P$ +uego )emos tres subrangos
de caracteres2 Minusculas que contendr& los caracteres de la a a la z$ Esto es porque las letras est&n ordenadas
segn la -abla .scii ascendentemente y sabemos que YaZ\ZzZ$ Digito contendr& los caracteres del E al P$ ?otar que
Digito contiene los caracteres num,ricos y Decimal los )alores enteros de esos nmeros$ ?o es lo mismo$
Ginalmente tenemos el tipo Mayusculas que contiene caracteres de la . a la a$
%ado que estos son tipos" para usarlos debemos declarar )ariables de ese tipo2
Type
Naturales= 0..MAXINT;
Mes= 1..12;
Decimal= 0..9;
Minusculas= 'a'..'z';
Digito= '0'..'9';
Mayusculas= 'A'..'Z';
Var
letraMin: Minusculas;
numero: Naturales;
letraMay: Mayusculas;
;omo )en es la misma sintaxis que para declarar una )ariable de tipo primiti)o" le damos un identificador"
dos puntos y luego el nombre del tipo$ Esto significa que la )ariable letraMin podr& tomar )alores de la a a la z ya
que es del tipo Minusculas$ ;omo el 5ubrango Minusculas corresponde a un 5ubrango de caracteres"
letraMin se comportar& como una )ariable c-ar con la diferencia de que no podr& tomar )alores fuera del rango
indicado por Minusculas$ 5i esto sucede tendremos un error en tiempo de e'ecuci#n$ 5i (an acti)ado Range
checking como se los indiqu, al inicio del tutorial" el compilador )erificar& esto en la medida de lo posible y se los
ad)ertir&" pero no siempre podr& (acerlo$ 1or e'emplo" si ustedes (acen read(letraMin) el compilador no podr&
asumir que el usuario puede ingresar un car&cter fuera del rango y por tanto compilar& correctamente" pero si (acen"
letraMin:= À' les ad)ertir& su error$ Bay m&s casos de esto" pero lo )er&n en la pr&ctica$
+o mismo sucede para los subrangos Decimal" Mes y Naturales" que son subrangos de integer$ +as
)ariables de estos tipos funcionar&n como )ariables enteras con la diferencia de que deben tomar )alores dentro de
los rangos establecidos$
Visto de esta manera no puedo incenti)arlos muc(o con el uso de los subrangos" sin embargo )eremos que
resultan tiles para definir .rreglos" que es el tema que )iene a continuaci#n$
+o que puedo decirles es que al definir un 5ubrango ustedes podr&n estar seguros de que sus )ariables tendr&n
los )alores adecuados$ ;laro que ustedes deben encargarse de que estas no tomen )alor por fuera del rango
establecido$
Vladimir Rodrguez FF
Arreglos:
Declaracin:
Duy bien" a(ora s se )iene algo m&s interesante$ Este es un tema muy importante y deber&n aprenderlo bien"
ya que los arreglos son estructuras usadas para casi todo y en la mayora de los lengua'es$
0n arreglo es una tabla compuesta por celdas que contienen" todas" )alores de un mismo tipo$

*------*------*------*------*-----*-----*-----*-----*-----*
| 23 | 34 | 0 | -12 | 6 | 9 | 11 | -2 | 34 |
*------*------*------*------*-----*-----*-----*-----*-----*
1 2 3 4 5 6 7 8 9
Ese es un e'emplo de un arreglo de enteros compuesto por nue)e celdas$ ;ada celda tiene un )alor distinto
:pueden no serlo< y cada una es independiente de las dem&s$ ;omo pueden )er todas las celdas est&n numeradas del 1
al P$ Estos )alores son llamados subndices y son los que usaremos para dirigirnos a una celda especfica$
Veamos primero c#mo se declara un arreglo2
Identificador= array[Subrango] of tipo;
%ebemos indicar un nombre para el arreglo :identificador<" luego" al igual que para los subrangos )a un signo
de igual :U< y la palabra reser)ada array :arreglo en ingl,s< seguida inmediatamente por un 5ubrango entre
par,ntesis rectos _` el cual indicar& la dimensi#n del arreglo :cuantas celdas tendr&<$ +uego colocamos la palabra
reser)ada of y un tipo para los )alores que (abr& en cada celda$ Este tipo puede ser uno primiti)o de 1ascal o uno
definido anteriormente por el programador$ Veamos algunos e'emplos2
El arreglo dibu'ado arriba podra estar declarado como2
Arreglo1= array[1..9] of integer;
En este e'emplo le dimos el nombre Arreglo1$ %eclaramos directamente entre los par,ntesis rectos un
5ubrango$ +a dimensi#n de ese 5ubrango indica la dimensi#n del arreglo" en este caso el 5ubrango )a de 1 a P por
tanto contiene P elementos$ Esto indica que el arreglo tendr& nue)e celdas$ Es importante notar que esto indica solo la
dimensi#n del arreglo y no el tipo de datos que contendr&" o sea" Arreglo1 no contendr& datos que solo )ayan de 1
a P sino que contendr& cualquier entero en sus celdas ya que su tipo est& declarado luego de of y es integer$
El 5ubrango entre par,ntesis rectos" adem&s de indicar cu&ntas celdas tendr& el arreglo" tambi,n indica c#mo
se numeran$ Arreglo1 tendr& P celdas numeradas del uno al nue)e" sin embargo" de (aberse declarado
Arreglo1= array[10..19] of integer;
sera igual al anterior solo que sus nue)e celdas estaran numeradas del 1E al 1P" o de (aberse declarado de esta
manera
Arreglo1= array[à'..'i'] of integer;
seguira teniendo nue)e celdas solo que estaran identificadas de la a a la i$
+o m&s comn es numerarlas del 1 en adelante y es lo recomendable$
-al como (emos declarado esos arreglos estamos declarando sus dimensiones con subrangos an#nimos" o sea"
declarando estos 'usto dentro de los par,ntesis rectos sin darles nombre alguno$ 5in embargo tambi,n es posible
colocar dentro de estos par,ntesis un 5ubrango ya declarado anteriormente$ 1or e'emplo2
Type
Decimal= 0..9;
Arreglo1= array[Decimal] of integer;
;omo )en" teniendo declarado antes el 5ubrango Decimal es posible utilizarlo para definir la dimensi#n y
numeraci#n del arreglo$ En este caso Arreglo1 tendr& 1E celdas numeradas del E al P$
-ambi,n es posible (acer esto
Type
Decimal= 0..9;
Arreglo1= array[Decimal] of Decimal;
En este caso" el arreglo tiene 1E celdas numeradas del E al P y cada una puede contener datos del tipo
Decimal$ 5iempre es posible utilizar algn tipo para definir otro s y solo s el tipo a utilizar est& definido
anteriormente$ ?o sera posible utilizar Decimal para definir el arreglo si declar&ramos este 5ubrango m&s aba'o
que el arreglo$
0n arreglo es un tipo y por tanto )a declarado luego de la palabra Type tal como se )e en estos dos e'emplos$
Veamos a(ora m&s e'emplos de arreglos2
Vladimir Rodrguez FJ
Type
rango = 33..90;
arr1 = array [char] of integer; (* 256 celdas *)
arr2 = array [33..90] of real;
arr3 = array [integer] of char; (* demasiado grande! *)
arr4 = array [rango] of boolean;
-enemos un 5ubrango de enteros que )a de 33 a PE$ +uego tenemos arr1 que es un arreglo de 2FJ celdas
:cantidad total de caracteres< cuyos ndices )an de YaZ a YzZ donde cada una puede contener cualquier entero$ arr2
que es un arreglo de FL celdas numeradas del 33 al PE donde cada una puede contener cualquier real$ +uego tenemos
arr3 que pretendera ser un arreglo de unas JFF3J celdas numeradas desde el A32LJI (asta el 32LJL donde cada una
podra contener caracteres$ Este es un arreglo exorbitantemente grande" ocupara muc(sima memoria y pro)ocara
muc(os problemas$ .dem&s no es para nada ,tico crear este tipo de estructuras$
Ginalmente tenemos arr4 que tiene FL celdas numeradas del 33 al PE donde cada una es un booleano que
puede )aler -R0E o G.+5E$
Utilizacin de arreglos:
Basta a(ora solo (emos )isto como se declara un arreglo y lo que significan las distintas declaraciones" sin
embargo (ace falta traba'ar con ellos" y su sintaxis es un poco distinta a lo que )enimos acostumbrados$ Veremos un
primer e'emplo donde crearemos un arreglo de enteros de 1E celdas cuyos ndices )an del 1 al 1E y a cada celda le
daremos el mismo )alor que su ndice" o sea" a la primera le daremos el )alor 1" a la segunda el 2 y as sucesi)amente2
1 PROGRAM arreglos;
2
3 Type
4 arr= array[1..10] of integer;
5
6 Var
7 arreglo1: arr;
8
9 BEGIN
10 arreglo1[1]:= 1;
11 arreglo1[2]:= 2;
12 arreglo1[3]:= 3;
13 arreglo1[4]:= 4;
14 arreglo1[5]:= 5;
15 arreglo1[6]:= 6;
16 arreglo1[7]:= 7;
17 arreglo1[8]:= 8;
18 arreglo1[9]:= 9;
19 arreglo1[10]:= 10;
20 END.
En la lnea 3 indicamos que comenzar& la declaraci#n de tipos para" luego" en la lnea 4 declarar el tipo arr
que ser& un arreglo de 1E celdas numeradas del 1 al 1E del tipo entero$ ;omo arr es un tipo su prop#sito es declarar
)ariables de ese tipo" por lo tanto en la lnea L declaramos la )ariable arreglo1 del tipo arr$ 1odemos" al igual
que con los tipos primiti)os" declarar tantas )ariables como queramos de cualquier tipo que nosotros mismos
definamosM en este caso tenemos solo una" pero podra tener m&s y cada una sera independiente$
ien" en la lnea P comienza nuestro programa" el cual consta de diez lneas de asignaci#n donde en cada una
le damos un )alor a cada celda del arreglo$ Veamos esto con detalle" es bien sencillo$ ;ada celda del arreglo funciona
como una )ariable independiente" por tanto" en ese arreglo tenemos diez )ariables del tipo integer$ 1ara referirnos a
una celda debemos dar el nombre de nuestro arreglo :no el nombre del tipo sino el de la )ariable de ese tipo< seguido
por el ndice entre par,ntesis rectos de la celda a la que queremos ir$ %e este modo" en la lnea 1E" al escribir
arreglo1[1]:= 1 estamos diciendo que )aya a la primera celda de arreglo1 y le asigne el )alor 1$ +a sintaxis
gen,rica sera
Variable_del_tipo_arreglo[indice_de_la_celda]
con lo cual nos referiramos a cualquier celda$ Recordar que cada una es una )ariable independiente" por tanto esa
declaraci#n es como si fuera el nombre de la )ariable y funciona igual que cualquier otra )ariable" )alga la
redundancia$
-odo lo que sigue del programa es asignar a las celdas restantes el )alor que queremos y termina nuestro
programa$ 5in embargo no es muy til tener que escribir instrucci#n por instrucci#n para dar un )alor a cada celda$
Kmaginen un arreglo de 1EEE celdas" tendramos un programa de 1EEE lneas solo en asignaciones$ Veamos el mismo
programa pero asignando los mismos )alores a cada celda de una forma m&s inteligente2
Vladimir Rodrguez FL
1 PROGRAM arreglos;
2
3 Type
5
6 Var
7 arreglo1: arr;
8 i: integer;
9
10 BEGIN
11 For i:=1 to 10 do
12 arreglo1[i]:= i;
13 END.
Bemos sustituido las 1E lneas de asignaci#n por una instrucci#n GOR que )a de 1 a 1E$ G'ense que (emos
colocado la )ariable de control i dentro los par,ntesis rectos que indican el ndice de nuestras celdas$ %e este modo"
cuando i )alga 1 estaremos (ablando de la primera celda" cuando i pase a )aler 2 estaremos (ablando de la segunda
celda" y as sucesi)amente (asta 1E$ En este caso (emos asignado a cada celda el mismo )alor de su ndice" pero esto
podra no ser as$ Este arreglo dibu'ado sera2
*-----*-----*-----*-----*-----*-----*-----*-----*-----*-----*
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
*-----*-----*-----*-----*-----*-----*-----*-----*-----*-----*
1 2 3 4 F J L I P 1E
.(ora )eamos lo mismo pero asignando el doble del ndice a cada celda2
1 PROGRAM arreglos;
2
3 Type
5
6 Var
7 arreglo1: arr;
8 i: integer;
9
10 BEGIN
12 arreglo1[i]:= i*2;
13 END.
%e este modo arreglo1 a(ora quedara as2
*-----*-----*-----*-----*-----*-----*-----*-----*-----*-----*
| 2 | 4 | 6 | 8 | 10 | 12 | 14 | 16 | 18 | 20 |
*-----*-----*-----*-----*-----*-----*-----*-----*-----*-----*
1 2 3 4 F J L I P 1E
%entro de los par,ntesis rectos que indican el ndice del arreglo es posible" como (emos )isto ya" colocar el
)alor del ndice" una )ariable del tipo correcto o" como no (emos )isto an" una expresi#n que d, c#mo resultado un
)alor del tipo correcto y que est, dentro del rango de ndices posibles$
Es muy importante que lo que est, dentro de los par,ntesis rectos nunca exceda el rango en que est& numerado
el arreglo$ 5i en este e'emplo nosotros escribi,ramos
For i:=1 to 11 do
arreglo1[i]:= i*2;
se producira un error cuando i alcanzara el )alor 11 y el programa se cerrara abruptamente ya que la celda 11 no
existe$ 5i (an acti)ado Range checking lo m&s probable es que el compilador les a)ise antes" pero esto no es
siempre seguro ya que no siempre es detectable que podemos estar sali,ndonos del arreglo$
Veamos un nue)o e'emplo del mismo programa" solo que a(ora los ndices ser&n caracteres y a cada celda le
asignamos el )alor del ordinal de su ndice$ ?o ol)iden que el arreglo es de enteros$
Vladimir Rodrguez FI
1 PROGRAM arreglos;
2
3 Type
4 arr= array[à'..'j'] of integer;
5
6 Var
7 arreglo1: arr;
8 i: char;
9
10 BEGIN
11 For i:='a' to `j' do
12 arreglo1[i]:= ord(i);
13 END.
%e este modo nuestro arreglo quedara as2
*-----*-----*-----*-----*-----*-----*-----*-----*-----*-----*
| 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 |
*-----*-----*-----*-----*-----*-----*-----*-----*-----*-----*
YaZ YbZ YcZ YdZ YeZ YfZ YgZ Y(Z YiZ Y'Z
Hacer WRITE y READ de un arreglo:
5i quisi,ramos desplegar un arreglo en la pantalla" o sea" que se nos muestren todos sus )alores" debemos
escribir celda por celda$ En el e'emplo anterior tenamos el arreglo llamado arreglo1$ ;omo primer impulso para
escribirlo en pantalla uno tendera a (acer algo como esto
write(arreglo1);
y sin embargo eso no es posible$ %e (acerlo tendr&n un error en tiempo de compilaci#n en el cual el
compilador se les que'ar& por no poder escribir o leer )ariables de ese tipo$ Esto es porque un arreglo es una
estructura de datos y no un )alor especfico$ 1or este moti)o es que debemos escribir celda por celda$ ?o se ol)iden
que cada celda es como una )ariable m&s y funciona del mismo modo$
Veamos entonces como mostrar el arreglo de nuestro e'emplo anterior2
1 PROGRAM arreglos;
2
3 Type
4 arr= array[à'..'j'] of integer;
5
6 Var
7 arreglo1: arr;
8 i: char;
9
10 BEGIN
13
15 Write(arreglo1[i],' `);
16 END.
+a nica diferencia entre este programa y el anterior es que agregamos un GOR que en cada iteraci#n escribe
el )alor de una de las celdas$ Verifiquen esto ustedes mismos$
Ejercicio: Dodifiquen este programa para que con un solo GOR asigne los )alores al arreglo y lo muestre en
pantalla$
%el mismo modo" si quisi,ramos (acer read de un arreglo para que el usuario ingrese los )alores de cada
celda debemos (acerlo para cada una por separado$
Ejercicio: Realicen un programa en el cual exista un arreglo de enteros de cinco celdas de modo que el
usuario sea qui,n ingrese los )alores para cada celda$ %eben utilizar una instrucci#n GOR para ello$
Vladimir Rodrguez FP
Declaracin annima de un arreglo:
+os arreglos que (emos )isto (asta a(ora los (emos declarado como tipos de modo que podemos declarar
muc(as )ariables de ese tipo$ 5in embargo" a )eces sucede que sabemos que )amos a usar un nico arreglo en nuestro
programa y nada m&s$ %ado este caso no es necesario declarar el arreglo como tipo sino (acerlo de forma an#nima"
directamente como )ariable$ Veamos esto con el programa anterior ya que tenemos un nico arreglo en este2
1 PROGRAM arreglos;
2
3 Var
4 arreglo1: array[à'..'j'] of integer;
5 i: char;
6
7 BEGIN
10
12 Write(arreglo1[i],' `);
13 END.
;omo )en este programa es igual al anterior solo que (emos quitado la declaraci#n de tipos y (emos
declarado el arreglo directamente como )ariable$ %e este modo solo se usar& como arreglo1 y no como tipo por lo
cual no podremos declarar )ariables como en los casos anteriores$
?o est& mal si declaran siempre los arreglos como tipo" pero tengan en cuenta que un arreglo como tipo ocupa
m&s memoria que uno declarado an#nimamente$ 5i (an declarado un tipo array el programa guardar& memoria para
6recordar7 que existe un tipo definido por ustedes y qu, datos puede contener y luego tambi,n guardar& memoria
para cada )ariable que declaren de ese tipo$ 5i lo (acen de forma an#nima solo guardar& memoria para esa )ariable y
punto$
0n programa que utiliza muc(a memoria es menos eficiente" al igual que uno que realiza demasiadas
instrucciones o tareas$ 5iempre es importante tratar de que el programa (aga el menor traba'o posible para que sea
m&s )eloz y requiera menos recursos de la computadora para traba'ar$
=o no )oy a dedicarme a ense!arles acerca de la eficiencia de los programas ya que este tutorial est& dirigido
a personas que reci,n est&n aprendiendo" pero ya )ayan teniendo en cuenta que este es un aspecto muy importante$
%e todos modos en algunos casos nombrar, la me'or forma de realizar una tarea eficientemente$
Recorriendo arreglos:
=a sabemos como crear un arreglo y acceder a sus celdas para asignarles )alores" leer estos desde la entrada o
escribirlos$ -ambi,n sabemos que cada celda funciona como una )ariable independiente y que siempre podemos
acceder a la que queramos si sabemos como est&n numeradas las celdas$ Es por esto que con)iene siempre que los
ndices )ayan de 1$$?" o sea de 1 (asta ? donde ? es la cantidad de celdas del arreglo$ Esto ayuda a e)itar
confusiones y (ace todo muc(o m&s entendible$ 5in embargo pueden (acerlo de otra manera si consideran que para
cierto caso les resulta m&s til$
Duc(as )eces resulta necesario recorrer un arreglo" ya sea para buscar un elemento de ,l o para traba'ar de
algn modo con los )alores de sus celdas" de otro modo 8para qu, lo (abramos creado entonces9
.unque les de', esto como e'ercicio" espero lo (ayan (ec(o antes de llegar aqu" )eremos un e'emplo donde el
usuario ingresa 1E )alores enteros para un arreglo y luego nosotros desplegaremos ,stos para mostr&rselos y adem&s
le mostraremos la suma de ellos2
1 PROGRAM sumaCeldas;
2
3 Const
4 N= 10; //Dimensin del arreglo.
5
6 Type
7 arr= array[1..N] of integer;
8
9 Var
10 arreglo1: arr;
11 i, suma: integer;
Vladimir Rodrguez JE
12
13 BEGIN
14 //Mensaje para el usuario.
15 write('Ingresa `,N,' enteros: ');
16
17 //Leemos un valor para cada celda.
18 For i:=1 to N do
19 read(arreglo1[i]);
20
22 writeln;
23
24 //Mensaje al usuario. Mostramos su ingreso.
25 write('Usted ha ingresado: ');
26 For i:=1 to N do
27 write(arreglo1[i],' ');
28
29 //Iniciamos suma en 0 ya que an no hemos sumado nada.
30 suma:=0;
31
32 //Recorremos todo el arreglo sumando los valores a suma.
33 For i:=1 to N do
34 suma:= suma + arreglo1[i];
35
36 //Mostramos el resultado al usuario.
37 writeln;
38 writeln('La suma de los valores es: ',suma);
39 END.
+o primero a destacar en este e'emplo es el uso de la constante ? cuyo )alor es 1E$ Es simplemente la que
usaremos para declarar el 5ubrango que declara la dimensi#n del arreglo$ %e este modo la usaremos tambi,n en las
iteraciones GOR para recorrer todas las celdas del arreglo$ 5i luego debi,ramos modificar nuestro programa para que
el usuario ingrese 2E )alores en )ez de 1E solo debemos cambiar el )alor de ? en su declaraci#n de la lnea 4 y todo
funcionar& perfectamente$ %e lo contrario deberamos cambiar un 1E por un 2E cada )ez que iter&ramos con el
arreglo" al declararlo" etc$
En la lnea 1L tenemos un GOR que leer& un )alor para cada celda del arreglo$ %ada esa declaraci#n el usuario
puede ingresar de a un )alor (e ir presionando enter" o ingresar los 1E )alores separados por espacio en una misma
lnea y presionar enter al final$ Esto es posible ya que (emos usado el procedimiento read que lee un )alor y de'a el
cursor en la misma lnea$ %e (aber usado readln deberamos ingresar un )alor por lnea$
+es de'o el resto del programa a ustedes$
.(ora )eremos un e'emplo donde el usuario ingresa 1E )alores enteros en un arreglo y el programa le
mostrar& el mayor de todos ellos2
1 PROGRAM arreglos;
2
3 Const
5
6 Type
8
9 Var
10 arreglo1: arr;
11 i, mayor: integer;
12
13 BEGIN
15 write('Ingresa ',N,' enteros: ');
16
18 For i:=1 to N do
20
22 writeln;
23
Vladimir Rodrguez J1
24 //En un principio el mayor valor es el primero.
25 mayor:= arreglo1[1];
26
27//Ahora recorremos el resto del arreglo buscando el mayor valor.
28 For i:=2 to N do
29 begin
30 If arreglo1[i]>mayor then
31 mayor:= arreglo1[i];
32 end;
33
34 //Informamos al usuario.
35 writeln('El mayor valor ingresado es: ',mayor);
36 END.
+ean ustedes mismos este c#digo$ 5eguro son capaces de entenderlo muy bien$
Bsqueda de un elemento:
En este e'emplo )eremos un programa en el que el usuario ingresa 1E enteros que guardaremos en el arreglo y
luego le pediremos que ingrese otro )alor$ uscaremos ese )alor en el arreglo$ 5i est& a( lo notificaremos y en caso
contrario notificaremos que no est&2
1 PROGRAM BusquedaArreglo;
2
3 Const
5
6 Type
8
9 Var
10 arreglo1: arr;
11 i, valorBuscado: integer;
12 exito: boolean;
13
14 BEGIN
16 write('Ingresa ',N,' enteros: ');
17
19 For i:=1 to N do
21
23 writeln;
24
25 //Leemos el valor a buscar en el arreglo.
26 write('Ingresa el valor que deseas buscar: ');
27 readln(valorBuscado);
28
29 //Inicializamos nuestra variable ndice en 0.
30 i:=0;
31 {Iteramos hasta encontrar el valor o hasta
32 recorrer todo el arreglo sin hallarlo}
33 Repeat
34 //Aumentamos un ndice.
35 i:= i + 1;
36 exito:= arreglo1[i]=valorBuscado;
37 Until (exito) or (i=N);
38
39 writeln;
40
41 //Mostramos el mensaje correspondiente.
42 If exito then
43 writeln('El valor est en el arreglo.')
44 else
45 writeln('El valor no est en el arreglo.');
46 END.
+o importante aqu est& a partir de la lnea 3E donde inicializamos i en E ya que ser& nuestro ndice$ En la
lnea 33 declaramos un RE1E.- que aumentar& nuestro ndice de bsqueda y luego se fi'ar& si el )alor buscado es
igual al de la celda en que estamos posicionados$ En ese caso exito ser& true y la iteraci#n terminar&$ En caso
contrario )ol)eremos a aumentar i en 1 y nos fi'aremos en la nue)a posici#n$ +a iteraci#n terminar& al encontrar el
elemento o al recorrer todo el arreglo sin (allarlo$
Es importante destacar el uso del RE1E.- aqu$ ;omo primera cosa sabemos que iteraremos al menos una
)ez ya que debemos fi'arnos al menos en la primera celda del arreglo" por eso us, un RE1E.- y no un WBK+E$
.lguno podr& preguntarse 8y por qu, no usaste un GOR para recorrer el arreglo como (as (ec(o (asta a(ora9 ien"
)eamos como quedara ese RE1E.- si fuera un GOR
For i:=1 to N do
exito:= arreglo1[i]=valorBuscado;
If exito then
Writeln(Èl valor est en el arreglo.')
Else
Writeln(Èl valor no est en el arreglo.');
;on el GOR recorreremos todo el arreglo siempre$ +a bandera booleana se )ol)er& true al (allar el elemento$
Gunciona perfectamente al igual que el RE1E.-" a(ora piensen esto$ Kmaginen que tenemos un arreglo de FEE celdas
y el )alor que busc&bamos estaba en la celda nmero IJ$ ;on el RE1E.- recorreremos solo las primeras IJ celdas
del arreglo y nos detendremos ya que al encontrar el elemento no nos interesa lo dem&s$ ;on el GOR" al encontrar el
elemento la bandera ser& true pero an as recorreremos las FEE celdas$ Esto (ace al programa traba'ar de m&s cuando
no es necesario y le resta muc(a eficiencia$ 1iensen en un arreglo de miles y miles de celdas" por e'emplo" una base
de datos de >oogle en donde est&n guardadas casi todas las /ebs del mundo$ 85era me'or recorrer la base de datos
(asta encontrar el elemento o recorrerla toda siempre9
Es importante que comprendan esto$ .unque ya les di'e que no les (ara muc(o (incapi, con esto de la
eficiencia" tambi,n di'e que en ciertas ocasiones mencionara el modo de realizar ciertas tareas de la forma m&s
eficiente posible$
%eben notar que el programa anterior se detendr& ante el primer encuentro con el )alor buscado sin interesarse
en si se repite luego$
En la p&gina siguiente (ay una serie de e'ercicios$ ?o continen con el tutorial (asta que sean capaces de
realizarlos todos" o de lo contrario" no podr&n con los temas que )endr&n a continuaci#n
Ejercicio1: Escriban un programa que lea diez enteros de la entrada est&ndar y guarde estos en un arreglo$ El
programa debe indicar el mayor de ellos y el ndice de la posici#n en la que aparece" as como tambi,n" el menor de
ellos y su posici#n$ En caso de que se repita un )alor mostrar&n el ndice de la primera celda en que aparezca$
.sumimos que siempre se ingresan enteros en la entrada est&ndar$
E'emplo12
Ingrese 10 enteros: 2 3 1 4 5 10 6 7 8 9
El mayor entero es 10 en la posicin 6
El menor entero es 1 en la posicin 3
E'emplo22
Ingrese 10 enteros: 2 3 2 20 5 20 6 7 8 9
El mayor entero es 20 en la posicin 4
El menor entero es 2 en la posicin 1
Ejercicio2: Este e'ercicio conlle)a cierta dificultad" sobretodo porque traba'ar&n con dos arreglos a la )ez"
cada uno de distinto tama!o$ %ada la definici#n de tipo para representar cadenas de caracteres de largo M y N 2
CONST N = . . .;
CONST M = . . .; { M < N }
. . .
TYPE
CadenaM = ARRAY[1..M] Of Char;
CadenaN = ARRAY[1..N] Of Char;
Kmplementen un programa que lea dos cadenas de la entrada est&ndar de largo M y N respecti)amente" y
determine si la primer cadena ocurre como parte de la segunda cadena$ El programa debe funcionar para cualquier
)alor positi)o que puedan tomar M y N" considerando la restricci#n M \ N$ 0stedes mismos definan los )alores de las
constantes$E'emplo de entrada para ?UJ" DU32
tor
totora
E'emplo de salida2
El texto 'tor' se encuentra dentro del texto 'totora'.
E'emplo de entrada2
tos
totora
E'emplo de salida2
El texto 'tos' no se encuentra dentro del texto 'totora'.
Ejercicio3: -iene una dificultad similar al anterior$ %ada la definici#n de tipo para representar cadenas de caracteres
de largo N y M2

CONST N = . . .;
CONST M = . . .;
. . .
TYPE
CadenaM = ARRAY[1..M] Of Char;
CadenaN = ARRAY[1..N] Of Char;
1$ Escriban un programa que lea dos cadenas de largo M y N respecti)amente" e imprima un mensa'e en la
salida est&ndar indicando si alguna letra en la primera palabra ocurre en la segunda$
2$ Escriban un programa que lea dos cadenas de largo M y N respecti)amente" y determine si todas las letras
en la primera palabra ocurren en la segunda$
omo 8a saben. siempre que un ejercicio les de #erdaderos problemas no tienen ms que escribirme a
mstr#ladi<-otmail.com e+plicndome sus dudas 8 les responder9 en bre#e. !iempre intenten todo lo que puedan 8
prueben bien sus programas antes de dar por terminado un ejercicio.
Arreglos multidimensionales:
+os arreglos que (emos )isto (asta a(ora son unidimensionales" o sea" de una nica dimensi#n$ 5e dice esto
ya que se requiere una nica coordenada :ndice< para ubicar una celda del mismo$ 5in embargo es posible definir
arreglos de dos dimensiones :2%<" de tres dimensiones :3%< y m&s$ .qu )eremos e'emplos de arreglos de (asta tres
dimensiones ya que no requerimos de m&s para traba'ar" sin embargo muc(os programas usan arreglos de ?
dimensiones$ ;omo nosotros existimos en un espacio de dimensi#n 3 solo podemos )er gr&ficamente arreglos de
dimensi#n 3 o menor$
Arreglos bidimensionales:
;omencemos por )er arreglos de dos dimensiones$ Estos dibu'ar&n una tabla de datos del mismo tipo" tambi,n
conocidas matem&ticamente como matrices$
Bay dos maneras de declarar arreglos bidimensionales" una es declarar un arreglo de un arreglo" o sea" un
arreglo cuyas celdas sean tambi,n arreglos$ Esta es la forma m&s fea de (acerlo y la que menos recomiendo" pero
existe$ Ve&moslo en un e'emplo2
1 PROGRAM BIDIMENSIONAL;
2
3 Type
4 arr1= array[1..5] of integer;
5 Tabla= array[1..7] of arr1;
6
7 Var
8 i, j: integer;
9 matriz: Tabla;
10
11 BEGIN
12 For i:= 1 to 7 do
13 For j:= 1 to 5 do
14 matriz[i,j]:= 0;
15 END.
En la lnea 4 )emos un tipo arr1 que es un arreglo de F celdas de enteros$ En la lnea F )emos el tipo Tabla
que es un arreglo de L celdas del tipo arr1" o sea que cada celda es un arreglo de F celdas$ 5i dibu'&ramos Tabla al
igual que lo (icimos antes tendramos L celdas del 1 al L" esto estara indicando cuantas filas tiene nuestra tabla$ 5i
desplegamos cada celda de Tabla estaramos abriendo (acia la derec(a F lugares con lo cual estaramos indicando
las columnas de nuestra tabla$
;olumnas:'<
Gilas:i<
Ese sera el dibu'o de Tabla" como )en (ay L filas :lneas (orizontales< y F columnas :lneas )erticales<$ El 0
corresponde a la posici#n :3"3< de la tabla ya que est& en la fila 3 y en la columna 3$ 5iempre para una tabla se
especificar&n las coordenadas de una celda nombrando primero el nmero de filas y luego el de columnas$
En la lnea P del e'emplo declaramos la )ariable matriz del tipo Tabla$ El traba'o con los arreglos
bidimensionales es id,ntico al de los arreglos unidimensionales$ ;ada celda es una )ariable independiente y para
acceder a cada una simplemente nombramos nuestro arreglo y damos entre par,ntesis rectos las coordenadas de
nuestra celda separadas por comas$ +a forma gen,rica sera as2
Variable_arreglo[fila,columna]
de este modo" si quisi,ramos ir a la celda que est& en la fila L y en la columna 4 deberamos escribir matriz[7,4]$
Vladimir Rodrguez JF
E E E E E
E E E E E
E E 0 E E
E E E E E
E E E E E
E E E E E
E E E E E
En nuestro programa de e'emplo asignamos a cada celda el )alor E$ ;omo )en debemos usar dos GOR
anidados para recorrer una tabla" uno para recorrer las filas y otro para las columnas$
Vean que el subrango en arr1 indica cu&ntas columnas tendr& la matriz y en subrango en Tabla indica
cu&ntas filas$
0na sintaxis alterna para acceder a una celda de nuestra tabla es la siguiente2
Variable_arreglo[fila][columna]
y por tanto si" usando esta sintaxis" quisi,ramos acceder a la fila L y la columna 4 deberamos escribir matriz[7]
[4]$ ?o recomiendo esta sintaxis$
Veamos a(ora la segunda forma de declarar un arreglo bidimensional" la cual es la que yo recomiendo que
usen2
1 PROGRAM BIDIMENSIONAL;
2
3 Type
4 Tabla= array[1..7,1..5] of integer;
5
6 Var
7 i, j: integer;
8 matriz: Tabla;
9
10 BEGIN
11 For i:= 1 to 7 do
12 For j:= 1 to 5 do
13 matriz[i,j]:= 0;
14 END.
;omo )en en la lnea 4 (emos declarado el tipo Tabla en el cual (emos incluido dos subrangos entre los
par,ntesis rectos separados por coma$ El primer subrango :1$$L< indica la cantidad de filas y el segundo :1$$F< la
cantidad de columnas que tendr& la matriz$ Esto siempre es as$ ;omo )en" de este modo queda todo muc(o m&s
claro$
?O-.2 +a cantidad de celdas de un arreglo bidimensional es igual al resultado de multiplicar la cantidad de
filas por la cantidad de columnas$
;omo ejercicio quiero que modifiquen ese programa para que despliegue en la salida est&ndar la matriz$ En
este caso aparecer& una tabla de E como esta2
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Esto no es muy difcil y radica explcitamente en el uso de GOR$
Ejercicio2: Dodifiquen los programas anteriores para que" si el usuario no ingresa un entero" notifiquen el
error y )uel)an a pedir el )alor correcto$
Ejercicio3 5e llama matriz cuadrada a toda aquella matriz que tiene tantas filas como columnas" o sea" si tiene
F filas tiene F columnas$ +a transpuesta de una matriz cuadrada es aquella matriz que tiene como columnas lo que
antes eran filas$ O sea" si tenemos una matriz cuadrada ." una matriz cuadrada es transpuesta de . si las columnas
de son iguales a las filas de ." o sea" si se satisface que _i"'Ù._'"i` para todos los )alores posibles de i y '$
Vladimir Rodrguez JJ
E'emplo$ 5ea . de F filas y F columnas como se muestra en la figura" )eamos como sera su transpuesta 2
.
1 2 3 4 5 1 0 1 5 2
0 0 0 0 0 2 0 1 4 2
1 1 1 1 1 3 0 1 3 2
5 4 3 2 1 4 0 1 2 2
2 2 2 2 2 5 0 1 1 2
;omo )en" lo que en . eran filas" en son columnas$ +a primera fila de . que contiene los )alores 1" 2" 3" 4
y F es la primera columna de 1" 2" 3" 4 y F" y as sucesi)amente$
Escriban un programa que calcule la transpuesta de un arreglo de nmeros reales con cinco renglones y cinco
columnas$ +os )alores de la matriz se leen desde la entrada est&ndar$ El resultado se debe imprimir en la salida
est&ndar$ Recuerden la relaci#n _i"'Ù._'"i` para que sean transpuestas$
Este e'ercicio no es muy complicado$ -al )ez lo peor de esto es que traba'a con una propiedad matem&tica de
las matrices y para aquellos que no lo (an estudiado puede resultar difcil de comprender$ .n as creo que no
deberan tener problemas$
Arreglos tridimensionales:
Esto es b&sicamente lo mismo$ 5e declaran exactamente igual solo que a(ora (abr& tres subrangos entre
par,ntesis rectos y por ende deberemos colocar tres coordenadas para indicar cual celda deseamos )er :una
coordenada para la fila :altura<" otra para la columna :largo< y otra para el e'e :anc(o<<$ Bago esta aclaraci#n porque
si bien un arreglo bidimensional dibu'a una tabla" uno tridimensional dibu'a un prisma y por tanto debemos decir
cuan a lo alto" largo y anc(o queremos posicionarnos$
Esto es un arreglo bidimensional de F filas y I columnas$ Visto de
este modo es un rect&ngulo donde la cantidad de filas son su altura y la
cantidad de columnas su largo$ Este es un arreglo de FxI$
.s podramos )isualizar un arreglo
tridimensional de FxIxJ$ ;omo )en es un arreglo de
tablas que estaran todas bien pegadas formando un
prisma$ ?osotros debemos indicar en qu, fila y
columna est& nuestra celda y en cual tabla de todas$
5iempre indicamos _fila" columna" tabla`$ Esto es un
intento de que puedan )isualizar un arreglo
tridimensional$
El punto ro'o correspondera a la posici#n _4"I"3` por
estar en la cuarta fila" octa)a columna de la tercera
tabla$ El azul correspondera a la posici#n _1"3"J`$
Basta aqu llegamos con arreglos$ .(ora les
propondr, un 1RO=E;-O$
Vladimir Rodrguez JL
REALIZANDO UN PROYECTO
MASTER MIND
ien" dado todo lo que saben (asta a(ora les propongo realizar el siguiente programa$ 5e trata de un )ie'o
'uego conocido llamado Daster Dind$ Es un 'uego para dos personas" una (ace de adi#inador y la otra de pensador$
El adi)inador intentar& adi)inar un c#digo de cuatro letras" que solo el pensador conoce" en un nmero m&ximo de
intentos determinado$ ;ada )ez que el adi)inador propone un c#digo" si no adi)ina" el pensador le dar& pistas para
que pueda adi)inar$ Estas pistas estar&n dadas por dos notas" 0E?O5 y RE>0+.RE5$ Veamos un e'emplo2
5upongamos que el pensador se in)enta el c#digo .;% para que el otro 'ugador adi)ine$ ;omo primer
intento el adi)inador presenta el c#digo .G>B$ ;omo )en no (a acertado" pero una de las letras de su c#digo
coincide con la del c#digo del pensador" por tanto (ay una bien$ Esa . corresponde a un 0E?O ya que adem&s de
ser la misma letra est& en la misma posici#n que en el c#digo del pensador" en este caso" en el primer lugar$
0n RE>0+.R corresponde a una letra que esta en ambos c#digos pero en una posici#n diferente$ 1or
e'emplo" si para adi)inar el .;% el adi)inador presentara el G.>B solo la letra . est& en ambos c#digos" pero en el
del pensador est& en primer lugar y en el del adi)inador est& en segundo lugar$ .mbas notas se presentan a la )ez$
Veamos un e'emplo suponiendo que las letras que puede (aber en el c#digo )an de la . a la G inclusi)e$ +as letras
pueden repetirse$
El c#digo del pensador es G%%.2
Primer intento2 ABCD Buenos: 0 Regulares 2
;omo )en no (ay letras que coincidan en posici#n" pero tenemos en el c#digo del adi)inador una . que est&
en el primer lugar :en el del pensador est& en el ltimo< y una % en ltimo lugar :en el del pensador est& en segundo o
tercer lugar< y corresponden cada una a un regular$
Segundo intento: BADC Buenos: 1 Regulares: 1
.(ora la % coincide en el tercer lugar de ambos c#digos$ ?otar que en el c#digo del pensador (ay tambi,n
una % en el segundo lugar" pero esta no (ace que la % del tercer lugar del c#digo del adi)inador sea un regular ya que
esta coincide con la % del tercer lugar$ +a . siegue estando en posiciones distintas$
Tercer intento: EDAE Buenos: 1 Regulares: 1
Cuarto intento: EDAF Buenos: 1 Regulares: 2
Quinto intento: DDAF Buenos: 1 Regulares: 3
Sexto intento: FADD Buenos: 2 Regulares: 2
Sptimo intento: FDDA Buenos: 4 Regulares: 0
En este caso el adi)inador (a ganado$ ?oten que si suman uenos @ Regulares el resultado siempre ser&
menor o igual al nmero de letras en el c#digo :en este caso 4< y s#lo ser& igual si todas las letras en el c#digo del
adi)inador est&n en el del pensador$ ?unca puede ser mayor$
%adas las siguientes declaraciones2
Const
primeraLetra= À';
ultimaLetra= `F';
largoCodigo= 4;
maxIntentos= 10;
Type
Codigo= array[1..largoCodigo] of char;
deben programar el Daster Dind de modo que la ;10 (aga de pensador y el usuario de adi)inador$ El programa
deber& crear un c#digo al azar y luego el usuario intentar& adi)inarlo$
;ada )ez que el usuario ingrese un c#digo el programa le dar& las notas correspondientes$ 5i el usuario
adi)ina el programa debe mostrarle un mensa'e de felicitaciones$ 5i el usuario llega la cantidad m&xima de intentos
sin adi)inar" el programa debe notificarle que perdi# y mostrarle cual era el c#digo que deba adi)inar$
;ada )ez que el usuario ingrese un caracter que no corresponda al rango de letras del c#digo :Y.Z a YGZ<" o que
ingrese un c#digo m&s largo o m&s corto que 4 caracteres el programa debe mostrar un mensa'e de error y )ol)er a
pedir el ingreso del c#digo sin aumentar el intento actual del usuario$
En cada momento el programa ir& mostrando el intento actual$ Veamos unos e'emplos de e'ecuci#n2
Dispones de 10 intentos para adivinar:
Vladimir Rodrguez JI
1)--> ABCD B2 R0
2)--> AFCD B2 R1
3)--> AFD
ERROR
3)--> AFDFF
ERROR
3)--> AFJD
ERROR
3)--> A5FD
ERROR
3)--> ACFD B3 R0
4)--> ACED B4 R0
FELICIDADES. HAS GANADO.
En este e'emplo )emos que el programa primero despliega un mensa'e para notificar al usuario de cuantos
intentos m&ximos dispone para adi)inar$ +uego comienza el 'uego$ El programa muestra el nmero de intento actual
y una flec(a$ +uego se espera la entrada del usuario$ El programa despliega las notas y pasa a la lnea siguiente
mostrando el intento actual" la flec(a y aguardando la entrada del usuario$
-ambi,n )emos en el tercer intento que el usuario ingresa un c#digo m&s corto de lo debido" eso es un
ERROR$ Duestra el mensa'e y pasa a la siguiente lnea pero no aumenta el intento actual" seguimos en el tercero$
+uego el usuario ingresa un c#digo m&s largo de lo debido$ 5e notifica el error y )ol)emos a esperar un ingreso sin
aumentar el nmero de intento$ +uego el usuario ingresa un c#digo de cuatro letras pero con una C incluida" la cual no
est& en el rango comprendido entre Y.Z y YGZ$ Esto tambi,n es un error$ +uego el usuario ingresa un c#digo con un F y
este car&cter tampoco est& en el rango de Y.Z a YGZ y por tanto es un ERROR$ ;omo )en siempre seguimos en el
tercer intento$ Ginalmente el usuario ingresa bien el c#digo y el programa contina$
En el cuarto intento el usuario adi)ina el c#digo" se le informa de ello y as gana$
Veamos un e'emplo en el que pierde2
El c#digo del pensador es .%%
Dispones de 10 intentos para adivinar:
1)--> ABCD B1 R2
2)--> ABCE B1 R1
3)--> ABCF B1 R1
4)--> AFCD B1 R1
5)--> ABCC B1 R1
6)--> ABBA B1 R1
7)--> ABDB B3 R0
8)--> ADBB B3 R0
9)--> ADCB B3 R0
10)--> ADCB B3 R0
Lamentablemente has perdido.
El cdigo era ADDB.
;rear un c#digo al azar y calcular los uenos de un c#digo mostrado por el usuario no es muy difcil$ +a
)erdadera dificultad de esto estar& a la (ora de calcular los Regulares ya que cuando se repitan letras tendr&n
problemas para contabilizarlas una nica )ez$ 1or e'emplo si el c#digo a adi)inar es .%G% y se nos muestra el
.% tenemos un ueno y un Regular$ +a % est& dos )eces en el c#digo del pensador y una en el del adi)inador"
pero no corresponde a dos regulares" sino a uno$
Otro caso es .%G% y .%$ En este caso la . est& bien y la % coincide en la segunda posici#n" por tanto es
un ueno y no un Regular a pesar de que (ay una % en la cuarta posici#n del c#digo del pensador$
Estas y muc(as otras dificultades se les presentar&n con este programa$
Realmente deben ser capaces de realizarlo$ +es lle)ar& como mnimo una semana (acerlo bien" no se maten
por (acerlo en menos tiempo" realmente cuesta$ Esta )ez tendr&n muc(as consultas que (acerme" as que escrbanme
a mstr)ladi3(otmail$com y pregunten todas las dudas que tengan$
Existen muc(simas formas de realizar este programa$ 5u imaginaci#n es el lmite$
Duc(a suerte$
Vladimir Rodrguez JP
Vladimir Rodrguez LE
CUARTA PARTE
SUBPROGRAMAS: Procedimientos y Funciones
Vladimir Rodrguez L1
Introduccin:
ien" (asta a(ora el tema m&s complicado que (emos )isto lo representan los arreglos :array<M sin embargo
entraremos a(ora en temas un tanto m&s difciles y que por ende requerir&n m&s traba'o por parte de ustedes a la (ora
de practicar$ =o intentar, explicarlos lo m&s detalladamente posible y de un modo entendible siempre partiendo de la
base de que ustedes como lectores no tienen conocimiento alguno sobre programaci#n$
Basta el momento (emos )isto programas que podan o no estar di)ididos en )arios bloques$ 1or si no lo
recuerdan llam&bamos bloque a aquella secci#n de c#digo delimitada entre un E>K? y un E?%$ ;ada bloque
siempre contiene m&s de una instrucci#n" de lo contrario no tendra sentido definirlo aunque es posible (acerlo" pero
es )isto por el programa como una nica instrucci#n$
%el modo en que (emos )enido programando" si nuestro programa tu)iera que realizar la misma tarea m&s de
una )ez nosotros deberamos escribir las mismas lneas de c#digo todas esas )eces$ Esto extiende muc(simo nuestro
c#digo fuente de'&ndolo difcil de entender adem&s de complicar muc(simo la tarea del programador$ Es por esto
que existen dos estructuras muy importantes y potentes que forman a los llamados subprogramas :peque!os
programas dentro del programa principal< conocidos como 1RO;E%KDKE?-O5 y G0?;KO?E5 :en otros lengua'es"
como Ca)a" ambas estructuras se conocen como D,todos<$
Estas estructuras comienzan con lo que en programaci#n se conoce como Dodularizaci#n ya que como su
nombre lo indica permiten formar m#dulos de programa que se encargan de ciertas tareas especficas$ %e este modo
el c#digo queda muc(o m&s entendible y compacto adem&s de lograrse una buena ordenaci#n del mismo$ Es
sumamente importante que entiendan todo este captulo antes de continuar si en )erdad quieren lograr crear un buen
programa" sea del tipo que sea" ya que los procedimientos y las funciones son b&sicos para cualquier programador
a)anzado$
Procedimientos:
Declaracin y llamado:
Veamos primero los 1RO;E%KDKE?-O52 0n 1rocedimiento ser& un subprograma que se encargar& de
realizar una tarea especfica dentro del programa principal$ .l igual que al programa principal" a los procedimientos
se les asigna un nombre :identificador< con el cual podremos llamarlo luego para pedirle que realice su tarea$ 0n
procedimiento se define de la siguiente manera
PROCEDURE identificador(parmetros);
0samos la palabra reser)ada PROCEDURE para indicar que definiremos un procedimiento" luego le damos un
nombre cualquiera que identifique su tarea o que nos sir)a a nosotros como referencia$ 5eguido del nombre se
colocan entre par,ntesis los par&metros que utilizar& el procedimiento para traba'ar :esto lo )eremos dentro de poco<
y finalmente un punto y coma$ -odo esto compone lo que llamamos encabezado o firma del procedimiento$ ?o
pueden existir dos procedimientos con el mismo identificador ya que como (a sido (asta a(ora y debera resultarles
ob)io" no pueden repetirse identificadores$ Esto puede cambiar de un lengua'e a otro" pero no entraremos en esos
detalles" concentr,monos en 1ascal$
;omo ya (e dic(o" un procedimiento es un subprograma" o sea" un peque!o programa dentro del programa
principal y por este moti)o tendr& una estructura casi id,ntica a la de este ltimo$ +o que quiero decir con esto es que"
luego del encabezado del procedimiento" podremos definir ;O?5-.?-E5" -K1O5" V.RK.+E5 e incluso otros
subprogramas dentro$ -ambi,n tendr& un bloque principal delimitado entre E>K? y E?% solo que este E?%
terminar& en punto y coma$ ?unca ol)iden que el nico E?% que termina en punto es el del programa principal$
Esta sera la estructura del programa principal con lo )isto (asta el momento2
PROGRAM Nombre_del_programa;
Const //Declaramos constantes.
Type //Declaramos tipos.
Var //Declaramos variables.
BEGIN
//Bloque principal del programa.
END.
Veamos la estructura pero agregando el lugar donde se declaran los procedimientos y funciones2
PROGRAM Nombre_del_programa;
Const //Declaramos constantes.
Type //Declaramos tipos.
Var //Declaramos variables.
{Declaracin de Procedimientos y Funciones}
BEGIN
//Bloque principal del programa.
END.
Veamos a(ora la estructura de un procedimiento2
PROCEDURE Nombre_del_procedimiento(parmetros);
Const //Declaracin de constantes.
Type //Declaracin de tipos.
Var //Declaracin de variables.
BEGIN
{Bloque principal del procedimiento}
END;
?oten que la estructura es id,ntica a la del programa principal excepto por el encabezado y por el (ec(o de
que el E?% del bloque principal termina en punto y coma$ . esa estructura debera a!adirle la declaraci#n de
funciones y procedimientos" pero esta )a en el mismo lugar que en el bloque del programa principal y no creo que
(aga falta mostrarles donde )a$ ?o se pongan ner)iosos" pronto entender&n me'or todo esto$
Veamos un e'emplo sencillo en el que pedimos al usuario que ingrese su ?ombre" su .pellido" su Edad" su
%ocumento de Kdentidad y su %irecci#n$ +uego mostraremos los datos ingresados pero separados por una lnea
formada por guiones y luego )arias lneas en blanco$ Veremos la )ersi#n sin procedimiento y luego la )ersi#n con
procedimiento$
1ara este e'emplo en particular usaremos el tipo primiti)o STRING" que lee cadenas de caracteres desde la
entrada est&ndar$ +o correcto a los efectos de este manual sera leer car&cter a car&cter y guardar estos en un arreglo
para formar la palabra" pero esto se los pedir, luego en un e'ercicio$
1 PROGRAM Datos_de_Usuario;
2
3 Const
4 separador='-';
5 lineas_a_saltear= 4;
6
7 Var
8 nombre, apellido, documento, direccion: string;
9 i: integer;
10
11 BEGIN
12 //Pedimos los ingresos al usuario.
13 Write('Ingresa tu nombre: ');
14 readln(nombre);
15 write('Ingresa tu apellido: ');
16 readln(apellido);
17 write('Ingresa tu documento: ');
18 readln(documento);
19 write('Ingresa tu direccin: ');
20 readln(direccion);
21
22 //Realizamos la primera separacin.
24 write(separador);
25 For i:=1 to lineas_a_saltear do
26 writeln;
27
28 //Escribimos el nombre del usuario.
29 writeln('NOMBRE: ',nombre);
30
31 //Realizamos la segunda separacin.
35 writeln;
36
37 //Escribimos el apellido del usuario.
38 writeln('APELLIDO: ',apellido);
39
40 //Realizamos la tercera separacin.
44 writeln;
45
46 //Escribimos el documento del usuario.
47 writeln('DOCUMENTO: ',documento);
48
49 //Realizamos la cuarta separacin.
53 writeln;
54
55 //Escribimos la direccin del usuario.
56 writeln('DIRECCIN: ',direccion);
57 END.
Este es un programa muy sencillo y no deberan tener ninguna dificultad al leerlo$ .n as explicar, lo que
(ace as luego se entiende perfectamente el e'emplo con procedimiento$
%eclaramos en las primeras lneas dos constantes2 separador" que es del tipo c-ar inicializada con el
gui#nM este car&cter ser& el que dibu'e una lnea separadora" esto es bien simple" escribimos unos 2E guiones en la
misma lnea y ya$ +uego est& la constante lineas_a_saltear que es del tipo integer inicializada con el nmero 4
y es la que utilizaremos para indicar cuantas lneas en blanco de'aremos entre dato y dato$
+uego declaramos cuatro )ariables del tipo string para leer los datos del usuario" una por cada dato$ ;omo ya
di'e" el tipo string lee los datos en forma de cadenas de caracteres$ Esto implica que si uno ingresa un )alor 4FFJ no
ser& el nmero entero 4FFJ sino la cadena de caracteres Y4FFJZ$ Es ideal para leer palabras o frases" pero no
(ablaremos de su uso en este manual ya que la idea aqu es que ustedes aprendan a programar estructuradamente y
entiendan como funcionan las (erramientas m&s primiti)as$ %e este modo lograr&n desarrollar una gran (abilidad
para programar y ser&n capaces de resol)er grandes problemas con pocas (erramientas" que muc(as )eces ser& a lo
que tendr&n que enfrentarse$
+a otra )ariable declarada es i" del tipo entero" y ser& la que usaremos como )ariable de control para los FOR$
%esde la lnea 13 a 2E inclusi)e solo pedimos al usuario que ingrese sus datos y los leemos desde la entrada
est&ndar$ Esto no implica ninguna dificultad para ustedes$
En la lnea 23 declaramos un GOR que simplemente dibu'a los 2E guiones y en la lnea 2F declaramos el GOR
que se encarga de de'ar lneas en blanco" tantas como la constante lineas_a_saltear indique en su )alor$ Estos
dos GOR se repetir&n )arias )eces durante el c#digo" cada )ez que necesitemos dibu'ar la lnea de guiones y de'ar
lneas en blanco$
;omo podr&n )er" usaremos cuatro )eces estas dos instrucciones en nuestro programa$ Realmente esto resulta
estpido ya que quedara m&s proli'o si no de'&ramos lneas en blanco para presentar los datos del usuario" pero la
intenci#n de este e'emplo es )er la necesidad de los procedimientos de una manera sencilla" ya que un buen e'emplo
sera muy comple'o y no es adecuado presentarlo en el momento en el que ustedes est&n intentando aprender una
nue)a (erramienta y que resultar& bastante difcil de comprender si no se traba'a con cuidado$
.(ora )eamos el mismo e'emplo pero con un procedimiento llamado Saltear que se encargue de realizar la
tarea de los dos GOR" o sea" dibu'ar la lnea de guiones y de de'ar lneas en blanco2
2
3 Const
4 separador='-';
6
7 Var
9 i: integer;
10
11 Procedure Saltear();
12 Begin
13 For i:= 1 to 20 do
14 Write(separador);
15 For i:= 1 to lineas_a_saltear do
16 Writeln;
17 End;
18
19 BEGIN
22 readln(nombre);
29
31 Saltear();
34
36 Saltear();
37
40
42 Saltear();
43
Vladimir Rodrguez LF
46
48 Saltear();
49
52 END.
ien" este programa es id,ntico al anterior en el sentido de que realiza exactamente la misma tarea$ ;omo
suceda en la )ersi#n anterior" repetamos cuatro )eces la declaraci#n de los GOR que se ocupan de dibu'ar los
guiones y saltear lneas$ .(ora lo (aremos solo una )ez dentro del procedimiento Saltear$
+as declaraciones de constantes y )ariables quedan id,nticas a las anteriores$ .(ora la diferencia principal
est& en que luego de las )ariables declaramos a nuestro procedimiento$ Ve&moslo detalladamente2
Procedure Saltear();
Begin
For i:= 1 to 20 do
Write(separador);
For i:= 1 to lineas_a_saltear do
Writeln;
End;
-enemos su encabezado que consta simplemente de la palabra reser)ada procedure y luego de su
identificador Saltear seguido por los par,ntesis$ En este caso estos par,ntesis no tienen nada dentro porque este
procedimiento no utiliza par&metros" eso lo )eremos m&s adelante$ . pesar de que no existan par&metros" es
con)eniente incluir los par,ntesis )acos" aunque pueden no (acerlo si lo prefieren$
+uego del encabezado podramos (aber declarado constantes" )ariables" tipos yHu otros procedimientos" pero
no (ace falta para este e'emplo tan sencillo" as que procedemos directamente a iniciar el bloque principal con la
palabra Begin$ . partir de aqu se escriben todas las instrucciones que realizar& el procedimiento" las cuales pueden
ser lo que a ustedes se les ocurra" lo que les (aga falta y que saben utilizar&n en m&s de una ocasi#n$ ?o ol)iden que
un procedimiento es un peque!o programa dentro del programa principal y por lo tanto admite exactamente las
mismas reglas$
En este caso nuestro procedimiento contiene a los dos GOR de antes y nada m&s$ ;erramos su bloque
principal con End; con lo cual nuestro programa sabe que all termina la declaraci#n de Saltear$
ien" ya tenemos nuestro procedimiento que se encarga de dibu'ar la lnea de guiones y de de'ar lneas en
blanco" a(ora solo debemos llamarlo cada )ez que lo necesitemos$ Esto es bien f&cil" solo escribimos su nombre en el
lugar en el que deseamos que realice su tarea y entre par,ntesis colocamos los par&metros que utilizaremos" en este
caso como no (ay par&metros solo de'amos los par,ntesis )acos aunque bien podramos no incluirlos$ En este
e'emplo )emos las cuatro llamadas en las lneas 31" 3J" 42 y 4I$
En este caso en particular no a(orramos muc(as lneas de c#digo al utilizar el procedimiento" pero como ya
di'e" un )erdadero e'emplo sera muy comple'o y en realidad los procedimientos y funciones utilizados llegan a estar
formados por cientos y cientos de lneas$ ;omo )en" utilizando un procedimiento solo (ace falta escribir una nica
)ez una tarea especfica )ol)i,ndose el c#digo m&s legible y m&s f&cil de mantener en caso de errores o actualizaci#n$
;uando nuestro programa principal llega" por e'emplo" a la lnea 31" regresa a la 12 :o a aquella donde est, el
E>K? del bloque principal del procedimiento< y realiza una por una las instrucciones all indicadas (asta llegar al
E?% que finaliza el bloque del procedimiento$ 1ueden )er esto si utilizan el %E0>ER paso a paso utilizando GL en
)ez de GI para a)anzar$ ;omo ya expliqu, antes" GL ingresa dentro de los subrprogramas en el paso a paso y GI no$
Variables Globales y Locales. Introduccin al Alcance de Identificadores:
En nuestro e'emplo )imos que nuestro procedimiento no posea ninguna )ariable declarada dentro$ 5in
embargo tambi,n )emos que la nica )ariable que usa es i y la nica constante es lineas_a_saltear adem&s de
que ambas solo son usadas por el procedimiento y por nadie m&s$ %ado este caso bien podramos (aberlas declarado
adentro del procedimiento para que se entienda que solo ser&n usadas por este y por nadie m&s$
+as )ariables declaradas en el programa principal son llamadas variables globales y las que se declaran
dentro de un procedimiento o una funci#n son llamadas variables locales o internas$ +as )ariables globales son
)isibles dentro de todo el programa" o sea" uno puede (acer referencia a ellas en cualquier parte del c#digo$ 1or
e'emplo" si tenemos una )ariable global entera llamada x podremos asignarle un )alor en cualquier parte de nuestro
programa" o sea" escribir x:=10 en la lnea nmero F y luego en la lnea nmero 12FI escribir x:= 25 o utilizarla
en expresiones o para que el usuario ingrese un )alor" etc$" por citar e'emplos tontos$ +as )ariables locales son
)isibles solo dentro del procedimiento o la funci#n en que son declaradas$ Esto implica que solo podamos (acer
referencia a )ariables locales dentro del bloque principal de su subprograma y n# fuera$ 1or e'emplo" si tenemos una
)ariable string llamada nombre dentro de un procedimiento podremos utilizarla como queramos solo dentro su
bloque principal" por e'emplo con una instrucci#n readln(nombre)" pero si escribimos la misma instrucci#n u
Vladimir Rodrguez LJ
otra que implique a dic(a )ariable fuera del bloque principal de su subprograma el compilador no la reconocer&
porque no la )e y nos dir& que no est& declarada$
5i )emos al programa principal como una m&quina" por e'emplo" un )e(culo" cada subprograma
corresponder& a alguna parte que se encarga de una tarea especfica$ 1or e'emplo" nosotros podemos conducir y
utilizar un reproductor de ;%s a la )ez$ +a unidad lectora de ;%s del )e(culo es como un procedimiento que se
encarga de reproducir los ;%s cuando nosotros lo dispongamos" pero aunque la podemos utilizar cuando queramos y
colocar el ;% que queramos :este sera nuestro par&metro<" no podemos )er ni utilizar sus piezas internas :que seran
sus )ariables locales<$ %e este modo si se rompe la unidad reproductora simplemente debemos ir directamente a ella
para repararla sin necesidad de tocar nada m&s del )e(culo$ +o mismo sucede con nuestros subprogramas$
2
3 Var
5
6 Procedure Saltear();
7 Const
8 separador='-';
10
11 Var
12 i: integer;
13 Begin
14 For i:= 1 to 20 do
15 Write(separador);
16 For i:= 1 to lineas_a_saltear do
17 Writeln;
18 End;
19
20 BEGIN
23 readln(nombre);
30
32 Saltear();
35
37 Saltear();
38
41
43 Saltear();
44
47
49 Saltear();
50
53 END.
?o solo las )ariables son )isibles segn donde est&n declaradas" las constantes y los tipos tambi,n pueden ser
globales o locales$
;omo )emos en este e'emplo" (e colocado las constantes de nuestro programa y la )ariable i dentro del
procedimiento Saltear$ 5i ustedes quisieran referirse a i fuera del procedimiento tendran un error en tiempo de
Vladimir Rodrguez LL
compilaci#n indic&ndoles que no encuentra el identificador 6i7$ Esto es porque i no es )isible fuera del
procedimiento$ Es como una pieza de nuestro reproductor de ;%s" no podemos )erlas ni utilizarlas$ Esto garantiza
que el procedimiento se dedique nicamente a su tarea y esta no pueda ser modificada accidentalmente por un cambio
de )alores o cosas por el estilo$
G'ense que si tu)i,ramos un programa de miles y miles de lneas donde solo existen )ariables globales"
cuando nuestros subprogramas se dispongan a usarlas" si nosotros no nos dimos cuenta y las modificamos antes en
algn lado del programa" realizar&n err#neamente sus tareas adem&s de que son totalmente dependientes de lo que
sucede globalmente en el programa y por tanto de nuestra suma atenci#n en el momento de programar$ Esto causa
que el intentar corregir errores se )uel)a una tarea ardua y tediosa cuando en realidad podra ser m&s sencillo$ En
nuestro )e(culo no sera aconse'able que funcionara mal el reproductor de ;%s porque ser rompi# el radiador" por
e'emplo" sino que el reproductor es independiente y por ende no depende de las dem&s piezas del )e(culo$ . la
in)ersa" no sera bueno que no funcionara el radiador si se nos rompe el reproductor$ Esto se aplica a otras
muc(simas partes" por supuesto$
.(ora bien" no ol)idemos que las )ariables globales son )isibles en todo el programa y podemos usarlas tanto
dentro como fuera de los subprogramas$ En nuestro )e(culo podramos decir que la batera es global ya que es usada
por muc(as partes y si esta falla todas esas partes fallar&n$ En realidad lo correcto sera decir que el sistema el,ctrico
es un subprograma donde est& declarada la batera y dentro de ,l tenemos a otros subprogramas como el reproductor
de ;%s" el claxon" las luces" los limpiaparabrisas" etc" y por tanto para todos estos subprogramas la batera resultara
global" aunque no para el resto del )e(culo$
%ic(o de otra manera$ -odo lo declarado dentro de un subprograma es local al mismo y por ende solo )isible
dentro de este" pero resulta global a lo que est& declarado all dentro$ 5iendo as" si tenemos un subprograma dentro
del cual (ay m&s subprogramas" las )ariables declaradas dentro de ,l ser&n 6globales7 a sus subprogramas pero no
ser&n )isibles fuera de ,l$
Veamos esto con declaraciones sencillas2
PROGRAM alcance_identificadores;
Var
x, y: integer;
Procedure Procedimiento1();
Var
a, b: integer;
Procedure Procedmiento2();
Var
j, k: integer;
Begin
//Instrucciones Procedimiento2.
End;
Begin
//Instrucciones Procedimiento1.
End;

BEGIN
//Instrucciones programa principal.
END.

Este es un e'emplo gen,rico sencillo$ -enemos el programa principal y dos procedimientos"
Procedimiento1 y Procedmiento2 de modo que el segundo est& declarado dentro del primero$ Est&n las
)ariables globales x e y declaradas en el programa principal y por ende )isibles en cualquier parte del c#digo" dentro
o fuera de cualquiera de los procedimientos$ %eclaradas en Procedimiento1 est&n las )ariables a y b las cuales
son )isibles solo dentro de dic(o procedimiento y no fuera$ ;omo Procedmiento2 est& declarado dentro de
Procedimiento1 estas )ariables resultan globales para Procedmiento2" o sea que son )isibles dentro de todo
su c#digo$ Ginalmente dentro de Procedmiento2 est&n declaradas j y k las cuales son solo )isibles all dentro y
en ningn otro lado$
.(ora )eamos este mismo e'emplo pero con un funcionamiento sencillo2
1 PROGRAM alcance_identificadores;
2
3 Var
4 x, y: integer;
5
6 Procedure Procedimiento1();
7 Var
Vladimir Rodrguez LI
8 a, b: integer;
9
10 Procedure Procedmiento2();
11 Var
12 j, k: integer;
13 Begin
14 x:= 10;
15 y:= 11;
16 a:= 1;
17 b:= 2;
18 j:= 20;
19 k:= 21;
20
21 write(x,' ',y,' ',a,' ',b,' ',j,' ',k);
22 End;
23 Begin
24 Procedimiento2();
25 End;
26
27 BEGIN
29 END.
;omo ya deberan saber" dadas estas declaraciones" cualquier )ariable es )isible en Procedimiento2 as
que utilizamos este para inicializarlas todas con los )alores que )en y luego utilizamos el m,todo WRK-E para
mostrar estos nmeros en pantalla separados por un espacio$ Procedimiento1 lo nico que (ace es llamar a
Procedimiento2 y el programa principal lo nico que (ace es llamar a Procedimiento1$ Este programa
podra resumirse solo a tener Procedimiento2 o incluso ni tenerlo" pero es para que aprendan esto del alcance de
los identificadores de las )ariables$
.(ora bien$ 8*u, pasa si escribimos la instrucci#n de la lnea 21 fuera de Procedimiento29 5i lo
(acemos dentro Procedimiento1 tendramos un error de compilaci#n ya que dentro del WRK-E (acemos
referencia a las )ariables j y k y estas solo son )isibles dentro de Procedimiento2$ 5i lo (acemos fuera de
Procedimiento1 tendramos un error del mismo tipo al anterior ya que (acemos referencia a las )ariables a, b,
j y k que no son )isibles fuera de sus procedimientos$ 1or este moti)o el nico que puede mostrar en pantalla los
resultados es Procedimiento2 ya que es donde son )isibles todas las )ariables de nuestro programa$
?o (ace falta inicializar todas las )ariables dentro de Procedimiento2$ Veamos el mismo e'emplo pero
inicializando cada )ariable dentro de su procedimiento para luego mostrar el resultado en pantalla2
1 PROGRAM alcance_identificadores;
2
3 Var
4 x, y: integer;
5
6 Procedure Procedimiento1();
7 Var
8 a, b: integer;
9
10 Procedure Procedmiento2();
11 Var
12 j, k: integer;
13 Begin
14 j:= 20;
15 k:= 21;
16
17 write(x,' ',y,' ',a,' ',b,' ',j,' ',k);
18 End;
19 Begin
20 a:= 1;
21 b:= 2;
23 End;
24
25 BEGIN
26 x:= 10;
27 y:= 11;
29 END.
Vladimir Rodrguez LP
Este programa produce exactamente la misma salida que el anterior$ 5olo (emos inicializado las )ariables en
distintos lugares$ %eben identificar bien cada bloque" o sea" cual pertenece al programa principal" cual a un
procedimiento y cual al otro$
5i no logran entender esto no deben continuar (asta que lo (ayan logrado ya que esto forma parte de la base
necesaria para entender subprogramas$ +o que )iene a continuaci#n requiere que (ayan comprendido donde puede
)isualizarse cada )ariable en dependencia de donde (a sido declarada$
Sombreado de Identificadores:
ien" continuemos con esto del alcance de los identificadores$ Basta a(ora simplemente (emos )isto que cada
)ariable es )isible dentro del cuerpo del subprograma en que (a sido declarada y no fuera$ .(ora bien" la
complicaci#n con esto comienza cuando tenemos una )ariable global con cierto nombre y luego en un subprograma
tenemos una )ariable local con el mismo nombre$ 81ero como9 8?o era que no pueden repetirse identificadores9 En
efecto" no pueden repetirse" pero como (emos )isto" una )ariable local es )isible solo dentro del subprograma donde
se (a declarado y por tanto fuera de este es como si no estu)iera declarada" como si no existiera" por lo tanto es
posible declarar otra con el mismo nombre$
1ero si la )ariable global es )isible dentro de un subprograma" cuando adem&s declaramos dentro de este una
)ariable local con el mismo nombre 8c#mo sabemos a cual nos estamos refiriendo dentro del subprograma9
Esto es simple pero genera muc(as confusiones$ 5i tenemos una )ariable global con un nombre id,ntico al de
una local" cuando dentro del subprograma nos referimos a ese identificador tiene precedencia la )ariable local" o sea"
esta 6sombrea7 a la global dentro del subprograma$ Veamos un e'emplo bien sencillo de entender2
1 PROGRAM sombreo_identificadores;
2
3 Var
4 X: integer;
5
J Procedure sombreo();
7 Var
I X: integer;
9
10 Begin
11 X:= 10;
12 End;
13
14 BEGIN
15 Sombreo();
1J END.
En este e'emplo tenemos una )ariable global N y una local dentro del procedimiento sombreo tambi,n
llamada N$ ;omo )emos" dentro del procedimiento (e inicializado N en 1E$ El programa principal lo nico que (ace
es llamar al procedimiento$
8;u&l de las dos N )ale 1E9 ;omo la inicializaci#n fue dictada dentro del procedimiento" al referenciar a N
nos estamos dirigiendo a la N local y no a la global" por lo tanto la N que )ale 1E es la interna al procedimiento y la
otra no sabemos cuanto )ale porque no le (emos dado ningn )alor an$
.(ora )eamos otro e'emplito sencillo2
1 PROGRAM sombreo_identificadores;
2
3 Var
4 X: integer;
5
J Procedure sombreo();
7 Var
I X: integer;
9
10 Begin
11 X:= 10;
12 Writeln(X);
13 End;
14
15 BEGIN
1J X:= 5;
17 Sombreo();
Vladimir Rodrguez IE
1I Write(X);
1P END.
.(ora (e inicializado ambas )ariables" la global con el )alor F y la interna con el )alor 1E$ 8;#mo ser& la
salida de este programa9
Parmetros: Pasaje por Valor:
;on lo )isto (asta a(ora acerca de los procedimientos no podemos (acer muc(o ya que no resultan demasiado
tiles$ En la mayora de los casos nuestro programa ir& realizando tareas y obteniendo resultados con dic(as tareas" y
muc(as )eces necesitaremos pasarle esos datos a los procedimientos para que traba'en con ellos$ 5i )ol)emos a
nuestro e'emplo del )e(culo y el reproductor de ;%s" nosotros necesitamos introducir un ;% para que este sea
reproducido obteniendo como resultado la msica$
Esto puede (acerse con las )ariables globales" pero como ya di'e" lo correcto es (acer que el procedimiento
sea independiente al resto del programa$ Es por eso que existen los par&metros" para introducir datos al procedimiento
y e)entualmente para obtenerlos$
+os par&metros no son m&s que )ariables como las que ya conocemos y que funcionar&n como )ariables
locales al procedimiento" con dos peque!as diferencias2 se declaran en el encabezado y no dentro del cuerpo del
procedimientoM y se inicializan al entrar al procedimiento con los )alores que nosotros pasemos como par&metros$
Veamos esto en un e'emplo sencillo2
1$ PROGRAM triangulo;
2.
3. Var
4$ base, altura: real;
5.
J$ Procedure calcularArea(b, h: real);
7. Begin
I$ if (b>0) and (h>0) then
P$ writeln('El rea del tringulo es: ',(b*h)/2:1:1)
10. else
11$ writeln('ERROR. Ninguna dimensin de un tringulo puede ser
menor o igual a 0.');
12$ End;
13.
14. BEGIN
1F$ //Pedimos el ingreso de datos al usuario.
1J$ write('Ingaresa el valor de la base: ');
1L$ readln(base);
1I$ write('Ingresa el valor de la altura: ');
1P$ readln(altura);
20.
21$ //Llamamos al procedimiento calcularArea.
22. calcularArea(base,altura);
23$ END.
Este es un programa sencillo para calcular el &rea de un tri&ngulo" no muy diferente al que ya (emos creado$
-enemos dos )ariables reales globales" una para el )alor de la longitud de la base del tri&ngulo y otra para el )alor de
la longitud de la altura$ %esde la lnea 1F (asta la 1P inclusi)e pedimos al usuario que ingrese los )alores de estas
dimensiones$
Veamos el encabezado del procedimiento calcularArea$ Entre par,ntesis tenemos la declaraci#n de dos
)ariables reales" b y h$ ;omo )en solo se trata de una declaraci#n como cualquier otra" solo que no lle)a la palabra
V.R delante :luego )eremos que s puede lle)arla pero solo para casos especiales<$ Esas )ariables" b y h"
corresponden a los par&metros del procedimiento" en este caso dos" por lo tanto cuando lo llamemos debemos
ingresarle dos )alores para sus par&metros para que las )ariables b y h los tomen$
Vean la llamada de la lnea 222 calcularArea(base,altura); Es igual a las anteriormente )istas con
la diferencia de que a(ora entre par,ntesis (emos colocado los )alores de los par&metros" los cuales" en este caso"
est&n dados por las )ariables base y altura$
El orden en el que se ingresan los par&metros en la llamada al procedimiento es el orden en el que se tomar&n"
por lo tanto base" que est& en primer lugar" le dar& su )alor a b ya que es el primer par&metro declaradoM y altura
Vladimir Rodrguez I1
le dar& su )alor a h ya que fue declarado en segundo lugar$ +os par&metros se pasan separados por comas tal y como
lo )en ustedes all$
-ambi,n es posible pasar directamente )alores como par&metros al procedimiento" por e'emplo" (acer una
llamada de este estilo2 calcularArea(10,20.33)$ 5i ese fuera el caso b tomara el )alor 1E y h el 2E$33$ Es
por esto que (oy di'e que los par&metros se inicializan en la llamada al procedimiento" ya que siempre tomar&n los
)alores que se les pasen$
?o es posible pasar un nmero de par&metros distintos al declarado en el encabezado$ 1or e'emplo"
calcularArea tiene dos par&metros y por tanto solo dos )alores deben pasarse en su llamada" ni m&s ni menos$
Otra cosa muy pero muy importante es que sean compatibles los tipos de par&metros con los )alores que se les
pasan$ En este caso los par&metros son ambos del tipo real y por tanto esperar&n )alores reales o enteros en la
llamada" pero no podr&n ir caracteres o cadenas de caracteres$ 5i lo (acen tendr&n un error en tiempo de compilaci#n
ya que el compilador se dar& cuenta de que (an introducido tipos incompatibles$
Declaracin de parmetros de tipos diferentes:
El encabezado del procedimiento anterior era
Procedure calcularArea(b, h: real);
pero bien poda (aber sido
Procedure calcularArea(b: real; h: real);
Es posible declarar los par&metros por separado indicando su tipo y utilizando el punto y coma para comenzar
con la declaraci#n siguiente$ 5in embargo resulta m&s til declarar todos los par&metros de un mismo tipo
especificando solo una )ez dic(o tipo" tal y como lo (ice en el e'emplo del tri&ngulo$ .(ora )eamos e'emplos de
encabezados sencillos donde (ay par&metros de tipos distintos2
Procedure procedimiento1(a, b: real; x, y: integer; letra: char;
nombre: string);
;omo )en tenemos seis par&metros" dos reales" dos enteros" un car&cter y una cadena$ Ese orden de
declaraci#n deber& respetarse para llamar al procedimiento2
procedimiento1(un real, otro real, un entero, otro entero,
un carcter, una cadena);
5i cambian dic(o orden tendr&n un error de compilaci#n$
Otro e'emplo2
Procedure procedimiento2(a, b: integer; n: char; x: integer);
.qu (ay cuatro par&metros" dos enteros" un car&cter y otro entero$ 81or qu, no declar, todos los enteros en una sola
declaraci#n9 O sea" este encabezado bien podra ser
Procedure procedimiento2(a, b, x: integer; n: char);
pero aunque son los mismos par&metros el orden est& en lugares diferentes y por tanto los )alores se pasar&n en dic(o
orden$ En el primer e'emplo la llamada sera as2
Procedimiento2(un entero, otro entero, un carcter, un entero);
y en el segundo e'emplo sera as2
Procedimiento2(un entero, otro entero, un entero, un carcter);
-engan muc(o cuidado con esto ya que el orden de declaraci#n y el de in)ocaci#n deben ser iguales$ . )eces
por una cuesti#n de entendimiento es me'or utilizar un encabezado como el del primer e'emplo$ Veamos algo tonto
pero tal )ez les ayude a entender esto2 5upongamos que tenemos un procedimiento del cual no nos interesa su
funcionamiento pero toma como par&metros el nombre de dos usuarios y sus edades$ 0n encabezado podra ser este2
Procedure usuarios(nombre1, nombre2: string; edad1, edad2: real);
Otro podra ser este2
Procedure usuarios(nombre1: string; edad1: real; nombre2: string;edad2: real);
%ados los nombres de los par&metros en ambos se entiende que nombre1 y edad1 corresponden a un
usuario y nombre2 y edad2 a otro$ 5in embargo en la llamada" en el primer e'emplo introducimos los dos nombres
y luego las dos edades en el orden correspondiente :usuario1" usuario2" edad de usuario1" edad de usuario2< mientras
que en el segundo e'emplo introducimos el usuario" su edad" el otro usuario y su edad$ +es presento ambos modelos
para que los tengan en mente$ 0stedes seleccionar&n el m&s adecuado o crear&n los suyos propios segn lo )ean
necesario$
Es importante que sepan que los par&metros pueden ser de cualquier tipo" incluso los declarados por ustedes
mismos siempre que dic(os tipos sean globales para el subprograma en cuesti#n$
Asignaciones de parmetros:
;omo ya di'e antes" los par&metros funcionan como )ariables locales al procedimiento al que pertenecen y
por lo tanto pueden usarse como tales$ O sea" podemos asignarle )alores a un par&metro" utilizarlo en una expresi#n"
(acer RE.% y WRK-E" etc$ ?o creo que esto requiera de e'emplos ya que ustedes deben traba'ar muy bien con las
)ariables a estas alturas$
Parmetros Nominales y parmetros Efectivos:
+lamamos par&metros nominales a los nombres :identificadores< que aparecen en el encabezado del
procedimiento o funci#n y par&metros efecti)os a los que usamos en la llamada al subprograma" ya sean )alores"
)ariables o expresiones$
En nuestro e'emplo del tri&ngulo los par&metros nominales eran b y h" y los efecti)os eran base y altura$
Basta a(ora (emos )isto el m,todo de pasa'e de par&metros por )alor" o sea" nosotros le pasamos )alores a los
par&metros en la llamada al procedimiento y sus par&metros se inicializan con dic(os )alores para traba'ar$ +o que
sucede luego con los par&metros no influye en el resto del programa" solo en el interior del procedimiento" excepto
claro que modifiquemos a prop#sito )ariables globales" cosa que no recomiendo$ Entonces" si dices que no es
recomendable modificar )ariables globales" 8c#mo podemos obtener resultados de un procedimiento9
Esa sera una buena pregunta$ 5i luego de calcular el &rea de tri&ngulo quisi,ramos seguir traba'ando con ese
)alor" pero no queremos utilizar )ariables globales 8qu, (acemos9
.ll es donde entra el pasa'e de par&metros por referencia" pero no (ablar, de ello toda)a" ya que es lo m&s
complicado de este tema$
En )ez de eso (ablemos primero de las funciones$
Funciones:
Declaracin y llamado:
+as funciones no difieren casi en nada de los procedimientos$ -ienen solo dos diferencias fundamentales2 el
encabezado" y que las funciones de)uel)en un )alor como resultado de su traba'o$ %e este modo" para calcular el &rea
de un tri&ngulo lo correcto es usar una funci#n y no un procedimiento$
>r&bense esto bien2
+.5 G0?;KO?E5 %EV0E+VE? V.+ORE5 ;ODO RE50+-.%O" +O5
1RO;E%KDKE?-O5 ?O$
Veamos como se declara una funci#n2
Function nombre(parmetros): tipo;
En )ez de utilizar la palabra reser)ada Procedure utilizamos Function$ +uego le damos un nombre y
entre par,ntesis declaramos sus par&metros tal y como lo (acamos con los procedimientos$ +uego de la declaraci#n
de par&metros )an dos puntos y el tipo de )alor que de)ol)er& la funci#n$ Este tipo debe ser un tipo simple" o sea" no
puede ser enumerado" arreglo :array<" con'unto :set< ni registro :record<$ -oda)a no (emos (ablado de algunos de
ellos" pero ya lo (aremos luego$
.(ora )eamos el e'emplo del &rea del tri&ngulo utilizando una funci#n que la calcule y de)uel)a su )alor2
2.
3. Var
4$ base, altura, area: real;
5.
J$ Function calcularArea(b, h: real): real;
L$ Begin
I$ if(b>0) and (h>0) then
P$ calcularArea:= b*h/2
10. else
11$ calcularArea:= 0;
12$ End;
13.
14. BEGIN
15. //Pedimos el ingreso de datos al usuario.
1J$ write('Ingaresa el valor de la base: ');
1L$ readln(base);
1I$ write('Ingresa el valor de la altura: ');
1P$ readln(altura);
20.
21. //Llamamos a la funcin calcularArea.
22$ area:= calcularArea(base,altura);
23$ writeln('El rea del tringulo es: ',area:1:2);
24$ END.
El funcionamiento de este programa es b&sicamente el mismo al del anterior con la diferencia de que en )ez
de un procedimiento usamos una funci#n adem&s de que declaramos una nue)a )ariable que contendr& el &rea del
tri&ngulo$
Veamos el encabezado de la funci#n2
Function calcularArea(b, h: real): real;
;omo )emos (emos declarado dos par&metros tal como lo (abamos (ec(o en el procedimiento$ .mbos
par&metros contienen )alores reales$ El tipo de la funci#n lo (emos declarado como real y por tanto esta de)ol)er& un
nmero como resultado de sus tareas$ El tipo de la funci#n no tiene nada que )er con el tipo de sus par&metros" en
este caso da la casualidad de que todo es del tipo real" pero pueden ser cualesquiera siempre y cuando el de la funci#n
sea un tipo simple$
.l igual que (acamos en el procedimiento" en la funci#n )erificamos primero que las dimensiones ingresadas
sean mayores que E" de lo contrario diremos que el &rea )ale E mediante la asignaci#n de la lnea 11$ .ll pueden )er
que utilizamos la funci#n como si fuera una )ariable y le asignamos el )alor E$ Vemos esto tambi,n en la lnea P
donde calculamos el &rea en caso de que las dimensiones sean )&lidas y le asignamos a la funci#n el )alor de
multiplicar el par&metro b por el par&metro h y di)idir ese resultado entre 2$
+a funci#n puede usarse a la izquierda de una expresi#n de asignaci#n ::=< solo si estamos dentro de su
bloque principal y solo cuando queramos asignarle el )alor que nos de)ol)er&$ Guera de su cuerpo la funci#n puede
ser usada solo a la derec(a de las expresiones de asignaci#n" ya sea para realizar c&lculos o para que otras )ariables
tomen su )alor" tal como sucede en la lnea 22 de nuestro programa$
Dediante la expresi#n de asignaci#n area:= calcularArea(base,altura) estamos asign&ndole a la
)ariable area el )alor que de)ol)er& calcularArea con los par&metros ingresados$
Otro modo de (aber escrito este programa (abra sido no declarar la )ariable area y escribir la instrucci#n
WRK-E+? de la lnea 23 de esta manera2
writeln('El rea del tringulo es: ', calcularArea(base,altura):1:2);
;omo pueden obser)ar" incluimos dentro de la instrucci#n WRK-E directamente la llamada a la funci#n
calcularArea para mostrar en pantalla su )alor$
Funciones Booleanas:
El tipo oolean es un tipo simple que toma uno de dos )alores posibles2 -R0E :)erdadero< o G.+5E :falso<$
Esto por supuesto ustedes ya lo saben$ +as funciones pueden ser del tipo boolean ya que como acabo de decir es un
tipo simple$ El (ec(o de que me tome un traba'o extra para tratarlas es para que ustedes puedan )er las formas m&s
comunes en las que estas son utilizadas$
.(ora )eremos el e'emplo del &rea del tri&ngulo donde tendremos dos funciones" una para )erificar que lo
ingresado por el usuario corresponde a dimensiones adecuadas para el tri&ngulo" en tal caso la funci#n de)ol)er&
-R0E y en caso contrario G.+5E$ 5i las dimensiones son correctas entonces llamaremos a la funci#n para calcular el
&rea del tri&ngulo para la cual solo nos limitaremos a (acer el c&lculo ya que siempre la llamaremos en caso de que
los datos ingresados sean correctos$
2.
3. Var
4$ base, altura, area: real;
5.
J$ Function verificarDatos(b, h: real): boolean;
7. Begin
I$ verificarDatos:= (b>0) and (h>0);
P$ End;
10.
11$ Function calcularArea(b, h: real): real;
12. Begin
13$ calcularArea:= b*h/2;
14$ End;
15.
16. BEGIN
17. //Pedimos el ingreso de datos al usuario.
1I$ write('Ingaresa el valor de la base: ');
1P$ readln(base);
2E$ write('Ingresa el valor de la altura: ');
21$ readln(altura);
22.
23$ If verificarDatos(base,altura) then
24$ writeln('El rea es: ',calcularArea(base,altura):1:2)
25. else
2J$ writeln('Has ingresado alguna dimensin menor o igual a 0.');
2L$ END.
Este e'emplo debera de resultarles bien sencillo de entender$ -enemos dos funciones declaradas$ 5olo
explicar, el funcionamiento de la funci#n verificarDatos2 ;omo pueden )er tiene dos par&metros reales y la
funci#n es del tipo boolean$ +a sentencia de la lnea I es igual a la que se usa para las )ariables del tipo boolean" o
sea" dic(a sentencia es equi)alente a escribir2
If (a>0) and (h>0) then
verificarDatos:= true
else
verificarDatos:= false;
Vladimir Rodrguez IF
.mbas formas funcionan de igual manera" pero la m&s correcta es la que yo utilic, en el programa$ .n as
ustedes siempre tienen la libertad de utilizar las (erramientas que prefieran$
Veamos a(ora el KG de la lnea 232
If verificarDatos(base,altura) then
;omo ya di'e" las funciones pueden ser usadas como )ariables pero no pueden asign&rsele )alores fuera de su
bloque principal$ En este caso la estamos utilizando en el KG como una )ariable del tipo boolean y por ende estamos
preguntando si es -R0E" recuerden que solo incluir el nombre de un boolean es preguntar por su )eracidad" y para
preguntar por su falsedad se utiliza el operador l#gico ?O-$
.(ora )eamos un e'emplo un poco m&s comple'o acerca del uso de una funci#n booleanas$ En este caso
)eremos una funci#n llamada Pertenece la cual se encargar& de )erificar si un elemento pertenece o no a un
arreglo$ En caso afirmati)o de)ol)er& -R0E y en caso contrario G.+5E2
1$ PROGRAM BooleanFunction;
2.
3. Const
4$ N= 5;
5.
6. Type
L$ arreglo = array [0..N] of integer;
8.
9. Var
1E$ i, elem: integer;
11$ a: arreglo;
12.
13$ Function Pertenece(x: integer; A: arreglo): boolean;
14. Var
1F$ i: integer;
16.
17. Begin
1I$ i:= 1;
19.
2E$ While (i <= N) and (A[i] <> x) do
21$ i:= i + 1;
22.
23$ Pertenece:= i <= N;
24$ End;
25.
26. BEGIN
2L$ Write(Ìngresa `,N,' enteros: `);
2I$ For i:=1 to N do
2P$ read(a[i]);
3E$ Writeln;
31$ Write(Ìngrese el elemento a buscar: `);
32$ readln(elem);
33.
34$ If pertenece(elem,a) then
3F$ writeln(Èl elemento `,elem,' pertenece al arreglo.')
3J$ else
3L$ writeln(Èl elemento `,elem,' no pertenece al arreglo.');
38.
3P$ END.
*uiero que ustedes mismos estudien este e'emplo (asta que lo comprendan$ Verifquenlo a mano si (ace falta"
eso muc(as )eces funciona para comprender como funciona un programa y es muc(as )eces lo que (ace falta para
encontrar un error que ni con el depurador :debuger< podemos (allar$
Vladimir Rodrguez IJ
Llamar a un subprograma desde otro subprograma:
Esto es realmente sencillo y segn mi consideraci#n no requiere ni de e'emplificaci#n" solo una le)e
explicaci#n para que lo sepan nada m&s" aunque an dar, un e'emplito gen,rico$
Es posible llamar a un subprograma desde otro siempre y cuando el subprograma que estamos llamando fue
declarado antes que el subprograma desde el que estamos llamando$ Veamos lo siguiente2
Procedure proc1(parmetros nominales);
Begin
//Instrucciones;
End;
Procedure proc2(parmetros nominales);
Begin
//Instrucciones
Proc1(parmetros efectivos);
End;
;omo )en aqu tenemos dos procedimientos" Proc1 y Proc2" el primero declarado antes que el segundo$ En
el cuerpo de Proc2 )emos una llamada a Proc1$ Esto es posible porque Proc1 ya est& declarado arriba" de lo
contrario el compilador nos dira que no encuentra el identificador especificado$ %ado esto no podemos llamar a
Proc2 desde Proc1$ Esto se aplica tanto para procedimientos como para funciones" y es posible llamar a una
funci#n desde otra" a un procedimiento desde una funci#n" a una funci#n desde un procedimiento" etc$" en fin" a un
subprograma desde otro$
;omo (abr&n )isto" (asta el momento (emos usado solo el pasa'e de par&metros por )alor tanto para
funciones como para procedimientos$ +a pr#xima secci#n de este manual explicar& el pasa'e de par&metros por
referencia$ Esto lle)ar& un poco de traba'o para su entendimiento" pero si se esmeran )er&n que no es tan complicado$
Espero que (asta a(ora (ayan entendido todo$ ;omo ya saben pueden escribirme a mi casilla de correo
mstr)ladi3(otmail$com para consultar cualquier duda que tengan y yo se las responder, a la bre)edad$ -ambi,n
pueden sugerir e'ercicios o se!alar errores en el manual" cosas que tal )ez resulten inentendibles" etc$
Vladimir Rodrguez IL
Parmetros: Pasaje por Referencia:
.ntes de comenzar con la explicaci#n en s de lo que significa el pasa'e de par&metros por referencia (e de
dar una le)e y sumamente b&sica explicaci#n acerca de lo que en )erdad es una )ariable$ +uego me extender, un
poco (ablando de la memoria R.D para que logren comprender esto lo me'or posible$
?o se (asta que punto saben ustedes de computadoras" pero asumo que tienen un dominio bastante a)anzado
si se (an lanzado a la programaci#n$ ;on esto me refiero a que saben usar una 1; sin dificultad alguna" na)egar en
Knternet" descargar y subir arc(i)os$ -ambi,n supongo que saben lo que es un disco duro y para qu, sir)e" qu, es la
memoria R.D y para qu, sir)e" cu&les son los dispositi)os de entrada y salida" etc$ .n as )eamos un pantallazo
muy general acerca de la memoria R.D" que es lo que nos importa a(ora$
-odos ustedes deben de (aber )isto que al obtener un nue)o programa este suele especificar los
requerimientos mnimos del equipo para que pueda funcionar$ +o m&s importante acerca de estos requerimientos es la
)elocidad de procesamiento de la ;10" la capacidad de almacenamiento del disco duro y la cantidad de memoria
R.DM para los 'uegos tambi,n suele indicarse el mnimo requerido de capacidad y )elocidad de la >10 :tar'eta
gr&fica<$ ;omo deberan saber" la ;10 :;entral 1rocessing 0nit< o 0nidad ;entral de 1rocesamiento corresponde al
cerebro de la computadora y es la que se encarga de procesar absolutamente toda la informaci#n que se est,
transfiriendo en el momento$ %e este modo la ;10 en)a luego diferentes instrucciones a los diferentes componentes
de la computadora para que estos realicen sus propias tareas$
;omo (an )isto a(ora que saben lo que es programar" una ;10 se dedica a seguir instrucciones bien
estructuradas$ +as sigue paso a paso tal y como son dictadas por los programadores$ 1or eso decimos que una
computadora no es inteligente" es estpida ya que (ace exactamente lo que se le dice y nada m&s$ ;laro que existen
algoritmos de inteligencia artificial que permiten 6pensar7 a una computadora" pero no tengo idea de c#mo funcionan
y adem&s no son rele)antes aqu$
+as instrucciones que sigue la ;10 son cargadas en la memoria R.D solo mientras se necesiten all" luego
son eliminadas para liberar la memoria y de'ar lugar a otras instrucciones$ -ambi,n se libera toda la R.D al apagar
el 1;$ Esta memoria est& di)idida en celdas que a su )ez est&n di)idas en celdas que representan bits de informaci#n$
En dic(as celdas es donde se guardan las )ariables" las constantes" etc$ %ependiendo de la informaci#n que contenga
una )ariable o algn otro elemento ser& la cantidad de celdas de memoria que se necesitar&n para almacenarlo$ ?o es
lo mismo guardar un entero que un arreglo de enteros" claramente el segundo es muc(o m&s grande que el primero$
;omo pueden )er en la imagen" tenemos un peque!o
trozo de c#digo 1ascal y una representaci#n de la memoria R.D$
En el c#digo 1ascal podemos )er la declaraci#n de una )ariable
entera a que es inicializada con el )alor 1E$ +o que en realidad
estamos (aciendo es ocupar una celda de memoria" o parte de
ella" con el )alor entero 1E$ +o que para nosotros representa el
identificador a es el nombre de la )ariable" pero en realidad para
la ;10 esa es la direcci#n de la celda de memoria donde se est&
guardando la informaci#n de esa )ariable$
;uando nosotros declaramos constantes o )ariables lo que
estamos (aciendo en realidad es guardar celdas de memoria para
almacenar su informaci#n$ +os identificadores :nombres< solo
contienen la referencia a la celda de memoria donde se guarda la
informaci#n$ Es por esto que no podemos duplicar
identificadores" sera como decirle al ;10 6=uarda la
in,ormacin de esta #ariable en tal celda de memoria. 8 la de
esta otra #ariable tambi9n all. pero ambas deben ser
independientes e-7$ 1or este moti)o es bueno que un programa
utilice siempre la menor cantidad de )ariables posible" para que
necesite menos memoria R.D para poder e'ecutarse$ G'ense que normalmente los programas son muy comple'os y
tienen miles de )ariables" tipos" constantes y estructuras diferentes$ 1iensen nada m&s en el programa que est&n
usando a(ora para leer este texto si es que lo (acen en su computadora" o piensen en el procesador de texto que yo
us, para escribirlo$ 8;u&ntas )ariables (ay9 .dem&s tambi,n se carga la interfaz gr&fica para que nosotros )eamos
botoncitos" menes e conos" cuadros de texto" etc$ Bay miles de estructuras dentro de dic(o programa que se dedican
a ir )erificando si lo que se escribe tiene faltas de ortografa o no" estructuras de bsqueda" de correcci#n" de
numeraci#n" etc$ 1odra escribir un nico manual dedicado al an&lisis de un procesador de textos a)anzado como lo
es Microso,t >ord u ?pen?,,ice >riter$
;uando nosotros escribimos una expresi#n de asignaci#n del tipo x:= y; estamos diciendo2 6%e a la celda
donde est la in,ormacin de @ 8 copia esta in,ormacin en la celda donde guardas la de 1.6$ Esto solo copia los
contenidos de las celdas de memoria" pero ambas siguen siendo independientes$ +o mismo pasa cuando llamamos a
un subprograma y le damos par&metros de entrada" lo que (acemos es copiar el contenido de las celdas de memoria
de los par&metros efecti)os en los nominales" pero unos siguen siendo independientes de otros$ Esto no suceder& en el
pasa'e de par&metros por referencia ya que en realidad no pasaremos los contenidos de las celdas sino la referencia de
su ubicaci#n en la memoria$
Vladimir Rodrguez II
ien" )eamos entonces lo que significa el pasa'e de par&metros por referencia$ 1rimero lo explicar, tal como
es y luego lo detallar, con ilustraciones y e'emplos para que puedan comprenderlo bien ya que esto es un tema muy
importante para la programaci#n y lo necesitar&n si pretenden lanzarse a aprender un lengua'e m&s a)anzado que el
1ascal$ ;omo ya di'e" en el pasa'e de par&metros por referencia no copiamos el contenido de una celda de memoria
en otra sino que copiamos la referencia de su ubicaci#n en la memoria$ Veamos qu, cornos significa esto2 ;uando
(ablo de re,erencia a una celda de memoria me refiero a su direcci#n$ ;ada celda tiene una direcci#n nica en la
memoria" o sea" lo que indica su ubicaci#n$ Kmaginen que cada celda de memoria es un (ogar diferente disponible
para (abitarM al igual que en el mundo real" cada (ogar tiene una direcci#n nica$ ?o importa c#mo se escribe esa
direcci#n ni como la interpreta la ;10" solo importa que cada celda tiene una nica direcci#n que la identifica$
5i les parece me'or" imaginen que esa direcci#n es una flec(a que le dice a la )ariable 5Esa celda de all es
donde guardars tu in,ormacin6$ Veamos )arios dibu'os ilustrando primero las asignaciones normales :lo que
(emos )isto (asta a(ora< y luego las de pasa'e por referencia$ 5upongan que declaramos tres )ariables tal como lo
)en en la Gigura 1$ En ese momento se asignar&n lugares de memoria para dic(as )ariables pero como no les (emos
asignado ningn )alor no sabemos qu, informaci#n pueda contener cada celda$ +uego" en al Gigura 2" le asignamos a
cada )ariable un )alor" entonces el programa mirar& la flec(a de esa )ariable y asignar& ese )alor a la celda que le
corresponde sustituy,ndolo por el )alor anterior2
.(ora imaginen que luego de las asignaciones de la Gigura 2 realizamos la de la Gigura 32
;omo pueden )er all lo nico que (emos (ec(o
fue asignarle a y el )alor de x y por lo tanto lo
que sucedi# fue que se copi# el )alor que estaba
en la celda de x (acia la celda de y$
-ambi,n puede )erse que cada celda sigue
siendo independiente y cada )ariable sigue
manteniendo su misma celda" o sea" cada flec(a
sigue apuntando al mismo lugar que antes$
Eso es lo que no suceder& en el pasa'e por
referencia ya que lo que (acemos en ese caso es
cambiar la direcci#n de las flec(as$
Es importante notar que las celdas no se
guardan en ningn orden especfico" por eso la
celda de x est& m&s aba'o que la de y a pesar de
que la primera )ariable se declara antes$
Veamos un e'emplo de un procedimiento
llamado proc1 con tres par&metros" num1,
num2 y letra, a los cuales les pasamos sus
)alores con el pasa'e por )alor tal y como lo
(emos )enido (aciendo (asta a(ora2
Vladimir Rodrguez IP
?
?
?
Var
x, y: integer;
a: char;
x
y
a
Figura 1
15
10
c
X:= 10;
Y:= 15;
a:= `c';
x
y
a
Figura 2
10
10
c
y:= x;
x
y
a
Figura 3
1ues bien" )eamos lo que ilustra esta figura$ %eclaramos las )ariables globales x, y como enteros y a
como car&cter$ El procedimiento tiene los tres par&metros que ya nombre los cuales tambi,n funcionan como
)ariables :eso ya lo expliqu, antes<$ .l comenzar el programa le asignamos a cada )ariable global un )alor especfico
de acuerdo a su tipo y luego llamamos al procedimiento indicando qu, )alor de cada )ariable debe asignarse a cada
par&metro$ Eso lo (acemos al colocar las )ariables entre par,ntesis al llamar al procedimiento ya que el orden en que
esas se colocan es el que indica cual )ariable corresponde a cual par&metro$ %e ese modo copiamos el )alor de x a
num1" el de y a num2 y el de a a letra$ . los efectos de lo que sucede en memoria eso es lo mismo que (acer las
siguientes asignaciones2
num1:= x; num2:= y; letra:= a;
.(ora )eamos el mismo e'emplo pero pasaremos por referencia el )alor del par&metro letra" los otros
dos seguir&n siendo por )alor$ .qu podr&n apreciar qu, es lo que le indica al programa cu&l par&metro se toma por
referencia y cual no$ 0sar, dos figuras para este e'emplo" una para antes de la llamada al procedimiento y otra para
luego de la misma2
Vladimir Rodrguez PE
10
Var
x, y: integer;
a: char;
Procedure proc1(num1, num2: integer; letra:
char);
(. . .)
//Bloque del procedimiento.
BEGIN
x:= 10;
y:= 15;
a:= `c';
proc1(x,y,a);
END.
x
Y
a
num1
num2
letra
Figura 4
15
c
10
15
c
Vean que el encabezado del procedimiento sigue siendo igual excepto porque usamos la palabra reser)ada
V.R antes de declarar el par&metro letra$ 0sar esta palabra antes de declarar los par&metros indica que los )alores
de estos ser&n tomados por referencia$ .(ora )eamos lo que sucede luego del llamado al procedimiento2
Vladimir Rodrguez P1
10
Var
x, y: integer;
a: char;
Procedure proc1(num1, num2: integer; var letra:
char);
BEGIN
x:= 10;
y:= 15;
a:= `c';
END.
x
Y
a
num1
num2
letra
Figura 5
15
c
?
?
?
10
Var
x, y: integer;
a: char;
Procedure proc1(num1, num2: integer; var letra:
char);
BEGIN
x:= 10;
y:= 15;
a:= `c';
proc1(x,y,a);
END.
x
Y
a
num1
num2
letra
Figura 6
15
c
10
15
8*u, sucedi#9 1ues bien" como ya di'e antes" en el pasa'e de par&metros por referencia estamos pasando la
direcci#n de una celda y no su )alor" por tanto como el par&metro letra es pasado por referencia le estamos
diciendo que tome la misma celda de memoria que a para guardar sus )alores$ Esto implica que a(ora (ay dos
)ariables que utilizan la misma celda para almacenarse y por lo tanto si modificamos una modificamos la otra y que
apuntan a lo mismo" o sea" si dentro del bloque del procedimiento (acemos una asignaci#n letra:= `z'; el
)alor de la celda que a(ora dice c cambiar& a z y por lo tanto" a tambi,n )aldr& z y no c$ +o mismo si (acemos al
re),s" imaginen que asignamos a:= `h'; dentro del procedimiento$ El par&metro letra tambi,n )aldr& h ya que
mira a la misma celda$ En simples palabras" a y letra pasan a formar uno mismo" o sea" es como si nombr&ramos
la misma cosa de dos formas diferentes$ %a lo mismo si la llamamos a o letra" modifican y responden lo mismo en
tanto miren a la misma celda de memoria$
Este efecto durar& solo dentro del bloque principal del procedimiento$ 0na )ez salgamos de all todo
)ol)er& a la normalidad$
-al )ez piensen que podra (aber explicado esto de un modo m&s corto" pero cr,anme que no basta solo con
decir 5En el pasaje de parmetros por re,erencia el parmetro e,ecti#o 8 el nominal pasan a ser uno mismo durante
toda la ejecucin del subprograma.6 Esto generar& muc(as dudas a la (ora de traba'ar" incluso a(ora las tendr&n
cuando comiencen con los e'ercicios$
Importante: %eclarado un par&metro por referencia solo puede usarse una )ariable como par&metro
efecti)o y no un )alor especfico$ Esto significa que para este procedimiento Procedure proc1(num1, num2:
integer; var letra: char); no podemos (acer una llamada como esta2 proc1(x,y,10); pero s una
proc1(x,5,a); ya que num1 y num2 son par&metros que se toman por )alor$
Veamos a(ora dos ilustraciones m&s$ En la Gigura L )emos lo que sucede si los par&metros num1 y num2
se toman por referencia y letra por )alor" y en la Gigura I )emos lo que sucede si todos son par&metros tomados
por referencia2

10
Var
x, y: integer;
a: char;
Procedure proc1(var num1, num2: integer; letra:
char);
BEGIN
x:= 10;
y:= 15;
a:= `c';

proc1(x,y,a);
END.
x
Y
a
num1
num2
letra
Figura 7
15
c
c
%ado que utilizar pasa'e de par&metros por referencia modifica al par&metro efecti)o usamos estos como
par&metros de entradaHsalida a un procedimiento$ Esto es muy til ya que a diferencia de una funci#n podemos
obtener muc(os datos de salida en )ez de uno solo$
?O-.2 ?o es recomendable utilizar el pasa'e de par&metros por referencia para las funciones$
;on esto quedara abarcado todo lo referente a los subprogramas y por tanto es (ora de practicar todo lo
que (an ledo ya que sin pr&ctica no a)anzar&n un pelo$ Es totalmente imprescindible que los (agan todos o de lo
contrario no ser)ir& de nada todo lo dado (asta a(ora$ +os m&s importantes son los ltimos" escritos en letra ro'a los
que corresponden a un parcial de facultad$ -odo lo dado en las clases es lo que yo les (e explicado aqu y los
e'ercicios que les (e puesto" incluso los enlaces de inernet" perteneces a la facultad y por tanto ustedes son totalmente
capaces de resol)er estos e'ercicios (abiendo ledo este manual y (abi,ndose esforzado en realizar los e'ercicios
planteados y estudiar los e'emplos que les (e puesto$
Ejercicios:
Ejercicio 1: Expliquen la diferencia entre un par&metro formal :o nominal< y un par&metro )erdadero :o
efecti)o<$
Ejercicio 2: Escriban un procedimiento con solo tres par&metros enteros2 a" b y c$ El efecto del
procedimiento debe ser 6girar7 los )alores de los par&metros (acia la derec(a de manera que" despu,s de la e'ecuci#n"
el )alor que originalmente estaba en a quede en b" el que estaba en b quede en c y el que estaba en c quede en a$
E'emplos de entrada2
4 1 7
-12 6 2
E'emplos de salida2
7 4 1
2 -12 6
10
Var
x, y: integer;
a: char;
Procedure proc1(var num1, num2: integer; letra:
char);
BEGIN
x:= 10;
y:= 15;
a:= `c';

proc1(x,y,a);
END.
x
Y
a
num1
num2
letra
Figura 8
15
c
Ejercico 3: ;onsideren el siguiente programa 2

1 PROGRAM alcance;
2 Var tum, num, temp: Integer;
3 Procedure Prog (a, b: integer; VAR c: integer);
4 Var reloj: Integer;
5 Begin
6 reloj:= a * b;
7 reloj:= reloj + 1;
8 c:= reloj + a;
9 WriteLn(a, b, c, reloj)
10 End;
11 (*Programa principal*)
12 BEGIN
13 tum:= 1;
14 num:= 2;
15 Prog(tum, num, temp);
16 WriteLn(temp);
17 tum:= 0;
18 num:= 1;
19 Prog(tum, num, temp);
20 WriteLn(temp)
21 END.
1$ Kdentifiquen laHs )ariableHs globales del programa principal$
2$ Kdentifiquen laHs )ariableHs localHes declaradaHs en el procedimiento Prog$
3$ Kdentifique los par&metros formales del procedimiento Prog$ %etermine los par&metros de entrada :de
)alor< y de salida :por )ariable<$
4$ %etermine los par&metros por )alor )erdaderos :efecti)os< en la primera in)ocaci#n del procedimiento$
F$ %etermine los par&metros por )alor )erdaderos :efecti)os< en la segunda in)ocaci#n del procedimiento$
J$ %etermine la salida est&ndar del programa$ 8;u&ntas lneas se escribir&n9
Ejercicio 4: %ado el siguiente procedimiento

PROCEDURE Prueba (x: Real; y: Integer; VAR z: Real);
y las siguientes )ariables

VAR tiempo : Real;
tiempo_i : Integer;
%eterminen cu&les de las siguientes in)ocaciones son correctas$ Custifiquen$
1rueba: 1" 2$E" tiempo <M
1rueba: tiempobi" 3" tiempo <M
1rueba: tiempobi" 3" 2$E <M
1rueba: 1" 3" tiempobi <M
1rueba: F T tiempobi" round: L$3 <" tiempo <M :T tiempobi ya fue inicializada T<
1rueba: tiempo" 3" tiempo <M 1rueba: 1rueba: F" 33$I" tiempo <" P2" tiempo <M
Cules son los errores en las invocaciones incorrectas?
Ejercicio 5: Kmplementen un procedimiento que dado un arreglo de enteros de)uel)a el )alor m&s grande y
el ndice en que ,ste ocurre$ El largo del arreglo es dado por una constante ? global al procedimiento$
Ejercicio 6: Escriban una funci#n llamada con# que con)ierta un arreglo de caracteres" cada uno de los
cuales contiene un dgito decimal" al entero equi)alente$
1or e'emplo" si el par&metro de entrada es A B'C. BDC. BEC F" entonces el entero resultante ser& 'DE$ El largo del arreglo
es dado por una constante N global a la funci#n$
Ejercicio 7: Kmplementen una funci#n que dados 2 arreglos de caracteres" determine si el primero es prefi'o
del segundo$ +uego reescriban el Ejercicio D de la pgina GE utilizando esta funci#n$ En caso de que la cadena m&s
corta pertenezca a la m&s larga" despliegue en la salida est&ndar la posici#n en que comienza la coincidencia$
-omando el primer e'emplo dado en la letra de dic(o e'ercicio" la salida sera2
El texto 'tor' se encuentra dentro del texto 'totora' ( posicin de
comienzo: 3 ).
En caso de que no (aya coincidencia" el mensa'e deber& ser el mismo que en el e'ercicio 2 de la p&gina J3$
Ejercicio 8: %ado el siguiente programa2
PROGRAM principal (input, output);
VAR a, b : Integer;
PROCEDURE a1 (VAR x : Real);
VAR c : char;
PROCEDURE a2 (y : char);
VAR d : Integer;
BEGIN
. . .
END;
BEGIN
. . .
END;
PROCEDURE b1;
VAR e : Integer;
BEGIN
. . .
END;
BEGIN
. . .
END;
Kndiquen las )ariables a las que se puede (acer referencia dentro del alcance del procedimiento a2" las que
se pueden referenciar dentro de a1" las que se pueden referenciar dentro de b1 y las )ariables globales$
Ejercicio 9: %eterminen la salida del siguiente programa si se obtiene de la entrada est&ndar el entero 4
:elegir la opci#n a" b" c o d<$
PROGRAM Ppal (input, output);
VAR x : Integer;
PROCEDURE a (VAR y : Integer);
BEGIN
y := y * 2;
END;
PROCEDURE b (x : Integer);
BEGIN
x := x + 5;
Vladimir Rodrguez PF
END;
BEGIN
ReadLn (x);
b (x);
WriteLn (x);
a (x);
WriteLn (x);
END.
a 4 b 4 c P d P
I P 1I I
Ejercicio 10: %eterminen la salida del siguiente programa2
PROGRAM Detectar (input, output);
VAR a, b, c, d : Integer;
PROCEDURE pal (y: Integer; VAR z: Integer);
VAR c : Integer;
BEGIN
b := y * z;
c := b + z;
y := y + 1;
z := z * (z + 1);
WriteLn (b:3, c:3, y:3, z:3)
END;
BEGIN
a := 2;
c := 3;
d := 5;
pal (c, d);
WriteLn (a:3, b:3, c:3, d:3);
b := 4;
pal (b, a);
WriteLn (a:3, b:3, c:3, d:3)
END.
El simbolo - representa el salto de lnea$
.2 1F 2E 4 3EA 2 1F 4 3EA P 1E P JA J P 4 3E
2 1F 2E 4 3EA 2 1F 4 FA P 1E P JA 2 P 4 F
;2 1F 2E 4 3EA 2 1F 3 3EA I 1E F JA J I 3 3E
%2 1F 2E 4 3EA 2 1F 3 FA I 1E F 3A 2 I 3 F
Ejercicio 11: Kndiquen cual sera la salida del siguiente programa suponiendo que como entrada se le
proporciona el ltimo dgito de su nmero de c,dula de identidad$ 1or e'emplo" si su nmero de c,dula es el
1$234$FJLAI" entonces el nmero que se ingresa es el L$
Program Ej1 (input,output);
var z: integer;
function f (y : integer) : boolean;
begin
z := z + y;
f := y mod 2 = 0
end;
procedure a (var y : integer);
Vladimir Rodrguez PJ
begin
y := 2 * y;
end;
procedure b (var z : integer);
begin
z := z + 5;
end;
begin
readln(z);
if f(z) then a(z) else b(z);
writeln('Salida = ', z)
end.
Ejercicio 12: Kndique cual sera la salida del siguiente programa suponiendo que como entrada se le
proporciona el ltimo dgito de su nmero de c,dula de identidad$ 1or e'emplo" si su nmero de c,dula es el
1$234$FJLAI" entonces el nmero que se ingresa es el L$ El orden de e)aluacion de las expresiones numericas depende
de cada compilador$ En este caso" asuma que ese orden es de izquierda a derec(a$
program jul2002 (input,output);
var z: integer;
function g (var x: integer):integer;
begin
x := x + 1;
z := z + 1;
writeln('Salida en g1:',x + z);
g := x + z
end;
function f (x: integer; var y: integer): integer;
function g(x: integer): integer;
begin
x := x + 1;
writeln('Salida en g2:',x + z);
g := x + z
end;
begin
x := x + 1;
z := z + x - y + 2;
if x mod 2 = 0 then y := y + 1
else y := y - 1;
x := g(x) + y;
writeln('Salida en f:',x);
f := x
end;
procedure p (var x,y: integer);
begin
y := f(x,y) + z;
y := y + g(x) + x;
x := x + 1;
writeln('Salida en p:',y)
end;
begin
readln(z);
p(z,z);
writeln('Salida final:',z + 1);
end.
Vladimir Rodrguez PL
Vladimir Rodrguez PI
QUINTA PARTE
Enumerados
Registros con y sin variante
Arreglo con tope
Vladimir Rodrguez PP
Introduccin:
Vol)emos una )ez m&s a los tipos definidos por el programador$ Basta a(ora traba'amos con los 5ubrangos"
que podan tomar )alores consecuti)os dentro de un rango especfico contenido en un rango mayorM y los .rreglos"
que correspondan con tablas de datos de un mismo tipo$ %ic(as tablas podan tener una dimensi#n" dos" tres o
muc(as m&s$
+uego de eso cambiamos de tema para pasar a los 1rocedimientos y las Gunciones" que correspondan con
peque!os programas dentro del programa principal cuya funci#n era realizar una tarea especfica$ .(ora (ace falta
terminar de )er los tipos que podemos definir nosotros mismos como programadores" y nos quedan tres2 Enumerados"
;on'untos :casi no traba'aremos con ellos< y Registros$
+o )erdaderamente importante aqu son los Registros ya que estos son capaces de almacenar )arios datos
diferentes y de diferentes tipos cada uno" pero esto ya lo ampliaremos en su momento$
Vladimir Rodrguez 1EE
Enumerados:
+os Enumerados" tal como su nombre lo indica" son enumeraciones de ciertos elementos especficos y que
generalmente corresponden a un mismo grupo de calificaci#n$ 1or e'emplo" los das de la semana corresponden todos
a un mismo grupo :das de la semana<M los meses del a!o tambi,n son un grupo especfico" y as con muc(as otras
cosas que se nos pueden ocurrir$ &sicamente un enumerado es un con'unto de elementos que nosotros definiremos
uno a uno$
Realmente no resultar& difcil traba'ar con este tipo de datos$ Veamos primero su declaraci#n2
Type
diasSemana=(domingo, lunes, martes, miercoles, jueves, viernes,
sabado);
Mes= (enero, febrero, marzo, abril, mayo, junio, julio, agosto,
setiembre, octubre, noviembre, diciembre);
puntoCardinal= (norte, sur, oeste, este);
0tilizamos primero la palabra Type y luego" al igual que antes" le damos un nombre al tipo seguido de un
signo de igual$ +uego colocamos entre par,ntesis y separados por comas cada elemento del enumerado$ %e este modo
tenemos all uno que contiene todos los das de la semana" otro con todos los meses del a!o y otro con los cuatro
puntos cardinales$
+a declaraci#n gen,rica de un tipo enumerado sera as2
Type nombreDelTipo= (elemento1, . ,elementoN);
donde cada elemento dentro de los par,ntesis corresponde a un identificador cualquiera$ .s" los elementos de los
enumerados" pueden llamarse de cualquier manera pero 'am&s repetirse" 'am&s pueden comenzar con nmeros o
caracteres especiales ni contener espaciosM como ya di'e" son identificadores y por ende (an de cumplir las mismas
reglas que estos$
Visto de esta manera no resulta muy sencillo (allarle una utilidad a los enumerados" sin embargo podremos
)er que s la tienen cuando usemos registros$ 1or este moti)o a(ora )eremos solo aspectos generales de este tipo de
datos para luego poder aplicarlos realemente con lo registros$
1ara empezar" cada elemento que asignamos a un enumerado tiene un ordinal de acuerdo a la posici#n en la
que est& nombrado comenzando a contar desde el nmero E$ %e este modo para el tipo diasSemana tendramos
los siguientes ordinales2
ord(domingo)= 0
ord(lunes)= 1
ord(viernes)= 5
ord(sabado)= 6
%e modo in)erso podemos obtener un elemento de un enumerado dado su ordinal$ 1ara el tipo diasSemana
esto sera as2
diasSemana(0)= domingo
diasSemana(3)= miercoles
.plicando estas dos propiedades a los tipos Mes y puntoCardinal podramos tener lo siguiente2
Mes(0)= enero puntoCardinal(0)= norte
Mes(11)= diciembre puntoCardinal(3)= este
ord(octubre)= 9 ord(sur)= 1
Recuerden siempre que la funci#n OR% de)uel)e un )alor del tipo integer$
.(ora dganme cu&l sera la salida que obtendramos de las siguientes sentencias si pertenecieran a un
programa donde est&n declarados los enumerados anteriores2
writeln(ord(Mes(0)));
writeln(puntoCardinal(ord(domingo)));
Es sumamente importante que al intentar obtener un elemento de un enumerado dado por su ordinal 'am&s
utilicemos un entero que est, por fuera del rango de elementos del enumerado$ Esto significa que" por e'emplo" para
el tipo diasSemana no escribamos algo como esto2 diasSemana(7), diasSemana(-1),
Vladimir Rodrguez 1E1
diasSemana(1.5)$ ;omo )en" en el primer caso estamos y,ndonos un lugar fuera del enumerado" en el segundo
caso estamos pidiendo el elemento de una ubicaci#n negati)a la cual 'am&s existir& y en el tercer caso pasamos como
par&metro un real cuando solo se admiten enteros" dato este ltimo que no les (aba dic(o$
Read y Write con enumerados:
;omo primera cosa les digo que$$$ ?O E5 1O5K+E B.;ER RE.% =HO WRK-E con los enumerados$ Esto
significa que" declarada una )ariable de un tipo enumerado" no podemos incluir esta dentro de un procedimiento
RE.%" RE.%+?" WRK-E o WRK-E+?$ 1or e'emplo" para los enumerados anteriores" el siguiente fragmento de
c#digo estara mal2
Type
diasSemana=(domingo, lunes, martes, miercoles, jueves, viernes,
sabado);
mesAo= (enero, febrero, marzo, abril, mayo, junio, julio,
agosto, setiembre, octubre, noviembre, diciembre);
puntoCardinal= (norte, sur, oeste, este);
Var
dia: diasSemana;
mes: mesAo;
punto: puntoCardinal;
BEGIN
read(dia);
mes:= enero;
writeln(' ',enero);
punto:= sur;
writeln('El da ',dia,' de ',mes,' fuimos al ',punto,'.');
END.
5i (an entendido lo que (e (ablado de enumerados (asta a(ora podr&n darse cuenta r&pidamente de que los
errores en este c#digo est&n dados por el uso de )ariables de tipos enumerados en procedimientos RE.% y WRK-E$
+as asignaciones s son correctas$
?oten que para inicializar una )ariable de tipo enumerado con un )alor especfico lo (acemos como con
cualquier otra" o sea" damos el nombre de la )ariable seguido del smbolo de asignaci#n 2U y luego el )alor que le
queremos dar escrito tal cual lo nombramos nosotros al incluirlo en el enumerado$
Comparaciones con enumerados:
5egn el orden de enumeraci#n en que est&n dados los elementos de un enumerado tenemos los mismos
smbolos de comparaci#n que para los nmeros2
\ Denor que
\U Denor o igual que
U Kgual que
[U Dayor o igual que
[ Dayor que
\[ %istinto que
1or e'emplo" para el tipo puntoCardinal= (norte, sur, oeste, este) tenemos que
norte<sur ya que el primero est& en la posici#n E y el segundo en la posici#n 1$ +o mismo si la comparaci#n fuera
de diferencia2 norte<>sur$
5upongo que no debera decir que no es posible comparar )ariables de tipos enumerados diferentes ya que
seran )ariables de distintos tipos" o sea" para nuestro fragmento de c#digo anterior no sera posible comparar la
)ariable dia con la )ariable mes ya que son de tipos diferentes" una del tipo diasSemana y la otra del tipo
mesAo.
;omo debera resultar ob)io ya" los tipos enumerados son tipos ordinales" o sea" tienen una cantidad finita de
elementos y dado cualquiera de ellos es posible saber cu&l es el anterior y cual es el siguiente al mismo$ 1or lo tanto
para estos tipos de datos podemos utilizar las funciones predefinidas de 1ascal succ y pred" la primera para obtener
el sucesor de un elemento siempre y cuando no nos estemos refiriendo al ltimo" y la segunda para obtener el
predecesor de un elemento siempre y cuando no nos estemos refiriendo al primero$ Vol)iendo a e'emplificar con los
tres tipos enumerados definidos al inicio de esta secci#n tendramos lo siguiente2
succ(lunes)= martes
pred(noviembre)= octubre
succ(este) //No tiene sucesor, es el ltimo elemento.
pred(domingo) //No tiene predecesor, es el primero.
En la mayora de los e'emplos que (e dado aqu acerca de estas dos funciones" de las comparaciones y de la
utilizaci#n de ordinales para enumerados (e utilizado directamente los elementos del enumerado" o sea" si miran aqu
arriba (ay cosas como succ(lunes)= martes" cuando en general lo que se usa son )ariables del tipo
enumerado$ ;on esto quiero decir que si" por e'emplo tu)i,ramos una )ariable declarada como la siguiente
Var
dia: diasSemana;
BEGIN
dia:= lunes;
END.
podramos utilizar a dic(a )ariable dentro de las funciones de sucesor y predecesor as como tambi,n en
comparaciones y la funci#n OR%$ 1or e'emplo2
succ(dia)= martes;
pred(dia) //No tiene sucesor.
ord(dia)= 1 //Es el segundo elemento del enumerado.
dia<>martes //Es verdadero ya que la variable dia es igual a lunes.
ien" a(ora )eamos un peque!o e'emplo de programa en el cual tendremos un enumerado con los das de la
semana" otro con los meses del a!o y un subrango de enteros que ir& desde el nmero 1 al 31$ El usuario elegir& un
da de la semana" la fec(a correspondiente al mismo da y el mes" tras lo cual el programa desplegar& la fec(a en
formato %c.HDE5H.dO y en formato de oraci#n$ Ve&moslo2
1.PROGRAM enumerados;
2.
3.Type
4. diasSemana= (domingo, lunes, martes, miercoles, jueves, viernes, sabado);
5. diasMes= 1..31;
6. mesAnio= (enero, febrero, marzo, abril, mayo, junio, julio, agosto,
7. setiembre, octubre, noviembre, diciembre);
8.
9.Var
10. dia: diasSemana; //Guarda un da de la semana.
11. fecha: diasMes; //Guarda un da del mes.
12. mes: mesAnio; //Guarda un mes del ao
13. anio, aux: integer; //anio guarda el ao, aux es para leer enteros.
14.
15.BEGIN
16.{Pedimos al usuario que ingrese los datos----------------------------------}
17. //Pedimos el ingreso del ao en cuestin.
18. write('Ingresa el ao: ');
19. readln(anio);
20.
21. //Pedimos el ingreso del nmero del mes del ao.
22. write('Ingresa un nmero correspondiente a un mes del ao (1-12): ');
23. readln(aux);
24. mes:= mesAnio(aux - 1);
25.
26. //Pedimos el ingreso del nmero del da de la semana.
27. write('Ingresa un nmero correspondiente a un da de la semana (1-7): ');
28. readln(aux);
29. dia:= diasSemana(aux - 1);
30.
31. //Pedimos el ingreso del nmero de un da del mes.
32. write('Ingresa un nmero correspondiente a una fecha del mes (1-31): ');
33. readln(fecha);
34.
35. writeln;
36.
37.{Escribimos la fecha en formato DIA/MES/AO.-------------------------------}
38. //Escribimos la fecha en formato DD/MM/AAAA.
39. writeln('La fecha ingresada DIA/MES/AO es: ',fecha,'/',ord(mes+1,'/',
anio,'.');
40.
41.{Escribimos la fecha en formato de oracin---------------------------------}
42. //Primero escribimos el da.
43. Case dia of
44. domingo: write('Domingo ');
45. lunes: write('Lunes ');
46. martes: write('Martes ');
47. miercoles: write('Mircoles ');
48. jueves: write('Jueves ');
49. viernes: write('Viernes ');
50. sabado: write('Sbado ');
51. End;
52.
53. //Ahora escribimos la fecha del mes.
54. write(fecha,' de ');
55.
56. //Ahora escribimos el mes.
57. Case mes of
58. enero: write('Enero del ao ');
59. febrero: write('Febrero del ao ');
60. marzo: write('Marzo del ao ');
61. abril: write('Abril del ao ');
62. mayo: write('Mayo del ao ');
63. junio: write('Junio del ao ');
64. agosto: write('Agosto del ao ');
65. setiembre: write('Setiembre del ao ');
66. octubre: write('Octubre del ao ');
67. noviembre: write('Noviembre del ao ');
68. diciembre: write('Diciembre del ao ');
69. End;
70.
71. //Escrbimos el ao.
72. write(anio,'.');
73.END.
.nalicemos un poco este c#digo desde el comienzo de su bloque principal$ 1rimero pedimos al usuario que
ingrese un a!o y lo leemos como entero$ +uego en la lnea 22 le indicamos que ingrese un nmero entre 1 y 12 para
indicar un mes del a!o" y en la lnea siguiente le asignamos a la )ariable mes el elemento cuyo ordinal es igual al
)alor indicado por el usuario menos 1$ Esta resta se debe a que los meses del enumerado est&n numerados del E al 11
y el usuario ingresa nmeros del 1 al 12$ .plicamos el mismo procedimiento para inicializar la )ariable dia$ En
ambos casos usamos una )ariable auxiliar llamada aux para leer los enteros ingresados por el usuario$
;omo ltimo dato pedimos que se ingrese la fec(a del da" o sea" a qu, da del mes nos estamos refiriendo y
leemos este como un entero guard&ndolo en la )ariable fecha$
En la lnea 3P escribimos la fec(a en formato %%HDDH....$ ?oten que en el procedimiento WRK-E+? de
dic(a lnea" para escribir el nmero del mes al que nos referimos escribimos el ordinal de la )ariable mes )ol)i,ndole
a sumar 1$ Esto ya deberan entenderlo$
.(ora comienza lo interesante ya que utilizamos dos )eces la funci#n ;.5E$ En el ;.5E de la lnea 43
estamos diciendo2 5!i la #ariable da es igual al #alor domingo entonces escribe H2omingo H. sino. si es igual al
#alor lunes entonces escribe H;unes H....6$ Esta funci#n es equi)alente a una anidaci#n de KG como la que sigue2
If dia=domingo then
write('Domingo ')
else
if dia=lunes then
write('Lunes ')
else
if dia=martes then
write('Martes ')...
5i entendieron eso deberan ser capaces de entender el ;.5E de la lnea FL ya que funciona exactamente
igual$
;omo siempre les digo que ante cualquier duda o inquietud que tengan as como ante cualquier sugerencia
escrbanme a mstr)ladi3(otmail$com y les responder, a la bre)edad$
.(ora entret,nganse con algunos e'ercicios acerca de los enumerados$
Ejercicios
Ejercicio 1: ;onsideren la siguiente declaraci#n2
TYPE color = (rojo, blanco, azul, purpura);
VAR
coloracion : color;
%eterminen cu&les de los siguientes fragmentos de c#digo son )&lidos 'ustificando la respuesta2
a< Read (rojo);
WriteLn (rojo);
d< coloracion := blanco;
CASE coloracion OF
rojo : WriteLn ('rojo');
blanco : WriteLn ('blanco');
azul : WriteLn ('azul');
purpura: WriteLn ('purpura')
END;
b< Read (coloracion);
Write (coloracion);
e< coloracion := azul;
CASE coloracion OF
rojo : WriteLn (rojo);
blanco : WriteLn (blanco);
azul : WriteLn (azul);
purpura: WriteLn (purpura)
END;
c< coloracion := blanco;
WriteLn (coloracion);
f< IF coloracion = azul THEN
WriteLn ('azul')
ELSE
WriteLn ('no azul')
Ejercicio 2: %eterminen cuales de las siguientes declaraciones son )&lidas2
a< -=1E letra U :eNe" e=e" eae<M
b< -=1E lengua'e U :1ascal" Gortran" asic<M
c< -=1E materias U :matematicas" (istoria" computacion" biologia<M
carrera = (matematicas, computacion);
d)TYPE estado = (residente, ciudadano, extranjero);
nacionalidad = (americano, europeo, africano, asiatico, otra);
e< -=1E codigo U :1" 2" 3" 4" F<M
f< -=1E codigo U :c1" c2" c3" c4" cF<M
g<-=1E estado U :soltera" casada" comprometida" di)orciada<M
VAR type : estado;
(< -=1E ciudad U :1aysandu" 5anCose" -acuarembo" ;anelones<M
VAR ciudad : type;
i< V.R ciudad 2 :Ri)era" 5alto" 5oriano" Roc(a<M
'< 1RO;E%0RE encontrar :V.R ciudad 2 :Dinas" Glorida" Glores<<M
X< -=1E traba'o U :obrero" oficinista" indefinido<M
. . .
PROCEDURE buscar (VAR empleo : trabajo);
Vladimir Rodrguez 1EF
Ejercicio 3: Es posible definir subrangos de enumerados ya que estos ltimos corresponden a un tipo ordinal$
Examinen estas declaraciones2

TYPE tipodia = (Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo);
VAR dia : tipodia;
laborable : Lunes..Viernes;
finsemana : Sabado..Domingo;
Kndiquen cu&l de las siguientes afirmaciones es correcta2
5e producir& un error de e'ecuci#n si se asigna el )alor Dartes a ,indesemana
5e producir& un error de e'ecuci#n si se asigna el )alor Viernes a laborable$
Ejercicio 4: Examinen la siguiente definici#n 2

TYPE raro = (gugol, nudol, brudol, cudol, zudol, budol);
%eterminen el )alor de las siguientes expresiones2
1$ ord (gugol)
2$ ord (zudol)
3$ succ (brudol)
4$ succ (budol)
F$ pred (gugol)
J$ ord (succ (zudol))
Ejercicio 5:
Obtengan el )alor de las siguientes expresiones2
1$ ord ('7') - ord ('0')
2$ ord ('1') - ord ('1')
3$ chr (3 + ord ('0'))
4$ chr (0 + ord ('0'))
Ejercicio 6:: Examinen la siguiente declaraci#n2
TYPE vocal = (a, e, i, o, u);
VAR letra : vocal;
uncar : char;
%eterminen si se e'ecutar& sin error el siguiente c#digo en PASCAL2
letra := a;
WHILE letra <= u DO
BEGIN
Read (uncar);
WriteLn (Èl caracter capturado es ', uncar);
letra := succ (letra)
END
letra := u;
REPEAT
Read (uncar);
WriteLn (Èl caracter capturado es ', uncar);
letra := pred (letra)
UNTIL letra = a
Vladimir Rodrguez 1EJ
Registros:
+os tipos de datos que (emos )isto (asta a(ora (an podido ser primiti)os :c-ar. integer. real. boolean< o
estructurados :subrangos. arreglos. enumerados<$ +os tres tipos estructurados que )imos son (omog,neos" o sea" que
todos los datos que contienen son de un mismo tipo$ 1or e'emplo" en un arreglo todas las celdas contienen datos de un
mismo tipo" ya sean enteros" reales" u otro tipo definidos por ustedes mismos$ 0n subrango no es m&s que un
inter)alo m&s peque!o dentro de un con'unto de elementos mayor" pero sigue contiendo todos sus elementos de un
mismo tipo$ .qu es donde los registros se diferencian de todos los dem&s tipos ya que pueden contener muc(os datos
y todos de diferentes tipos$
1or e'emplo" podramos tener un registro que contenga caracteres" enteros" reales" cadenas" arreglos y muc(o
m&s$ 1ara ser un poco m&s especficos" podramos crear un registro que dada una persona contenga su nombre"
apellido" edad" documento de identidad" direcci#n entre muc(as otras cosas$
Declaracin:
ien" primero les dir, como se declara gen,ricamente un registro" luego )eremos un e'emplo de programa
donde guardaremos datos de dos personas" primero sin usar registros y luego us&ndolos$
Type
NombreDelRegistro= record
campo1: tipo;
campo2: tipo;
.
.
.
campoN: tipo;
End;
;omo estamos (ablando de un tipo resulta ob)io que declararemos un registro deba'o de la palabra -=1E$ .l
igual que a los dem&s tipos definidos por ustedes mismos debemos darle un nombre seguido del signo de igual y
luego utilizamos la palabra reser)ada RE;OR% :registro en ingl,s<$ %espu,s definimos cada uno de los campos que
contendr& tal como si fueran )ariables :en efecto eso son<" o sea" le damos un nombre seguido por dos puntos y luego
le asignamos un tipo cualquiera recordando que si usaremos uno definido por nosotros mismos debemos (aber
declarado este antes$
Veamos un e'emplo de declaraci#n de un registro llamado E5-0%K.?-E en el cual guardaremos el nombre
de un estudiante" su edad" su documento de identidad y el grado que cursa2
Type
Grados= (primero, segundo, tercero, cuarto, quinto, sexto);
Estudiante= record
nombre: string;
edad, documento: integer;
grado: Grados;
End;
;omo )en primero tenemos un tipo llamado >R.%O5 que no es m&s que un enumerado de los grados
posibles que un estudiante puede cursar$ ?uestro registro contiene cuatro campos :)ariables<" una del tipo string" dos
del tipo integer y una ltima del tipo grados" el cual fue declarado pre)iamente por nosotros mismos$
.(ora )eamos los dos e'emplos de los que (abl, para )er c#mo funcionan los registros$ En el siguiente
programa guardaremos el nombre" la edad" el documento de identidad y el grado de dos estudiantes distintos$ -odos
estos datos los asignaremos nosotros manualmente internamente en el programa" o sea" no (aremos RE.% de nada"
simplemente le daremos )alores a nuestras )ariables y ya" como si nuestros estudiantes )inieran precargados en el
programa2
1. PROGRAM Reg1;
2.
3. TYPE
4. Grados= (primero, segundo, tercero, cuarto, quinto, sexto);
5.
6. VAR
7. NombreEstudiante1, NombreEstudiante2: String;
8. EdadEstudiante1, EdadEstudiante2: Integer;
9. DocumentoEstudiante1, DocumentoEstudiante2: Integer;
Vladimir Rodrguez 1EL
10. GradoEstudiante1, GradoEstudiante2: Grados;
11.
12. BEGIN
13. NombreEstudiante1:= 'Fulano de Tal';
14. EdadEstudiante1:= 16;
15. DocumentoEstudiante1:= 12345;
16. GradoEstudiante1:= cuarto;
17.
18. NombreEstudiante2:= 'Mengano';
19. EdadEstudiante2:= 18;
20. DocumentoEstudiante2:= 16543;
21. GradoEstudiante2:= sexto;
22. END.
Duy bien" este programa no representa ningn tipo de dificultad para ustedes" simplemente declaramos
)ariables y las inicializamos con )alores adecuados a su tipo$ -al )ez debo aclarar por qu, en las lneas I y P declar,
cuatro )ariables integer cuando podra (aber usado una sola lnea$ 5implemente para separar las )ariables que se
corresponden con la edad a las que se corresponden con los documentos de identidad$ Este programa sera me'or si
obtu)iera los datos de la entrada est&ndar" sin embargo eso solo es utilizar RE.% en cada lnea y ya$ 0stedes mismos
pueden (acerlo si quieren$
.(ora )eamos el mismo programa pero usando un registro2
1. PROGRAM Reg1;
2.
3. TYPE
4. Grados= (primero, segundo, tercero, cuarto, quinto, sexto);
5.
6. Estudiante= RECORD
7. Nombre: String;
8. Edad, Documento: Integer;
9. Grado: Grados;
10. END;
11.
12. VAR
13. Est1, Est2: Estudiante;
14.
15. BEGIN
16. Est1.Nombre:= 'Fulano de Tal';
17. Est1.Edad:= 16;
18. Est1.Documento:= 12345;
19. Est1.Grado:= cuarto;
20.
21. Est2.Nombre:= 'Mengano';
22. Est2.Edad:= 18;
23. Est2.Documento:= 16543;
24. Est2.Grado:= sexto;
25. END.
ien$ ;omo )en" luego del tipo =rados (e declarado el tipo Estudiante que es un registro$ Es el mismo que
us, como primer e'emplo$ %ic(o registro tiene cuatro campos que funcionan tal cual las )ariables que ya conocen y
se declaran de la misma manera$ ;omo el registro es un tipo creado por nosotros mismos" debemos declarar )ariables
de ese tipo para poder usarlo$ Eso (ice en la lnea 13 de nuestro programa" declar, las )ariables Est' y EstD del tipo
Estudiante. ;ada una de estas )ariables contiene a las otras cuatro 6dentro7$ %e este modo tendremos una )ariable
Nombre" una Edad" una 2ocumento" y una =rados para Est' as como otras cuatro para EstD$
5i queremos acceder a la )ariable Nombre de Est' lo (acemos mediante la notaci#n Est'.Nombre$ .s con
todas las dem&s$ %e forma gen,rica" si tengo un registro gen,rico como el siguiente
MiRegistro= RECORD
Campo1: Tipo1;
Campo2: Tipo2;
. . .
CampoN: TipoN;
END;
y luego declaro una )ariable MiVariable: MiRegistro; " o sea" una )ariable llamada Mi%ariable del tipo
MiRegistro" para acceder al ampo' escribo Mi%ariable.ampo'" lo mismo si quiero acceder al ampoD$ O sea"
para acceder al campo nmero K" si K es un nmero entre 1 y ?" escribo Mi%ariable.ampo7$
Vladimir Rodrguez 1EI
+os campos de un registro son )ariables comunes y corrientes y por tanto todo lo que aplicamos a estas se
aplica a dic(os campos$
Una estructura compleja:
-eniendo los registros podemos crear estructuras muy comple'as$ 5implemente citar, un e'emplo para que les
quede ya que lo necesitar&n para traba'ar en lo que se )iene$
5upongan las siguiente declaraci#n
TYPE
Registro= Record
Nombre: String;
Documento: Integer;
Edad: Integer;
End;
ListaRegistro= Array[1..7] of Registro;
VAR
MiLista: ListaRegistro;
;omo pueden obser)ar simplemente (e declarado un registro de tres campos y luego un arreglo de siete
celdas donde cada una corresponde al registro$ 5i lo dibu'ara podramos tener algo as2
MiLista
Nombre
Documento
Edad
Nombre
Documento
Edad
Nombre
Documento
Edad
Nombre
Documento
Edad
Nombre
Documento
Edad
Nombre
Documento
Edad
Nombre
Documento
Edad
1 2 3 4 F J L
5i cada celda es un registro" entonces para acceder al campo ?ombre de la celda nmero 1 tendramos lo
siguiente2
MiLista[1].Nombre
Recuerden que cada celda de un arreglo es como una )ariable del tipo del arreglo" por lo tanto" cada celda de
este arreglo es del tipo Registro por lo cual funciona como tal$ Espero que este simple e'emplo les sir)a para
)isualizar esto$
.(ora les propongo un e'ercicio para comprender me'or lo b&sico de los registros para luego continuar con un
programa m&s comple'o2
Ejercicio 1: %eterminen cu&les de las siguientes definiciones de registro son )&lidas2
a<

TYPE estado = RECORD
nombre : ARRAY[1..30] OF CHAR;
edad : 0..120;
sexo : (Fem, Masc);
b<

TYPE ejemplo = RECORD
prueba : 0..100;
final : 'A'..'F';
orden : 1..100
END;
c<

TYPE franco = RECORD
prueba : 0..100;
examen : 0..10;
prueba : 0..100
END;
Vladimir Rodrguez 1EP
d<

TYPE califs = RECORD
nombre,
direccion : ARRAY[1..30] OF CHAR;
prueba,
examen : 0..100;
tipoest : (flojo, trabajador, puntual, impuntual)
END;
Ejercicio 2 ~Programa Complejo: En pos de comprender realmente lo que (emos aprendido (asta a(ora"
les propondr, ir traba'ando gradualmente en el programa que describir, a continuaci#n$ 5u dificultad no se comparar&
con la de Daster Dind" sin embargo ser& de gran utilidad traba'ar con ,l$ +o programaremos de forma sencilla" o
me'or dic(o" lo programar&n de forma sencilla para luego ir agregando cosas$ %e este modo )er&n" adem&s de lo que
refiere a los temas en s" lo complicado que puede resultar agregar cosas a un programa ya escrito$ 1or este moti)o y
por otros m&s" yo les ir, marcando ciertas estructuras que deber&n utilizar obligatoriamente m&s las que ustedes
mismos deseen agregar" de modo que todo sea bastante m&s legible que si se (ace a lo bruto$ Vamos a ello2
BASE DE PRODUCTOS - Parte 1
;omenzaremos a armar algo as como una base de datos de un comercio peque!o$ %ic(o comercio tiene a su
disposici#n elementos que nicamente pueden corresponderse con las siguientes categoras2 ;omestibles" Grutas y
Verduras" Bigiene del (ogar e Bigiene personal$ ;omo )en son solo cuatro$
.simismo" para cada elemento tenemos los siguientes datos que deseamos almacenar2
?ombre2 5implemente una palabra que identifique al producto$
K%2 0n nmero que es nico para cada producto y lo identifica entre los dem&s$
5tocX2 *u, cantidad de este producto tenemos a disposici#n$
1recio2 ;uanto )ale el producto$
;ategora2 . cual de las cuatro categoras anteriores corresponde el producto$
1ara comenzar supondremos que el comercio tiene nicamente cinco productos a la )enta" ni m&s ni menos" y
que no agregar& ni quitar& ninguno$ ?uestro programa almacenar& los datos de cada producto en un arreglo de cinco
celdas" una para cada producto" cada una de las cuales almacenar& todos los datos mencionados anteriormente$ +os
datos de cada producto ser&n ingresados mediante la entrada est&ndar por un usuario$ .sumiremos para todos los
casos que los datos ingresados son correctos" o sea que2 K% es un nmero entero positi)o y que no se repetir& para
ningn producto" que stocX es un entero positi)o o E" que precio es un real positi)o y que categora se corresponde
con alguna de las anteriores$
%e este modo tendremos las siguientes declaraciones obligatorias2
Const
N= 5;
Type
Categorias= (comestibles, frutas_verduras, higiene_h, higiene_p);
TNaturales= 1..MAXINT;
Elemento= Record
Nombre: String;
Stock: TNaturales;
Precio: Real;
Categoria: Categorias;
ID: TNaturales;
End;
Productos= Array[1..N] of Elemento;
.l iniciar nuestro programa debe mostrarnos un men como el siguiente2
DE?f 1RK?;K1.+2
1) Ingresar datos de productos.
2) Ver lista de productos.
3) Modificar productos.
4) Vender.
5) Buscar.
6) Salir.
Opcin:
1ara el Den 1rincipal usaremos un procedimiento cuya firma ser& la siguiente2
PROCEDURE MenuPrincipal(VAR listaProductos: Productos);
+uego entender&n me'or el funcionamiento de esto" ya que para cada men tendremos un procedimiento
distinto que ser& llamado por el procedimiento MenuPrincipal$ El nico par&metro all presente define a nuestra
lista de productos" o sea" nuestro arreglos de F celdas$
Veamos cada men por separado y su declaraci#n2
1< Ingresar datos de productos: Este men nos pedir& que ingresemos los datos de todos los productos
en nuestro arreglo :lista< sin importar si ya (aban datos o no" o sea" sobrescribiremos los datos
existentes$ .l seleccionar esta opci#n )eremos una pantalla como la siguiente2
|-----------Producto 1-----------|
ID >> 1
Nombre >> Azcar
Stock >> 10
Precio >> 50,5
Categoras: (1) Comestibles
(2) Frutas y verduras
(3) Higiene del hogar
(4) Higiene personal
Ingrese la opcin deseada >> 1
.ll pueden apreciar en negro lo escrito por el programa y en azul lo que ingresa el usuario$ ;ada opci#n
aparecer& a medida que ingresamos la anterior" o sea" una )ez ingresemos el )alor de K% y presionemos E?-ER"
)eremos la opci#n de ingreso de ?ombre$ .ll )en el orden en el que se ingresan los datos$ ;omo las categoras
fueron declaradas como un enumerado y estos no pueden leerse desde la entrada est&ndar" debemos dar una lista de
opciones a seleccionar por el usuario y luego en base a esta debemos asignar nosotros mismos el )alor de la categora$
5i continu&ramos ingresando datos tendramos algo como esto2
|-----------Producto 1-----------|
ID >> 1
Nombre >> Azcar
Stock >> 10
Precio >> 50,5
|-----------Producto 2-----------|
ID >> 2
Nombre >> Harina
Stock >> 10
Precio >> 42,5
|-----------Producto 3-----------|
ID >> 3
Nombre >> Desodorante
Stock >> 10
Precio >> 89,90
= podramos continuar as con los dos productos restantes$
1ara el ingreso de estos datos usaremos un procedimiento como el siguiente2
PROCEDURE IngresoProducto(VAR listaProductos: Productos; indice: integer);
%onde indice indicar& la posici#n en el arreglo listaProductos en la que debe agregarse el producto$
Este procedimiento lee directamente desde la entrada est&ndar por lo cual ser& ,l qui,n muestre las salidas que se )en
en los e'emplos$ -engan en cuenta que este procedimiento ingresa de a un producto en la lista en un lugar deterinado
de la misma$ +a opci#n 1 del men modifica toda la listaM ustedes deben implementar eso usando este procedimiento$
.l terminar de ingresar todos los datos )eremos el mensa'e Presione ENTER para #ol#er al men: principal...
2< Ver lista de Productos: Este men nos mostrar& en pantalla las siguientes opciones2
Ver lista de productos:
0) Ver todos
1) Comestibles
2) Frutas y verduras
3) Higiene del hogar
4) Higiene personal
9) Volver al Men Principal
Opcin >>
+a primera opci#n de este men nos desplegar& un listado con todos los elementos de la lista y las dem&s solo
aquellos que se correspondan con la categora seleccionada$ En todos los casos la salida ser& as2
Lista de elementos seleccionados (TODOS):
Azucar ID: 1
Harina ID: 2
Manzana ID: 3
Banana ID: 4
Fideos ID: 5
Presione ENTER para volver al Men Principal...
Lista de elementos seleccionados (FRUTAS y VERDURAS):
Manzana ID: 3
Banana ID: 4
+a opci#n P simplemente nos regresa al men anterior$ ?o deberan tener problemas con eso$
1ara esto deben utilizar un procedimiento como el siguiente2
Procedure MostrarListaProductos(listaProductos: Productos; opcion: char);
donde opcion le indicar& al procedimiento el criterio por el que tiene que mostrar los productos$
+, Modificar Productos: Esta opci#n del Den 1rincipal nos mostrar& las siguientes nue)e2
Modificar Productos:
1) Todos
2) Segn ID
3) Segn Nombre
4) Comestibles
7) Higiene personal
Opcin >>
1ara esto deber&n implementar un procedimiento con la siguiente firma2
PROCEDURE ModificarProductos(VAR listaProductos: Productos; opcion: char);
el cual funcionar& del mismo modo que MostrarListaProductos$ 0na )ez elegida la opci#n de criterio segn
el cual modificaremos los productos" el programa nos mostrar& los datos del primer producto a modificar y luego
deba'o nos pedir& que ingresemos los nue)os datos$ 5upongamos que seleccionamos la ocpi#n 12
Modificando productos (TODOS):
Nombre: Azucar
ID: 1
Stock: 15
Precio: 50,5
Categora: Comestibles
Ingrese los nuevos datos:
Nombre >> Azcar
ID >> 123
Stock >> 18
Precio >> 50,5
Categoras (1) Comestibles
(4)Higiene personal
Ocpion >> 1
+uego de lo cual pasaramos a modificar el siguiente producto" adecuado al criterio elegido en las siete
opciones disponibles$ 0na )ez terminados todos los productos adecuados se nos mostrar& el siguiente mensa'e
Ha terminado de modificar los productos (TODOS).
1ara mostrar los datos de un producto en pantalla deben implementar un procedimiento como el siguiente2
PROCEDURE MostrarDatosProducto(listaProductos: Productos; indice: integer);
donde indice indicar& el lugar en la lista donde se encuentra nuestro producto$ 5i se le pasa indice como )alor
igual a E entonces el procedimiento mostrar& el mensa'e2 No e+isten datos para mostrar$ ;ualquier otro )alor debe
ser una posici#n existente en nuestro arreglo de elementos$
.simismo" para buscar un producto y obtener su ndice utilizar&n las siguientes funciones segn el criterio de
bsqueda :K%" ?ombre o ;ategoras<2
FUNCTION BuscarPorID(listaProductos: Productos; ID: integer): integer;
FUNCTION BuscarPorNombre(listaProductos: Productos; nombre: string): integer;
FUNCTION BuscarPorCategoria(listaProductos: Productos; categoria: categorias):
integer;
donde cualquiera de estas funciones retornar& como )alor entero el ndice del primer elemento de la lista que cumpla
con la condici#n de bsqueda$ 1or e'emplo" si buscamos segn la categora ;omestibles" se nos retornar& la posici#n
del primer comestible en la lista listaProductos ignorando a todos los dem&s$ %e este modo deber&n
ingeni&rselas para ir obteniendo todos los productos necesarios por medio de esta funci#n$ Estas funciones deben
declararse antes que el procedimiento MostrarDatosProducto" de lo contrario no podr&n llamarlas dentro del
mismo$ Otra opci#n sera declararlas de forma interna al procedimiento" pero esto limitara su uso solo a dic(o
procedimiento$
1ara cualquiera de estas tres funciones" si no encuentran el producto buscado entonces retornaran el )alor E$
;uando se quiere modificar un producto segn su K%" como dic(o producto ser& nico" se pedir& al usuario
que ingrese un K% para buscar el producto" luego se mostrar&n sus datos para modificarlo posteriormente2
Modificando productos (ID):
Ingrese el ID del producto a modificar: 1
Nombre: Azucar
ID: 1
Stock: 15
Precio: 50,5
Nombre >> Azcar
ID >> 123
Stock >> 18
Precio >> 50,5
(4)Higiene personal
Ocpion >> 1
Ha terminado de modificar el producto con ID original 1.
Presione ENTER para regresar al Men Principal...
1ara modificar productos segn su ?ombre se aplicar& la misma l#gica que para modificarlos segn su
categora$ -anto nombre como categora no son datos nicos" solo el K% es nico para cada elemento" todos los dem&s
datos se pueden repetir$ %e este modo deben ir buscando a lo largo de toda la lista de productos e ir modificando
aquellos que resulten adecuados al criterio de modificaci#n$ 1ara todos los casos asumimos que se ingresan datos
correctos$ Veamos algn e'emplo m&s2
Modificando productos (NOMBRE):
Ingrese el nombre de los productos a modificar: Azucar
Nombre: Azucar
ID: 1
Stock: 15
Precio: 50,5
Nombre >> Azcar
ID >> 123
Stock >> 18
Precio >> 50,5
(4)Higiene personal
Ocpion >> 1
No existen ms elementos con el nombre Azucar.
Ha terminado de modificar los elementos con el nombre original Azucar.
Modificando productos (COMESTIBLES):
Nombre: Azucar
ID: 1
Stock: 15
Precio: 50,5
Nombre >> Azcar
ID >> 123
Stock >> 18
Precio >> 50,5
(4)Higiene personal
Ocpion >> 1
Nombre >> Harina
ID >> 2
Stock >> 10
Precio >> 42,5
Nombre >> Harina de miz
ID >> 17
Stock >> 16
Precio >> 40,5
(4)Higiene personal
Ocpion >> 1
No existen ms elementos con la categora Comestibles.
Ha terminado de modificar los elementos con la categora original Comestibles.
+a opci#n P simplemente nos mostrar& el mensa'e Presione ENTER para volver al Men
Principal...
4) Vender: Esta opci#n nos pedir& el K% del producto que deseamos )ender" nos mostrar& sus datos
luego" para pedirnos el 5tocX que deseamos )ender" modificando esa cantidad en los datos del producto$ Veremos el
equi)alente en dinero a la )enta realizada para luego )er el mensa'e de regreso al men principal$ Veamos un
e'emplo2
Ingrese el ID del producto que desea vender: 1
Datos del producto:
Nombre: Azucar
ID: 1
Stock: 15
Precio: 50,5
Ingrese la cantidad que desea vender: 10
Dinero obtenido: 505,00
5) Buscar: .qu se nos desplegar&n las siguientes opciones2
Buscar productos:
1) Segn ID
2) Segn Nombre
Opcin >>
+a primera opci#n nos pedir& el K% del producto que deseamos buscar y luego nos mostrar& sus datos en
pantalla$ +a segunda opci#n (ar& lo mismo pero mediante el nombre$ 5i el nombre se repite en m&s de un producto se
nos desplegar&n los datos de todos ellos en el orden en el que fueron ingresados o modificados$ Veamos e'emplos2
Buscando segn ID:
Ingrese el ID del producto que desea buscar: 2
Nombre : Harina
ID: 2
Stock: 10
Precio: 42,5
Buscando segn NOMBRE:
Ingrese el nombre del/los producto/s: Manzana
Nombre: Manzana
ID: 3
Stock: 10
Precio: 30,00
Categora: Frutas y Verduras
Fin de la lista.
Buscando segn NOMBRE:
Ingrese el nombre del/los producto/s: Banana
Nombre: Banana
ID: 4
Stock: 10
Precio: 37,50
Categora: Frutas y Verduras
Nombre: Banana
ID: 24
Stock: 8
Precio: 42,5
Fin de la lista.
5i no (ay elementos que mostrar simplemente )eremos el mensa'e /in de la lista para luego )er el cl&sico
Presione ENTER para #ol#er al Men: Principal...
6) Salir: Esta opci#n simplemente terminar& con la e'ecuci#n del programa" siendo la nica forma de
(acerlo$ 1ara esto usar&n la funci#n exit de pascal$
Limpiar la pantalla: 1ara este e'ercicio puede resultar muy con)eniente el (ec(o de borrar el contenido de la
pantalla para mostrar uno nue)o y no que lo anterior se desplace (acia arriba$ 1or e'emplo" para mostrar los distintos
mens" quedara muc(o m&s proli'o que se borre todo lo que (ay en pantalla para mostrar el nue)o men en limpio" y
no que este aparezca deba'o de un mont#n de datos anteriores$
1ara lograr esto utilizaremos una librera de pascal$ Esto no se corresponde con el cometido de este manual
por lo que solo explicar, c#mo limpiar la pantalla$ El uso de libreras lo )eremos m&s adelante" en un segundo manual
donde abordaremos la programaci#n orientada a ob'etos" si no mane'an bien todos los conceptos que (ay aqu pues
simplemente no tiene sentido seguir con cosas m&s comple'as$
8*u, es una librera9 &sicamente es una unidad de programa que consta de funciones y procedimientos que
alguien program# y puso a nuestra disposici#n para que podamos utilizarlas$ Esto no lo entender&n muy bien a(ora y
no tiene demasiado sentido que me extienda" solo qu,dense con la idea de que nosotros podemos especificar qu,
librera queremos usar para luego poder in)ocar a sus funciones y procedimientos$ ;laro est& que debemos conocer
qu, par&metro de entrada necesita cada subprograma y qu, nos de)ol)er& en caso de ser una funci#n$
Existe una librera incluida en Gree 1ascal llamada CRT$ Esta librera nos pro)ee de funciones para el control
de la pantalla y el teclado$ %e todas ellas solo nos interesa una" ClrScr" lo cual es una abre)iaci#n de ;lear 5creen"
que significa +impiar 1antalla$
1ara indicar las libreras que )amos a usar debemos escribir la palabra reser)ada 05E5 luego de la
declaraci#n del identificador de nuestro programa$ +uego de 05E5 escribimos los nombres de nuestras libreras y ya"
podemos comos llamar a sus funciones y procedimientos sin problema$ Veamos un simple e'emplo de la limpieza de
la pantalla2
1 PROGRAM LimpiaPantalla;
2
3 USES crt;
4
5 VAR
6 i, j: integer;
7
8 BEGIN
9 For i:=1 to 20 do
10 begin
11 For j:=1 to 20 do
12 write('#');
13 writeln;
14 end;
15 writeln;
16 write('Presione ENTER para limpiar la pantalla...');
17 readln;
18 clrscr;
19 write('Ha borrado la pantalla. Presione ENTER para cerrar...');
20 readln;
21 END.
Este programa lo nico que (ace es dibu'ar un cuadro de 2Ex2E utilizando el car&cter g" luego borra el dibu'o
y muestra un nue)o mensa'e$ +a funci#n clrscr puede ser llamada cada )ez que queramos$
Basta aqu )a esta parte del programa$ En s no cambiaremos muc(o su funcionamiento" sino que
utilizaremos nue)as (erramientas para optimizarlo" pero esto lo )eremos a continuaci#n$ 5i necesitan que corri'a sus
programas" sus c#digos fuente" si tienen dudas" si quieren mis propios c#digos fuente del programa completo o de
alguno de los procedimientos o funciones que les propongo implementar" si necesitan un e'ecutable de e'emplo para
)er todo esto en funcionamiento simplemente escrbanme a mstr)ladi3(otmail$com solicit&ndome lo que les (aga
falta y les responder, a la bre)edad$ Duc(a suerte$ Kntenten (acer este programa antes de continuar" ya que me basar,
en esto para aplicar muc(os de los conceptos que an nos faltan por )er$
La funcin WITH... DO:
Esta funci#n es solo para aplicarse con registros y su utilidad radica casi nicamente en (acernos escribir
muc(o menos ya que nos facilita el acceso a las )ariables de un registro$ Veamos un simple e'emplo de su
funcionamiento$ 1rimero escribir, un simple programa que dado un registro asignar& )alores a sus )ariables2
1 PROGRAM PrimeroSinWith;
2
3 TYPE
4 Grados= (primero, segundo, tercero, cuarto, quinto, sexto);
5
6 Estudiante= RECORD
7 Nombre: String;
8 Edad, Documento: Integer;
9 Grado: Grados;
10 END;
11 VAR
12 Alumno: Estudiante;
13
14 BEGIN
15 Alumno.Nombre:= 'Vladimir';
16 Alumno.Edad:= 18;
17 Alumno.Documento:= 12345
18 Alumno.Grado:= sexto;
19 END.
.(ora )eamos el mismo programa pero utilizando WK-B$$$ %O2
1 PROGRAM AhoraConWith;
2
3 TYPE
5
7 Nombre: String;
9 Grado: Grados;
10 END;
11 VAR
13
14 BEGIN
15 With Alumno do
16 begin
17 Nombre:= 'Vladimir';
18 Edad:= 18;
19 Documento:= 12345
20 Grado:= sexto;
22 end;
23 END.
;omo )en" su nico cometido es e)itarnos tener que escribir constantemente el nombre de nuestra )ariable
del tipo registro seguido de un punto para luego especificar la )ariable del registro a la que queremos acceder$
0tilizando WK-B$$$ %O simplemente escribimos el nombre de nuestra )ariable del tipo registro una nica )ez y luego
nos dirigimos a las )ariables internas directamente$ ;laro est& que esto funciona solo dentro de los lmites del E>K?
y el E?% correspondientes a la funci#n WK-B" o sea" en nuestro programa accedemos directamente a las )ariables de
Alumno solo dentro de las lneas 1J y 22 que corresponden al bloque de WK-B$
%el mismo que en estos e'emplos utilizamos los campos del registro para asignarles )alores" podemos
utilizarlos dentro de un WK-B para (acer cualquier cosa de las que ya conocemos$
Ambigedad con WITH... DO:
Esto solo ser& un simple e'emplo para que conozcan el tipo de confusiones que se puede tener si no se usa la
funci#n WK-B con cuidado2
1 PROGRAM EjemploAmbiguo;
2
3 TYPE
5
7 Nombre: String;
9 Grado: Grados;
10 END;
11 VAR
13 Grado: integer; //Prestar atencin a esta variable.
14
15 BEGIN
16 With Alumno do
17 begin
18 Nombre:= 'Vladimir';
19 Edad:= 18;
20 Documento:= 12345
21 Grado:= 10; //Error, Grado aqu representa a Alumno.Grado
22 Grado:= sexto; //Esto s es correcto.
23 end;
24 END.
;omo )en" solo con)iene utilizar WK-B cuando necesitamos traba'ar nicamente con todos los datos del
registro sin in)olucrar otros$ ;laro est& que si no los identificadores no se repiten no (ay problema$ +o que sucede en
este programa es que el registro tiene un campo llamado Grado y a su )ez (e declarado una )ariable global llamada
Grado$ Esto es totalmente posible ya que en realidad no estoy repitiendo identificadores" la )ariable del registro en
realidad se llama Alumno.Grado y mi )ariable global solo Grado$ 5in embargo" dentro de WK-B tendremos el
problema que se )e en el e'emplo de la lnea 21" ya que intentamos asignar el )alor 1E a nuestra )ariable global" pero
para el compilador all nos estamos refiriendo a la )ariable Alumno.Grado que es de tipo Grados y no puede
asumir )alores enteros$
Registro con variante
Esto no es en s un nue)o tema" sino una aplicaci#n pr&ctica para lo que ya conocemos$ 0n registro con
)ariante suele utilizarse para representar una entidad que puede pertenecer a diferentes categoras que tienen
diferentes datos pero que a su )ez existen datos comunes a todas las categoras$ ;omo para m no existe me'or
explicaci#n que un e'emplo" )amos a ello2
5upongamos que dada una persona de nuestra empresa puede ser Encargado o Pen" si es encargado entonces
le asignamos un grado que puede ser 0ajo" Medio o "lto" y si es pe#n le asignamos un rango que puede ser No#ato o
Prctico$ .simismo un pe#n puede tener una carga (oraria de entre 4E y 4I (oras semanalesM para un encargado no se
especifica$ 1ara cualquier caso guardamos adem&s el nombre y el documento del funcionario$ ;omo pueden )er los
datos )ariar&n segn el tipo de funcionario :categora< pero a su )ez tenemos datos comunes a todos" que son el
documento y el nombre$ Veamos la estructura del registro2
TYPE
Categorias= (encargado, peon);
Funcionario= Record
Nombre: String;
Documento: Integer;
Case categoria: Categorias of
encargado: (grado: (Bajo, Medio, Alto));
peon: (rango:(Novato, Practico); cargaHoraria: 40..48);
End;
Explicar, un poco esto2 El registro Funcionario funciona igual que todos los dem&s )istos (asta a(ora$
-enemos la )ariable Nombre del tipo !tring" la )ariable Documento del tipo 7nteger y luego la )ariable
categoria del tipo ategorias$ ;omo pueden )er esta )ariable se declara y se define en el encabezado de un
;.5E$$$ OG" cosa que (asta a(ora no (abamos )isto y solo utilizaremos esta forma de declarar un ;.5E para los
registros con )ariante$ %ependiendo del )alor que tome esta )ariable definiremos las siguientes2
5i categoria toma el )alor encargado entonces definimos la )ariable grado como un
enumerado que corresponde a los grados de un encargadoM si toma el )alor peon entonces nos definimos
la )ariable rango como otro enumerado con los rangos de un pe#n y su )ez definimos la )ariable
cargaHoraria como un subrango de enteros que )a de 4E a 4I inclusi)e$ ;omo en este caso
definimos dos )ariables diferentes las separamos por punto y coma$ -odas las )ariables declaradas para
cada caso )an entre par,ntesis$ +as )ariables de un mismo tipo pueden declararse todas 'untas
separ&ndolas por coma$ Esto funciona como en los encabezados de un procedimiento o una funci#n$
. pesar de darle esta forma" el registro funciona como si estu)iera declarado de esta manera2
Funcionario= Record
Nombre: String;
Documento: Integer;
categoria: Categorias;
grado: (Bajo, Medio, Alto);
rango:(Novato, Practico);
cargaHoraria: 40..48);
End;
5in embargo" darle una aplicaci#n correcta a la estructura anterior (ace que un c#digo sea muc(o m&s legible"
corto" entendible y no )an a creer cuantos errores de programaci#n nos a(orramos$ .dem&s" la estructura del registro
con )ariante nos da una )isi#n muc(o m&s clara de la informaci#n que estamos mane'ando y de c#mo utilizarla$
El acceso a las )ariables :campos< del registro sigue siendo como siempre a pesar de que su declaraci#n (a
cambiado" por eso mismo les (e aclarado que el registro con )ariante funciona como si fuera este ltimo que )en
aqu" sin embargo en este ltimo no es posible )isualizar qu, tipo de informaci#n corresponde a los distintos casos
8me comprenden9 En el primero se )e claramente que si el funcionario es encargado debemos asignarle un grado" y si
es pe#n le asignamos un rango y una carga (oraria$ %eclarando el registro como uno normal da la impresi#n de que
todos esos datos ir&n para todos los funcionarios" o sea" todos tienen una categora" un grado" un rango y una carga
(oraria" pero en realidad no es as$
Veamos entonces un simple programa en el que tenemos un arreglo de tres celdas el cual contendr& los datos
de los empelados en cada una de ellas" o sea" tenemos tres personas$ +os datos ser&n ledos de la entrada est&ndar y
asumiremos que son correctos siempre$ 0tilizar, la estructura del GOR para esto ya que ingresaremos tres
funcionarios s o s" no me interesa nada m&s2
1. PROGRAM RegistroVariante;
2.
3. CONST
4. N= 3;
5.
6. TYPE
7. Categorias= (encargado, peon);
8.
9. Funcionario= Record
10. Nombre: String;
11. Documento: Integer;
12. Case categoria: Categorias of
13. encargado: (grado: (Bajo, Medio, Alto));
14. peon: (rango:(Novato, Practico); cargaHoraria: 40..48);
15. End;
16.
17. Personal= Array[1..N] of Funcionario;
18.
19. VAR
20. MisFuncionarios: Personal;
21. i: integer;
22. opcion: char;
23.
24. BEGIN
25. For i:=1 to N do
26. begin
27. writeln('Funcionario nmero ',i,':');
28. writeln;
29. write('Nombre: ');
30. readln(MisFuncionarios[i].Nombre);
31. write('Documento: ');
32. readln(MisFuncionarios[i].Documento);
33. writeln('Seleccione una categora: (1) Encargado');
34. writeln(' (2) Pen');
35. write('Opcin: ');
36. readln(opcion);
37.
38. Case opcion of
39. '1': begin
40. writeln;
41. writeln('Seleccione un grado para el encargado: (B)
Bajo');
42. writeln(' (M)
Medio');
43. writeln(' (A)
Alto');
45. readln(opcion);
46.
47. Case opcion of
48. 'b', 'B': MisFuncionarios[i].grado:= Bajo;
49. 'm', 'M': MisFuncionarios[i].grado:= Medio;
50. 'a', 'A': MisFuncionarios[i].grado:= Alto;
51. End;
52. end;
53. '2': begin
54. writeln;
55. writeln('Seleccione un rango para el pen: (N)
Novato');
56. writeln(' (P)
Prctico');
58. readln(opcion);
59.
60. Case opcion of
61. 'n', 'N': MisFuncionarios[i].rango:= Novato;
62. 'p', 'P': MisFuncionarios[i].rango:= Practico;
63. End;
64.
65. writeln;
66. write('Ingrese la carga horaria semanal del pen (40 a
48 hs): ');
67. readln(MisFuncionarios[i].cargaHoraria);
68. end;
69. End;
70.
71. writeln;
72. end;
73. END.
Explicar, un poco este programa" aunque no debera darles problemas ya que en s no es nada comple'o" solo
leemos y asignamos datos" nada m&s$ En la lnea 1L declaramos el tipo Personal que no es m&s que un arreglo del
tipo Funcionario" o sea" un arreglo donde cada celda representa a un registro$ En la lnea 2E declaro una )ariable
del tipo Personal" o sea" creo mi arreglo para traba'arM luego declaro la tpica )ariable i del tipo integer para
iterar en las celdas del arreglo$ Ginalmente declaramos la )ariable opcion del tipo c-ar" esta la usaremos para
asignar )alores a los tipos enumerados ya que estos no pueden leerse de la entrada est&ndar$
El bloque principal de nuestro programa es un enorme GOR que iterar& desde 1 a ? en nuestro arreglo" o sea
en todas sus celdas$ ;omo ? )ale 3" nuestro GOR iterar& 3 )eces con lo cual terminar& nuestro programa$ En la lnea
3E leemos directamente el campo Nombre de la celda i de nuestro arregloM (acemos lo mismo en la lnea 32 para el
campo Documento$ +uego desplegamos en pantalla las opciones para la categora de nuestro funcionario i" las
cuales las leeremos como caracteres en la )ariable opcion$ %ependiendo e la opci#n elegida por el usuario ser& la
informaci#n que pediremos$ 5i se ingresa un 1 entonces pediremos los datos para un encargado y se ingresa un 2
pediremos los datos para un pe#n$ Esto lo )en con el CASE opcion OF que inicia en la lnea 3I y cierra en la lnea
JP$ El funcionamiento de esta estructura no debera darles problemas$ +o que cabe destacar aqu es que" por e'emplo"
si la opci#n elegida es la 1" o sea" si estamos ingresando los datos de un encargado" solo usaremos las )ariables que
guardan la informaci#n pertinente a esa categora y no tocamos las dem&s porque no nos interesan$ +o que quiero
decir es que" por e'emplo" para un encargado no tocamos en ningn momento las )ariables rango o
cargaHoraria porque no nos interesan y no traba'aremos con ellas en un posterior tratamiento de la informaci#n$
Es un error asignar )alores a campos que no se corresponden con la informaci#n que estamos tratando" o sea"
si )amos a traba'ar con un pe#n entonces nos aseguramos de ello y luego asignamos los )alores solo y nicamente a
las )ariables que son pertinentes a la categora de pe#n$ 1odramos" si queremos" asignar un )alor de grado a pesar
de estar traba'ando con la categora pe#n" el compilador lo permitir& tranquilamente y no (abr& ningn tipo de error
en el programa en s" pero est& mal porque un pe#n no tiene grado sino rango y no nos importa los )alores que
grado pueda tomar en este caso$
Arreglo con tope:
Esta no es una nue)a estructura sino una nue)a implementaci#n de una estructura conocida" los arreglos$ .
estas alturas deberan ser capaces de traba'ar perfectamente con ellos$ ;omo bien saben" los arreglos se definen de un
tama!o fi'o y este no puede )ariar a lo largo del programa ya que es asignado en tiempo de compilaci#n$ .(ora bien"
imaginen que necesitamos almacenar datos pero que a priori no sabemos cuantos" por e'emplo" imaginen que en el
programa del supermercado no sabemos cuantos productos tendremos que ingresar" puede ser uno o pueden ser
treinta 8c#mo (acemos9
En principio utilizaremos los arreglos" luego )eremos c#mo se (ace esto realmente utilizando memoria
din&mica" nuestro ltimo tema$ ien" )amos a los arreglos con tope" la idea es la siguiente2 De asigno un nmero
m&ximo de ob'etos a almacenar" lo cual definir& la dimensi#n del arregloM luego )oy registrando cu&ntos elementos
almaceno en el mismo y ser& (asta ese punto donde na)egar, en el arreglo" no me interesar& el resto$ 1or e'emplo" si
nos definimos un arreglo de FE celdas del tipo car&cter" el cual usaremos para guardar palabras que pueden tener entre
una y cincuenta letras" al guardar una palabra de diez letras solo nos interesa recorrer las primeras diez celdas del
arreglo" las otras cuarenta no ser&n necesarias$ En este caso mi tope ser& el nmero 1E y lo implementar, como si se
tratase del final de mi arreglo$
Veamos un e'emplo de esto en un c#digo de un simple programa que espera recibir de la entrada un c#digo
num,rico de tama!o )ariable con un m&ximo de 2E caracteres$ +a idea es )erificar que efecti)amente el c#digo sea
num,rico$ ?o podemos leer la entrada est&ndar como un entero porque si el usuario pone otra cosa que no sean
nmeros el programa dar& un error en tiempo de e'ecuci#n" nada recomendable$ +o mismo sucede con el tipo real$ 5i
leemos la entrada como string no tendremos problemas en e'ecuci#n" sin embargo 8c#mo )erificamos que la cadena
ingresada sea 'ustamente num,rica9
1. PROGRAM ArrayConTope;
2.
3. CONST
4. MaxCaracteres= 20;
5.
6. TYPE
7. Codigo= Array[1..MaxCaracteres] of char;
8.
9. VAR
10. MiCodigo: Codigo;
11. Tope, i: integer;
12. error: boolean;
13.
14.
15. BEGIN
16. Tope:= 0; //Representa un cdigo (palabra) nulo ya que no existe celda
de ndice 0.
17. write('Ingrese un cdigo numrico: '); //Mensaje para el usuario.
18.
19. //Leemos hasta el fin de lnea o hasta llegar al mximo permitido.
20. //Notar que leemos directamente sobre la celda del arreglo.
21. Repeat
22. Tope:= Tope + 1;
23. read(MiCodigo[Tope]);
24. Until (eoln) or (Tope=MaxCaracteres);
25.
26. readln; //Consumimos el fin de lnea.
27.
28. //Iteramos por nuestro arreglo hasta que exista un caracter no numrico
29. //o hasta llegar al tope sin haber encontrado error.
30. i:=0;
31. Repeat
32. i:= i + 1;
33. error:= (ord(MiCodigo[i])<ord('0')) or (ord(MiCodigo[i])>ord('9'));
34. Until (error) or (i=Tope);
35.
36. If error then
37. writeln('Error en cdigo, no es numrico.')
38. else
39. writeln('Cdigo correcto.');
40. END.
1odramos decir que el programa anterior no est& mal ya que aplica la estructura del arreglo con tope
correctamente" sin embargo no es la implementaci#n m&s adecuada :esto depender& del punto de )ista de los
programadores<$ %ado que el arreglo con tope en realidad est& representando un con'unto" el cual puede ser )aco
cuando el tope )ale E o puede contener elementos )ariables a lo largo del programa" la implementaci#n correcta es
aquella que lo )isualiza como una nica entidad$ %e este modo" la forma correcta de aplicar el programa anterior es la
siguiente2
1. PROGRAM ArrayConTope;
2.
3. CONST
4. MaxCaracteres= 20;
5.
6. TYPE
7. ConjuntoCodigo= Record
8. Codigo: Array[1..MaxCaracteres] of char;
9. Tope: 0..MaxCaracteres;
10. End;
11.
12. VAR
13. MiCodigo: ConjuntoCodigo;
14. i: integer;
15. error: boolean;
16.
17.
18. BEGIN
19. MiCodigo.Tope:= 0; //Representa un cdigo (palabra) nulo ya que no
existe celda de ndice 0.
20. write('Ingrese un cdigo numrico: '); //Mensaje para el usuario.
21.
22. //Leemos hasta el fin de lnea o hasta llegar al mximo permitido.
23. //Notar que leemos directamente sobre la celda del arreglo.
24. Repeat
25. MiCodigo.Tope:= MiCodigo.Tope + 1;
26. read(MiCodigo.Codigo[MiCodigo.Tope]);
27. Until (eoln) or (MiCodigo.Tope=MaxCaracteres);
28.
29. readln; //Consumimos el fin de lnea.
30.
31. //Iteramos por nuestro arreglo hasta que exista un caracter no
numrico
32. //o hasta llegar al tope sin haber encontrado error.
33. i:=0;
34. Repeat
35. i:= i + 1;
36. error:= (ord(MiCodigo.Codigo[i])<ord('0')) or
(ord(MiCodigo.Codigo[i])>ord('9'));
37. Until (error) or (i=MiCodigo.Tope);
38.
39. If error then
40. writeln('Error en cdigo, no es numrico.')
41. else
42. writeln('Cdigo correcto.');
43. END.
Ejercicio 0: Dodifiquen este programa para utilizarlo con WK-B$$$%O$
. continuaci#n les expongo )arios e'ercicios" todos dise!ados por docentes de Gacultad de Kngeniera$ -odos
los e'ercicios pueden y deben ser resueltos con lo )isto (asta el momento$ +a informaci#n que yo les (e dado en este
manual resulta incluso muc(o m&s completa que la que dan los profesores en las clases ya que ellos apuntan a que los
estudiantes in)estiguen lo que no conocen y se las arreglen solos en muc(os casos" usando clases de consulta como
apoyo a las dudas$ 0stedes pueden escribirme a mi correo electr#nico mstr)ladi3(otmail$com para consultar todas
las dudas$ Duc(os e'ercicios son de gran dificultad" identificar, las dificultades de cada e'ercicio con colores2 Verde
:dificultad ba'a<" .marillo :%ificultad Dedia<" ?aran'a :%ificultad Dedia .lta<" Ro'o :%ificultad .lta<$
.lgunos e'ercicios apuntan" adem&s de a la programaci#n en s" al uso de conocimientos matem&ticos que no
se imparten aqu" por lo cual simplemente aclarar, para esos casos que se requiere el conocimiento matem&tico y
ustedes decidir&n si lo tienen o no para realizar el e'ercicio$ Guera de todos aquellos que requieren matem&tica" usedes
deben ser capaces de resol)er todos estos e'ercicios$ Recuerden que la me'or (erramienta para la programaci#n es la
pr&ctica$ 5i no se ponen con estas cosas no llegar&n a nada" y tratar de a)anzar para )er que )iene pero de'ando cosas
en el camino no ser)ir& de nada$ RRR.delanteSSS
Ejercicio 1: Examinen la siguiente declaraci#n 2

CONST
CANT_PERS = 100;
MAX_CADENA = 30;
TYPE
Cadena = RECORD
letras : ARRAY[1..MAX_CADENA] OF CHAR;
largo : 0..MAX_CADENA;
END;
Persona = RECORD
nombre : Cadena;
edad : 0..120;
estado : (casado, soltero, divorciado);
salario : REAL;
exenciones : 0..MAXINT;
END;
VAR
juanita : Persona;
grupo : ARRAY[1..CANT_PERS] OF Persona;
%eterminen cu&les de las siguientes proposiciones son )&lidas2
a)

grupo [1] := juanita;
b)

grupo [1].nombre := 'juanita';
c)

Read (grupo [1].estado);
d)

WITH grupo DO writeln (nombre);
e)

WITH grupo [100] DO
BEGIN
Read (edad);
END;
f)

WITH juanita DO
BEGIN
nombre := grupo [50].nombre;
salario := grupo [1].salario
END;
Ejercicio 2: 5upongan que una sociedad geneal#gica tiene un arreglo de registros que indican la fec(a de
nacimiento y subndice en el arreglo de los registros de los padres y madres de )arias personas$ El arreglo de registros
y las )ariables correspondientes podran ser parecidos a ,stos 2
CONST
MAXPERSONAS = 1000;
MAXCAD = 20;
TYPE
Cadena = RECORD
letras : Array[1..MAXCAD] Of Char;
largo : 0..MAXCAD;
END;
UnaPersona = RECORD
nombre : Cadena;
FechNac : RECORD (* Fecha de nacimiento *)
mes : 1..12;
dia : 1..31;
anio : 0..MAXINT
END;
IndMadre, IndPadre : 0..MAXPERSONAS;
END;
Familia = RECORD
pers : ARRAY[1..MAXPERSONAS] OF UnaPersona;
tope : 0..MAXPERSONAS;
END;
VAR
historia : Familia;
usted : Cadena;
+os campos IndMadre e IndPadre contienen el subndice en el arreglo (istoria de los registros de la madre
y el padre$ Este )alor ser& cero si no se dispone de la informaci#n correspondiente$ 5upongan que la )ariable
usted contiene el nombre de una personaM ex(iban entonces los nombres y fec(as de nacimiento de los padres
y los cuatro abuelos de esa persona :si es que se contienen la informaci#n<$
Ejercicio 3: Escriba una funci#n en 1.5;.+ llamada alfa que tenga como par&metro una cadena de
caracteres :representada con un arreglo con tope< llamada frase y una )ariable de tipo car&cter llamada letra$ +a
funci#n alfa produce el nmero de apariciones del car&cter letra en la frase$
Ejercicio 4: :Requiere conocimientos de matem&tica b&sica de ni)el secundario" concretamente deben saber
(allar las races de cualquier polinomio de segundo grado :funci#n cuadr&tica<< Kmplementen un procedimiento que
calcule las races de una ecuaci#n de segundo grado$ El cabezal del procedimiento debe de ser el siguiente2
Procedure Raices(a, b, c : Real; Var r : TipoRaices);
1$ %efinan el tipo TipoRaices utilizando la estructura de registro con )ariante$
2$ Kmplementen el procedimiento pedido$
Ejercicio 5: :Este conocimiento est& basado en una notaci#n matem&tica comn para cualquier estudiante
pero a)anzada para su tratamiento$ El conocimiento necesario se corresponde con los ltimos a!os de secundaria yHo
inicios de estudios terciarios< 5e considera el tipo de dato Nerr que es la uni#n de los nmeros naturales :?< con el
con'unto Err$ El con'unto Err se define como {diverr, reserr, argerr}" donde diverr es el error de la
di)isi#n por cero"reserr es el error de la resta con resultado negati)o y argerr es el error de cualquier operaci#n
donde alguno de sus argumentos no es natural$
5e definen las siguientes operaciones sobre elementos del tipo Nerr2
division: Nerr x Nerr Nerr
5i a pertenece a N y b pertenece a N - {0} UU[ divivision(a,b) = a DIV bM
5i a pertenece a N y b = 0 UU[ division(a,b) = diverrM
5i a pertenece a Err o b pertenece a Err UU[ division(a,b) = argerrM
resta2 Nerr x Nerr h Nerr
5i a pertenece a N y b pertenece a N y a >= b UU[ resta(a,b) = a - bM
5i a pertenece a N y b pertenece a N y a < b UU[ resta(a,b) = reserrM
5i a pertenece a Err o b pertenece a Err UU[ resta(a,b) = argerrM
suma: Nerr x Nerr Nerr
5i a pertenece a N y b pertenece a N UU[ suma(a,b) = a + bM
5i a pertenece a Err o b pertenece a Err UU[ suma(a,b) = argerrM
producto: Nerr x Nerr Nerr
5i a pertenece a N y b pertenece a N UU[ producto(a,b) = a * bM
5i a pertenece a Err o b pertenece a Err UU[ producto(a,b) = argerrM
1$ %efinan en 1.5;.+ el tipo Err$
2$ %efinan en 1.5;.+ el tipo Nerr$
3$ Kmplementen los procedimientos que implementan respecti)amente las operaciones di)isi#n" resta"
suma y producto del tipo Nerr$
PROCEDURE division (n1:Nerr; n2:Nerr; VAR n3:Nerr);
PROCEDURE resta (n1:Nerr; n2:Nerr; VAR n3:Nerr);
PROCEDURE suma (n1:Nerr; n2:Nerr; VAR n3:Nerr);
PROCEDURE producto (n1:Nerr; n2:Nerr; VAR n3:Nerr);
Ejercicio 6: :Datem&tica de ni)el terciario :^lgebra lineal de matrices< 5e desea implementar en 1.5;.+ el
producto de matrices de elementos de tipo Nerr$ +as matrices a operar podr&n tener diferentes dimensiones$ 5e sabe
que si una matriz tiene dimensi#n mxn" m y n son enteros positi)os que nunca superar&n a constantes N e =
respecti)amente$
El producto entre matrices de tipo Nerr se define de manera an&loga al producto de matrices de nmeros
naturales con la suma y el producto para el tipo Nerr dado en el e'ercicio anterior$
5ea la matriz m1 de dimensi#n m x n y la matriz m2 de dimensi#n p x q$ 5i n U p el producto m1 x m2 tendr&
dimensi#n m x q" en caso contrario diremos que el producto falla$
%efinir en 1.5;.+ el tipo MNerr" que representa las matrices de dimensiones m x n de tipo Nerr" para
cualquier m entre 1 e =" y para cualquier n entre 1 y N$ 1uede asumir que N e = son mayores o iguales que 1$
.dem&s MNerr debe tener un )alor de error 6merr7 para el caso en que el producto de matrices falle$
Kmplementar el procedimiento2
PROCEDURE mprod (m1:MNErr; m2:MNerr; VAR m3:MNerr);
El procedimiento mprod recibe dos matrices m1 y m2" retornando en m3 el producto m1 x m2 o merren caso
de que dic(o producto falle$
Ejercicio 7: En una isla del ;aribe una banda de piratas se gana la )ida asaltando barcos mercantes$
.nualmente en la isla se realiza un e)ento multitudinario llamado 6la entrega de los premios ;ala)era7$ 1ara este a!o
los piratas est&n pensando en entregar el premio 6;ala)era de Oro7 al pirata que (aya conseguido mas dinero
asaltando barcos para la banda$ ;omo usualmente los piratas discuten a qui,n le corresponden los premios en
trifulcas interminables y sangrientas" este a!o la comisi#n directi)a de la banda (a decidido informatizar el registro de
logros de los piratas en los distintos asaltos" con la esperanza de terminar as con algunas de las discuciones sobre los
cr,ditos que le corresponden a cada pirata$
+os logros de los piratas durante el a!o se organizan en la siguiente estructura2
CONST
MAXPIRATAS=10000; (* Limite de piratas que pueden vivir en la isla. *)
MAXASALTOS=500; (* Limite de asaltos a los que estadisticamente puede sobrevivir
un pirata. *)
MAXDIGITOSCI=8; (* Cantidad de digitos para almacenar un numero de cdula. *)
TYPE
TipoCI=ARRAY[1..MAXDIGITOSCI] OF CHAR;
TipoFecha=RECORD
dia:1..31;
mes:1..12;
anho:INTEGER
END;
TipoAsalto=RECORD
nombre_barco:ARRAY[1..30] OF CHAR; (* Nombre del barco asaltado *)
fecha:TipoFecha; (* Fecha del atraco *)
botin:INTEGER (* Suma de dinero obtenida para la
banda *)
END;
ConjuntoAsaltos=RECORD (* Contiene informacin sobre los asaltos *)
asaltos:ARRAY[1..MAXASALTOS] OF TipoAsalto;
tope:0..MAXASALTOS
END;
TipoPirata=RECORD
nombre:ARRAY[1..30] OF CHAR; (* Nombre del pirata *)
CI:TipoCI; (* Cdula de identidad *)
CASE estavivo:BOOLEAN OF (* Indica el estado vital actual del
pirata *)
TRUE: (asaltos:ConjuntoAsaltos); (* Contiene informacin sobre los
asaltos *)
(* realizados por el pirata
*)
FALSE: ()
END;
Banda=RECORD
pirata:ARRAY[1..MAXPIRATAS] OF TipoPirata; (* Contiene informacin de los
piratas de la banda *)
tope:0..MAXPIRATAS (* Indica cantidad de piratas
*)
END;
5e pide2
Parte a)
Kmplementar la funci#n2
FUNCTION dinero_obtenido_por_pirata(pirata:TipoCI, anho:INTEGER, b:Banda) :
INTEGER;
la cual debe recibir la ;K de un pirata" un a!o y una banda" y retornar la suma de dinero obtenida por el pirata
para la banda en ese a!o$ En caso de que el pirata se encuentre muerto o no se encuentre en la banda debe
retornar E$
5e sugiere implementar primero funciones2
FUNCTION CIiguales (ci1, ci2:TipoCI):BOOLEAN;
(* Retorna TRUE si "ci1" y "ci2" son iguales, FALSE si no. *)
FUNCTION contar_dinero (ca:ConjuntoAsaltos; anho:INTEGER):INTEGER;
(* Retorna la suma del dinero obtenido en los asaltos del conjunto "ca"
realizados durante el ao "anho". *)
Parte b)
Kmplementar la funci#n2
PROCEDURE hallar_ganadores(piratas:Banda, anho:INTEGER; VAR
piratas_merecedores:ConjuntoCIs)
la cual dada una banda de pirata y un a!o" de)uel)e en piratasbmerecedores las c,dulas de los piratas )i)os
merecedores del premio 6;ala)era de Oro7$ -engamos en cuenta" que )arios piratas pueden coincidir en la
cantidad de dinero obtenido para la banda y que no (ayan otros piratas que los superen$ ;on'unto;Ks se declara
como sigue2
TYPE
ConjuntoCIs=RECORD
cedulas:ARRAY[1..MAXPIRATAS] OF TipoCI; (* Arreglo de
cedulas *)
tope:0..MAXPIRATAS (* Cantidad de
cdulas en el array *)
END;
Ejercicio 8: Examen .gosto 2EE1
5e desea traba'ar con una aritm,tica de ?aturales de (asta 1EE dgitos$ +os Enteros de 1.5;.+ no soportan
dic(a aritm,tica" por lo que se piensa utilizar la siguiente representaci#n de ?aturales basada en arreglos con
tope2
CONST
MaxDig = 100;
TYPE
Digito = 0..9;
Natural = RECORD
digitos : ARRAY[1..MaxDig] OF Digito;
tope : 0..MaxDig;
END;
Kmplementar la suma de ?aturales representados en t,rminos de la estructura anterior$ 0tilizar el siguiente
cabezal2
Procedure Suma(a, b : Natural: Var c : Natural);
BASE PRODUCTOS - Parte 2
.!adiremos dos funcionalidades m&s a nuestro programa2 Captura de Errores y una Lista Variable de
Elementos a almacenar$ 1ara esto tendr&n que modificar bastante su c#digo" lo cual puede ser bastante complicado y
les mostrar& la realidad de traba'ar con un c#digo ya (ec(o$ 5i no utilizaron buenos comentarios estar&n en problemas
ya que tendr&n que rememorar lo que (ace su programa e incluso con ellos tendr&n que acomodar su cabeza
nue)amente a una l#gica puntual$ ;ada programa es un mundo" tiene sus problemas y complicaciones" su estructuraM
y para cada uno deben adecuar su mente$ Kmaginen lo que es traba'ar con el c#digo de otra persona cuya cabeza
funciona de una forma totalmente diferente a la nuestra" cuya l#gica nos (ace rompernos la cabeza en el intento por
comprendela$ 1ues ese es el mundo de la programaci#n" de la creaci#n de soft/are" y cr,anme" lo que yo les (e
mostrado en este manual no es nada$ En pr#ximas entregas iremos sumergi,ndonos m&s en un mundo donde la magia
es posible" donde la imaginaci#n es pr&cticamente el nico lmite" donde el ingenio es la me'or (erramienta" donde la
paciencia es la me'or )irtud$ 5in embargo nada ser& sencillo" necesitar&n sentarse a pensar (oras c#mo lograr tal o
cual cosa" analizar una y otra )ez d#nde cornos est& el error que (ace a nuestro programa tirarnos cualquier cosa en
un caso concreto RRRR1ERO 5K E? -O%O5 +O5 %ED^5 ;.5O5 G0?;KO?.SSS Duc(as )eces pensar&n que no
(ay soluci#n" que necesitan alguna otra (erramienta" sin embargo este manual (a apuntado a que ustedes puedan
lograr grandes soluciones con (erramientas b&sicas$ 1.5;.+ tiene muc(as cosas m&s que nosotros ni (emos
nombrado y que en ciertos aspectos solucionaran muc(os problemas de forma autom&tica$ +engua'es superiores
lograr&n con dos palabras resol)er lo que a ustedes les (a lle)ado diez o m&s lneas de c#digo y (oras de rompedero
de cabeza" pero as se aprende y as" con esos lengua'es superiores" lograr&n resol)er cosas que tal )ez otras personas
no podran$ ien" )ayamos a nuestro programa$
?uestro programa deber& tiranos el mensa'e 6ERR?R3 2ato inesperado. ingrese un dato #lido7 para
cualquier caso en el que ingresemos algo inadecuado en cualquier entrada$ 5iempre que se muestre el mensa'e de
error el programa deber& quedar a la espera de un nue)o ingreso para el mismo dato$ %etallar, aqu los posibles
errores en las entradas y dar, e'emplos de e'ecuciones2
Nombre2 El nombre de un producto debe estar formado nicamente por nmeros yHo letras
maysculas yHo minsculas$ ;ualquier otro car&cter se tomar& como in)&lido$
ID2 El K% debe ser un nmero entero positi)o" o sea" un natural$ 5i el dato ingresado no se
corresponde con un nmero entero positi)o o directamente no es un nmero lo consideraremos
como error$ 1ara el K% tambi,n deberemos corroborar que no se repita en todos los ingresos
anteriores" ya que eso tambi,n sera un error$
Stock2 %ebe ser un nmero entero positi)o$ -iene las mismas restricciones que el K% con la
excepci#n de 5tocX s puede repetirse$
Precio2 Este dato debe ser un nmero real positi)o" en caso de ser negati)o o no ser un nmero lo
consideraremos como error$ Este dato les traer& problemas de captura ya que leer la entrada como
car&cter y luego pasarla a real no es tan sencillo como pasarla a entero$
Categora2 1ara este dato solo debemos corroborar que lo ingresado se corresponda con una de las
opciones mostradas en pantalla" de lo contrario ser& un error$ Esto se aplicar& a todas las pantallas
de nuestro programa en las que el usuario deba elegir una de )arias opciones$
Para controlar el nombre ingresado deben implementar una funci#n como la siguiente2
FUNCTION NombreCorrecto(nombre: CadenaChar): Boolean;
donde CadenaChar ser& un tipo global declarado de la siguiente manera2
CONST
MaxLargoNombre: 20;
TYPE
CadenaChar= RECORD
nombre: Array[1..MaxLargoNombre] of Char;
tope: 0..MaxLargoNombre;
END;
+a funci#n NombreCorrecto de)ol)er& -R0E si la cadena ingresada cumple las condiciones de m&s arriba"
G.+5E en caso contrario$
Para corroborar que la entrada corresponde a un entero positivo deben utilizar la siguiente funci#n2
FUNCTION EsEnteroPositivo(numero: CadenaChar): Boolean
la cual de)ol)er& -R0E si la entrada es un entero positi)o o E$ Esto lo usar&n para K% y para 5tocX" y tal )ez para
algn otro caso m&s donde ustedes crean que sea pertinente$ ?o admitimos el signo de @ en la entrada$
Del mismo modo comprobaremos si la entrada se corresponde a un real positivo2
FUNCITION EsRealPositivo(numero: CadenaChar): Boolean;
la cual ob)iamente de)ol)er& -R0E si la entrada es un real positi)o o G.+5E en caso contrario$ Recuerden que
tomamos como real positi)o que contenga nmeros yHo una sola coma$ ?o admitimos el signo de @ en la entrada$ %e
este modo" entradas correctas seran las siguientes2
1 Recordar que los nmeros enteros son reales$
1E
1E"E
"12 equi)ale a E"12 por lo cual es correcto$
132F"123
Entradas incorrectas seran2
@1
@1"23
A1"23
AE
@E
12"12"3
"E"1
12"A1
Para obtener el valor entero de una entrada correcta deben implementar la funci#n siguiente2
FUNCTION StringToInt(numero: CadenaChar): Integer;
la cual de)ol)er& dic(o )alor$ Esta funci#n recibe una cadena de caracteres correcta" por lo cual la )erificaci#n de
error debe (acerse antes de su llamada$
Del mismo modo implementarn una funcin para obtener el valor real de una cadena de caracteres
correctos2
FUNCTION RealToInt(numero: CadenaChar): Real;
Esta funci#n" como di'e antes" les traer& problemas porque no es lo mismo pasar una cadena de caracteres a un )alor
entero que a un )alor real$ +es explicar, la l#gica que se me ocurri# a m para su implementaci#n2
0n nmero real est& constituido de dos partes" la que est& antes de la coma y la que est& despu,s" o sea" la
parte entera y la parte real$ 1or e'emplo2
1 2 1arte entera 1" parte real E$
1"EEE2 1arte entera 1" parte real E$
E1"E2 1arte entera 1" parte real E$
12"F22 1arte entera 12" parte real F2$
El truco est& entonces en obtener estas dos partes por separado como nmeros enteros" de este modo si
tenemos el 12"F2 tendremos por un lado el 12 y por otro lado el F2" ambas partes como enteros" lo cual es f&cil lle)ar
a )alor integer con la funci#n StringToInt$ 0na )ez tenemos el entero 12 por un lado y el entero F2 por otro
debemos establecer el F2 como el real E"F2 y sum&rselo al 12 con lo cual obtenemos 12"F2$
12 @ E"F2U 12"F2$
1ara obtener el E"F2 a partir de F2 basta con di)idirlo entre 1EE$ %e este modo" si nuestra parte real tiene un
solo dgito debemos di)idirla entre 1E" si tiene dos dgitos debemos di)idirla entre 1EE" si tiene tres entre 1EEE y as
sucesi)amente$ 1or e'emplo2
123"14JU 123 @ 14JH1EEE
1"23JFU 1 @ 23JFH1EEEE
E1"EU 1 @ EH1E
Espero que con esto puedan implementar correctamente la funci#n Real-oKnt$ ;ualquier duda estoy a su disposici#n
en mi correo mstrvladi@hotmail.com$
Para comprobar que la opcin de la categora seleccionada es correcta, o para comprobar que la
opcin de un men se corresponde con una de las disponibles deben implementar una funci#n como la siguiente2
FUNCTION OpcionCorrecta(inicioRango, finRango: char): Boolean;
la cual recibir& en sus par&metros el inicio del rango de opciones y el final del mismo" por e'emplo" )iendo un men
como los que tiene nuestro programa2
1) Todos
2) Segn ID
3) Segn Nombre
4) Comestibles
7) Higiene personal
Opci#n [[
inicioRango sera e1e y finRango sera ePe$ .(ora bien" si son obsera)dores deberan preguntarse qu, pasa si el
usuario ingresa el )alor eIe$ 1ues sera una buena pregunta$ 1ara estos casos debemos modificar nuestro men de
modo que todas las opciones sean consecuti)as2
1) Todos
2) Segn ID
3) Segn Nombre
4) Comestibles
7) Higiene personal
Opcin >>
Estas modificaciones deber&n (acerlas con todos los mens que (agan falta$ .sumiremos siempre que
inicioRango<finRango$
Ginalmente queda por )er el (ec(o de que la lista de elementos sea )ariable$ 1ara esto implementaremos un
arreglo con tope de la siguiente manera2
Const
N= 5;
Type
Categorias= (comestibles, frutas_verduras, higiene_h, higiene_p);
TNaturales= 1..MAXINT;
Elemento= Record
Nombre: String;
Stock: TNaturales;
Precio: Real;
Categoria: Categorias;
ID: TNaturales;
End;
Productos= Record
Array[1..N] of Elemento;
tope: 0..N;
End;
;omo )en" esta definici#n no cambia a la anterior en casi nada" simplemente implementa el tipo 1roductos
como un arreglo con tope$ %e este modo nuestro Den 1rincipal ser& as2
DE?f 1RK?;K1.+2
1) Ingresar nuevo producto.
2) Ver lista de productos.
3) Modificar productos.
4) Vender.
5) Buscar.
6) Cantidad de productos ingresados.
7) Eliminar producto.
8) Salir.
Opcin:
donde cambia la primera opci#n" ya que a(ora no ingresaremos un nmero de productos preestablecido" sino que
podemos ingresar uno o m&sM y a!adimos dos opciones nue)as$ Veamos entonces la opci#n 1 de nuestro men2
|-----------Producto 1-----------|
ID >> 1
Nombre >> Azcar
Stock >> 10
Precio >> 50,5
Ingresar otro producto (1= SI/2= NO): j
ERROR: Dato inesperado, ingrese un dato vlido.
Ingresar otro producto (1= SI/2= NO): 1
|-----------Producto 2-----------|
ID >> 2
Nombre >> Harina
Stock >> 10
Precio >> 42,5
;on eso )ol)eramos al Den 1rincipal$ 5i el usuario est& en el men principal y selecciona la opci#n 1"
entonces )ol)eremos al ingreso de productos tal como se )io arriba$ Kmaginen que ya se (an ingresado F productos"
entonces )eramos2
|-----------Producto 6-----------|
ID >> 6
Nombre >> AzcarImpalpable
Stock >> 10
Precio >> 55,5
5iempre debemos saber cuantos productos tenemos en nuestra lista$
Veamos a(ora la opci#n J2 Cantidad de productos ingresados2
5implemente se nos mostrar& en pantalla la cantidad de productos en nuestra lista$ 1or e'emplo2
Total de productos: 6
+o ltimo por )er es la opci#n Eliminar producto2 5e nos mostrar& el siguiente men2
ELIMINAR PRODUCTO:
1) Eliminar segn ID
2) Eliminar Comestibles
3) Eliminar Frutas y Verduras
4) Eliminar Higiene del Hogar
5) Eliminar Higiene Personal
Opcin:
1odemos eliminar un elemento determinado dando su K%" o podemos eliminar toda una categora completa
para agilizar las cosas$ Veamos dos e'emplos2
5upongamos que seleccionamos la opci#n 1" luego se nos pedir& el K%$ 5upondremos que el usuario ingresa
un K% que no existe" lo cual es un error" se pedir& de nue)o el dato" tras lo cual el usuario ingresar& un K% correcto$
;omo podr&n )er" para no eliminar nada y )ol)er al men principal debe ingresarse la letra D" cualquier otra cosa
ser& un error$
Ingrese el ID del producto a eliminar o M para volver al men principal: 12
Ingrese el ID del producto a eliminar o M para volver al Men Principal: 1
ID: 1
Nombre: Azcar
Stock: 10
Precio: 50,5
Seguro que desea eliminar este producto (S/N): S
Producto eliminado, presione ENTER para volver al Men Principal...
Veamos a(ora un e'emplo en el que se selecciona la categora comestibles para eliminar los productos2
Seguro que desea eliminar la categora comestibles? (S/N): S
Eliminados:
Azucar ID: 1
Harina ID: 2
Fideos ID: 5
;omo )en" se mostrar& un listado de todos los elementos eliminados$ Estar&n mostrados en el orden que
fueron ingresados$ 1ara cualquiera de estas opciones deber&n implementar el siguiente procedimiento2
PROCEDURE EliminarProducto(VAR Lista: Productos; indice: integer);
donde lista ser& nuestro listado de elementos e indice ser& el lugar de la lista donde est& el elemento a eliminar$
;ada )ez que se elimina un elemento debemos correr todos los siguientes a ese un lugar a la izquierda y reducir el
tope un nmero$ Veamos una ilustraci#n2
Producto
1
Producto
2
Producto
3
Producto
4
Producto
5
Vaco Vaco
1 2 3 4 F J L
.ll )emos una lista de elementos donde el arreglo tiene L celdas"
F de las cuales contienen productos" las otras dos no" por lo tanto nuestro TOPE 5
tope es F$ En este e'emplo eliminaremos el producto nmero 3" con lo
cual nuestro arreglo quedara as$
Producto
1
Producto
2
Producto
4
Producto
5
Vaco Vaco Vaco
1 2 3 4 F J L
El producto nmero 3 fue eliminado
con lo cual a(ora el producto 4 y F se corren un
lugar (acia la izquierda y el tope se reduce en 1" o sea" TOPE 4
1roducto 4 estaba en la celda 4 pero a(ora est& en la
celda 3" 1roducto F estaba en la celda F pero a(ora est& en la 4" y donde estaba 1roducto F no (ay nada que nos
interese" por lo tanto corremos nuestro tope (acia la ltima celda que contiene informaci#n$
?uestro procedimiento debe (acer 'ustamente esta tarea cada )ez que se elimina un elemento de nuestra lista$
5i por e'emplo se eliminaran todos los 1roductos menos el 1roducto F entonces quedara as" donde TOPE 12
Producto
5
Vaco Vaco Vaco Vaco Vaco Vaco
1 2 3 4 F J L
5i se eliminara todo" nuestro -O1E sera E y nuestro arreglo estara 6)aco7" y lo pongo entre comillas porque
en realidad las celdas siguen conteniendo informaci#n solo que a nosotros no nos importa en absoluto y la tratamos
como nula o )aca" de eso se trata la implementaci#n de .rreglos con -ope$
5i se intenta eliminar productos cuando ya no existe nada para eliminar el programa debe darnos el mensa'e
5;a lista de elementos est #aca6$
Basta aqu llegamos por a(ora con nuestro proyecto$ +a siguiente parte de este tutorial trata el ltimo tema y"
a mi gusto" el m&s interesante" con lo cual modificaremos por ltima )ez nuestro programa de modo que quede
6perfecto7 y utilice solo los recursos que necesita para funcionar" pero ya )eremos esto$
%eben intentar realizar todo lo que detallo aqu antes de continuar" no importa cuanto tiempo les lle)e"
cuantas )eces se tranquen" si tienen que escribirme a m o buscar m&s info en Knternet" deben lograr (acerlo$ ?o (ay
nada aqu que no puedan (acer con lo que saben (asta a(ora" es m&s" todo est& pensado para que lo (agan 'ustamente
con estas (erramientas$ 5i (an logrado resol)er la mayora de los e'ercicios anteriores m&s este programa" entonces
(an aprendido lo b&sico de la programaci#n de forma excelente y podr&n resol)er cualquier tipo de situaci#n que no
requiera estructuras muc(o m&s comple'as que estas que (emos )isto m&s las que )eremos a continuaci#n$ Existe una
(erramienta de implementaci#n de funciones llamada RE;0R5Ki?" sin embargo no la )eremos en esta entrega$
SEXTA PARTE
Memoria Dinmica: El tipo Puntero
Listas Encadenadas Simples
Introduccin:
Bemos llegado al fin al tema m&s importante de este tutorial" el que (e )enido nombrando desde (ace tiempo
y el que tal )ez les (aga quemar bastante m&s las neuronas" los 1unteros$ .ntes que nada d,'enme aclarar que el tipo
1untero no tiene nada que )er con el puntero del rat#n$$$$ 'e'e$$$ ueno" pong&monos serios$
;omo di'e en la introducci#n a la tercera parte de este tutorial" todos los tipos que (emos )isto (asta a(ora son
est&ticos" o sea que una )ez declaradas las )ariables de cierto tipo se asignar& en tiempo de compilaci#n la memoria
R.D necesaria para guardar el mayor )alor de dic(o tipo y mantendremos siempre esa memoria reser)ada para
nuestro uso" la utilicemos o no$ 0n e'emplo bien sencillo son los arreglos con tope$ %eclarado un arreglo de ?
cantidad de celdas" al compilar el programa se dir& que reser)emos en memoria el espacio suficiente para guardar
datos en todas ellas$ 5upongan que ? es igual a 1EEE en un arreglo con tope para guardar qui,n sabe qu, cosaM al
compilar el programa se asignar& memoria para mil celdas aunque usemos solo una o dos" lo cual es un desperdicio$
Es aqu donde entra en 'uego el tipo 1unteros" ya que nos permitir& pedir memoria en tiempo de e'ecuci#n" tanta
como necesitemos" y de)ol)erla cuando queramos$ 1or eso llamamos a este tema Demoria %in&mica$
0tilizando la estructura de los punteros" por e'emplo" podemos (acer que nuestro programa de productos de
almac,n pida memoria para guardar los datos de un producto cada )ez que el usuario ingresa uno nue)o" y liberar
dic(a memoria cuando se eliminan los productos$ Ese tipo de tareas lo (aremos con una estructura llamada +istas
Encadenadas" pero an nos faltan datos para llegar a ello" as que )allamos all& con los punteros$
El tipo Puntero:
0n puntero es un tipo" al igual que un arreglo o un registro" pero es un tipo muy especial ya que (ace
referencia directa a un lugar especfico de la memoria R.D pero no es parte de ese lugar" o sea" una )ariable del tipo
puntero es entonces un apuntador a un lugar de memoria" una direcci#n" una flec(a o como ustedes quieran
)isualizarla me'or$ -odas las )ariables de los tipos est&ticos :todos los que (emos )isto (asta el momento< nos
referencian el lugar de la memoria en el que est&n" por esto son llamadas variables referenciadas y por lo tanto
cambiando el )alor de la )ariable cambiamos el )alor del lugar de la memoria" sin embargo con un puntero no es as"
ya que ,l apunta a un lugar con el cual podemos (acer lo que sabemos (asta el momento" pero el )alor del puntero
seguir& siendo el mismo porque la direcci#n de la memoria sigue siendo la misma" o sea que un puntero no apunta al
lugar de la memoria en que est&" sino a otro totalmente distinto$ -al )ez leyendo eso ustedes dir&n2 Pero 8a -emos
ledo de ,lec-as 8 lugares de memoria a los que apuntan" y yo les dir, que tienen raz#n" pero la diferencia a(ora es
que podemos controlar a esas flec(as y adem&s al lugar al que apuntan$ =a comprender&n esto un poco me'or a
medida que a)ancemos$
Declaracin:
Veamos entonces en un e'emplo como definir el tipo puntero (acia enteros2
TYPE
MiPuntero= înteger;
;omo pueden obser)ar" al tratarse de un tipo debe ir declarado deba'o de la palabra reser)ada -=1E" luego le
damos un nombre seguido del signo de igual tal como si fuera un registro" un arreglo u otro tipo definido por nosotros
mismos$ +uego escribimos el acento circunfle'o :^< seguido inmediatamente del tipo al que apuntaremos sin separar
por espacios$ En este caso (emos definido un tipo puntero llamado MiPuntero que apuntar& a datos del tipo
integer" o sea" apuntaremos a nmeros enteros$ ;omo en cualquier tipo debemos definir luego una )ariable de ese
tipo para poder traba'ar con ,l$ En este e'emplo2
VAR
puntero1: MiPuntero;
Basta este punto solo tenemos una )ariable del tipo puntero" o sea una direcci#n" pero no est& inicializada por
lo cual no apunta a nada" tiene basura y con ella no se puede traba'ar$ ;ualquier intento de traba'o con un puntero no
inicializado terminar& probablemente con un error en tiempo de e'ecuci#n lo cual no es para nada recomendable" por
lo tanto SIEMPRE INICIALIZEN SUS PUNTEROS" o me'or dic(o SIEMPRE INICIALIZEN SUS
VARIABLES$ 5e que ya di'e eso antes" pero nunca est& de m&s recordarlo" aunque pueden )erlo en todos y cada uno
de los e'emplos de programas en este manual$
Entonces lo primero que debemos (acer es inicializar nuestro puntero" y para esto tenemos dos maneras2 lo
inicializamos de la nada" o sea" pedimos una celda de memoria a la que apuntar para luego poder asignarle )alores a
esta y traba'ar con ella como con cualquier )ariableM o bien le asignamos la direcci#n de otro puntero ya inicializado$
. diferencia de cualquier tipo" a un puntero no podemos asignarle )alores" o sea" no podemos dar una direcci#n
especfica de una celda y decirle 6apunt& para all7" excepto si le pasamos la direcci#n de otro puntero o si le damos el
)alor de una constante especial" pero esto lo )eremos m&s adelante$ .(ora )eamos como inicializar un puntero desde
la nada$
Otro modo de declarar un puntero es" al igual que con arreglos" de forma an#nima2
VAR puntero1: înteger;
El procedimiento NEW y el operador ^:
ien" un puntero no se inicializa como cualquier )ariable porque como ya di'e no podemos ir y asignar un
)alor especfico tal y como lo (acemos con los enteros" los caracteres y dem&s$ 5implemente pediremos una celda de
memoria y esta se asignar& autom&ticamente en funci#n de lo que exista disponible$ 5i se diera el caso en el que no
(aya suficiente memoria R.D tendramos algn problema" pero esto no suceder& para nosotros ya que nuestros
programas no usar&n casi nada$ 1ara darle un )alor inicial a un puntero tenemos que utilizar el procedimiento ?EW"
el cual simplemente lle)ar& entre par,ntesis el nombre de nuestra )ariable puntero$ En nuestro e'emplo sera2
NEW(puntero1);
con lo cual a(ora tenemos una celda de memoria asignada para nuestro traba'o$ ?uestro puntero tiene una direcci#n
fi'a" o sea" tiene un )alor" pero el lugar de la celda al que apunta contiene basura" tal como sucede con las )ariables
normales$ 5i definimos una )ariable del tipo integer y no la inicializamos esta quedar& con un )alor que depender& de
nuestro compilador" lo cual no es para nada seguro$ >r&ficamente tenemos lo siguiente2
?uestra )ariable puntero1 apunta (acia un lugar preciso pero no sabemos qu, (ay all$ .(ora bien" si un puntero
contiene la direcci#n de la memoria pero no su )alor 8c#mo modificamos lo que existe all9
En una )ariable comn y corriente como las que conocemos" simplemente al escribir su nombre estamos
referenciando al lugar de la memoria que ocupa y su contenido" con lo cual podemos acceder a ,l directamente y
modificarlo" mostrarlo en pantalla" asignarle un )alor ledo de la entrada est&ndar o (acer cualquier operaci#n$ ;on un
puntero podemos (acer lo mismo ya que 1.5;.+ nos da la estructura para traba'ar con el )alor de la memoria como
si fuera una )ariable referenciada2
puntero1^:= 10;
%e este modo estamos asignando el )alor 1E a la celda de memoria" tal como si fuera una )ariable entera
comn$ 1odemos entonces decir que puntero1^ es el identificador de la )ariable en esa celda$ +o que intento decir
es que del mismo modo que en una declaraci#n del tipo
VAR
X: integer;
utilizamos al identificador N para traba'ar con los )alores de la memoria" en una declaraci#n del tipo
VAR
X: UnTipoPuntero;
utilizamos al identificador X^ para traba'ar con el )alor de la memoria$ %e este modo podemos (ace con X^ todo lo
que se puede (acer con las )ariables comunes" sea RE.%" RE.%+?" WRK-E" WRK-E+?" as como tambi,n
podemos utilizarlos en asignaciones" operaciones" comparaciones y dem&s$
Entonces" (ay algo que tiene que quedar muy claro$ %ado un tipo puntero y una )ariable N del tipo puntero"
una cosa es nombrar a N :el puntero en s< y otra es nombrar a Nj :el lugar al que apunta N<$ %iremos que N contiene
la direcci#n en la que est& Nj$ 5i lo )emos gr&ficamente sera as2
En esta
figura pueden )er el
c#digo 1.5;.+
completo de lo que
(emos )isto (asta
a(ora sobre
punteros$ ;reamos
el tipo
MiPuntero como
punteros a enteros"
luego declaramos la
)ariable
puntero1 de ese
tipo" pedimos una
celda de memoria
para luego poder
asignarle el )alor entero 1E con lo cual termina nuestro programa$
.lgo muy pero muy importante es que no pueden hacer referencia a puntero#- si antes no han
solicitado una celda de memoria ya que si nuestro puntero no apunta a ningn lado 8qu, es entonces puntero1^9
;omo di'e antes" traba'ar con un puntero no inicializado nos dar& un error en tiempo de e'ecuci#n" y no queremos eso
'am&s$ +as )ariables del tipo puntero" a pesar de contener una direcci#n de memoria" son )ariables y por tanto su
espacio de memoria se asigna en tiempo de compilaci#n$ 8%e que sir)en entonces9 ?o es lo mismo mantener est&tico
el )olumen de memoria necesario para almacenar a )arios punteros que para almacenar los tipos a los que estos
apuntar&n$ Veamos un e'emplo para que comprendan esto2
5upongan la siguiente declaraci#n2
TYPE
RegistroPersona= Record
Nombre: String;
Edad: Integer;
Peso: Real;
End;

Persona= ^RegistroPersona; //Un puntero al registro.
VAR
pers1: Persona; //Variable del tipo puntero a un registro.
+a )ariable pers1 es un puntero a un registro" o sea" contendr& la direcci#n de memoria en la que guardar,
un registro con tres datos" sin embargo pers1 solo guarda una direcci#n" lo cual es est&tico para cualquier tipo de
puntero y es infinitamente menor en tama!o que lo que se necesita para almacenar un registro$ 1or lo tanto es me'or
mantener un )olumen de memoria est&tico para almacenar punteros que para almacenar estructuras de datos
comple'as$ 5i tengo que almacenar tres registros" es me'or ocupar el espacio de tres punteros que soliciten la memoria
cuando (aga falta y la liberen luego" que mantener siempre ocupado el espacio para tres registros" los cuales pueden
ser enormes$ Kmaginen un arreglo de registros tal y como usamos en nuestro programa de productosM dic(o arreglo es
una estructura muy comple'a y conlle)a muc(a memoria 8no sera me'ora administrarla de otra manera9 1ues s" y
pronto )eremos como (acerlo$
.(ora )ean el siguiente c#digo e intenten darse cuenta de qu, saldr& en pantalla si ptr1 y ptr2 son
punteros a enteros2
new(ptr1);
new(ptr2);
ptr1^ := 12;
ptr2^ := ptr1^ + 4;
readln(ptr1^); (* suponga que se ingresa 3 *)
writeln(ptr2^ * ptr1^) (* qu despliega? *)
+a respuesta correcta es no se sabe" piensen ustedes el por qu,$
Alias de variables:
Veamos lo siguiente paso a paso2
TYPE
puntero= înteger;
VAR
p1, p2: puntero;
-enemos (asta este momento lo siguiente2
donde ninguna de nuestras )ariables est& inicializada y por lo tanto no podemos (acer nada con ellas$ 5igamos
entonces y )eamos lo que sucede2
NEW(p1);
;omo pueden )er (emos
solicitado un lugar de memoria
para p1" o sea lo inicializamos de
la nada y le damos su espacio para
almacenar un enteroM dic(o
espacio contiene algn )alor
desconocido :basura<$ +a )ariable p2 sigue sin inicializar por lo que contiene una direcci#n que no sir)e para nada y
que solo nos traer& problemas (asta que le demos un )alor$
.(ora (acemos lo siguiente2 p2:= p1 con lo cual obtenemos el siguiente resultado2
Bemos asignado a p2 el )alor de p1" o sea" le (emos
dic(o a p2 que apunte (acia la misma celda que p1$ ;uando
dos o m&s punteros apuntan a una misma celda decimos que
son alias$ Esto puede ser muy til ya pero a la )ez es muy
peligroso ya que al modificar la celda de uno modificamos la
del otro" tal como sucede con el pasa'e de par&metros por
referencia$
.(ora )eamos una asignaci#n similar pero muy
diferente2
5ean p1 y p2 punteros a caracteres :c(ar<" dado el siguiente fragmento de c#digo tenemos la siguiente
situaci#n2
New(p1);
New(p2);
p1^:= 'c';
p2^:= 'j';
?oten a(ora la diferencia entre estas dos asignaciones suponiendo que las mismas son escritas luego del
c#digo anterior" o sea" o escribimos una o la otra" no una seguida de la otra2
p1^:=p2^ p1:=p2
;omo podr&n obser)ar" en el primer caso (emos copiado el contenido de la celda de p2 en la de p1 con lo
cual ambas )ariables :p1^ y p2^< )alen lo mismo$ Esto es igual a (acer una asignaci#n del tipo X:= Y siendo X e Y
)ariables de un mismo tipo$ .(ora )ean el segundo caso donde en )ez de usar p1^ y p2^ usamos p1 y p2
directamente$ ;omo podr&n obser)ar p1 pasa a apuntar al mismo lugar que p2 transform&ndose ambos en alias" sin
embargo la celda a la que apuntaba p1 originalmente queda sin nadie que la apunte por lo cual ya no es posible
acceder a ella" pero sigue conteniendo su )alor guardado y por tanto sigue ocupada" no (a sido liberada$ +a forma
correcta de (acer esto (abra sido liberar primero la celda de p1 de modo que este quede indefinido y luego (acer la
asignaci#n p1:= p2$
Este tipo de errores es muy comn y pronto )eremos alguno m&s$ El traba'o con la memoria din&mica
requiere muc(sima atenci#n para (acerlo bien y controlar todo correctamente$ 1or eso muc(os programadores
sostienen que es me'or tener un sistema que se encargue de liberar la memoria autom&ticamente cada cierto tiempo
como lo (ace Ca)a y otros no$ =o me inclino por los que no" pero es una simple opini#n personal$
0n uso incorrecto de ?EW2
5i (acemos ?EW de un puntero ya inicializado estaremos pidiendo un nue)o espacio de memoria para ,l" con
lo cual apuntaremos al nue)o lugar y de'aremos el otro en la nada$ 5ea p un puntero a caracteres2
NEW(p); p^:= 'a'; .(ora" luego de estas instrucciones (acemos NEW(p);
;omo )er&n" al (acer ?EW de un puntero obtenemos un nue)o lugar en la memoria sin importar lo que
(ubiera antes$ %e este modo si el puntero estaba indefinido lo definimos" y si ya estaba definido lo redefinimos sin
importar lo que (aba antes$ %e este modo" si ya tenamos un lugar de la memoria asignado" obtenemos uno nue)o a
costa de abandonar el otro pero de'&ndolo a(" con o sin )alor asignado" pero no liberado y sin posibilidad de )ol)er a
acceder a ,l$
-engan esto siempre en mente2 ?EW nos da un nue)o espacio de memoria y nos apunta (acia ,l" no importa
lo que (aya sucedido (asta el momento" ?EW define nue)amente de cero al puntero y ya$ 5i (acemos treinta ?EW
seguidos de un mismo puntero (abremos creado treinta lugares de memoria pero solo apuntaremos al ltimo creado y
los otros )eintinue)e quedar&n en nuestra memoria" ocupando lugar" pero sin posibilidad de ser accedidos o usados$
1or suerte los sistemas operati)os se encargan de liberar la memoria mal usada$
El procedimiento DISPOSE:
.s como se nos (ace necesario solicitar memoria cuando (aga falta" se nos (ar& necesario liberarla cuando
ya no la necesitemos$ Bemos )isto que" dado un puntero a algn tipo determinado" el procedimiento ?EW nos asigna
una porci#n de memoria y su direcci#n para que podamos acceder a ella$ 1or e'emplo" dado un puntero p a cualquier
tipo" si (acemos NEW(p) obtenemos nuestra porci#n de memoria a la cual llamaremos p^ y su direcci#n quedar&
almacenada en p$ .s como es de f&cil solicitar memoria lo es el liberarla$ -eniendo un puntero ya inicializado"
utilizamos el procedimiento %K51O5E para liberar su porci#n de memoria" por e'emplo" sea el mismo puntero p a
algn tipo especfico y estando p ya inicializado utilizamos2
DISPOSE(p);
%e este modo la porci#n de memoria se libera para que el sistema pueda utilizarla y p queda indefinido" o sea"
queda como si nunca lo (ubi,ramos inicializado$
Vimos anteriormente que si (acemos sucesi)os ?EW de un mismo puntero )amos solicitando memoria en
cada uno" pero )amos de'ando perdidas las porciones de memoria de los ?EW anteriores qued&ndonos solo con la del
ltimo" lo cual es un desperdicio porque el sistema cree que las porciones no referenciadas est&n igualmente siendo
utilizadas y eso no es as$ .(ora 8qu, pasa si (acemos sucesi)os %K51O5E de un mismo puntero9 ;opien este c#digo
en su compilador y obser)en el resultado2
PROGRAM SucesivosDispose;
TYPE
TipoPuntero= ^Char;
VAR
puntero: TipoPuntero;
BEGIN
writeln('Presione ENTER para solicitar memoria al sistema');
readln;
new(puntero);
writeln('Hemos solicitado memoria al sistema.');
writeln('Presione ENTER para liberar la memoria solicitada.');
readln;
dispose(puntero);
writeln('Hemos liberado la memoria solicitada.');
writeln('Presione ENTER para liberar nuevamente.');
readln;
dispose(puntero);
writeln('Todo ha salido bien, presione ENTER para salir.');
readln;
END.
;omo )er&n" primero solicitamos memoria inicializando puntero mediante ?EW con lo cual obtenemos
nuestro espacio para almacenar un car&cter as como la direcci#n de ese espacio$ +uego liberamos ese espacio
mediante %K51O5E con lo cual la informaci#n contenida en ,l se pierde" o sea" de'a de existir puntero^ y
puntero queda indefinido" o sea" su direcci#n es cualquier cosa$ +uego nue)amente intentamos liberar memoria"
sin embargo puntero no apunta a nada especfico" contiene una direcci#n err#nea porque est& indefinido" por lo
tanto no podemos liberar memoria de un lugar al que no podemos llegar lo cual genera un error en tiempo de
e'ecuci#n y nuestro programa se cerrar& abruptamente :si no es as depende del compilador" sin embargo de'ar eso a
suerte es un error en la metodologa de programaci#n<$ ;omo )en" utilizar %K51O5E con punteros no inicializados es
un error gra)e y (ay que tener muc(o cuidado a la (ora de utilizar este procedimiento$ 1or eso es complicado
administrar bien la memoria que utiliza el programa" m&s an cuando la cosa se )uel)e comple'a$
.(ora que saben liberar memoria pueden (acer de forma correcta lo que se!al, como error anteriormente" o
sea" cuando tenemos dos punteros inicializados pero queremos transformarlos en alias" o sea" que ambos apunten a lo
mismo" debemos primero liberar la memoria de uno de ellos y luego cambiar su direcci#n" de este modo no (abr&
porciones de memoria que se queden perdidas en el espacio2
Nota: 5ea un puntero p (acia cualquier tipo especfico" si p no est& inicializado no podemos referenciar a p^
porque tal lugar de memoria no existe$ Bacerlo causa un error en tiempo de e'ecuci#n$ %e este modo" referenciar al
lugar que apunta un puntero luego de un procedimiento %K51O5E es un error de programaci#n$
5eguiremos con un ltimo concepto para luego )er algunos e'ercicios antes de continuar$ El siguiente tema
luego de esto ser& +istas Encadenadas" lo cual est& basado en el mero uso de punteros$
0? ERROR ;ODf?2 .lias y %K51O5E2
5upongan que tenemos dos punteros" p y q" apuntando a una misma celda" o sea" p y q son alias2
5i (acemos DISPOSE(p) 8qu, pasa9
.(ora q qued# tambi,n indefinida porque la porci#n de memoria a la que apuntaba ya no existe$ -engan
muc(o cuidado con este tipo de situaciones$
El puntero nulo, la constante NIL:
Bemos )isto que una )ariable de un tipo puntero es una )ariable que contiene una direcci#n (acia una porci#n
de memoria en la que se almacenar& un tipo de dato especificado$ Vimos tambi,n que no es posible asignar )alores
especficos a un puntero excepto si le pasamos el )alor de otro puntero ya inicializado anteriormente$ Existe" sin
embargo" una constante general para cualquier tipo de puntero la cual contiene el )alor 6nulo7 y que podemos
asignarle a cualquiera de nuestros punterosM esta constante es llamada ?K+$ 5ea p un puntero a un tipo cualquiera"
podemos (acer2
p:= NIL;
en cualquier momento$ ?K+ es la forma correcta de decir que un puntero no est& apuntando a nada" que es nulo" lo
cual no es lo mismo que decir que no est& inicializado$ 0n puntero que 6apunta7 a ?K+ no tiene memoria asignada"
pero tiene un )alor correcto" asimismo" como no tiene celda asignada no podemos acceder a ella mediante el operador
^" o sea" para nuestro p" si p=NIL no podemos acceder a p^ porque no existe" si lo (acemos tendremos un error en
tiempo de e'ecuci#n" por eso siempre que estemos traba'ando en situaciones donde un puntero pueda )aler ?K+
debemos preguntarlo primero$ Esto es posible porque ?K+ admite comparaciones" o sea" si tenemos un puntero p
podemos (acer por e'emplo2
KG pU?K+ -BE?$$$
o por e'emplo
KG p\[?K+ -BE?$$$
o en cualquier cosa ya que podemos utilizarlo como condici#n2
WBK+E p\[?K+ %O$$$
RE1E.- $$$0?-K+ pU?K+
etc$
.signar el )alor ?K+ a un puntero ya inicializado sin antes (acer %K51O5E de ,l es un error ya que
cambiaremos la direcci#n del puntero sin antes liberar la memoria con lo cual quedara esta perdida en la nada$ Es el
mismo caso que asignar a un puntero ya inicializado el )alor de otro puntero sin antes liberar sus memoria$
IMPORTANTE: 5iempre que )ayan a asignar a un puntero ya inicializado algn )alor deben liberar la
memoria asignada para ,l$
Bacer %K51O5E de un puntero ?K+ es un error de programaci#n" puede no causar problemas" pero no debe
(acerse 'am&s$
81ara qu, sir)e el )alor ?K+9 8%e qu, sir)e decir que un puntero no apunta a nada9 1ues lo )eremos dentro
de poco" primero realicen estos e'ercicios simples antes de continuar$
Ejercicio1: a) %eterminen cu&les de las siguientes proposiciones son )&lidas2
new(apun1)
new(apun1^)
apun1 := apun3
apun2^ := apun2^ + apun1^
apun1 := NIL
apun4^ := NIL
writeln(apun2, apun3)
read(apun1^, apun4^)
b) %eterminen cu&les de las siguientes proposiciones son )&lidas2
1.apun1 := NIL
2.apun2 := new(apun1)
3.dispose(apun3)
4.apun3^ := NIL
5.apun3 := apun4 AND (apun3 = NIL)
6.apun4^ := NIL
Ejercicio 2:
1.
;onsideren las declaraciones que se (icieron en el Ejercicio 1$ %eterminen la salida que produce el siguiente
c#digo2
new(apun1);
new(apun2);
new(apun3);
apun2 := apun1;
apun1^ := 2;
apun2^ := 3;
apun3^ := 'A';
writeln(apun1^, apun2^, apun3^)
2.
8-iene algn error el siguiente c#digo9 5upongan que apun1 es una )ariable de apuntador que (ace referencia
a una )ariable entera$
new(apun1);
read(apun1^);
writeln(apun1^);
dispose(apun1);
writeln(apun1^)
Ejercicio 3: ;onsideren las declaraciones realizadas en el Ejercicio 1" determinen la salida del siguiente
c#digo2
new(apun3);
new(apun1);
apun3^ := 'Z';
apun2 := NIL;
apun4 := NIL;
IF (apun3 <> NIL) AND (apun2 = NIL) THEN
writeln (`Cdigo A');
IF apun3^ = `Z' THEN
writeln (`Cdigo Z')
ELSE
writeln (`Cdigo X')
Ejercicio 4
%ado el siguiente c#digo en 1ascal
Type
TipoVehiculo = (barco, camion);
Transporte = record
capacidad : INTEGER;
case vehiculo : TipoVehiculo of
barco : (habitaciones : INTEGER);
camion : ();
end;
var a, b, c : ^Transporte;
begin
new(a);
a^.capacidad := 30;
a^.vehiculo := barco;
a^.habitaciones := 4;
new(b);
b^.capacidad := 4;
b^.vehiculo := camion;
new(c);
c^.capacidad := 5;
c^.vehiculo := camion;
end.
1- 8;u&l de las siguientes figuras representa el estado de la memoria9 :tengan en cuenta que se omiten los
nombres y )alores de algunos campos para no recargar el dibu'o<$
2- %ada la instrucci#n2 b := c
2$1 8;u&l de las siguientes figuras representa el estado de la memoria posterior a la instrucci#n9
:tengan en cuenta que en las figuras se omiten los nombres y )alores de algunos campos para no recargar el
dibu'o<$
2$2 8
5era correcto
(acer dispose(b) antes de la instrucci#n9 Custifiquen$
3- %ada la instrucci#n b^ := c^
3$1 %ibu'en el estado de la memoria posterior a la instrucci#n$
3$2 8*u, )alor tiene b^.capacidad9
3$3 -eniendo en cuenta que se quiere mantener las referencias a los componentes referenciados 8sera
correcto (acer dispose(c ) despu,s de la instrucci#n9 Custifiquen$
Realicen todos estos e'ercicios antes de continuar$ 1regntenme acerca de todo aquello que les pro)oque
dudas" les responder, a la bre)edad$ 5i no logran comprender estos conceptos no podr&n traba'ar con lo que )iene a
continuaci#n$ RRR.delanteSSS
Listas encadenadas simples:
Es aqu donde utilizaremos el )erdadero potencial de los punteros$ ?o aprenderemos en s nada nue)o ya que
en lo que a lengua'e refiere (emos aprendido todo a lo que apunta el manual" esto es simplemente una
implementaci#n de una (erramienta ya conocida" una implementaci#n que probablemente no se les ocurrira por s
mismos y es por esto que en las uni)ersidades y cursos de programaci#n se ense!a de forma especfica$
%e forma sencilla" una lista encadenada simple es un listado de )arios elementos de un mismo tipo donde
existe uno que es el primero y uno que es el ltimo" tal como en los arreglos$ +a diferencia es que las listas son
din&micas y pueden aumentar o disminuir de tama!o llegando incluso a ser )acas" ocupando solo la memoria que
necesitan para existir en el momento preciso$ . forma de esquema" tenemos un primer elemento que" adem&s de
contener todos los datos que sean" nos dir& donde est& el segundo elemento" que nos dir& donde est& el tercero" que
nos dir& donde esta el cuarto" y as sucesi)amente (asta llegar a uno que nos diga 5@a no -a8 ms elementos6$
.ll pueden )er un dibu'o sencillo de lo que sera una lista encadenada$ ;ada elemento contiene lo que tiene
que contener y adem&s nos dice donde est& el elemento siguiente a ,l en la lista" (asta que algn elemento nos diga
que ya no existe nada m&s despu,s de ,l con lo cual diremos que estamos al final de la lista$
Veamos como aplicar este concepto en 1.5;.+$ 1ara empezar diremos que cada elemento de una lista es un
nodo" por lo tanto una lista puede ser )aca :cuando no existe nodo alguno<" contener un nodo o )arios$ +a gracia de
esto ser& poder modificar los nodos" quitarlos" agregarlos y mo)erlos$ En este primer e'emplo definiremos lo que es
un nodo de lo que ser& un alista de nmeros enteros$ 1ongan muc(a atenci#n para comprender esto porque causa
confusi#n y a )eces cuesta entender lo que se est& escribiendo2
TYPE
Lista= ^NodoLista;

NodoLista= Record
numero: integer;
siguiente: Lista;
End;
Veamos2 %efinimos el tipo Lista como punteros (acia el tipo NodoLista" el cual declaramos m&s aba'o
como un registro de dos campos" uno del tipo entero que ser& nuestra informaci#n" y otro con un puntero del tipo
Lista" o sea" un puntero que apuntar& a elementos del tipo NodoLista$ .l tener un puntero del tipo Lista"
estaremos apuntando a un registro que dentro de ,l tendr&" adem&s de un nmero entero" otro puntero del tipo
Lista" y as por cada uno$ ;ada elemento del tipo Lista podr& apuntar a otro con la misma estructura$ Veamos
esto en un dibu'o2
;omo )en" cada elemento del tipo Lista tiene un puntero que apunta a una estructura del tipo Lista por lo
cual podemos ir repitiendo esa estructura tanto como queramos" donde cada elemento tiene el puntero (acia el
siguiente quedando todos encadenados$
%e este modo" para tener una lista simplemente necesito el puntero (acia el primer elemento ya que a partir
de este podr, obtener el siguiente y" recorriendo uno a uno" puedo )er la lista completa$ 5iempre para dar una lista
debe darse el puntero (acia el primer elemento$
%ado este sistema" debemos recorrer siempre las listas de forma secuencial" elemento a elemento" ya que no
podemos ir directamente a un nodo especfico$ 1or e'emplo" en una lista de 1E elementos no puedo ir al elemento
nmero F sin antes recorrer los 4 anteriores$ Esto deri)a en problemas de eficiencia y metodologas del uso de listas
para solucionarlos" pero no los )eremos aqu ya que lo importante a(ora es saber traba'ar con ellas$
;rearemos" dada la estructura anterior" una lista de tres nodos" guardando el nmero 1E den cada uno2
1 PROGRAM PrimeraLista;
2
3 TYPE
4 Lista= ^NodoLista;
5
6 NodoLista= Record
7 numero: integer;
8 siguiente: Lista;
9 End;
10
11 VAR
12 MiLista, i: Lista;
13
14 BEGIN
15 New(MiLista); //Creo el primer elemento de la lista.
16 i:= MiLista; //Utilizo un puntero alternativo para iterar.
16 i^.numero:= 10;
17
18 New(i^.siguiente); //Creo el segundo elemento de la lista.
19 i:= i^.siguiente; //Ahora i apunta al segundo elemento de la lista.
20 i^.numero:= 10;
21
22 New(i^.siguiente); //Creo el tercer elemento de la lista.
23 i:= i^.siguiente; //Ahora i apunta al tercer elemento de la lista.
24 i^.numero:= 10;
25 END.
.nalicemos este c#digo un pocoM tengan en cuenta que lo (e (ec(o as para que )ean todo" luego lo (ar, de la
forma correcta$ En la lnea 1F in)ocamos a ?EW para que la )ariable puntero MiLista obtenga un lugar de
memoria para almacenar a un registro NodoLista2
Di+ista obtiene la direcci#n de un registro ?odo+ista y
apunta (acia all$ %ic(o registro tendr& a priori un nmero entero
cualquiera en su campo numero y un puntero no inicializado en
su campo siguiente$
En la lnea 1J utilizo un puntero adicional i para apuntar tambi,n al primer elemento de la lista
transformando a MiLista y a i en alias2
En la lnea 1I solicito el espacio necesario para alo'ar a un nue)o elemento$ El puntero i^.siguiente es
del tipo Lista" por lo tanto la sentencia New(i^.siguiente) crear& un nue)o registro y nos dar& su direcci#n
de memoria2
En la lnea 1P (ago que i apunte al elemento creado recientemente2
En la lnea 2E asigno el )alor 1E al nue)o elemento2
En la lnea 22 creo el tercer elemento del mismo modo que fue (ec(o para crear el segundo$ +uego (ago que i
apunte (acia dic(o elemento para asignarle el )alor 1E tal como (ice anteriormente2
%e este modo (e logrado construir una lista de tres nodos" cada uno con el )alor 1E" donde el puntero
MiLista apunta al primero de ellos y todos est&n encadenadosM as" solo obteniendo la direcci#n de MiLista
puedo recorrer todos los nodos uno por uno$
Veamos a(ora un c#digo que (ace lo mismo pero mediante un GOR que iterar& tres )eces$ Este c#digo es el
m&s correcto ya que ser& igual de largo para crear tres nodos que para crear cien 8comprenden92
1 PROGRAM PrimeraLista;
2
3 TYPE
4 Lista= ^NodoLista;
5
6 NodoLista= Record
7 numero: integer;
8 siguiente: Lista;
9 End;
10 VAR
11 MiLista, i: Lista;
12 j: integer; //Un iterador entero para el FOR.
13
14 BEGIN
15 New(MiLista);
16 For j:= 1 to 3 do //Crear tres nodos.
17 begin
18 If j=1 then
19 i:=MiLista
20 else
21 new(i^.siguiente);
22
23 If j<>1 then
24 i:= i^.siguiente;
25
26 i^.numero:= 10;
27 end;
28 END.
El an&lisis de este c#digo les queda de tarea para ustedes$
Vladimir Rodrguez 1FE
Lista vaca:
%i'e (oy por a( que un lista puede ser )aca o puede contener uno o m&s elementos" lo cual es totalmente
cierto$ Entonces" diremos que una lista es )aca cuando el puntero al primer elemento )ale ?K+$ 1or e'emplo" para la
estructura anterior si MiLista= NIL diremos que la lista de nmero es )aca$
.unque ya (aba (ablado del )alor ?K+ para un puntero" no (aba dibu'ado su
representaci#n gr&fica$ ;omo pueden obser)ar all" no dibu', una flec(a" sino un fin
abrupto representado por lneas" eso significa ?K+" un puntero que no apunta a nada" lo
cual es muy distinto a un puntero indefinido$ 1uedo preguntar si un puntero es ?K+
mediante una comparaci#n" pero no puedo saber si es indefinido mediante ningn tipo de
sentencia del lengua'e$
Fin de lista:
En la primera lista que (emos )isto aqu creamos tres nodos$ .(ora (aremos un peque!o programa que cree
tantos nodos como el usuario quiera y a cada uno le asigne el nmero que el usuario quiere$ .l terminar nos dir&
cuantos nodos (emos creado$ .sumimos en todo momento que el usuario siempre ingresa informaci#n correcta2
PROGRAM PrimeraLista;

USES crt;
TYPE
Lista= ^NodoLista;
NodoLista= Record
numero: integer;
siguiente: Lista;
End;
VAR
MiLista, i: Lista;
j: integer; //Un iterador entero para el FOR.
opcion: char; //Para leer opciones de teclado.
BEGIN
//En esta seccin de cdigo solo mostramos opciones al usuario, creando
//la lista vaca si el usuario dice que SI.
//
//-----------------------------------------------------------------------
clrscr;
write('Desea crear una lista de nmeros enteros? S/N: ');
readln(opcion);
j:= 0;
//Simplemente damos opciones de inicio al usuario.
Case opcion of
'S': begin
MiLista:= NIL;
writeln('Hemos creado una lista vaca.');
writeln;
end;
'N': begin
write('Presione ENTER para salir...');
readln;
exit;
end;
End;//Fin del CASE OF.
{Crearemos tantos nodos como quiera el usuario.
Cada vez que elija la opcin 1 crearemos un nuevo nodo y leeremos un
nmero de la entrada estndar. Terminaremos cuando el usuario lo desee.
De este modo la lista ser de un largo totalmente aleatorio en cada
ejecucin}
//-----------------------------------------------------------------------
Vladimir Rodrguez 1F1
Repeat
//Mostramos las opciones al usuario
clrscr;
writeln('LISTA DE NMEROS: ');
writeln;
writeln('1) Agregar nuevo nmero a la lista');
writeln('2) No agregar ms nmeros');
writeln;
write('Opcin: ');
readln(opcion);
{Si la opcin leda es 1 creo el nodo correspondiente y hago que
i apunte a dicho nodo. Vean que discrimino mediante un IF si la
lista es vaca y si no lo es. Al final leo el nmero directo sobre
el nodo para luego sumar 1 a mi contador j.}
Case opcion of
'1': begin
clrscr;
write('Nmero: ');
If MiLista=NIL then
begin
New(MiLista);
i:= MiLista;
end
else
begin
new(i^.siguiente);
i:= i^.siguiente;
end;
readln(i^.numero);
j:= j+1;
end;
'2': writeln('No se ingresarn ms nmeros.');
end;
Until opcion='2';
//Terminado el bucle del REPEAT mostramos la informacin al usuario y ya.
clrscr;
writeln('Se han agregado ',j,' nmeros.');
write('Presione ENTER para salir.');
END.
?o (e numerado las lneas de este c#digo porque no lo analizare" los comentarios son lo suficientemente
descripti)os como para que ustedes puedan comprender lo que se est& (aciendo" adem&s de que todo (a sido
explicado con anterioridad$ ?o continen (asta no comprender este c#digo$
81ara qu, este programa9 8*u, tiene que )er con el fin de una lista9 ueno" lo que (emos (ec(o aqu es crear
una lista de largo aleatorio" o sea" crearemos tantos nodos como el usuario quiera en el momento" por lo tanto nunca
es posible saber cuantos elementos tendremos$ Entonces" 8qu, pasa si a(ora queremos mostrar los elementos de la
lista9 %ebemos recorrer uno a uno (asta llegar al final de la misma" pero no sabemos (asta donde recorrer$ Es cierto
que en este caso (emos contabilizado los nodos creados por lo cual podramos iterar tantas )eces como diga nuestra
)ariable j" sin embargo esa no es la forma correcta de (acerlo porque en general" los programas que traba'an listas no
)an contabilizando lo que crean ya que la comple'idad a la que se enfrentan no lo permite y traera muc(simos
problemas" sobretodo al tener que utilizar (erramientas como la recursi#n" que" aunque en este manual no la
aprenderemos" es importante que aprendan a traba'ar de forma correcta desde el principio$
?o puedo explicitarles aqu la importancia de esto ya que no es a lo que apunta este manual$ ?ormalmente los
programas traba'an con m#dulos independientes" o sea" partes de c#digo independientes entre s donde cada una est&
en arc(i)os diferentes" y luego existe un arc(i)o principal que se encarga de enlazar :(acer linX o linXear< todos los
arc(i)os independientes$ %e este modo el paso de informaci#n entre un m#dulo y otro se )uel)e comple'o y cuanto
menos )ariables y estructuras existan en este pasa'e (acen que la programaci#n sea m&s sencilla" as como el
mantenimiento y la actualizaci#n de los programas$ En nuestro pr#ximo manual" donde pasaremos al lengua'e
DO%0+.A2" que es un 1.5;.+ un tanto m&s a)anzado y orientado a la modularizaci#n de programas" casi a la
programaci#n orientada a ob'etos" aprender&n estas cosas y podr&n (acer programas muc(o m&s comple'os" como
peque!os editores de texto y dem&s$
Veamos entonces c#mo marcar el final de una lista de manera correcta$
Es simple$ ;ada nodo tiene un puntero que apunta al siguiente elemento de la lista" el ltimo elemento
simplemente apuntar& a ?K+ y ya" con eso diremos que la lista termin# y con eso podremos crear algoritmos muy
eficientes en el tratamiento de listas encadenadas$
Veamos" de forma gen,rica" e'emplos de c#digos para el traba'o (abitual con listas encadenadas" o sea"
contabilizar sus elementos" agregar un elemento al principio" agregar un elemento al final" buscar un elemento" borrar
el primero" borrar la lista completa2
Largo de una lista:
function largo(l: lista): integer;
var
contador: integer;
p: lista;
begin
contador:= 0;
p:= l;
while p <> nil do
begin
contador:= contador + 1;
p:= p^.siguiente; (* avanzar a la siguiente celda *)
end;

largo:= contador;
end;
Bsqueda de un elemento:
function pertenece(elem: T; l: lista): boolean;
var
p: lista;
begin
p:= l;
(* notar: evaluacin por circuito corto *)
while (p <> nil) and (p^.elemento <> elem) do
p:= p^.siguiente;

pertenece:= (p <> nil);
end;
;omo )en en los comentarios" notar la e)aluaci#n por circuito corto$ 5i no lo recuerdan" significa que en una
condici#n .?%" la parte de la izquierda se cumple entonces )erificamos la parte de la derec(a y en caso de que
ambas sean ciertas el .?% es cierto :-R0E<$ 5i la condici#n de la izquierda es falsa entonces ni siquiera )erificamos
la de la derec(a$ En este caso" si la condici#n de la derec(a es falsa significa que p=NIL por lo tanto" si quisi,ramos
)erificar la segunda parte tendramos que acceder a p^" lo cual es un error porque un puntero ?K+ no apunta a nada$
Agregar elemento al principio:
procedure agregar_al_principio(var l: lista; elem: T);
var p : lista;
begin
new(p); (*crear nueva celda*)
p^.elemento:= elem; (*cargar el elemento*)
(* ajuste de punteros *)
p^.siguiente:= l;
l:= p;
end;
Agregar elemento al final:
procedure agregar_al_final(var l: lista; elem: T);
var p,q : lista;
begin
new(p); (*crear nueva celda*)
p^.elemento:= elem; (*cargar el elemento*)
p^.siguiente:= nil; (*es el ltimo*)

if l = nil then
l:= p
else
begin
(*busco el ltimo de l*)
q:= l;
while q^.siguiente <> nil do
q:= q^.siguiente;

(*engancho p a continuacion del ltimo*)
q^.siguiente:= p;
end;

end;
Borrar el primer elemento de una lista no vaca:
procedure borrar_primero(var l: lista);
var
p: lista;
begin
p:= l;
l:= l^.siguiente;
dispose(p);
end;
Borrar una lista completa:
1ara liberar todo el espacio ocupado por una lista es necesario liberar celda por
celda$
procedure borrar_lista(l: lista);
var
p: lista;
begin
while l <> nil do
begin
p:= l;
l:= l^.siguiente;
dispose(p);
end;
end;
;ontinuemos a(ora entonces con los e'ercicios acerca de punteros" estos est&n orientados a las listas2
Ejercicio 5: %ado el siguiente c#digo que permite crear una lista encadenada2

TYPE
apuntador = ^registro;
registro = RECORD
dato : ...; (* integer, char, real, ... *)
sigreg : apuntador;
END;
VAR
apuntaInic : apuntador;
apuntaActual : apuntador;
indice : integer;
BEGIN
new(apuntaInic);
apuntaActual := apuntaInic;
FOR indice := 1 TO 3 DO
BEGIN
new(apuntaActual^.sigreg);
apuntaActual := apuntaActual^.sigreg
END;
apuntaActual^.sigreg := NIL;
END.
8;#mo modificara el c#digo anterior si se desea" mediante la inclusi#n de una tercera )ariable de tipo
apuntador" apuntar al ltimo registro de la lista9
5uponiendo que el tipo del campo YdatoZ en el registro definido anteriormente es de tipo c-ar" escriban un
procedimiento en 1ascal llamado Buscar que ex(iba un mensa'e que indique si un )alor de tipo c-ar se encuentra o
no en la lista$
El cabezal del procedimiento es el siguiente2

procedure Buscar(c : char; apuntaInic : apuntador)
donde c es el c-ar a buscar y apuntaInic es la referencia del comienzo de la lista$
Ejercicio 6:
1$%efinan un tipo llamado +istEnt" el cual representa una lista encadenada de enteros$
2$ Escribir un procedimiento en 1ascal que permita insertar un entero al principio de la lista encadenada$ El cabezal
del procedimiento es el siguiente2
Procedure InsertarPrincipio(valor: integer; VAR lista: ListEnt);
3$ Escribir un procedimiento en 1ascal que permita eliminar el primer elemento de una lista encadenada$ El cabezal
del procedimiento es el siguiente2
procedure EliminarPrincipio (VAR lista: ListEnt);
Ejercicio 7: %ada la siguiente definici#n2
Type
ListChar = ^registro;
registro = RECORD
campo: char;
siguiente : ListChar
END;
Vladimir Rodrguez 1FF
1$ Escribir una funci#n en 1ascal que permita insertar un car&cter al final de una lista encadenada de caracteres$
1onga especial atenci#n en no modificar la lista con la cual se in)oca a la funci#n" sino que se debe copiar toda la
lista" y operar sobre la copia$
El cabezal de la funci#n es el siguiente2
function InsertarUltimo (valor :char; lista: ListChar):ListChar;
2$ Escribir un procedimiento en 1ascal que permita eliminar los primeros cant caracteres :siendo cant una )ariable
dada" mayor o igual a cero< de una lista encadenada de caracteres$ El cabezal del procedimiento es el siguiente2
procedure DescartarComienzo(cant : integer; VAR lista: ListChar);
3$ Escribir una funci#n en 1ascal que permita obtener" a partir de una lista de caracteres" otra lista con los caracteres
que se encuentran entre la posici#n 6indBase7 e 6indSup7 de la lista original :siendo 6indBase6 e 6indSup7
nmeros enteros mayores o iguales a cero<$ El cabezal de dic(a funci#n es el siguiente2
function SubCadena (indBase, indSup : integer; lista : ListChar) : ListChar;
BASE PRODUCTOS - Parte 3
?uestro programa seguir& (aciendo las mismas cosas que en su segunda parte solo que esta )ez utilizar& la
estructura de listas encadenadas para almacenar los elementos de modo que solo utilizar& la memoria necesaria para
la cantidad de productos almacenados en el momento$
5er& tarea de ustedes modificar los cabezales de los procedimientos y las funciones que utilizaban la
estructura del arreglo con tope para traba'ar con la lista de elementos as como es tarea de ustedes modificar la
declaraci#n de los tipos principales del programa$ ?o necesitan traba'ar con listas para corregir errores de la entrada
estandar" solo quiero que lo (agan con la lista de productos$
5i necesitaran que yo les en)e los cabezales de todos los subprogramas no tendr, problema en (acerlo ya que
por lo general es lo que se (ace" sin embargo ser& un buen e'ercicio para ustedes el tener que pensarlos$
Vladimir Rodrguez 1FJ
UN ULTIMO PRYECTO:
+es propondr, aqu el traba'o con lo que fue la segunda tarea de 1rogramaci#n 1 en la Gacultad de Kngeniera
donde estudio$ Estos proyectos est&n dise!ados para que apliquen todo lo dado aqu y para que piensen de forma
estructurada" la misma forma que (e ense!ado a lo largo de este manual$ Es de alto ni)el pero podr&n (acerla" yo
estar, abierto a que pregunten todas y cada una de las dudas que tengan al respecto ya que por lo general estos
traba'os se acompa!an con alguna clase de consulta$ +e dar, aqu la letra tal y como fue dada a los estudiantes
incluyendo (asta las reglas de no copiar y dem&s" muc(a suerte$ Espero que lancen a realizar esto2
%eben leer todo antes de continuar" ya que luego de la letra del problema existen las instrucciones para
implementarlo ya que se les brindar& un arc(i)o con el c#digo ya escrito para la interfaz gr&fica y un arc(i)o con el
cual deber&n traba'ar ustedes creando el motor del 'uego$ .qu )en un e'emplo de un programa donde un arc(i)o se
encarga de realizar la interfaz gr&fica y otro de (acer las tareas del programa" luego ambos traba'an 'untos$
1. Introduccin
Este documento presenta el problema que deber resolverse para la aprobacin de la segunda
tarea del laboratorio del curso 2010.
Se presenta informacin acerca de: normas, recursos, plazos, una presentacin general del
problema, las especificaciones del mismo, eemplos de eecucin ! la forma de entrega.
2. Informacin general
El estudiante que no respete alguna de las consideraciones que siguen corre el riesgo de que su
trabao sea invalidado, con la consiguiente p"rdida del curso.
Compilador
#odos los programas deben ser compatibles con el compilador del curso $%ree &ascal'.
(o se aceptarn como vlidas aquellas tareas que pudieran funcionar con alg)n otro
compilador &ascal, pero no funcionen con %ree &ascal, versin 2.2.2 para *indo*s.
Grupos
Esta tarea se deber realizar en forma individual.
&ara todas las tareas rige el +eglamento del ,nstituto de -omputacin ante ,nstancias
de (o ,ndividualidad en los .aboratorios. / continuacin se adunta un fragmento del
mismo0 ante cualquier duda se recomienda leer el documento completo
$1ttp:22***.fing.edu.u!2inco2cursos2prog12pm2field.p1p2.aboratorio2(o,ndividuali
dad'
.os laboratorios deben ser realizados )nicamente por los integrantes
del grupo establecido .a realizacin de los laboratorios es
estrictamente individual, sea a nivel unipersonal en el primer caso, o
del grupo establecido en el segundo. Se entiende que compartir total o
parcialmente cualquier actividad del laboratorio atenta contra la
integridad del estudiante universitario ! de su formacin, ! por lo
tanto constitu!e una falta grave. Espec3ficamente no es posible
compartir por ninguna v3a entre integrantes de grupos distintos las
tareas de codificacin, digitacin, compilacin, depuracin !
documentacin de los programas u obetos $o entregas' del
laboratorio. /dems de que no se pueden compartir actividades del
laboratorio, no se pueden compartir los productos de las mismas. -ada
grupo es responsable de su trabao de laboratorio ! de que el mismo
sea individual, independientemente de las causas que pudiesen
originar la no individualidad. / modo de eemplo ! sin ser e41austivos:
utilizacin de cdigo realizado en cursos anteriores $por otros
estudiantes' u otros cursos, perder el cdigo, olvidarse del cdigo en
lugares accesibles a otros estudiantes, prestar el cdigo o dear que el
mismo sea copiado por otros estudiantes, dear la terminal con el
usuario abierto al retirarse, enviarse cdigo por mail, utilizar cdigo
Vladimir Rodrguez 1FL
suministrado por terceros, etc. /simismo se pro13be el env3o de cdigo
al grupo de noticias del curso, dado que el mismo ser considerado
como una forma de compartir cdigo ! ser sancionado de la manera
ms severa posible.
Forma de entrega
.as entregas se realizarn por la *eb. &ara ello se deber acceder a un sitio destinado
a tal fin ! seguir los pasos que se e4plicarn en la pgina correspondiente. Esta pgina
estar disponible cuando comience el plazo de entrega.
Fecha de Entrega
Se debe entregar desde el 5211 al 10211. El plazo vence el 10211 a las 12 de la noc1e.
3. Presentacin
3.1 Juego Iguales
,guales es un uego tipo puzle. El obetivo es eliminar fic1as obteniendo la ma!or cantidad de
puntos posible. .as fic1as que estn ad!acentes las unas de las otras se eliminan como un bloque.
.as dems fic1as se colapsan para rellenar los 1uecos vac3os ! se forman nuevos bloques. (o se
puede eliminar fic1as que no est"n en un bloque.
El tablero se inicia como una reilla llena de fic1as. 6abr cuatro tipos de fic1as. Si las fic1as
ad!acentes de un bloque son todas del mismo tipo, entonces pueden ser eliminadas simplemente
seleccionando una de ellas. El n)mero de fic1as en el bloque ! los puntos que se obtendrn al eliminar
ese bloque se muestran en la parte inferior. -uanto ms fic1as tenga un bloque ms puntos se
obtendrn. 7na vez que el bloque 1a sido eliminado, las fic1as encima de "l comenzarn a caer para
rellenar el espacio. Si se elimina una columna entera, entonces las fic1as se desplazarn 1acia la
izquierda para rellenar el espacio.
8os fic1as se consideran ad!acentes:
si estn en la misma columna ! en filas consecutivas, o
si estn en la misma fila ! en columnas consecutivas.
Vladimir Rodrguez 1FI
En la siguiente figura se muestra paso a paso el resultado de la eliminacin de un bloque para el
uego Same9ame del entorno 9nome de 9(72.inu4.
Se decide eliminar el bloque de fic1as verdes.
1. .as fic1as se desplazan 1acia abao.
2. -omo quedan columnas libres a la izquierda, se desplazan todos las fic1as 1acia la izquierda.
:. +esultado de eliminar el bloque de fic1as verdes.
El uego termina cuando no 1a! bloques a eliminar.
3.2 Fichas
-ada celda del tablero contendr una fic1a del conunto ;/, <, -, 8= o estar vac3a. /l comenzar el
uego, el tablero se llena de fic1as de forma aleatoria.
3.3 Puntaes
.a puntuacin est basada en el n)mero de fic1as que se eliminen:
Nmero de fichas eliminadas Puntos obtenidos
2 E
3 1
4 4
V V
Vladimir Rodrguez 1FP
n :n A 2<j2
Si se eliminan todas las fic1as 1a! una bonificacin de 1.000 puntos.
!. "r#uitectura del sistema
El sistema que implementa el uego se construir de acuerdo con la siguiente arquitectura:
usuario
^
|
|
v
+-------+ +----------+
| motor |<-----> | interfaz |
+-------+ +----------+
^ ^
\ /
\ /
v /
estructura
Este es un modelo simple donde tenemos dos capas o mdulos: la interfaz ! el motor.
.a interfaz se encarga de realizar el dilogo con el usuario, capturar sus entradas e invocar las
operaciones asociadas. .a interfaz tambi"n manea la imagen del uego en pantalla actualizndola
cada vez que 1a! cambios. En resumen, se encarga de todo lo que tenga que ver con entrada !
salida. .a interfaz no realiza ninguna modificacin directa sobre la estructura de datos.
El motor es el mdulo que trata con la estructura de datos que representa el uego en un estado
determinado. Este mdulo estar compuesto por todos los subprogramas necesarios para eecutar
las acciones del usuario ! reflear estas en la estructura de datos. El motor no realiza ninguna
operacin de entrada ! salida.
En esta tarea, el estudiante implementar solamente el motor. .a interfaz ser provista por los
docentes. En las siguientes secciones e4plicamos los detalles del mdulo a ser implementado.
$. Estructura
.a estructura de datos que representa el uego es la siguiente:
$.1 Estado del Juego
El #ipoEstado>uego es un registro con los siguientes campos:
Vladimir Rodrguez 1JE
tablero: contiene el tablero del uego
puntae: contiene el puntae actual del usuario
finalizado: indica si el uego 1a finalizado.
#ipoEstado>uego ? record
tablero : #ipo#ablero0
puntae : ,nteger0
finalizado : <oolean0
end0
$.2 %a&lero' Celdas ( Fichas
El tablero se representa con la siguiente estructura:
#ipo%ic1a ? $/, <, -, 8'0
#ipoEstado-elda ? record
case vacia : boolean of
true : $'0
false : $fic1a : #ipo%ic1a'0
end0
+ango%ila ? 1..@/AB%,./S0
+ango-olumna ? 1..@/AB-C.7@(/S0
#ipo#ablero ? record
celdas : arra! D+ango%ila, +ango-olumnaE of #ipoEstado-elda0
tope%ila : +ango%ila0
tope-olumna : +ango-olumna0
end0
Esta estructura es una matriz con dos topes $ver arra! con tope'. 8e esta manera se pueden
representar tableros de diferentes tamaFos. .as celdas vlidas de la matriz son aquellas cu!as
coordenadas $i,' son tales que:
1G? i G? tope%ila
1G? G? tope-olumna
.as constantes @/AB%,./S ! @/AB-C.7@(/S se suponen definidas con valores apropiados. Estos
valores estn definidos en la interfaz, de manera que el estudiante no necesita conocerlos.
-ada celda del tablero puede estar vac3a, o contener una fic1a como indica el registro con
variantes#ipoEstado-elda. &ara esta implementacin las fic1as son 5, ! las distinguimos con las
etiquetas: /, <, - o 8.
$.3 Posicin ( )ista de Posiciones
7na posicin en el tablero se representa con la siguiente estructura:
#ipo&osicion ? record
fila : +ango%ila0
columna : +ango-olumna
end0
&ara representar una bloque $o conunto de fic1as' utilizaremos el tipo #ipo.ista&osicion, que es
un arreglo con tope, como se muestra a continuacin:
#ipo.ista&osicion ? record
lista : arra! D1..@/AB-E.8/SE of #ipo&osicion0
tope : 0..@/AB-E.8/S0
end0
*. )os su&programas
Vladimir Rodrguez 1J1
El motor del uego est constituido por un conunto de subprogramas que trabaan sobre la
estructura definida.
*.1 Procedimiento iniciali+arJuego
Este subprograma es invocado al comienzo del uego para generar el tablero inicial.
procedure inicializar>uego$ cuantasBfilas :+ango%ila0 cuantasBcolumnas :+ango-olumna0 var
estado :#ipoEstado>uego'0
.os parmetros que recibe son:
cuantasBfilas: cantidad de filas que va a tener el tablero
cuantasBcolumnas : cantidad de columnas que va a tener el tablero
Este procedimiento debe retornar el parmetro estado configurado para iniciar el uego, esto es:
para cada celda selecciona al azar una fic1a: /, <, - 8
el uego no est finalizado
el puntae es cero
*.2 Procedimiento o&tener,lo#ue
8ado un tablero ! la posicin de una celda, devuelve la lista de posiciones de celdas que estn en
el mismo bloque seg)n las reglas del uego.
procedure obtener<loque$ tablero :#ipo#ablero0 posicion :#ipo&osicion0 var bloque
:#ipo.ista&osicion'
*.3 Procedimiento o&tener,lo#ue-asGrande
8ado un tablero, devuelve en bloque el bloque ms grande. Si 1a! ms de un bloque que cumpla
con esta condicin, devuelve cualquiera de estos.
procedure obtener<loque@as9rande$ tablero :#ipo#ablero0 var bloque :#ipo.ista&osicion'0
*.! Funcin puntos"Generar
8ado un bloque de posiciones a eliminar ! un tablero, devuelve la cantidad de puntos que se
generar3an si se eliminara el bloque. (o solo debe tomar en cuenta la cantidad de posiciones en el
bloque, sino tambi"n debe tener en cuenta si el tablero queda vac3o o no, pues puede
corresponder sumar el puntae e4tra.
function puntos/9enerar$ bloque :#ipo.ista&osicion0 tablero: #ipo#ablero' : ,nteger0
*.$ Procedimiento ordenar,lo#ue
Este procedimiento ordena una lista de posiciones bloque de forma creciente. Esto es, una celda
Di1, 1E es menor que Di2, 2E si $i1 G i2' o si $i1 ? i2' ! $1 G 2'. &or eemplo, la lista $D1,1E, D2,1E,
D:,5E, D:,HE, D:,IE'est ordenada.
procedure ordenar<loque$var bloque : #ipo.ista&osicion'0
*.* Procedimiento eliminar,lo#ue
8ado un bloque $o lista de posiciones de celdas a eliminar' ! un estado del uego, elimina las
celdas ! 1ace los corrimientos necesarios para que el tablero del uego sea vlido nuevamente.
7na vez que el bloque 1a sido eliminado, las fic1as ubicadas encima de "l caen para rellenar el
espacio. Si se elimina una columna entera, entonces las fic1as se desplazan 1acia la izquierda para
rellenar el espacio. Se debe sumar el puntae ganado al puntae total del usuario.
procedure eliminar<loque $ bloque :#ipo.ista&osicion0 var estado :#ipoEstado>uego'0
.. /e pide
Escribir un arc1ivo con todos los subprogramas que forman el motor del uego.
.os cabezales de los subprogramas deben coincidir e4actamente con los que aparecen en esta
letra. Si el estudiante realiza alg)n cambio se considerar que el subprograma no fue
implementado.
&r4imamente se publicar la interfaz implementada por el equipo docente, unto con
instrucciones de cmo compilar ! eecutar el programa compuesto por la interfaz ! el motor.
Se puede utilizar todo lo visto en las clases tericas ! prcticas.
&ara la correccin, las tareas se compilarn con la versin 2.2.2 para *indo*s. .a compilacin ! la
eecucin se realizarn en l3nea de comandos. El comando de compilacin se invocar de la
siguiente manera:
fpc J-o J-r J@tp programa.pas
Si trabaa con el ,8E, aseg)rese de configurarlo para que compile de la misma manera que el
comando anterior $1abilitacin de +ange -1ecKing, ,nteger Cverflo* -1ecKing ! L#urbo &ascal
-ompatibleM'.
(o est permitido utilizar facilidades de %ree &ascal que no forman parte del estndar ! no se dan
en el curso. /s3 por eemplo, no se pueden utilizar ninguna de las palabras
siguientes: uses, crlscr, goto4!,crt, readKe!, longint, string, breaK, etc"tera.
En esta tarea como en todos los problemas de este curso, se valorar adems de la lgica correcta,
la utilizacin de un buen estilo de programacin de acuerdo a los criterios impartidos en el curso.
8e esta manera, se 1ar "nfasis en buenas prcticas de programacin que lleven a un cdigo
legible, bien documentado ! mantenible, tales como:
indentacin adecuada
utilizacin correcta ! apropiada de las estructuras de control
cdigo claro ! legible
algoritmos razonablemente eficientes
utilizacin de comentarios que documenten ! complementen el cdigo
utilizacin de constantes simblicas
nombres mnemot"cnicos para variables, constantes, etc"tera.
0. "p1ndices
0.1 23meros aleatorios
En free pascal se pueden generar n)meros al azar utilizando la funcin random. Esta funcin
recibe un parmetro entero positivo ! retorna un n)mero aleatorio ma!or o igual que 0 ! menor
que el parmetro recibido.
El procedimiento randomize debe invocarse una sola vez, previamente a cualquier invocacin de la
funcin random. El )nico obetivo de esta operacin es inicializar el generador de n)meros
aleatorios.
/ continuacin se muestra un eemplo donde se generan 10 n)meros al azar entre 1 ! I, como si
fueran lanzamientos de un dado.
; inicializacin =
randomize0
for i:? 1 to 10 do
begin
; sorteo =
numero:? random$I' N 10
*riteln$numero'0
end0
#ener en cuenta que la funcin random puede repetir n)meros.
0.2 Gu4a para resol5er algunos de los pro&lemas presentados en este o&ligatorio
/lgunos algoritmos tienen compleidades algor3tmicas que requieren pensarlos con cuidado. En
este ap"ndice damos algunas sugerencias para su implementacin.
6&tener ,lo#ue
7n algoritmo posible consiste en manear dos listas de posiciones: lista de pendientes ! lista de
visitadas, aparte del bloque $o lista' que queremos obtener como resultado.
El algoritmo es el siguiente:
1. /gregar la posicin inicial a la lista de posiciones pendientes.
2. @ientras 1a!a posiciones en la lista de pendientes, procesar cada posicin de la siguiente
manera:
1. Ouitarla de la lista de pendientes
2. /gregarla a la lista de visitadas
:. /gregarla a la lista de posiciones que forma el bloque que estamos buscando
5. /gregar todas las posiciones ad!acentes, que sean del mismo tipo del bloque que
estamos armando, ! que no 1a!an sido visitadas, a la lista de pendientes para
procesarla ms tarde.
Eliminar ,lo#ue
6a! varios algoritmos que resuelven este problema. /lgunos ms eficientes que otros. 7na opcin
es:
1. @arcar todas las celdas del bloque a eliminar como vac3as,
2. @over todas las fic1as 1acia abao para cubrir los 1uecos que 1a!an quedado en las
columnas.
:. Si se generaron columnas vac3as, mover las columnas que contienen fic1as 1acia la izquierda
$respetando el orden que ten3an', ! que las columnas vac3as queden a la derec1a.
7. 8eferencias
1$ 1ttp:22librar!.gnome.org2users2s*ellJfoop22.:12s*ellJfoop.1tml
2$ 1ttp:22en.*iKipedia.org2*iKi2SameB9ame
Instrucciones para la interfaz grfica:
1. Introduccin
-on el fin de poder probar en forma interactiva los subprogramas que se piden en la tarea 2, se les
brinda el cdigo iguales.pas, al cual le faltan los subprogramas que se pide implementar.
7d. deber implementar dic1os subprogramas en el arc1ivo motor.pas. &ara que esto funcione,
dentro del arc1ivo iguales.pas se encuentra la siguiente directiva: ;$INCLUDE motor.pas=. Esto
tiene el mismo efecto que copiar ! pegar el contenido del arc1ivo motor.pas dentro
de iguales.pas en el lugar de dic1a directiva. #enga en cuenta que los subprogramas del motor.pas
publicado pueden tener instrucciones a los efectos que compile iguales.pas que no necesariamente
deben estar en la solucin implementada.
2. 8estricciones
El programa final que implemente el uego debe funcionar sin que 7d. tenga que modificar el
arc1ivo iguales.pas. #odos los subprogramas que se pide implementar en la letra de la tarea
2, as3 como cualquier funcin, procedimiento, tipo, etc. e4tra que 7d. necesite definir,
debern ser implementados en el arc1ivo motor.pas.
.as directivas, procedimientos ! funciones no estndar usadas en el arc1ivo iguales.pasfueron
utilizadas con el fin de que 7d. tenga una interfaz ms amigable. Sin embargo, como es regla
en este curso, 7d. no puede utilizar facilidades de %ree &ascal que no forman parte del
estndar ! que no se dan en el curso para implementar los subprogramas que se piden o
cualquier otro subprograma e4tra que necesite.
7d. no debe usar variable globales, toda la comunicacin con la interfaz debe ser a trav"s de
los parmetros de los subprogramas.
3. 9escripcin de la interfa+
3.1 Pantalla principal
.a interfaz se muestra en la siguiente figura:
<sicamente tiene un cabezal, un tablero ! una barra de estado:
En el cabezal est el nombre del uego ! se despliegan mensaes cuando el ugador 1a
ganado o perdido.
En el tablero se ven:
las celdas vac3as $que se representan con el caracter P.Q' o con fic1as $que se
representan con los caracteres P/Q, P<Q, P-Q o P8Q con un color distinto cada uno'.
la posicin en donde est parado el usuario $que se indica con el cursor que est
parpadeando'.
el bloque de fic1as ad!acentes del mismo tipo que la fic1a de la posicin en
donde est parado el cursor $que se resaltan con un color ms brillante'
En la barra de estado se puede ver:
la fila ! la columna donde est posicionado el usuario,
la cantidad de fic1as del bloque de fic1as ad!acentes del mismo tipo que la fic1a
de la posicin en donde est parado el usuario.
los puntos a generar por el usuario, si borra el bloque de fic1as ad!acentes del
mismo tipo que la fic1a de la posicin en donde est parado
los puntos !a generados en ugadas $o acciones' previas.
7sando las flec1as del teclado ! algunas teclas se consigue probar ! ugar.
3.2 Pantalla inicial
-uando se inicia el uego aparece la siguiente pantalla, que nos permite elegir el tamaFo del
tablero o cargar el estado del uego $nuevo o !a empezado' desde un arc1ivo.
Vladimir Rodrguez 1JF
3.3 "(uda
&or ms informacin 7d. puede ver la a!uda que trae la interfaz. &resionando la tecla L1M $de 1elp
en ingl"s' se obtiene la siguiente pantalla:
4$ ;omunicaci#n interfazAmotor
!.1 In5ocacin a iniciali+ar Juego:...;<
-uando se inicia un uego nuevo seleccionando el nivel $fcil, intermedio, dif3cil', la interfaz
invoca al procedimiento inicializar>uego$R' pasando como parmetros cierta cantidad de filas !
columnas dependiendo de cada nivel.
!.2 In5ocacin a los otros su&programas del motor
-uando el usuario se posiciona sobre una celda determinada ! presiona algunas de las teclas
correspondientes a eliminar bloque, eliminar bloque ms grande, etc., la interfaz invoca los
procedimientos ! funciones que correspondan pasando los parmetros que se necesiten, el estado
del uego !2o la posicin, dependiendo del procedimiento o funcin del motor que est" invocando.
Vladimir Rodrguez 1JJ
&or lo tanto, la comunicacin entre la interfaz ! el motor se realiza usando solo los parmetros de
los procedimientos ! las funciones definidos en el motor.pas.
$. Funcionalidades
/parte de poder ugar en forma interactiva, esta interfaz ofrece otras funcionalidades que le
permitirn encontrar ! corregir errores ms fcilmente, por eemplo:
.istar las posiciones del bloque de fic1as seleccionado que devuelve el
procedimientoobtener<loque$R'
.istar las posiciones del bloque de fic1as seleccionado que devuelve el
procedimientoobtener<loque$R', ordenadas tal cual las ordena el
procedimiento ordenar<loque$R'
Solver atrs $o des1acer' una accin.
9uardar la configuracin actual del estado del uego en un arc1ivo de te4to.
-argar la configuracin de un estado del uego desde un arc1ivo de te4to.
9uardar en un arc1ivo de te4to el 1istorial de los sucesivos estados del uego ! las acciones
que se realizaron.
*. 8ecomendaciones
*.1 Para compilar
-ree una carpeta $o directorio' donde va a trabaar, descargue los arc1ivos iguales.pas $que
contiene la interfaz' ! motor.pas $que solo contiene los encabezados de los subprogramas' !
cpielos a dic1a carpeta.
-ompile el arc1ivo iguales.pas desde la l3nea de comandos con: fpc J-o J-r J@tp iguales.pas, o
desde el ,8E teniendo abierta la ventana con el arc1ivo iguales.pas. El compilador se da cuenta
automticamente de que tiene que incluir el cdigo del arc1ivo motor.pas donde est la directiva
mencionada antes.
Esto !a va a generar una interfaz sencilla que, si bien no permite crear uegos nuevos ni realizar
acciones, s3 permite cargar arc1ivos con uegos de prueba, como se e4plica a continuacin. /
medida que implemente los procedimientos ! funciones, podr realizar ms acciones del uego.
*.2 Para pro&ar usando la interfa+
6asta que usted no implemente el procedimiento inicializar>uego$R', no va a poder generar sus
propios tableros. &ero s3 puede ir probando los otros procedimientos ! funciones, por eemplo
cargar el uego desde uno de los arc1ivo de eemplo que le proporcionamos.
/ continuacin se proporcionan algunos arc1ivos generados desde la interfaz, los cuales se pueden
cargar sin necesidad de implementar los procedimientos ! funciones del motor.
estado>uego1.t4t
estado>uego2.t4t
estado>uego:.t4t
estado>uego:Jempezado.t4t
/ continuacin se proporcionan algunos arc1ivos con 1istoriales de eemplo. .os 1istoriales
contienen la secuencia de uegos que se generan a partir de un estado inicial ! la aplicacin
sucesiva de acciones eliminar<loque o eliminar<loque@as9rande:
1istorial1.t4t
1istorial2.t4t
1istorial:.t4t
/dems 7d. puede probar los procedimientos ! funciones implementando su propia interfaz !2o
pequeFos programas para probar cada procedimiento por separado. +ecuerde que lo que 7d. debe
implementar son los procedimientos, la interfaz es simplemente una a!uda para probar ! ugar con
su implementacin del motor.pas.
Vladimir Rodrguez 1JL
Descarga del programa de prueba: +es de'o aqu el programa ya creado para que puedan probar
como funciona" as ya saben como debe de quedarles$ Bagan clicX aqu para ba'ar el arc(i)o$
GUIA PARA REALIZAR TEST DE ESTE PROGRAMA:
1. Introduccin
-omo parte de un proceso industrial, la fase de pruebas aFade valor al producto generado. #odos
los programas tienen defectos $somos 1umanos' ! la fase de pruebas a!uda a descubrirlos. Ese es
uno de los principales valores que aFade.
&robar un programa es eecutarlo con la peor intencin con el fin de encontrarle defectos.
&ara "sto se diseFan casos de prueba. 7n caso de prueba consta de:
entradas $parmetros de entrada al programa'
resultados esperados
En esta 1oa encontrarn casos de prueba de eemplo $casos de prueba bsicos' ! puntos que
deber3an tener en cuenta a la 1ora de probar.
TT /s3 que a 1incarle los dientes a esto que ser de gran a!uda para ustedesUU
2. =Cmo arman un pu++le>
En general, uno empieza por el borde, luego arma las partes ms fciles, las dif3ciles, ! siempre,
para cada parte, uno se va cerciorando que se est uniendo las piezas correctamente. .uego
untamos las partes prearmadas 1asta llegar a la figura final.
3. =Por #u1 estamos 5iendo cmo armar un pu++le>
.a idea de cmo armar un puzzle e implementar ! probar el uego iguales tiene muc1as
similitudes. El borde ! algunas partes !a estn prearmados ! testeados $iguales.pas' ! le pedimos
que armen ! testeen las partes faltantes $motor.pas' para completar el uego o LpuzzleM. &arece
una tarea fcil, VnoW
&or lo tanto para probar su tarea deben tener en cuenta : puntos de prueba ! en este orden:
1. &robar cada una de las partes armadas por ustedes por separado. C sea, cada subprograma o
procedimiento por separado.
2. &robar que las partes encaan correctamente en lo que !a est armado. C sea, que al unir los
subprogramas implementados por ustedes con los implementados por nosotros no generen
errores.
:. &robar finalmente que todas las partes unto con el borde funcionan correctamente. C sea,
nuestro puzzle es el que est en la imagen de la caa. Esto se 1ace probando desde la
interfaz. /c es dnde se pone ms divertido, es 1ora de ugar.
-omo bien dice la letra de la tarea L7d. puede probar los procedimientos implementando su
propia interfaz, !2o pequeFos programas para probar cada procedimiento por separado. +ecuerde
que lo que 7d. debe realizar son los procedimientos, la interfaz es simplemente una a!uda para
probar ! ugar con su motor.M
!. Indicaciones ( pautas a seguir para las prue&as
!.1 Pro&ar por separado los su&programas
&rueben todos los procedimientos por separado. Esta t"cnica les ser de gran a!uda al momento
de 1acer la prueba desde la interfaz. Es decir, disminuir significativamente la cantidad de errores
que encontrarn ! su gravedad. &ueden armarse un programa principal au4iliar que simplemente
Vladimir Rodrguez 1JI
1aga la llamada al procedimiento bao prueba ! luego imprima el resultado en pantalla para que
puedan verificar la correctitud de su resultado.
/ modo de eemplo se presentan los siguientes programas:
&rueba,nicializar>uego.pas
&ruebaCbtener<loque.pas
que sirven para probar en forma independiente los procedimientos incializar>uego !
obtener<loque. +ecomendamos que armen programas similares para probar el resto de los
subprogramas por separado.
!.2 Pautas para los casos de prue&a
+ecomendamos que piensen los casos de pruebas antes de empezar a probar ! que anoten sus
ideas. +ecuerden que un caso de prueba se puede decir que est formado por entradas $en este
caso, parmetros del procedimiento', un resultado esperado ! un resultado obtenido. /dems se
puede agregar una descripcin para entender rpidamente qu" se est atacando.
.a idea es que prueben lo que se les sugiere abao. Si tienen algunas ideas ms, no las descarten,
)senlas para probar, incluso en combinacin con estas.
iniciali+arJuego
8iferentes dimensiones de tableros, c1icos, medianos, grandes
-asos l3mites en las dimensiones: m4imo tablero $@/AB%,./S X @/AB-C.7@(/S', m3nimo
tablero $1 4 1'
Serificar que el uego no est finalizado
Serificar que el puntae es cero
Serificar que las fic1as se distribu!en aleatoriamente sobre el tablero
o&tener,lo#ue
8iferentes ubicaciones de la posicin: en el centro del tablero, en el borde derec1o, en el
borde izquierdo, en el borde superior, en el borde inferior
8iferentes fic1as en la celda de la posicin: con fic1a /, <, -, 8, vac3a
8iferentes ad!acentes a la celda de la posicin: con ad!acentes a la derec1a, a la izquierda,
arriba, ! abao
Sin ad!acentes
o&tener,lo#ue-asGrande
8iferentes estados, situaciones, posiciones $como en el caso anterior'
&robar con un tablero con solo bloques unitarios
&robar con un tablero lleno de fic1as del mismo color $el bloque es todo el tablero'
&robar con un tablero con bloques del mismo tamaFo
puntos"Generar
Siendo n la cantidad de fic1as en el bloque:
&robar cuando el resultado es 0 puntos $n?0, n?1, o n?2'
&robar para nY2
&robar para un n grande
ordenar,lo#ue
Crdenar un bloque de tamaFoY1
Crdenar un bloque de tamaFo 1
Crdenar un bloque de tamaFo cero
Crdenar un bloque que abarque todo el tablero
eliminar,lo#ue
Eliminar un bloque del centro del tablero
Vladimir Rodrguez 1JP
Eliminar un bloque que provoque uno o varios desplazamientos de columnas.
Eliminar un bloque de tamaFo 1 $esto no deber3a tener efecto'
Eliminar un bloque que abarque todo el tablero
!.3 Integrar el motor.pas con iguales.pas
/dems de manear bien las estructuras !a definidas, deben estar seguros que los datos que les
llegan son los esperados por ustedes ! los datos que devuelven son los esperados por la interfaz. En
otras palabras deben verificar que estn tomando correctamente los datos que les pasan por
parmetro ! devolvi"ndolos correctamente tambi"n.
!.! En el uego' desde la interfa+
Esta es la )ltima. Si 1icieron bien las pruebas anteriores no deber3an tener muc1os errores en esta
etapa. .es sugerimos que para esta parte lo que ms deben 1acer es ugar. +ecuerden que la
intencin debe ser encontrar fallas ! no salterselas. .o meor es enfocarse en buscar cierto tipo
de errores durante varias partidas seguidas. &iensen que tienen una misin, encontrar defectos,
entonces por varias partidas ponen el foco en buscar ciertos defectos, por eemplo, eliminar
bloques ! verificar que las dems fic1as se desplazan correctamente. Es importante que se
guarden los 1istoriales de cada partida$X', as3 cuando ocurre una falla, pueden reproducirla. Esto
les servir al momento de verificar que 1a!an arreglado el defecto. .es podr ser )til anotar en
una planilla la correspondencia entre los errores ! los arc1ivos de 1istorial. En las misiones,
pueden intercalar los distintos niveles de tablero de la interfaz, o alguno armado por ustedes.
$X' +ecuerde que la interfaz proporcionada por los docentes, le permite guardar ! cargar desde un
arc1ivo de te4to el estado de un uego $reci"n iniciado, o !a comenzado'. #ambi"n se puede
guardar en un arc1ivo de te4to el 1istorial de los estados por los que pas el uego ! las acciones
que se realizaron.
$. Indicaciones 3tiles
-uando utilicen casos de prueba
Eecuten todos los casos de prueba ! anoten sus resultados antes de comenzar la revisin de
los que fallaron. Esto les facilitar el trabao.
/ la 1ora de empezar la revisin de los casos que fallaron. Se puede seguir estos pasos:
+evisar la formulacin del caso de prueba. &uede que est" mal el caso ! no sea el
programa.
Si el caso de prueba es correcto, se pasa a detectar qu" parte del cdigo est
generando la falla. Esto lo pueden 1acer debugueando por eemplo.
-uando 1a!an arreglado todos los errores, eecuten los casos de prueba que en un principio
no fallaron. Esto es para asegurarse que los cambios 1ec1os no introdueron errores en lo que
andaba bien.
/lgunas indicaciones ms para cuando prueben desde la interfaz:
/l igual que con los casos de prueba, eecuten varias misiones, las que ustedes crean
convenientes, antes de empezar a corregir los errores.
*. Conceptos de testing maneados en esta gu4a
#esting 7nitario $probar cada parte por separado'
#esting de ,ntegracin $probar cmo encaan las partes entre s3'
#esting de Sistema o -aa (egra $probar que el puzzle armado es igual al de la imagen en la
caa'
Vladimir Rodrguez 1LE
Despedida y Agradecimientos:
Basta aqu (emos llegado con este manual" de )erdad espero que les (aya ser)ido para algo as como esperar,
sus correos para preguntar" corregir" sugerir y dem&s$ +a creaci#n de este documento est& inspirada en el
agradecimiento a todos aquellos que al igual que yo (an decidido utilizar su tiempo para ayudar a quienes buscan
informaci#n en la /eb" una ayuda sin fines de lucro sino m&s bien todo lo contrario" una ayuda sin la cual yo (oy no
sabra nada$ Duc(as gracias a todos ellos" muc(as gracias a quienes publiquen y difundan este manual" a todas
aquellas p&ginas /eb que permitan su descarga gratuita" a todos quienes se tomen enserio este curso y aprendan
realmente$
?o es una despedida para siempre porque continuar, con m&s manuales" manuales para los cuales asumir,
que ya (an ledo este$ En la segunda entrega" como ya di'e" abordaremos el lengua'e DO%0+.A2 el cual sigue siendo
1.5;.+ pero orientado a la modularizaci#n$ ;on dic(o lengua'e aprenderemos a crear programas separados por
m#dulos indi)iduales" lo cual nos da infinitas posibilidadesM abordaremos la recursi#n como (erramienta y sin la cual
no podr&n solucionar muc(os problemas" adem&s de que les pro)eer& del poder de realizar tar,as que de otro modo
seran imposiblesM abordaremos estructuras como las de &rboles" colas y otras tantas usadas en muc(os tipos de
programasM aprender&n acerca del dise!o de -.% :-ipos .bstractos de %atos< entre muc(as otras cosas$ +os
programas seguir&n siendo )istosamente (orribles pero potencialmente competentes" lo cual es lo m&s importante"
porque de nada sir)e saber crear (ermosas interfaces gr&ficas si nuestros programas no saben traba'ar$
Estoy pensando tambi,n crear un anexo a este manual" no para aprender conceptos nue)os" sino para traducir
estos conceptos a un lengua'e moderno como Ca)a" a modo de incenti)o$ El aprendiza'e seguir& orientado a la
segunda entrega de este tutorial" por lo cual lo otro es un simple agregado a este" pero an lo estoy pensando ya que
Ca)a obliga a aprender conceptos de la programaci#n orientada a ob'etos y an no (emos traba'ado con ello en
absoluto$
Babiendo ledo todo este manual cualquiera de ustedes debera poder iniciarse en otro lengua'e si leen
manuales de ,l" podr&n al menos (acer casi las mismas cosas que (asta a(ora pero tal )ez con un modo de traba'o
muc(o me'or y un tanto m&s sencillo$ 5in embargo esperar, que lean la pr#xima entrega" la cual espero est, lista para
mediados de este a!o" o sea" Cunio o Culio de 2E11$
>racias nue)amente a todos los que me (an ledo" a todos los que me escribir&n y a todos quienes decidan
aportar algo m&s a esto$ Estar, a su disposici#n siempre que necesiten ayuda y tambi,n para recibirla ya que yo
tambi,n estoy aprendiendo" reci,n ingresando a este mundo tan comple'o y tan interesante$ >racias a todos y a todas$
0n cordial saludo de su amigo Vladimir Rodrguez$ Ba sido un gusto escribir esto y" aunque me (a lle)ado su
tiempo" (oy me siento feliz de poder mostrarlo$ >racias$
Vladimir Rodrguez 1L1
INDICE DE CONTENIDO
PRIMERA PARTE
Conceptos bsicos de programacin
Kntroducci#n 4
?ociones sobre +engua'e de 1rogramaci#n F
Knstalando el ambiente de desarrollo GreeA1ascal J
Verificando Knstalaci#n I
;orrigiendo ug y configurando para comenzar P
;onfiguraci#n Range ;(ecXing e Knteger O)erflo/ 1E
?0E5-RO 1RKDER 1RO>R.D.2 RRRBO+. D0?%OSSS 11
Write y Writeln 13
Kntroducci#n a las )ariables 14
E'emplo de asignaci#n 1F
+eer m&s de una )ariable a la )ez 1F
E'ercicio 1J
Kntroducci#n a la compatibilidad de tipos 1L
Errores en tiempo de E'ecuci#n y errores en tiempo de ;ompilaci#n 1I
1alabras reser)adas 1P
Kdentificadores 2E
-ipos de datos 2E
Operadores en pascal 2E
1recedencia de operadores 21
Gunciones matem&ticas de pascal 21
0n e'emplo del uso de %KV y DO%$ Kntroducci#n a los comentarios 22
Kntroducci#n a las constantes 23
ooleanos 2J
.lgunas notas 2J
E'ercicios 2J
SEGUNDA PARTE
Seleccin y Repeticin
Kntroducci#n 2I
5elecci#n$ Knstrucci#n KG$$$-BE? e KG$$$-BE?$$$E+5E 2P
.nidaci#n de la instrucci#n Kf$$$t(en 3E
.nidaci#n de un if$$$t(en con un if$$$t(en$$$else 3E
;ondiciones compuestas 32
-ablas de )erdad 32
Operadores relacionales 33
0n e'emplo matem&tico 33
Knstrucci#n de selecci#n ;.5E$$$E+5E 3J
E'ercicio 3I
5ecuencia de repetici#n GOR 3P
.nidaci#n de GOR 4E
E'ercicios 41
%E0>ER 43
5ecuencia de repetici#n WBK+E$$$%O 44
0n peque!o 'uego 4J
>enerar nmeros aleatorios 4L
5ecuencia de repetici#n RE1E.-$$$0?-K+ 4I
;entinela 4I
E'ercicio 4P
0n e'emplo m&s comple'o$ ;ontador de palabras 4P
E'emplo de captura de error 4P
-abla .scii FE
E'ercicios F1
TERCERA PARTE
Introduccin a los TIPOS definidos por el programador
Subrangos y Arreglos
Kntroducci#n F4
5ubrangos FF
.rreglos FJ
%eclaraci#n FJ
0tilizaci#n de arreglos FL
Bacer WRK-E y RE.% de un arreglo FP
E'ercicios FP
%eclaraci#n an#nima de una arreglo JE
Recorriendo arreglos JE
squeda de un elemento J2
E'ercicios J3
.rreglos multidimensionales JF
.rreglos bidimensionales JF
E'ercicios JJ
.rreglos tridimensionales JL
RE.+Ka.?%O 0? 1RO=E;-O2 D.5-ER DK?% JI
CUARTA PARTE
SUBPROGRAMAS: Procedimientos y Funciones
Kntroducci#n L2
1rocedimientos L3
%eclaraci#n y llamado L3
Variables >lobales y +ocales$ Kntroducci#n al .lcance de Kdentificadores LJ
5ombreado de Kdentificadores LP
1ar&metros2 1asa'e por Valor IE
%eclaraci#n de par&metros de tipos diferentes I2
.signaciones de par&metros I3
1ar&metros ?ominales y par&metros Efecti)os I3
Gunciones I4
%eclaraci#n y llamado I4
Gunciones ooleanas IF
+lamar a un subprograma desde otro subprograma IL
1ar&metros2 1asa'e por Referencia II
E'ercicios P3
QUINTA PARTE
Enumerados
Registros con y sin variante
Arreglo con tope
Kntroducci#n 1EE
Enumerados 1E1
Read y Write con enumerados 1E2
;omparaciones con enumerados 1E2
E'ercicios 1EF
Registros 1EL
%eclaraci#n 1EL
0na estructura comple'a 1EP
E'ercicios 1EP
.5E %E 1RO%0;-O5A1arte 1 11E
+impiar la pantalla 11L
+a funci#n WK-B$$$%O 11I
.mbigkedad con WK-B$$$%O 11P
Registro con )ariante 12E
.rreglo con tope 123
E'ercicios 124
.5E %E 1RO%0;-O5A1arte 2 13E
SEXTA PARTE
Memoria Dinmica: El tipo Puntero
Listas Encadenadas Simples
Kntroducci#n 13I
El tipo 1untero 13P
%eclaraci#n 13P
El procedimiento ?EW y el operador j 13P
El procedimiento %K51O5E 142
El puntero nulo" la constante ?K+ 144
E'ercicios 14F
+istas encadenadas simples 14I
+ista )aca 1F1
Gin de lista 1F1
+argo de una lista 1F3
squeda de un elemento 1F3
.gregar un elemento al principio 1F3
.gregar elemento al final 1F4
orrar el primer elemento de una lista no )aca 1F4
orrar una lista completa 1F4
E'ercicios 1FF
.5E %E 1RO%0;-O5A1arte 3 1FJ
UN ULTIMO PROYECTO
+etra 1FL
Knstrucciones para la interfaz gr&fica 1J4
%escarga del programa de prueba 1JI
>ua para realizar el test de este programa 1JI
DESPEDIDA Y AGRADECIMIENTOS 1L1
Vladimir Rodrguez 1LF
Vladimir Rodrguez 1LJ

Manual de Pascal

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Manual de Pascal

Uploaded by

Copyright:

Available Formats

Programacin estructurada en Pascal

You might also like