Manual IntProgramacion Nivel1 - Veroctubre2017

Introducción
a la
Programación
Nivel 1
Material elaborado por CENEAC Producciones, C.A.

Prohibida su reproducción total o parcial, por medios
impresos o digitales, sin autorización del Autor.
CENEAC Producciones, C.A.
Universidad Central de Venezuela, Facultad de Ciencias, Edif. III, Av. Los Ilustres, Los Chaguaramos, Caracas, Venezuela
Tlf. (58 212) 605-13-14 693-47-38 (telfax) correo ceneac@ciens.ucv.ve www.ceneac.com.ve
CENEAC – Introducción a la Programación con Nivel 1.
Material elaborado por CENEAC Producciones, C.A. Prohibida su reproducción total o parcial sin autorización del Autor.
INDICE
1. Introducción .......................................................................................................................................... 1
1.1. Conceptos Básicos ..................................................................................................................... 1
1.2. Definición de los elementos presentes en un Algoritmo.............................................................. 3
Tipos de datos............................................................................................................................. 3
Constantes, Variables y Expresiones .......................................................................................... 4
Acciones Básicas ........................................................................................................................ 7
Formas de Composición de Acciones ......................................................................................... 8
2. Procedimientos y Funciones ............................................................................................................... 12

2.1. Paso de Parámetros en Procedimientos y Funciones ................................................................ 12
2.2. Alcance: Variables Locales y Variables Globales....................................................................... 18
3. Formas Iterativas de Composición de Acciones (Ciclos) .................................................................... 19

3.1. Ciclo Para ( for ) ......................................................................................................................... 19
3.2. Ciclo Repetir ( repeat ) ............................................................................................................... 21
3.3. Ciclo Mientras ( while ) ............................................................................................................... 22
4. Talleres de Ejercicios ......................................................................................................................... 24

4.1. Taller 1: Expresiones .................................................................................................................. 25
4.2. Taller 2: Secuenciamiento y Condicionales................................................................................ 26
4.3. Taller 3: Estructuras Iterativas o Ciclos ..................................................................................... 27
Anexo 1: Lenguaje de Programación Turbo Pascal
1. Guía de Sintaxis de Turbo Pascal...................................................................................................... A2

1.1. Elementos Básicos del Lenguaje .............................................................................................. A3
Palabras Reservadas ............................................................................................................... A3
Identificadores .......................................................................................................................... A3
Cadena de caracteres .............................................................................................................. A4
Línea de programa ................................................................................................................... A4
Estructura de un programa....................................................................................................... A4
Procedimientos y Funciones .................................................................................................... A5
1.2. Tipos de Datos .......................................................................................................................... A5
Tipos Simples........................................................................................................................... A5
Tipo Subrango.......................................................................................................................... A6
Tipo Enumerado....................................................................................................................... A6
Tipo Estructurado ..................................................................................................................... A7
1.3. Variables y Constantes.............................................................................................................. A7

Constantes predefinidas........................................................................................................... A7
Declaración de variables .......................................................................................................... A7
Constantes con tipos ................................................................................................................ A8
Alcance de las variables........................................................................................................... A8
1.4. Operadores ............................................................................................................................... A9
Aritméticos ............................................................................................................................... A9
Lógicos ..................................................................................................................................... A9
Relacionales............................................................................................................................. A9
De Conjuntos ......................................................................................................................... A10
Concatenación ....................................................................................................................... A10
1.5. Sentencias .............................................................................................................................. A10
Asignación o Igualación ......................................................................................................... A10
Compuesta ............................................................................................................................. A10
Condicional ( if ) ..................................................................................................................... A11
Condicional anidado ( if )........................................................................................................ A11
Ciclo Para ( for ) ..................................................................................................................... A11
Ciclo Repetir ( repeat ) ........................................................................................................... A12
Ciclo Mientras ( while ) ........................................................................................................... A12
Comparación entre los ciclos Repetir y Mientras ................................................................... A12
1.6. Procedimientos y Funciones estándar .................................................................................... A12
Funciones Aritméticas ............................................................................................................ A12
Funciones de transferencia .................................................................................................... A13
Procedimientos o Funciones ordinales .................................................................................. A13
Tratamiento de cadenas......................................................................................................... A14
Anexo 2: Reglas de Traducción al Lenguaje Pascal ………………………………………………. A15
1.- Reglas de Traducción para Tipos de Datos ................................................................................ A16
2.- Reglas de Traducción de la Notación Algorítmica al Lenguaje Pascal ....................................... A17
Anexo 3: Ejemplos de Programas en Turbo Pascal ......................................................................... A19
1. INTRODUCCIÓN
1.1 Conceptos Básicos

A partir de los años 80, la masificación en el uso de los computadores se ha convertido en una realidad, de tal forma que
hoy en día son una herramienta indispensable en casi todas las actividades del quehacer humano.
A pesar de las diversas áreas en las que el computador juega un papel preponderante y del desarrollo tecnológico, que ha
llevado de los grandes computadores (main frames) a los microcomputadores actuales, las componentes básicas de un
computador siguen siendo: el hardware y el software.
El hardware de un computador es el conjunto de componentes físicas que lo forman, siendo las tres componentes
principales del hardware:
 La memoria principal o memoria RAM (Random Access Memory) • La Unidad Central de Proceso o CPU
 Los Dispositivos Periféricos.
La memoria principal o memoria RAM es la componente encargada del almacenamiento tanto de los programas como de
los datos a ser procesados. El rendimiento de una memoria se mide en términos de su capacidad (tamaño medido en MB o
GB) y de la velocidad con que los datos son almacenados y recuperados.
La Unidad Central de Proceso o CPU es la componente encargada de realizar los cálculos y transformaciones sobre los
datos, para obtener los resultados; así como también de “gobernar” las diferentes componentes del computador. El CPU
está formado por dos componentes principales:
 Unidad de Control, parte encargada de “gobernar” a las distintas componentes del computador.
 Unidad Aritmético-Lógica o ULA, componente encargada de realizar los cálculos y transformaciones sobre los datos.
El rendimiento del CPU se mide en términos de su velocidad (medida en MHz o GHz) para efectuar los cálculos.
Los Dispositivos Periféricos tienen como función principal permitir la comunicación entre el usuario y el computador, ya
sea para la captura de datos o presentación de resultados.
Estos dispositivos pueden clasificarse, de acuerdo a su utilización, en tres categorías:
 Dispositivos de Entrada:
Son aquellos dispositivos que sólo permiten la comunicación Usuario  Computador. Por ejemplo: el teclado, el
ratón, el micrófono, los controles para juegos (joystick), el escáner, etc.
 Dispositivos de Salida:
Son aquellos dispositivos que sólo permiten la comunicación Computador  Usuario. Por ejemplo: la impresora
(salida permanente), el monitor (salida no permanente), las cornetas, etc.
 Dispositivos de Entrada/Salida:
También llamados memorias auxiliares o secundarias, son aquellos dispositivos que permiten la comunicación
Usuario  Computador; además, estos dispositivos le proporcionan al computador un medio de almacenamiento de
información adicional, desde el cual es posible leer o escribir información. Ejemplos de estos dispositivos son: la
unidad de disquete, la unidad de CD, DVD, disco duro (fijos y USB), pendrive, tarjetas flash, pantallas táctiles, etc.
El software de un computador es el conjunto de programas (sistemas) que permiten la utilización de los recursos del
computador y comprende:
 Programas para el control del computador (Sistemas Operativos, Interpretadores, Compiladores,...)
 Programas de aplicación para la resolución de una amplia gama de problemas mediante el computador (Sistemas
Administrativos, Bases de Datos, Editores de Texto, Editores Gráficos, Editores de Páginas Web,...)
Material elaborado por CENEAC Producciones, C.A. Prohibida su reproducción total o parcial sin autorización del Autor. 1
La disciplina dentro de la computación dedicada a la resolución de problemas mediante el computador es la Programación,

cuyo producto final son los Programas, los cuales tienen como finalidad dar órdenes a una máquina (computador), a fin de
obtener resultados.
Para la elaboración de un programa, el programador debe atacar dos aspectos fundamentales:
 Organizar los datos en la memoria del computador (Estructuración de los Datos).
 Definir el proceso de tratamiento de esos datos (Estructuración de los Programas).
Abstracción
Mecanismo intelectual principal en la actividad de la programación, el cual durante la etapa de análisis del problema permite
la separación de los aspectos relevantes de los irrelevantes en el contexto estudiado.
Análisis Descendente
Método de análisis que consiste en la aplicación sucesiva de la capacidad de abstracción sobre un problema determinado,
lo cual permite la descomposición del problema en subproblemas, tales que, la composición de sus soluciones constituyen
una solución al problema original. A su vez, para la obtención de la solución de cada subproblema se puede aplicar
nuevamente este método. De esta forma, la solución del problema se presenta por etapas, conocidas como Niveles de
Abstracción.
Analogía
Para conseguir una solución de un problema, el análisis puede conducir a considerar problemas análogos más simples, en
los que una solución se conoce. La analogía puede establecerse poniendo en relación elementos de diferente índole:
métodos, acciones a seguir, datos, resultados, ... del problema cuya solución es conocida y del problema a resolver.
Objeto
Elementos de un algoritmo que pueden tener asociado un valor.
Estado
Es el conjunto de valores que poseen los objetos de un algoritmo en un momento dado.
Instrucciones o Acciones
Es un suceso que dura un tiempo finito y produce un resultado o efecto perfectamente definido y previsto. Toda acción
opera sobre algún objeto y es posible reconocer el efecto de tal acción por los cambios de estado presentados por el objeto.
Por lo tanto, una acción está perfectamente determinada por sus estado inicial (antes de realizar la acción) y final (después
de realizar la acción).
Algoritmo
Es una secuencia finita de pasos (instrucciones), expresados en un lenguaje natural o pseudo-formal, que resuelven un
problema dado.
Programa
Es un algoritmo expresado o traducido a un Lenguaje de Programación con el objetivo de dar órdenes a un dispositivo o
máquina.
Máquina o Dispositivo
Es un mecanismo capaz de realizar acciones según un patrón determinado (programa) el cual es descrito mediante un
repertorio finito de acciones elementales propio de cada máquina.
Resolución de problemas de programación
Así, la principal razón para que las personas aprendan lenguajes y técnicas de programación es utilizar al computador como
una herramienta para resolver problemas a través de la creación y ejecución de programas.
La resolución de un problema exige al menos la realización de las siguientes actividades:
1. Análisis del problema 2. Diseño del algoritmo 3. Traducción del algoritmo para obtener el programa
4. Ejecución y validación del programa.
1.2 Definición de los Elementos presentes en un Algoritmo

Para expresar la solución de un problema a través de un algoritmo, es necesario definir primero el lenguaje con el cual se
escribirá el algoritmo. El uso de lenguaje natural (por ejemplo, castellano) para estos fines presenta una serie de
inconvenientes, tales como ambigüedad (diferentes interpretaciones a una misma oración) e imprecisión (dificultad para
expresar ideas). Estos inconvenientes conducen a la necesidad de definir los elementos presentes en un algoritmo a través
de la definición de una Notación Algorítmica (o Lenguaje Pseudo-formal) en la cual dichos inconvenientes se minimicen o
eventualmente eliminen. Además, la Notación Algorítmica a definir y utilizar debe:
 Ser fácil de leer y entender
 Reflejar de una manera directa el análisis que produjo la solución del problema
 Ser poderosa, esto es, que con pocos elementos se puedan expresar muchas cosas.
A continuación, serán presentados los diferentes elementos que conforman un algoritmo a través de la definición de la
Notación Algorítmica que utilizaremos para escribir los algoritmos. La presentación de estos elementos se hará a través de
ejemplos tipo.
Generalmente, los problemas están especificados en términos de un conjunto de informaciones iniciales (datos) y del
cálculo que se desea efectuar para obtener los resultados (requerimientos). Por lo tanto, para la definición de una Notación
Algorítmica, para expresar la solución de dichos problemas, es necesario especificar los diferentes Tipos de Datos
(conjuntos de valores que pueden tomar la información y las operaciones que pueden aplicarse sobre ellos). Así como
también, las diferentes maneras en que se pueden expresar dichos valores (constantes, variables y expresiones).
1.2.1 Tipos de Datos

Un tipo de dato es el conjunto de valores que puede tomar la información y las operaciones que se pueden realizar sobre
esos valores. Los tipos de datos se clasifican en:
 Tipos de datos no estructurados: son aquellos cuyos valores no pueden dividirse en componentes.
 Tipos de datos estructurados (Estructuras de Datos): son aquellos cuyos valores están formados por componentes y
por lo tanto pueden descomponerse en términos de los valores que los constituyen.
En principio sólo consideraremos los Tipos de Datos no estructurados, dejando para la parte final la manipulación de los
Tipos de Datos Estructurados.
Tipos de Datos no Estructurados

Los distintos tipos de datos se representan en diferentes formas en el computador, siendo esta representación un conjunto o
secuencia de bits (dígitos 0 o 1). Los lenguajes de programación de alto nivel permiten al programador hacer abstracción de
la manera como los datos son representados. Los tipos de datos no estructurados con los que se trabajará se pueden
clasificar en:
 Numéricos (entero, real)  Lógicos o Booleanos  Caracteres (carácter, string o cadena)
Tipo de dato Entero

El tipo entero es un subconjunto finito de los números enteros (números que no tienen parte decimal), pudiendo ser
positivos o negativos.
Los siguientes son ejemplos de valores de tipo entero: 5 -15 1340 -325 0 12000
Tipo de dato Real

El tipo real es un subconjunto finito de los números reales. Los números reales están formados por una parte entera y una
parte decimal, pudiendo ser positivos o negativos.
Los siguientes son ejemplos de valores de tipo real: 5.0 -15.25 1340.3 -325.1245 0.007
Tipo de dato Lógico

El tipo lógico, también denominado booleano, es aquel conformado por dos valores: verdadero y falso.
Este tipo de dato se utiliza para representar las alternativas (si/no) a determinadas condiciones.
Tipo de dato Carácter

El tipo carácter, esta conformado por el conjunto finito y ordenado de caracteres que el computador reconoce, pudiendo ser
diferentes de un computador a otro. Los siguientes son ejemplos de valores del tipo carácter:
 Caracteres alfabéticos (A, B, C, ....., Y, Z) (a, b, c, ......, y, z).
 Caracteres numéricos (1, 2, 3, ....., 9, 0).
 Caracteres especiales (+ , - , * , / , ; , . , < , > , = , $ , @ , % , ....... )
Tipo de dato String (cadena)

El tipo string, es una sucesión de caracteres delimitados por comillas. La longitud de la cadena de caracteres es el número
de ellos comprendidos entre las comillas. Los siguientes son ejemplos de valores del tipo string:
"Luis Rivas" "A, B, C" ""
" " "8 de octubre de 2.015" "Sr. Pastor"
1.2.2 Constantes, Variables y Expresiones

Existen tres maneras de denotar a los valores de los distintos tipos de datos, estas son:
 Constantes: denotación de un valor particular del conjunto.
 Variables: denotación de un valor genérico del conjunto.
 Expresiones denotación de valores a partir operaciones entre constantes y variables.
Constantes
Son valores que no cambian durante la ejecución del algoritmo (programa).
Ejemplos de constantes según su tipo de dato:
Tipo Ejemplos
Entero 0 345 -124 200 32456 -9799
Real 0.1 12.25 -3.25 350.0 -123.3 1234.5643
Lógico verdadero falso
Carácter "A" "X" "1" "$" "7"
String "Casa" "18 de julio" "US$ 300.7"
Variables
Una variable es un objeto cuyo valor puede cambiar durante el desarrollo del algoritmo o la ejecución del programa. Cada
variable tendrá entonces asociado un tipo de dato, pudiendo sólo tomar valores de ese tipo.
Los nombres de las variables, a veces conocidos como identificadores, pueden constar de varios caracteres alfanuméricos
(letras y números) de los cuales el primero debe ser una letra. Ejemplos de nombres válidos de variables: A3, NOMBRE,
CONTADOR, SW.
Los nombres elegidos para las variables del algoritmo (programa) deben ser significativos y tener relación con el objeto que
representan, para así facilitar la lectura del mismo.
Expresiones
Las expresiones son combinaciones de constantes, variables, operadores y paréntesis. Cada expresión al ser evaluada
toma un valor que se determina aplicando los operadores a los valores de las constantes y variables implicadas en la
expresión. Dependiendo del valor resultante de evaluar la expresión se tiene el tipo de la expresión. Así, encontramos
expresiones aritméticas (resultado entero o real), expresiones lógicas (resultado lógico) y expresiones de tipo carácter
(resultado carácter o string).
Expresiones Aritméticas
A continuación se presentan los diferentes operadores aritméticos que se pueden utilizar para la construcción de
expresiones aritméticas, indicando el tipo de operando que admiten y el tipo del resultado de la expresión.
Operador Significado Tipo de Operandos Tipo de Resultado
** Exponenciación Entero o real Entero o real
div División entera Entero Entero
mod Resto de la división entera Entero Entero
/ División real Entero o Real Real
* Multiplicación Entero o real Entero o real
- Resta Entero o real Entero o real
+ Suma Entero o real Entero o real
Los siguientes ejemplos muestran resultados de expresiones aritméticas, compruébelos:
Expresión Resultado Expresión Resultado

10.5 / 3.0 3.5 10 div 3 3
1/4 0.25 18 div 2 9
2.0 / 4.0 0.5 30 div 30 1
6/1 6.0 6 div 8 0
Reglas de Prioridad
Cuando las expresiones tienen dos o más operandos, se requieren reglas que permitan evitar ambigüedades al momento
de realizar la evaluación de la expresión. Estas se denominan Reglas de prioridad o de precedencia y son:
a) Las operaciones que están encerradas entre paréntesis se evalúan primero. Si existen diferentes paréntesis
anidados (unos dentro de otros), las expresiones más internas se evalúan primero.
b) Las operaciones aritméticas se realizan de acuerdo al siguiente orden de prioridad.
 Exponencial ( ** )
 División real ( / ), división entera ( div ), resto de la división entera ( mod ) y multiplicación ( * )
 Suma ( + ) y resta ( - )
En caso de coincidir varios operadores de igual prioridad en una expresión o subexpresión encerrada entre paréntesis, el
orden de prioridad será de izquierda a derecha.
Expresiones Lógicas
Una expresión lógica es aquella que al ser evaluada puede tomar sólo uno de estos dos valores: verdadero o falso. Las
expresiones lógicas se forman combinando constantes lógicas, variables lógicas y otras expresiones lógicas, utilizando los
operadores lógicos no, y, o, y los operadores relacionales (de relación o comparación) =, <, >, <=, >=, <>.
Operadores Lógicos
Operador Significado Ejemplo de Expresión
no Negación no P
y Conjunción PyQ
o Disyunción PoQ
Operadores Relacionales
< Menor que A<3
> Mayor que P>Q
= Igual P=1
<= Menor o igual A <= P
>= Mayor o igual P >= Q
<> Diferente P <> Q
Los siguientes ejemplos muestran resultados de expresiones lógicas, compruébelos.

Expresión Resultado Expresión Resultado
(1 > 0) y (3 = 3) verdadero (0 < 5) o (0 > 5) verdadero
5 >= 7 falso P o (no P) verdadero
(A > 0) y (A < 0) falso P y (no P) falso
5<0 falso 5=0 falso
Prioridad de los operadores (aritméticos y lógicos)
Operador Prioridad
**, no Más alta (primera operación ejecutada)
/, *, div, mod, y 
+, -, o
<, >, =, <=, >=, <> Más baja (última operación ejecutada)
Al igual que en las expresiones aritméticas, los paréntesis se pueden utilizar y tendrán prioridad sobre cualquier operación.
Además, en caso de coincidir varios operadores de igual prioridad en una expresión o subexpresión encerrada entre
paréntesis, el orden de prioridad será de izquierda a derecha.
Expresiones String
Una expresión de tipo string es aquella que al ser evaluada produce un valor de tipo string. Las expresiones string se
forman combinando constantes, variables y otras expresiones de tipo string lógicas, utilizando los operadores del tipo string:
concatenar y subcadena. En el caso de concatenar se utilizan diversos operadores, los comunes: || + &
Operadores string
|| + & Concatenación "Pedro y " || "Pablo"
substr(string,inicio,tamaño) Subcadena substr("Pedro",1,2)
Los siguientes ejemplos muestran resultados de expresiones string

Expresión Resultado
"Pedro y " + " Pablo" "Pedro y Pablo"
substr("Pedro",1,2) "Pe"
substr("Casa roja",6,4) "roja"
1.2.3 Acciones Básicas

Se definirán tres acciones básicas: asignación, entrada simple (lectura) y salida simple (escritura), a partir de las
cuales, mediante las formas de composición de acciones, se crearan acciones más complejas que permitirán expresar la
solución de cualquier tipo de problema.
Asignación ( = )
Esta acción es la base para la construcción de las soluciones de los problemas; ya que permite modificar el estado de los
objetos que conforman el algoritmo y de esta forma obtener los resultados requeridos.
Ejemplos. Sean A y P variables de tipo entero, PI variable de tipo real, C variable de tipo lógico y S variable de tipo string.
A = -3 (a la variable A se le asigna u otorga el valor -3)
PI = 3,1415
P = -9 * A
C = (PI = 8,1)
P = P+1
S = "Perro Nro. " + P
El operador = se conoce como operador de asignación (también se utiliza “”) y tiene como efecto el cambio de estado
(cambio de valor), de la variable que aparece a la izquierda de él. Cabe estacar que el operador = también puede ser
utilizado para realizar comparaciones entre expresiones y verificar sin sus valores son iguales.
Para los ejemplos anteriores, el efecto de cada acción de asignación es:
Acción Efecto de la asignación

A = -3 A toma el valor 3 (o el valor 3 se le asigna a la variable A)
PI = 3,1415 PI toma el valor 3,1415 (a PI se le asigna el valor 3,1415)
P = -9 * A P se le asigna el resultado de -9 por el valor de A (-3), es decir, se la asigna 27
C = (PI = 8,1) C se le asigna el resultado de comparar si el valor de PI es igual a 8,1 pero
como son distintos, a C se le asigna Falso
P = P+1 P toma su valor más 1, es decir, a P se le asigna 28
S = "Perro Nro. " + P S se le asigna la concatenación o de la cadena "Perro Nro." con el valor de P, S
toma entonces como valor la cadena “Perro Nro. 28”
Entrada Simple ( Leer )

La entrada simple o lectura permite nominar información que se encuentra almacenada en un dispositivo de entrada.
Ejemplos: Sean A y B dos variables de tipo entero
Leer(A) Leer(B)
La operación Leer indica que de algún dispositivo de entrada externo, del cual se hace abstracción, se está copiando un
valor sobre la variable que aparece entre paréntesis. Esta acción tiene como efecto el cambio de valor (o cambio de estado)
de la variable entre paréntesis.
NOTA: ¿POR QUÉ SUBRAYAR ALGUNAS PALABRAS?
Es común observar en los algoritmos que algunas de las instrucciones se destacan, bien sea con negritas o subrayándolas.
Esto se hace con el objetivo de destacarlas como palabras reservadas o instrucciones que tienen un significado especial
en el pseudocódigo. Se destacan porque tienen un uso especial, y por lo tanto, esas palabras no se pueden usar como
nombres o identificadores de constantes, variables o procedimientos.
Salida Simple ( Escribir )

La salida simple o escritura es la acción que se utiliza para mostrar los valores almacenados en las variables, se utiliza
frecuentemente para mostrar los resultados obtenidos por el algoritmo o programa.
Ejemplos: Sea A variable de tipo entero
A = 5 * 20 Escribir(A) Escribir(A + 1)
La operación Escribir indica que a través de algún dispositivo de salida externo, del cual se hace abstracción, se está
escribiendo o mostrando el valor que aparece entre paréntesis.
Intradocumentación o comentarios ( // )
Esta acción permite agregar al algoritmo comentarios sobre la utilidad de sus instrucciones. La intradocumentación del
código es una buena práctica algorítmica y de programación ya que ayuda al mejor entendimiento de la lógica utilizada en la
solución que el algoritmo plantea a un problema dado. Uno de los operadores utilizados para agregar comentarios en
pseudocógigo es //, mientras que en algunos lenguajes se usan combinaciones como: (* *) /* */ ‘ # / 
1.2.4. Formas de Composición de Acciones

Las formas de composición de acciones son los mecanismos mediante los cuales se construirán nuevas acciones a partir
de acciones ya creadas. A continuación se presentan las formas de composición de acciones más usuales, así como
también ejemplos de sus usos.
Las siguientes convenciones serán usadas en la presentación:
 Las letras mayúsculas A, B, C, … representarán acciones cualesquiera.
 Las letras griegas , , , … representaran expresiones lógicas (predicados).
 Las iniciales EI y EF denotarán a los Estados Inicial y Final de las acciones, respectivamente.
Secuenciamiento
La forma de composición de acciones más natural es el secuenciamiento, el cual simplemente consiste en la presentación
de un conjunto de acciones en un cierto orden. Permite indicar el orden en que se desea se ejecuten una serie de acciones.
Notación
Sean A, B, C acciones cualesquiera. El secuenciamiento de ellas en el orden A, B, C se expresa de la siguiente forma:
A
B (orden textual)
C
o bien A ; C ; B; (orden dado mediante el operador de secuenciamiento “ ; “)
EJEMPLO 1: Intercambio de dos valores

Enunciado
Dadas dos variables n1 y n2 que identifican a dos valores enteros cualesquiera, intercambiar su valor.
Análisis
Para la solución del problema es necesario evitar la pérdida del valor de una de las dos variables, pérdida que se deriva de
una utilización directa de la asignación, por eso se utilizará una tercera variable aux. De las versiones que se presentan, la
primera resuelve el problema con la ayuda de una variable auxiliar (solución por memorización) y la segunda lo resuelve
mediante acumulaciones basadas en las propiedades de los operadores + y – (solución por cálculo).
Solución de la Primera Versión Solución de la Segunda Versión

Escribir(“Suministre los 2 números de entrada.”); Escribir(“Suministre los 2 números de entrada.”);
Leer(n1); Leer(n2); Leer(n1); Leer(n2);
EI = { n1 = x, n2 = y, x, y  ENTEROS } EI = { n1 = x, n2 = y, x, y  ENTEROS }
aux = n1; //se guarda en aux para no perder n1 n1 = n1 + n2;
n1 = n2; n2 = n1 – n2;
n2 = aux; n1 = n1 – n2;
EF = { n1= y, n2 = x, x, y  ENTEROS } EF = { n1 = y, n2 = x, x, y  ENTEROS }
Escribir(“Resultado luego del intercambio: ”); Escribir(“Resultado luego del intercambio: ”);
Escribir(n1); Escribir(n2); Escribir(n1); Escribir(B);
Léxico Léxico
Entero n1, n2: Nominan a los valores a intercambiar Entero n1, n2: Nominan a los valores a intercambiar
Entero aux: Variable auxiliar para el proceso
Ejemplo 2: Equivalencia de una cantidad en segundos a días, horas, minutos y segundos

Enunciado
Dadas un valor entero y positivo S, que representa una cantidad en segundos, se quiere hallar su equivalente en días,
horas, minutos y segundos sobrantes.
Análisis
La solución consiste hacer divisiones sucesivas sobre el número de segundos inicial para hallar las equivalencias.
Solución
Escribir(“Suministre la cantidad inicial de segundos.”); Leer(S);
EI = { S = x, x > 0, x  ENTEROS }
MIN = S div 60 ; SEG = S mod 60; // div y mod son operadores y palabras reservadas
HOR = MIN div 60 ; MIN = MIN mod 60;
DIA = HOR div 24 ; HOR = HOR mod 24;
EF = { S = x, x > 0, SEG = se, MIN = m, HOR = h, DIA = d, x, se, m, h, d  ENTEROS, h < 24, m < 60,
se < 60, s = (( d * 24 + h) * 60 + m) * 60 + se }
Escribir(“El equivalente de segundos en días, horas, minutos y segundos es: ”);
Escribir(DIA); Escribir(HOR); Escribir(MIN); Escribir(SEG);
En este caso sería más conveniente utilizar un Escribir con múltiples valores: Escribir (DIA, HOR, MIN, SEG)
Léxico
Entero S: Variable que nomina al valor en segundos dado.
Entero SEG, MIN, HOR, DIA: Variables para almacenar la cantidad de segundos, minutos, horas y días
respectivamente, calculadas a partir del valor dado.
Condicional simple
El condicional simple es una forma de composición de acciones que se utiliza en problemas donde las acciones a realizar
dependen del resultado de evaluar ciertas condiciones.
Notación
Sea  un predicado (expresión lógica) que condiciona la ejecución de una acción A cualquiera, el condicionamiento de la
acción A al predicado  se expresa:
Si  entonces
A;
Fsi;
En este análisis, la acción A sólo se ejecutará si el predicado  al ser evaluado es verdadero.
Ejemplo 3: Ordenamiento de dos valores

Enunciado
Dadas dos variables a y b que identifican a dos valores enteros respectivamente, se quiere modificar eventualmente esas
identificaciones de tal manera que a nomine al valor más grande y b al más pequeño.
Análisis
Un análisis inicial del problema indica que eventualmente debemos intercambiar los valores de las variables, lo cual nos
lleva a un problema cuya solución es conocida (Intercambio de dos valores). El centro de la solución está en la respuesta a
la pregunta ¿Cuándo debemos intercambiar?
Solución
Escribir(“Suministre los valores de los dos números a comparar.”); Leer(a, b); //solicitud y lectura de valores
EI = { a = e1, b = e2, e1, e2  ENTEROS }
Si a < b entonces // a es menor que b, por lo tanto hay que intercambiar sus valores
c = a ; a = b ; b = c; // reutilizamos las instrucciones para intercambiar valores
Fsi;
EF = { a = máximo(e1,e2), b = mínimo(e1,e2), e1, e2  ENTEROS }
Escribir(“El valor máximo es: ” + A + “ y el mínimo es; ” + B );
Léxico
entero a, b: variables para los valores a ordenar como máximo y mínimo.
entero c: variable auxiliar para no perder uno de los dos valores de entrada.
Condicional doble
El condicional doble es una forma de composición de acciones que se utiliza en problemas donde las acciones a realizar
dependen de si el resultado de evaluar ciertas condiciones es verdadero o falso; esto es, las acciones se ejecutan de
manera excluyente.
Notación
Sean A y B acciones cualesquiera y sea  un predicado (expresión lógica) que condiciona la ejecución de las acciones A y
B en forma excluyente; esto es si  es verdadero se ejecutará la acción A y si  es falso se ejecutará la acción B. Este tipo
de condicionamiento se expresa de la siguiente forma:
Si  entonces
A;
sino
B;
Fsi;
En este análisis, sólo se ejecutará una de las dos acciones, dependiendo del valor resultante de evaluar el predicado 
Ejemplo 4: Máximo de dos valores

Enunciado
Dadas dos variables a y b que identifican a dos valores enteros e1 y e2 respectivamente, se quiere determinar cual de los
dos valores es el mayor.
Análisis
La solución se basa en la determinación de una partición del dominio de los datos, que refleje los casos posibles asociados
al problema.
Solución
Escribir(“Suministre los valores de los dos números a comparar.”); Leer(a, b); // solicitud y lectura de valores
EI = { a = e1, b = e2, e1, e2  ENTEROS }
Si a > b entonces
Escribir(“El mayor valor es: ” + a); // el mayor valor lo tiene la variable a
Sino
Si a < b entonces
Escribir(“El mayor valor es: ” + b); // el mayor valor lo tiene la variable b
Sino
Escribir(“Ambos valores son iguales”)
Fsi;
Fsi;
EF = { se escribió el mayor valor entre a y b, o se indicó que ambos son iguales }
Léxico
entero a, b: variables que nominan a los valores de entrada dados
2. PROCEDIMIENTOS Y
FUNCIONES
2.1. Paso de Parámetros en Procedimientos y Funciones

La nominación de acciones es un mecanismo que permite asociarle un nombre a un conjunto de acciones, para luego
referirse al conjunto mediante ese nombre. Dependiendo de ciertas características propias de la Acción Nominada, esta
puede ser un Procedimiento o una Función.
Este mecanismo de asociarle un nombre a un conjunto de acciones, puede utilizarse como:
 Simplificación en la escritura del algoritmo, al "factorizar" un conjunto de acciones que se repiten.
 Una forma de abstracción, al dar un nombre a una acción que se especifica y posteriormente se desarrolla (análisis
descendente).
La especificación de una Acción Nominada (procedimiento o función) es una caracterización del efecto de la acción
independientemente de su desarrollo. Por lo tanto toda Acción Nominada tiene un sola especificación (¿Qué hace la
acción?) y una o más realizaciones (¿Cómo lo hace?)
Notación de Procedimientos.
Definición de Procedimientos
La definición de un procedimiento consta de dos partes:
1. El encabezado del procedimiento (primera línea)
2. El cuerpo del procedimiento (líneas restantes)
Ejemplo de definición de procedimientos

Con A, B, C y D acciones cualesquiera y  un predicado (expresión lógica)
procedimiento NOMBRE ( lista de parámetros formales )
// comentario con el objetivo o especificación de la función
A;
C;
B;
fprocedimiento NOMBRE;
Uso de procedimientos
Para ejecutar el Procedimiento antes definido, basta colocar su nombre seguido de una lista de parámetros actuales
sobre los que se aplicará el conjunto de acciones agrupadas en el procedimiento.
Ejemplo de uso de procedimientos

B;
C;
Si  entonces
D;
sino
NOMBRE (lista de parámetros actuales)
Fsi;
A;
Notación de Funciones
Definición de Funciones
La definición de una función también consta de dos partes:
1. El encabezado de la función (1era. línea)
2. El cuerpo de l función (líneas restantes)
Ejemplo de definición de funciones

Con A, B, C y D acciones cualesquiera
función NOMBRE ( lista de parámetros formales ) : tipodedatodelretorno
// comentario con el objetivo o especificación de la función
A;
C;
Retornar(valor_resultado_que_retorna);
ffunción NOMBRE;
Uso de funciones
Para ejecutar una función, basta colocar su nombre seguido de una lista de parámetros actuales sobre los que se
aplicará la función a la derecha de un operador de asignación. Las funciones retornan un solo valor.
Ejemplo de uso de funciones

B;
D;
Variable = NOMBRE (lista de parámetros actuales);
A;
Tanto para el caso de los procedimientos como en el de las funciones, se tiene que:
a) Lista de parámetros formales es una serie de 0 ó más variables que se utilizaran dentro del cuerpo de la Acción
Nominada (procedimiento o función).
b) Lista de parámetros actuales es una serie de 0 ó más constantes, variables y/o expresiones sobre las cuales se
desea aplicar la Acción Nominada (procedimiento o función). Estos deben especificarse en cada llamada a la Acción
Nominada y contienen los valores que sustituirán a los parámetros formales, es decir, los valores sobre los cuales se
desea aplicar la Acción Nominada; pudiendo cambiar de una llamada a otra.
c) Debe existir una correspondencia uno a uno tanto en el tipo como en el número de parámetros actuales y formales,
la cual en general se establece de acuerdo al orden de colocación de los mismos.
d) Dependiendo del tipo de sustitución deseada, se definen diversas maneras de realizar el Paso de Parámetros,
siendo las dos más utilizadas las denominadas: Paso de parámetros por valor y Paso de parámetros por referencia.
Paso de Parámetros por Valor

Bajo este esquema, el parámetro actual se evalúa y el valor resultante de la evaluación sustituye al correspondiente
parámetro formal; de tal forma que, independientemente de los cambios que sufra el parámetro formal, durante la ejecución
de la Acción Nominada, el valor del parámetro actual correspondiente no se modificará.
Paso de Parámetros por Referencia

Bajo este esquema, el parámetro actual se evalúa y el valor resultante de la evaluación sustituye al correspondiente
parámetro formal; de tal forma que, cualquier cambio que sufra el parámetro formal, durante la ejecución de la Acción
Nominada, afectará el valor del parámetro actual correspondiente. Así, el parámetro actual puede cambiar su valor una vez
ejecutada la Acción Nominada.
Para distinguir las dos clases de Paso de Parámetros, se postulan las siguientes reglas:
1. El Paso de Parámetros por Valor es la forma más frecuente de sustitución y por ende se tomará por defecto.
2. El Paso de Parámetros por Referencia se indica colocando el símbolo var antes de parámetro formal
correspondiente.
Para ilustrar los conceptos relacionados con los tipos de Paso de Parámetros, se presenta el siguiente ejemplo.
Ejemplo 5: Diferencia entre el Paso de Parámetros por Valor y por Referencia
Sea el siguiente procedimiento:
procedimiento EJEMPLO (var Entero X , Entero Y)
// Ejemplo para mostrar el efecto de los dos tipos de paso de parámetros
X = X + 5;
Y = Y + 5;
fprocedimiento EJEMPLO;
y sea el siguiente fragmento de algoritmo que llamo o utiliza al procedimiento Ejemplo:

Entero A, B; // declaración de las variables y del tipo de dato de sus valores
A = 10; B = 10;
EJEMPLO( A , B )
// al regresar del procedimiento EJEMPLO A = 15 y B = 10
Escribir(“los valores de A y B luego de llama a EJEMPLO son: ” + A + “ - ” + B);
Una vez realizada la llamada al procedimiento EJEMPLO, los valores que se imprimen son 15 y 10 respectivamente, los
cuales corresponden a los valores que almacenan los parámetros actuales A y B. Note que el valor del parámetro A cambió
(por haber sido pasado por referencia) mientras que el valor del parámetro B no cambió (por haber sido pasado por valor).
Ejemplo 6: Cálculo de las raíces de una ecuación de 2do. grado

Enunciado
Dados tres valores reales a, b y c correspondientes a los coeficientes de la ecuación de 2do. grado ax2 + bx + c, se quiere
calcular las raíces de dicha ecuación, ya sean reales o imaginarias.
Análisis
La solución del problema consiste en primero verificar que los valores dados efectivamente representen los coeficientes de
una ecuación de 2do. grado, esto es el valor a debe ser diferente de cero. Una vez realizada esta verificación se debe
determinar las condiciones bajo las cuales se tienen soluciones reales o imaginarias y en un primer nivel de abstracción, se
especificaran dos procedimientos llamados: SolucionesReales y SolucionesImaginarias, que calculan las soluciones reales
o imaginarias respectivamente.
El segundo nivel de abstracción consiste en el desarrollo de los procedimientos antes descritos.
Solución:
Algoritmo Principal
// algoritmo que llama a los procedimientos SolucionesReales y SolucionesImaginarias para calcular las raíces de
// una ecuación de segundo grado
Real a, b, c, d, r1, r2, i1, i2; // declaración de las variables del algoritmo
Escribir(“Suministre los valores de los coeficientes a, b y c de la ecuación.”); Leer(a, b, c);
EI = { a = x, b = y, c = z , x, y, z  REALES }
Si a = 0 entonces
Escribir(“Datos de Entrada Inválidos”);
sino
d = B ** 2 – 4 * A * C;
si d >= 0 entonces
SolucionesReales( a , b , d , r1 , r2 );
Escribir(“Las raíces reales de la ecuación son r1= ” + r1 + ” y r2= ” + r2);
sino
SolucionesReales( a , b , d , r1 , i1 , r2 , i2 );
Escribir(“Las raíces reales de la ecuación son r1= ” + r1 + ” , r2= ” + r2 +
“ y raíces imaginarias son i1= ” + i1 + ” , i2= ” + i2);
Fsi;
Fsi;
EF = { Se han impreso los resultados según el caso: datos inválidos, raíces reales o raíces imaginarias}
Léxico del Algoritmo Principal

real a, b, c: Variables que nominan a los valores de entrada.
real d : Variable para almacenar el valor del discriminante de la ecuación.
real r1, r2, i1, i2: Variables que nominan a las raíces de la ecuación.
procedimiento SolucionesReales(a,b,d,r1,r2): Calcula las raíces reales de una ecuación de 2º
procedimiento solucionesImaginarias(a,b,d,r1,i1,r2,i2): Calcula la raíces reales y las imaginarias de una ecuación de 2º
Observe que en el algoritmo anterior se utilizan dos procedimientos sin haberlos desarrollado, sólo los invocamos o
llamamos en el cuerpo de instrucciones del algoritmo, esto permite solucionar el problema en un primer nivel de abstracción.
La solución definitiva y completa se obtendrá cuando se desarrollen los siguientes procedimientos.
Definición del Procedimiento SolucionesReales(a,b,d,r1,r2)

Procedimiento SolucionesReales (Real A, B, D, Var Real X1, X2)
// Calcula las raíces reales de una ecuación de 2do. grado
EI = { A = a, B = b, D = b2 – 4ac , D >= 0, a, b, d  REALES }
Real R, P; // declaramos variables propias o locales del procedimiento SolucionesReales
R = D ** (1/2) / (2 * A);
P = -B / (2 * A);
X1 = P + R; X2 = P – R;
EF = { A = a, B = b, D = b2 – 4ac , D >= 0, X1 = x1, X2 = x2, , x1 = (-b + (b2 –4ac) ** (1/2)) / (2a),

X2 = (-b - (b2 –4ac) ** (1/2)) / (2a), a, b, d, x1, x2  REALES }
Fprocedimiento SolucionesReales;
Léxico del Procedimiento SolucionesReales
real A,B,D: Parámetros formales pasados por valor, contienen a los valores de entrada al procedimiento
real X1,X2: Parámetros formales pasados por referencia, contienen a los valores de las raíces reales de
la ecuación de 2do. grado.
real P,R: Variables auxiliares para el cálculo.
Definición del Procedimiento SolucionesImaginarias(a, b, d, r1, i1, r2, i2)

procedimiento SolucionesImaginarias (Real a, b, d, Var Real r1, i1, r2, i2)
// Calcula las raíces reales y las imaginarias de una ecuación de 2do. grado
EI = { A = a, B = b, D = b2 – 4ac , D < 0, a, b, d  REALES }
R = -D ** (1/2) / (2 * A);
P = -B / (2 * A);
R1 = P ; I1  R;
R2 = P ; I2  -R;
EF = { A = a, B = b, D = b2 – 4ac , D < 0, R1 = p, I1 = q, R2 = r, I2 = s,
p + iq = (-b + i (4ac – b2) ** (1/2)) / 2a, r + is = (-b - i (4ac – b2) ** (1/2)) / 2a, con i = (-1) ** (1/2),
a, b, d, p, q, r, s  REALES }
fprocedimiento SolucionesImaginarias;
Léxico del Procedimiento SOLUCIONES_ IMAGINARIAS

real A,B,D: Parámetros formales pasados por valor, contienen a los valores de entrada al procedimiento
real R1, I1, R2, I2:Parámetros formales pasados por referencia, contienen a los valores de las raíces imaginarias de la
ecuación de 2do. grado.
real P,R: Variables auxiliares para el cálculo.
Ejemplo 7: Cálculo de una función matemática

Enunciado
Dados dos valores reales a y b, se quiere construir un algoritmo para evaluar la siguiente función matemática:
y = 8x3 + 3x si x > 1
y = -3x + 1 si x  1
sobre cada uno de los valores de entrada, así como también sobre la suma de ambos.
Análisis
La solución se basa en la definición de una función que implemente la función matemática dada y que se aplique a cada
uno de los valores de entrada así como también a la suma de ambos. La función se debe realizar de tal forma que permita
calcular el valor resultante de la evaluación de la función matemática dada. Este valor será retornado al algoritmo en el
nombre de la función.
Solución:
Algoritmo Principal
// invoca o llama a una función matemática
Real A, B, FA, FB, FAB; // declaración de las variables del algoritmo
Escribir(“Suministre los valores de entrada A y B a evaluar.”); Leer(A, B);
EI = { A = a, B = b, a, b  REALES }
FA = FUNCMAT(A);
FB = FUNCMAT(B);
FAB = FUNCMAT(A+B);
EF = {FA = fa, FB = fb, FAB = fab, fa=funmat(a), fb=funmat(b), fab=funmat(a+b), a, b, fa, fb, fab  REALES}
Escribir(“El valor de la función para A es: ” + FA);
Escribir(“El valor de la función para B es: ” + FB);
Escribir(“El valor de la función para A + B es: ” + FAB);

real A, B: Variables que nominan a los valores de entrada.
real FA, FB, FAB: Variables que nominan los resultados de evaluar la función en los valores indicados.
función FUNCMAT (X): Evalúa la función matemática dada.
Definición de la Función FUNCMAT(X)

función FUNCMAT (Real X): Real
// Evalúa la función matemática según el valor de X
EI = { X = a, a  REALES }
Real Y; // variable local de FUNCMAT utilizada para guardar el resultado de la evaluación de cada función
si X > 1 entonces
Y = 8 * X ** 3 + 3 * X;
sino
Y = -(3 * X) + 1;
fsi
EF = { Y = y, y = 8x3 + 3x si x > 1 o y = -3x + 1 si x  1, y  REALES }
Retornar(Y);
ffunción FUNCMAT;
Léxico de la Función FUNCMAT

real X: Parámetro formal pasado por valor, contiene el valor sobre el cual se desea evaluar la función matemática dada
real Y: Variable auxiliar para el cálculo.
2.2. Alcance: Variables Locales y Variables Globales

Las variables utilizadas en el algoritmo principal y en los procedimientos y funciones se clasifican en dos tipos:
 Variables locales
 Variables globales
Una variables local es aquella que está declarada y definida dentro de un procedimiento o función (subprograma), así esta
variable será considerada como diferente de otras variables con el mismo nombre declaradas en el algoritmo principal o en
otros procedimientos y funciones. La variable tendrá validez en el subprograma en que está definida. Cuando otro
subprograma utiliza el mismo nombre se refiere a una posición de memoria diferente y por ende a otra variable.
Una variable global es aquella que está declarada en el algoritmo principal, del que dependen todos los subprogramas.
El uso de variables locales tiene muchas ventajas, siendo una de las más importantes la de que los subprogramas se hacen
independientes, estableciéndose la comunicación entre el algoritmo principal y los subprogramas a través de los parámetros
únicamente. Esto conlleva a que para utilizar un subprograma (procedimiento o función) sólo se necesita saber lo que hace
y no como lo hace.
Esta característica hace posible dividir grandes proyectos en partes independientes más pequeñas y de esta forma varios
programadores podrán contribuir a encontrar la solución trabajando independientemente.
En un algoritmo simple con un subprograma, cada variable es o bien local al procedimiento o global al algoritmo completo.
Sin embargo, si el algoritmo incluye subprogramas que a su vez contiene a otros subprogramas -subprogramas anidados-
entonces la noción de global y local cambia a una forma más general.
El alcance de un identificador (constante, variables o subprograma) es la parte de algoritmo donde se conoce el
identificador, esto es: si están definidas localmente a un subprograma su alcance se confina a cualquier subprograma que
esté dentro del subprograma donde están definidas, a menos que la variable sea redefinida. En la siguiente figura, se ilustra
el concepto de alcance.
A Identificadores Son accesibles

definidos en: desde:
B
A A,B,C,D,E,F,G
C
B B,C
C C
D D,E,F,G
E E,F,G
D
F F
E G G
F Excepto que sean redefinidos
3. FORMAS ITERATIVAS
DE COMPOSICIÓN DE ACCIONES (CICLOS)
Para aquellos problemas en los cuales es necesario repetir un conjunto de acciones un número (conocido o no) de veces,
se definen las formas iterativas de composición de acciones, también llamadas estructuras de control iterativas.
Existen varias estructuras de control iterativas, siendo las tres más comunes: el para (for), el repetir (repeat) y el mientras
(while).
3.1. Ciclo Para (For)

Esta estructura de control iterativa, se utiliza en aquellos problemas donde se conoce el número de veces que se desea
ejecutar un conjunto de acciones.
Notación
Sea N un número entero y positivo que indica cuantas veces se desea ejecutar las acciones A, B y C, siendo A, B, C
acciones cualesquiera. La repetición de las acciones A, B, C utilizando la estructura de control iterativa Para se expresa:
Para I = 1 hasta N inc 1 hacer ó Para I = N hasta 1 dec 1 hacer

A; A;
B; B;
C; C;
Fpara; Fpara;
Donde:
I se denomina variable de control y es incrementada (inc) o decrementada (dec) automáticamente en el valor indicado.
N es el número de veces que se desea repetir las acciones.
Notas:
 A las acciones comprendidas entre los delimitadores Para y fpara se les denomina cuerpo de la iteración o instrucciones
del ciclo.
 En el ciclo Para la variable de control no debe ser modificada en el cuerpo de la iteración.
 Cuando el incremento es en 1, se puede omitir la instrucción “inc 1” en el encabezado del Para.
Ejemplo 8: Cálculo de la nota promedio, nota máxima y nota mínima de una serie de N notas
Enunciado
Dada una serie de N notas se desea calcular el promedio de las mismas, así como también la máxima y la mínima nota.
Análisis
La solución se basa en el tratamiento secuencial de cada una de las N notas; esto es, en la definición de las acciones a
realizar sobre una nota (acumularla, compararla para determinar máximo y mínimo) y la aplicación de estas mismas
acciones sobre el resto las notas.
Solución:
Algoritmo Principal
// Calcula el promedio, máximo y mínimo de un conjunto de N notas suministradas. Se asume que N > 0
Real Nota, Max, Min, Suma, Prom; // declaración de las variables del algoritmo
Entero i, N; // i es la variable índice del ciclo Para y N la cantidad de notas a procesar
Escribir(“Suministre la cantidad de notas a procesar.”); Leer(N);
EI = { N = n, n > 0, n  REALES }
Max = 0 ; Min = 20; // inicializamos las variables con sus mayores valores opuestos
Suma = 0; // se inicializa la variable acumuladora en 0
Para i = 1 hasta N en 1 hacer
Escribir(“Suministre la nota ” + i ); Leer(Nota);
Suma = Suma + Nota;
si Nota < Min entonces
Min = Nota;
Fsi;
si Nota > Max entonces
Max = Nota;
Fsi;
Fpara;
PROM = SUMA / N;
EF = { PROM = p, 20  p  0, p es el promedio de las n notas,
MAX = ma, 20  ma  0, ma es la nota máxima de las n notas,
MIN = mi, 20  mi  0, ma es la nota mínima de las n notas, p, ma, mi  REALES }
Escribir(“La nota promedio es: ” + Prom);
Escribir(“La nota máxima es: ” + Max);
Escribir(“La nota mínima es: ” + Min);

entero N: Nomina al número de notas a procesar.
real Nota: Nomina a cada una de las notas.
real Suma: Almacena la suma de las notas a procesar.
real Prom: Nomina a la nota promedio
real Max: Nomina a la nota máxima.
real Min: Nomina a la nota mínima.
Observación
En el estado inicial se asume que el valor de N es mayor que cero y en términos de esa suposición se trabaja. ¿Qué
resultados daría el algoritmo si, por error, al introducir el valor de N se introduce un valor negativo o cero?
3.2. Ciclo Repetir (Repeat)

Esta estructura de control iterativa, se utiliza en aquellos problemas donde no se conoce el número de veces que se desea
ejecutar un conjunto de acciones, pero las mismas se ejecutan 1 o más veces.
Notación
Sea  un predicado que caracteriza la terminación de un proceso iterativo y sean A y B acciones cualesquiera. La repetición
de las acciones A y B utilizando la estructura de control iterativa Repetir se expresa:
Repetir
A;
B;
hasta ;
Esta composición es equivalente al siguiente secuenciamiento de acciones:

A ; B  ; (A ; B  ; (A ; B  ; (A ; B  ; .............. )))
   
test test test test
donde el test de terminación se efectúa después de cada ejecución de las acciones A y B. Así, con el repetir las acciones
del cuerpo de la iteración se ejecutan una o más veces.
Ejemplo 9: Cálculo de interés sobre un capital.

Enunciado
Dado un valor real C, que representa una cantidad en Bolívares y un valor R que representa un porcentaje de interés anual,
se desea calcular al cabo de cuantos años se duplicará el capital.
Análisis
La solución se basa en el cálculo y acumulación de los intereses generados por el capital inicial año por año, hasta alcanzar
la meta propuesta.
Solución:
Algoritmo Principal
// Calcula la cantidad de años necesarios para duplicar un capital inicial C
Real CI, I, C; Entero Años; // declaración de variables
Escribir(“Introduzca el capital inicial”); Leer(CI); //solicitud y lectura de los valores de entrada
Escribir(“Introduzca el % de Interés”); Leer(I);
EI = { CI = ci, ci > 0, I = i, i > 0, ci, i  REALES }
C = CI ; Años = 0; // inicializamos convenientemente las variables C y Años
Repetir
C = C + C * I / 100; Años  Años + 1;
hasta C >= 2 * CI;
EF = { años = a, C = c, a es el número de años mínimo para duplicar el capital inicial ci, a  ENTEROS,
c, ci  REALES }
Escribir(“Para duplicar el capital se necesitan: ” + Años);

real CI: Nomina al capital inicial.
real I: Nomina a la tasa de interés anual.
real C: Almacena el capital acumulado a lo largo de los años.
entero Años: Nomina al número de años necesarios para duplicar el capital
Observación
En el estado inicial se asume que el valor del Capital Inicial (CI) y el valor de la tasa de interés (I) son mayores que cero y
en términos de esa suposición se trabaja. ¿Cómo generalizaría Ud. el algoritmo para que funcione independientemente de
los valores de entrada dados?
3.3. Mientras (While)

Esta estructura de control iterativa, se utiliza en aquellos problemas donde no se conoce el número de veces que se desea
ejecutar un conjunto de acciones, pero las mismas se ejecutan 0 o más veces.
Notación
Sea  un predicado que caracteriza el comienzo o continuación (negación de la condición de terminación) de un proceso
iterativo y sean A y B acciones cualesquiera. La repetición de las acciones A y B utilizando la estructura de control iterativa
Mientras se expresa:
Mientras  hacer
A;
B;
Fmientras;
Esta composición es equivalente al siguiente secuenciamiento de acciones:

 (A ; B  ; (A ; B  ; (A ; B ................. )))
  
test test test
donde el test de comienzo o continuación se efectúa antes de cada ejecución de las acciones A y B. Así, con el mientras las
acciones del cuerpo de la iteración se ejecutan cero o más veces.
Ejemplo 10: Cálculo del salario de una serie de trabajadores por hora.
Enunciado
Se desea calcular lo que devengarán una serie de trabajadores por el trabajo realizado en una obra, para esto se definió la
siguiente tarifa horaria: las horas trabajadas en horario normal se pagan a razón de Bs. 20 y las horas extras a razón de Bs.
25, mientras no excedan de 10 horas. Si las horas extras exceden de 10 horas, el exceso se paga a razón de Bs. 23,5 la
hora. Además, se conoce que los datos de cada trabajador, que se introducirán, son: nombre del trabajador, horas normales
trabajadas y horas extras trabajadas. La introducción de los datos terminará cuando se introduzca "*" como nombre del
trabajador.
Análisis
La solución se basa en el procesamiento y cálculo del salario devengado por cada trabajador de acuerdo a las tarifas
definidas, la solución se obtiene al aplicar los cálculos de un trabajador a todos los trabajadores a través de la estructura
iterativa mientras.
Solución:
Algoritmo Principal
// Calcula el salario de un trabajador en función de las horas normales y horas extras trabajadas
String Nombre; // declaración de variables
Real HN, HE, S, PagoHN, PagoHE, pagoHE2;
PagoHN = 20; PagoHE = 25; pagoHE2 = 23,5; //inicializamos estas variables con el monto pagado al trabajador
// usar estas variables facilita actualizar los honorarios del trabajador por hora
Escribir(“Introduzca nombre del trabajador o * para terminar”); Leer(Nombre);

EI = { Se tienen el nombre y los honorarios por horas normales y extras trabajadas }
Mientras NOMBRE <> "*"
Escribir(“Introduzca número de horas trabajadas en horario normal”); Leer(HN);
Escribir(“Introduzca número de horas extras trabajadas”); Leer(HE);
S = HN * PagoHN;
si HE > 10 entonces
S = S + 10 * PagoHE + (HE - 10) * PagoHE2;
sino
S = S + HE * PagoHE;
Fsi;
// se muestra el salario del trabajador actual
Escribir(“El trabajador ”+ Nombre + “ devengará un salario de Bs. ” + S);
// se solicita el nombre del siguiente trabajador

Escribir(“Introduzca nombre del siguiente trabajador o * para terminar”); Leer(Nombre);
Fmientras;
EF = { Se han procesado cero o más trabajadores }

string Nombre: Nomina al nombre de cada trabajador.
real HN,HE: Nomina a las horas normales y extras trabajadas por cada trabajador.
real S: Almacena la cantidad de Bolívares devengada por cada trabajador.
Observación
El fin del proceso iterativo, en este caso viene dado por una marca especial “*” en la secuencia de datos de entrada. Esta
marca o valor de parada la define el trabajador según las características del problema.
TALLERES
DE EJERCICIOS
Taller 1:
EXPRESIONES
1. ¿Cuál es el resultado que se obtiene al evaluar las siguientes expresiones?
No. Expresión Resultado

1 3 + 6 * 14
2 8+7 *3 +4*6
3 -4 * 7 + 2 ** 3 / 4 - 5
2. Convierta las siguientes expresiones algebraicas a expresiones aritméticas en forma lineal
No. Expresión algebraica Expresión en forma lineal

1 A2 + B2
2 X+Y
U+ W
A
3 X + Y (Z + W)
*
W
Y
4
-B + B2 - 4AC
2A
3. Calcule el resultado de evaluar las siguientes expresiones, considerando que la variables involucradas tienen los
siguientes valores:
A = 5, B = 3, C = -1, D = Verdadero, E = Falso, F = "C", G = "hola"
No. Expresión Resultado

1 A * 3 + B ** 2 / C * B + A
2 (A > 0) o (B > 0) o (C > 0) o (no D)
3 no ( A > 0 o B > 0 o C > 0 ) y no D
4 G II " " II F II G
5 A ** B - 1 + ( C ** 2 * A ) + ( A ** 2 * (C + B ))
6 (A+B > A-B) o (no D y E)
Taller 2:
SECUENCIAMIENTO Y
CONDICIONALES
Elabore un algoritmo para resolver cada uno de los siguientes problemas
1. Dado un punto en el plano, calcule la distancia existente entre ese punto y el origen.
Ayuda: Recuerde que en un triángulo rectángulo, la suma de los cuadrados de los catetos es igual a la hipotenusa al
cuadrado (Teorema de Pitágoras).
2. Generalice la solución del problema anterior a fin de que hallar la distancia entre dos puntos cualesquiera.
3. Dados dos valores G1 y G2, que representan cantidades en grados, verifique si los valores dados corresponden al
mismo ángulo.
4. Calcular el valor absoluto de un entero dado.

Ayuda: El valor absoluto de un número N se define como: N si N  0 o -N si N < 0
5. Ordenar ascendentemente tres valores enteros dados.
6. Ordenar ascendentemente cuatro valores enteros dados.
7. Determinar el signo de la suma de dos números dados, sin calcularla.
8. Dada una fecha del año actual, calcule el Juliano de esa fecha.
Ayuda: El Juliano de una fecha es la cantidad de días que han transcurrido desde el 01 de Enero hasta la fecha dada.
9. Dada una fecha del año actual, calcule que día de la semana es.
10. Calcule el día de la semana que Ud. nació.

Ayuda: Considere en su análisis, las soluciones de los problemas 8 y 9 de este taller
11. Calcule el número de días que una persona ha vivido.
Taller 3:
ESTRUCTURAS
ITERATIVAS O CICLOS
Elabore un algoritmo para resolver cada uno de los siguientes problemas, utilice procedimientos o funciones de ser el caso.
1. Dado un valor entero N, (1  N  9), se quiere que usted imprima la tabla de multiplicar asociada a N.
2. Dados dos valores enteros X1 y X2, se quiere calcular el producto de X1 por X2 mediante sumas sucesivas.
3. Adapte la solución del problema anterior y calcule el resultado de elevar X1 a la X2.
4. Dado un número entero N (N > 1), se quiere calcular e imprimir los divisores del número N.
5. Calcule e imprima los número primos que hay entre 1 y un valor dado N (N > 1).
6. Dado un valor entero N (N > 1), se quiere contar la cantidad de primos morochos que hay entre 1 y N.
Ayuda: Dos números primos son morochos si son impares y sucesivos.
7. Dada un cédula de identidad, genere una clave de cuatro dígitos, formada de acuerdo a las siguientes reglas:
a. El dígito de las unidades en la clave será el dígito menos significativo del resultado de sumar los dígitos
más y menos significativos de la cédula de identidad.
b. El dígito de las decenas en la clave será el resto de dividir entre 9 a la suma de todos los dígitos de la
cédula.
c. El dígito de las centenas de la clave será el resto de dividir entre 7 a la suma de los dígitos pares
existentes en la cédula.
d. El dígito de las unidades de mil en la clave será el digito más significativo del resultado obtenido al
multiplicar todos los dígitos, diferentes de cero, de la cédula de identidad.
CENEAC – Introducción a la Programación con Nivel 1 - Anexo Lenguaje de Programación Turbo Pascal.
ANEXO 1
LENGUAJE DE PROGRAMACIÓN
TURBO PASCAL
Material elaborado por CENEAC Producciones, C.A. Prohibida su reproducción total o parcial sin autorización del Autor. A1
GUÍA DE SINTAXIS DE
TURBO PASCAL 7.0
El lenguaje de programación Pascal es un lenguaje de alto nivel y propósito general desarrollado por el profesor suizo
Niklaus Wirth como un lenguaje para enseñar la programación de forma disciplinada y sistemática.
Una versión preliminar surgió en 1968 y el primer compilador totalmente completo apareció a finales de 1970. Las diferentes
versiones de compiladores ofrecían interpretaciones ligeramente diferentes que impedían la compatibilidad entre ellas. Por
estas razones, diferentes proyectos se iniciaron para producir una definición estándar del lenguaje y culminaron en dos: uno
de la International Standard Organization (I.S.O.) en 1982, y otro por un comité conjunto del American National Standard
Institute (A.N.S.I.) y del Institute of Electrical and Electronics Engineers (I.E.E.E.). Estas dos versiones se conocen como
ISO Pascal y ANSI/IEEE Pascal, y difieren en algunos aspectos no especialmente significativos.
Sin embargo, dos versiones no estándar se han popularizado considerablemente: UCSD Pascal (construida por Regents of
the University of California) y Turbo Pascal (marca registrada de Borland International, Inc.). De ellas, Turbo Pascal es sin
duda la más popular y la que más ha contribuido a la difusión del lenguaje, sobre todo en el mundo universitario, científico y
técnico.
En 1983, la firma Borland International lanzó al mercado de un modo experimental un compilador de Pascal denominado
Turbo Pascal v1.0 a un reducido precio. Fue un éxito, no sólo por la rapidez de compilación (del orden de 50 líneas por
segundo) sino porque incorporaba un entorno de desarrollo de programas con editor incorporado, gráficos, gestión de
archivos. Tras las versiones 2.0 y 3.0, a finales de 1987, Borland lanzó la versión 4.0 que no supuso una evolución, sino una
ruptura con las versiones anteriores, ya que incorporaba compilación independiente (unidades), gestión de proyectos,
enteros de gran precisión y un buen número de utilidades como nunca se habían reunido en un compilador de Pascal. En
1988 Borland lanzó la versión 5.0 y durante 1989 la 5.5, que sigue las nuevas filosofías del campo de la programación: la
programación orientada a objetos. A finales de 1991 lanza la versión 6.0, que perfeccionaba el entorno de programación e
incorpora la biblioteca de objetos Turbo Vision, que contiene una completa estructura de aplicaciones. A finales de 1992
presentó la versión 7.0, que ha añadido nuevas propiedades al lenguaje Pascal y una nueva biblioteca de objetos Turbo
Visión 2.0. En la actualidad existen versiones de Pascal para Windows, Linux y otros sistemas operativos.
Los elementos del lenguaje Pascal nos permiten construir desde las sentencias más simples hasta las más complejas, así
como los distintos tipos de datos, tanto predefinidos como aquellos que son definidos por el usuario. Estos elementos
incluyen un conjunto de caracteres o alfabeto de caracteres, palabras reservadas, identificadores estándar, tipos de datos
numéricos, carácter, etc.
Las características fundamentales que reúne Pascal estándar son:
 Constituye una herramienta excelente para el aprendizaje de la programación.
 Ser un lenguaje de propósito general.
 Lenguaje procedural (imperativo, orientado a órdenes).
 Lenguaje estructurado (soporta las estructuras básicas WHILE, FOR y REPEAT. No necesita el empleo de la sentencia
GOTO).
 Lenguaje recursivo.
 Gran riqueza de tipos de datos, con una gran cantidad de tipos tanto predefinidos como definidos por el usuario.
 Producción por los compiladores de códigos ejecutables rápidos y eficientes.
1.1. Elementos Básicos del Lenguaje
Palabras Reservadas
Turbo Pascal, como lenguaje de programación posee su propio código con palabras de uso exclusivo, a las cual se
denomina palabras reservadas (palabras clave, palabras reservadas o keywords). Estas palabras no pueden ser usadas
como identificadores de variables, constantes o procedimientos ya que son códigos con un significado específico en el
lenguaje y por lo tanto tienen una función definida en Turbo Pascal.
Las palabras reservadas en Pascal estándar y en Turbo Pascal (versiones 6.0 o mayores) son:
Palabra Significado / Uso Palabra Significado / Uso Palabra Significado / Uso

absolute directiva (variables) div operador goto instrucción
and operador (booleano) do instrucción if instrucción
array tipo downto instrucción (for ... then) implementatio estructura unitaria
asm instrucción else instrucción (if or case) n operador (conjunto)
begin marcador de bloque end marcador de bloque in instrucción
case instrucción external directiva (funciones) inherited retrocompatibilidad
const declaración o directiva file tipo inline tipo
constructor método especial for instrucción interface declaración
destructor método especial forward directiva de función label
function declaración
mod operador (matemático) record tipo unit estructura unitaria
nil valor repeat instrucción until instrucción
not operador (booleano) set tipo uses estructura unitaria
object retrocompatibilidad (clase) shl operador (matemático) var declaración
of instrucción (case) shr operador (matemático) virtual directiva (método)
or operador (booleano) string tipo while instrucción
packed directiva (registro) then instrucción (v. if) with instrucción
private especificador acceso (clase) to instrucción (v. for) xor operador (booleano)
procedure declaración type declaración
program estructura de programa
Identificadores
Los identificadores son palabras que representan constantes, variables, tipos de datos, procedimientos o funciones. Existen
dos tipos de identificadores: los predefinidos de Turbo Pascal y los definidos por el programador. 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 una palabra
reservada. Todo identificador en Pascal debe ser definido previamente a su utilización.
Algunos de los identificadores predefinidos son: integer, real, byte, sin. Los identificadores definidos por el programador son
elementos como variables, procedimientos, funciones, etc.
En Turbo Pascal no existe diferencia entre mayúsculas y minúsculas, así que a un identificador denominado "valor" se le
puede referir como "VALOR" o "VaLoR".
Ejemplos:
Writeln Exit CadenaReal System Rosas
Un_mes Nombre_Apellidos Dia_del_Mes Pedro_1
Cadena de caracteres
′Turbo′ {Turbo} ′ ′ ′ {′} ′ ′ {cadena nula } ′ ′ {espacio}
Línea de programa
Las líneas de programa en Turbo Pascal tienen una longitud máxima de 126 caracteres.
Estructura de un programa
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 secciones que podríamos
denominar Cabecera, Declaraciones y Programa.
La cabecera del programa únicamente lleva el nombre del programa. En la sección de declaraciones se le indica al
compilador todos los objetos 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.
Después de haber realizado todas las declaraciones, se pueden declarar las funciones y los procedimientos a ser utilizados
en el programa, para luego escribir el programa principal. El programa principal inicia con la palabra reservada BEGIN y
termina con la palabra END., esta última con un punto al final.
Cada línea 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.
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.
Nombre del programa Elemento opcional
Cabecera program Ejemplo (lista_de_parámetros);

Declaraciones de const
constantes
Secreto = ′ R2D2 ′ ;
Declaraciones de type
tipos
Formato = string[12];
Declaraciones de
variables
var
Respuesta : formato;
Declaraciones de procedure EjemploUno;

procedimientos y
funciones begin
{ cuerpo del procedimiento}
end;
…
Cuerpo del programa begin

{ cuerpo principal del programa}
end.
Procedimientos y Funciones
En Pascal, una rutina puede asumir dos formas: un procedimiento o una función. En teoría, un procedimiento es una
operación que se pide a la computadora que realice, y una función es un cálculo que devuelve un valor. Esta diferencia se
enfatiza por el hecho de que una función tiene un resultado, un valor de salida, mientras que un procedimiento no. Ambos
tipos de rutinas pueden tener múltiples parámetros, de tipos de datos dados.
En la práctica, sin embargo, la diferencia entre funciones y procedimientos es muy limitada: puede hacer una llamada a una
función para realizar cierta tarea y luego saltarse el resultado (que podría ser un código de error opcional o algo similar) o
puede hacer una llamada a un procedimiento que transmite un resultado dentro de sus parámetros (más sobre parámetros
de referencia se comentará más tarde en este capítulo).
Cabecera
procedimiento
procedure identificador (lista de parámetros);
{ declaraciones de datos }
begin
{ cuerpo del procedimiento }
end;
Cabecera function identificador (lista de parámetros);

función
{ declaraciones de datos }
begin
{ cuerpo del procedimiento }
end;
1.2. Tipos de Datos
Tipos Simples
Lógicos: Boolean true false
Este tipo de datos tienen la peculiaridad de que solo pueden tomar dos tipos de datos: verdadero o falso. El verdadero es
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.
Números 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. 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 precisión. Los tipos de enteros en
Turbo Pascal y el rango de valores que aceptan son:
Byte 0 . . 255
Integer -32768 . . 32767
LongInt -2147483648 . . 2147483647
ShortInt -128 . . 127
Word 0 . . 65535
Números reales:
Los números reales son aquellos que cuentan con una parte decimal. 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. Turbo Pascal cuenta con varios tipos de datos reales, pero no se puede utilizar, más que el tipo real en
máquinas que no cuenten con un coprocesador matemático. Los tipos de datos reales en Turbo Pascal y el rango de
valores que aceptan son:
Real 2.9 x 10-39 . . 1.7 x 1038
Single 1.5 x 10-45 . . 3.4 x 1038
Double 5.0 x 10-324 . . 1.7 x 10308
Extended 3.4 x 10-4932 . . 1.1 x 104932
Comp -263 + 1 . . 263 - 1
Carácter: Char (Cualquier carácter ASCII)

Los caracteres son cada uno de los símbolos que forman el código ASCII. Los caracteres se especifican entre apostrofes:
El tipo Char es un tipo ordinal de Pascal, lo que quiere decir que sus elementos 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 obtener 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.
Ejemplos de caracteres: 'a' 'B' '2' '#'
Cadenas: String (Secuencia de hasta 255 caracteres ASCII. Si no se especifica un tamaño, se utilizará por defecto 255)
Las cadenas son secuencias de caracteres o arreglos que tienen una longitud máxima de 255 caracteres. Se definen entre
apostrofes. El tipo de Pascal para las cadenas es String.
El tamaño por defecto para un tipo string es de 255 caracteres, pero es posible definir uno mas pequeño utilizando la
sintaxis Variable : String[Tamaño];
Donde Variable es la variable a definir y Tamaño es el número máximo de caracteres que podrá contener esa variable
(mayor a 0 y menor a 256).
Tipo Subrango
type
Dígitos = 0 .. 9
Días = Lunes .. Domingo
Mayúsculas = ′A′ .. ′Z′
Un tipo de subrango define un rango de valores dentro del rango de otro tipo (de ahí el nombre subrango). Se puede definir
un subrango del tipo Integer, de 1 a 10 o de 100 a 1000, o se puede definir un subrango del tipo Character, como en :
En la definición de un subrango, no se necesita especificar el nombre del tipo base. Sólo se necesita proporcionar dos
constantes de ese tipo. El tipo original debe ser ordinal, y el tipo resultante será otro tipo ordinal.
Tipo Enumerado
type
Naipes = {Oros, Espadas, Bastos, Copas}
Colores = {Rojo, Amarillo, Verde, Azul, Violeta}
Los tipos enumerados constituyen otro tipo ordinal definido por el usuario. En vez de indicar un rango para un tipo existente,
en una enumeración usted hace una lista de todos los valores posibles del tipo. En otras palabras, una enumeración es una
lista de valores.
Cada valor en la lista tiene una ordinalidad [número de orden] asociada, comenzando desde cero. Cuando aplica usted la
función Ord a un valor de tipo enumerado, obtiene este valor. Por ejemplo, Ord (Amarillo) devuelve 1.
Tipo Estructurado
Arreglo ( array )
El tipo arreglo define una lista de un número fijo de elementos de un tipo específico. Normalmente se utiliza un índice entre
corchetes para acceder a uno de los elementos del arreglo. Los corchetes también se utilizan para especificar los valores
posibles del índice cuando el arreglo ha sido definido.
Ejemplos:
array[1..100] of Real;
array[Boolean] of array [1..10] of array [Longitud] of Real;
packed array[1..10, 1..15] of Boolean;
Registro ( record )
Los tipos record definen colecciones fijas de elementos de distintos tipos. Cada elemento, o campo, tiene su propio tipo. La
definición de un tipo registro incluye todos estos campos, dándole un nombre a cada uno, que se utiliza para acceder a él
posteriormente.
Ejemplos: type Fecha = record

type Reg = record Año : Integer;
Nombre : String [40]; Mes: Byte;
Edad : Integer; Día : Byte;
Salario : Real; end;
end;
Conjunto ( set )
Tipos de conjunto indican un grupo de valores, donde la lista de valores disponibles se indica mediante el tipo ordinal en que
se basa el conjunto. Los tipos suelen ser limitados, y a menudo se representan con una enumeración o un subrango. Si
tomamos el subrango 1..3, los valores posible del conjunto basado en él incluyen sólo 1, sólo 2, sólo 3, tanto 1 como 2,
tanto 1 como 3, 2 y 3, todos los tres valores, o ninguno de ellos.
Una variable normalmente contiene exactamente uno de los valores posibles para el rango de su tipo. Una variable de tipo
conjunto, sin embargo, puede contener uno, dos o más valores del rango. Incluso puede incluirlos todos.
Ejemplo:
Letras := [′A′, ′B′, ′C′, ′D′, ′E′]
NoLetras := [ ]
1.3. Variables y Constantes

Constantes predefinidas
true verdadero
false falso
maxint entero mayor disponible en máquina
Declaración de variables
var var
x, y, z : Real; Digito : 0..9;
Constantes con tipos

Tipo simple: Tipo registro:
const type
Min : Integer = 0; Punto = record
Max : Integer = 100; x, y : Real;
end;
Tipo cadena: Vector = array [0 .. 1] of Punto;
const
Cabecera : string[10] = ′ Ciudades ′; const
Respuesta: string[5] = ′ Si ′; Origen : Punto = (x:0.0; y:0.0);
Linea: Vector = ( (x:-4.5; y:1.5), (x:6.4; y:5.0) );
Tipo estructurado:
const
Digitos : array [0 .. 10] of Char = ( ′0′,′1′,′2′,′3′,′4′,′5′,′6′,′7′,′8′,′9′ );
Alcance de las variables

El alcance ámbito de un identificador es el conjunto de módulos (programas o subprogramas) en el que está legalmente
declarado el identificador.
program Principal;
var
Variables globales
w,x,y,z: …
procedure Uno (var w: …; a: …); Parámetros locales
w, a, x
var
x: …;
begin
…
end;
procedure Dos (b: …; c: …; var x: …);
Parámetros locales
var
b, c, x, z, w
z,w: …;
begin
…
end;
begin {Principal}
…
Uno (y,z);
…
Dos(w,y,x);
…
end.
1.4. Operadores
Aritméticos
Operador Sintaxis Significado
+ +expresión Positivo (unitario)
+ expresión1 + expresión2 Suma (binaria)
- -expresión Negativo (unitario)
- expresión1 - expresión2 Resta (binario)
* expresión1 * expresión2 Multiplicación
/ expresión1 / expresión2 División real
DIV expresión1 DIV expresión2 División entera
MOD expresión1 MOD expresión2 Resto (módulo)
Cuando en una expresión se utiliza más de un operador, éstos se evalúan conforme a una prioridad establecida por Turbo
Pascal. En caso de existir paréntesis en la expresión se evaluará primero el contenido de los paréntesis antes que otros
operadores. Si existen dos operadores de igual prioridad se evaluará de izquierda a derecha.
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.
Lógicos
Operador Sintaxis Significado
NOT NOT expresión Complemento
AND expresión1 AND expresión2 AND (y lógico)
OR expresión1 OR expresión2 OR (o lógico)
XOR expresión1 XOR expresión2 XOR( o lógico exclusivo)
Relacionales
Operador Sintaxis Devuelve verdadero si
= expresión1 = expresión2 Expresiones son iguales
<> expresión1 <> expresión2 Expresiones no son iguales
< expresión1 < expresión2 expresión1 es menor que expresión2
<= expresión1 <= expresión2 expresión1 es menor o igual a expresión2
> expresión1 > expresión2 expresión1 es mayor que expresión2
>= expresión1 >= expresión2 expresión1 es mayor o igual a expresión2
De Conjuntos
Operador Sintaxis Devuelve verdadero si
= conjunto1 = conjunto2 conjunto1 y conjunto2 son idénticos.
Cada elemento de conjunto1 está contenido en conjunto2 y
cada elemento de conjunto2 está contenido en conjunto1.
<> conjunto1 <> conjunto2 Uno de los conjuntos contiene al menos un elemento que no está
en el otro conjunto.
<= conjunto1 <= conjunto2 Cada elemento de conjunto1 está también en conjunto2.
< conjunto1 < conjunto2 Cada elemento de conjunto1 está también en conjunto2.
Además, conjunto2 contiene al menos otro elemento que no se
encuentra en conjunto1.
>= conjunto1 >= conjunto2 Cada elemento de conjunto2 está también en conjunto1.
< conjunto1 > conjunto2 Cada elemento de conjunto2 está también en conjunto1.
Además, conjunto1 contiene al menos otro elemento que no se
encuentra en conjunto2.
IN elemento IN conjunto1 El elemento se encuentra en conjunto1.
Concatenación: + Concatena dos cadenas
1.5. Sentencias
Asignación o Igualación
La operación de asignación es 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á una expresión o algún valor
directo que se almacenará en el primer identificador.
<identificador> := <expresion> Ejemplos:

rango := alto-bajo;
cuenta := cuenta + 1; {cuenta guardará su valor anterior incrementado en 1}
nombre := ′Juan Liora′; {Nombre guardará la cadena ′Juan Loira′}
Compuesta
begin <sentencias> end; Ejemplo:
begin
z := 5;
GetReal (′ Valor ′, ValorReal);
Writeln (ValorReal);
end;
Condicional ( if ):
if <condición> then Ejemplo:
<sentencias> if Cad1 <> Cad2 then
Opcional
[else begin
<sentencias> ]; Cad1 := Cad1+Cad2;
Writeln (′ nueva cadena ′, Cad1);
end;
Condicional anidado ( if ):
if <condición> then Ejemplo:
<sentencias> if x > y then
else if <condición> then if x > z then
<sentencias> Write (x)
else if <condición> then else
<sentencias> Write (z)
else else
<sentencias>; if y > z then
Write (y)
else
Write (z);
Writeln (′ es el Mayor ′);
Ciclo Para ( for ):

1. for <índice> := <valor inicial> to <valor inicial> do
<sentencias>;
Ejemplos:
for j := 1 to 10 do
for i := 1 to 10 do begin
Writeln (′ Cuerpo de bucle ′); j := j + z;
Writeln (′ Pasos: ′, paso : 2);
paso := paso + 1
end;
Writeln (′ Fuera del bucle ′);
2. for <índice> := <valor inicial> downto <valor inicial> do

<sentencias>;
Ejemplos:
for i := 10 downto 1 do
begin
Resultado := i * Resultado;
Writeln (′ Bucle: ′, i, Resultado);
end;
Ciclo Repetir ( repeat ):

repeat Ejemplo:
<sentencia>; paso := 1;
until <condición> repeat
Writeln (′ Pasos: ′, paso : 2);
paso := paso + 1;
until paso > 10;
Ciclo Mientras ( while ):

while <condición> do Ejemplo:
<sentencia>; paso := 1;
while paso <= 10 do
<sentencia>= sentencia simple begin
sentencia compuesta Writeln ( ′ Pasos: ′, paso : 2 );
paso := paso + 1;
end;
Comparación entre los ciclos Repetir y Mientras:

 La diferencia entre el bucle while-do (mientras ... haz) y el bucle repeat-until (repite ... hasta que) consiste en que el
código de la instrucción repeat se ejecuta siempre al menos una vez.
 La otra diferencia clave entre estos dos bucles es que el bucle repeat-until incluye una condición inversa. El bucle se
ejecuta mientras la condición no se cumpla. Cuando sí lo hace, el bucle finaliza. Esto es lo contrario de lo que pasa con
un bucle while-do, que se ejecuta mientras la condición sea cierta. Por esta razón tuve que invertir la condición en el
código que aparece arriba, para obtener una instrucción equivalente.
1.6. Procedimientos y Funciones estándar
Turbo Pascal contiene procedimientos y funciones estándar (incorporadas o predefinidas) y variables

predeclaradas en la unidad System.
Funciones Aritméticas
Nombre Sintaxis Descripción
Abs Abs (x); Devuelve el valor (positivo) absoluto de su argumento x.
ArcTan ArcTan (x:Real): Real; Arco tangente del argumento expresado en radianes.
Cos Cos (x:Real): Real; Coseno del argumento expresado en radianes.
Exp Exp (x:Real): Real; Potencia exponencial del argumento (ex).
Frac Frac (x:Real): Real; Parte decimal de un número real.
Int Int (x:Real): Real; Parte entera de un número real.
Ln Ln (x:Real): Real; Logaritmo neperiano (base e) del argumento.
Sin Sin (x:Real): Real; Seno del argumento.
Sqr Sqr (x); Cuadrado del argumento.

Sqrt Sqrt (x:Real): Real; Raíz cuadrada del argumento.
Ejemplos:
y := Abs(x) * 2; z := Int(345.678);
z := ArcTan(1.75); t := Ln(1.25);
Tan := Sin(x) / Cos(x); z := Sin(Pi);
Pot := Exp(3); f := Sqr(3.45);
R := Frac(-245.123); f := Sqrt(1.2345);
Funciones de transferencia
Chr Chr (x : Byte) : Char; Devuelve el carácter correspondiente al código ASCII.
Ord Ord (x) : LongInt; Número ordinal de un tipo ordinal.
Round Round (x : Real) : LongInt; Redondea un número real a un entero largo.
Trunc Trunc (x : Real) : LongInt; Trunca un valor de tipo real a entero.
Ejemplos: Round(5.449) devuelve 5

Write (Chr(i)); Trunc(-3.14) devuelve -3
Ord( ′A′ ); Trunc(6.5) devuelve 6
Opcional
Procedimientos o Funciones ordinales
Dec Dec (var x [;n: LongInt]); Decrementa una variable.
Inc Inc (var x [;n: LongInt]); Incrementa una variable.
High High(x); Devuelve el valor más alto en el rango del argumento que debe ser
un tipo arreglo o un tipo cadena.
Low Low (x); Devuelve el valor más bajo en el rango del argumento que debe
ser un tipo arreglo o un tipo cadena.
Odd Odd (x : LongInt) : Boolean; Devuelve true si el argumento es impar.
Pred Pred(x); Devuelve el predecesor del argumento (x de tipo ordinal).
Succ Succ(x); Devuelve el sucesor del argumento (x de tipo ordinal).
Ejemplos:
Dec(z); for Dia := Low(ADia) to High(ADia) do
Inc(z); begin
…
for i := 0 to High(x) do end;
s := s + x[i];
Pred( ′z′ ) devuelve ′y′
Succ(1946) devuelve 1947
Tratamiento de cadenas
Procedimientos:
Delete Delete (var s: String; Pos, Len: Integer); Borra una subcadena a partir de una posición en una
cadena.
Insert Insert (var s: String; var D: String; Pos: Integer); Inserta una subcadena a partir de una posición en una
cadena.
Str Str (i: Integer; var s: String); Convierte un valor numérico a cadena.
Val Val (s: String; var i, p: Integer); Convierte una cadena a su valor numérico.
Funciones:
Concat Concat (s1, s2, …, sn: String) : String; Concatena (une) cadenas.
Copy Copy (s: String; pos, long: Integer) : String; Copia una cadena dada.
Length Length (s: String) : Integer; Longitud de una cadena.
Pos Pos (patron, fuente: String) : Integer; Posición de la primera ocurrencia de una subcadena.
Ejemplos:
Cad_1 := ′computadora′; Str (Maxint, Cad_1);
Delete (Cad_1, 4, 3); Writeln (Cad_1);
Insert ( ′put′, Cad_1, 4); Val ( ′32425′, r, e);
s := Concat( ′xyz′, ′ Luis ′); s := Copy (s, 2, 3);
t := Length (Cad_1);
ANEXO 2
REGLAS DE TRADUCCIÓN AL
LENGUAJE PASCAL
1. REGLAS DE TRADUCCIÓN
PARA LOS TIPOS DE DATOS
Notación Pascal Observaciones

Entero A Var A: integer; Si -32768 < A < 32767
Entero H H: longint; Si A <= -32768
Real B B: real; o A >= 32767
Lógico C C: boolean;
Caracter D D: char;
String E E: string;
Arreglo A de Entero de [1:9]; Var A: array [1..9] of integer; Arreglo unidimensional
Tipo Arreglo Notas de Real de [1:60]; Type Declaración de un tipo de

Notas = array [1..60] of real; dato Arreglo (Notas) y
Notas SecA, SecB; declaración de variables de
SecA, SecB : Notas; ese tipo (SecA y SecB)
Arreglo M de Real de [1:5, 1:3]; Var M: array [1..5, 1..3] of real; Arreglo bidimensional o
matriz
Registro R: Var R: record Registro con tres campos

Campo1: Real; Campo1: real;
Campo2: Lógico; Campo2: boolean;
Campo3: String; Campo3: string;
Fregistro; end;
Tipo Registro Producto: Type Producto = record Declaración de un tipo de

Código : Entero; Código : longInt; dato Registro (Producto) y
Nombre : String; Nombre : string; de variables de ese tipo (P1
Precio : Real; Precio : real; y P2)
Fregistro; end;
Producto P1, P2; P1, P2: Producto;
Archivo Arch de Carácter; Var Arch: file of char; Archivo de caracteres
Tipo Archivo Libros de String; Type Libros = file of string; Declaración de un tipo de
dato Archivo (Libros) y
Libros CasasMuertas, U21; CasasMuertas, U21: Libros; declaración de dos
variables archivo de tipo
Libros
2. REGLAS DE TRADUCCIÓN DE LA NOTACIÓN

ALGORÍTMICA AL LENGUAJE PASCAL

Leer(A); read(A); Lee y se queda en la línea
readln(A); Lee y salta de línea
Leer(A); Leer(B); read(A,B); Lectura de dos o más variables

Leer(A, B); readln(A,B);
A = B; A := B;
Escribir(A); write(A); Escribe y se queda en la línea

writeln(A); Escribe y salta de línea
Escribir (A, B); write(A,B); Escritura de dos o más variables
Si (A > B) y (A > C) entonces if (A > B) and (A > C) then Caso una sola acción dentro de
A = A + 1; A := A + 1; condicional simple.
Fsi;
Si (A > B) y (A > C) entonces if (A > B) and (A > C) then Caso dos o más acciones dentro
A = A + 1; begin de condicional simple.
B = A / 2; A := A + 1;
Fsi; B := A / 2;
end;
Si (A > B) y (A > C) entonces if (A > B) and (A > C) then Caso una sola acción dentro de
A = A + 1; A := A + 1 (* sin ; *) cada parte de un condicional
sino else doble
B = A / 2; B := A / 2;
Fsi;
Si (A > B) y (A > C) entonces if (A > B) and (A > C) then Caso dos acciones en el
A = A + 1; begin entonces y una acción en el sino
C = B + 1; A := A + 1; de un condicional doble
sino C := B + 1;
B = A / 2; end (* sin ; antes del else *)
Fsi; else
B := A / 2 ;
Si (A > B) y (A > C) entonces if (A > B) and (A > C) then Caso dos acciones en el
A = A + 1; begin entonces y dos acciones en el
C = B + 1; A := A + 1; sino de un condicional doble
sino C := B + 1;
B = A / 2; end
A = B * C; else
Fsi; begin
B := A / 2;
A := B * C;
end;
Continúa …
Reglas de traducción (continuación)

Para K = 1 hasta N en 1 hacer for K := 1 to N do Caso una sola acción dentro del Para.
A = A + 1; A := A + 1;
Fpara;
Para K = 1 hasta N hacer for K := 1 to N do Caso dos o más acciones dentro del
A = A + 1; begin Para.
B = A / 2; A := A + 1;
Fpara; B := B / 2;
end;
Repetir repeat Caso una sola acción dentro del

A = A / 2; A := A / 2; Repetir.
hasta A < 1; until A < 1;
Repetir repeat Caso dos o más acciones dentro del

A = A / 2; A := A / 2; Repetir.
B = B + 1; B := B + 1;
hasta A < 1; until A < 1;
Mientras A >=1 hacer while A >=1 do Caso una sola acción dentro del
A = A / 2; A := A / 2; Mientras.
Fmientras;
Mientras A >=1 hacer while A >=1 do Caso dos o más acciones dentro del
A = A / 2; BEGIN Mientras.
B = B + 1; A := A / 2;
Fmientras; B := B + 1;
END;
ANEXO 3
EJEMPLOS DE PROGRAMAS EN
TURBO PASCAL
EJEMPLO 1: Cálculo del IVA del precio de un producto

Enunciado: Calcule el IVA a pagar por un producto cuyo precio es suministrado por el usuario
program CalcularIva;
(* Este programa calcula el IVA a pagar por un producto *)
{ Los comentarios también pueden colocarse entre llaves }
(* declaración de constantes y variables *)

CONST porcIva = 0.09;
VAR
precio, montoIva, precioFinal : real;
BEGIN
(* solicitamos y leemos datos de entrada *)

writeln('Suministre el precio original del producto');
read(precio);
(* realizamos el procesamiento o cálculo *)

montoIva := precio * porcIva;
precioFinal := precio + montoIva;
(* escribimos los resultados *)

writeln('El precio final del producto es: ' , precioFinal)
END.
EJEMPLO 2: Cálculo del valor absoluto. Utiliza el condicional Si.

Enunciado: Calcule el valor absoluto de número decimal cualquiera.
program ValorAbsoluto;
(* calcula el valor absoluto de un número suministrado por el usuario *)
USES crt; (* librería que permite utilizar procedimientos que modifican el formato de la salida por
pantalla cuando se corre el programa *)
(* declaración de variables *)
VAR
num, orig: real;
mensaje: string;
BEGIN
clrscr; (* limpia la pantalla de la salida de corridas previas *)
textbackground(5); (* cambiamos el color del texto *)
mensaje := 'Suministre el número de entrada'; (* inicializamos la variable string del mensaje *)
(* solicitamos y leemos el valor de entrada *)

writeln (mensaje); readln(num);
orig := num; (* guardamos el valor original *)
(* aplicamos el concepto de valor absoluto usando un condicional Si *)

if num < 0.0 then
num := -1.0 * num; (* pasamos el número de entrada a positivo *)
writeln('el número de entrada es: ' , orig , ' y el |num| es ' , num:1:2 );
(* con la instrucción num:<cant enteros>:<cant decimales> damos formato al número de salida,
en este caso para que se muestre como un real con 2 decimales *)
readkey; (* en lugar de sacarnos de la ventana de corrida (pantalla negra), se queda a la espera de

que pulsemos una tecla, permitiéndonos así ver los resultados con mayor tranquilidad *)
END.
EJEMPLO 3: Cálculo de Divisores. Utiliza el ciclo Para.

Enunciado: Indique todos los números que dividen a un valor entero N dado por el usuario.
program DivisoresDeN;
(* muestra todos los divisores de un número entero N suministrado *)
USES Crt;
VAR
N: LongInt; i, cont: Integer; mens: string;
BEGIN
clrscr; (* limpiamos pantalla de resultados previos *)
textcolor(10);
cont := 0; (* cantidad de divisores encontrados *)
mens := 'suministre el valor de entrada, debe ser un entero > 0';
(* validación del dato de entrada con un ciclo Repetir *)

Repeat
writeln (mens); readln(N);
until N > 0;
(* ciclo Para que verifica cada divisor de N *)

For i:=1 to N do
begin
if (N mod i = 0) then
(* escribimos el número divisor *)
begin
writeln('el número ' , i , ' es divisor de N=' , N);
cont := cont + 1;
end;
{ fin del if }
end;
writeln(N , ' tiene ' , cont , ' divisores.'); (* indicamos la cantidad de divisores encontrada *)
if cont = 2 then
begin
writeln('entremos al Si que prueba si el número N es primo.'); writeln;
writeln(N ,' es además un número primo.');
end; (* fin del Si que verifica si el número es primo *)
readkey; (* deja visible la salida del programa hasta pulsar una tecla cualquiera *)
END.
EJEMPLO 4: Verificaciones matemáticas. Utiliza llamada a acciones y funciones con pase de parámetros.
Enunciado: Informar al usuario 4 opciones y utilizar llamadas a acciones o funciones para calcular sobre valores enteros:
Opción 1: verificar si un número n es capicúa Opción 2: verificar si un número n es primo
Opción 3: intercambiar 2 valores n1 y n2
Opción 4: calcular la suma de los números pares entre 2 números n1 y n2, además de informar cuantos pares hay
program CalculosMatematicos;
(* utiliza acciones o funciones para realizar calcular sobre números enteros *)
USES crt;
VAR { declaración de variables utilizadas en el cuerpo del program }
opcion, num1, num2, sumaPares, cantPares: Integer;
res: Boolean; { variable lógica para indicar si es primo o no }
PROCEDURE Capicua (N: integer; var capi :integer);

{ verifica si un número es capicúa: si se invierten sus dígitos es el mismo número original }
VAR { declaración de variables locales o internas al procedimiento Capicua }

copia, alreves, resto: integer;
begin
copia := N; alreves := 0; { en esta variable se reconstruirá el número invertido }
{ en el siguiente ciclo Mientras invertimos el número N guardándolo en al revés }

while N <> 0 do
begin
resto := N mod 10;
alreves := alreves * 10; { corre los dígitos a la izquierda }
alreves := alreves + resto; { agrega las unidades de N }
N := N div 10;
end;
{ escribimos los resultados }

writeln('El número original es: ' , copia:1);
{ verificamos si hay capicúa }

if alreves = copia then
writeln('Es capicúa, es igual al derecho que al revés.') (* recordar que antes del else no va ; *)
else
writeln('No es capicúa, el número al revés es: ' , alreves);
capi := alreves;
readkey; (* deja visible la salida del programa hasta pulsar una tecla cualquiera *)
end; { fin del procedimiento capicúa }
FUNCTION verificaPrimo (num: integer): boolean;

{ verifica si num es número primo }
Var
i, cont: integer; { variables locales de esPrimo }
esPri: boolean;
begin
cont := 0; { inicializamos el contador }
For i:=1 to num do
begin
if (num mod i = 0) then
cont := cont + 1; { contamos los divisores }
{ fin del if }
end;
{ verificamos si el número es primo }

if cont = 2 then
esPri := true { recordar que antes del else no se debe colocar ; }
else
esPri := false; { el número tiene más de 2 divisores por lo tanto no es primo }
{ fin del Si que verifica si el número es primo }
verificaPrimo := esPri; { retorno del resultado de la función }
end; { fin de la función esPrimo }
(* ***** ****************************************** ***** *)

(* *** AHORA VIENEN LAS INSTRUCCIONES DEL PROGRAM PRINCIPAL *** *)
(* ***** ****************************************** ***** *)
BEGIN
Repeat
Writeln('Indique el cálculo a realizar:');
writeln('1. Para verificar si num1 es Capicúa.');
writeln('2. Para verificar si num 1 es Primo.' );
writeln('3. Para intercambiar los valores de las variables num1 y num2.');
writeln('4. Para calcular la suma de los números pares que hay entre num1 y num2,
además de indicar cuántos valores pares hay entre ellos.' );
Readln(opcion);
Until (opcion >= 1) and (opcion <= 3);
case opcion of
1: { opción para verificar capicúa }
begin
writeln('suministre el número');
readln(num1);
num2 := 0;
Capicua(num1,num2);
writeln('el valor de num2 ahora es: ' , num2);
end;
2: { opción verificar si es primo }

begin
writeln('suministre el número');
readln(num1);
res := verificaPrimo(num1);
Writeln('El número ' , num1 , ' es primo? ' , res );
end;
3: { opción para realizar el intercambio de los valores de num1 y num2 }

begin
{ instrucciones para esta opción, incluyendo la llamada al procedimiento correspondiente }
end;
4: { opción para calcular la suma de los números pares entre num1 y num2 }
begin
{ instrucciones para esta opción, incluyendo la llamada al procedimiento correspondiente }
end;
else { opción por defecto y distinta a todas las anteriores }

Writeln('Ha indicado una opción inválida o no contemplada');
end; {termina la selección }
writeln; {estamos dejando una línea en blanco }

writeln('Pulse cualquier tecla para salir del programa');
readkey;
END.

Manual IntProgramacion Nivel1 - Veroctubre2017

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Manual IntProgramacion Nivel1 - Veroctubre2017

Caricato da

Copyright:

Formati disponibili

Introducción

Material elaborado por CENEAC Producciones, C.A.

2. Procedimientos y Funciones ............................................................................................................... 12

3. Formas Iterativas de Composición de Acciones (Ciclos) .................................................................... 19

4. Talleres de Ejercicios ......................................................................................................................... 24

Anexo 1: Lenguaje de Programación Turbo Pascal

1. Guía de Sintaxis de Turbo Pascal...................................................................................................... A2

1.3. Variables y Constantes.............................................................................................................. A7

Anexo 2: Reglas de Traducción al Lenguaje Pascal ………………………………………………. A15

1.- Reglas de Traducción para Tipos de Datos ................................................................................ A16

2.- Reglas de Traducción de la Notación Algorítmica al Lenguaje Pascal ....................................... A17

Anexo 3: Ejemplos de Programas en Turbo Pascal ......................................................................... A19

1.1 Conceptos Básicos

La disciplina dentro de la computación dedicada a la resolución de problemas mediante el computador es la Programación,

1.2 Definición de los Elementos presentes en un Algoritmo

1.2.1 Tipos de Datos

Tipos de Datos no Estructurados

Tipo de dato Entero

Tipo de dato Real

Tipo de dato Lógico

Tipo de dato Carácter

Tipo de dato String (cadena)

1.2.2 Constantes, Variables y Expresiones

Expresión Resultado Expresión Resultado

Los siguientes ejemplos muestran resultados de expresiones lógicas, compruébelos.

Los siguientes ejemplos muestran resultados de expresiones string

1.2.3 Acciones Básicas

Acción Efecto de la asignación

Entrada Simple ( Leer )

Salida Simple ( Escribir )

1.2.4. Formas de Composición de Acciones

EJEMPLO 1: Intercambio de dos valores

Solución de la Primera Versión Solución de la Segunda Versión

Ejemplo 2: Equivalencia de una cantidad en segundos a días, horas, minutos y segundos

Ejemplo 3: Ordenamiento de dos valores

Ejemplo 4: Máximo de dos valores

2.1. Paso de Parámetros en Procedimientos y Funciones

Ejemplo de definición de procedimientos

Ejemplo de uso de procedimientos

Ejemplo de definición de funciones

Ejemplo de uso de funciones

Paso de Parámetros por Valor

Paso de Parámetros por Referencia

y sea el siguiente fragmento de algoritmo que llamo o utiliza al procedimiento Ejemplo:

Ejemplo 6: Cálculo de las raíces de una ecuación de 2do. grado

Léxico del Algoritmo Principal

Definición del Procedimiento SolucionesReales(a,b,d,r1,r2)

EF = { A = a, B = b, D = b2 – 4ac , D >= 0, X1 = x1, X2 = x2, , x1 = (-b + (b2 –4ac) ** (1/2)) / (2a),

Definición del Procedimiento SolucionesImaginarias(a, b, d, r1, i1, r2, i2)

Léxico del Procedimiento SOLUCIONES_ IMAGINARIAS

Ejemplo 7: Cálculo de una función matemática

Léxico del Algoritmo Principal

Definición de la Función FUNCMAT(X)

Léxico de la Función FUNCMAT

2.2. Alcance: Variables Locales y Variables Globales

A Identificadores Son accesibles

3.1. Ciclo Para (For)

Para I = 1 hasta N inc 1 hacer ó Para I = N hasta 1 dec 1 hacer

Léxico del Algoritmo Principal

3.2. Ciclo Repetir (Repeat)

Esta composición es equivalente al siguiente secuenciamiento de acciones:

Ejemplo 9: Cálculo de interés sobre un capital.

Léxico del Algoritmo Principal