programacion

PASCAL
Algoritmos: descripción y notación algorítmica
Introducción
El objetivo primordial de la asignatura es proporcionarle al alumno los conocimientos que le
permitan diseñar algoritmos propios para la resolución de problemas matemáticos, parte de tales
conocimientos versarán sobre uno o más lenguajes de programación para describir dichos
algoritmos así como técnicas para desarrollar programas eficientes y comprensibles.
Sin embargo, el objetivo de esta asignatura no es “programar computadores” propiamente tal, por
lo que aquellos alumnos que no tengan experiencia en el manejo de computadores no deben
preocuparse, los contenidos de la asignatura se proporcionarán de forma gradual y dando por
supuesto que los alumnos nunca han aprendido un lenguaje de programación. Aquellos alumnos
que conozcan algún lenguaje tienen ciertas ventajas pero también inconvenientes al tener que
luchar contra “vicios” adquiridos.
Aproximación intuitiva a los algoritmos
Como ya se ha dicho, un lenguaje de programación no es más que una forma de representar un
algoritmo, así pues, ¿qué es un algoritmo? Antes de proporcionar una definición precisa del
término daremos un pequeño rodeo puesto que los algoritmos han acompañado a la humanidad
desde hace mucho tiempo, con la salvedad de que la mayor parte eran dados por supuesto o bien
se les denominaba con términos diferentes. A continuación se muestran algunos ejemplos clásicos.
Algoritmo: Instrucciones para subir una escalera
[...] Las escaleras se suben de frente, pues hacia atrás o de costado resultan particularmente
incómodas. La actitud natural consiste en mantenerse de pie, los brazos colgando sin esfuerzo, la
cabeza erguida aunque no tanto que los ojos dejen de ver los peldaños inmediatamente superiores
al que se pisa, y respirando lenta y regularmente. Para subir una escalera se comienza por levantar
esa parte del cuerpo situada a la derecha abajo, envuelta casi siempre en cuero o gamuza, y que
salvo excepciones cabe exactamente en el escalón. Puesta en el primer peldaño dicha parte, que
para abreviar llamaremos pie, se recoge la parte equivalente de la izquierda (también llamada pie,
pero que no ha de confundirse con el pie antes citado), y llevándola a la altura del pie, se le hace
seguir hasta colocarla en el segundo peldaño, con lo cual en éste descansará el pie, y en el
primero descansará el pie. (Los primeros peldaños son siempre los más difíciles, hasta adquirir la
coordinación necesaria. La coincidencia de nombre entre el pie y el pie hace difícil la explicación.
Cuídese especialmente de no levantar al mismo tiempo el pie y el pie).
Llegando en esta forma al segundo peldaño, basta repetir alternadamente los movimientos hasta
encontrarse con el final de la escalera. Se sale de ella fácilmente, con un ligero golpe de talón que
la fija en su sitio, del que no se moverá hasta el momento del descenso
Julio Cortázar (Historias de Cronopios y de Famas).

Algoritmo: Tortilla de papas
Ingredientes:
2 vasos (de los de agua) de aceite (1/2 litro)
sal
8 huevos
1 kg de papas
Se lavan las papas una vez peladas, y se secan con un paño; se parten en dos a lo largo y
después se cortan en láminas finitas. Se pone el aceite en la sartén a calentar y se fríen,
moviéndolas de vez en cuando y echándoles un poco de sal. Una vez fritas (más o menos doradas,
según gusten), se separan y se ponen a escurrir en un colador grande. Se quita el aceite sobrante
de la sartén. Aparte se baten los huevos con tenedor y muy fuerte; se pone un poco de sal; en el
mismo plato de los huevos se echan las papas y se mueven con un tenedor. En una sartén grande
(o en dos pequeñas) se ponen 3 cucharadas soperas de aceite para que sólo cubra el fondo.
Cuando está caliente se vierte la mezcla de huevos y papas. Se mueve la sartén por el mango para
que no se pegue la tortilla. Cuando se vea que está bien despegada y dorada (esto depende del
gusto de cada cual), se pone una tapadera encima, se vuelca la sartén y se escurre suavemente la
tortilla otra vez en la sartén. Se vuelve a mover por el mango y cuando esté cuajada (a gusto) se
pasa a una fuente redonda y se sirve.
Simone Ortega (1080 recetas de cocina).
Algoritmo: Multiplicación de números enteros
Para obtener el producto de dos números enteros utilizando lápiz y papel se debe escribir el primer
factor (multiplicando) y, justo debajo y alineado a la derecha, el segundo factor (multiplicador).
Se recorren todas las cifras del multiplicador de derecha a izquierda y se operan con cada una de
las cifras el multiplicando, también de derecha a izquierda, escribiendo los resultados intermedios
en líneas separadas; cada línea estará desplazada una posición a la izquierda respecto a la línea
inmediatamente superior.
Una vez se han obtenido todos los resultados intermedios se suman columna a columna
obteniéndose el resultado final.

Algoritmos: descripción y notación algorítmica
Si se estudia con atención cada uno de los algoritmos anteriores descubriremos una serie de
características interesantes que definen la naturaleza de lo que es un algoritmo:
Un algoritmo resuelve un problema específico: subir una escalera, obtener una tortilla de papas
o hacer una multiplicación.
Un algoritmo es llevado a cabo por una entidad que trabaja en un entorno dado: una persona
cuyo universo inmediato se reduce a su propio cuerpo y una escalera; un cocinero con una sartén,
huevos, papas, aceite, sal y cebolla; o un niño con lápiz y papel.
Un algoritmo consta de una serie de pasos que deben llevarse a cabo siguiendo una
secuencia marcada: algunos de los pasos en uno de los algoritmos anteriores serían: dar la vuelta
a la tortilla, batir los huevos, pelar las papas o romper los huevos; dichos pasos deben aplicarse en
un orden prefijado y no de cualquier manera.
Un algoritmo se aplica de forma mecánica: un algoritmo no precisa decisiones subjetivas ni
creatividad en su aplicación, cualquiera con una receta adecuada para obtener tortilla de papas
logrará una tortilla de papas. Sin embargo, sí es necesario un acto creativo para desarrollar un
nuevo algoritmo.
Un algoritmo termina en un tiempo finito: todos los algoritmos deben finalizar, pueden tardar
más o menos tiempo en lograr un resultado pero dicho tiempo debe ser finito.
Definición de algoritmo. Etimología del término algoritmo
En resumen,
Un algoritmo es una secuencia de pasos que es llevado a cabo de forma mecánica y sistemática
por un actor que se desenvuelve en un entorno dado para resolver un problema determinado en un
tiempo finito.
Esa podría ser una definición válida de algoritmo, otra posible definición sería la siguiente:
Un algoritmo es una combinación de instrucciones combinadas de forma adecuada para resolver
un determinado problema en una cantidad finita de tiempo. Cada instrucción es una indicación
sencilla y no ambigua.
En estos momentos, el alumno debería tener bastante claro qué es un algoritmo, en qué consiste y
dar ejemplos de algoritmos; también es probable que se esté preguntando de dónde procede el
mismo término,
“ALGORITMO”, ¿por qué denominamos “algoritmos” a los algoritmos y no “recetas” o
“combinaciones de indicaciones sencillas y no ambiguas...”?
El término proviene de Mahommad ibn Musa al-Khowârizmî (Mahommed, hijo de Musa, natural de
Kharizm), matemático persa del siglo IX; las matemáticas le deben la introducción del sistema de
numeración actual y del álgebra.
En su libro De numero indiorum (Sobre los números hindúes) proporciona las reglas para realizar
las operaciones aritméticas (con los nuevos números, por supuesto), dichas reglas se denominaron
“reglas de al-Khowârizmî” y, por deformación “algoritmos”, haciéndose extensivo el término a
cualquier conjunto de reglas para resolver un problema determinado.

Máquinas para aplicar algoritmos
El hombre siempre ha deseado tener herramientas que le ayudaran a efectuar cálculos precisos y
rápidos; aunque los actuales computadores electrónicos tienen una historia relativamente corta
(apenas medio siglo) son muchos los precedentes mecánicos y electromecánicos que han
aparecido a lo largo de la historia.
Algunos de los hitos más interesantes serían los siguientes:
• 3000 A.C: Ábaco de arena (Oriente medio).
• 1274: Ramón Llull ideó dispositivos mecánicos para realizar demostraciones lógicas.
• 1500: Leonardo DaVinci diseño máquinas de calcular mecánicas.
• 1624: Wilhelm Schickard desarrolló una calculadora con cuatro operaciones básicas.
• 1642: Blaise Pascal creó la “Máquina Aritmética” que permitía realizar sumas.
• 1671: Gottfried Leibniz construyó una calculadora mecánica que permitía sumar, restar,
multiplicar, dividir y calcular raíces cuadradas.
• 1830: Charles Babbage diseño y desarrolló la primera computadora de uso general, la
“Máquina Analítica”;
dicha máquina funcionaría impulsada mediante vapor y, aunque nunca llegó a ser construída4, Ada
Lovelace (hija del poeta Lord Byron y colaboradora de Babbage) se convirtió en la primera
“programadora” del mundo al escribir programas para dicha máquina; el primero de ellos permitiría
calcular la serie de Bernoulli.
A finales del siglo XIX se comenzaron a aplicar nuevas técnicas como las tarjetas perforadas
(inicialmente utilizadas para controlar telares) y la electricidad en el desarrollo de máquinas
precursoras de los computadores; durante la segunda guerra mundial se dio un impulso definitivo
hacia el desarrollo de los mismos y se estableció una arquitectura que aún hoy perdura; la
revolución iniciada por el transistor y, posteriormente, por el chip condujeron a la actual explosión
informática.
Elementos participantes en la realización de un algoritmo
Al mencionar las características fundamentales de los algoritmos decíamos que un algoritmo es
llevado a cabo por una entidad que trabaja en un entorno dado. En los ejemplos anteriores la
entidad era un ser humano y el entorno era el propio entorno físico que le rodeaba; sin embargo,
en esta asignatura los algoritmos que nos interesan no van a ser aplicados por un individuo (no
sería práctico ni eficiente) sino por un instrumento mecánico. Así, de cara a una descripción
“aséptica” de los algoritmos se emplearán los siguientes términos para referirnos a los elementos
que participan en un algoritmo:
• Procesador: un procesador es un ente que es capaz de entender los pasos (acciones)
que componen el algoritmo y llevarlos a cabo (ejecutarlos).
• Entorno: es el conjunto de materiales necesarios para la ejecución del algoritmo.
• Acción: es un suceso, llevado a cabo por el procesador, que modifica el entorno.
William Gibson y Bruce Sterling escribieron una novela de ciencia ficción, The Difference Engine
(La máquina diferencial), en la que las máquinas de Babbage llegan a ser construidas en la época
victoriana de tal manera que Inglaterra entra de forma simultánea en la Revolución Industrial y la
Revolución de la Información.

Al aplicar estos conceptos al algoritmo de la tortilla de patatas podemos ver que el procesador es el
cocinero, el entorno son los ingredientes (huevos, papas, cebolla) y las acciones cada uno de los
actos que se aplican sobre los ingredientes (romper, batir, pelar, trocear, salar, freir, etc).
Si, en cambio, se aplican a un algoritmo que se vaya a ejecutar en un computador tenemos que el
procesador es el computador, el entorno son los datos con los que va a trabajar y las acciones
serían todas aquellas operaciones que el computador puede realizar sobre los datos (sumar,
restar, comparar, etc).
Formas de describir un algoritmo
Dado que los algoritmos permiten resolver problemas de forma mecánica, está claro que resulta
muy interesante compartir dicho algoritmo de tal manera que otras personas puedan conocerlo y
aplicarlo; así surge el problema de describir los algoritmos de forma tal que todas las
características que los definen se mantengan invariables.
Lenguaje natural
La primera y más sencilla forma de describir un algoritmo es empleando el lenguaje natural; por
ejemplo, el algoritmo para encontrar las raíces de una ecuación de segundo grado podría
describirse así:
1. Definir los coeficientes de la ecuación de segundo grado: a, b y c.
2. Determinar el valor del discriminante: b2-4ac.
3. Si el discriminante es cero sólo hay una solución: -b/(2a).
4. Si el discriminante es positivo pero no cero hay dos soluciones: (-b콀discr)/(2a).
5. Si el discriminante es negativo no hay soluciones reales.
La ventaja fundamental es la facilidad de comprensión, cualquier persona (hispanoparlante, por
supuesto) que lea dicho algoritmo podría entenderlo y aplicarlo; sin embargo, son varios los
problemas que plantea describir un algoritmo de esta forma:
• El lenguaje natural no es universal, este algoritmo sería completamente inútil para los no
hispanoparlantes.
• El lenguaje natural es ambiguo y, por tanto, susceptible de errores.
• El lenguaje natural es demasiado amplio, lo que para una persona puede ser una
instrucción sencilla puede no serlo para otra y desde luego no lo será para un computador.
Por todo ello, se han buscado nuevas formas de describir los algoritmos que, cuando menos, sean
más universales, estén mejor delimitadas y no sean ambiguas; dos técnicas que logran esto son
los organigramas y las notaciones en pseudocódigo.

Organigramas (Diagramas de Flujo)
Los organigramas o diagramas de flujo permiten describir los algoritmos de forma gráfica; para ello
utilizan una serie de bloques que indican distintas circunstancias y flechas que muestran bajo qué
condiciones se pasa de un bloque a otro.
Algunos de los símbolos son los siguientes:
Terminal Punto de comienzo o final de un programa.
Entrada/Salida Información introducida para su proceso o generada como resultado.
Decisión Operación que determina varios caminos alternativos a seguir.
Proceso Cualquier proceso distinto de la E/S o las decisiones.
Los organigramas presentan varias ventajas frente al lenguaje natural:
• Los símbolos son universales.
• Son menos propensos a la ambigüedad.
• Por estar basados en un número pequeño de bloques y reglas para su empleo permiten
delimitar mejor los algoritmos.
• Se aproximan más a la forma en que trabaja el computador.
Sin embargo:
• El hecho de emplear símbolos supone que una persona que desconozca los símbolos
puede tener dificultades para comprender el algoritmo o no entenderlo en absoluto.
• Aunque los símbolos son universales el texto que se coloca en su interior sigue siendo
lenguaje natural.
• La representación gráfica puede resultar bastante tediosa y en el caso de algoritmos
complejos
• extremadamente confusa.
• Un computador no es capaz de utilizar una representación visual como descripción de un
algoritmo.
Actualmente, los organigramas no son muy utilizados aunque para mostrar el funcionamiento de
algoritmos sencillos siguen siendo resultando prácticos.

Pseudolenguaje y/o Pseudocódigo
El pseudolenguaje y/o pseudocódigo pretende aunar en un solo tipo de representación las ventajas
del lenguaje natural y de los organigramas sin ninguno de sus problemas; por tanto, el
pseudocódigo:
• Es fácilmente comprensible para una persona que lo vea por vez primera.
• Está bien delimitado.
• Elimina las ambigüedades del lenguaje natural.
• Se representa de una forma compacta.
De esta forma, el pseudocódigo se suele ver como un subconjunto de un lenguaje natural que
proporciona un número limitado de operaciones para la construcción de algoritmos; la única
finalidad del pseudocódigo (como de los organigramas) es la comunicación entre seres humanos.
A continuación se muestra un ejemplo de algoritmo descrito mediante un pseudolenguaje:
COMENZAR
ESCRIBIR
Deme los coeficientes y resolveré una ecuación de 2º grado
ESCRIBIR
¿Cuánto vale A?
LEER
a
ESCRIBIR
¿Cuánto vale B?
LEER
b
ESCRIBIR
¿Cuánto vale C?
LEER
c
discr ! b2-4ac
ESCRIBIR
No hay soluciones
reales
discr = 0
s ! -b/(2a) ESCRIBIR
Sólo hay una
solución, s
SI
NO
discr > 0 s1 ! (-b+vdiscr)/(2a)
s2 ! (-b-vdiscr)/(2a)
ESCRIBIR
Las soluciones son,
s1, s2
SI
NO
FIN
A continuación se muestra el mismo ejemplo de algoritmo descrito mediante un
pseudocódigo:
escribir ‘Deme los coeficientes y resolveré una ecuación de 2º grado’
escribir ‘¿Cuánto vale A?’

leer a
escribir ‘¿Cuánto vale B?’
leer b
escribir ‘¿Cuánto vale C?’
leer c
discr ! b2-4ac
si discr=0 entonces
s ! -b/(2a)
escribir ‘Sólo hay una solución:’, s
si no
si discr>0 entonces
s1 ! (-b+vdiscr)/(2a)
s2 ! (-b-vdiscr)/(2a)
escribir ‘Las soluciones son:’, s1, s2
si no
escribir ‘No hay soluciones reales.’
fin_si
fin_si
Lenguajes de programación
Un lenguaje de programación comparte las mismas características que el pseudocódigo pero,
además de ser comprensible para un ser humano, resulta comprensible para un computador; esto
es, un algoritmo descrito mediante un lenguaje de programación puede ser ejecutado por una
máquina.
A continuación se muestra el algoritmo anterior descrito en el lenguaje de programación PASCAL:
program segundoGrado
Var a,b,c : Integer ;
Begin
writeln *,'Deme los coeficientes y resolveré una ecuación de 2º grado'
writeln *, '¿Cuánto vale A?'
readln *, a
writeln *, '¿Cuánto vale B?'
readln *, b
writeln *, '¿Cuánto vale C?'
readln *, c
discr = b*b-4*a*c
if (discr==0) then
s = -b/(2*a)
writeln *, 'Sólo hay una solución: ', s
else
if (discr>0) then
s1 = (-b+sqrt(discr))/(2*a)
s2 = (-b-sqrt(discr))/(2*a)
writeln *, 'Las soluciones son: ',s1,s2
else
writeln *, 'No hay soluciones reales'
end if
end if
end
Como se puede ver, existen muchas similitudes entre el pseudocódigo y un lenguaje de
programación como PASCAL, de hecho la mayor parte de lenguajes de programación modernos

resultan bastante inteligibles con unos conocimientos básicos de inglés; sin embargo, aunque
ahora sea difícil de apreciar, el pseudocódigo aún es un lenguaje demasiado ambiguo y poco
preciso para un computador.
Desarrollo e implementación de un algoritmo
A la hora de resolver un problema mediante la utilización de un computador no se codifica
directamente un programa en un lenguaje dado; aún cuando los lenguajes de programación son
inteligibles para los humanos están bastante alejados de nuestra forma de pensar y si el problema
es complejo resulta muy difícil, por no decir imposible, escribir un programa en un solo paso.
Por esa razón, existen toda una serie de fases por las que es necesario pasar desde que se
plantea un problema hasta que se obtiene un programa de computador que lo resuelve; la finalidad
fundamental de esta asignatura no es convertir a los alumnos en expertos en el tema pero es
necesario que conozcan unos aspectos metodológicos mínimos de cara a desarrollar su trabajo
con computadores de una forma eficaz (y más agradable). En una primera fase, análisis, se estudia
el problema a resolver: qué datos precisan ser introducidos para obtener la solución, en qué
consistirá dicha solución, qué errores puede presentar, etc. En caso de disponerse de más
información relativa al problema, por ejemplo cualquier tipo de fórmula o expresión matemática
también se incluiría como información de análisis. Un aspecto importante es que durante el análisis
no se busca una forma de resolver el problema, tan sólo se trata de comprender la naturaleza del
mismo; una forma práctica de enfocar el análisis es dividiéndolo, a su vez, en fases de entrada,
proceso, salida y condiciones erróneas.
En una segunda fase, diseño, se busca una forma de resolver el problema, es decir, un algoritmo;
para ello puede emplearse la técnica de “diseño descendente”. El diseño descendente se basa en
el principio de “divide y vencerás” (Del latín “divide et impera”, aunque generalmente atribuida a César es una
máxima romana abrazada por personajes como Maquiavelo, Luis XI de Francia o Montesquieu.); este método consiste
en resolver el problema mediante una aproximación con distintos niveles de abstracción, nunca se
debe atacar desde el principio con un enfoque excesivamente detallado (muy próximo al
computador).
En primer lugar se plantea el problema empleando términos del mismo problema (nivel de
abstracción 1). En segundo lugar, se descompone en varios subproblemas expresados también en
términos del problema y tratando de hacerlos lo más independientes entre sí que sea posible.
Este paso se repite para cada subproblema tantas veces como sea necesario hasta llegar a una
descripción del problema que emplee instrucciones sencillas que puedan ser transformadas de
forma sencilla a código en un lenguaje de programación.
En la fase de diseño pueden emplearse gráficos en forma de árbol para representar los
subproblemas y las relaciones entre ellos y pseudocódigo para la descripción “formal” de la forma
de resolver cada subproblema.
A continuación se mostrará un ejemplo de análisis y diseño para un problema dado.
Enunciado: Proporcionar un algoritmo que determine si un año indicado por el usuario es bisiesto.
Entrada: El usuario debería introducir un año, un año es un número entero positivo.
Proceso: Un año es bisiesto si es múltiplo de 4 pero no de 100, la excepción son los años múltiplos
de 400.
Salida: Hay dos posibles salidas: “El año es bisiesto” y “El año no es bisiesto”.

Análisis:
Condiciones de error: Si el dato introducido no es válido (número negativo o cero) debería
indicarse: “Dato no válido.”
Nivel 1 Determinar si un año indicado por el usuario es o no un año bisiesto.
2.1. Solicitar un año al usuario.
2.2. Determinar si el año es bisiesto o no.
Nivel 2
2.3. Indicar al usuario el resultado obtenido.
Nivel 3 2.1.1. Dar un mensaje al usuario solicitando un año.
2.1.2. Leer el año.
2.1.3. Si el año no es válido indicárselo al usuario.
2.2.1. Si el año no es múltiplo de 4 no es bisiesto.
2.2.2. Si el año es múltiplo de 4 pero no de 100 es bisiesto.
2.2.3. Si el año es múltiplo de 400 es bisiesto.
Diseño
2.3.1. Si el año es bisiesto dar el mensaje “El año es bisiesto”.
2.3.2. Si el año no es bisiesto dar el mensaje “El año no es bisiesto”.
Si el problema es muy sencillo puede realizarse un organigrama que describa el algoritmo que lo
resuelve, en caso contrario es preferible utilizar un pseudocódigo; es necesario decir que el
pseudocódigo también se desarrollar por niveles, de hecho, por cada caja/problema anterior
debería obtenerse un pseudocódigo que lo resuelva.
Problema Pseudocódigo del algoritmo que lo resuelve
Determinar si un año indicado por el usuario es o no un año bisiesto. Solicitar un año al usuario
Determinar si el año es bisiesto o no
Indicar al usuario el resultado obtenido
Solicitar un año al usuario escribir “Por favor, deme un año”
leer AÑO
si AÑO = 0 entonces
escribir “El año no es válido”
si no
determinar si el año es bisiesto o no
indicar al usuario el resultado obtenido
fin_si
Determinar si el año es bisiesto o no si el año es múltiplo de 4 entonces
si el año es múltiplo de 400 entonces
BISIESTO ! si
si no
BISIESTO ! no
si no
BISIESTO ! si

fin_si
fin_si
si no
BISIESTO ! no
fin_si
Indicar al usuario el resultado obtenido si BISIESTO = si entonces
escribir “El año es bisiesto”
si no
escribir “El año no es bisiesto”
fin_si
Una vez hecho esto es posible obtener el pseudocódigo completo y detallado que resuelve
el problema:
escribir ‘Por favor, deme un año’
leer AÑO
si AÑO = 0 entonces
escribir ‘El año no es válido’
si no
BISIESTO ! si
si no
BISIESTO ! no
si no
BISIESTO ! si
fin_si
fin_si
si no
BISIESTO ! no
fin_si
si BISIESTO = si entonces
escribir ‘El año es bisiesto’
si no
escribir ‘El año no es bisiesto’
fin_si
fin_si
Una vez se ha obtenido el pseudocódigo traducirlo a un lenguaje de programación es
extremadamente sencillo,
el código PASCAL correspondiente al pseudocódigo anterior es el siguiente:
program anno_bisiesto
var anno:integer;
bisiesto.boolean;
begin
writeln *,'Por favor, deme un año'
readln *,anno
if (anno<=0) then
writeln *,'El año no es válido'
else

if (mod(anno,4)==0) then
if ((mod(anno,400))==0) then
bisiesto=.true.
else
if ((mod(anno,100))==0) then
bisiesto=.false.
else
bisiesto=.true.
end if
end if
end if
if (bisiesto) then
writeln *,'El año es bisiesto'
else
writeln *,'El año no es bisiesto'
end if
end if
end
Conceptos fundamentales
A lo largo de la asignatura se utilizarán en muchas ocasiones algunos términos que conviene
definir cláramente; por el momento, los más importantes serán los conceptos de: acción, indicador
o variable, información,estado, datos y resultados, léxico, tipo de datos y operador.
Acción: Como ya se dijo anteriormente, una acción es un suceso, llevado a cabo por un
procesador. Una acción siempre modifica su entorno.
Indicador o variable: El entorno de una acción está compuesto de indicadores que pueden tomar
distintos valores (por esa razón también se denominan variables puesto que los valores pueden
cambiar, es decir, variar); cada indicador o variable tiene asignado un nombre para poder referirse
a él.
Información: El hecho de que un indicador/variable tenga asociado un valor es irrelevante si dicha
asociación no es interpretada; por ejemplo si sabemos que el indicador/variable “v” tiene asociado
el valor “70.5” no nos aporta nada, es la interpretación de “v” como “velocidad en km/h” de dicha
pareja la que nos proporciona una información. Así pues, la información es la asociación entre una
variable, un valor y la interpretación que se hace.
Estado: Puesto que el entorno está formado por indicadores/variables que pueden tomar
diferentes valores está claro que el entorno no es inmutable sino dinámico; el conjunto de valores
de los indicadores/variables del entorno en un instante se denomina estado. De esta forma, si una
acción modifica su entorno (los valores de uno o más indicadores) se puede afirmar que las
acciones hacen pasar el entorno de un estado a otro.
Datos/resultados: Una acción emplea un tiempo finito en su ejecución; si la acción se inicia en t0
y termina en t1, el estado del sistema en el instante t0 (los valores de los indicadores) definen los
datos de la acción mientras que el estado del sistema en el instante t1 (los valores de los
indicadores tras la ejecución de la acción) definen los resultados de la acción.
Léxico: Como sabemos, un procesador comprende y ejecuta instrucciones que componen un
algoritmo; el conjunto finito de acciones que el procesador puede comprender y ejecutar constituye
el léxico del procesador.
Tipo de datos: En matemáticas se clasifican los datos en función de ciertas características
importantes; así tenemos naturales, enteros, reales, complejos, etc. Esta clasificación se hace

mediante conjuntos; dichos conjuntos pueden estar formados por elementos individuales, R, o
agregaciones de valores, Rn. Esta forma de clasificación resulta muy útil y, por tanto, a partir ahora
todos los indicadores (variables) tendrán asignado un tipo.
Operador: A lo largo de muchos de los ejemplos anteriores se ha dado por supuesto que el
procesador conocía la forma de realizar asignaciones, comparar valores, etc. Dichas acciones se
conocen con el nombre de operadores y las acciones que realizan son, por tanto, operaciones; los
alumnos conocen la mayor parte de los operadores presentes en el léxico de la notación
algorítmica que se va a estudiar; se trata de los operadores aritméticos, de comparación, etc.
Introducción de la notación algorítmica a emplear
A lo largo del curso se empleará una notación uniforme para el pseudocódigo; aunque dicha
notación se irá explicando de forma paulatina en este apartado se explicarán algunos aspectos
básicos que, además, servirán para ilustrar algunos de los conceptos anteriores.
Variables: Como se dijo con anterioridad el entorno en que trabajará el procesador viene definido
por una serie de variables (también llamados indicadores) que toman valores cambiantes; también
se dijo que las variables tendrán nombres para poder referirse a las mismas.
Los nombres de las variables (junto con algunos elementos que se verán más adelante) son
identificadores y tradicionalmente los identificadores se han formado con caracteres alfanuméricos
(esto es, letras y números) incluyendo el carácter de subrayado y excluyendo los blancos y
caracteres no anglosajones (como la ‘ñ’ y las vocales acentuadas).
Otra característica de los identificadores es que no pueden empezar por número, sólo por letra (o
subrayado). En algunas notaciones (y lenguajes de programación), las mayúsculas se consideran
como caracteres diferentes de las minúsculas mientras que en otros no se hace así; para
simplificar las cosas nuestra notación será insensible a mayúsculas.
En resumen,
Ejemplos de identificadores válidos: v, aceleracion, K, v1, b_n, Pot, ...
Ejemplos de identificadores no válidos: 1n (empieza por número), año (incluye un carácter no
válido, la ‘ñ’), aceleración (incluye un carácter no válido, la ‘ó’), p v (incluye un espacio en blanco),
Ejemplos de identificadores equivalentes (en nuestra notación): v y V; anno, Anno, ANNO y AnnO;
Pot, pot y poT, ...
Tipos de datos: Ya se ha mencionado el hecho de que las variables deben pertenecer a un tipo de
datos determinado; en nuestra notación algorítmica tenemos los siguientes tipos: entero, real,
logico y caracter. Los tipos se describen en función de las operaciones que admiten.
El tipo entero se corresponden con un subconjunto finito (un rango) de los enteros6, variando el
tamaño de dicho rango en función del computador; las operaciones soportadas son las
operaciones aritméticas básicas: suma (+), resta (-), producto (*), división entera (div) y
módulo/resto (mod). El resultado de operar dos valores de tipo entero resulta otro valor de tipo
entero con un valor exacto (siempre y cuando no resulte un valor fuera del rango).
El tipo real se corresponde con un subconjunto de números reales; una diferencia fundamental
entre un valor real y un valor entero es que el segundo siempre es exacto mientras que el primero
es un valor aproximado, susceptible de errores de redondeo. El tipo real admite las mismas
operaciones que el tipo entero, exceptuando la división entera y el módulo (la división real emplea
el operador /); además de estas, admite las típicas funciones reales: raíz cuadrada,
exponenciación, potenciación, logaritmo y funciones trigonométricas. Al operar valores de tipo real

se obtienen resultados de tipo real. Para facilitar las cosas es posible operar valores de tipo real
con valores de tipo entero y aplicar operaciones del tipo real al tipo entero; en todos estos casos el
resultado es de tipo real.
El tipo logico admite tan sólo dos valores: verdadero y falso; las operaciones admitidas son las de
la lógica booleana: y-lógico (and o .), o-lógico (or o .) y no-logico (not o ¬). Hay que señalar que hay
operadores que, aún no operando sobre valores de tipo logico, dan como resultado valores de
dicho tipo; nos referimos a los operadores de comparación.
El tipo caracter comprende el conjunto de caracteres imprimibles; dicho conjunto tiene una serie de
características:
Contiene las 26 letras del alfabeto latino, los 10 dígitos de la numeración arábiga y caracteres
como símbolos de puntuación.
Los subconjuntos de letras y números están ordenados; es decir si un carácter es mayor que la ‘A’
y menor que la ‘Z’ es una letra mayúscula, si es mayor que ‘a’ y menor que ‘z’ es una letra
minúscula y si es mayor que ‘0’ y menor que ‘9’ es un número.
Existe un carácter blanco o espacio.
El tipo caracter tiene una única operación propia, la concatenación de cadenas de caracteres que
emplea el operador (+). Todos los tipos admiten, además, la operaciones de comparación: los
operadores de comparación disponibles son mayor (>), menor (<), mayor o igual (=), menor o igual
(=), igual (=) y distinto (.). Como ya se dijo, el resultado de una comparación es un valor de tipo
logico.
Literales: En todo momento es posible definir literales, expresiones de valor constante, de
cualquier tipo; así es posible tener literales de tipo entero (por ejemplo, 45, 0 o –17), de tipo real
(por ejemplo, 3.141592, 10.5e20 o –5.24e–5) y de tipo caracter (por ejemplo, ‘E’, ‘etc’ o ‘Esto es
una cadena’). En muchas ocasiones es necesario utilizar un valor literal de forma reiterada, por
ejemplo 3.141592, en esos casos es preferible referirse a dicho valor mediante un identificador, por
ejemplo pi, que utilizar el valor en sí; para ello se utilizan las denominadas
constantes, identificadores a los que se les asigna un valor que no puede ser modificado en
ningún punto del algoritmo. Para definir una constante emplearemos la notación:
constante = literal
De esta forma se está asociando a un identificador un valor constante determinado, a partir de la
definición de la constante, ésta puede ser utilizada en cualquier punto del algoritmo comportándose
de forma
En una lección posterior se describirá la forma en que un computador manipula los diferentes tipos
de datos, explicándose la razón por la que los enteros y reales sólo son representables en un
rango determinado.
Expresiones: una expresión es una combinación de variables, constantes y literales de tipos
compatibles entre sí, estos elementos están combinados mediante operadores válidos; la
expresión más simple está formada por un único elemento (variable, literal o constante) sin ningún
operador. Es posible tener expresiones aritméticas (combinando expresiones de tipo entero y/o
real), expresiones lógicas (combinando expresiones de tipo logico) y expresiones de tipo caracter.

Asignación: el operador de asignación, !, se emplea según la notación siguiente: izquierda !
derecha El elemento situado a la izquierda del operador es una variable a la que se asignará el
valor de la expresión de la derecha; para poder realizar la asignación de forma adecuada ambos
elementos deben ser del mismo tipo.
Entrada/salida: La mayor parte de los algoritmos necesitan interactuar con el usuario, es posible
que éste deba indicar una serie de valores (por ejemplo, los coeficientes de una ecuación de
segundo grado) o que el algoritmo deba proporcionar unos resultados al mismo usuario (por
ejemplo, las posibles soluciones de dicha ecuación). Las acciones de entrada salida son dos: leer y
escribir.
El formato de la primera es muy sencillo: leer variable; el resultado de la acción es la lectura de un
valor por teclado que será asignado a la variable variable. El formato de la segunda es similar:
escribir expresión; donde expresión puede ser de cualquier tipo (entero, real, logico o caracter). El
resultado de esta acción es la visualización (en una pantalla) de la expresión.
Para terminar esta introducción, se mostrará la estructura básica de un algoritmo en la notación
que se utilizará a lo largo del curso:
constantes
c1 = literal1
c2 = literal2
...
variables
v1 : tipo1
v2 : tipo2
...
inicio
accion1
accion2
...
fin
A continuación se muestra un algoritmo muy sencillo que convierte una longitud expresada en
centímetros en su equivalente expresada en pulgadas:
constantes
cm_inch = 0.39
variables
longitud_cm . real
longitud_inch . real
inicio
leer longitud_cm
longitud_inch ! longitud_cm * cm_inch
escribir longitud_inch
fin

Resumen
1. Un algoritmo es una secuencia de pasos ejecutada mecánica y sistemáticamente por un actor en
unentorno dado para resolver un problema determinado en un tiempo finito.
2. Los algoritmos son tan antiguos como la humanidad.
3. El término algoritmo deriva del nombre del matemático Mahommed ibn Musa al-Khowârizmî.
4. Los computadores son máquinas que ejecutan algoritmos.
5. Los 3 elementos fundamentales de un algoritmo son:
• Procesador.
• Entorno.
• Acción.
6. Un algoritmo puede describirse mediante:
• Lenguaje natural.
• Organigramas.
• Pseudocódigo.
• Lenguajes de programación.
7. Para implementar un programa que resuelva un problema hay que realizar:
• Un análisis del problema.
• Un diseño descendente del algoritmo (descomponiendo el problema en subproblemas).
8. Algunos conceptos fundamentales en algorítmica son los siguientes:
• Acción.
• Indicador o variable.
• Información.
• Estado.
• Datos/resultados.
• Léxico.
• Tipo de datos.
• Operador.
9. Conceptos importantes a tener en cuenta en la notación algorítmica a utilizar son:
• Variables.
• Tipos de datos.
• Literales y constantes.
• Expresiones.
• Operación de asignación.
• Operaciones de entrada/salida.

PASCAL
Palabras reservadas
Para poder programar en cualquier lenguaje es necesario conocer los códigos mediante los cuales
podamos expresar las tareas que queremos realizar. El Turbo Pascal, como lenguaje de
programación poseé su propio código con palabras de uso exclusivo para ciertas funciones, a
estas palabras les llamaremos palabras reservadas de Turbo Pascal.
Las palabras reservadas de Turbo Pascal (versiones 6.0 o mayores) son:
Pascal Estandar y Turbo Pascal 6.0
AND ARRAY BEGIN CASE
CONST DIV DO DOWNTO
ELSE END FILE FOR
FORWARD FUNCTION GOTO IF
IN LABEL MOD NIL
NOT OF OR PACKED
PROCEDURE PROGRAM RECORD REPEAT
SET THEN TO TYPE
UNTIL VAR WHILE WITH
Turbo Pascal
ABSOLUTE ASM DESTRUCTOR
IMPLEMENTATION INTERFACE OBJECT
PRIVATE SHR UNIT
VIRTUAL CONSTRUCTOR EXTERNAL
INLINE INTERRUPT SHL
STRING USES XOR
Estas palabras no pueden ser usadas como identificadores (siguiente tópico) ya que cada una de
ellas tiene una función definida en Turbo Pascal.
Identificadores
Los identificadores son palabras que representan constantes, variables, tipos de datos,
procedimientos, funciones y algunos otros datos. Existen dos tipos de identificadores: los
predefinidos de Turbo Pascal y los definidos por el programador.
Algunos de los identificadores predefinidos son: integer, real, byte, sin, ...
Los identificadores definidos por el programador son los elementos del lenguaje tales como
variables, procedimientos, funciones, etc.

Un identificador es una secuencia de 1 a 127 caracteres, que inicia con una letra, no tienen
espacios ni símbolos: &, !, *, etc. y no es alguna palabra reservada.
Para el Turbo Pascal no existen diferencias entre mayúsculas y minúsculas, así que a un
identificador denominado "valor" se le puede referir como "VALOR" o "VaLoR".
Todo identificador en Pascal debe ser definido previamente a su utilización.
Tipos de datos
El manejo de la información en Turbo Pascal se realiza mediante diferentes clases de datos. En
este apartado se tratarán los principales tipos y conforme se vayan necesitando se explicaran los
demás.
Integer Números enteros sin parte decimal.
Char Caracteres del código ASCII
Boolean Pueden contener los valores de falso o verdadero
Real Números que pueden incluir una parte decimal
String En una secuencia de caracteres que se trata como un solo dato.
Variables y constantes
Los tipos de datos que manejaremos en nuestro programa pueden ser de dos clases: variables o
constantes.
Como su nombre lo indica las variables pueden cambiar a lo largo de la ejecución de un programa,
en cambio las constantes serán valores fijos durante todo el proceso.
Un ejemplo de una variable es cuando vamos a sumar dos números que serán introducidos por el
usuario del programa, éste puede introducir dos valores cualesquiera y no sería nada útil
restringirlo a dos valores predefinidos, así que dejamos que use los valores que el necesite sumar.
Ahora, si nuestro programa de operaciones matemáticas va a utilizar el valor de PI para algunos
cálculos podemos definir un identificador PI con el valor de 3.1415926 constante, de tal forma que
PI no pueda cambiar de valor, ahora en lugar de escribir todo el número cada vez que se necesite
en nuestro programa, solo tenemos que escribir PI.
Las variables y constantes pueden ser de todos los tipos vistos anteriormente: numéricos tanto
enteros como reales, caracteres, cadenas de caracteres, etc.
Comentarios
Es posible introducir comentarios en nuestro programa que sirvan unicamente para mejorar la
comprensión del código fuente.
Un comentario no es tomado en cuenta al momento de la compilación del programa y es de
enorme importancia al momento de crearlo, modificarlo o mantenerlo.
Existen dos formas de colocar comentarios en un programa de Turbo Pascal, entre llaves:
{Comentario} o entre parentesis y asteriscos: (*Comentario*).

Estructura de los programas
El lenguaje utilizado en Turbo Pascal es estructurado, lo que significa que cada programa requiere
una forma específica de escritura para que sea entendido por el compilador.
Todo programa cuenta con algunas partes o módulos los cuales son:
Cabecera
Declaraciones
Programa
La cabecera del programa unicamente lleva el nombre del programa. En la sección de
declaraciones se le indica al compilador todos los identificadores y unidades que se utilizarán
durante la ejecución del programa. En la sección del programa se escribe el código de
instrucciones que se llevarán a cabo.
Sentencia PROGRAM
La sentencia PROGRAM es la declaración del nombre del programa.
Consta de tres partes: la palabra reservada PROGRAM, a continuación un identificador utilizado
como el nombre del programa y al final un punto y coma ";". Por ejemplo:
PROGRAM suma_de_dos_numeros ;
Esta declaración es siempre la primer linea en cualquier programa de Turbo Pascal.
Declaración de unidades
Las unidades son módulos independientes del programa que, aunque no son ejecutables por si
mismos, pueden ser utilizados por el programa principal sin necesidad de reescribir el código que
contienen. Para la utilización de estos "subprogramas" es necesaria su declaración.
La palabra reservada USES cumple el propósito de declarar las unidades en el formato siguiente:
USES crt, dos; Esta linea declara y habilita para su uso a la unidad crt y a la unidad dos
Cada unidad que se declara debera estar separada de la siguiente por una coma. Al final de todas
las unidades declaradas se deberá colocar un punto y coma ";".
Declaración de constantes y variables
Para declarar las constantes se utiliza la palabra reservada CONST seguida de un identificador al
que se le dará un valor determinado, un signo de igual "=", el valor que recibirá el identificador y al
final un punto y coma ";". Ejemplo:
CONST pi = 3.1415926;
De esta forma el identificador pi recibirá el valor de 3.1415926 y no será posible cambiarlo en el
transcurso del programa.

Es posible declarar varias constantes sucesivamente, puede ser una por renglón o varias en un
solo renglón. Cuando se hace ésto, la palabra CONST solo se pone una sola vez como cabecera y
a continuación todas las constantes por definir. Ejemplo:
CONST
PI = 3.1415926;
Nombre = 'Juan Gutiérrez';
Unidad = 1;
Otra forma de escribir lo mismo es así:
CONST PI = 3.1415926; Nombre = 'Juan Gutiérrez'; Unidad = 1;
Pero por cuestiones de legibilidad es preferible la primera opción.
La declaración de variables se lleva a cabo de la misma forma, solo que en lugar de la palabra
CONS utilizamos la palabra VAR, y en lugar de "= valor;", utilizamos : tipo , sustituyendo "tipo" por
alguna clase válida de datos en Turbo Pascal. Ejemplo:
VAR Num_entero : Integer;
Nombre : String;
Programa principal
Despues de haber realizado todas las declaraciones se puede iniciar con el programa principal. (Es
posible, antes del programa, declarar las funciones y procedimientos, pero eso se analizará
posteriormente).
El programa principal inicia con la palabara reservada BEGIN y termina con la palabra END., esta
última con un punto al final.
Cada linea de código, enunciado, sentencia o instrucción completa que se escriba deberá terminar
con un punto y coma ";".
Solo se omitirá el punto y coma cuando se utiliza la palabra reservada ELSE. Aunque puede
también omitirse si la siguiente expresión es END o UNTIL.
Ya conociendo la estructura es posible escribir un primer programa:
PROGRAM Primera_Prueba;
VAR
Entero : Integer;
CONST
Mensaje = 'Introduce un valor entero: ';
Respuesta = 'El valor es: ';
BEGIN
Write(Mensaje);
{Escribe en pantalla el mensaje definido como constante}
ReadLn(Entero);
{Lee un valor de teclado y lo almacena en la variable Entero}
WriteLn(Respuesta, Entero);

{Escribe en pantalla el contenido de Respuesta y el valor que se ingresó de teclado}
END.
Como podrá apreciarse, no es importante el orden en el que se declaran las variables y constantes
(aplicable solo al Turbo Pascal), es decir, pueden declararse primero las variables y luego las
constantes y viceversa:
PROGRAM Primera_Prueba;
CONST
Mensaje = 'Introduce un valor entero: ';
Respuesta = 'El valor es: ';
VAR
Entero : Integer;
BEGIN
Write(Mensaje);
{Escribe en pantalla el mensaje definido como constante}
ReadLn(Entero);
{Lee un valor de teclado y lo almacena en la variable Entero}
WriteLn(Respuesta, Entero);
{Escribe en pantalla el contenido de Respuesta y el valor que se ingresó de teclado}
END.
Compilación y ejecución en memoria
La compilación de un programa es el paso mediante el cual traducimos dicho programa al lenguaje
maquina entendible por la computadora.
Para lograr la compilación en el entorno integrado de desarrollo de Turbo Pascal se utiliza la opción
Compile del menú del mismo nombre. Para accesar al menú se utiliza la secuencia de teclas: [ALT]
+ [C], y luego se escoge la opción Compile.
Otra forma de realizar la compilación es con la secuencia de teclas: [ALT] + [F9].
Es posible compilarlo y ejecutarlo automaticamente utilizando la secuencia: [CONTROL] + [F9]
Compilación al disco
Para poder ejecutar un programa sin necesidad de llamar al entorno integrado de desarrollo de
Turbo Pascal es necesario compilar el programa al disco.
Para hacer esto es necesario activar la opción Destination a Disk, esto se hace entrando al menú
Compile, se selecciona la opción Destination y se presiona [Enter], de esta forma se cambia el
destino de compilación de memoria a disco o viceversa (Dependiendo de la opción seleccionada
actualmente).
Una vez compilado un programa en el disco es posible ejecutarlo directamente desde el sistema
operativo.

Asignación o igualación
La operación de asignación es una de las más utilizadas en Turbo Pascal ya que nos permite darle
un valor determinado a las variables que declaramos en el programa o lo que es lo mismo,
igualarla a algún valor determinado.
El símbolo utilizado para la operación es los dos puntos seguidos por un signo de igual := , a la
izquierda de dicho símbolo se coloca el identificador al que se le asignará un nuevo valor y a la
derecha se colocará un identificador o algún valor directo que se almacenará en el primer
identificador. Ejemplo:
Nombre := 'Juan Pérez';
{Nombre guardará la cadena "Juan Pérez"}
Resta := Numero1 - Numero2;
{Resta gurdará el resultado de la resta de Numero2 a Numero1}
Area := (Base*Altura)/2;
{Obtiene el area de un triangulo y la guarda en el identificador Area}
Es indispensable para todo programa que cuente con la capacidad de manejar entradas y salidas
de información, ya que sin estas capacidades sería un programa inútil.
Salida de datos a la pantalla
Las instrucciones que permiten mostrar datos en la pantalla de la computadora son: Write y
WriteLn. Aunque ya se hizo uso de ellas en los pequeños programas anteriores de ejemplo, aqui se
describirán a fondo.
La sintaxis de los procedimientos es la siguiente:
Write (indentificadores);
WriteLn (indentificadores);
Donde los identificadores son aquellos que contienen la información que se desea mandar a la
pantalla. Es posible utilizar varios de ellos por cada instrucción Write o WriteLn, unicamente se
separan unos de otros por comas ",". Ejemplo:
Write (Nombre, ApellidoP, ApellidoM);
Esta linea de código desplegará consecutivamente los contenidos de los identificadores Nombre,
ApellidoP y ApellidoM. En caso de que la variable Nombre almacenara el valor 'Jaime ', la variable
ApellidoP 'Otárola ' y la variable ApellidoM 'López', el resultado en pantalla sería: Jaime Otárola
López
Podemos obtener el mismo resultado si utilizamos la siguiente estructura:
Write (Nombre);
Write (ApellidoP);
Write (ApellidoM);
Si en lugar de utilizar la instrucción Write hacemos uso de WriteLn con la misma sintaxis del
ejemplo anterior:

WriteLn (Nombre);
WriteLn (ApellidoP);
WriteLn (ApellidoM);
lo que obtendriamos sería:
Jaime
Otárola
López
De este ejemplo es posible concluir que la diferencia entre las instrucciones Write y WriteLn es que
esta última imprime el contenido de los identificadores y cambia el cursor al siguiente renglón de la
pantalla, y la primera solo escribe el contenido y deja el cursor al final del dato escrito.
Entrada de datos desde teclado
Las instrucciones estandar de Turbo Pascal para obtener datos desde el teclado son Read y
ReadLn. La sintaxis de estas instrucciones es muy parecida a la de Write y WriteLn:
Read (Identificador);
El identificador puede ser cualquier variable definida previamente, NO puede ser una constante.
Puede ser también un conjunto de variables, separadas entre comas, en este caso se guardara el
primer valor dado antes del [Enter] en el primer identificador proporcionado, luego el segundo y así
sucesivamente hasta el último identificador.
La diferencia en el uso de la instrucción Read con respecto a ReadLn es que en la primera, si se le
dan mas datos de los que se introducirán se guardan en un buffer y se usarán en la siguiente
instrucción Read o ReadLn del programa, en cambio ReadLn ignora todo dato posterior a los que
esten definidos en la instrucción.
En caso de que se le indique a Read o ReadLn que lea un tipo específico de valor, y se le
proporcione otro diferente se generará un error y se detendrá la ejecución del programa.
Tipos de datos
Un programa debe ser capaz de manejar diferentes tipo de datos, como pueden ser números
enteros, reales, caracteres, cadenas de caracteres, etc. Para lograr el manejo de toda esta
información Turbo Pascal proveé diferentes tipos de datos para los identificadores que se
utilizarán. Algunos de los más importantes se citan en seguida:
Tipos enteros
En esta categoría Turbo Pascal cuenta con 5 tipos diferentes, cada uno abarca un rango específico
de valores y utilizan una diferente cantidad de memoria dependiendo de ese rango. Naturalmente
el trabajar con rangos menores nos ofrece una mayor velocidad y menor espacio en memoria, pero
si se utilizan enteros largos se cuenta con mayor presición. Los tipos de enteros en Turbo Pascal
son:
Tipo Rango de valores que acepta
Integer -32,768 a 32,767

Word 0 a 65535
ShortInt -128 a 127
Byte 0 a 255
LongInt -2,147,483,648 a 2,147,483,648
Al utilizar los tipos enteros es posible representar en el programa un número en formato
hexadecimal, para hacer esto solo se le antepone el símbolo "$" al valor hexadecimal, al
momento de visualizar dicho valor, o utilizarlo en alguna operación será como decimal. Por
ejemplo:
Cantidad := $10;
El valor que se guarda en "Cantidad" es 16.
Tipos reales
Los números reales son aquellos que cuentan con una parte decimal. En Turbo Pascal contamos
con varios tipos de datos reales, pero no se puede utilizar, mas que el tipo real, en máquinas que
no cuenten con un coprocesador matemático. Los tipos de datos reales son:
Tipo Rango de valores que acepta
Real 2.9E-39 a 1.7E38
Single 1.5E-45 a 3.4E38
Double 5.0E-324 a 1.7E308
Extended 1.9E-4851 a 1.1E4932
Comp -9.2E18 a 9.2E18
Los números reales deben llevar por fuerza al menos un dígito de cada lado del punto
decimal así sea éste un cero. Como ejemplo, el número 5 debe representarse como: 5.0, el .5
como 0.5 , etc.
En este tipo de datos se utiliza la notación científica, que es igual a la de las calculadoras, el dígito
que se encuentra a continuación de la E representa la potencia a la que se elevará el número 10
para multiplicarlo por la cantidad a la izquierda de dicha E:
3.0E5 = 3.0 * 10^5 = 3.0 * 100000 = 300000
1.5E-4 = 1.5 * 10^-4 = 1.5 * 0.0001 = 0.00015
Tipos caracter
Los caracteres son cada uno de los símbolos que forman el código ASCII, el tipo estándar
de Pascal para estos datos es Char. Los caracteres se especifican entre apostrofes:
'a' </TD 'B' </TD '2' '#'
El tipo Char es un tipo ordinal de Pascal, ésto quiere decir que sus elementos válidos
siguen una secuencia ordenada de valores individuales. La secuencia de caracteres para
este tipo corresponden al número del código ASCII, del 0 al 255.

Es posible accesar a cada uno de los caracteres utilizando un signo # antes de su valor
correspondiente, por ejemplo, la letra A puede ser representada como #65, el retorno de
carro, o enter, se representa como #13, y así cualquier caracter.
Tipo cadena
Las cadenas son secuencias de caracteres o arreglos que tienen una longitud maxima de 255
caracteres. Se definen entre apostrofes. El tipo de Pascal para las cadenas es String.
PROGRAM Cadena;
VAR
Nombre : String;
BEGIN
Nombre := 'Ernesto Chávez';
WriteLn (Nombre);
END.
Este programa guarda la cadena 'Ernesto Chávez' en la variable definida como tipo string, y
la visualiza en la pantalla por medio de la instrucción WriteLn.
El tamaño por defecto para un tipo string es de 255 caracteres, pero es posible definir uno
mas pequeño utilizando el siguiente formato: Variable : String[Tamaño]; Donde Variable es la
variable a definir y Tamaño es el número maximo de caracteres que podrá contener esa variable
(naturalmente mayor a 0 y menor a 256).
Es posible acceder a un solo caracter de una cadena utilizando inmediatamente despues del
nombre de la misma la posición del caracter encerrada entre corchetes. Por ejemplo:
PROGRAM Cadena01;
VAR
Nombre : String[30];
{Permite un máximo de 30 caracteres en la variable}
BEGIN
Nombre := 'Jaime Otárola López';
WriteLn (Nombre[5]);
{Visualiza el 5to caracter de la cadena}
END.
Tipos lógicos
Este tipo de datos tienen la peculiaridad de que solo pueden tomar dos tipos de datos:
verdadero o falso, el verdadero puede ser representado por su nombre en inglés: True y el
falso por False; también se representan por 1 y por 0 respectivamente.
El tipo está definido como Boolean.
Los datos lógicos tienen una enorme aplicación en la evaluación de ciertos procesos, así como en
el control de flujo de los programas.

Operaciones aritméticas y expresiones
Operaciones Aritméticas
Operaciones básicas
Operadores DIV y MOD (Enteros)
Prioridad de operadores
Constantes variables
Uso de las constantes variables
Constantes expresiones
Uso de las expresiones como constantes
Operaciones básicas
Las operaciones básicas en Turbo Pascal están formadas por dos partes: el operador y los
operandos.
Un operador es el símbolo que le indica al programa que operación realizará y los operandos son
los datos sobre los cuales se efectuará la operación.
Los operadores de Turbo Pascal son:
Operador Operación
+ Suma
- Resta
* Multiplicación
/ División
El tipo de datos que pascal regresa como resultado de una operación dependerá del tipo de
datos usados como operandos. Por ejemplo, la suma de dos enteros da como resultado otro
entero, y la suma de dos números reales da como resultado otro número real.
Operadores DIV y MOD
La división de dos números, sin importar su tipo, dará como resultado un número real, así
que para dividir dos enteros, y obtener el resultado como entero, Turbo Pascal ofrece el
operador DIV, el cual da el resultado entero de una división entre enteros, y el operador
MOD que regresa el residuo de una división de enteros.
Su sintaxis es:
entero := dividendo DIV divisor
entero := dividendo MOD divisor
El siguiente programa es un ejemplo del uso de los operadores aritméticos:
PROGRAM Operaciones_Básicas;
VAR
Suma, Resta, Multiplicacion, Division : Real;
Cociente_Entero, Residuo_Entero : Integer;

BEGIN
Suma := 12 + 8;
Resta := 12 - 8;
Multiplicacion := 12 * 8;
Division := 12/8;
Cociente_Entero := 12 DIV 8;
Residuo_Entero := 12 MOD 8;
WriteLn ('La suma de 12 + 8 es igual a: ',Suma);
WriteLn ('La resta de 12 - 8 es igual a: ',Resta);
WriteLn ('La multiplicación de 12 * 8 es igual a: ',Multiplicacion);
WriteLn ('La división de 12 / 8 es igual a: ',Division);
WriteLn ('La división entera de 12 / 8 es igual a: ',Cociente_Entero);
WriteLn ('El residuo de la división entera de 12 / 8 es: ',Residuo_Entero);
END.
Prioridad de operadores
Cuando se utilizan en alguna expresión mas de un operador, éstos se evaluan conforme a
una prioridad establecida por Turbo Pascal. Es necesario conocer el orden de evaluación
para evitar errores en nuestros programas.
El orden en que se ejecutan las operaciones es el siguiente:
*, /, DIV, MOD primeros en evaluarse, todos tienen igual prioridad.
+, - últimos en evaluarse, ambos tienen igual prioridad.
En caso de existir parentesis en la expresión se evaluará primero el contenido de los
parentesis antes que otros operadores.
Si existen dos operadores de igual prioridad se evaluará de izquierda a derecha.
Para observar la importancia de la evaluación correcta de los operadores se expone el
siguiente ejemplo:
PROGRAM Operadores;
VAR
Resultado_Uno, Resultado_Dos : Real;
BEGIN
Resultado_Uno := 3 + 5 * 7;
Resultado_Dos := (3 + 5) * 7;
WriteLn ('El resultado de la operación 3 + 5 * 7 es: ',Resultado_Uno);
WriteLn ('El resultado de la operación (3 + 5) * 7 es: ',Resultado_Dos);
END.
Como se podrá observar en la primera operación se ejecutará primero la operación 5*7 y al
resultado se le sumarán 3,en cambio,en la segunda operación se realizará primero la suma
3+5 para multiplicarle al resultado 7.
Uso de las constantes variables
Cuando se declaran las variables en Turbo Pascal no se inicializan con algún valor en
especial, ésto quiere decir que una variable que no ha sido igualada a cierto valor llevará un

contenido imprevisible, cosa no deseable en la mayoría de los programas, para evitar
resultados indeseables es posible asignarle a cada variable un valor "por defecto", que se
guarde al iniciar el programa.
Estas variables inicializadas son llamadas constantes variables, ya que se declaran en la
sección de constantes, pero es posible cambiar su valor.
La sintaxis para su declaración es la siguiente:
Identificador : tipo_de_datos = valor;
Ejemplo:
PROGRAM Constantes_Variables;
CONST
Valor_Inicializado : Integer = 23;
Texto_Inicializado : String = 'Buenos Dias!';
VAR
Texto : String;
Entero : Integer;
BEGIN
WriteLn ('Cadena inicializada: ',Texto_Inicializado);
WriteLn ('Cadena sin inicializar: ',Texto);
WriteLn ('Entero inicializado: ',Valor_Inicializado);
WriteLn ('Entero sin inicializar: ',Entero);
END.
Uso de las expresiones como constantes
Es posible declarar constantes con base en otras constantes ya declaradas en el programa
utilizando alguna expresión para este fin, por ejemplo:
CONST
Columnas = 80;
Filas = 24;
Total_de_espacios = Columnas * Filas;
Solo es posible utilizar constantes en las expresiones de este tipo, si se usa alguna variable
ocurrirá un error al momento de compilar el programa.
Sentencias compuestas
Las sentencias compuestas son grupos de sentencias, separadas cada una por un punto y coma
";" que son tratadas como una sola sentencia.
Para identificar una sentencia compuesta de un grupo sucesivo de sentencias se encierran entre
las palabras reservadas BEGIN y END. Uno de los ejemplos más claros de una sentencia
compuesta es el cuerpo de un programa principal en Turbo Pascal, el lenguaje toma todo lo que
existe entre estas dos sentencias como un solo elemento a ejecutarse aún cuando contenga varias
instrucciones o sentencias:

PROGRAM Prueba;
BEGIN
WriteLn('Primera linea de una sentencia compuesta');
WriteLn('Segunda linea de una sentencia compuesta');
WriteLn('Tercera linea de una sentencia compuesta');
END.
El punto y coma que se encuentra antes de la palabra reservada END puede ser suprimido sin
afectar a la compilación. En ocasiones es necesario repetir un determinado número de veces la
ejecución de una sentencia, ya sea sencilla o compuesta, para realizar esta tarea Turbo Pascal
cuenta con instrucciones específicas para el tipo de repetición que se requiera.
Ciclos FOR
El ciclo FOR repite una sentencia un determinado número de veces que se indica al momento de
llamar al ciclo.
Lo que hace FOR es que incrementa una variable en uno desde un valor inicial hasta un valor final
ejecutando en cada incremento la sentencia que se quiere repetir. Su sintaxis es:
FOR identificador := inicio TO fin DO instrucción;
Donde el identificador es la variable que se incrementará, inicio es el primer valor que tendrá dicha
variable y fin es el valor hasta el cual se incrementará la misma; instrucción es la sentencia
(sencilla o compuesta) que se ejecutará en cada incremento de la variable.
El siguiente ejemplo escribe los números del 1 al 50 en pantalla. La variable utilizada es "Numero".
PROGRAM Ciclo_FOR;
VAR
Numero : Integer;
BEGIN
FOR Numero := 1 to 50 DO
WriteLn(Numero);
END.
Una de las limitaciones de los ciclos FOR es que una vez iniciado el ciclo se ejecutará el número
de veces predefinido sin posibilidad de agregar o eliminar ciclos.
Es posible hacer que un ciclo cuente hacia atrás, es decir que la variable en lugar de incrementarse
se decremente. Para ésto cambiamos la palabra TO por DOWNTO, y colocamos el valor mayor a
la izquierda y el menor a la derecha. Ejemplo:
PROGRAM Ciclo_FOR_2;
VAR
Numero : Integer;
BEGIN
FOR Numero := 50 DOWNTO 1 DO
WriteLn(Numero);
END.

Ciclos WHILE
Los ciclos WHILE ofrecen la ventaja de que la ejecución se realiza mientras se cumpla una
condición, por lo tanto es posible controlar el número de repeticiones una vez iniciado el ciclo. Su
sintaxis es:
WHILE condición DO instrucción
Donde condición es la condición que se evaluará, mientras ésta sea verdadera se ejecutará la
instrucción, que es una sentencia simple o compuesta.
Un programa que escriba los números del 1 al 50, utilizando el ciclo WHILE se vería como sigue:
PROGRAM Ciclo_WHILE;
VAR
Numero : Integer;
BEGIN
Numero := 1;
WHILE Numero <= 50 DO
BEGIN
WriteLn (Numero);
Numero := Numero +1;
END;
END.
Al final del programa la variable Numero guardará el valor 51, que fué el valor que no cumplió con
la condición establecida en el ciclo WHILE.
Ciclos REPEAT-UNTIL
Este tipo de ciclos es muy parecido a los ciclos WHILE, la diferencia entre ambos es que en WHILE
la condición se evalúa al principio del ciclo, en cambio en REPEAT-UNTIL se evalúa al final, lo que
significa que en un ciclo REPEAT-UNTIL la sentencia se ejecutará por lo menos una vez, cosa que
puede no ocurrir en el ciclo WHILE. Ejemplo:
PROGRAM Ciclo_RepeatUntil;
VAR
Numero : Integer;
BEGIN
Numero := 1;
REPEAT
WriteLn (Numero);
Numero := Numero + 1;
UNTIL Numero = 50;
END.
Para crear un buen programa es necesario dotarlo con capacidad de desición con base en las
variables o eventos definidos por el programador, para que el programa sea aplicable en un
entorno más generalizado y no solo para un problema específico.
Para lograr este control se cuenta con las estructuras de control que, en Turbo Pascal, son las
siguientes:

Sentencia IF...THEN...ELSE
Esta expresión es utilizada para ejecutar una sentencia en el caso que una condición establecida
sea verdadera, de lo contrario se podra ejecutar una sentencia distinta. Su sintaxis es:
IF condición THEN instrucción ELSE otro
Donde condición es la expresión que se evaluará, en caso de ser verdadera se ejecutará la
sentencia dada como instrucción, en caso de que la condición sea falsa se ejecutara la sentencia
dada como otro. Ejemplo:
PROGRAM IF_THEN_ELSE;
VAR
Contador : Integer;
BEGIN
FOR contador := 1 to 50 DO
BEGIN
IF contador > 10 THEN WriteLn(Contador) ELSE WriteLn('*');
END;
END.
En este pequeño programa la variable Contador se incrementará desde 1 hasta 50, la sentencia
condicional IF verificará si es verdad que Contador es mayor a 10, de ser así se escribirá en
pantalla el valor de la variable, de lo contrario se escribira en la pantalla un caracter "*". Como el
contador inicia desde 1, tenemos que se imprimiran 10 asteriscos antres del primer número, que
será el 11, valor que si cumple la condición "Contador > 10" (la hace verdadera).
La sección ELSE con su correspondiente sentencia son opcionales y pueden omitirse en caso de
no necesitarse.
Sentencias IF anidadas
Es posible utilizar en una expresión del tipo IF..THEN..ELSE una sentencia compuesta como la
sentencia a ejecutarse en caso de que la condición sea verdadera, así como en la sentencia
posterior a un ELSE, de esta forma podemos utilizar otra sentencia IF..THEN..ELSE dentro de la
anterior, para de esta forma evaluar varias condiciones una dentro de otra. Ejemplo:
IF Numero > 5 THEN
BEGIN
IF Numero <10 THEN Opcion :="Numero;<BR"> IF Numero <30 THEN Opcion2
:="Numero;<BR"> END;
Selecciones CASE
Esta forma de control se utiliza cuando se va a evaluar una expresión que puede contener varios
datos diferentes y en cada dato deberá realizar una acción especial. Por ejemplo, si se crea un
menú con diferentes opciones se realizará un determinado proceso para cada acción, aunque la
selección por parte del usuario se haga desde el mismo lugar.

El siguiente programa ilustra el uso de la forma CASE, el programa preguntará un número al
usuario y lo clasificará de acuerdo a su valor.
PROGRAM Case;
VAR
Numero : Integer;
BEGIN
WriteLn('Introduzca un número entero del 1 al 5: ');
ReadLn(Numero);
CASE Numero OF
1 : WriteLn('El número fué 1');
ELSE WriteLn('El número no estaba en el rango indicado');
END.
GOTO
La sentencia GOTO es una sentencia utilizada para alterar el flujo del programa, es decir, para ir a
ejecutar una sentencia en un lugar diferente del programa y no la linea siguiente.
El uso de GOTO no es aconsejable ya que destruye el modelo de la programación estructurada
que es la que se utiliza en Turbo Pascal, además se cuenta con las estructuras de datos anteriores
que hacen casi innecesario su uso.
Para utilizar este tipo de salto es necesario declarar etiquetas, que no son otra cosa que el
identificador que marcará el lugar a donde se dirigirá el flujo del programa al momento de usar el
GOTO. La declaración de etiquetas se hace antes que la de constantes y variables, la palabra
reservada para su declaración es LABEL. El nombre de la etiqueta es un nombre de un
identificador como cualquier otro, pero al utilizarse debe terminar con dos puntos ":".
La sintaxis del comando es:
GOTO etiqueta;
Ejemplo:
PROGRAM Uso_del_GOTO;
LABEL
Etiqueta;
BEGIN
WriteLn('Esta linea si se escribirá');
GOTO Etiqueta;
WriteLn('Esta linea no se escribirá');
Etiqueta:
WriteLn('Se efectuó el brinco');
END.
HALT

La instrucción HALT provoca la terminación inmediata de un programa, sin importar las siguientes
instrucciones. Normalmente se utiliza en casos de error, se despliega un mensaje y se termina el
programa. Ejemplo:
PROGRAM Uso_de_HALT;
BEGIN
WriteLn('Primera linea del programa');
WriteLn('Terminará la ejecución del programa');
HALT
WriteLn('');
END.
Definición de procedimiento
Un procedimiento es un grupo de sentencias que realizan una tarea concreta. En lugar de
reescribir el código completo de esa tarea cada vez que se necesite, unicamente se hace una
referencia al procedimiento.
Por ejemplo, es muy común que se quiera visualizar un título determinado varias veces en un
programa, para evitar teclear ese título en nuestro programa fuente todas las veces que sea
necesario creamos un procedimiento llamado "Titulo" que se encargará de escribirlo.
Una vez creado un procedimiento actuará como una instrucción más de Turbo Pascal, y para
ejecutarlo unicamente teclearemos el nombre de dicho procedimiento.
Para poder ejecutar un procedimiento es necesario declararlo en el programa que se este
utilizando.
Creación de los procedimientos
El primer paso para crear un procedimiento es saber que queremos que haga. Una vez definiendo
este punto declaramos el procedimiento despues de haber declarado variables y constantes, antes
del cuerpo del programa principal. La palabra reservada para su declaración es Procedure seguida
del nombre del procedimiento. Vamos a crear un procedimiento encargado de escribir en pantalla
el enunciado "Programa de Turbo Pascal":
PROCEDURE Titulo;
BEGIN
WriteLn ('Programa de Turbo Pascal');
END;
Uso de los procedimientos
Una vez declarado el procedimiento es posible utilizarlo como una instrucción de Turbo Pascal. Al
uso de un procedimiento se le conoce como llamada al procedimiento.
El siguiente programa ilustra el uso o la llamada al procedimiento creado anteriormente:
PROGRAM Procedimientos;
PROCEDURE Titulo;
BEGIN

WriteLn ('Programa de Turbo Pascal');
END;
BEGIN
WriteLn ('Programa ejemplo del uso de procedimientos');
Titulo;
{Llama al procedimiento}
WriteLn;
Titulo;
{Vuelve a llamar al procedimiento}
END;
Variables locales y globales
En Turbo Pascal cada identificador tiene un campo de acción, solo dentro de éste campo es
posible utilizarlo. Los ejemplos más claros son las variables, que pueden ser globales o locales. La
diferencia estriba en que una variable global puede ser utilizada por cualquier parte del programa,
incluyendo a todos los procedimientos, en cambio una variable local puede ser utilizada
unicamente por el procedimiento en el que esta declarada, el programa principal y los otros
procedimientos la toman como inexistente. Ejemplo:
PROGRAM Variables;
VAR
Hola : String;
PROCEDURE prueba;
VAR
Adios : String;
BEGIN
{En esta sección si es posible usar la variable Hola}
Adios := 'Adios, que les vaya bien';
WriteLn (Adios);
END;
BEGIN
{En esta sección no se reconoce a la variable Adios}
Hola := 'Hola, bienvenidos al programa';
WriteLn (Hola);
WriteLn (Adios);
{Al compilar el programa se generará un error ya que la variable Adios es inexistente en esta
sección, para eliminar el problema quites esta linea}
prueba;
END.
Es posible darle el mismo nombre a una variable local y a una global en el mismo programa, pero
entonces el procedimiento no podrá utilizar la variable global ya que le da preferencia a las locales
sobre las globales. Por ejemplo:
PROGRAM Variables_2;
VAR
Saludo : String;
PROCEDURE Mensaje;
VAR
Saludo : String;

BEGIN
Saludo := 'Este mensaje solo es válido para el procedimiento "Mensaje"';
WriteLn('Saludo');
END;
BEGIN
Saludo := 'Primer saludo (Global)';
WriteLn (Saludo);
Mensaje;
WriteLn (Saludo); {Se escribirá el mensaje "Primer saludo"}
END.
Parámetros
Para poder pasar información entre el programa principal y procedimientos, o entre los mismos
procedimientos usamos los parámetros, que son los canales de comunicación de datos.
Los parámetros son opcionales y si no se necesitan no se deben usar. Para utilizarlos es necesario
declararlos son la siguiente sintaxis:
PROCEDURE nombre (lista de parámetros);
La lista de parámetros esta compuesta de los nombres de los mismos y del tipo de datos que
representan, los del mismo tipo se separan con comas "," y cada tipo diferente se separa con punto
y coma ";". Ejemplo:
Procedure Ejemplo(a, b : Integer; c, d : String);
Para llamar a un procedimiento que utiliza parámetros se pueden utilizar como tales otras variables
o constantes, siempre y cuando sean del mismo tipo que los declarados. Ejemplo:
Ejemplo(1, 2, 'Hola', 'Adios');
Ejemplo de un programa con procedimiento que utiliza un parámetro.
PROGRAM Parametros;
VAR
Saludo : String;
PROCEDURE Imprime_5 (a : String);
VAR
Contador : Integer;
BEGIN
FOR contador := 1 to 5 DO
{Imprime 5 veces la cadena almacenada }
WriteLn(a);
{en la variable "a", que es la información}
END;
{que llega como parámetro }
BEGIN
Saludo := 'Bienvenidos al programa';
Imprime_5 (Saludo);
{llama al procedimiento Imprime_5, usando como}

{parámetro la variable Saludo }
Imprime_5 ('Fin');
{Utiliza la cadena "fin" como parámetro }
END.
Es válido crear un procedimiento que llame a otro procedimiento siempre y cuando el
procedimiento llamado haya sido declarado antes del que lo usará.
Definición de las funciones
Las funciones son, al igual que los procedimientos, un conjunto de sentencias que se ejecutan
constantemente, la diferencia entre éstas y los procedimientos es que las funciones regresan un
valor. La declaración de las funciones se realiza de la siguiente forma:
FUNCTION nombre(parámetros) : tipo_de_datos;
A continuación se escribe el contenido de la función como una sentencia normal (sencilla o
compuesta), normalmente terminando con la igualación de la función al valor que regresará.
Ejemplo:
FUNCTION Promedio (a, b : Real) : Real; {Promedio de dos números reales}
BEGIN
Promedio := (a + b) / 2;
END;
Uso de las funciones
Como las funciones devuelven un valor específico la forma más usual de utilizarlas es por medio
de asignaciones de una variable a la función. Ejemplo:
PROGRAM Funciones;
VAR
X, Y, Z : Real;
FUNCTION Promedio (a, b : Real) : Real;
{Promedio de dos números reales}
BEGIN
Promedio := (a + b) / 2;
END;
BEGIN
X := 5.89;
Y := 9.23;
Z := Promedio (X, Y);
{Iguala Z al valor devuelto por la función Promedio}
WriteLn('El promedio de ',X,' y ',Y,' es: ',Z);
END.
Procedimieto HALT

El procedimiento HALT ya se habia revisado anteriormente, pero se tomó como una instrucción,
siendo que es realmente un procedimiento predefinido de Turbo Pascal que nos permite terminar
nuestro programa en cualquier punto del mismo.
El procedimiento EXIT provoca la salida del procedimiento que se está ejecutando y nos regresa al
lugar de donde fue llamado.
Procedimientos INC y DEC
El procedimiento INC incrementa en 1 el contenido de cualquier variable de tipo entero, es lo
mismo en un programa teclear:
Variable := Variable + 1;
o telcear:
Inc(Variable);
El procedimiento DEC decrementa en 1 el valor de cualquier variable de tipo entero que se le
indique, se usa igual que INC:
DEC (Variable);
Truncamiento y redondeo
La función Round (número) redondea un número real al entero más cercano y devuelve el
resultado como un número real.
La función Trunc (número) elimina la parte decimal del número real y devuelve el resultado como
tipo entero. Ejemplo:
PROGRAM Redondeo;
VAR
Entero : Integer;
ValorReal1, ValorReal2 : Real;
BEGIN
ValorReal1 := 123.435;
ValorReal2 := Round(ValorReal1);
Entero := Trunc (ValorReal1);
WriteLn('El resultado de la función Round sobre el valor');
WriteLn(ValorReal1, ' es: ','ValorReal2, ' (Número real)');
WriteLn('El resultado de la función Trunc sobre el valor');
WriteLn(ValorReal1, ' es: ', Entero, ' (Número entero)');
END.
Funciones exponenciales y logarítmicas
La función Sqr devuelve el cuadrado del valor utilizado como parámetro.
Sqrt regresa la raíz cuadrada del valor dado como parámetro, el resultado siempre es real
aunque se utilice un número de tipo entero como argumento. Ejemplo:

PROGRAM Exponentes;
VAR
Dato, Cuadrado : Integer;
Raiz : Real;
BEGIN
Dato := 45;
Cuadrado := Sqr(Dato);
Raiz := Sqrt(Dato);
WriteLn(' El cuadrado de ',Dato, ' es: ',Cuadrado);
WriteLn('La raíz cuadrada de ',Dato,' es: ',Raiz);
END.
Las funciones Exp y Ln tratan con logaritmos naturales o neperianos. Exp devuelve la
funcion exponencial e^x y Ln devuelve el logaritmo natural de x. El resultado en ambos
siempre es del tipo real.
Es posible crear una función con base en estas dos para calcular el resultado de un número
x elevado a una potencia n, la cual nos quedaría así:
FUNCTION Potencia(x,n:Real):Real;
BEGIN
Potencia := Exp(n *Ln(x))
END;
El uso de esta función en un programa podría ser:
PROGRAM Potenciacion;
FUNCTION Potencia(x, n : Real) : Real;
BEGIN
Potencia := Exp(n * Ln(x))
END;
BEGIN
WriteLn('El resultado de 5 elevado a 3 es: ',Potencia(5,3));
END.
Funciones aritméticas
Abs regresa el valor absluto del identificador que se le pase como parámetro. El valor que
devuelve será del mismo tipo que el argumento. Abs(-24) {Regresa el valor 24} La función Int
devuelve la parte entera de un valor real, como tipo real.
La función Frac regresa la parte decimal de un valor real, también como valor real.
Funciones trigonométricas
Las funciones trigonometricas definidas en Turbo Pascal son: Sin(valor), Cos(valor) y
Arctan(valor), todas las demas pueden definirse desde estas:
Tan(x) Sin(x) / Cos(x)
Cot(x) Cos(x) / Sin(x)
Sec(x) 1 / Cos(x)

Csc(x) 1 / Sin(x)
Las funciones para utilizarlas son:
FUNCTION Tan(x : Real) : Real;
BEGIN
Tan := Sin(x) / Cos(x)
END;
FUNCTION Cot(x : Real) : Real;
BEGIN
Cot := Cos(x) / Sin(x)
END;
FUNCTION Sec(x : Real) : Real;
BEGIN
Sec := 1 / Cos(x)
END;
FUNCTION Csc(x : Real) : Real;
BEGIN
Csc := 1 / Sin(x)
END;
Generación de números aleatorios
Para generar números aleatorios Turbo Pascal cuenta con la función Random y el procedimiento
Randomize.
La función Random genera un número aleatorio de tipo real comprendido entre 0 y 1, en cambio la
función Random (x) genera un entero aleatorio entre 0 y x.
Sin embargo el uso de la función Random es en ocasiones insuficiente por si sola para la
generación de valores aleatorios ya que los números son realmente pseudoaleatorios, y cada vez
que se ejecute el programa se obtendrían los mismos valores. Para evitar esto debemos utilizar en
todo programa que utilice valores aleatorios el procedimiento Randomize, que inicializa el
generador de números aleatorios, en otras palabras, asegura que los números que obtendrá serán
diferentes cada vez que se ejecute el programa.
Es recomendable usar este procedimiento antes de cada función random del programa.
Ejemplo de un programa generador de números aleatorios:
PROGRAM Nums_Aleatorios;
VAR
x : Integer;
BEGIN
Randomize
WriteLn('Lista de números aleatorios');
For x := 1 to 20 do
WriteLn(Random);
END

Las cadenas de caracteres son secuencias de caracteres con longitudes que varían desde 1 hasta
los 255 caracteres. El tipo identificador de las cadenas es String. Cuando declaramos una variable
de tipo string será posible introducir hasta 255 caracteres en ella, pero también es factible declarar
cadenas más cortas agregando al momento de la declaración la longitud de la variable, por
ejemplo:
VAR
Mensaje : String[120]; {Longitud maxima = 120 caracteres}
Comparación de cadenas
La comparación de cadenas es una operación muy común en Turbo Pascal; estas comparaciones
se realizan con base en el orden del código ASCII, por ejemplo la cadena 'Prueba' es menor a la
cadena 'prueba' ya que el valor del código ASCII de P es 80 y el de p es 112.
Así también podemos diferenciar las cadenas con respecto a su tamaño: 'Hola' es menor a
'Bienvenido'
Existe un caso especial de una cadena, que es cuando no tiene ningún caracter en ella, en ese
momento decimos que es una cadena nula o vacía. Se recomienda ampliamente inicializar todos
los valores de las cadenas a cadenas nulas al inicio del programa, ya que podrían contener datos
extraños e indeseables.
Manejo de los elementos de la cadena
Es posible leer cada elemento de una cadena por separado, por ejemplo, si en la variable Calle
almacenamos la cadena 'Hidalgo' es posible asignar a otra cadena el valor de Calle[x] donde x es
el caracter de la cadena que se quiere leer, así también es posible visualizar el caracter en pantalla
usando la instrucción WriteLn. Ejemplo:
PROGRAM Caracter;
VAR
Calle : String;
Letra : String;
BEGIN
Calle := 'Hidalgo';
WriteLn(Calle[2]); {Visualiza el segundo caracter de Calle}
Letra := Calle[1]; {Guarda en Letra el primer caracter de Calle}
WriteLn(Caracter) END.
Para conocer la longitud de una cadena utilizamos la función Length, la longitud es la cantidad de
caracteres que contiene la cadena en un momento determinado.
Su sintaxis es:
Length (cadena);
La función regresa un valor entero.
PROGRAM Funcion_Length;
VAR
Cadena : String;
BEGIN

Cadena := 'Prueba de longitud';
WriteLn ('Longitud de la cadena: ', Length (Cadena));
END.
El programa imprime en la pantalla un mensaje con la longitud de la cadena almacenada en
memoria, en este caso específico 18.
En ocasiones es necesario combinar dos o más cadenas de caracteres en una sola, para lograr
ésto utilizamos los siguientes métodos.
Operador +
Es una de las formas más sencillas de unir dos cadenas y se maneja exactamente como una
suma, la única limitante es que en caso de ser mayor la longitud resultante de la suma que la
longitud que pueda manejar la variable en que se almacenará se truncarán los caracteres
sobrantes. Ejemplo:
Cadena1 := 'Buenos ';
Cadena2 := 'dias ';
Cadena3 := Cadena1 + Cadena2;
WriteLn (Cadena3);
Se imprimirá en la pantalla: 'Buenos dias'. (Notese que este ejemplo es solo una sección del
programa, para ejecutarlo es necesario completar la estructura).
Función Concat
La función concat produce los mismos resultados que la concatenación, es posible incluir cualquier
número de cadenas que se necesiten concatenar.
La suma de las cadenas no deberá sobrepasar la longitud que la variable, a la cual se asignará
dicha suma, puede manejar. Ejemplo:
Cadena := Concat (Cad1, cad2, cad3);
Pos
Laa función Pos nos sirve para localizar una determinada cadena dentro de otra, en otras palabras
para verificar si una cadena es subcadena de otra segunda.
Los parámetros que requiere son: la cadena que se buscará y la cadena donde se buscará la
primera:
Pos (Cadena1, Cadena2);
Cuando encuentra la cadena la función devuelve su posición inicial, en caso de que no la
encuentre devuelve el valor de 0.
Ejemplo:
Cadena := 'Domingo Lunes Martes Miercoles Jueves Viernes Sabado';
WriteLn(Cadena);

WriteLn(Pos('Lunes', Cadena)); {Muestra 9}
WriteLn(Pos('Jueves', Cadena)); {Muestra 32}
WriteLn(Pos('Ayer', Cadena)); {Muestra 0}
Copy
La función copy regresa una subcadena de una variable o constante dada como parámetro. Su
sintaxis es:
Copy (Cadena, Inicio, Cantidad);
Donde Cadena es la fuente de la subcadena, Inicio es la posición desde la cual se obtendrá la
subcadena y Cantidad es el número de caracteres que se extraerán.
Los valores de Inicio y Cantidad deben ser de tipo entero.
Ejemplo:
Cadena := "Nuevos horizontes";
WriteLn (Copy(Cadena, 8, 10)); {Visualiza: horizontes}
Insert
El procedimiento Insert sirve para insertar una cadena dentro de otra en alguna posición
determinada. Sintaxis:
Insert (Cadena1, Cadena2, Posición)
Donde Cadena1 es la que se insertará, Cadena2 es donde se insertará y Posición es el lugar
donde se insertará. El parámetro Posición debe ser de tipo entero.
Delete
Este procedimiento elimina un determinado número de caracteres de una cadena. Su sintaxis es:
Delete (Cadena, Inicio, Número)
Cadena es la variable en la cual se eliminarán los caracteres, Inicio es la posición del primer
caracter a eliminar y Número es la cantidad de caracteres que se borrarán.
UpCase
La función UpCase regresa la letra mayuscula correspondiente al caracter dado como parámetro.
Es muy común trabajando con cadenas que se quiera convertir una que contiene un número a su
valor numérico, para poder utilizarlo en operaciones matemáticas, así como convertir un número a
su equivalente en una cadena.
Esto es más fácil de entender si consideramos que no es lo mismo el valor 75 y el valor '75', en el
primer caso es un número mientras que en el segundo es un par de caracteres ASCII.
Para lograr estos cambios de tipo en Turbo Pascal utilizamos los procedimientos siguientes:

Str
El procedimiento Str obtiene una cadena a partir de un valor numérico. Su sintaxis es:
Str(Valor, Cadena)
Donde valor es el número a convertir y Cadena es la variable donde se almacenará la cadena ya
convertida.
Val
Este procedimiento convierte una cadena en un valor de tipo numérico, el problema con esta
función es que si la cadena no esta formada exclusivamente de números siguiendo las reglas para
el tipo de datos que se vallan a obtener se generará un error. Sintaxis:
Val (Cad, Num, Código)
Cadena contiene la cadena que será procesada, Num es la variable de tipo numérico donde se
guardará el valor de la cadena y Código es una variable de tipo entero (Integer) que contendrá el
valor de 0 si no hubo errores y un valor diferente en caso de que no se haya podido convertir la
cadena, el valor de Código representa la posición de la cadena donde ocurrio el error.
Archivos de acceso secuencial
Los archivos de acceso secuencial son llamados también archivos de texto, están formados por
cadenas de caracteres separadas unas de otras por los códigos retorno de carro/avance de línea,
que corresponden a los caracteres 13/10 del código ASCII. El final del archivo se indica mediante
el caracter ASCII 26, que también se expresa como ^Z o EOF.
Es posible visualizar estos archivos con la orden TYPE del sistema operativo DOS y se pueden
editar con cualquier editor de textos.
Este tipo de archivos solo permiten operaciones de lectura y escritura secuenciales, la unica forma
de modificarlos es agregando líneas al final del archivo.
Los pasos para leer o escribir en un archivo de este tipo son:
Declarar una variable de tipo texto y asociarla al nombre de un archivo. A esto también se le llama
declarar el archivo.
Abrir el archivo ya sea para lectura o escritura.
Leer o escribir datos en el archivo.
Cerrar el archivo
Declaración de un archivo
Para declarar un archivo primero se declara una variable tipo text de la siguiente forma:
VAR
VarArchivo : Text;
Una vez declarada la variable se asigna al nombre de algun archivo:

ASSIGN (VarArchivo, NombreArchivo); Donde NombreArchivo es una cadena de caracteres que
contiene el nombre del archivo, la unidad de disco donde se encuentra y el directorio. Por ejemplo:
ASSIGN (VarArchivo, 'C:DOSPRUEBA.TXT');
Abrir archivos
Exsiten tres formas de abrir un archivo:
Rewrite Reset Append
Escribir datos en un archivo
Para escribir datos a un archivo se utilizan las instrucciones Write y WriteLn, como si se quisiera
escribir a la pantalla, con la diferencia de que se especificará la variable de archivo ya declarada.
Ejemplo:
WriteLn(VarArchivo, 'Prueba de archivos'); Esta sentencia grabaría el texto 'Prueba de archivos'
en el archivo asignado a VarArchivo.
Leer datos de un archivo
Para leer los datos de un archivo de acceso secuencial se utilizan las instrucciones Read y
ReadLn.
La instrucción Read lee uno o varios datos del archivo abierto y deja el puntero en el mismo
renglón en el cual leyó los datos, en cambio ReadLn lee los datos y mueve el puntero al siguiente
renglón.
Fin del archivo
Normalmente los archivos de este tipo se leen renglón por renglón hasta llegar al final del mismo.
Cuando se conoce de antemano el tamaño del archivo es posible utilizar un ciclo FOR, pero es
más seguro utilizar la función EOF la cual es verdadera despues de que el programa lee la última
linea de un archivo de acceso secuencial.
La sintaxis de la función EOF es:
EOF (VaribleArchivo);
Es común realizar la verificación de la función con un ciclo WHILE como en el ejemplo siguiente:
WHILE NOT EOF(Archivo) DO
BEGIN
ReadLn(Archivo, Datos);
WriteLn(Datos);
END;
Cerrar archivos

Para asegurar que toda la información se grabe en el disco correctamente es necesario cerrar el
archivo antes de que se termine la ejecución del programa, de lo contrario se corre el riego de que
la última información que se haya accesado no se grabe en su totalidad.
La instrucción para cerrar un archivo es Close, y su sintaxis es:
Close (VaribleArchivo);
Función Eoln
La función Eoln sirve para verificar si el puntero ha llegado al final de la linea. Regresa el valor
verdadero si se encuentra al final. Comunmente se utiliza en las lecturas caracter por caracter.
Agregar datos a un archivo de texto
Para añadir datos a un archivo de texto son necesarios los siguientes pasos:
Asignar un archivo a una variable con Assign
Agregar los datos con el procedimiento Append
Escribir los datos
Cerrar el archivo
A continuación se ilustra un ejemplo de un programa que agrega una linea a un archivo de texto:
PROGRAM Archivo;
VAR
Texto : TEXT;
BEGIN
Assign (Texto, 'PRUEBA.DAT');
Append(Texto);
WriteLn(Texto, 'Agregando una linea al archivo PRUEBA.DAT');
Close (Texto)
END.
Archivos de acceso directo
Un archivo de acceso directo esta formado por un conjunto de partes individuales que pertenecen
al mismo tipo de datos. Cada uno de los componentes del archivo es llamado registro.
Cada uno de los componentes de este tipo de archivos es accesible directamente.
Los archivos de acceso directo son también llamados archivos con tipos o tipeados.
Estructura del archivo
A diferencia de los archivos secuenciales, los archivos tipeados no estan compuestos de lineas de
caracteres, sino que se acomodan en registros con estructuras fijas. La longitud de los registros
esta determinada por la cantidad de bytes que se necesitan para almacenar el tipo de datos que
contendrá el registro.

Por ejemplo, si se van a almacenar números enteros en un archivo, cada registro servirá para un
número específico y ocupará 2 bytes, el siguiente registro utilizará los dos bytes siguientes del
archivo y así sucesivamente hasta completar la cantidad de datos que se vayan a almacenar.
Este tipo de archivos no pueden ser visualizados con la instrucción type del sistema operativo
debido al formato utilizado para guardarlos.
Declaración de un archivo
Para declarar un archivo de acceso directo se realiza con las palabras reservadas FILE OF, su
sintaxis es la siguiente:
VariableArchivo : FILE OF TipoElementos;
Esta declaración se realiza en la sección correspondiente a la declaración de las variables.
Ejemplo:
PROGRAM Archivo_Tipeado;
VAR
Archivo : FILE OF Integer;
BEGIN
END.
Normalmente no se desea crear archivos que puedan almacenar un solo tipo de datos ya que se
requeririan varios archivos, por ejemplo para alguna base de datos: uno para los nombres, otro
para apellidos, otro para la edad, etc. Para evitar este inconveniente es posible usar registros del
tipo RECORD, que permiten grabar en un solo registro un grupo de datos que pueden ser de
diferentes tipos, uno de tipo INTEGER, uno de tipo STRING, etc.
Los registros del tipo record deben ser declarados antes de las variables en una sección llamada
TYPE con el siguiente formato:
TYPE
Nombre_Reg = RECORD
Campo_del_registro_1 : Tipo;
Campo_del_registro_2 : Tipo;
...
Campo_del_registro_n : Tipo;
END;
Donde Nombre_Reg es el nombre del registro que se utilizará, Campo_del_Registro_x son las
variables que estarán contenidas en el registro y Tipo es el tipo de cada una de las variables del
registro.
La sección TYPE se escribe antes de la declaración de las variables.
Como ejemplo, si se quiere crear un archivo el que se guarden el nombre, domicilio, edad y estado
civil de un grupo de personas el primer paso a realizar es crear un registro que contenga todos
estos campos:
TYPE
Datos = RECORD
Nombre : String[40];

Domicilio : String[60];
Edad : Integer;
EdoCivil : String[10];
END;
El siguiente paso es declarar un archivo del tipo Datos así como una variable del mismo tipo de los
que se utilizarán en el archivo:
VAR
Archivo : FILE OF Datos;
Persona : Datos;
Asignación de un archivo
Aún cuando se tenga declarado el archivo no es posible grabar nada en él si no se le asigna un
nombre real para guardarlo en el disco. El proceso de dicha asignación es el mismo que para los
archivos de texto:
Assign (Archivo, 'Nombre.ext');
Nombre.txt puede ser una constante, una variable o estar escrita directamente en el programa.
Naturalmente debe cumplir con todas las reglas para nombrar un archivo.
Abrir archivos
Una vez declarado un archivo ya es posible abrirlo. En caso de querer abrir un archivo nuevo se
utiliza la instrucción Rewrite, o si el archivo ya existe en el disco se abre con el procedimiento
Reset.
No existe ninguna diferencia entre la apertura de un archivo de acceso directo para su lectura o
para su escritura.
Si al utilizar el procedimiento Rewrite el archivo asignado ya existía se eliminará del disco y se
creará uno nuevo, por lo mismo se debe tener ciudado al momento de abrir estos archivos.
Registro actual y tamaño de un archivo
La función FileSize regresa el tamaño de un archivo, o mejor dicho devuelve el número de
registros contenidos en éste.
Al momento de abrir un archivo nuevo la función FileSize regresa el valor de 0, lo que significa que
el archivo no tiene datos guardados en él.
Posicionamiento en el interior de un archivo
Cada uno de los registros de un archivo esta referenciado por un número específico comenzando
desde el registro 0 y aumentando de 1 en 1.
La función FilePos devuelve el número de registro actual, su sintaxis es:
FilePos (VariableArchivo)

VariableArchivo es la variable a la cual se asignó un nombre de archivo en el disco.
Para moverse a un registro determinado se utiliza la función Seek, con la siguiente sintaxis:
Seek (VariableArchivo, NumRegistro);
Para moverse al final del archivo para agregar un nuevo registro se utiliza este mismo comando
con el parametro NumRegistro como sigue:
Seek (VariableArchivo, FileSize(VariableArchivo));
Cuando se avanza en un archivo registro por registro se utiliza la función EOF para determinar si
ya se llegó al final del archivo.
Lectura y escritura de archivos
Para la lectura y escritura en un archivo de acceso directo unicamente se utilizan los
procedimientos Read y Write. Despues de cada operacion de lectura o escritura el puntero se
posiciona en el siguiente registro.
Para estar seguros de que se leera el registro que se desea se debe emplear el procedimiento
seek antes de cualquier procedimiento de lectura o escritura.
Cerrar un archivo
Para cerrar los archivos abiertos se procede igual que en uno de acceso secuencial, utilizando el
procedimiento close:
Close (VariableArchivo);
Modo de Pantalla
Las constantes definidas de Turbo Pascal para indicar el modo de pantalla que se utilizará son:
Constante Valor Modo de video
BW40 0 40x25 Blanco y negro en tarjeta de color
CO40 1 40x25 Color
CO80 3 80x25 Color
Mono 7 80x25 Monocromático
Colores
Las constantes definidas para los colores son:
Colores para primer plano y fondo:
Constante Valor Color
Black 0 Negro
Colores para primer plano:
Constante Valor Color
Dark gray 8 Gris oscuro

Blue 1 Azul
Green 2 Verde
Cyan 3 Cyan
Red 4 Rojo
Magenta 5 Magenta
Brown 6 Marrón
Light Gray 7 Gris claro
Light Blue 9 Azul claro
Light Green 10 Verde claro
Light Cyan 11 Cyan claro
Light Red 12 Rojo claro
Light Magenta 13 Magenta claro
Yellow 14 Amarillo
White 15 Blanco
Parpadeo
Blink 128
La unidad CRT provee un conjunto de variables utilizadas para modificar aspectos referentes a
entradas de teclado, modo de la pantalla, etc. A continuación se listan las principales con su
función específica.
CheckBreak
Tipo : boolean.
Cuando el contenido de esta variable es True se encuentra activada la terminación de un programa
por medio de las teclas Crtl-Break. Si se cambia su valor a False se desactiva esta opción.
Su valor por defecto es True.
DirectVideo
Tipo : boolean.
Cuando existen problemas de entrada/salida de texto se debe desactivar esta variable (guardar en
ella el valor false) que inhibe la escritura directa de caracteres a la memoria de video.
LastMode
Tipo : Word
La variable LastMode contiene el valor del modo de texto actual. Se inicializa al momento de iniciar
el programa y se utiliza comunmente para restaurar el modo original al momento de terminar el
programa.
TextAttr
Tipo : Byte
Usualmente se utiliza para cambiar los atributos de colores en la pantalla, es más rápido que los
procedimientos TextColor y TextBackground que tienen la misma función.
WindMin

Tipo : Word; Esta variable contiene las coordenadas de la esquina superior izquierda de la ventana
de texto activa definida por el procedimiento Window.
WindMax
Esta variable contiene las coordenadas de la esquina inferior derecha de la ventana de texto activa
definida por el procedimiento Window.
A continuación se listan algunos de los procedimientos que incluye esta unidad con una breve
descripción de cada uno.
ClrEol
Sintaxis:
ClrEol;
Este procedimiento borra todos los caracteres de la linea actual desde la posición del cursor hasta
el final de la linea. Ejemplo:
PROGRAM Proc_ClrEol;
USES Crt;
VAR x,y : Integer;
BEGIN
FOR x := 1 TO 24 DO
FOR y := 1 TO 80 DO
Write('#');
GotoXY(15,15);
ClrEol;
END.
ClrScr
Sintaxis:
ClrScr;
Se utiliza para borrar la pantalla completa o la ventana actual y situa el cursor en la esquina
superior izquierda. Ejemplo:
PROGRAM LimpiarPantalla;
USES Crt;
VAR x,y : Integer;
Prb : String;
BEGIN
FOR x := 1 TO 24 DO
FOR y := 1 TO 80 DO
Write('#');
WriteLn('Presione [ENTER] para borrar la pantalla');
ReadLn(Prb);
ClrScr;
WriteLn('Se borró la pantalla');
END.

Delay
Sintaxis:
Delay(Tmp : Word);
Detiene la ejecución del programa durante un tiempo especificado en Tmp en milisegundos. El
intervalo válido es desde 0 hasta 65535, la precisión del retardo depende de la precisión del reloj
interno de la computadora. Ejemplo:
PROGRAM Retardo;
USES Crt;
BEGIN
WriteLn('Inicia retardo de aproximadamente 5 segundos');
Delay(5000);
WriteLn('Fin del retardo');
END.
DelLine
Sintaxis:
DelLine; Borra la linea donde se encuentra el cursor y las lineas inferiores suben una posición.
Ejemplo
PROGRAM BorrarLinea;
USES Crt;
VAR x : Integer;
prb : String;
BEGIN
ClrScr;
For x := 1 to 20 DO
WriteLn('Linea número: ', x);
WriteLn('Presione [ENTER] para borrar la linea 6');
GotoXY(0,6);
DelLine;
WriteLn('Linea 6 eliminada');
END.
GotoXY
Sintaxis:
GotoXY(x, y : Byte);
Posiciona el cursor en las coordenadas especificadas por x y y.
El byte x representa la columna partiendo de izquierda a derecha y el byte y representa la fila
partiendo de arriba hacia abajo. Ejemplo:
PROGRAM Posición;
USES Crt;
BEGIN
GotoXY(10,10);

Write('*');
GotoXY(20,20);
Write('*');
END.
HighVideo
Sintaxis:
HighVideo;
Activa la pantalla de video de alta intensidad.
InsLine
Sintaxis:
InsLine
Inserta una linea en blanco en la posición actual del cursor.
LowVideo
Sintaxis:
LowVideo
Activa la pantalla de video de baja intensidad.
NormVideo
Sintaxis:
NormVideo;
Restaura los atributos de primer plano y fondo a los colores originales establecidos cuando arrancó
el programa.
NoSound
Sintaxis:
NoSound;
Desactiva el sonido iniciado con el procedimiento Sound.
Sound
Sintaxis:
Sound (Frecuencia : Word);

Genera un sonido en la bocina de la computadora a una frecuencia determinada por el valor de
Frecuencia. Para detener el sonido es necesario ejecutar el procedimiento NoSound.
TextBackground
Sintaxis:
TextBackGround (Color : byte);
Se utiliza para seleccionar el color del fondo de la pantalla. Los valores que puede utilizar son del 0
al 7, también es posible utilizar las constantes predefinidas para los colores.
TextColor
Sintaxis:
TextColor (Color : Byte);
El procedimiento TextColor se usa para seleccionar el color del texto en la pantalla.
TextMode
Sintaxis:
TextMode (Modo : Word);
Define el modo de video, ésto es, el número de filas y columnas que se podrán mostrar en pantalla,
también si se mostrarán en blanco y negro o en color.
Los modos válidos de pantalla de texto son:
Constante Valor Modo de video
CO40 1 40x25 Color
CO80 3 80x25 Color
Mono 7 80x25 Monocromático
Window
Sintaxis:
Window (x1, y1, x2, y2 : Byte);
Define las coordenadas de la ventana de texto activa; x1 y y1 son las coordenadas de la esquina
superior izquierda, x2 y y2 son las coordenadas de la esquina inferior derecha.
Las siguientes son las funciones de la unidad CRT:

KeyPressed
Tipo: Boolean
La función KeyPressed devuelve el valor de True si se pulsó alguna tecla y false si no se ha
presionado ninguna.
ReadKey
Tipo: Char
Esta función lee un caracter del teclado, se utiliza mucho para leer teclas de dirección, teclas de
control y de funciones.
WhereX
Tipo: Byte
WhereX devuelve el número de la columna donde se encuentra el cursor.
WhereY
Tipo: Byte
La función WhereY devuelve el número de la fila donde se encuentra el cursor al momento de
llamar a la funcioacute;n.

programacion

Más contenido relacionado

Similar a programacion (20)

Último (20)

programacion