Algoritmos

UNIVERSIDAD NACIONAL DE INGENIERÍA
FACULTAD DE CIENCIAS
Escuela Profesional de Matemática
El Lenguaje de Programación Delphi

Apuntes de clase
Realizado por:
Edgard Kenny Venegas Palacios
Lima - Perú
2009
Índice general
1. Algoritmos y Programació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. Representación de un algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.1. Implementación y aná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 válidos . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2. Tipos de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.1. Tipos de datos numéricos . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3. Declaración de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.1. Asignació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 aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4.2. Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5. Funciones matemáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.6. Los operadores div y mod . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3. Estructuras de control 19
3.1. Estructuras selectivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.1.1. Sentencia IF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2. Estructuras selectivas de mú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
4. Cadenas. Entrada y salida de información 35

4.1. Cadenas y caracteres (String y Char) . . . . . . . . . . . . . . . . . . . . . . 35
4.1.1. Longitud de una cadena . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.1.2. Concatenación de cadenas . . . . . . . . . . . . . . . . . . . . . . . . 36
4.2. Conversión de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.2.1. Conversión de cadena a número . . . . . . . . . . . . . . . . . . . . . 36
4.2.2. Inputbox y Showmessage . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2.3. Ejercicios Resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5. Vectores y Matrices 43
5.1. Arreglos Estáticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.1.1. Vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.1.2. Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.2. Arreglos Dinámicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
6. Procedimientos y Funciones 53
6.1. Parámetros por valor y referencia . . . . . . . . . . . . . . . . . . . . . . . . 55
6.3. Técnicas de ordenación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6.3.1. Selección . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
6.3.2. Inserción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
6.3.3. Burbuja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
7. Registros 63
7.1. Declaración de registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Bibliografı́a 67
ii
Introducción
Delphi es uno de los lenguajes llamados de alto nivel, porque una sola de sus instruc-
ciones equivale a millares de código de máquina.
Delphi está 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
programación más difundida y utilizada.
El objetivo de de este manual es mostrar las caracterı́sticas y estructura de un algoritmo

para la solución de problemas concretos.
Además, hay que resaltar que un primer curso de programación estructurada permite
obtener los conocimientos necesarios para analizar problemas de manera creativa y de
plasmarlas a través de un programa codificado, como es en este caso el lenguajes visual
Delphi.
0
Capı́tulo 1
Algoritmos y Programación
Estructurada
En matemáticas, ciencias de la computación y disciplinas relacionadas, un algoritmo

es una lista bien definida, ordenada y finita de operaciones que permite hallar la solución
a un problema. Dado un estado inicial y una entrada, a través de pasos sucesivos y bien
definidos se llega a un estado final, obteniendo una solució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 cuestión o inclusive en las instruc-
ciones que recibe un trabajador por parte de su patrón. También existen ejemplos de ı́ndole
matemático, como el algoritmo de la división para calcular el cociente de dos números, el
algoritmo de Euclides para calcular el máximo común divisor de dos enteros positivos,
o el mé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 mecánicamente problemas matemá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 especificación de un
conjunto de pasos (operaciones, instrucciones, órdenes, etc.) orientados a la resolución de
un problema (método), el segundo es ese conjunto de operaciones especificadas en un de-
terminado lenguaje de programació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 programación, en un cir-
cuito eléctrico, en un aparato mecánico, usando papel y lápiz, o en algún otro modelo de
computación.
1
E. Kenny Venegas P.
1.1.1. Propiedades de los algoritmos

El cientı́fico de computación Donald Knuth ofreció una lista de cinco propiedades, que son
ampliamente aceptadas como requisitos para un algoritmo:
1. Carácter finito. Un algoritmo siempre debe terminar después de un número finito

de pasos.
2. Precisió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 más entradas: cantidades que le son dadas antes
de que el algoritmo comience, o dinámicamente mientras el algoritmo corre.
4. Salida. Un algoritmo tiene una o más salidas: cantidades que tienen una relació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
lápiz y papel.
1.1.2. Caracterı́sticas de los algoritmos

A continuación mencionamos las caracterı́sticas de los algoritmos:
Finitos: Debe acabar en algún momento.
Eficientes: Deben ocupar la mı́nima memoria y minimizar el tiempo de ejecución.
Legibles: El texto que lo describe debe ser claro, tal que permita entenderlo y leerlo
fácilmente.
Modificables: Estarán diseñados de modo que sus posteriores modificaciones sean

fáciles de realizar, incluso por programadores diferentes a sus propios autores.
Modulares: La filosofı́a utilizada para su diseño debe favorecer la división del pro-
blema en módulos pequeños.
1.2. Representación de un algoritmo

Un algoritmo puede representarse mediante un pseudocódigo o un diagrama de flu-
jo. El usar pseudocódigo y diagramas de flujo evita muchas ambigüedades del lenguaje
natural. Dichas expresiones son formas más estructuradas para representar algoritmos; no
obstante, se mantienen independientes de un lenguaje de programación especı́fico.
Los diagramas de flujo son descripciones gráficas de algoritmos; usan sı́mbolos conec-
tados con flechas para indicar la secuencia de instrucciones y están regidos por ISO.
2
1.2. Representación de un algoritmo
Los diagramas de flujo son usados para representar algoritmos pequeños, ya que abarcan
mucho espacio y su construcción es laboriosa. Por su facilidad de lectura son usados co-
mo introducción a los algoritmos, descripción de un lenguaje y descripción de procesos a
personas ajenas a la computación.
A continuación describimos los sı́mbolos usados en los diagramas de flujo:
Un pseudocódigo es la descripción de un algoritmo que asemeja a un lenguaje de progra-

mació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 pseudocódigo no está regido por ningún está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 descripción de un algoritmo usualmente se hace en tres niveles:
1. Descripción de alto nivel. Se establece el problema, se selecciona un modelo

matemático y se explica el algoritmo de manera verbal, posiblemente con ilustra-
ciones y omitiendo detalles.
2. Descripción formal. Se usa pseudocódigo para describir la secuencia de pasos que

encuentran la solución.
3. Implementación. Se muestra el algoritmo expresado en un lenguaje de progra-

mación especı́fico o algún objeto capaz de llevar a cabo instrucciones.
La máquina de Turing es un modelo matemático, diseñado por Alan Turing, que formal-
iza el concepto de algoritmo. A este modelo se le refiere comunmente como la “descripción
de más bajo nivel” por el hecho de que no utiliza ninguna expresión coloquial.
1.2.1. Implementación y aná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
eléctrico o un aparato mecánico. Algunos algoritmos inclusive se diseñan especialmente
para implementarse usando lápiz y papel. El algoritmo de multiplicación tradicional, el
3
E. Kenny Venegas P.
algoritmo de Euclides, la criba de Eratóstenes y muchas formas de resolver la raı́z cuadra-

da son sólo algunos ejemplos.
Como medida de la eficiencia de un algoritmo, se suelen estudiar los recursos (memoria

y tiempo) que consume el algoritmo. El análisis de algoritmos se ha desarrollado para
obtener valores que de alguna forma indiquen (o especifiquen) la evolución del gasto de
tiempo y memoria en función del tamaño de los valores de entrada.
El análisis y estudio de los algoritmos es una disciplina de las ciencias de la computación

y, en la mayorı́a de los casos, su estudio es completamente abstracto sin usar ningún tipo
de lenguaje de programación ni cualquier otra implementación; por eso, en ese sentido,
comparte las caracterı́sticas de las disciplinas matemáticas. Ası́, el análisis de los algo-
ritmos se centra en los principios básicos del algoritmo, no en los de la implementación
particular. Una forma de plasmar (o algunas veces “codificar”) un algoritmo es escribirlo
en pseudocódigo o utilizar un lenguaje muy simple tal como léxico, cuyos códigos pueden
estar en el idioma del programador.
Todo pseudocó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: Limón , azúcar , agua
Cuerpo del algoritmo: Partir el limón en dos.
Exprimir el contenido del limón en el vaso.
Echar agua y azúcar en el vaso.
Mezclar.
La estructura del programa es la siguiente:
Program nombre del programa


Uses 

declaración de bibliotecas 



Type 



declaración de arreglos y nuevos tipos de variables

Cabecera
Const 

declaración de constantes




Var





declaración de variables

begin  
.. Cuerpo
. 
end.

4
1.3. Entradas y salidas de datos
Se debe colocar siempre un punto después del “end”.
Todo algoritmo se representa en el siguiente diagrama, donde las flechas de rojo se llaman
compiladores:
Programadores ↔ Algoritmo ↔ Programa ↔ Computadora

↓ ↓ ↓ ↓
Español ↔ Inglés ↔ Lenguaje Máquina ↔ Lenguaje Máquina
1.3. Entradas y salidas de datos

La salida de datos es la visualización de informació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, éste se debe escribir entre apóstrofes.
Ejemplo 1.2 write(’Hola, Mundo’);
Lo que hace escribir el texto “Hola, Mundo” en la pantalla del computador, es decir se
visualizará
Hola, Mundo
Ejemplo 1.3 writeln(’Adios, Mundo’);
A diferencia del anterior, el cursor estará en la siguiente lı́nea, por lo tanto, la salida será la
siguiente:
Adios, Mundo
Para que el usuario pueda ingresar caracteres deberá utilizar el comando readln (leer).
Este comando tambié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 ejecución
del programa.
Se debe colocar un punto y coma ( ; ) despué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 óptima comprensió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 representación gráfica del programa anterior.
6
Capı́tulo 2
Partes de un programa
2.1. Variables y constantes

Cuando se procesa información o datos, un programa para computadora generalmente
mantiene valores para varias cantidades, a éstas cantidades se les puede hacer referencia
por nombres y son conocidos como variables. El valor de una variable puede alterarse
durante la ejecució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 válidos

Los identificadores deben cumplir varios requisitos (los cuales se asemejan a los requisitos
que debe tener el nick de un usuario de correo electrónico):
Sólo deben contener caracteres alfanuméricos y los caracteres “ ” y “ ”.
El primer carácter debe ser una letra o subrayado.
No puede contener espacios en blanco ni vocales tildadas, ni ñ o Ñ.
No debe ser ninguna palabra reservada.
Las palabras reservadas son aquellas palabras que ya tienen una funció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 mayú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 servirá 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 continuación:
1. Integer: Almacena números enteros.
2. Real: Almacena números reales (con decimales).
3. Char: Almacena un caracter cualquiera del código ASCII.
4. String: Almacena uno o más caracteres (texto).
5. Boolean: Almacena el valor de TRUE o FALSE (V o F).
2.2.1. Tipos de datos numéricos

Tipo Rango de valores Ocupació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. Declaración de variables

Sintaxis
Var < Identificador > : < Tipo de variable > ;
Ejemplo 2.2
cad : string;
Raiz 12 : real;
Edad : integer;
Opcion : char;
2.3.1. Asignación de valores en el cuerpo del programa

Sintaxis
< Nombre de la variable > := < Valor de la variable > ;
Donde “:=” es el operador de asignación. Cuando queremos asignar el valor de una variable
del tipo char o string, colocaremos el carácter o caracteres entre apó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 más de un identificador en la asignació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 má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 paréntesis despué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 será:
a=
5False
Ejemplo 2.5
10
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 será:
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 continuación
escribimos el nombre de la variable entre paré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 será:
Ingrese un entero:
Supongamos que ingresamos 3 como el valor de a, luego se visualizará:
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 será:
Escriba su nombre:
12
2.4. Tipos de operadores
Supongamos que ingresamos Jorge como el valor de nombre. Luego se visualizará:
Escriba su nombre: Jorge

Escriba su edad:
Supongamos que ingresamos 20 como el valor de edad. Finalmente la salida será:
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 acompañados de textos que se separan de las variables
mediante comas.
2.4. Tipos de operadores

2.4.1. Operadores aritméticos
+ : suma
- : resta
* : producto
/ : división
2.4.2. Operadores lógicos

And ( y)
Or ( o)
Not ( negació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
También podemos más de dos operadores ló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 matemáticas

Delphi tiene implementada las siguientes funciones matemá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 hiperbólico
Cosh : Coseno hiperbólico
Sintaxis
< función > ( < variable > ) ;

< función > ( < valor numérico > ) ;
Observaciones
Las funciones Abs y Sqr , respetan el tipo de variable, es decir, si la variable es real
(entera), el resultado también será 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 matemá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 cuadrá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 instrucció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 visualizará 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 número visualizado debe multiplicarse por 100000 = 1. En general, cuando se mues-
tra el valor de un número real, se verá en la pantalla aE + b ó aE − b, en consecuencia el
valor será a × 10b ó a × 10−b respectivamente.
Para evitar la salida de los 14 decimales que tiene a podemos indicar en el programa el
número de decimales que tendrá una variable real y también podemos dar espacios en
blanco antes de mostrar un valor. Para ello escribiremos:
< variable de tipo real > : n : m
En este caso el número de decimales será m. Supongamos que el número de dı́gitos en la
salida es d, entonces el número de espacios en blanco que se dará antes de imprimir el
valor será n − d, si n − d < 0 entonces no se dará 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 mostrará la salida: 1.41
En la segunda lı́nea se ha dado 2 espacios.
2.6. Los operadores div y mod

Hay otros operadores aritméticos definidas en Delphi como div y mod, los cuales están
definidos como el cociente y el residuo de una división entera respectivamente. Es decir,
dados a y b números enteros existen nú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 nú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.
Observació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.

1. Dados a, b y c números reales, elabore un programa que muestre las raı́ces (reales o
complejas) de la ecuación cuadrática
ax2 + bx + c = 0.
2. Haga un algoritmo que calcule la suma y producto de dos polinomios cuadráticos.

Para ello el programa debe pedir los coeficientes de los términos independientes,
lineales y cuadrá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 efectú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) Selección simple
If <expresión booleana> then

Begin
<sentencias> se ejecuta sólo si la expresión booleana es verdadera.
End ;
B) Selección doble
If < expresión booleana > then

Begin
<sentencias 1>
End ELSE
Begin
<sentencias 2>
End;
Estructura If Simple (Si - entonces)

Está compuesto únicamente de una condición. La estructura “si - entonces” evalúa la
condición y en tal caso:
19
E. Kenny Venegas P.
Si la condición es verdadera, entonces ejecuta la acción Si (o acciones si son varias).

Si la condición es falsa, entonces no se hace nada.
Ejemplo 3.1 Construir un algoritmo tal, que dado como dato la calificación de un alumno
en un examen, escriba “Aprobado” en caso que esa calificación fuese mayor o igual que
10.
Algoritmo Calificación
Variables
cal: entero
Inicio
Leer (cal)
Si cal >= 10 entonces
Escribir ("Aprobado")
Fin_si
Fin
Estructura If Doble
Es una estructura lógica que permite controlar la ejecución de varias acciones y se
utilizan cuando se tienen dos opciones de acció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 calificación de un alumno en un examen, escriba .aprobado”si
su calificació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 nú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 pseudocódigo que diga si un número real está 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,’ está en el intervalo [ -1 , 1 ]’)
Sino
Escribir (x,’ no está en el intervalo [ -1 , 1 ]’)
Fin
Ejemplo 3.5 Haga un programa que pida el ingreso de 2 números y calcule el mayor de
ellos.
Program Mayor2;
{$APPTYPE CONSOLE }
Var
a,b: real;
22
3.2. Estructuras selectivas de mú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.

Se ha visto que el compilador puede escoger entre dos alternativas. En algunos casos,
el compilador debe escoger entre una lista con más de dos alternativas. Hay dos métodos:
IF anidado y Case .
3.2.1. El Enunciado IF Anidado

En la solución de problemas encontramos numerosos casos en los que luego de tomar
una decisión y marcar el camino correspondiente a seguir, es necesario tomar otra de-
cisión. Dicho proceso puede repetirse varias veces. En aquellos problemas en donde un
bloque condicional incluye otro bloque condicional se dice que un bloque está 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 número entero y diga si es
positivo, cero o negativo. En el caso que sea positivo diga ademá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 más de dos elecciones posibles. Este problema
se podrı́a resolver por estructuras selectivas simples, dobles o anidadas, pero si el número
de alternativas es grande puede plantear serios problemas de escritura y de legibilidad.
Usando la estructura de decisión múltiple se evaluará una expresión que podrá tomar n
valores distintos, 1, 2, 3, . . . , n y según que elija uno de estos valores en la condición, se
realizará una de las n acciones o lo que es igual, el flujo del algoritmo seguirá sólo un
determinado camino entre los n posibles. Esta estructura se representa por un selector el
cual si toma el valor 1 ejecutará la acción 1, si toma el valor 2 ejecutará la acción 2, si
toma el valor N realizará la acción N .
Ejemplo 3.7 Diseñar un algoritmo tal que dados como datos dos variables de tipo entero,
obtenga el resultado de la siguiente funció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 representación de tal algoritmo en un diagrama de flujo y en el diagrama NS.
24
Sintaxis:
Case <selector> of
Opción 1 : sentencia 1;
.
.
Opción n : sentencia n
Else
Sentencia n+1
End;
Observación:
El selector debe ser de tipo ordinal, es decir entero o cará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-
ción de control o variable, para determinar cuando debe detenerse la ejecución. Hay tres
26
tipos de lazos de control:
Sentencia For (Desde/Para).
Sentencia While (Mientras).
Sentencia Repeat (Repetir).
El conjunto de instrucciones que se ejecuta repetidamente cierto número de veces, se

llama Ciclo, Bucle o Lazo.
Una Iteració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 acción. Los contadores se
utilizan con la finalidad de contar sucesos o acciones internas de un bucle; deben realizar
una operación de inicialización y posteriormente las sucesivas de incremento o decremento
del mismo. La inicialización consiste en asignarle al contador un valor. Se situará antes y
fuera del bucle.
Representación:
<nombre del contador>←<nombre del contador> + <valor constante>
Si en vez de incremento es decremento se coloca un menos en lugar del má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. Representació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 número de veces que se eje-
cutará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
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 condición es evaluada antes de la primera ejecución de sentencias,

de modo que si la condición es falsa, la secuencia nunca es ejecutada. La ejecución de estas
sentencias continua mientras la expresió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. Tambié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 condición, cuando
se cumple la condición, se sale del ciclo.
Ejemplo 3.12 Haga un algoritmo que calcule la suma de los cuadrados de los primeros
100 números enteros utilizando la estructura Mientras.
30
Sintaxis:
While ( expresión booleana ) do
Begin
Sentencia 1 ;
Sentencia 2 ;
.
Sentencia n ; // el ; es opcional
End ;
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;
Readln
End.
3.3.3. La Sentencia REPEAT

Se llama Repetir a la estructura algorı́tmica que se ejecuta un número definido de veces
hasta que la condición se torna verdadera:
31
E. Kenny Venegas P.
Las reglas para la construcció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 condición ahora estará colocada al final
del bucle para que primero ejecutamos la instrucción y luego preguntamos si la condición
se cumple. Esto quiere decir, que en esta estructura el bucle se realizará por lo menos
una vez. También podrás observar que la condición está al revés, porque el bucle se repite
hasta que la condición se cumpla. En el bucle Mientras, la condición se evaluaba mientras
era cierta.
Ejemplo 3.14 Hacer un algoritmo que calcule la suma de los cuadrados de los primeros
100 números enteros utilizando la estructura Repeat.
Sintaxis:
32
REPEAT
Sentencia 1 ;
Sentencia 2 ;
.
.
.
Sentencia n ;
Until (expresió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.
Program SumaRepeat;
{$APPTYPE CONSOLE}
Var
suma,i: integer;
Begin
suma:=0;
i:=0;
Repeat
i:=i+1;
suma:=suma+sqr(i);
Until (i=100);
Readln
End.
La estructura While y la estructura Repeat, se conocen como Iterativas. Se usan cuan-

do no se conoce con anticipación el número de veces que se ejecutará la acción.
La diferencia entre ambas es que la condición se sitúa al principio (Mientras) o al final

(Repetir) de la secuencia de instrucciones. Entonces, en el primero, el bucle continúa mien-
tras la condición es verdadera (la cual se comprueba antes de ejecutar la acción) y en el
segundo, el bucle continúa hasta que la condición se hace verdadera (la condición se com-
prueba después de ejecutar la acción, es decir, se ejecutará al menos una vez).
La estructura Desde/Para suele utilizarse cuando se conoce con anterioridad el número

de veces que se ejecutará la acción y se le conoce como Estructura Repetitiva en lugar de
iterativa, para diferenciarla de las dos anteriores.
33
E. Kenny Venegas P.

1. Haga un programa que dado x ∈ R evalúe la funció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 números positivos y muestre su media

aritmética, geométrica y armónica.
4. Realice un programa que pida el ingreso de la parte real e imaginaria de un nú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 nú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

informació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.
Observació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 biyección entre el conjunto de caracteres y el conjunto {1, 2, . . . , 255}, a tal
biyección se le conoce como código ASCII.
Por ejemplo: @ = ALT + 64 (sólo en Windows).
Note que: <caracter asociado>=CHR (<número entero entre 1 y 255>)
<có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 usará la funció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. Concatenació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 será:
’HolaComo estas?’ A:= ’ABC ’ B:= ’XYZ’ C:= A + B C:= ’ABC XYZ’ // Ahora el valor
de C será: ’ABC XYZ’
4.2. Conversión de tipos

Lo que hemos estado trabajando hasta el momento es la entrada y salida de infor-
mación del modo consola. Para visualizar la información en ventanas debemos utilizar
una conversión de nuestras variables al tipo cadena (string) y además usar los comandos
inputbox y showmessage.
4.2.1. Conversión de cadena a nú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
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 visualizará 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 nú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 números’,
’Ingrese el primer número:’,’’));
m:=StrToInt(InputBox(’Lectura de números’,
’Ingrese el segundo número:’,’’));
p:=StrToInt(InputBox(’Lectura de números’,
’Ingrese el tercer número:’,’’));
prom:=(n+m+p)/3;
ShowMessage(’El promedio de los nú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 número ingresado por teclado.
Program factorial;
Uses
SysUtils,dialogs;
Var
i,n,f:integer;
Begin
repeat
n:=strtoint(inputbox(’’,’Ingrese un nú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 número ingresado es primo o no.
Program primo;
Uses SysUtils,Dialogs;
Var n,i,k:integer; r:real;
Begin
n:=StrToInt(InputBox(’’,’Ingrese un número’,’’));
r:=sqrt(n); i:=1; k:=0;
while (i<=r) and (k=0) do
begin
i:=i+1;
38
if (n mod i = 0) then
k:=1;
end;
if (k=0) then
ShowMessage(IntToStr(n)+’ si es un número primo’)
else
ShowMessage(IntToStr(n)+’ no es un número primo’)
End.
4. Elabore un programa que pida el ingreso de un nú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 número’,’Ingrese el nú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 número está 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 número’,’Ingrese el nú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 número ingresado no está en base 2’);
End.
6. Elabore un programa que pida un número real x y un número natural n y calcule la

suma.
Program suma_exp;
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 número ingresado por el
usuario.
Program div_propios;
Uses
SysUtils,Dialogs;
Var
i,n:integer;
cad:string;
40
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 números términos de la sucesió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(’Sucesión de Fibonacci’,
’Ingrese el número de té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 sucesión de Fibonacci es’+#13+S);
End.
9. Diseñar un programa tal que dados como datos una variable de tipo entero y una
del tipo real, obtenga el resultado de la siguiente función:
Program ValCase;
Var
num: integer;
v,val: real;
Begin
num:=StrToInt(InputBox(’’,’Ingrese un número entero:’,’’));
v:=StrToFloat(InputBox(’’,’Ingrese un nú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 función será’+#13+FloatToStr(val))
End.

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 números a y b son parientes.
2. Elabore un programa que halle un número primo de forma abc tal que a < b < c.
En caso no exista tal número el programa debe devolver 0 como salida.
3. Haga un programa que indique si dos números N y M están formados por los mismos
dı́gitos. Ejemplos: 321 y 213, 45 y 554.
4. Realice un programa que dado N devuelva un nú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 números primos entre dos
números N y M dados.
6. (Tercer Teorema de Fermat). El matemático francés Pierre Fermat enunció en una

proposición que no existen números enteros x, y, z y n > 2 tales que xn + y n = z n .
Elabore un programa que busque un contraejemplo de esta afirmación para nú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 Está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 nú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 dimensió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; // Conversión de A a la cadena S
end;
showmessage(’El vector A es’+#13+S)
End.
Ejemplo 5.3 Program norma;

const max=20;
Var i,n:integer; norm:real;
A:vector; S:string;
Begin
norm:=0;
for i:=1 to n do
begin
A[i]:=strtoint(inputbox(’A[’+inttostr(i)+’]’,’Ingrese valor’,’’));
S:=S+inttostr(A[i])+#9; // Conversió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;

const max=20;
Var i,n:integer; A:vector; S:string;
Begin
n:=strtoint(inputbox(’Sucesión de Fibonacci’,
’Ingrese el número de términos’,’’));
A[1]:=1; S:=’1’;
if n>1 then
begin
A[2]:=1; S:=S+#9+’1’;
44
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 sucesión de Fibonacci es’+#13+S);
End.
Ejemplo 5.5 Program suma_vectores;

const max=20;
type vector=array[1..max] of real;
Var i,n:integer; A,B:vector; S,S1,S2:string;
Begin
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 número máximo de filas del arreglo y m el número máximo
de columnas.
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;
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, muéstre-
las y calcule su suma.
Program suma_matrices;
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
for i:=1 to n do
begin
for j:=1 to n do
begin
A[i,j]:=strtoint(inputbox(’A[’+inttostr(i)+’,
B[i,j]:=strtoint(inputbox(’B[’+inttostr(i)+’,
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 función que devuelve un número real aleatorio entre 0 y 1. a + (b −

a)∗random devuelve un número real aleatorio entre a y b.
Random(n) es una función que devuelve un número entero entre 0 y n−1. Randomize
sirve para no obtener los mismos números aleatorios (cambia de raiz).
Trunc(x) es una función que devuelve la parte entera del nú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, además sume A y B.
Program aleatorio;
const max=20;
Type vector=array[1..max] of real;
Var i,n:integer; A,B:vector; S,S1,S2:string;
Begin
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; // Tambié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 Dinámicos

A diferencia de los arreglos estáticos, su tamaño se define en tiempo de ejecución, es
decir al compilar el programa, usando la función setlength. La ventaja de usar arreglos
dinámicos es el ahorro de memoria.
Sintaxis:
Type
Arreglo_dinamico = array of Tipo_dato;
Var
Identificador = Arreglo_dinámico;
Begin
...
setlength(Identificador,tama~no);
...
End.
Observación: El ı́ndice de los elementos de un arreglo diná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 números reales de -10 a 10:
Program aleatorio_din;
Type vector_d=array of real;
Var i,n:integer; A:vector_d; cad:string;
Begin
n:=strtoint(inputbox(’’,’Ingrese un número natural’,’’));
cad:=’Los primeros números reales son:’+#13;
setlength(A,n); randomize;
48
5.2. Arreglos Diná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 números naturales.
Program aleatorio_n;
Type vector_d=array of integer;
Var i,n:integer; A:vector_d; cad:string;
Begin
cad:=’Los primeros ’+inttostr(n)+’ nú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;
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 número de
filas de las matrices’,’’));
n:=strtoint(inputbox(’’,’Ingrese el nú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
diná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 número de filas’,’’));
m:=strtoint(inputbox(’’,’Ingrese el nú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

1. Haga un programa que pida el ingreso de números y lo almacene en un arreglo y diga
cú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 deberá mostrar que 1
aparece tres veces, 2 aparece dos veces y 3 aparece una vez.
2. Un mé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 té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 método de ordenación. Por ejemplo, si el
arreglo es [0.3 1 -2 2.5 1.7] el programa deberá devolver -2 0.3 1 1.7 2.5
3. Modifique el ejercicio anterior para que no se visualizen los elementos más de una
vez. Por ejemplo, si el arreglo es [1 -1 2 1 3 -1 2 3 2 1] el programa deberá devolver
-1 1 2 3.
4. La moda de un conjunto de números es aquel número que tiene la mayor frecuencia
entre todos, es decir, el que se repite más. Elabore un programa que, dado un conjunto
de n números (con n dado por el usuario) ingresados de forma ascendente, halle la
moda de ellos. (Obs. En caso haya dos nú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. Diseñ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 ecuació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 función es un procedimiento que puede devolver un valor (só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 funció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 número ingresado por el usuario:
Program factorial;
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.

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;
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 dimensió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;

leer(A,n); imprimir(A,n);
End.
Ejemplo 6.3 Programa que evalúa un polinomio cuyos coeficientes están en una arreglo:
Program val_polinomio;
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. Pará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;

n:=strtoint(inputbox(’’,’Ingrese el grado del polinomio’,’’));
Setlength(P,n+1);
P[0]:=strtofloat(inputbox(’’,’Ingrese el término independiente’,’’));
S:=’El polinomio P es:’+#13+floattostr(P[0]);
for i:=1 to n do
begin
P[i]:=strtofloat(inputbox(’’,’Ingrese el término de orden ’
+inttostr(i),’’));
S:=S+’+’+floattostr(P[i])+’x^’+inttostr(i);
end;
x:=strtofloat(inputbox(’’,’Ingrese el número real a evaluar’,’’));
Showmessage(S+#13+#13+’P(’+floattostr(x)+’) = ’+floattostr(val(P,x)));
End.
6.1. Parámetros por valor y referencia

Un parámetro de entrada es el valor de una variable de entrada de un procedimiento
o función y se pueden dividir en:
Parámetros de entrada por valor, si solo adquiere el valor del parámetro ingresado
en el programa principal.
Parámetros de entrada por referencia, si es permitida la modificación del parámetro

ingresado en el programa principal.
Cuando los parámetros de entrada son por valor no es necesario colocar “var” antes de las
variables de entrada, mientras que si son parámetros de referencia debemos incluir “var”
antes de las variables de entrada.
Ejemplo 6.4 Programa que calcula el factorial de un número usando una función recur-
siva:
55
E. Kenny Venegas P.
Program factorial_recursivo;
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;

showmessage(’El factorial de ’ + inttostr(n) +
’ es ’+inttostr(fact(n)));
End.
Ejemplo 6.5 Programa que dice si un número es primo o no (mencionando quien lo

divide).
Program primos;
Type v2=array[1..2] of integer;
var n:integer; p:v2;
Function primo(n:integer):v2; // pará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
end;

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.

1. Elabore un programa que calcule el máximo común divisor de n números ingresados
por el usuario. Sugerencia: Haga un subprograma que halle el MCD de dos números
utilizando el algoritmo de Euclides.
2. Elabore un programa que calcule el mı́nimo común múltiplo de n números ingresados
por el usuario. Sugerencia: Haga un subprograma que halle el MCM de dos números
utilizando M CM (a, b) · M CD(a, b) = a · b.
n
3. En 1640 Fermat afirmó que F (n) = 22 + 1 es primo ∀ n ≥ 0 (estos números son
conocidos como los números de Fermat). Haga un programa que calcule el menor
número de Fermat que no es primo.
4. Haga un programa que calcule el menor nú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 nú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 número de Carmichael si, y só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 número ingresado por el usuario es o no un
número de Carmichael.
6.3. Técnicas de ordenación

Definamos el problema de ordenación:
57
E. Kenny Venegas P.
Dados n números reales: x1 , x2 , x3 , . . . , xn colocarlos en orden creciente.
Veremos algunas técnicas de ordenación como los métodos de selección, inserción y bur-
buja.
6.3.1. Selección
Algoritmo Ordenación por selecció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
Implementación del método de ordenación por selección:
Program ordenacion_seleccion;
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
for i:=1 to n do
end;
Procedure intercambiar(var a,b:real);

var temp:real;
begin
temp:=a;
58
6.3. Técnicas de ordenació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;

leer(A,n);
cad:=’El vector ingresado es’+#13+s(A,n)+#13;
showmessage(cad+’Ordenado por el método de selección es’
+#13+s(selec(A,n),n));
End.
6.3.2. Inserción
Este algoritmo encuentra la posición correcta para xi en el segmento x1 , x2 , . . . , xi−1 y
lo coloca allı́, es decir, lo inserta.
Algoritmo Ordenación por Inserción

Variables
i,j,n : enteros v : real
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 implementación del método de inserción (con “inser” como un procedimiento

o función).
Program ordenacion_insercion;
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
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
end;
A[j]:=v;
end;
// incluir "inser:=A;" en el caso de utilizar "inser" como una función
end;

leer(A,n);
cad:=’El vector ingresado es’+#13+s(A,n)+#13;
inser(A,n);
showmessage(cad+’El vector ordenado por el método de inserción es’
+#13+s(A,n));
// Incluir lo siguiente si se utiliza "inser" como función:
{showmessage(cad + ’El vector ordenado por el método de inserción es’
+ #13 + s(inser(A,n),n));}
End.
6.3.3. Burbuja
Algoritmo Ordenación burbuja
Variables
i,j,n,m : enteros
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.

1. Modifique los algoritmos de selección, inserción y burbuja para que ordenen al-
fabéticamente un arreglo de cadenas. (Obs. En Delphi es permitida la comparación
de cadenas.)
61
E. Kenny Venegas P.
2. Elabore un programa que cuente el número de intercambios realizados al ordenar un

arreglo haciendo uso de
a) Método de Selección.
b) Método de Inserción.
c) Método de la Burbuja.
3. Modifique los algoritmos de selección, inserció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 método de ordenació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 método de ordenació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 generalizació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 denominará “campo”.
7.1. Declaració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 colocará “ = Record” y dentro de Var irá “ : Record”.

Ejemplo 7.1 A continuación definiremos el registro “Amigo” dentro como una variable
y con tres campos (Nombre, Edad y Telef ):
Program registro_amigo;
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 número telefónico es ’+inttostr(amigo.telef));
End.
Ejemplo 7.2 El siguiente programa dirá si aprobó o desaprobó un alumno en el curso
indicado.
63
E. Kenny Venegas P.
Program registro_alumno;
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 := ’ desaprobará ’
else
cad := ’ aprobará ’;
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 ó 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. Declaración de registros
n:=strtoint(inputbox(’’,’Nú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 có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 có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 Matemá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
for i:= 1 to j3 do
65
E. Kenny Venegas P.
for i:= 1 to j5 do
showmessage(cad)
End.

1. Haga una listado de alumnos del curso de Computación y Algoritmos I (ingresados
por el usuario) que contenga los siguientes datos: Apellidos y nombres, Especialidad,
Código y Promedio final. Muestre esta lista por orden de mérito.
2. Elabore un programa que lea los siguientes datos acerca de una persona: nombre,
edad y sexo (indique sólo H o M) y determine:
a) Las personas de sexo masculino (H)

b) Las personas mayores de 18 años
c) Las personas de sexo femenino entre 18 y 23 años
3. Diseñe un programa que pida al comprador de un auto las siguientes caracterı́sticas:

Marca, Año y Color. Además debe mostrar el precio del vehı́culo a comprar, teniendo
en cuenta que sólo se venden las marcas Tayet, Sumari, Macros y Futura, de los años
2000 al 2008, y sus precios base respecto al año 2008 y en color blanco son: 12000,
15000, 18000 y 20000 dólares respectivamente. Si el comprador no quisiera un auto
del año entonces se hará un descuento de $250 por cada añ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 pagará $50 adicionales. El programa deberá 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. Programación con Delphi, 1996.
[3] LLACUA PERA, Javier Ita. Programando con Objetos en Pascal.
[4] LUCCHESI, Cláudio et al. Aspectos Teóricos da Computação, 1979.
[5] MELCHOR ESPINOZA, Victor. Aprenda a Programar con Deplhi, 2004.
[6] PERRY, Greg. Aprendiendo Principios de Programación en 24 horas, 1999.
67

Algoritmos

Cargado por

Copyright:

Formatos disponibles

Algoritmos

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Algoritmos

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD NACIONAL DE INGENIERÍA

El Lenguaje de Programación Delphi

1. Algoritmos y Programación Estructurada 1

4. Cadenas. Entrada y salida de información 35

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

En matemáticas, ciencias de la computación y disciplinas relacionadas, un algoritmo

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

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

1.1. Concepto y caracterı́sticas de un algoritmo

1.1.1. Propiedades de los algoritmos

1. Carácter finito. Un algoritmo siempre debe terminar después de un número finito

1.1.2. Caracterı́sticas de los algoritmos

Finitos: Debe acabar en algún momento.

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

Modificables: Estarán diseñados de modo que sus posteriores modificaciones sean

1.2. Representación de un algoritmo

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

Un pseudocódigo es la descripción de un algoritmo que asemeja a un lenguaje de progra-

La descripción de un algoritmo usualmente se hace en tres niveles:

1. Descripción de alto nivel. Se establece el problema, se selecciona un modelo

2. Descripción formal. Se usa pseudocódigo para describir la secuencia de pasos que

3. Implementación. Se muestra el algoritmo expresado en un lenguaje de progra-

1.2.1. Implementación y análisis de los algoritmos

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

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

El análisis y estudio de los algoritmos es una disciplina de las ciencias de la computación

Todo pseudocódigo consta de 3 partes: nombre, cabecera y cuerpo.

Nombre: Algoritmo para hacer un vaso de limonada

La estructura del programa es la siguiente:

Program nombre del programa

Se debe colocar siempre un punto después del “end”.

Programadores ↔ Algoritmo ↔ Programa ↔ Computadora

1.3. Entradas y salidas de datos

Ejemplo 1.2 write(’Hola, Mundo’);

Ejemplo 1.3 writeln(’Adios, Mundo’);

Para la óptima comprensión de los comandos definidos anteriormente debemos introducir

1.4. Ejercicios propuestos

2. Realice la representación gráfica del programa anterior.

2.1. Variables y constantes

Un Nombre (Al que llamaremos identificador).

2.1.1. Identificadores válidos

Sólo deben contener caracteres alfanuméricos y los caracteres “ ” y “ ”.

El primer carácter debe ser una letra o subrayado.

No puede contener espacios en blanco ni vocales tildadas, ni ñ o Ñ.

No debe ser ninguna palabra reservada.

Un identificador no es sensible a las mayúsculas, por ejemplo, un identificador cono Min-

2.2. Tipos de variables

1. Integer: Almacena números enteros.

2. Real: Almacena números reales (con decimales).

3. Char: Almacena un caracter cualquiera del código ASCII.

4. String: Almacena uno o más caracteres (texto).

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

2.2.1. Tipos de datos numéricos

2.3. Declaración de variables

Var < Identificador > : < Tipo de variable > ;

2.3.1. Asignación de valores en el cuerpo del programa

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

Podemos colocar más de un identificador en la asignación del tipo de variables si los

Los comentarios se usan para describir una o más instrucciones en el programa y no

sqrt ( sqr(b) - 4ac )