Vous êtes sur la page 1sur 71

UNIVERSIDAD NACIONAL DE INGENIERÍA

FACULTAD DE CIENCIAS
Escuela Profesional de Matemática

El Lenguaje de Programación Delphi


Apuntes de clase

Realizado por:
Edgard Kenny Venegas Palacios

Lima - Perú
2009
Índice general

1. Algoritmos y Programación Estructurada 1


1.1. Concepto y caracterı́sticas de un algoritmo . . . . . . . . . . . . . . . . . . 1
1.1.1. Propiedades de los algoritmos . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2. Caracterı́sticas de los algoritmos . . . . . . . . . . . . . . . . . . . . 2
1.2. Representación de un algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.1. Implementación y análisis de los algoritmos . . . . . . . . . . . . . . 3
1.3. Entradas y salidas de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2. Partes de un programa 7
2.1. Variables y constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.1. Identificadores válidos . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2. Tipos de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.1. Tipos de datos numéricos . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3. Declaración de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.1. Asignación de valores en el cuerpo del programa . . . . . . . . . . . 9
2.3.2. Ingreso de datos por el usuario . . . . . . . . . . . . . . . . . . . . . 11
2.4. Tipos de operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4.1. Operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4.2. Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5. Funciones matemáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.6. Los operadores div y mod . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.7. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3. Estructuras de control 19
3.1. Estructuras selectivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.1.1. Sentencia IF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2. Estructuras selectivas de múltiples alternativas . . . . . . . . . . . . . . . . 23
3.2.1. El Enunciado IF Anidado . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2.2. La Sentencia Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.3. Estructuras repetitivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.3.1. La Sentencia FOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3.2. La sentencia while . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

i
3.3.3. La Sentencia REPEAT . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.4. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

4. Cadenas. Entrada y salida de información 35


4.1. Cadenas y caracteres (String y Char) . . . . . . . . . . . . . . . . . . . . . . 35
4.1.1. Longitud de una cadena . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.1.2. Concatenación de cadenas . . . . . . . . . . . . . . . . . . . . . . . . 36
4.2. Conversión de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.2.1. Conversión de cadena a número . . . . . . . . . . . . . . . . . . . . . 36
4.2.2. Inputbox y Showmessage . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2.3. Ejercicios Resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.3. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

5. Vectores y Matrices 43
5.1. Arreglos Estáticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.1.1. Vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.1.2. Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.2. Arreglos Dinámicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.3. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

6. Procedimientos y Funciones 53
6.1. Parámetros por valor y referencia . . . . . . . . . . . . . . . . . . . . . . . . 55
6.2. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6.3. Técnicas de ordenación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6.3.1. Selección . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
6.3.2. Inserción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
6.3.3. Burbuja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
6.4. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

7. Registros 63
7.1. Declaración de registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.2. Ejercicios propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

Bibliografı́a 67

ii
Introducción

Delphi es uno de los lenguajes llamados de alto nivel, porque una sola de sus instruc-
ciones equivale a millares de código de máquina.
Delphi está basado en el lenguaje Pascal, cuyas capacidades fueron extendidas para con-
vertirlo en un lenguaje orientado a objetos; que en la actualidad es la metodologı́a de
programación más difundida y utilizada.

El objetivo de de este manual es mostrar las caracterı́sticas y estructura de un algoritmo


para la solución de problemas concretos.
Además, hay que resaltar que un primer curso de programación estructurada permite
obtener los conocimientos necesarios para analizar problemas de manera creativa y de
plasmarlas a través de un programa codificado, como es en este caso el lenguajes visual
Delphi.

0
Capı́tulo 1

Algoritmos y Programación
Estructurada

En matemáticas, ciencias de la computación y disciplinas relacionadas, un algoritmo


es una lista bien definida, ordenada y finita de operaciones que permite hallar la solución
a un problema. Dado un estado inicial y una entrada, a través de pasos sucesivos y bien
definidos se llega a un estado final, obteniendo una solución.

En la vida cotidiana se emplean algoritmos en multitud de ocasiones para resolver diver-


sos problemas. Algunos ejemplos se encuentran en los instructivos (manuales de usuario),
los cuales muestran algoritmos para usar el aparato en cuestión o inclusive en las instruc-
ciones que recibe un trabajador por parte de su patrón. También existen ejemplos de ı́ndole
matemático, como el algoritmo de la división para calcular el cociente de dos números, el
algoritmo de Euclides para calcular el máximo común divisor de dos enteros positivos,
o el método de Gauss para resolver un sistema lineal de ecuaciones.

La importancia de un algoritmo radica en mostrar la manera de llevar a cabo procesos y


resolver mecánicamente problemas matemáticos o de otro tipo.

1.1. Concepto y caracterı́sticas de un algoritmo


El concepto de algoritmo, aunque similar y obviamente relacionado, no debe con-
fundirse con el concepto de programa. Mientras el primero es la especificación de un
conjunto de pasos (operaciones, instrucciones, órdenes, etc.) orientados a la resolución de
un problema (método), el segundo es ese conjunto de operaciones especificadas en un de-
terminado lenguaje de programación y para un computador concreto, susceptible de ser
ejecutado (o compilado o interpretado). Un algoritmo, estrictamente hablando, no puede
ejecutarse hasta que se implementa, ya sea en un lenguaje de programación, en un cir-
cuito eléctrico, en un aparato mecánico, usando papel y lápiz, o en algún otro modelo de
computación.

1
E. Kenny Venegas P.

1.1.1. Propiedades de los algoritmos


El cientı́fico de computación Donald Knuth ofreció una lista de cinco propiedades, que son
ampliamente aceptadas como requisitos para un algoritmo:

1. Carácter finito. Un algoritmo siempre debe terminar después de un número finito


de pasos.

2. Precisión. Cada paso debe estar precisamente definido; las operaciones a llevar a
cabo deben ser especificadas de manera rigurosa y no ambigua para cada caso.

3. Entrada. Un algoritmo tiene cero o más entradas: cantidades que le son dadas antes
de que el algoritmo comience, o dinámicamente mientras el algoritmo corre.

4. Salida. Un algoritmo tiene una o más salidas: cantidades que tienen una relación
especı́fica con las entradas.

5. Eficacia. Todas las operaciones a realizar en un algoritmo deben ser de tal modo que
puedan ser hechas de manera exacta y en un tiempo finito por un hombre usando
lápiz y papel.

1.1.2. Caracterı́sticas de los algoritmos


A continuación mencionamos las caracterı́sticas de los algoritmos:

Finitos: Debe acabar en algún momento.

Eficientes: Deben ocupar la mı́nima memoria y minimizar el tiempo de ejecución.

Legibles: El texto que lo describe debe ser claro, tal que permita entenderlo y leerlo
fácilmente.

Modificables: Estarán diseñados de modo que sus posteriores modificaciones sean


fáciles de realizar, incluso por programadores diferentes a sus propios autores.

Modulares: La filosofı́a utilizada para su diseño debe favorecer la división del pro-
blema en módulos pequeños.

1.2. Representación de un algoritmo


Un algoritmo puede representarse mediante un pseudocódigo o un diagrama de flu-
jo. El usar pseudocódigo y diagramas de flujo evita muchas ambigüedades del lenguaje
natural. Dichas expresiones son formas más estructuradas para representar algoritmos; no
obstante, se mantienen independientes de un lenguaje de programación especı́fico.

Los diagramas de flujo son descripciones gráficas de algoritmos; usan sı́mbolos conec-
tados con flechas para indicar la secuencia de instrucciones y están regidos por ISO.

2
1.2. Representación de un algoritmo

Los diagramas de flujo son usados para representar algoritmos pequeños, ya que abarcan
mucho espacio y su construcción es laboriosa. Por su facilidad de lectura son usados co-
mo introducción a los algoritmos, descripción de un lenguaje y descripción de procesos a
personas ajenas a la computación.

A continuación describimos los sı́mbolos usados en los diagramas de flujo:

Un pseudocódigo es la descripción de un algoritmo que asemeja a un lenguaje de progra-


mación pero con algunas convenciones del lenguaje natural. Tiene varias ventajas con re-
specto a los diagramas de flujo, entre las que se destaca el poco espacio que se requiere para
representar instrucciones complejas. El pseudocódigo no está regido por ningún estándar.
Pseudo viene de falso y por ende es un codigo al que aunque es entendible no se aplica al
proceso que debe realizar la maquina.

La descripción de un algoritmo usualmente se hace en tres niveles:

1. Descripción de alto nivel. Se establece el problema, se selecciona un modelo


matemático y se explica el algoritmo de manera verbal, posiblemente con ilustra-
ciones y omitiendo detalles.

2. Descripción formal. Se usa pseudocódigo para describir la secuencia de pasos que


encuentran la solución.

3. Implementación. Se muestra el algoritmo expresado en un lenguaje de progra-


mación especı́fico o algún objeto capaz de llevar a cabo instrucciones.

La máquina de Turing es un modelo matemático, diseñado por Alan Turing, que formal-
iza el concepto de algoritmo. A este modelo se le refiere comunmente como la “descripción
de más bajo nivel” por el hecho de que no utiliza ninguna expresión coloquial.

1.2.1. Implementación y análisis de los algoritmos


Muchos algoritmos son ideados para implementarse en un programa. Sin embargo, los al-
goritmos pueden ser implementados en otros medios, como una red neuronal, un circuito
eléctrico o un aparato mecánico. Algunos algoritmos inclusive se diseñan especialmente
para implementarse usando lápiz y papel. El algoritmo de multiplicación tradicional, el

3
E. Kenny Venegas P.

algoritmo de Euclides, la criba de Eratóstenes y muchas formas de resolver la raı́z cuadra-


da son sólo algunos ejemplos.

Como medida de la eficiencia de un algoritmo, se suelen estudiar los recursos (memoria


y tiempo) que consume el algoritmo. El análisis de algoritmos se ha desarrollado para
obtener valores que de alguna forma indiquen (o especifiquen) la evolución del gasto de
tiempo y memoria en función del tamaño de los valores de entrada.

El análisis y estudio de los algoritmos es una disciplina de las ciencias de la computación


y, en la mayorı́a de los casos, su estudio es completamente abstracto sin usar ningún tipo
de lenguaje de programación ni cualquier otra implementación; por eso, en ese sentido,
comparte las caracterı́sticas de las disciplinas matemáticas. Ası́, el análisis de los algo-
ritmos se centra en los principios básicos del algoritmo, no en los de la implementación
particular. Una forma de plasmar (o algunas veces “codificar”) un algoritmo es escribirlo
en pseudocódigo o utilizar un lenguaje muy simple tal como léxico, cuyos códigos pueden
estar en el idioma del programador.

Todo pseudocódigo consta de 3 partes: nombre, cabecera y cuerpo.

Ejemplo 1.1

Nombre: Algoritmo para hacer un vaso de limonada


Cabecera: Materiales: Vaso, cuchara, jarra,cuchillo
Ingredientes: Limón , azúcar , agua
Cuerpo del algoritmo: Partir el limón en dos.
Exprimir el contenido del limón en el vaso.
Echar agua y azúcar en el vaso.
Mezclar.

La estructura del programa es la siguiente:

Program nombre del programa



Uses 

declaración de bibliotecas 



Type 



declaración de arreglos y nuevos tipos de variables

Cabecera
Const 

declaración de constantes




Var





declaración de variables

begin  
.. Cuerpo
. 
end.

4
1.3. Entradas y salidas de datos

Se debe colocar siempre un punto después del “end”.

Todo algoritmo se representa en el siguiente diagrama, donde las flechas de rojo se llaman
compiladores:

Programadores ↔ Algoritmo ↔ Programa ↔ Computadora


↓ ↓ ↓ ↓
Español ↔ Inglés ↔ Lenguaje Máquina ↔ Lenguaje Máquina

1.3. Entradas y salidas de datos


La salida de datos es la visualización de información en pantalla, para ello debemos
usa los comandos write (escribir) o writeln (escribir y dar salto de lı́nea).
Si se quiere mostrar en la pantalla de texto, éste se debe escribir entre apóstrofes.

Ejemplo 1.2 write(’Hola, Mundo’);

Lo que hace escribir el texto “Hola, Mundo” en la pantalla del computador, es decir se
visualizará

Hola, Mundo

Ejemplo 1.3 writeln(’Adios, Mundo’);

A diferencia del anterior, el cursor estará en la siguiente lı́nea, por lo tanto, la salida será la
siguiente:

Adios, Mundo

Para que el usuario pueda ingresar caracteres deberá utilizar el comando readln (leer).
Este comando también se utiliza para visualizar la pantalla hasta que el usuario presione
“enter”. Es por ello que siempre se coloca readln antes del end para detener la ejecución
del programa.

Se debe colocar un punto y coma ( ; ) después de utilizar los comandos write, writeln y
readln. Aunque no es necesario colocar ; antes del end. En realidad no hay diferencia si
coloca o no el ; antes de un end.

Para la óptima comprensión de los comandos definidos anteriormente debemos introducir


el concepto de variables.

5
E. Kenny Venegas P.

1.4. Ejercicios propuestos


1. Detecte los errores del siguiente programa:

program correcto;
var a,b,c: real;
d,e: entero;
begin
write(’ingrese a’;
read(a);
b=a+1;
c=c-1;
for i=1 to a do
begin
d:=b*c; e:=b/c;
b:=b+a; c:=c-a;
end;
write(’resultado= ’d-e);
end

2. Realice la representación gráfica del programa anterior.

6
Capı́tulo 2

Partes de un programa

2.1. Variables y constantes


Cuando se procesa información o datos, un programa para computadora generalmente
mantiene valores para varias cantidades, a éstas cantidades se les puede hacer referencia
por nombres y son conocidos como variables. El valor de una variable puede alterarse
durante la ejecución del programa.
Una constante es una variable, con la diferencia de que su valor no se altera.
Una variable va a tener dos propiedades (o partes):

Un Nombre (Al que llamaremos identificador).

Un Tipo (El tipo de variable puede ser entero, real, texto, etc.).

2.1.1. Identificadores válidos


Los identificadores deben cumplir varios requisitos (los cuales se asemejan a los requisitos
que debe tener el nick de un usuario de correo electrónico):

Sólo deben contener caracteres alfanuméricos y los caracteres “ ” y “ ”.

El primer carácter debe ser una letra o subrayado.

No puede contener espacios en blanco ni vocales tildadas, ni ñ o Ñ.

No debe ser ninguna palabra reservada.

Las palabras reservadas son aquellas palabras que ya tienen una función declarada, por
ejemplo: char, var, if, for, etc . . .

Ejemplo 2.1

Jose (correcto).

7
E. Kenny Venegas P.

123abc (incorrecto).

raiz 23 (correcto).

byte (incorrecto).

Un identificador no es sensible a las mayúsculas, por ejemplo, un identificador cono Min-


Max puede escribirse de cualquiera de las siguientes maneras:

Minmax

minMax

minmax

MINMAX

MiNmAx

Al declarar una variable, tras el identificador que servirá como nombre, indicaremos el
tipo de dato que podremos almacenar en ella.

2.2. Tipos de variables


Delphi tiene definido 5 tipos de variables los cuales mencionamos a continuación:

1. Integer: Almacena números enteros.

2. Real: Almacena números reales (con decimales).

3. Char: Almacena un caracter cualquiera del código ASCII.

4. String: Almacena uno o más caracteres (texto).

5. Boolean: Almacena el valor de TRUE o FALSE (V o F).

2.2.1. Tipos de datos numéricos


Tipo Rango de valores Ocupación
ShortInt -128 a 127 8 bits
Byte 0 a 255 8 bits
SmallInt -32768 a 32767 16 bits
Word 0 a 65535 16 bits
Integer -2147483648 a 2147483647 32 bits
Single 1.2e-38 a 3.4e38 32 bits
Real 2.2e-308 a 1.8e308 64 bits

8
2.3. Declaración de variables

2.3. Declaración de variables


Sintaxis

Var < Identificador > : < Tipo de variable > ;

Ejemplo 2.2

cad : string;
Raiz 12 : real;
Edad : integer;
Opcion : char;

2.3.1. Asignación de valores en el cuerpo del programa


Sintaxis

< Nombre de la variable > := < Valor de la variable > ;

Donde “:=” es el operador de asignación. Cuando queremos asignar el valor de una variable
del tipo char o string, colocaremos el carácter o caracteres entre apóstrofes.

Ejemplo 2.3

Program Prueba;

var
a: integer; b: real;
c: char; d: string;
e,f: boolean;

begin
a:=5; // 5 es el valor de a
b:=3.25; // 3.25 es el valor de b
c:=’1’; { ’1’ es el valor de c }
d:=’11’; (* ’11’ es el valor de *)
e:=True; // El valor de e es verdadero
f:=False; { El valor de f es falso }
end.

Observaciones

No hay error si b:=5; pero si a := 3.25; estarı́a mal ya que a debe ser entero.

No hay error si d:=’1’; pero si c:= ’11’; estarı́a mal ya que c debe ser un caracter.

9
E. Kenny Venegas P.

Podemos colocar más de un identificador en la asignación del tipo de variables si los


separamos por comas (,) como en el ejemplo anterior al definir e y f.

Los comentarios se usan para describir una o más instrucciones en el programa y no


son ejecutados por el programa. Si es un comentario corto podemos utilizar “//”, en todo
caso podemos escribir el comentario dentro de llaves o dentro de (* *), los cuales se usan
en comentarios largos, como en el ejemplo anterior.
Si queremos visualizar en la pantalla el valor de una variable podemos utilizar el comando
write o writeln, para ello escribiremos el nombre de la variable entre paréntesis después
de alguno de estos comandos. Es decir:

Sintaxis

Write ( < nombre de la variable > ); Writeln ( < nombre de la variable > ) ;

Ejemplo 2.4

program Prueba1;

var
entero : integer;
b: boolean;

begin
Entero := 5;
B:=False;
Writeln (’a = ’);
Write (entero);
Writeln (b);
Readln;
end.

La pantalla de salida será:

a=
5False

Ejemplo 2.5

10
2.3. Declaración de variables

program Prueba2;

var
a : integer;

begin
a := 3;
Write (’a = ’);
Writeln( a );
Writeln;
a := 5;
Write (’Ahora a = ’);
Writeln ( a );
Readln;
end.

La pantalla de salida será:

a=3
Ahora a = 5

Cuando queremos dar un salto de lı́nea simplemente, como en el ejemplo anterior, es-
cribiremos en el programa writeln.

2.3.2. Ingreso de datos por el usuario


Para el ingreso de datos (por teclado) utilizaremos el comando readln y a continuación
escribimos el nombre de la variable entre paréntesis. Es decir:

Sintaxis

Readln ( < Nombre de la variable a ser leı́da > ) ;

Ejemplo 2.6

program Prueba3;

var
a: integer;

begin
Writeln (’Ingrese un entero’);

11
E. Kenny Venegas P.

Readln (a);
Write ( ’a = ’ );
Write (a);
Readln;
end.

Primero la pantalla de salida será:

Ingrese un entero:

Supongamos que ingresamos 3 como el valor de a, luego se visualizará:

Ingrese un entero:
3
a=3

Ejemplo 2.7

program Prueba;

var
nombre: string;
edad: integer;

begin
Write (’Escriba su nombre: ’);
Readln (nombre);
Write (’Escriba su edad: ’);
Readln (edad);
Writeln (’Su nombre es ’,nombre,’ y su edad es ’,edad );
Readln;
end.

Primero la pantalla de salida será:

Escriba su nombre:

12
2.4. Tipos de operadores

Supongamos que ingresamos Jorge como el valor de nombre. Luego se visualizará:

Escriba su nombre: Jorge


Escriba su edad:

Supongamos que ingresamos 20 como el valor de edad. Finalmente la salida será:

Escriba su nombre: Jorge


Escriba su edad: 20
Su nombre es Jorge y su edad es 20

En el ejemplo anterior utilizamos dos variables cuyos valores son ingresados por el usuario
y estos valores son mostrados acompañados de textos que se separan de las variables
mediante comas.

2.4. Tipos de operadores


2.4.1. Operadores aritméticos
+ : suma
- : resta
* : producto
/ : división

2.4.2. Operadores lógicos


And ( y)
Or ( o)
Not ( negación )
Xor ( o exclusivo )

Ejemplo 2.8

( 4 < 5 ) and ( 3 >= 2 ) True


( -1 < > 1 ) or ( 3 < 2 ) True
Not ( 4 < 5 ) False
( 1 > = 0 ) xor ( 1 < 0 ) True
También podemos más de dos operadores lógicos, por ejemplo:

( ( 1 < > 0 ) or ( 1 > 2 ) ) and ( 4 < 3 ) False


Not ( ( 1 > = 2 ) and ( 0 < = -1) ) True

13
E. Kenny Venegas P.

2.5. Funciones matemáticas


Delphi tiene implementada las siguientes funciones matemáticas:

Sin : Seno
Cos : Coseno
Tan : Tangente
Exp : Exponencial
Sqr : Al cuadrado
Sqrt : Raı́z cuadrada
Ln : Logaritmo neperiano
Abs : Valor absoluto
ArcTan : Arco tangente
ArcSin : Arco seno
ArcCos : Arco coseno
Sinh : Seno hiperbólico
Cosh : Coseno hiperbólico
Sintaxis

< función > ( < variable > ) ;


< función > ( < valor numérico > ) ;

Observaciones

Las funciones Abs y Sqr , respetan el tipo de variable, es decir, si la variable es real
(entera), el resultado también será real (entera).

Para utilizar las funciones Tan, ArcSin, ArcCos, Sinh y Cosh debemos incluir la
biblioteca Math.

Ejemplo 2.9

program Prueba ;

var
a, b: integer ;
c, d: real ;

begin
a := 2;
b := sqr(a) ;
c := -3.5;
d := abs(c) ;

14
2.5. Funciones matemáticas

end.

Para obtener, debemos escribir en el programa:

sqrt ( sqr(b) - 4*a*c )

Para obtener xy , debemos escribir en el programa:

exp ( ln (x)*y )

3+1
Para 2 , debemos escribir en el programa:

( sqrt(3) +1 ) / 2

Ejemplo 2.10

Escribir un programa en Delphi que calcule la suma y el producto de las raı́ces del poli-

nomio cuadrático: x2 − ax + ln b, donde a y b son ingresados por el usuario.

program Ejemplo1;

{$APPTYPE CONSOLE}

var
a,b: real;

begin
Write (’Ingrese el valor de “a”: ’);
Readln (a);
Write (’Ingrese el valor de “b”: ’);
Readln (b);
Writeln (’El valor de la suma de las raı́ces es ’,sqrt(a));
Writeln (’El valor del producto de las raı́ces es ’,ln(b));
Readln;

end.

Para ver la salida de un programa se debe incluir la instrucción {$APPTYPE CONSOLE}


al inicio de la cabecera del programa como en el ejemplo anterior.

Supongamos que ingresamos a = 2 y b = 4, entonces al final de ejecutar el programa


anterior se visualizará en la pantalla:

15
E. Kenny Venegas P.

Ingrese el valor de “a”: 2


Ingrese el valor de “b”: 4
El valor de la suma de las raı́ces es 1.414213562373E+0000
El valor del producto de las raı́ces es 1.38629436111989E+0000

Se aprecia que en la salida, ambos valores tienen 14 decimales y al final E+0000 significa
que el número visualizado debe multiplicarse por 100000 = 1. En general, cuando se mues-
tra el valor de un número real, se verá en la pantalla aE + b ó aE − b, en consecuencia el
valor será a × 10b ó a × 10−b respectivamente.

Para evitar la salida de los 14 decimales que tiene a podemos indicar en el programa el
número de decimales que tendrá una variable real y también podemos dar espacios en
blanco antes de mostrar un valor. Para ello escribiremos:
< variable de tipo real > : n : m
En este caso el número de decimales será m. Supongamos que el número de dı́gitos en la
salida es d, entonces el número de espacios en blanco que se dará antes de imprimir el
valor será n − d, si n − d < 0 entonces no se dará espacios en blanco. Apliquemos esto en
el siguiente ejemplo:

Program Ejemplo2;
{$APPTYPE CONSOLE}
Begin
Writeln ( ln(3):4:2 );
Write ( sqrt(2):6:2 );
Readln
End.

1.10
En la pantalla se mostrará la salida: 1.41

En la segunda lı́nea se ha dado 2 espacios.

2.6. Los operadores div y mod


Hay otros operadores aritméticos definidas en Delphi como div y mod, los cuales están
definidos como el cociente y el residuo de una división entera respectivamente. Es decir,
dados a y b números enteros existen números enteros q y r, tal que : a = q ∗ b + r, donde
0 = r < b. Entonces q = a div b y r = a mod b.
Sintaxis:
<Variable de tipo entero> := <Variable de tipo entero> div <Variable de tipo entero>
;

16
2.6. Los operadores div y mod

<Variable de tipo entero> := <Variable de tipo entero> mod <Variable de tipo


entero>;

Ejemplos:

14 div 3 = 4
14 mod 3 = 2
5 mod -2 = 1
5 div -2 = -2

Ejemplos:

1. Dado n un entero positivo menor que 100, el cual es ingresado por el usuario, haga
un programa en Delphi que halle la suma de sus cifras:

Program SumaCifras;
{$APPTYPE CONSOLE}
Var : a,b,n : byte ;
Begin
Write ( ’Ingrese un entero positivo menor que 100: ’ ) ;
Readln (n) ;
a:= n div 10 ;
b:= n mod 10 ;
Write ( ’ la suma de cifras de ’ , n : 2 ) ;
Write ( ’ es ’, a+b ) ;
Readln;
End.

2. Elabore un programa que pida 4 números: a, b, c y d, luego calcule el determinante


de y muestre el resultado.

Program Ejemplo2;
{$APPTYPE CONSOLE}
Var
a,b,c,d,det: real;
Begin
Writeln (’Ingrese el valor de a, b , c y d en ese orden: ’);
Readln(a,b,c,d);
det:=a*d-b*c;
Write(’El valor del determinante es ’,det:6:3);
Readln
End.

Observación:

17
E. Kenny Venegas P.

En el segundo ejemplo podemos ver que no fue necesario introducir las variables una
por una, pues en Delphi se puede introducir varias variables a la vez con el comando
Readln si separamos las variables mediante comas.

2.7. Ejercicios propuestos


1. Dados a, b y c números reales, elabore un programa que muestre las raı́ces (reales o
complejas) de la ecuación cuadrática

ax2 + bx + c = 0.

2. Haga un algoritmo que calcule la suma y producto de dos polinomios cuadráticos.


Para ello el programa debe pedir los coeficientes de los términos independientes,
lineales y cuadráticos de los polinomios y debe mostrar los coeficientes de ambos
resultados.

18
Capı́tulo 3

Estructuras de control

3.1. Estructuras selectivas


El compilador de un programa efectúa selecciones evaluando expresiones booleanas,
esto es, expresiones que tienen valores de verdadero o falso.

3.1.1. Sentencia IF
La sentencia If presenta dos formas: simple y doble.

A) Selección simple

If <expresión booleana> then


Begin
<sentencias> se ejecuta sólo si la expresión booleana es verdadera.
End ;

B) Selección doble

If < expresión booleana > then


Begin
<sentencias 1>
End ELSE
Begin
<sentencias 2>
End;

Estructura If Simple (Si - entonces)


Está compuesto únicamente de una condición. La estructura “si - entonces” evalúa la
condición y en tal caso:

19
E. Kenny Venegas P.

Si la condición es verdadera, entonces ejecuta la acción Si (o acciones si son varias).


Si la condición es falsa, entonces no se hace nada.

Ejemplo 3.1 Construir un algoritmo tal, que dado como dato la calificación de un alumno
en un examen, escriba “Aprobado” en caso que esa calificación fuese mayor o igual que
10.

Algoritmo Calificación
Variables
cal: entero
Inicio
Leer (cal)
Si cal >= 10 entonces
Escribir ("Aprobado")
Fin_si
Fin

Estructura If Doble
Es una estructura lógica que permite controlar la ejecución de varias acciones y se
utilizan cuando se tienen dos opciones de acción, por la naturaleza de estas se debe ejecutar
una o la otra, pero no ambas a la vez, es decir, son mutuamente excluyentes.

20
3.1. Estructuras selectivas

Ejemplo 3.2 Dado como dato la calificación de un alumno en un examen, escriba .aprobado”si
su calificación es mayor que 10 y Reprobado.en caso contrario.

Algoritmo Calificacion
Inicio
Leer (cal)
Si cal > 10 entonces
Escribir ("aprobado")
Sino
Escribir ("reprobado")
Fin_si
Fin

Ejemplo 3.3 Dado como dato el sueldo de un trabajador, aplicar un aumento del 15 %
si su sueldo es inferior a $1000 y 12 % en caso contrario, luego imprimir el nuevo sueldo
del trabajador.

Program Multiplo2;
{$APPTYPE CONSOLE}
Var
a,b: integer;
Begin

21
E. Kenny Venegas P.

Write (’Ingrese un entero positivo: ’) ;


Readln (a) ;
If ( a>0 ) then
Begin
b:= a mod 2 ;
If (b = 0) then
Write ( a,’ es multiplo de 2’)
Else
Write ( a,’ no es multiplo de 2’) ;
End;
Readln
End.

Observaciones:

1. Si el número de sentencias es 1 se puede obviar el Begin - End.

2. Antes de un Else no hay “;”.

3. Al final del End hay “;”.

4. No es obligatorio colocar “;” antes de un End.

5. No se puede visualizar las vocales tildadas.

Ejemplo 3.4 Elabore un pseudocódigo que diga si un número real está o no en el intervalo
[-1 1].

Algoritmo Intervalo;
Variables
x: real
Inicio
Escribir (’Ingrese un numero real: ’)
Leer (x)
Si (x=-1) y (x=1) entonces
Escribir (x,’ está en el intervalo [ -1 , 1 ]’)
Sino
Escribir (x,’ no está en el intervalo [ -1 , 1 ]’)
Fin

Ejemplo 3.5 Haga un programa que pida el ingreso de 2 números y calcule el mayor de
ellos.

Program Mayor2;
{$APPTYPE CONSOLE }
Var
a,b: real;

22
3.2. Estructuras selectivas de múltiples alternativas

Begin
Writeln ( ’Ingrese dos numeros reales: ’ ) ;
Readln (a,b) ;
If ( a > b ) then
Write (’El numero mayor es ’ , a:5:3)
Else
Write (’El numero mayor es ’ , b:5:3);
Readln
End.

3.2. Estructuras selectivas de múltiples alternativas


Se ha visto que el compilador puede escoger entre dos alternativas. En algunos casos,
el compilador debe escoger entre una lista con mas de dos alternativas. Hay dos métodos:
IF anidado y Case .

3.2.1. El Enunciado IF Anidado


En la solución de problemas encontramos numerosos casos en los que luego de tomar
una decisión y marcar el camino correspondiente a seguir, es necesario tomar otra de-
cisión. Dicho proceso puede repetirse varias veces. En aquellos problemas en donde un
bloque condicional incluye otro bloque condicional se dice que un bloque está anidado
dentro del otro.

Sintaxis:

If < condicion 1 > then


< sentencia 1 >
Else If < condicion 2 > then
< sentencia 2 >
Else If < condicion 3 > then
< sentencia 3 >
.
.
.
Else
< sentencia n > ;

Ejemplo 3.6 Elabore un programa que pida el ingreso de un número entero y diga si es
positivo, cero o negativo. En el caso que sea positivo diga además si es par o impar.

Program IF_Anidado;
{$APPTYPE CONSOLE }
Var

23
E. Kenny Venegas P.

n: integer;
Begin
Write ( ’Ingrese un numero entero: ’ ) ;
Readln (n) ;
If (n<0) then
Write ( ’El numero es negativo ’ )
Else if ( n = 0 ) then
Write ( ’El numero es cero’ )
Else if ( n mod 2 = 0 ) then
Write ( ’El numero es positivo y par’ )
Else
Write ( ’El numero es positivo e impar’ );
Readln
End.

3.2.2. La Sentencia Case


Con frecuencia es necesario que existan más de dos elecciones posibles. Este problema
se podrı́a resolver por estructuras selectivas simples, dobles o anidadas, pero si el número
de alternativas es grande puede plantear serios problemas de escritura y de legibilidad.
Usando la estructura de decisión múltiple se evaluará una expresión que podrá tomar n
valores distintos, 1, 2, 3, . . . , n y según que elija uno de estos valores en la condición, se
realizará una de las n acciones o lo que es igual, el flujo del algoritmo seguirá sólo un
determinado camino entre los n posibles. Esta estructura se representa por un selector el
cual si toma el valor 1 ejecutará la acción 1, si toma el valor 2 ejecutará la acción 2, si
toma el valor N realizará la acción N .

Ejemplo 3.7 Diseñar un algoritmo tal que dados como datos dos variables de tipo entero,
obtenga el resultado de la siguiente función:

 100V, siN um = 1;
100V ,

siN um = 2;

V al(N um.V ) =

 100/V, siN um = 3;
0, en otro caso.

Veamos la representación de tal algoritmo en un diagrama de flujo y en el diagrama NS.

24
3.2. Estructuras selectivas de múltiples alternativas

Sintaxis:

Case <selector> of
Opción 1 : sentencia 1;
Opción 2 : sentencia 2;
Opción 3 : sentencia 3;
.
.
Opción n : sentencia n
Else
Sentencia n+1
End;

Observación:

El selector debe ser de tipo ordinal, es decir entero o carácter.

25
E. Kenny Venegas P.

Ejemplo 3.8 Implemente el algoritmo del ejemplo anterior.


Program ValCase;
{$APPTYPE CONSOLE}
Var
num,v: integer;
val: real;
Begin
Writeln(’Ingrese los valores de "num" y "val" en ese orden:’);
Readln(num,v);
Case num of
1: val:= 100*v;
2: val:= exp(ln(100)*v);
3: val:= 100/v
Else
val:= 0;
End;
Write(’El valor de "val" es ’,val:6:3);
Readln
End.

Ejemplo 3.9 Elabore un programa que diga si el dı́a de hoy hay o no clases
Program DiaCase;
{$APPTYPE CONSOLE }
Var
cad: string;
op: char;
Begin
Write (’Ingrese la primera letra del dia de hoy: ’);
Readln(op);
Case op of
’l’,’L’: cad:=’Hay clases pues es lunes’;
’j’,’J’: cad:=’Hay clases pues es jueves’
Else
cad:= ’Hoy no hay clases ’;
End;
Writeln (cad);
Readln
End.

3.3. Estructuras repetitivas


Nos permiten ejecutar una secuencia de instrucciones repetidamente usando una condi-
ción de control o variable, para determinar cuando debe detenerse la ejecución. Hay tres

26
3.3. Estructuras repetitivas

tipos de lazos de control:

Sentencia For (Desde/Para).

Sentencia While (Mientras).

Sentencia Repeat (Repetir).

El conjunto de instrucciones que se ejecuta repetidamente cierto número de veces, se


llama Ciclo, Bucle o Lazo.
Una Iteración es cada una de las diferentes pasadas o ejecuciones de todas las instrucciones
contenidas en el bucle.

Fases de un Programa Cı́clico:

1. Entrada de datos e instrucciones previas

2. Lazo o bucle

3. Instrucciones finales o resto del proceso

4. Salida de resultado

Contador
Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad
constante cada vez que se produce un determinado suceso o acción. Los contadores se
utilizan con la finalidad de contar sucesos o acciones internas de un bucle; deben realizar
una operación de inicialización y posteriormente las sucesivas de incremento o decremento
del mismo. La inicialización consiste en asignarle al contador un valor. Se situará antes y
fuera del bucle.

Representación:

<nombre del contador>←<nombre del contador> + <valor constante>

Si en vez de incremento es decremento se coloca un menos en lugar del más.

Ejemplo: i = i + 1

Acumulador
Es una variable que suma sobre sı́ misma un conjunto de valores para de esta manera
tener la suma de todos ellos en una sola variable. La diferencia entre un contador y un
acumulador es que mientras el primero va aumentando de uno en uno, el acumulador va
aumentando en una cantidad variable. Representación:

<Nombre del acumulador>←<nombre del acumulador> + <valor variable>

27
E. Kenny Venegas P.

3.3.1. La Sentencia FOR


Se usa frecuentemente cuando se conoce de antemano el número de veces que se eje-
cutarán las acciones de un bucle. Esta es una de sus caracterı́sticas.

Ejemplo 3.10 Hacer un algoritmo que calcule la suma de los cuadrados de los primeros
100 enteros y escribir el resultado. Se desea resolver el problema usando la sentencia For.

28
3.3. Estructuras repetitivas

Sintaxis:

INCREMENTOS:

For <contador>:=<val ini> to <val fin> do


Begin
<sentencias>;
End;

DECREMENTOS:

For <contador>:=<val ini> downto <val fin> do


Begin
<sentencias>;
End;

Ejemplo 3.11 Implementar el algoritmo anterior.

Program SumaCuadrados;
{$APPTYPE CONSOLE}
Var
suma,i: integer;
Begin
suma:=0;
for i:=1 to 100 do
suma:=suma+sqr(i);
Write(’El valor de la suma es ’,suma);
Readln
End.

3.3.2. La sentencia while

En esta estructura la condición es evaluada antes de la primera ejecución de sentencias,


de modo que si la condición es falsa, la secuencia nunca es ejecutada. La ejecución de estas
sentencias continua mientras la expresión booleana sea verdadera.

29
E. Kenny Venegas P.

Observe en el diagrama de flujo, que se necesita una variable contadora (un ı́ndice), para
llevar la cuenta de las veces que entramos al cuerpo del ciclo. También es importante notar
que esta variable se inicializa antes de entrar al cuerpo del ciclo y dentro del cuerpo se
incrementa en una cantidad constante, por lo general en uno.
Esta variable a la vez, nos sirve para compararla con el valor dado en la condición, cuando
se cumple la condición, se sale del ciclo.

Ejemplo 3.12 Haga un algoritmo que calcule la suma de los cuadrados de los primeros
100 números enteros utilizando la estructura Mientras.

30
3.3. Estructuras repetitivas

Sintaxis:
While ( expresión booleana ) do
Begin
Sentencia 1 ;
Sentencia 2 ;
.
Sentencia n ; // el ; es opcional
End ;
Ejemplo 3.13 Implementar el algoritmo anterior.
Program SumaMientras;
{$APPTYPE CONSOLE}
Var
suma,i: integer;
Begin
suma:=0;
i:=1;
while (i<=100) do
Begin
suma:= suma + sqr(i);
i:=i+1;
End;
Write(’El valor de la suma es ’,suma);
Readln
End.

3.3.3. La Sentencia REPEAT


Se llama Repetir a la estructura algorı́tmica que se ejecuta un número definido de veces
hasta que la condición se torna verdadera:

31
E. Kenny Venegas P.

Las reglas para la construcción de esta estructura usando Repetir, nos dicen que debemos
declarar una variable contador que debe inicializarse antes del ciclo e incrementarse dentro
del ciclo. A diferencia de la estructura Mientras, la condición ahora estará colocada al final
del bucle para que primero ejecutamos la instrucción y luego preguntamos si la condición
se cumple. Esto quiere decir, que en esta estructura el bucle se realizará por lo menos
una vez. También podrás observar que la condición está al revés, porque el bucle se repite
hasta que la condición se cumpla. En el bucle Mientras, la condición se evaluaba mientras
era cierta.

Ejemplo 3.14 Hacer un algoritmo que calcule la suma de los cuadrados de los primeros
100 números enteros utilizando la estructura Repeat.

Sintaxis:

32
3.3. Estructuras repetitivas

REPEAT
Sentencia 1 ;
Sentencia 2 ;
.
.
.
Sentencia n ;
Until (expresión booleana);

Observaciones:

No es necesario colocar Begin y End, pues Repeat y Until, marcan el inicio y el final
del cuerpo del ciclo.

No es necesario colocar el punto y coma antes del Until.

Ejemplo 3.15 Implementar el algoritmo anterior.

Program SumaRepeat;
{$APPTYPE CONSOLE}
Var
suma,i: integer;
Begin
suma:=0;
i:=0;
Repeat
i:=i+1;
suma:=suma+sqr(i);
Until (i=100);
Write(’El valor de la suma es ’,suma);
Readln
End.

La estructura While y la estructura Repeat, se conocen como Iterativas. Se usan cuan-


do no se conoce con anticipación el número de veces que se ejecutará la acción.

La diferencia entre ambas es que la condición se sitúa al principio (Mientras) o al final


(Repetir) de la secuencia de instrucciones. Entonces, en el primero, el bucle continúa mien-
tras la condición es verdadera (la cual se comprueba antes de ejecutar la acción) y en el
segundo, el bucle continúa hasta que la condición se hace verdadera (la condición se com-
prueba después de ejecutar la acción, es decir, se ejecutará al menos una vez).

La estructura Desde/Para suele utilizarse cuando se conoce con anterioridad el número


de veces que se ejecutará la acción y se le conoce como Estructura Repetitiva en lugar de
iterativa, para diferenciarla de las dos anteriores.

33
E. Kenny Venegas P.

3.4. Ejercicios propuestos


1. Haga un programa que dado x ∈ R evalúe la función
 √
 |x|/ 1 − x, x < −1
f (x) = cos(x) ln(1 + x2 ), −1 ≤ x ≤ 5
tan(x3 − x2 ), x>5

2. Elabore un programa que pida el ingreso de x ∈ R y determine si x ∈ dom(f ), donde


q p
f (x) = sen(1 + x2 ) − 125 − x3 .

3. Elabore un programa que pida el ingreso de n números positivos y muestre su media


aritmética, geométrica y armónica.

4. Realice un programa que pida el ingreso de la parte real e imaginaria de un número


complejo z = a + bi y muestre la parte real e imaginaria de z n , donde n es ingresado
por el usuario.

5. Haga un programa que halle y muestre todos los números de la forma aabb, donde
a y b son dı́gitos distintos, tal que aabb sea un cuadrado perfecto.

34
Capı́tulo 4

Cadenas. Entrada y salida de


información

4.1. Cadenas y caracteres (String y Char)


CARACTERES:

Una variable del tipo Char , almacena un caracter que puede ser leı́do por el teclado.
Observación:
Es distinto poner ’2’ que 2, pues ’2’ representa una variable del tipo char o string,
mientras 2 es una variable del tipo integer o real.
Existe una biyección entre el conjunto de caracteres y el conjunto {1, 2, . . . , 255}, a tal
biyección se le conoce como código ASCII.

Por ejemplo: @ = ALT + 64 (sólo en Windows).

Note que: <caracter asociado>=CHR (<número entero entre 1 y 255>)

<código ASCII asociado, variable de tipo entero>= (<Variable de tipo caracter>)

CADENAS Una cadena es una arreglo de caracteres.

Si A es una cadena : A = ’H’ ’O’ ’L’ ’A’


Por ejemplo:
VAR A:= string
A:= ’ HOLA’

Program Cadena;
{$APPTYPE CONSOLE}

35
E. Kenny Venegas P.

Var A : string
Begin
Write ( ’ Ingresa tu nombre ’ );
Read ( A );
Write (’ HOLA ’ );
Write ( A );
Write (’ ¿ Como estas ? ’);
Readln
End.

4.1.1. Longitud de una cadena


Se usará la función LENGTH para conocer la cantidad de caracteres de una cadena.

<longitud de la cadena>=LENGTH(<Variable de tipo String>);

Por ejemplo, dentro de un programa tendremos:


Cad := ’algoritmo’; // Cad es una variable del tipo String
Lon := LENGTH (Cad); // Lon es una variable del tipo Integer

En este ejemplo, el valor de de “Lon” es 9.

4.1.2. Concatenación de cadenas


Para concanetar (unir) dos cadenas , se usa el operador ’+’.

(<Cadena concanetada>) =<cadena 1> + <cadena 2>

Por ejemplo, si A, B y C son variables del tipo String:


A:= ’Hola’; B:= ’Como estas’ C:= A + B + ’ ?’; // Entonces el valor de C será:
’HolaComo estas?’ A:= ’ABC ’ B:= ’XYZ’ C:= A + B C:= ’ABC XYZ’ // Ahora el valor
de C será: ’ABC XYZ’

4.2. Conversión de tipos


Lo que hemos estado trabajando hasta el momento es la entrada y salida de infor-
mación del modo consola. Para visualizar la información en ventanas debemos utilizar
una conversión de nuestras variables al tipo cadena (string) y además usar los comandos
inputbox y showmessage.

4.2.1. Conversión de cadena a número


En adelante trabajaremos con mayor frecuencia con variables del tipo string, es por
ello que en algunos casos convertiremos variables del tipo integer o real a variables del tipo

36
4.2. Conversión de tipos

string y viceversa.

Para convertir una cadena a entero: StrToInt


Para convertir una cadena a reales: StrToFloat
Para convertir un entero a cadena: IntToStr
Para convertir un real a cadena: FloatToStr

Ejemplo 4.1 Program Prueba;


{$APPTYPE CONSOLE}
Uses SysUtils;
Var cad : string;
Num : integer;
Begin
Write ( ’Ingrese un entero’ );
Read ( cad );
Num := StrToInt ( cad );
Write ( ’Ud. Ha ingresado :’ + IntToStr( Num ) );
Readln
End.

4.2.2. Inputbox y Showmessage


Para utilizar los comandos Inputbox y Showmessage necesitamos incluir las librerias
SysUtils y Dialogs (o en todo caso Qdialogs).
Con el comando Inputbox leeremos las cadena “cad” de la siguiente forma:

cad:=Inputbox(<cad1>,<cad2>,<cad3>);

donde “cad1” es una cadena que se visualizará como tı́tulo de la ventana, “cad2” es una
cadena que solicita el ingreso del dato y “cad3” es una cadena que se muestra como valor
tentativo a ingresar.
El comando Showmessage sirve para mostrar una el valor de una cadena en una ventana.

Veamos algunos ejemplos en los siguientes ejercicios resueltos:

4.2.3. Ejercicios Resueltos


1. Haga un programa que pida el ingreso de 3 números enteros y calcule su promedio.

Program promedio;
Uses
SysUtils, Dialogs;
Var
n,m,p: integer;

37
E. Kenny Venegas P.

prom: real;
Begin
n:=StrToInt(InputBox(’Lectura de números’,
’Ingrese el primer número:’,’’));
m:=StrToInt(InputBox(’Lectura de números’,
’Ingrese el segundo número:’,’’));
p:=StrToInt(InputBox(’Lectura de números’,
’Ingrese el tercer número:’,’’));
prom:=(n+m+p)/3;
ShowMessage(’El promedio de los números ingresados es
’+FloatToStr(prom));
{ ShowMessage(’El promedio de ’+IntToStr(n)+’, ’+IntToStr(m)+’ y
’+IntToStr(p)+’ es ’+FloatToStr(prom)); }
End.

2. Elabore un programa que calcule el factorial de un número ingresado por teclado.

Program factorial;
Uses
SysUtils,dialogs;
Var
i,n,f:integer;
Begin
repeat
n:=strtoint(inputbox(’’,’Ingrese un número natural
menor que 20’,’’));
until (n>=0);
f:=1;
for i:=2 to n do
f:=f*i;
showmessage(’El factorial de ’+inttostr(n)+’ es ’+inttostr(f));
End.

3. Haga un programa que verifique si un número ingresado es primo o no.

Program primo;
Uses SysUtils,Dialogs;
Var n,i,k:integer; r:real;
Begin
n:=StrToInt(InputBox(’’,’Ingrese un número’,’’));
r:=sqrt(n); i:=1; k:=0;
while (i<=r) and (k=0) do
begin
i:=i+1;

38
4.2. Conversión de tipos

if (n mod i = 0) then
k:=1;
end;
if (k=0) then
ShowMessage(IntToStr(n)+’ si es un número primo’)
else
ShowMessage(IntToStr(n)+’ no es un número primo’)
End.

4. Elabore un programa que pida el ingreso de un número en base 2 y lo convierta a


base 10.

Program change_of_base;
Uses
SysUtils,Dialogs;
Var
n,m,p:integer;
cad:string;
Begin
cad:=InputBox(’Lectura del número’,’Ingrese el número
en base 2:’,’’);
n:=StrToInt(cad);
m:=n mod 10;
p:=2;
while (n>0) do
begin
n:=n div 10;
m:=m+(n mod 10)*p;
p:=p*2;
end;
ShowMessage(cad+’ convertido a base 10 es ’+IntToStr(m));
End.

5. Haga el programa anterior verificando si el número está ingresado en base 2 y uti-


lizando variables del tipo string.

Program change_of_base;
Uses
SysUtils,Dialogs;
Var
i,n:integer; m:real;
cad:string;
Begin
cad:=InputBox(’Lectura del número’,’Ingrese el número

39
E. Kenny Venegas P.

en base 2:’,’’);
n:=length(cad);
i:=1;
while (i<=n) and (StrToInt(cad[i])<=1) do
i:=i+1;
if (i=n+1) then
begin
m:=0;
for i:=n downto 1 do
m:=m+StrToInt(cad[i])*exp(ln(2)*(n-i));
ShowMessage(cad+’ convertido a base 10 es ’+FloatToStr(m));
end
else showmessage(’El número ingresado no está en base 2’);
End.

6. Elabore un programa que pida un número real x y un número natural n y calcule la


suma.

Program suma_exp;
Uses SysUtils,Dialogs;
Var
i,k,n:integer; x,fx,sum:real;
Begin
x:=StrToFloat(InputBox(’’,’Ingrese un numero real:’,’’));
n:=StrToInt(InputBox(’’,’Ingrese un numero natural:’,’’));
Sum:=0; k:=1; fx:=1;
for i:=1 to n do
begin
k:=k*i;
fx:=fx*x;
sum:=sum+fx/k;
end;
ShowMessage(’La suma es ’+FloatToStr(sum))
End.

7. Haga un programa que calcule los divisores propios de un número ingresado por el
usuario.

Program div_propios;
Uses
SysUtils,Dialogs;
Var
i,n:integer;
cad:string;

40
4.2. Conversión de tipos

Begin
n:=StrToInt(InputBox(’’,’Ingrese un numero natural:’,’’));
for i:=1 to (n div 2) do
If (n mod i = 0) then
cad:=cad+IntToStr(i)+#9;
ShowMessage(’Los divisores propios de ’+IntToStr(n)+
’ son:’+#13+cad);
End.

8. Elabore un programa que muestre los n primeros números términos de la sucesión


de Fibonacci, donde n es ingresado por el usuario.

Program Fibonnacci;
Uses SysUtils,dialogs;
Var i,a,b,temp,n:integer; S:string;
Begin
n:=strtoint(inputbox(’Sucesión de Fibonacci’,
’Ingrese el número de términos’,’’));
S:=’1’; a:=1;
if n>1 then
begin
S:=S+#9+’1’; b:=1;
for i:=3 to n do
begin
temp:=b;
b:=a+b;
a:=temp;
S:=S+#9+inttostr(b);
end;
end;
showmessage(’La sucesión de Fibonacci es’+#13+S);
End.

9. Diseñar un programa tal que dados como datos una variable de tipo entero y una
del tipo real, obtenga el resultado de la siguiente función:

Program ValCase;
Uses SysUtils,Dialogs;
Var
num: integer;
v,val: real;
Begin
num:=StrToInt(InputBox(’’,’Ingrese un número entero:’,’’));
v:=StrToFloat(InputBox(’’,’Ingrese un número real positivo:’,’’));

41
E. Kenny Venegas P.

Case num of
1: val:= 100*v;
2: val:= exp(ln(100)*v);
3: val:= 100/v
Else
val:= 0;
End;
ShowMessage(’El valor de la función será’+#13+FloatToStr(val))
End.

4.3. Ejercicios propuestos


1. Se dice que a es pariente de b si la suma de los dı́gitos de a2 es igual a b y la suma
de los dı́gitos de b2 es a. Ejemplo: 13 y 16. Realice un programa que determine si
dos números a y b son parientes.

2. Elabore un programa que halle un número primo de forma abc tal que a < b < c.
En caso no exista tal número el programa debe devolver 0 como salida.

3. Haga un programa que indique si dos números N y M están formados por los mismos
dı́gitos. Ejemplos: 321 y 213, 45 y 554.

4. Realice un programa que dado N devuelva un número M formado por los dı́gitos de
N ordenados de menor a mayor. Ejemplo: si N = 7142 entonces M = 1247.

5. Realice un programa que devuelva la suma de todos los números primos entre dos
números N y M dados.

6. (Tercer Teorema de Fermat). El matemático francés Pierre Fermat enunció en una


proposición que no existen números enteros x, y, z y n > 2 tales que xn + y n = z n .
Elabore un programa que busque un contraejemplo de esta afirmación para números
entre 1 y 20 con n = 3 y n = 4.

42
Capı́tulo 5

Vectores y Matrices

Para hacer uso de vectores o matrices, Delphi ha definido “array”, que en castellano
significa arreglo. Un array es un tipo de variable definida por el usuario, similar a una
cadena, con la diferencia de que en vez de caracteres sus elementos pueden ser cualquier
tipo de variable.

5.1. Arreglos Estáticos


5.1.1. Vectores
Para definir un vector (arreglo unidimensional) lo declararemos en la cabecera de la
siguiente manera:

Type nombre vector=array[n..m] of tipo variable;

donde n y m son números enteros y la longitud del arreglo serı́a n−m+1, “nombre vector”
es el nombre del arreglo vectorial y “tipo variable” puede ser integer, real, char, etc.

Veamos algunos ejemplos:

Ejemplo 5.1 Program ejemplo;


Uses sysutils,dialogs;
Type vector=array[1..4] of integer;
Var A:vector;
Begin
A[1]:=2; A[2]:=3; A[3]:=5; A[4]:=7;
End.

Ejemplo 5.2 Program arreglo;


Uses SysUtils, Dialogs;
const max=20;

43
E. Kenny Venegas P.

type vector=array[1..max] of integer;


Var i,n:integer; A:vector; S:string;
Begin
n:=strtoint(inputbox(’’,’Ingrese la dimensión del vector’,’’));
for i:=1 to n do
begin
// Definiendo el vector A:
A[i]:=strtoint(inputbox(’A[’+inttostr(i)+’]’,’Ingrese valor’,’’));
S:=S+inttostr(A[i])+#9; // Conversión de A a la cadena S
end;
showmessage(’El vector A es’+#13+S)
End.

Ejemplo 5.3 Program norma;


Uses SysUtils, Dialogs;
const max=20;
type vector=array[1..max] of integer;
Var i,n:integer; norm:real;
A:vector; S:string;
Begin
n:=strtoint(inputbox(’’,’Ingrese la dimensión del vector’,’’));
norm:=0;
for i:=1 to n do
begin
A[i]:=strtoint(inputbox(’A[’+inttostr(i)+’]’,’Ingrese valor’,’’));
S:=S+inttostr(A[i])+#9; // Conversión de A a la cadena S
norm:=norm+sqr(A[i]);
end;
norm:=sqrt(norm);
showmessage(’El vector A es’+#13+S)
End.

Ejemplo 5.4 Program Fibonnacci;


Uses SysUtils, Dialogs;
const max=20;
type vector=array[1..max] of integer;
Var i,n:integer; A:vector; S:string;
Begin
n:=strtoint(inputbox(’Sucesión de Fibonacci’,
’Ingrese el número de términos’,’’));
A[1]:=1; S:=’1’;
if n>1 then
begin
A[2]:=1; S:=S+#9+’1’;

44
5.1. Arreglos Estáticos

for i:=3 to n do
begin
A[i]:=A[i-1]+A[i-2];
S:=S+#9+inttostr(A[i]);
end;
end;
showmessage(’La sucesión de Fibonacci es’+#13+S);
End.

Ejemplo 5.5 Program suma_vectores;


Uses SysUtils, Dialogs;
const max=20;
type vector=array[1..max] of real;
Var i,n:integer; A,B:vector; S,S1,S2:string;
Begin
n:=strtoint(inputbox(’’,’Ingrese la dimensión del vector’,’’));
S1:=’El vector A es’+#13;
S2:=’El vector B es’+#13;
for i:=1 to n do
begin
// Definiendo los vectores A y B
A[i]:=strtofloat(inputbox(’Lectura del vector A’,
’Ingrese A[’+inttostr(i)+’]’,’’));
B[i]:=strtofloat(inputbox(’Lectura del vector B’,
’Ingrese B[’+inttostr(i)+’]’,’’));
S1:=S1+floattostr(A[i])+#9;
S2:=S2+floattostr(B[i])+#9;
S:=S+floattostr(A[i]+B[i])+#9;
end;
showmessage(S1+#13+#13+S2+#13+#13+’El vector A+B es’+#13+S)
End.

5.1.2. Matrices
Para definir una matriz (arreglo bidimensional) lo declararemos en la cabecera de la
siguiente manera:

Type nombre matriz=array[1..n, 1..m] of tipo variable;

donde “nombre matriz” es el nombre del arreglo bidimensional, “tipo variable” puede ser
integer, real, char, etc. y n es el número máximo de filas del arreglo y m el número máximo
de columnas.

Veamos algunos ejemplos:

45
E. Kenny Venegas P.

Ejemplo 5.6 Program ejemplo;


Uses sysutils,dialogs;
Type matriz=array[1..6,1..8] of integer;
Var A: matriz;
Begin
A[1,1]:=2; A[1,2]:=3; A[2,1]:=5; A[2,2]:=7;
End.

Ejemplo 5.7 Programa que pide el ingreso de cada elemento de una matriz cuadrada:

Program matricial;
Uses SysUtils,dialogs;
const max=20;
type matriz=array[1..max,1..max] of integer;
var i,j,n:integer; A:matriz; S:string;
Begin
n:=strtoint(inputbox(’’,’Ingrese el orden de la matriz’,’’));
// Lectura de los elementos de la matriz:
for i:=1 to n do
begin
for j:=1 to n do
begin
A[i,j]:=strtoint(inputbox(’A[’+inttostr(i)+’,
’+inttostr(j)+’]’,’Ingrese valor’,’’));
S:=S+inttostr(A[i,j])+#9;
end;
S:=S+#13;
end;
showmessage(’La matriz A es’+#13+S)
End.

Ejercicio: Modificar para una matriz no cuadrada, calcular la suma de los elementos.

Ejemplo 5.8 Elabore un programa que pida el ingreso de dos matrices cuadradas, muéstre-
las y calcule su suma.

Program suma_matrices;
Uses SysUtils,dialogs;
const max=20;
Type matriz=array[1..max,1..max] of integer;
var i,j,n:integer; A,B:matriz; S1,S2,S:string;
Begin
S1:=’La matriz A es’+#13;
S2:=’La matriz B es’+#13;
n:=strtoint(inputbox(’’,’Ingrese el orden de la matriz’,’’));

46
5.1. Arreglos Estáticos

for i:=1 to n do
begin
for j:=1 to n do
begin
A[i,j]:=strtoint(inputbox(’A[’+inttostr(i)+’,
’+inttostr(j)+’]’,’Ingrese valor’,’’));
B[i,j]:=strtoint(inputbox(’B[’+inttostr(i)+’,
’+inttostr(j)+’]’,’Ingrese valor’,’’));
S1:=S1+inttostr(A[i,j])+#9;
S2:=S2+inttostr(B[i,j])+#9;
S:=S+inttostr(A[i,j]+B[i,j])+#9;
end;
S1:=S1+#13; S2:=S2+#13; S:=S+#13;
end;
showmessage(S1+#13+#13+S2+#13+#13+’La matriz A+B es’+#13+S)
End.

Random es una función que devuelve un número real aleatorio entre 0 y 1. a + (b −


a)∗random devuelve un número real aleatorio entre a y b.

Random(n) es una función que devuelve un número entero entre 0 y n−1. Randomize
sirve para no obtener los mismos números aleatorios (cambia de raiz).

Trunc(x) es una función que devuelve la parte entera del número real x.

Ejemplo 5.9 Haga un programa que construya aleatoriamente dos arreglos unidimen-
sionales: A y B, tal que A contiene elementos reales del 0 al 10 con un solo decimal y B
elementos enteros del 1 al 10, además sume A y B.
Program aleatorio;
Uses SysUtils,dialogs;
const max=20;
Type vector=array[1..max] of real;
Var i,n:integer; A,B:vector; S,S1,S2:string;
Begin
n:=strtoint(inputbox(’’,’Ingrese la dimensión del vector’,’’));
S1:=’El vector A es’+#13;
S2:=’El vector B es’+#13;
randomize;
for i:=1 to n do
begin
A[i]:=trunc(100*random)/10; // También A[i]:=trunc(random(101))/10;
B[i]:=random(10)+1;
S1:=S1+floattostr(A[i])+#9;

47
E. Kenny Venegas P.

S2:=S2+floattostr(B[i])+#9;
S:=S+floattostr(A[i]+B[i])+#9;
end;
showmessage(S1+#13+#13+S2+#13+#13+’El vector A+B es’+#13+S)
End.

5.2. Arreglos Dinámicos


A diferencia de los arreglos estáticos, su tamaño se define en tiempo de ejecución, es
decir al compilar el programa, usando la función setlength. La ventaja de usar arreglos
dinámicos es el ahorro de memoria.

Sintaxis:

Type
Arreglo_dinamico = array of Tipo_dato;
Var
Identificador = Arreglo_dinámico;
Begin
...
setlength(Identificador,tama~no);
...
End.

Observación: El ı́ndice de los elementos de un arreglo dinámico empieza de cero.

Ejemplo 5.10 Program dinamico;


Uses SysUtils;
Type vector_d=array of integer;
Var A:vector_d;
Begin
setlength(A,4);
A[0]:=2; A[1]:=3; A[2]:=5; A[3]:=7;
End.

Ejemplo 5.11 Programa que genera aleatoriamente n números reales de -10 a 10:

Program aleatorio_din;
Uses SysUtils,dialogs;
Type vector_d=array of real;
Var i,n:integer; A:vector_d; cad:string;
Begin
n:=strtoint(inputbox(’’,’Ingrese un número natural’,’’));
cad:=’Los primeros números reales son:’+#13;
setlength(A,n); randomize;

48
5.2. Arreglos Dinámicos

for i:=0 to n-1 do


begin
A[i]:=(random(201)-100)/10; // -10+20*random;
cad:=cad+floattostr(A[i])+#9; // formatfloat(’0.00’,A[i])+#9;
end;
showmessage(cad)
End.

Ejemplo 5.12 Programa que genera aleatoriamente los n primeros números naturales.

Program aleatorio_n;
Uses SysUtils,dialogs;
Type vector_d=array of integer;
Var i,n:integer; A:vector_d; cad:string;
Begin
n:=strtoint(inputbox(’’,’Ingrese un número natural’,’’));
cad:=’Los primeros ’+inttostr(n)+’ números naturales son:’+#13;
setlength(A,n); randomize;
for i:=0 to n-1 do
begin
repeat
A[i]:=random(n)+1;
until A[i]=i+1;
cad:=cad+inttostr(A[i])+#9;
end;
showmessage(cad)
End.

Ejemplo 5.13 Programa que genera aleatoriamente dos matrices y las suma.

Program sum_matriz_din;
Uses SysUtils,dialogs;
Type matriz=array of integer;
Var i,j,n,m:integer; A,B:matriz; S1,S2,S:string;
Begin
S1:=’La matriz A es’+#13;
S2:=’La matriz B es’+#13;
m:=strtoint(inputbox(’’,’Ingrese el número de
filas de las matrices’,’’));
n:=strtoint(inputbox(’’,’Ingrese el número de
columnas de las matrices’,’’));
setlength(A,m*n); setlength(B,m*n);
randomize;
for i:=0 to m-1 do
begin

49
E. Kenny Venegas P.

for j:=0 to n-1 do


begin
A[n*i+j]:=random(m+n);
B[n*i+j]:=random(m+n);
S1:=S1+inttostr(A[n*i+j])+#9;
S2:=S2+inttostr(B[n*i+j])+#9;
S:=S+inttostr(A[n*i+j]+B[n*i+j])+#9;
end;
S1:=S1+#13; S2:=S2+#13; S:=S+#13;
end;
showmessage(S1+#13+S2+#13+’La matriz A+B es’+#13+S)
End.

Ejemplo 5.14 Programa que genera una matriz aleatoriamente definiendo un arreglo
dinámico cuyos elementos son vectores.

Program matriz_d_random;
Uses
SysUtils,Dialogs;
Type
vector = array of real;
matriz = array of vector;
Var
A:matriz; i,j,n,m:integer; S:string;
Begin
n:=strtoint(inputbox(’’,’Ingrese el número de filas’,’’));
m:=strtoint(inputbox(’’,’Ingrese el número de columnas’,’’));
setlength(A,n); // Genera las "n" filas de A
Randomize;
for i:=0 to n-1 do
begin
setlength(A[i],m); // Genera los "m" elementos de la fila "i"
for j:=0 to m-1 do
begin
A[i,j]:=-10+20*random;
S:=S+formatfloat(’0.00’,A[i,j])+#9;
end;
S:=S+#13;
end;
Showmessage(S);
End.

50
5.3. Ejercicios propuestos

5.3. Ejercicios propuestos


1. Haga un programa que pida el ingreso de números y lo almacene en un arreglo y diga
cúantas veces se ha repetido el ingreso de los elementos, por ejemplo si el arreglo A
contiene los elementos A=[1 2 3 1 2 1], entonces el programa deberá mostrar que 1
aparece tres veces, 2 aparece dos veces y 3 aparece una vez.
2. Un método sencillo para ordenar (digamos, ascendentemente) los elementos de un
arreglo A = A[1] A[2] . . . A[n] es el siguiente:
a) Iniciar i = 1.
b) Hallar el menor elemento de A[i] A[i + 1] . . . A[n].
c) Intercambiar el elemento hallado en el item (b) con el término A[i].
d) Aumentar i en 1.
e) Si i > n terminar el programa, en caso contrario regresar al paso (b).
Elabore un programa que implemente este método de ordenación. Por ejemplo, si el
arreglo es [0.3 1 -2 2.5 1.7] el programa deberá devolver -2 0.3 1 1.7 2.5
3. Modifique el ejercicio anterior para que no se visualizen los elementos más de una
vez. Por ejemplo, si el arreglo es [1 -1 2 1 3 -1 2 3 2 1] el programa deberá devolver
-1 1 2 3.
4. La moda de un conjunto de números es aquel número que tiene la mayor frecuencia
entre todos, es decir, el que se repite más. Elabore un programa que, dado un conjunto
de n números (con n dado por el usuario) ingresados de forma ascendente, halle la
moda de ellos. (Obs. En caso haya dos números candidatos a ser la moda, mostrar
el mayor de ellos.)
5. Dada una matriz A ∈ Rn×n , calcule la matriz escalonada reducida de A.
6. Genere aleatoriamente los elementos de una matriz y calcule:
a) La transpuesta
b) El mayor de sus elementos
c) El determinante
7. Dada una matriz A ∈ Rn×n , calcule su matriz adjunta y su inversa (si existe).
8. Resuelva el sistema de ecuaciones Ax = b, donde b es un arreglo unidimensional con
n elementos y A es un arreglo bidimensional n×n (ambos generados aleatoriamente).
9. Diseñe un programa que construya una base ortonormal {u1 , u2 , . . . , un } de Rn a
partir de v1 , v2 , . . . , vn vectores L.I. de Rn ingresados por el usuario.
Sugerencia: Proceso de Gram Schmidt. Primero ortogonalize haciendo
i
X hvj , ui i
u1 = v1 , ui+1 = vi+1 − uj , i = 1, . . . , n − 1
huj , uj i
j=1

51
E. Kenny Venegas P.

10. Elabore un programa que pida el ingreso de n pares ordenados (xi , yi ), i = 1, . . . , n


y halle la ecuación de la recta que minimice la suma de las distancias al cuadrado
de los puntos (xi , yi ) a dicha recta.

52
Capı́tulo 6

Procedimientos y Funciones

Un procedimiento es un subprograma que puede interactuar con los datos y simplifica


los programas extensos. Su sintaxis es:

Procedure nombre procedimiento(variables de entrada);

Una función es un procedimiento que puede devolver un valor (sólo una variable). Su sin-
taxis es:

Function nombre funcion(variables de entrada): variable salida;

Las variables que se definen dentro de un procedimiento o función son llamadas va-
riables locales, mientras que las variables definidas en el programa principal son llamadas
variables globales.

Ejemplo 6.1 Programa que calcula el factorial de un número ingresado por el usuario:

Program factorial;
Uses SysUtils,Dialogs;
Var n:integer;

Function fact(var n:integer): integer;


var i,f:integer;
begin
f:=1;
for i:=2 to n do
f:=f*i;
fact:=f;
end;

Begin // Inicio del programa principal

53
E. Kenny Venegas P.

n:=strtoint(inputbox(’’,’Ingrese un número natural


menor que 20’,’’));
showmessage(’El factorial de ’+inttostr(n)+’ es ’
+inttostr(fact(n)));
End.

Ejemplo 6.2 Programa que lee los elementos de un arreglo y luego los muestra:

Program leer_imprimir;
Uses SysUtils, Dialogs;
Type vector = array of real;
Var A:vector; n:integer;

Procedure leer(var A:vector; var n:integer);


var i:integer;
begin
n:=strtoint(inputbox(’’,’Ingrese la dimensión del vector A:’,’’));
Setlength(A,n);
for i:=1 to n do
A[i]:=strtofloat(inputbox(’A[’+inttostr(i)+’]’,’Ingrese’,’’));
end;

Procedure imprimir(var A:vector; var n:integer);


var s:string; i:integer;
begin
s:=’El vector ingresado es’+#13;
for i:=1 to n do
s:=s+floattostr(A[i])+#9;
showmessage(s);
end;

Begin // Inicio del programa principal


leer(A,n); imprimir(A,n);
End.

Ejemplo 6.3 Programa que evalúa un polinomio cuyos coeficientes están en una arreglo:

Program val_polinomio;
Uses SysUtils,Dialogs;
Type polinomio = array of real;
Var i,n:integer; x:real;
P:polinomio; S:string;

Function val(var P:polinomio; var x:real): real;


Var i:integer; v,fx:real;

54
6.1. Parámetros por valor y referencia

begin
v:=P[0]; fx:=x;
for i:=1 to high(P) do
begin
v:=v+P[i]*fx;
fx:=fx*x;
end;
val:=v;
end;

Begin // Inicio del programa principal


n:=strtoint(inputbox(’’,’Ingrese el grado del polinomio’,’’));
Setlength(P,n+1);
P[0]:=strtofloat(inputbox(’’,’Ingrese el término independiente’,’’));
S:=’El polinomio P es:’+#13+floattostr(P[0]);
for i:=1 to n do
begin
P[i]:=strtofloat(inputbox(’’,’Ingrese el término de orden ’
+inttostr(i),’’));
S:=S+’+’+floattostr(P[i])+’x^’+inttostr(i);
end;
x:=strtofloat(inputbox(’’,’Ingrese el número real a evaluar’,’’));
Showmessage(S+#13+#13+’P(’+floattostr(x)+’) = ’+floattostr(val(P,x)));
End.

6.1. Parámetros por valor y referencia


Un parámetro de entrada es el valor de una variable de entrada de un procedimiento
o función y se pueden dividir en:

Parámetros de entrada por valor, si solo adquiere el valor del parámetro ingresado
en el programa principal.

Parámetros de entrada por referencia, si es permitida la modificación del parámetro


ingresado en el programa principal.

Cuando los parámetros de entrada son por valor no es necesario colocar “var” antes de las
variables de entrada, mientras que si son parámetros de referencia debemos incluir “var”
antes de las variables de entrada.

Ejemplo 6.4 Programa que calcula el factorial de un número usando una función recur-
siva:

55
E. Kenny Venegas P.

Program factorial_recursivo;
Uses SysUtils,Dialogs;
Var n:integer;

Function fact(n:integer): integer;


// colocar y quitar "var" (ver cambios)
Var f:integer;
begin
f:=n;
if (n>1) then
begin
n:=n-1;
f:=f*fact(n);
end;
fact:=f; // fact:=n;
end;

Begin // Inicio del programa principal


n:=strtoint(inputbox(’’,’Ingrese un número natural
menor que 20’,’’));
showmessage(’El factorial de ’ + inttostr(n) +
’ es ’+inttostr(fact(n)));
End.

Ejemplo 6.5 Programa que dice si un número es primo o no (mencionando quien lo


divide).

Program primos;
Uses SysUtils,Dialogs;
Type v2=array[1..2] of integer;
var n:integer; p:v2;

Function primo(n:integer):v2; // parámetro de entrada por valor


var i,k:integer; r:real;
begin
r:=sqrt(n);
i:=1; k:=0;
while (i<r) and (k=0) do
begin
i:=i+1;
if (n mod i = 0) then
k:=1;
end;
primo[1]:=k; primo[2]:=i;

56
6.2. Ejercicios propuestos

end;

Begin // Inicio del programa principal


n:=strtoint(inputbox(’’,’Ingrese un número natural’,’’));
p:=primo(n);
if p[1]=0 then
showmessage(inttostr(n)+’ si es primo’)
else
showmessage(inttostr(n)+’ no es primo, pues
’+inttostr(p[2])+’ lo divide’)
End.

6.2. Ejercicios propuestos


1. Elabore un programa que calcule el máximo común divisor de n números ingresados
por el usuario. Sugerencia: Haga un subprograma que halle el MCD de dos números
utilizando el algoritmo de Euclides.
2. Elabore un programa que calcule el mı́nimo común múltiplo de n números ingresados
por el usuario. Sugerencia: Haga un subprograma que halle el MCM de dos números
utilizando M CM (a, b) · M CD(a, b) = a · b.
n
3. En 1640 Fermat afirmó que F (n) = 22 + 1 es primo ∀ n ≥ 0 (estos números son
conocidos como los números de Fermat). Haga un programa que calcule el menor
número de Fermat que no es primo.
4. Haga un programa que calcule el menor número de Mersenne (los cuales son de la
forma M (n) = 2n − 1) que no es primo.
5. Haga un programa que calcule el menor número primo p tal que p# + 1 no sea primo,
donde p# es el producto de todos los primos menores o iguales a p. Ejemplos: 2# = 2
y 5# = 2 · 3 · 5 = 30.
6. Un entero impar n es un número de Carmichael si, y sólo si, cada factor primo p de
n satisface las dos condiciones siguientes:
p2 no divide a n.
p − 1 divide a n − 1.
Elabore un programa que diga si un número ingresado por el usuario es o no un
número de Carmichael.

6.3. Técnicas de ordenación


Definamos el problema de ordenación:

57
E. Kenny Venegas P.

Dados n números reales: x1 , x2 , x3 , . . . , xn colocarlos en orden creciente.

Veremos algunas técnicas de ordenación como los métodos de selección, inserción y bur-
buja.

6.3.1. Selección
Algoritmo Ordenación por selección
Variables
i,j,n,m : enteros
x : arreglo de reales
Inicio
Leer x
n = tama~
no de x
Desde i = 1 hasta i = n-1 hacer
m = i
Desde j = i+1 hasta j = n hacer
Si x[j] < x[m] entonces m = j
Fin_desde
Intercambiar x[i] por x[m]
Fin_desde
Mostrar x
Fin

Implementación del método de ordenación por selección:

Program ordenacion_seleccion;

Uses SysUtils,Dialogs;
Type vector=array[1..20] of real;
var A:vector; n:integer; cad:string;

Procedure leer(var A:vector; var n:integer);


var i:integer;
begin
n:=strtoint(inputbox(’’,’Ingrese la dimensión del vector A:’,’’));
for i:=1 to n do
A[i]:=strtofloat(inputbox(’A[’+inttostr(i)+’]’,’Ingrese’,’’));
end;

Procedure intercambiar(var a,b:real);


var temp:real;
begin
temp:=a;

58
6.3. Técnicas de ordenación

a:=b;
b:=temp;
end;
Function s(A:vector; n:integer):string;
var cad:string; i:integer;
begin
for i:=1 to n do
cad:=cad+floattostr(A[i])+#9;
s:=cad+#13;
end;

Function selec(A:vector; n:integer):vector;


var i,j,m:integer;
begin
for i:=1 to n-1 do
begin
m:=i;
for j:=i+1 to n do
if (A[j]<A[m]) then
m:=j;
intercambiar(A[i],A[m]);
end;
selec:=A;
end;

Begin // Inicio del programa principal


leer(A,n);
cad:=’El vector ingresado es’+#13+s(A,n)+#13;
showmessage(cad+’Ordenado por el método de selección es’
+#13+s(selec(A,n),n));
End.

6.3.2. Inserción
Este algoritmo encuentra la posición correcta para xi en el segmento x1 , x2 , . . . , xi−1 y
lo coloca allı́, es decir, lo inserta.

Algoritmo Ordenación por Inserción


Variables
i,j,n : enteros v : real
x : arreglo de reales
Inicio
Desde i = 2 hasta i = n hacer
v = x[i]

59
E. Kenny Venegas P.

j = 1
mientras x[j-1] > v hacer
x[j] = x[j-1]
x[j] = v
fin_mientras
fin_desde
Mostrar x
Fin

Veamos la implementación del método de inserción (con “inser” como un procedimiento


o función).

Program ordenacion_insercion;

Uses SysUtils,Dialogs;
Type vector=array[1..20] of real;
var A,B:vector; n:integer; cad:string;

Procedure leer(var A:vector; n:integer);


var i:integer;
begin
for i:=1 to n do
A[i]:=strtofloat(inputbox(’A[’+inttostr(i)+’]’,’Ingrese’,’’));
end;

Function s(A:vector; n:integer):string;


var cad:string; i:integer;
begin
for i:=1 to n do
cad:=cad+floattostr(A[i])+#9;
s:=cad+#13;
end;

Procedure inser(var A:vector; n:integer);


// Function inser(A:vector; n:integer):vector;
var i,j:integer; v:real;
begin
for i:=2 to n do
begin
v:=A[i]; j:=i;
while (j>1) and (A[j-1]>v) do
begin
A[j]:=A[j-1];
j:=j-1;

60
6.4. Ejercicios propuestos

end;
A[j]:=v;
end;
// incluir "inser:=A;" en el caso de utilizar "inser" como una función
end;

Begin // Inicio del programa principal


n:=strtoint(inputbox(’’,’Ingrese la dimensión del vector A:’,’’));
leer(A,n);
cad:=’El vector ingresado es’+#13+s(A,n)+#13;
inser(A,n);
showmessage(cad+’El vector ordenado por el método de inserción es’
+#13+s(A,n));
// Incluir lo siguiente si se utiliza "inser" como función:
{showmessage(cad + ’El vector ordenado por el método de inserción es’
+ #13 + s(inser(A,n),n));}
End.

6.3.3. Burbuja
Algoritmo Ordenación burbuja
Variables
i,j,n,m : enteros
x : arreglo de reales
Inicio
Leer x
n = tama~no de x
Desde i = n hasta i = 2 hacer
Desde j = 1 hasta j = i-1 hacer
Si x[j] > x[i+1]
intercambiar x[j] por x[j+1]
Fin_si
Fin_desde
Fin_desde
Mostrar x
Fin

Ejercicio: Implementar el algoritmo anterior.

6.4. Ejercicios propuestos


1. Modifique los algoritmos de selección, inserción y burbuja para que ordenen al-
fabéticamente un arreglo de cadenas. (Obs. En Delphi es permitida la comparación
de cadenas.)

61
E. Kenny Venegas P.

2. Elabore un programa que cuente el número de intercambios realizados al ordenar un


arreglo haciendo uso de

a) Método de Selección.
b) Método de Inserción.
c) Método de la Burbuja.

3. Modifique los algoritmos de selección, inserción y burbuja para que muestren como
se va ordenando el arreglo original paso por paso.

4. Implemente el siguiente algoritmo, el cual es el método de ordenación mergesort(x, n):


Si n < 2 retornar
m = n div 2
l = x[1..m]
r = x[m + 1..n]
mergesort(l, m)
mergesort(r, n − m)
i=1
j=1
para k = 1, . . . , n
si li < rj entonces
xk = li ; i = i + 1
sino
xk = rj ; j = j + 1

5. Implemente el siguiente algoritmo, el cual es el método de ordenación quicksort(r, s)


Si s < r retornar
v = xr
i=r
j =s+1
repetir
repetir i = i + 1 hasta que xi ≥ v
repetir j = j + 1 hasta que xi < v
cambiar xi con xj
hasta j < i
cambiar xi con xj
cambiar xi con xs
quicksort(r, i − 1)
quicksort(i + 1, s)

62
Capı́tulo 7

Registros

Los registros son la generalización de los arreglos, ası́ como los arrays son las generali-
zaciones de las cadenas. Un registro es un arreglo unidimensional, en donde cada elemento
de ese arreglo puede ser cualquier tipo de variable, inclusive un arreglo. Cada elemento de
un arreglo se denominará “campo”.

7.1. Declaración de registros


Un registro se puede definir dentro de Type o como una variable (dentro de Var), con
la diferencia de que en Type se colocará “ = Record” y dentro de Var irá “ : Record”.

Veamos algunos ejemplos:


Ejemplo 7.1 A continuación definiremos el registro “Amigo” dentro como una variable
y con tres campos (Nombre, Edad y Telef ):
Program registro_amigo;
Uses SysUtils, Dialogs;
Var Amigo : Record
Nombre : String;
Edad : Byte;
Telef : Integer;
End;
Begin
Amigo.Nombre := ’Luis Salazar’;
Amigo.Edad := 20;
Amigo.Telef := 3456789;
Showmessage(amigo.nombre+’ tiene ’+inttostr(amigo.edad));
Showmessage(’y su número telefónico es ’+inttostr(amigo.telef));
End.
Ejemplo 7.2 El siguiente programa dirá si aprobó o desaprobó un alumno en el curso
indicado.

63
E. Kenny Venegas P.

Program registro_alumno;
Uses SysUtils, Dialogs;
Type
// Observe que aquı́ se define el registro "Alumno" dentro del Type.
Alumno = Record
Nombre : String;
Curso : String;
Nota : Byte;
End;
Var Alm:Alumno; cad:string;
Begin
Alm.Nombre := inputbox(’’,’Ingrese el nombre del alumno:’,’’);
Alm.Curso := inputbox(’’,’Ingrese el curso que lleva’,’’);
Alm.Nota := strtoint(inputbox(’’,’Ingrese el promedio:’,’’));
if (Alm.Nota < 10) then
cad := ’ desaprobará ’
else
cad := ’ aprobará ’;
showmessage(alm.nombre+cad+alm.curso+’ con ’+inttostr(alm.nota));
End.

Ejemplo 7.3 El siguiente programa muestra datos acerca de los Egresados de la Facultad
de Ciencias:

Program registros_egresados;
Uses SysUtils, dialogs;
Type Alumnos = Record
Nombre : String;
Especialidad : String; // N1,N2,N3 ó N5
Ponderado : Byte;
End;
Promocion = Array [1..100] of Alumnos;
vector = Array [1..100] of byte;
Var
promo: promocion; cad: string; op:char;
N1,N2,N3,N5:vector; i,j1,j2,j3,j5,n: integer;

Function print(var Alm:Alumnos):string;


begin
print := #13 + alm.nombre + #9 + alm.especialidad + #9
+ inttostr(alm.Ponderado);
end;

Begin

64
7.1. Declaración de registros

n:=strtoint(inputbox(’’,’Número de egresados de la Facultad


de Ciencias:’,’’));
j1:=0; j2:=0; j3:=0; j5:=0;
for i:=1 to n do
begin
promo[i].nombre := inputbox(’’,’Ingrese el nombre completo
del alumno:’,’’);
promo[i].especialidad := inputbox(’’,’Ingrese el código de
la especialidad:’,’’);
promo[i].ponderado := strtoint(inputbox(’’,’Ingrese el
promedio ponderado:’,’’));
cad:=promo[i].especialidad; op:=cad[2];
case op of
’1’: begin
j1:=j1+1; N1[j1]:=i;
end;
’2’: begin
j2:=j2+1; N2[j2]:=i;
end;
’3’: begin
j3:=j3+1; N3[j3]:=i;
end;
’5’: begin
j5:=j5+1; N5[j5]:=i;
end;
else showmessage(’Ingrese un código de especialidad
perteneciente a Ciencias’);
end;
end;
showmessage(’Hay ’+inttostr(j1)+’ egresados de la Especialidad
de Fı́sica.’+#13+ ’Hay ’+inttostr(j2)+’ egresados de
la Especialidad de Matemática.’+#13+ ’Hay ’+inttostr(j3)+
’ egresados de la Especialidad de Quı́mica.’+#13+
’Hay ’+inttostr(j5)+’ egresados de la Especialidad de
Ing. Fı́sica.’);
cad := ’Los alumnos egresados agrupados por especialidad son’
+ #13 + #13 + ’Apellidos y Nombres’ + #9 + ’Esp’ + #9 +
’Ponderado’ + #13;
for i:= 1 to j1 do
cad := cad + print(promo[N1[i]]);
for i:= 1 to j2 do
cad := cad + print(promo[N2[i]]);
for i:= 1 to j3 do
cad := cad + print(promo[N3[i]]);

65
E. Kenny Venegas P.

for i:= 1 to j5 do
cad := cad + print(promo[N5[i]]);
showmessage(cad)
End.

7.2. Ejercicios propuestos


1. Haga una listado de alumnos del curso de Computación y Algoritmos I (ingresados
por el usuario) que contenga los siguientes datos: Apellidos y nombres, Especialidad,
Código y Promedio final. Muestre esta lista por orden de mérito.

2. Elabore un programa que lea los siguientes datos acerca de una persona: nombre,
edad y sexo (indique sólo H o M) y determine:

a) Las personas de sexo masculino (H)


b) Las personas mayores de 18 años
c) Las personas de sexo femenino entre 18 y 23 años

3. Diseñe un programa que pida al comprador de un auto las siguientes caracterı́sticas:


Marca, Año y Color. Además debe mostrar el precio del vehı́culo a comprar, teniendo
en cuenta que sólo se venden las marcas Tayet, Sumari, Macros y Futura, de los años
2000 al 2008, y sus precios base respecto al año 2008 y en color blanco son: 12000,
15000, 18000 y 20000 dólares respectivamente. Si el comprador no quisiera un auto
del año entonces se hará un descuento de $250 por cada año que ha pasado. Si el
comprador quisiera el auto en color rojo o negro el precio se eleva en $100 y en otro
color se pagará $50 adicionales. El programa deberá decir si se encuentra a la venta
un auto con las caracterı́sticas ingresadas por el comprador.

66
Bibliografı́a

[1] CANTO, Marco. La Biblia del Delphi

[2] CHARTE, Francisco. Programación con Delphi, 1996.

[3] LLACUA PERA, Javier Ita. Programando con Objetos en Pascal.

[4] LUCCHESI, Cláudio et al. Aspectos Teóricos da Computação, 1979.

[5] MELCHOR ESPINOZA, Victor. Aprenda a Programar con Deplhi, 2004.

[6] PERRY, Greg. Aprendiendo Principios de Programación en 24 horas, 1999.

67