Programación para Topografía

2007
Notas de clase
Programación
para
Topografía
Gonzalo Jiménez C.
Julián Garzón B.
Facultad de Ingeniería
Programa de Topografía
Armenia, 2007
2007
Notas de clase
Programación
para
Topografía
Primer borrador
Gonzalo Jiménez Cleves

Topógrafo.
Esp. Computación para la docencia.
Msc. Ingeniería de Sistemas.
Docente Universidad del Quindío.
Julián Garzón Barrero

Tecnólogo en Topografía.
Ingeniero de Sistemas.
Docente Universidad del Quindío.
Universidad del Quindío

Facultad de Ingeniería - Programa de Topografía
Programación
para
Gonzalo Jiménez Cleves
Julián Garzón Barrero
Topografía
Este documento es una guía de enseñanza básica para aquellos estudiantes
de Topografía que se inician en el asombroso mundo de la programación y
que desean tener una visión estructurada para analizar y solucionar Algoritmos,
problemas, desarrollando la capacidad de pensar racionalmente a cerca de
soluciones alternativas y los resultados de aplicarlas, es decir de hacer
diagramas de flujo
elecciones inteligentes. El lenguaje que se utiliza es seudocódigo, lo cual es de datos, y
una característica muy importante porque facilita al alumno concentrarse
en las estructuras de datos y algoritmos asociados a ella sin necesidad de
programas
relacionarlas a un complejo lenguaje de programación.
Tabla de contenido Geomática
Tabla de contenido
1. Algoritmos, su representación, y programas .................... 7
1.1 Conceptos básicos de programación ................................... 7
1.1.1 Programar .................................................................................. 7
1.1.2 Dato............................................................................................ 7
1.1.3 Información ................................................................................ 7
1.1.4 Procesamiento de datos ............................................................ 7
1.2 Algoritmos y programas ..................................................... 8
1.3 Características de los algoritmos ........................................ 8
1.4 Pasos del desarrollo de un programa .................................. 9
1.4.1 Análisis del problema ................................................................. 9
1.4.2 Diseño del algoritmo .................................................................. 9
1.4.3 Codificación.............................................................................. 10
1.4.4 Implementación y depuración ................................................. 10
1.4.5 Pruebas .................................................................................... 12
1.4.5.1 Prueba de escritorio .................................................................... 12
1.4.5.2 Prueba manual de datos de muestra .......................................... 12
1.4.5.3 Prueba por un grupo selecto de usuarios potenciales................ 12
1.4.6 Documentación del programa ................................................. 14
1.4.6.1 Manual de usuario y manual del analista ................................... 14
1.4.7 Mantenimiento del programa ................................................. 15
1.5 La lógica como aspecto fundamental de la programación . 15
1.5.1 Argumentos ............................................................................. 16
1.5.2 Premisas y conclusión .............................................................. 16
1.6 Tipos de datos .................................................................. 18
1.6.1 Datos simples ........................................................................... 19
1.6.1.1 Enteros ........................................................................................ 19
1.6.1.2 Reales .......................................................................................... 19
1.6.1.3 Caracteres ................................................................................... 20
1.6.1.4 Cadenas ....................................................................................... 20
1.6.1.5 Datos lógicos ............................................................................... 21
1.7 Identificadores, constantes, variables y operadores ......... 21
1.7.1 Identificadores ......................................................................... 21
1.7.2 Constantes ............................................................................... 22
Geomática Programación para Topografía
1.7.3 Variables .................................................................................. 22

1.7.4 Operadores .............................................................................. 22
1.7.4.1 Operadores aritméticos .............................................................. 22
1.7.4.2 Operadores relacionales ............................................................. 26
1.7.4.3 Operadores lógicos ..................................................................... 27
1.7.5 Asignaciones ............................................................................ 29
1.8 Técnicas de representación de algoritmos ........................ 32
1.8.1 Descripción narrada ................................................................. 32
1.8.2 Diagramas de flujo ................................................................... 34
1.8.2.1 Inicio – Fin ................................................................................... 34
1.8.2.2 Entrada ....................................................................................... .35
1.8.2.3 Proceso ........................................................................................ 35
1.8.2.4 Decisión ....................................................................................... 35
1.8.2.5 Decisión doble ............................................................................. 36
1.8.2.6 Decisión múltiple ........................................................................ 36
1.8.2.7 Salida ........................................................................................... 37
1.8.2.8 Flujos ........................................................................................... 37
1.8.2.9 Conector ...................................................................................... 38
1.8.2.10 Conector .................................................................................... 38
1.8.2.11 Procedimiento ........................................................................... 38
1.8.3 Método para construir un diagrama de flujo .......................... 39
1.8.4 Reglas para construir un diagrama de flujo ............................. 32
1.8.5 Seudocódigo ............................................................................ 37
1.9 Ejercicios propuestos ........................................................ 50
2. Estructuras algorítmicas de selección ........................... 57

2.1 Introducción ...................................................................... 57
2.2 Estructura selectiva simple si entonces ............................. 58
2.3 Estructura selectiva doble si entonces / sino..................... 60
2.4 Estructura selectiva múltiple si múltiple ........................... 63
2.5 Estructuras selectivas anidadas ........................................ 65
3. Estructuras algorítmicas de repetición ......................... 81

3.1 Introducción ..................................................................... 81
3.2 Estructura Mientras .......................................................... 82
3.2.1 Ciclo Mientras .......................................................................... 82
3.2.2 Ejecución de un bucle cero veces ............................................ 83
3.2.3 Bucles infinitos ......................................................................... 84
3.2.4 Terminación de bucles con datos de entrada ......................... 84
3.3 Estructura repetir ............................................................. 84
3.3.1 Ciclo Repetir ............................................................................. 85
3.4 Estructura Desde .............................................................. 87
3.4.1 Ciclo Desde............................................................................... 87
3.5 Estructuras repetitivas anidadas ....................................... 91
4. Estructuras de datos ................................................... 97

4.1 Introducción ..................................................................... 97
4.2 Datos estructurados ......................................................... 97
4.2.1 Estructuras de datos estáticas ................................................. 98
4.2.2 Estructuras de datos dinámicas ............................................... 98
4.3 Arreglos............................................................................ 98
4.3.1 Vectores .................................................................................. 100
4.3.1.1 Definición de arreglos .............................................................. 100
4.4 Operaciones básicas con vectores ................................... 101
4.4.1 Lectura ................................................................................... 102
4.4.2 Búsqueda ............................................................................... 103
4.4.3 Modificación .......................................................................... 105
4.4.4 Eliminación ............................................................................. 109
4.5 Arreglos ordenados ........................................................ 115
4.5.1 Inserción................................................................................. 115
4.5.2 Búsqueda ............................................................................... 116
4.5.3 Eliminación ............................................................................. 121
4.6 Arreglos bidimensionales (matrices) ............................... 126
4.6.1 Declaración de arreglos bidimensionales .............................. 127
4.6.2 Lectura ................................................................................... 127

4.7 Características avanzadas de los arreglos........................ 130
4.7.1 Creación dinámica de arreglos .............................................. 131
4.7.2 Combinaciones de arreglos abiertos y de tamaño fijo .......... 132
4.8 Ejercicios propuestos ...................................................... 136
5. Subrutinas ............................................................... 143

5.1 Introducción ................................................................... 143
5.2 Identificadores ............................................................... 143
5.3 Funciones ....................................................................... 146
5.3 Procedimientos .............................................................. 150
5.4 Definición de parámetros formales ................................. 151
5.4.1 Paso de parámetros ............................................................... 151
5.4.1.1 Por valor .................................................................................... 151
5.4.1.2 Por referencia............................................................................ 151
6. Introducción a Visual Basic ........................................ 159

6.1 Introducción ................................................................... 159
6.2 Variables ........................................................................ 159
6.2.1 Nombre de las variables ....................................................... 160
6.2.2 Tipos de datos ....................................................................... 160
6.3 Constantes .................................................................... 162
6.4 Operadores .................................................................... 163
6.5 Entada y salida de datos ................................................. 164
6.5.1 Entrada de datos ................................................................... 164
6.5.2 Entada y salida de datos usando controles ......................... 169
6.5.2.1 El formulario, los controles y sus propiedades ........................ 170
6.5.3 Escribir el código .................................................................. 172
6.6 Sentencias de control .................................................... 179
6.6.1 Sentencia If ............................................................................ 179
6.6.2 Sentencia If…Then...Else ....................................................... 180
6.6.3 Sentencia Select Case ........................................................... 182

6.6.4 Sentencia For…Next ............................................................... 184
6.6.5 Sentencia While…Wend ........................................................ 185
6.6.6 Sentencia Do…Loop ............................................................... 186
Bibliografía................................................................... 191
Capítulo 1
Algoritmos, su
representación, y
programas
Objetivo general:
Proveer al estudiante de las técnicas de programación básicas que le permitan abordar

el desarrollo de algoritmos correctos y eficientes para resolver problemas.
Objetivos específicos:
 Representar mediante diagramas de flujo la formulación de un algoritmo que

pueda ser escrito en cualquier lenguaje de programación.
 Utilizar el seudocódigo como una técnica básica para diseñar programas.
3
Programación para Topografía Geomática
Tabla de contenido
1. Algoritmos, su representación, y programas .................... 7

1.1 Conceptos básicos de programación ................................... 7
1.1.1 Programar .................................................................................. 7
1.1.2 Dato............................................................................................ 7
1.1.3 Información ................................................................................ 7
1.1.4 Procesamiento de datos ............................................................ 7
1.2 Algoritmos y programas ..................................................... 8
1.3 Características de los algoritmos ........................................ 8
1.4 Pasos del desarrollo de un programa .................................. 9
1.4.1 Análisis del problema ................................................................. 9
1.4.2 Diseño del algoritmo .................................................................. 9
1.4.3 Codificación.............................................................................. 10
1.4.4 Implementación y depuración ................................................. 10
1.4.5 Pruebas .................................................................................... 12
1.4.5.1 Prueba de escritorio .................................................................... 12
1.4.5.2 Prueba manual de datos de muestra .......................................... 12
1.4.5.3 Prueba por un grupo selecto de usuarios potenciales................ 12
1.4.6 Documentación del programa ................................................. 14
1.4.6.1 Manual de usuario y manual del analista ................................... 14
1.4.7 Mantenimiento del programa ................................................. 15
1.5 La lógica como aspecto fundamental de la programación . 15
1.5.1 Argumentos ............................................................................. 16
1.5.2 Premisas y conclusión .............................................................. 16
1.6 Tipos de datos .................................................................. 18
Universidad del Quindío 5

1.6.1 Datos simples ........................................................................... 19

1.6.1.1 Enteros ........................................................................................ 19
1.6.1.2 Reales .......................................................................................... 19
1.6.1.3 Caracteres ................................................................................... 20
1.6.1.4 Cadenas ....................................................................................... 20
1.6.1.5 Datos lógicos ............................................................................... 21
1.7 Identificadores, constantes, variables y operadores ......... 21
1.7.1 Identificadores ......................................................................... 21
1.7.2 Constantes ............................................................................... 22
1.7.3 Variables .................................................................................. 22
1.7.4 Operadores .............................................................................. 22
1.7.4.1 Operadores aritméticos .............................................................. 22
1.7.4.2 Operadores relacionales ............................................................. 26
1.7.4.3 Operadores lógicos ..................................................................... 27
1.7.5 Asignaciones ............................................................................ 29
1.8 Técnicas de representación de algoritmos ........................ 32
1.8.1 Descripción narrada ................................................................. 32
1.8.2 Diagramas de flujo ................................................................... 34
1.8.2.1 Inicio – Fin ................................................................................... 34
1.8.2.2 Entrada ........................................................................................ 35
1.8.2.3 Proceso ........................................................................................ 35
1.8.2.4 Decisión ....................................................................................... 35
1.8.2.5 Decisión doble ............................................................................. 36
1.8.2.6 Decisión múltiple ........................................................................ 36
1.8.2.7 Salida ........................................................................................... 37
1.8.2.8 Flujos ........................................................................................... 37
1.8.2.9 Conector ...................................................................................... 38
1.8.2.10 Conector .................................................................................... 38
1.8.2.11 Procedimiento ........................................................................... 38
1.8.3 Método para construir un diagrama de flujo .......................... 39
1.8.4 Reglas para construir un diagrama de flujo ............................. 40
1.8.5 Seudocódigo ............................................................................ 45
6 Universidad del Quindío

1. Algoritmos, su
representación, y
programas
1.1 Conceptos básicos de

programación
1.1.1 Programar: Es un proceso para convertir

especificaciones generales de un sistema en instrucciones utilizables por
un computador, que produzcan los resultados deseados.
1.1.2 Dato: Es la cantidad mínima de información no elaborada,

sin sentido en sí misma, un dato no dice nada del porqué del las cosas, y
por si mismo tiene poca importancia.
1.1.3 Información: Es un conjunto organizado de datos,

que constituyen un mensaje sobre un determinado fenómeno.
1.1.4 Procesamiento de datos: Consiste en la

recolección de datos de entrada que son evaluados y ordenados para ser
colocados de manera que produzcan información útil.

1.2 Algoritmos y programas

La necesidad del manejo de información que hoy se caracteriza por
cantidad y velocidad de cambio, hace que en todas las profesiones se
tenga la necesidad de interactuar con algún lenguaje de programación
para desarrollar aplicaciones útiles y seguras que permitan resolver
problemas con rapidez.
Un algoritmo es un método para resolver un problema, presentado

como una secuencia ordenada de instrucciones lógicas y finitas que
conllevan a la solución del mismo.
La palabra algoritmo viene de un matemático Persa llamado Mohammed

Al-Kowarizmi, quien introdujo este término al mundo, su apellido fue
traducido al latín como Algorismus, el que posteriormente se conoció
como Algoritmo.
Programar es planificar, concebir, escribir, articular y probar las

instrucciones específicas que mediante los códigos de un lenguaje de
programación generan una aplicación ejecutable para resolver o aligerar
procesos con la ayuda del computador.
1.3 Características de los algoritmos

Debe ser preciso indicando la realización de cada paso de forma
ordenada.
Debe estar bien definido. Si se sigue un algoritmo más de una vez, los
resultados deben ser los mismos.

Debe ser finito. Si se sigue un algoritmo, es decir debe tener un número

determinado de pasos.
1.4 Pasos del desarrollo de un

programa
1.4.1 Análisis del problema
Esta fase requiere una clara definición donde se contemple exactamente

lo que debe hacer el programa y el resultado o solución deseada.
Dado que se busca una solución se precisan especificaciones de entrada

y salida.
Para poder definir bien un problema es conveniente responder a las
siguientes preguntas:
¿Qué entradas se requieren? (cantidad y tipo)

¿Cuál es la salida deseada? (cantidad y tipo)
¿Qué método produce la salida deseada?
1.4.2 Diseño del algoritmo
En la fase de análisis en el proceso de programación, se determina que

hace el programa, es decir, se plantea como hace el programa la tarea
solicitada.
Los métodos utilizados para el proceso del diseño se basan en el

conocido divide y vencerás. Es decir la resolución de un problema

complejo se realiza dividiendo el problema en sub-problemas y a

continuación dividir estos sub-problemas en otros de nivel más bajo,
hasta que sea implementada una solución en el computador. Este
método se conoce técnicamente como diseño descendente (top-down) o
modular.
Cada programa bien diseñado consta de un programa principal (el

módulo de nivel más alto) que llama a subprogramas (módulos) de nivel
más bajo, que a su vez pueden llamar a otros subprogramas.
Los módulos pueden ser planeados, codificados, comprobados y

depurados independientemente y luego ser combinados entre sí. Este
proceso implica la ejecución de estos pasos hasta que el programa se ha
terminado: programar un módulo, comprobarlo y depurarlo; además
combinar el módulo con los otros módulos.
El diseño del algoritmo es independiente del lenguaje de programación

en el que se vaya a codificar.
1.4.3 Codificación
Es la generación real del programa con un lenguaje de programación. En

esta etapa se hace uso de la lógica que se desarrolló en el paso del
diseño del algoritmo para generar el programa. Se debe seleccionar el
lenguaje apropiado para resolver el problema.
1.4.4 Implementación y depuración
Compilación y ejecución: Una vez que el algoritmo se ha convertido en

un programa fuente, es preciso introducirlo en memoria mediante el

teclado y almacenarlo posteriormente en un dispositivo de

almacenamiento. Esta operación se realiza con un editor de texto,
posteriormente el programa fuente se convierte en un archivo de
programa.
Figura 1-1 Esquema general de creación de un programa
El programa fuente debe ser traducido a lenguaje máquina. Este proceso

se realiza con el compilador y el sistema operativo que se encarga
prácticamente de la compilación. Si al compilar el programa fuente se
presentan errores (errores de compilación), es necesario volver a editar
el programa, corregir los errores y compilar de nuevo. Esto se repite
hasta que ya no se presenten más errores, obteniéndose el programa
objeto, el cual todavía no es ejecutable directamente. Al ya no existir
errores en el programa fuente se debe instruir al sistema operativo para
que efectúe la fase de montaje o enlace, del programa fuente con las
librerías del programa del compilador. Este proceso de montaje produce
un programa ejecutable.
Suponiendo que no existen errores durante la ejecución (errores en

tiempo de ejecución), se obtendrá la salida de resultados correctos del
programa.

1.4.5 Pruebas
Probar el programa consiste en verificar su funcionalidad a través de

varios métodos para detectar errores posibles.
1.4.5.1 Prueba de escritorio: El programador se

sienta frente a un escritorio y corrige una impresión del programa.
Revisa el listado línea por línea en busca de errores de sintaxis y lógica.
1.4.5.2 Prueba manual de datos de

muestra: Se corre el programa en forma manual aplicando datos
tanto correctos como incorrectos para comprobar que funciona
correctamente.
1.4.5.3 Prueba por un grupo selecto de

usuarios potenciales: Esto se conoce como prueba beta.
Se trata por lo general del paso final en la prueba de un programa.
Usuarios potenciales ponen a prueba el programa y ofrecen
retroalimentación.
Depurar es correr el programa en una computadora y corregir las partes

que no funcionan. En esta fase se comprueba el funcionamiento de cada
programa y esto se hace con datos reales o ficticios. Cuando los
programas están depurados, se prueban. Cuando los programas se
depuran, se pueden encontrar los siguientes errores:

Errores de sintaxis o de compilación
Son errores del programa fuente, puede deberse a palabras reservadas

del lenguaje mal escritas, expresiones erradas o incompletas, o variables
que no están definidas. Estos errores se detectan en la fase de
compilación. El compilador además de generar el código objeto genera
un reporte con los errores de sintaxis; el compilador sólo entrega ó el
reporte de errores ó el código objeto, puesto que no se puede generar el
objeto teniendo errores de sintaxis.
Errores de ejecución
se pueden presentar incluso luego de obtener un archivo ejecutable,

normalmente no se obtiene mensajes de error, sino que el programa se
termina de manera brusca, se deben generalmente a operaciones no
permitidas como dividir por cero, leer un dato no numérico en una
variable numérica, o exceder un rango de valores permitidos. Existen
programas auxiliares para detectar estos errores son los llamados
depuradores (Debuggers), estos permiten detener la ejecución de un
programa y ejecutarlos paso a paso, esto resulta útil para detectar
excepciones, errores sutiles y fallos que se presentan dependiendo de
distintas circunstancias.
Errores de diseño
Corresponden a la obtención de resultados que no son correctos y la

única manera de detectarlos es realizando suficientes pruebas del
programa. Son los más difíciles de corregir, no sólo por la dificultad de
detectarlos, sino porque se deben a la propia concepción y diseño del
programa, contra estos errores solo cabe replantear nuevamente el
algoritmo.

Errores de especificación
Es el peor tipo de error y el más difícil de corregir. Se deben a mal diseño

del programa posiblemente por mala comunicación usuario
programador y se detectan cuando ya se ha concluido el diseño e
instalación del programa, lo cual puede implicar repetir gran parte del
trabajo realizado.
1.4.6 Documentación del programa
Consiste en describir por escrito a nivel técnico los procedimientos

relacionados con el programa y su modo de uso. También se debe
documentar el programa para que sea más entendible.
Documentos que se elaboran:
1.4.6.1 Manual de usuario y manual del

analista: a los usuarios se les elabora un manual de referencia para
que aprendan a utilizar el programa. Esto se hace a través de
capacitaciones y revisión de la documentación del manual de usuario. El
manual del usuario no está escrito a nivel técnico sino al de los distintos
usuarios previstos y explica en detalle cómo usar el programa:
descripción de las tareas que realiza el programa, instrucciones
necesarias para su instalación puesta en marcha y funcionamiento,
recomendaciones de uso, menús de opciones, método de entrada y
salida de datos.
A los programadores a través del manual del analista para que recuerden
aspectos de la elaboración del programa o en caso que otras personas
puedan actualizarlo o modificarlo (darle mantenimiento) y no son

necesariamente las personas que lo diseñaron. Es por ello, que la

documentación debe contener algoritmos y diagramas de flujo de los
diferentes módulos que lo constituyen y las relaciones que se establecen
entre ellos; listados del programa, corridas, descripción de variables que
se emplean en cada módulo, cuáles son comunes a diferentes módulos y
cuáles locales; descripción de los ficheros de cada módulo y todo lo que
sea de importancia para un programador.
1.4.7 Mantenimiento del programa
Es el paso final del desarrollo del software. Alrededor del 75% del costo
total del ciclo de vida de un programa se destina al mantenimiento. El
propósito del mantenimiento es garantizar que los programas en uso
estén libres de errores de operación y sean eficientes y efectivos.
1.5 La lógica como aspecto

fundamental de la programación
Lógica es la capacidad de pensar racionalmente acerca de soluciones
alternativas y los resultados de aplicarlas, y por lo tanto, de hacer
elecciones inteligentes. La lógica es la encargada de determinar la validez
o invalidez de los argumentos; además permite proporcionar la
simbología que servirá para facilitar el desarrollo de la capacidad de
análisis de problemas, para obtener una solución posible.

1.5.1 Argumentos
Cuando el razonamiento se expresa con palabras, recibe el nombre de
"argumento". Un argumento es un grupo cualquiera de proposiciones o
enunciados que forman premisas y conclusiones. Este puede constar de
varias premisas pero de una sola conclusión.
1.5.2 Premisas y conclusión
Las premisas de un argumento son proposiciones afirmadas como

fundamento o razones para aceptar una conclusión. La conclusión es la
proposición afirmada que se basa en las otras proposiciones o premisas.
Una proposición puede ser premisa en un argumento y conclusión en
otro.
Ejemplo No 1:
“Todos los ángulos internos de un polígono suman (n-2)*180°” aparece

como premisa en el siguiente argumento:
“Todos los ángulos internos de un polígono suman (n-2)*180°”
“Las poligonales se deben ajustar”
“Por lo tanto, en todas las poligonales ajustadas la sumatoria de sus

ángulos internos es igual a (n-2)*180°”
Y como conclusión en el siguiente argumento:

“Todas las poligonales cerradas se deben ajustar”
“En un mismo vértice la suma de los ángulos interno y externo es igual a

360°”
“La sumatoria teórica de ángulos externos de una poligonal cerrada es
igual a (n+2)*180°”
“Por lo tanto, todos los ángulos internos de un polígono suman (n-
2)*180°”
Expresiones como “por tanto”, “por lo cual”, “de ello se deduce”, sirven
para introducir la conclusión de un argumento, en tanto que “pues” y
“porque” se usan para introducir las premisas.
Enunciado Simple: Es el que no contiene otro enunciado como parte

componente.
Ejemplo No 2:
"Los azimutes no pueden ser mayores a 360°"
Enunciado compuesto: Es el que se compone de varios enunciados.
Ejemplo No 3:
“Los azimutes no pueden ser mayores a 360° y las deflexiones no pueden

ser mayores que 180°”.

Cuando los enunciados se unen por la conjunción Y, se denominan

Enunciados conyuntos. Cuando se unen por el conector O, se denominan
enunciados disyuntos. De aquí surgen las tablas de verdad. (Tema que
será tratado en Operadores lógicos).
1.6 Tipos de datos

Los diferentes objetos de información con los que un programa trabaja
se denominan datos.
Todos los datos tienen un tipo asociado a ellos, que sirve para poder
conocer con qué tipo de información se va a trabajar.
Enteros
Reales
Simples Caracteres
Booleanos
Datos
Unidimensionales
Arreglos
Bidimensionales
Estructurados
Cadena de caracteres
Registros

1.6.1 Datos simples
Su principal característica es que ocupan solo una casilla de memoria,

por esto se hace referencia a un único valor a la vez, dentro de este
grupo se encuentran los enteros, reales, caracteres y booleanos.
1.6.1.1 Enteros
Es un subconjunto finito de los números, su característica principal es
que no tienen punto decimal, su rango depender del lenguaje en el que
se vaya a codificar el algoritmo. El rango depende de cuantos bits utilice
para codificar el número, normalmente 2 bytes, Para números positivos,
con 16 bits se pueden almacenar:
216= 65536 números enteros diferentes: de 0 al 65535, y de -32768 al

32767 para números con signo.
Ejemplo No 4:
2 , -152 , 14 , 1587 , -98
1.6.1.2 Reales
Estos números siempre tienen un punto decimal y pueden ser positivos o
negativos. Un número real consiste de un número entero y una parte
decimal.
Ejemplo No 5:
2.125 , -152. 587 , 14.0 , 158.7 , -98,002

1.6.1.3 Caracteres
Es un conjunto finito y ordenado de caracteres que el computador
reconoce. Un dato de este tipo contiene solo un carácter.
Ejemplo No 6:
Caracteres alfabéticos: (A,B,C,…Z, a,b,c…z)
Caracteres numéricos: (0,1,2,…9)
Caracteres especiales: (+, -, *, /, ^, . , ;, <, >, $, …….)
1.6.1.4 Cadenas
Es una sucesión de caracteres que se encuentran delimitados por una
comilla (apóstrofe). La longitud de una cadena de caracteres es el
número de ellos comprendidos entre los separadores o delimitadores,
por lo general en todos los lenguajes de programación la máxima
longitud que puede tomar una cadena es de 255 caracteres.
Ejemplo No 7:
‘Topografía’
‘Ingeniería Geomática’
‘7-46-01-48’

1.6.1.5 Datos lógicos

También se le denomina Booleano, es aquél dato que solo puede tomar
uno de dos valores: Falso o Verdadero.
Se utilizan para representar las alternativas (si/no) a determinadas

condiciones. Por ejemplo, cuando se pide si un valor entero es primo, la
respuesta será verdadera o falsa, según sea.
1.7 Identificadores, constantes,

variables y operadores
1.7.1 Identificadores
Todos los datos que procesa el computador, sean estos, simples o

estructurados, deben ser almacenados en celdas de memoria para su
utilización, estas celdas tienen un nombre que permite su identificación.
Un identificador se forma de acuerdo a las siguientes normas:
 El primer caracter debe ser una letra.
 Los demás caracteres pueden ser letras, dígitos ó el símbolo

especial:_

1.7.2 Constantes
Una constante es aquella que no cambia de valor durante la ejecución de

un programa. Existen tantos tipos de constantes como tipos de datos,
por lo tanto puede haber constantes de tipo entero, real, carácter, etc.
1.7.3 Variables
Son objetos que pueden cambiar su valor durante la ejecución del

programa. Al igual que las constantes, pueden existir tipos de variables
como tipos de datos.
1.7.4 Operadores
Un operador es el símbolo que determina el tipo de relación que habrá

de establecerse entre los operandos para alcanzar un resultado.
Los operadores pueden ser aritméticos, relacionales o lógicos.
1.7.4.1 Operadores aritméticos

Estos operadores permiten realizar operaciones aritméticas entre
operandos: números, constantes o variables, el resultado de una
operación aritmética siempre será un número.

Operador Operación Ejemplo Resultado

aritmético
** Potencia 2**8 256
* Multiplicación 8.15*5 40.75
/ División 45/10 4.5
+ Suma 12+7 19
- Resta 45.97-87.54 -41.57
mod Módulo 15 mod 2 1
div División entera 17 div 3 5
Tabla 1-1 Operadores aritméticos
Cuando se evalúan expresiones que contienen operadores aritméticos se

debe respetar su jerarquía, es importante señalar que el operador () es
asociativo y tiene la prioridad más alta en cualquier lenguaje de
programación.
Si una expresión contiene sub-expresiones entre paréntesis, estas se

evalúan primero, respetando la jerarquía de operadores en cada sub-
expresión. Si las sub-expresiones se encuentran anidadas por paréntesis
se evalúan primero las que estén en último nivel de anidamiento.

Operador Jerarquía Operación

aritmético
** (Mayor) Potencia
Multiplicación,
*, /, mod, div división, módulo,
división entera
+, - Suma, resta
(Menor)
Tabla 1-2 Jerarquía de operadores aritméticos
Si existen dos operadores con igual jerarquía dentro de una sub-

expresión se le da prioridad a aquel que esté más a la izquierda.
Ejemplo No 8:
a  10 / 2  7  68 15  33  45  2 / 16 / 3 / 15  1
a  10 / 2  7  68 15  33  2025 / 16 / 3 / 15  1
a  10 / 2  7  68 15  33  126.5625 / 3 / 15  1
a  10 / 2  7  68  495  126.5625 / 3 / 15  1
a  10 / 2  7  68  495  42.1875 / 15  1
a  10 / 2  7   427  42.1875 / 15  1
a  10 / 2  7  384.8125 / 15  1

a  10 / 2  7  25.6541  1
a  10 / 2  18.6541  1
a  5  18.6541  1
a  93.2705  1
a  92.2705
Ejemplo No 9:
b  7  2  160 mod 3  3  10div5 13  6
b  7  2  160 mod 27  10div5 13  6
b  7  2  25  10div5 13  6
b  14  25  10div5 13  6
b  350  10div5 13  6
b  350  2 13  6
b  350  26  6
b  376  6
b  370

1.7.4.2 Operadores relacionales

Son los que permiten comparar dos operandos, una característica
imprescindible de cualquier lenguaje de programación es la de
considerar alternativas, es decir, proceder de una determinada manera
si se cumplen o no las condiciones fijadas, con este tipo de operadores
se puede determinar si se cumplen o no dichas condiciones.
En un programa si una condición se cumple, el resultado es cierto; en

caso contrario, el resultado es falso. Un 0 representa la condición de
falso, y cualquier número distinto de 0 equivale a la condición cierto.
Operador Operación Ejemplo Resultado

relacional
= Igual que ‘azimut’ = “azimuth” Falso
<> Diferente a ‘angulo’ <> ‘distancia’ Verdadero
< Menor que 58 < 1 Falso
> Mayor que 38 > 10 Verdadero
<= Menor o igual que 15 <= 15 Verdadero
>= Mayor o igual que 5 >= 21 Falso
Tabla 1-3 – Operadores relacionales

Ejemplo No 10:
A  10 B  4
( A  5  B  2 / 2)  ( B  2div 2)
( A  5  100 / 2)  ( B  2div 2)
( A  5  50)  ( B  2div 2)
(50  50)  ( B  2div 2)
100  ( B  2div 2)
100  (16div 2)
100  4
Falso
1.7.4.3 Operadores lógicos

Son operadores binarios que permiten combinar los resultados de los
operadores relacionales comprobando que se cumplan las condiciones
necesarias.
Los operadores son de conjunción (y), disyunción (o), y negación (no)

Operador Jerarquía Expresión lógica Significado

lógico
(Mayor)
No No P No es cierto que P
Y PyQ P sin embargo Q
O (Menor) PoQ o P o Q o ambas
Tabla 1-4 Jerarquía de operadores lógicos
P Q ̃P ̃Q PoQ P^Q
Verdadero Verdadero Falso Falso Verdadero Verdadero
Verdadero Falso Falso Verdadero Verdadero Falso
Falso Verdadero Verdadero Falso Verdadero Falso
Falso Falso Verdadero Verdadero Falso Falso
Tabla 1-5 Tabla de verdad de los operadores lógicos
O: el resultado es verdadero si al menos una de las dos conjunciones es

verdadera.
Y: para que el resultado sea verdadero, las dos condiciones deben ser
verdaderas.

Operadores Jerarquía
() (Mayor)
**
*, /, div, mod
=, <>, <, >, <=, >=
No
O (Menor)
Tabla 1-6 Tabla de verdad jerarquía de todos los operadores (aritméticos, relacionales y lógicos)
Nota: El operador () es de tipo asociativo que tiene la prioridad más alta

en cualquier lenguaje de programación.
1.7.5 Asignaciones
Las asignaciones son acciones que permiten darle o asignarle a una

variable un valor determinado, la asignación es una operación de tipo
destructivo, significa que si la variable tenía asignado un valor, este se
destruye consignando ahora el nuevo valor. Los valores asignados a la
variable deben ser del mismo tipo de la variable.
En una asignación se resuelve primero la expresión (lado derecho del

símbolo de asignación), y se almacena el resultado en la variable.
Formato de la asignación:

Variable  expresión o valor
Donde la expresión puede ser aritmética o lógica, o una constante o

variable.
A una variable le puede ser asignado:
 El valor de otra variable

 Un valor constante
 El resultado de evaluar una expresión que pueda contener otras
variables.
Ejemplo No 11:
Variables
I, TOPO, J : entero
DIR, INV : real
CAR : caracter
BAND : booleano
1. I0
2. I  I+1
3. TOPO  0
4. J  5**2 div 3
5. CAR  ‘a’
6. TOPO  J div I
7. DIR  TOPO/3
8. BAND  (8>5) y (15<2**3)
9. INV  TOPO*5/J**2
10. I  I*3
11. DIR  DIR/5
12. BAND  BAND o (I=J)
13. I  DIR
14. CAR  J

Número de I J TOPO DIR INV CAR BAND

asignación
1 0
2 1
3 0
4 8
5 a
6 8
7 2.66
8 Falso
9 0.625
10 3
11 0.532
12 Falso
13 Error
14 Error
Tabla 1-7 Valores en memoria – proceso de asignación

1.8 Técnicas de representación de

algoritmos
1.8.1 Descripción narrada
Este algoritmo se caracteriza porque sigue un proceso de ejecución

común y lógico, describiendo textualmente paso a paso cada una de las
actividades a realizar dentro de una actividad determinada.
Ejemplo No 12:
Nombre del algoritmo: Reiteraciones
Descripción: Protocolo para la medición de un ángulo

por reiteración (entre dos señales) tres
veces, (tres posiciones)
Autor: GGG - GJC - JGB
Fecha: Marzo 2007
Pasos:
1 - Visar la señal de la izquierda y colocar en el limbo 00° 00' +

una lectura en segundos superior a cero.
2 - Barrer el ángulo en sentido horario, puntear la segunda señal

y registrar en cartera el valor leído en el círculo horizontal.

3 - Transitar, volver a puntear la misma señal, registrar en cartera

el valor que se lee en el círculo (debe diferir en 180° con el valor
leído en el paso 2.)
4 - Barrer el ángulo en sentido contra-horario hasta la primera

señal, puntearla y registrar la lectura del círculo. {Hasta este punto
el ángulo se ha medido dos veces, una en directa y sentido horario, otra
en inversa y sentido contra-horario.}
5 - Estando el instrumento punteando la señal de la izquierda en
posición inversa, colocar en el círculo el valor correspondiente al
2do. origen (en inversa) de manera que al transitar el instrumento
quede en posición directa, y en el círculo pueda leerse
directamente el origen correspondiente.
6 - Barrer el ángulo en sentido horario hasta la segunda señal,

puntearla y registrar la lectura correspondiente.
7 - Transitar, volver a visar la segunda señal, registrar la lectura.
8 - Barrer el ángulo en sentido contra-horario hasta la primera

señal, puntearla y registrar la lectura correspondiente.{ En este
punto se han hecho dos posiciones del ángulo, es decir se ha medido
dos veces en sentido horario y dos en sentido contra-horario, tanto en
directa como en inversa. }
{Para iniciar la tercera posición:}
9 – Igual al numeral uno pero teniendo en el círculo horizontal

como origen el valor de 120° (tabla 1-8), y continuar con el
procedimiento mencionado. {El procedimiento descrito se repite
hasta completar el número de posiciones requerido (mínimo dos), debe
notarse que 1a., 3a., 5a., etc. empiezan en directa y 2a., 4a. etc.
empiezan en inversa.}

Tel D I D I D I
2 00° 270° (90°)
3 00° 240° (60°) 120°
4 00° 225° (45°) 90° 315° 135°)
5 00° 216° (36°) 72° 288°(108°) 144°
6 00° 210° (30°) 60° 270° (90°) 120° 330°(150°)
Tabla 1-8 – Orígenes para reiteraciones
1.8.2 Diagramas de flujo
Es una representación gráfica del flujo lógico de datos que se utilizarán

en la formulación de un problema como ayuda en el desarrollo de un
algoritmo. Un diagrama de flujo es útil para determinar cómo funciona el
proceso para producir un resultado. Su correcta construcción es de gran
importancia porque a partir del mismo se escribe un programa en algún
lenguaje de programación. Si el diagrama de flujo está completo y
correcto, el paso del mismo a un lenguaje de programación es
relativamente simple y directo.
1.8.2.1 Inicio – Fin

Es un símbolo utilizado para indicar el comienzo o el punto final del
diagrama.
Figura 1-2 Inicio - Fin (Diagrama de flujo)

1.8.2.2 Entrada
Se utiliza para introducir datos de entrada. Expresa lectura.
Figura 1-3 Entrada (Diagrama de flujo)
1.8.2.3 Proceso
Representa cualquier serie de transferencia de datos u operaciones
aritméticas internas del computador. En su interior se expresan
asignaciones.
Figura 1-4 Proceso (Diagrama de flujo)
1.8.2.4 Decisión
Sirve para verificar el resultado de una expresión, en su interior se
almacena una condición, y dependiendo del resultado de evaluación de
la misma se sigue solo por uno de los caminos alternativos. Este símbolo
se utiliza en la estructura selectiva si entonces y en las estructuras
repetitivas repetir y mientras.

No
Si
Figura 1-5 Decisión (Diagrama de flujo)
1.8.2.5 Decisión doble

Símbolo utilizado para representar la estructura selectiva doble si
entonces/sino. En su interior se almacena una condición. Si el resultado
es verdadero se continúa por el camino de la izquierda, y si es falso por
el camino de la derecha.
Si No
Figura 1-6 Decisión doble (Diagrama de flujo)
1.8.2.6 Decisión múltiple

En su interior se almacena un selector, y dependiendo del valor de dicho
selector se sigue por una de las ramas o caminos alternativos. Este
símbolo se utiliza en la estructura selectiva si múltiple.

Figura 1-7 Decisión múltiple (Diagrama de flujo)
1.8.2.7 Salida
Símbolo utilizado para representar la impresión de un resultado. Expresa
escritura.
Figura 1-8 Salida (Diagrama de flujo)
1.8.2.8 Flujos
Son utilizadas para representar el progreso de los pasos en la secuencia;
la punta de la flecha indica la dirección del flujo del proceso.
Figura 1-9 Flujos (Diagrama de flujo)

1.8.2.9 Conector
Es un punto de referencia que indica donde debe continuar el diagrama
de flujo. Se utiliza para indicar un cambio en el flujo normal de datos
dentro de una misma página.
Figura 1-10 Conector (Diagrama de flujo)
1.8.2.10 Conector
Es un punto de referencia que se usa como conexión entre páginas
diferentes.
Figura 1-11 Conector páginas diferentes (Diagrama de flujo)
1.8.2.11 Procedimiento
Este símbolo sustituye a todo un sub-programa. Para continuar con el
flujo normal del programa se debe resolver el sub-problema que se
enuncia en su interior.
Figura 1-12 Procedimiento (Diagrama de flujo)

1.8.3 Método para construir un

diagrama de flujo
1. Propósito: Analizar cómo se pretende utilizar el diagrama de

flujo.
2. Determinar el nivel de detalle requerido.
3. Definir los límites del proceso, y enumerar los resultados.
4. Utilizar los símbolos apropiados para el diagrama de flujo.
5. Hacer preguntas como:
 Qué produce este paso?
 Quién recibe éste resultado?
 Algunos de los pasos requieren entradas que no se han

realizado?
6. Documentar cada paso de la secuencia del algoritmo.
7. Revisar todo el diagrama, fijándose que todos los flujos de

información encajen en las entradas y salidas del proceso. El
diagrama debe mostrar la forma exacta de lo que se desea que
ocurra.

1.8.4 Reglas para construir un diagrama

de flujo
1. Todo diagrama de flujo debe tener un inicio y un fin.
Inicio
Fin
Figura 1-13 Inicio – fin
2. Las líneas utilizadas para indicar la dirección del flujo del

diagrama deben ser rectas, verticales y horizontales.
No deben ser inclinadas
No se deben cruzar
Figura 1-14 Dirección de flujos

3. Todas las líneas utilizadas para indicar la dirección del flujo del
diagrama deben estar conectadas. La conexión puede ser a un
símbolo que exprese lectura, proceso, decisión, conexión,
impresión o fin de diagrama.
Figura 1-15 Conexiones
4. Cada símbolo significa un tipo de operación
 Entrada/Salida
 Proceso
 Decisión
 Transferencia
 Final.
5. La notación utilizada en el diagrama de flujo debe ser

independiente del lenguaje de programación.
Los diagramas de flujo se leen de arriba hacia abajo y de izquierda a

derecha.

Una secuencia de operaciones se ejecuta hasta que un símbolo terminal

muestra el final de la ejecución del proceso o un conector de bifurcación
transfiere el control a otro punto del programa.
Ejemplo No 13:
Construir el diagrama de flujo para un algoritmo donde dada una

magnitud angular como dato, imprimir “posible” si es menor que 360° e
“imposible” si es mayor.
Inicio
Magnitud angular
Magnitud No Imposible
Angular
<360º
Si
Posible
Fin

Ejemplo No 14:
Dibujar un diagrama de flujo con el que se pueda representar el trabajo

necesario (campo y oficina) para determinar si se puede o no ajustar una
poligonal.
Inicio
Trabajo de campo
Medición ángulos,
distancias (campo)
No
Error
Angular
aceptable
Si
GP. No
aceptable
Si
Ajuste poligonal
Datos ajustados
Fin

Ejemplo No 15:
Dados los datos A, B y C que representan números enteros diferentes,

construir un algoritmo para escribir estos números en forma ascendente.
Este es un ejemplo de los algoritmos conocidos como de Lógica Pura, ya
que poseen muchas decisiones y muchas bifurcaciones.
Salidas: A, B y C ordenados ascendentemente.

Entradas: A, B y C.
La dinámica del problema es comparar dos números a la vez
Inicio para conocer cuál es el mayor.
A,B,C
Si Si
A>B B>C A,B,C
No No
Si Si
A>C B,A,C A>C A,C,B
No No
Si C,A,B
B>C B,C,A
No
C,B,A
Fin

1.8.5 Seudocódigo
Seudo significa falso, por lo que se considera que seudocódigo no es

realmente un código sino una versión abreviada de instrucciones reales
para los computadores.
Se considera un primer borrador, dado que el seudocódigo tiene que

traducirse a un lenguaje de programación.
Esta técnica es para diseño de programas y permite definir las

estructuras de datos, las operaciones que se aplicarán a los datos y la
lógica que tendrá el programa para solucionar un determinado
problema. Lo ideal es utilizar un seudo-lenguaje muy parecido a nuestro
idioma, pero que respeta las directrices y los elementos de los lenguajes
de programación.
La ventaja del seudocódigo es que su uso en la planificación de un

programa, el programador se puede concentrar en la lógica y en las
estructuras de control y no preocuparse de las reglas de un lenguaje
específico.
Ejemplo No 16:
/*
Cod: T-001
Nombre: area_triangulo
Fecha: marzo 2007
Programador: JGB - GJC
Lenguaje: seudocodigo (SLE2)
Descripcion: calcula el área de un triángulo rectángulo,

teniendo como datos de entrada la base y la
altura.
*/

variables base: numerico

altura: numerico
area: numerico
inicio
imprimir("\n Entre la base: ")

leer (base)
imprimir("\n Entre la altura: ")

leer (altura)
area=(base*altura)/2
imprimir ("\n El area del tringulo es: ", area)
fin
Ejemplo No 17:
/*
Cod: T-002
Nombre: area_triangulo_heron
Fecha: marzo 2007
Descripcion: calcula el área de un triángulo, teniendo

como datos de entrada sus tres lados.
*/
variables
L1: numerico // lado 1
S: numerico // semiperimetro
area: numerico // area

inicio
cls()
imprimir("\n Entre el lado 1: ")

leer (L1)

leer (L2)

leer (L3)
area = sqrt(S*(S-L1)*(S-L2)*(S-L3))
imprimir ("\n El area del trinagulo es: ", area)
fin
Ejemplo No 18:
/*
Cod: T-003
Nombre: distancia_entre_dos_puntos
Fecha: marzo 2007
Descripcion: calcula la distancia horizontal entre

dos puntos, teniendo como datos de entrada
sus coordenadas Norte y Este.
*/
variables
N1: numerico // Norte punto 1
E1: numerico // Este punto 1
N2: numerico // Norte punto 2
E2: numerico // Este punto 2
d: numerico // distancia

inicio
cls()
imprimir("\n Entre la Norte del punto 1: ")

leer (N1)
imprimir("\n Entre la Este del punto 1: ")

leer (E1)
imprimir("\n Entre la Norte del punto 2: ")

leer (N2)
imprimir("\n Entre la Este del punto 2: ")

leer (E2)
d = sqrt(((E2-E1)^2)+((N2-N1)^2))
imprimir ("\n La distancia horizontal es: ", d)
fin
Ejemplo No 19:
/*
Cod: T-004
Nombre: proyecciones
Fecha: marzo 2007
Descripcion: calcula las proyecciones meridiana y

paralela teniendo como datos de
entrada el azimut y la distancia de
un punto a otro.
*/
variables
angulo : numerico
grados : numerico
minutos : numerico

segundos : numerico
angulo_radianes: numerico
pm : numerico // proyeccion meridiana
pp : numerico // proyeccion paralela
dh : numerico // distancia horizontal
constantes
PI = 3.141592654
inicio
cls()
imprimir("\n Entre el angulo con formato GG.MMSS : ")

leer (angulo)
imprimir("\n Entre la distancia horizontal : ")

leer (dh)
grados = int(angulo)
minutos = (int((angulo-int(angulo))*100))/60
segundos = ((angulo*100-(int(angulo*100)))*100)/3600
angulo_radianes = (grados+minutos+segundos)*PI/180
pm = dh*cos(angulo_radianes)
pp = dh*sin(angulo_radianes)
imprimir ("\n\n PM: ",pm ,"\t PP: ",pp)
fin

1.9 Ejercicios propuestos

1. Realice la siguiente asignación teniendo en cuenta la jerarquía de
operadores
a  10 /(5  (((54 mod 4) **2) / 2) / 2)  78div 2  (4  7 mod 4))
2. Encuentre el resultado del operador relacional luego de procesar

la siguiente información:
A = 2 ; B = -2 ; C = 4
( A  A  5  B  21 / 2)  ( B  (12div 2)  4  C mod 7)
3. Realice la tabla de asignación correspondiente al siguiente

algoritmo para cada una de las variables.
Variables
I, CONT, J : entero
POS1, POS2 : real
TEXT : caracter
BAND : booleano
1. I0
2. I  I+4 mod 3
3. CONT  4
4. J  5**2 div 3
5. TEXT  ‘topo’
6. POS1  J div I
7. POS2 J/3
8. CONT  (84>5) o (15<2**3)

9. I  POS2*5/J**2
10. I  I*3
11. CONT  POS1+POS2/5
12. BAND  BAND o (I=J)
13. I  CONT
14. TEXT  J
4. Desarrolle un algoritmo en seudocódigo que calcule el punto de

cero, teniendo como datos de entrada la altura de corte, de
lleno, y la distancia entre dichas alturas.
5. Dado un ángulo en grados, minutos y segundos, dibuje un

diagrama de flujo que permita convertir dicho ángulo a radianes.
6. Realice un diagrama de flujo que permita calcular la distancia

horizontal por el método exacto y el aproximado, teniendo como
datos de entrada la distancia geométrica y la diferencia de nivel
entre los dos puntos en cuestión.
7. Realice un algoritmo mediante descripción narrada que muestre

el protocolo para medir un ángulo por reiteración.
8. Dibuje un diagrama de flujo que permita calcular la distancia

horizontal teniendo como datos de entrada HS, HM, lectura del
círculo vertical, y K.
9. Desarrolle un algoritmo en seudocódigo que permita calcular las

coordenadas de un punto teniendo como datos de entrada la
distancia inclinada y la lectura de los círculos horizontal y vertical.
10. Dibuje un diagrama de flujo que permita conocer el rumbo de

una línea si se tiene como dato de entrada el azimut de la misma.

Capítulo 2
Estructuras
algorítmicas de
selección
Objetivo general:
Evaluar una o más condiciones que permitan una serie de acciones que se deben
cumplir en el momento de tomar una decisión.
 Identificar las diferencias entre las tres estructuras básicas de decisión.
 Utilizar las estructuras de decisión para solucionar problemas algorítmicos.
53
Tabla de contenido
2. Estructuras algorítmicas de selección ........................... 57

2.1 Introducción ...................................................................... 57
2.2 Estructura selectiva simple si entonces ............................. 58
2.3 Estructura selectiva doble si entonces / sino ..................... 60
2.4 Estructura selectiva múltiple si múltiple ........................... 63
2.5 Estructuras selectivas anidadas ........................................ 65


2. Estructuras
algorítmicas de
selección
2.1 Introducción
La especificación formal de algoritmos tiene utilidad cuando el algoritmo
requiere una descripción más complicada que una lista sencilla de
instrucciones. Este es el caso cuando existen un número de posibles
alternativas resultantes de la evaluación de una determinada condición
llamadas estructuras lógicas selectivas, esta toma de decisiones se basa
en la evaluación de una o más condiciones que señalarán el camino a
tomar. Hay situaciones en las que dicho camino se realiza en cascada; es
decir se toma una decisión, se marca el camino a seguir, se vuele a tomar
otra decisión y así sucesivamente, por este motivo para lograr la solución
de un problema se debe aplicar un árbol de decisión.
Las estructuras algorítmicas selectivas para la toma de decisiones son:
 SI ENTONCES (estructura selectiva simple)

 SI ENTONCES / SINO (estructura selectiva doble)
 SI MULTIPLE (estructura selectiva múltiple)

Cuando se aplican estructuras selectivas en cascada se pueden utilizar

combinaciones entre las estructuras señaladas.
2.2 Estructura selectiva simple si

entonces
Se identifica porque está compuesta solo de una condición, 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 hace nada.
No
Condición
Si
Acción
Figura 2-1 Estructura selectiva si entonces
Donde:
Condición expresa la condición a evaluar.
Acción expresa la acción o el conjunto de ellas que se debe realizar si la

condición resulta verdadera.

Ejemplo No 20:
/*
Cod: T-005
Nombre: azimut
Fecha: marzo 2007
Descripcion: ejemplo de estructura de decisión

simple si-entonces.
*/
variables
azimut: numerico
inicio
cls()
imprimir ("\n Entre el azimut: ")

leer (azimut)
si (azimut<=360)
{
imprimir ("\n se encuentra en el rango permitido")
}
fin
Representación en diagrama de flujo:

Inicio
azimut
Azimut<360 No
Si
Se encuentra en el
rango permitido
Fin
Figura 2-2 Diagrama de flujo selección simple
2.3 Estructura selectiva doble si

entonces / sino
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.
Si No
Condición
Acción1 Acción2
Figura 2-3 Estructura selectiva si entonces/ sino

Donde:
Condición expresa la condición a evaluar.
Acción1 expresa la acción o el conjunto de ellas que se debe realizar si la

condición resulta verdadera.
Acción2 expresa la acción o el conjunto de ellas que se debe realizar si la

condición resulta falsa.
Ejemplo No 21:
/*
Cod: T-006
Nombre: azimut_2
Fecha: marzo 2007

simple si-entonces / sino
*/
variables
azimut: numerico
inicio
cls()
imprimir ("\n Entre el azimut: ")

leer (azimut)
si (azimut<=360)
{
imprimir ("\n se encuentra en el rango permitido")

sino
imprimir ("\n el valor se encuentra por fuera del
rango")
}
fin
Representación en diagrama de flujo del ejemplo No 21:
Inicio
azimut
Si No
Azimut<360
Se encuentra en Se encuentra
el rango fuera del rango
permitido
Fin
Figura 2-4 Estructura selectiva doble

2.4 Estructura selectiva múltiple si

múltiple
Con frecuencia es necesario que existan más de dos elecciones posibles.
Este problema se puede resolver por estructuras selectivas simples o
dobles, anidadas, pero si el número de alternativas es grande puede
plantear serios problemas de escritura.
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, se continuará con el
flujo normal del diagrama realizándose la acción N+1
Selector
Valor 1 Valor 2 Valor 3 (de otra forma)

Acción 1 Acción 2 Acción N
Acción N+1
Figura 2-5 Estructura selectiva si múltiple

Donde:
Selector es la variable o expresión a evaluarse, y según la cual se tomará

una de las múltiples decisiones.
Acción 1 expresa la operación o conjunto de operaciones que se van a

realizar si el selector toma el Valor 1.
Acción 2 expresa la operación o conjunto de operaciones que se van a

realizar si el selector toma el Valor 2.
Acción N expresa la operación o conjunto de operaciones que se van a

realizar si el selector toma el Valor N.
Acción N+1 expresa la operación que se va a realizar cuando se continúe

con el flujo normal del diagrama.
Ejemplo No 22:
/*
Cod: T-007
Nombre: rumbo
Fecha: marzo 2007

si_multiple. Calcula el azimut de
una línea teniendo como dato de
entrada el rumbo de la misma
*/
Variables
azimut: numerico
rumbo: numerico
opcion: numerico

inicio
cls()
imprimir ("\nElija el número de la opción \n\n1.N-E (cuandrante 1)

\n\n 2.S-E (cuadrante 2) \n\n 3.S-W (cuadrante 3) \n\n 4.N-W
(cuadrante 4) \n\n Opcion? ")
leer (opcion)
eval
{
caso(opcion==1)
imprimir("\n Ingrese el valor del rumbo (NE): ")
leer (rumbo)
azimut=rumbo
imprimir("\n\n El valor del azimut es: ",azimut)
caso(opcion==2)
imprimir("\n Ingrese el valor del rumbo (SE): ")
leer (rumbo)
azimut=180-rumbo
caso(opcion==3)
imprimir("\n Ingrese el valor del rumbo (SW): ")
leer (rumbo)
azimut=180+rumbo
caso(opcion==4)
imprimir("\n Ingrese el valor del rumbo (NW): ")
leer (rumbo)
azimut=360-rumbo
sino
imprimir("\n Opcion errada...")
}
Fin
2.5 Estructuras selectivas anidadas

En el desarrollo de la solución de problemas mediante algoritmos, luego
de tomar una decisión y marcar el camino a seguir, es necesario tomar
otra decisión. Se señala el nuevo camino a seguir luego de evaluar la

condición, y nuevamente se debe tomar otra decisión. Este proceso

puede repetirse numerosas veces; en este caso para resolver el
problema, se están aplicando estructuras selectivas anidadas o también
llamadas en cascada. Estas estructuras no son más que la combinación
de las estructuras ya vistas.
Si No
Condicion1
No
Selector
Condicion5
Si
Valor1 valor2 De otra forma
No Si No
Acción21 Acción 51
Condicion3 Condicion4
Si
Acción31 Acción41 Acción42
Figura 2-6 Estructuras selectivas anidadas
Expresando el anterior diagrama de flujo en seudocódigo se tiene que:

.
.
.
Si condición1
entonces
Si selector1 igual
Valor1: Hacer acción21
Valor2:
Si condicion3 entonces
Hacer acción31
{ fin condicional si }
De otra forma:
Si condición4
entonces
Hacer acción41
sino
Hacer acción42
{ fin condicional si}
sino
si condición5 entonces
Hacer acción51
.
.
.
Ejemplo No 23:
Dibujar un diagrama de flujo y su equivalente en seudocódigo que

permita determinar si un número, es positivo, negativo o nulo, teniendo
como dato de entrada un número entero.

Inicio
Num
Si No
Num=0
Nulo Si No
Num>0
Positivo Negativo
Fin
Figura 2-7 Estructura selectiva anidada
/*
Cod: T-008
Nombre: nulo_positivo_negativo
Fecha: abril 2007

anidadas. determina si un numero es
nulo, positivo o negativo.
*/

variables num: numerico
inicio
cls()
imprimir ("\n Entre un número entero: ")

leer (num)
si (num==0)
{
imprimir ("\n El número es cero")
sino
si (num>0)
{
imprimir ("\n El número es positivo")
sino
imprimir ("\n El número es negativo")
}
}
fin
Ejemplo No 24:
Dado un número entero, escriba en seudocódigo, un algoritmo para

determinar si es par, impar o nulo; además de determinar cuántos
dígitos tiene.
/*
Cod: T-009
Nombre: nulo_positivo_negativo_2
Fecha: abril 2007

anidadas. Determina si un número es
nulo, positivo o negativo, y cuenta
el numero de dígitos que tiene.
*/

variables
entero: numerico // numero entrado por el usuario
inicio
imprimir ("\n Entre un numero: ")

leer (entero)
si(entero>0)
{
si(entero>=1 and entero<=9)
{
imprimir("\n El numero es positivo, y tiene una
cifra")
}
si (entero>=10 and entero<=99)
{
imprimir("\n El numero es positivo, y
tiene dos cifras")
}
}
si (entero<0)
{
si(entero>=-9 and entero<=-1)
{
imprimir("\n El numero es negativo y tiene una
cifra")
}
si (entero>=-99 and entero<=-10)
{
imprimir("\n El numero es negativo y
tiene dos cifras")
}
}
si(entero==0)
{
imprimir("\n El numero es cero")
}
fin

Ejemplo No 25:
Dado un número entero A, diseñe un diagrama de flujo y su equivalente

en seudocódigo, para determinar si es par, impar o nulo.
Inicio
Si No
A=0
Nulo Si No
-1**A > 0
Par Impar
Fin
Figura 2-8 Estructura selectiva anidada
/*
Cod: T-010
Nombre: nulo_par_impar
Fecha: abril 2007

anidadas. Determina si un número es
nulo, par o impar.
*/

variables
num: numerico
inicio
cls()
imprimir ("\n Entre un número entero: ")

leer (num)
si (num==0)
{
imprimir ("\n El número es neutro")
sino
si ((-1)^num>0) // ... otra opción sería con
el módulo de la división: si
(num%2==0)
{
imprimir ("\n El número es par")
sino
imprimir ("\n El número es impar")
}
}
fin
Ejemplo No 26:
Realice en seudocódigo un programa que calcule el rumbo de una línea y

la distancia entre sus extremos, teniendo como datos de entrada las
coordenadas de los extremos de la línea.
/*
Cod: T-011
Nombre: rumbo_distancia
Fecha: abril 2007
Descripción: programa que calcula el rumbo de una línea

y la distancia entre sus extremos, teniendo
como datos de entrada las coordenadas de los
extremos de la línea.
*/

constantes
PI: 3.14159265358979
variables
N1, N2, E1, E2, DH, RBO: numerico

aux, grados, minutos, segundos: numerico
inicio
cls()
/* Entrada de coordenadas */
imprimir ("\n N1= ")

leer (N1)
imprimir ("\n E1= ")

leer (E1)
imprimir ("\n N2= ")

leer (N2)
imprimir ("\n E2= ")

leer (E2)
/* Cálculo de distancia horizontal */
DH=sqrt((N2-N1)^2+(E2-E1)^2)
/* Cálculo del rumbo */
si (E2-E1==0 and N2>N1)

{
imprimir ("\n\n El rumbo es Norte")
imprimir ("\n\n La distancia horizontal es: ", DH)
terminar()
sino
si(E2-E1==0 and N2<N1)
{
imprimir("\n\n El rumbo es
Sur")
imprimir ("\n\n La distancia
horizontal es: ", DH)
terminar()
sino
si(N2-N1==0 and E2>E1)
{

imprimir("\n\n El Rumbo es
Este")
imprimir ("\n\n La distancia
horizontal es: ", DH)
terminar()
sino
si (N2-N1==0and E2<E1)
{
imprimir("\n\nEl rumbo
es Oeste")
imprimir ("\n\n La
distancia horizontal
es: ", DH)
terminar()
}
}
}
}
si (N2-N1>0)
{
imprimir("\n\n El rumbo de la línea es: ")
imprimir ("\r N ")
sino
imprimir ("\r S")
}
RBO = arctan((E2-E1)/(N2-N1))
aux=abs(RBO)*(180/PI) //valor del rumbo en radianes almacenado en

la variable aux
/* Proceso que convierte el valor en radianes a una magnitud angular */
grados=int(aux)
minutos=int((aux-grados)*60)
segundos=(((aux-grados)*60)-(int((aux-grados)*60)))*60
/* Esta estructura permite hacer el redondeo de los segundos */
si (segundos-int(segundos)>=0.50)
{
segundos=int(segundos)+1
sino
segundos=int(segundos)
}

imprimir(grados,"\rº")
imprimir(minutos,"\r'")
imprimir(segundos,"\r''")
si (E2-E1>0)
{
imprimir ("\rE")
sino
imprimir ("\r W")
}
imprimir ("\n\n La distancia horizontal es: ", DH)
fin
1. Realice un programa en seudocódigo que permita calcular las

proyecciones meridiana y paralela, y la distancia horizontal a
partir de los datos de lectura taquimétrica.
2. Elabore un algoritmo que calcule la cota de un punto mediante

nivelación taquimétrica, y que tenga como datos de entrada:
altura instrumental, HS, HM, HI, y lectura del ángulo cenital. Se
bebe tener en cuenta que: si al momento de registrar el ángulo
cenital no se pudo proyectar la altura instrumental con el hilo
medio [por un obstáculo en la visual], se debe aplicar la
corrección al ángulo α =[(T-O) cos α’]/D* sen 1”; donde D es la
distancia inclinada, T es la altura del instrumento, y O es la altura
del punto visado.
3. Escriba un programa que haga una conversión de azimut a

rumbo.

4. Dibuje un diagrama de flujo que permita calcular las coordenadas

de N número de puntos en un levantamiento radial, teniendo
como datos de entrada azimut y distancia horizontal.
5. Realice un algoritmo en seudocódigo que permita hacer

conversión de ángulos horarios en deflexiones.
6. Elabore un algoritmo que permita calcular las coordenadas de los

vértices de una poligonal abierta, teniendo como datos de
entrada deflexión y distancia horizontal.

Capítulo 3
Estructuras
algorítmicas de
repetición
Objetivo general:
Utilizar una estructura para hacer que una parte el código se repita un número finito
de veces ahorrando tiempo y líneas de código.
 Identificar los ciclos como un elemento fundamental de la programación

estructurada.
 Proponer estructuras cíclicas a soluciones que tengan líneas de código que se

repiten una y otra vez.
77
Tabla de contenido
3. Estructuras algorítmicas de repetición ......................... 81

3.1 Introducción ..................................................................... 81
3.2 Estructura Mientras .......................................................... 82
3.2.1 Ciclo Mientras .......................................................................... 82
3.2.2 Ejecución de un bucle cero veces ............................................ 83
3.2.3 Bucles infinitos ......................................................................... 84
3.2.4 Terminación de bucles con datos de entrada ......................... 84
3.3 Estructura repetir ............................................................. 84
3.3.1 Ciclo Repetir ............................................................................. 85
3.4 Estructura Desde .............................................................. 87
3.4.1 Ciclo Desde............................................................................... 87
3.5 Estructuras repetitivas anidadas ....................................... 91


3. Estructuras
algorítmicas de
repetición
3.1 Introducción
El diseño de los computadores está hecho especialmente para aquellas
aplicaciones en las que una operación o conjunto de operaciones deben
repetirse muchas veces.
Las estructuras repetitivas se utilizan cuando se quiere que un conjunto

de instrucciones se ejecuten un cierto número finito de veces.
Las estructuras que repiten una secuencia de instrucciones un número

determinado de veces se denominan bucles y, al hecho de repetir la
ejecución de una secuencia de acciones se denomina iteración.

3.2 Estructura Mientras

Esta estructura repetitiva mientras, es en la que el cuerpo del bucle se
repite cuando se cumple una determinada condición.
Los ciclos son estructuras de control que permiten ejecutar varias veces
una operación. Existen varios tipos de ciclos:
3.2.1 Ciclo Mientras

En este ciclo se repite una operación, mientras se cumpla una cierta
condición.
No
Condicion1
Si
Acción1
Figura 3-1 Estructura repetitiva Mientras
Ejemplo No 27:
Realice en seudocódigo un programa que permita mediante la estructura

de repetición mientras el ingreso a un sistema o negarlo.

/*
Cod: T-012
Nombre: mientras
Fecha: abril 2007
Descripcion: ejemplo de estructura de repetición mientras
*/
variables clave: cadena
geomatica: cadena
inicio
cls()
imprimir ("\n Por favor ingrese la calve de acceso ")

leer (clave)
mientras (clave <> "geomatica")

{
imprimir ("\n La clave es
incorrecta....ACCESO DENEGADO")
terminar()
}
imprimir("\n La calve es válida...puede ingresar al sistema !!")
fin
3.2.2 Ejecución de un bucle cero veces
Si se observa en una estructura mientras, lo primero que se da es la

evaluación de una expresión booleana. Si es falsa, entonces las acciones
del bucle no se ejecutan nunca. Esta acción puede parecer inútil,
afectará a ningún valor o salida. Sin embargo puede ser la acción
deseada.

3.2.3 Bucles infinitos
En algunas ocasiones los bucles no exigen final y en otras, no tienen fin

por errores en su diseño. Los programas o bucles correrán siempre o
mientras la máquina esté encendida, e incluso habrán situaciones en las
que nunca se cumpla la condición, eso significa que el bucle no se
detendrá nunca. A estos bucles se les llama bucles sin fin o infinito, y por
su condición deben evitarse siempre, por que afectan en forma
perjudicial a la programación.
3.2.4 Terminación de bucles con datos

de entrada
Si un algoritmo lee una lista de valores con un bucle mientras, se debe

incluir algún tipo de mecanismo para terminar el bucle. Para llevar esto a
cabo, existen cuatro métodos típicos para terminar un bucle de entrada:
1. Preguntas antes de la iteración

2. Encabezar la lista de datos con su tamaño
3. Finalizar la lista con su valor de entrada
4. Agotar los datos de entrada
3.3 Estructura repetir

Generalmente se quiere que un bucle se ejecute, mínimo una vez, antes
de que la condición de repetición sea cumplida o se compruebe. En la
estructura mientras, si la condición es falsa, no se dará ninguna
ejecución. Esta estructura se ejecutará mientras se cumpla una condición
determinada, la cual es comprobada al final del bucle.

3.3.1 Ciclo Repetir
En este ciclo se ejecuta una operación hasta que se cumpla una

condición. Ahora se ejecuta primero la operación y se verifica la
condición después.
Acción1
No
Condicion1
Si
Figura 3-2 Estructura repetitiva Repetir
Ejemplo No 28:
Escribir un programa en seudocódigo que dado como datos de entrada n

números enteros se obtenga el número de ceros (0) que hay entre estos
números.
/*
Cod: T-013
Nombre: repetir
Fecha: abril 2007
Descripcion: ejemplo de estructura de repetición Repetir.

El usuario ingresa "n" números enteros, y el
programa debe obtener la cantidad de ceros
que existen entre estos números.
*/

variables
i: numerico // auxiliar del ciclo

n: numerico // número total de datos que se ingresan
num: numerico // representa al número que se ingresa
cont: numerico // contador de ceros
inicio
cls()
imprimir ("\n Entre el número total de datos: ")

leer (n)
repetir
imprimir ("\n Entre el valor : ")
leer (num)
si (num==0)
{
cont=cont+1
}
i=i+1
hasta (i==n)
imprimir("\n existen ",cont," ceros")
fin
Repetir es opuesta a la estructura mientras. Repetir se ejecuta hasta que

se cumpla una condición que se comprueba al final del bucle. Esto
implica que las instrucciones que forman el cuerpo del bucle se ejecutan
por lo menos una vez. Con la estructura mientras el bucle puede
ejecutarse 0 o más veces.
Lo que el procesador hace al ejecutar la estructura repetir es:
 Se ejecutan: instrucción 1, instrucción 2, instrucción 3,......
 Se evalúa la condición. Si esta es FALSA se vuelve a repetir el ciclo

y se ejecutan instrucción 1, instrucción 2, instrucción 3,......
Si la condición es VERDADERA se sale del ciclo y se ejecuta instrucción X.

Mientras Repetir
Comprobación de la condición al inicio, Comprobación de la condición al

antes de entrar al ciclo final, después de haber ingresado
una vez al ciclo
Las instrucciones del cuerpo del ciclo se Las instrucciones del cuerpo del ciclo
ejecutan en forma repetitiva si la se ejecutan si la condición es falsa
condición es verdadera
Las acciones del ciclo se pueden ejecutar Las acciones del ciclo se ejecutan por
cero o más veces lo menos una vez
Tabla 3-1 – Diferencias entre estructuras Mientras y Repetir
3.4 Estructura Desde

Muchas veces ya se conoce el número de veces que se deben ejecutar
las acciones de un bucle. Pero cuando se quiere que el número de
iteraciones sea un número determinado, los programadores utilizan el
tipo de estructura desde.
3.4.1 Ciclo Desde
En este ciclo se ejecuta una operación un cierto número de veces,

especificando en un contador el incremento unitario, desde un Valor
Inicial hasta un Valor Final que marcará la condición de salida del ciclo.

Valor Inicial
Acción1
Incremento
No
Valor Final
Si
Figura 3-3 Estructura repetitiva Desde
Esta estructura accionará el ciclo las veces que sea necesario, llevando
de manera automática un control sobre el número de iteraciones o
pasos a través del cuerpo del bucle.
Ejemplo No 29:
Elabore un programa con la estructura desde que permita imprimir los

números del 1 hasta el 100 en forma continua, y que también imprima
los números pares que existen en el mismo rango.
/*
Cod: T-014
Nombre: desde
Fecha: abril 2007
Descripcion: ejemplo de estructura de repetición desde
*/

variables i: numerico
inicio
cls()
imprimir ("\n\n numeracion continua 1-100 \n\n")
desde i=1 hasta 100 paso 1

{
imprimir("\t",i)
}
imprimir ("\n\n numeracion de dos en dos 2-100 \n\n")
desde i=2 hasta 100 paso 2

{
imprimir ("\t",i)
}
fin
Ejemplo No 30:
Escribir un programa en seudocódigo que imprima los “n” primeros

términos de la sucesión de Fibonacci.
Análisis:
La serie Fibonacci es:

0, 1, 1, 2, 3, 5, 8, 13, 21, 35, 56…
La serie se inicia en cero (0), luego sigue uno (1), y el siguiente término
será la suma de los dos anteriores.
0, 1, 0+1 = 0, 1, 1
Luego
0, 1, 1, 1+1 = 0, 1, 1, 2
Y así sucesivamente
0, 1, 1, 2, 2+1 = 0, 1, 1, 2, 3

Los dos primeros términos (0 y 1) serán introducidos en dos variables a y

b, en cada iteración se suman los dos términos anteriores y se deben
reasignar los valores de las variables.
/*
Cod: T-015
Nombre: Fibonacci
Fecha: abril 2007
Descripcion: ejemplo de estructura de repetición desde.

Imprime los números de la serie Fibonacci
hasta un valor tope indicado por el usuario
*/
variables
a: numerico
b: numerico
n: numerico // número de elementos de la serie
i: numerico // auxiliar del ciclo
fibo: numerico // almacena el nuevo valor de la serie
inicio
cls()
imprimir ("\n\n Entre el número de elementos que desea imprimir de

la serie FIBONACCI: \n\n")
leer (n)
a=0
b=1
imprimir ("\n La serie es: ")
desde i=1 hasta n paso 1

{
imprimir("\t",a)
fibo=a+b
a=b
b=fibo
}
fin

3.5 Estructuras repetitivas anidadas

Así como las estructuras de selección pueden ser anidadas, es posible
que un ciclo pueda ser insertado dentro de otro. Para los dos casos, las
reglas de construcción de estructuras repetitivas anidadas son iguales: la
estructura interna deberá estar totalmente dentro de la externa no
pudiendo existir traslapos.
Las variables índices o de control de los bucles toman valores, de modo

tal que por cada valor de la variable índice del ciclo externo se debe
ejecutar totalmente en el bucle interno.

1. Escriba un programa en seudocódigo que calcule las
proyecciones y coordenadas de un polígono abierto sin control, a
partir de ángulos horarios y distancias calculadas
taquimétricamente.
2. Elabore un programa en seudocódigo que calcule la sumatoria de

ángulos internos y externos de una poligonal.
3. Escriba un programa de forma tal que dado como datos de

entrada 20 magnitudes angulares con formato GG.MMSS,
obtenga el promedio de todos aquellos que sean ≤ 180°30’
4. Escriba un programa que calcule desniveles taquimétricamente

entre un BM1 y un BM2.
5. Dibuje un diagrama de flujo que obtenga la suma e imprima los

términos de la siguiente serie: 2, 5, 7, 10, 12, 15, 17, …, 1800

6. Escriba un diagrama de flujo que lea un número entero N y

calcule el resultado de la siguiente serie:
1 1 1 1
1− + − +⋯±
2 3 4 𝑁

Capítulo 4
Estructuras de datos
Objetivo general:
Agrupar información de un mismo tipo en una estructura que permita realizar

procesos, búsquedas, inserciones y modificaciones de forma ordenada.
 Realizar operaciones básicas con matrices.
 Definir y asociar algoritmos a estructuras de datos.
 Tabular información en matrices y vectores de forma tal que puedan ser

analizadas.
93
Tabla de contenido
4. Estructuras de datos .................................................. 97

4.1 Introducción ..................................................................... 97
4.2 Datos estructurados ......................................................... 97
4.2.1 Estructuras de datos estáticas ................................................. 98
4.2.2 Estructuras de datos dinámicas ............................................... 98
4.3 Arreglos............................................................................ 98
4.3.1 Vectores .................................................................................. 100
4.3.1.1 Definición de arreglos .............................................................. 100
4.4 Operaciones básicas con vectores ................................... 101

4.4.1 Lectura ................................................................................... 102
4.4.2 Búsqueda ............................................................................... 103
4.4.3 Modificación .......................................................................... 105
4.4.4 Eliminación ............................................................................. 109
4.5 Arreglos ordenados ........................................................ 115
4.5.1 Inserción................................................................................. 115
4.5.2 Búsqueda ............................................................................... 116
4.5.3 Eliminación ............................................................................. 121
4.6 Arreglos bidimensionales (matrices) ............................... 126
4.6.1 Declaración de arreglos bidimensionales .............................. 127
4.6.2 Lectura ................................................................................... 127
4.7 Características avanzadas de los arreglos........................ 130

4.7.1 Creación dinámica de arreglos .............................................. 131

4.7.2 Combinaciones de arreglos abiertos y de tamaño fijo .......... 132
4.8 Ejercicios propuestos ...................................................... 136

4. Estructuras
de datos
4.1 Introducción
Todas las variables que se han considerado hasta ahora son de tipo
simple. Una variable de tipo simple consiste de una sola caja de memoria
y sólo puede contener un valor cada vez. Una variable de tipo
estructurado consiste en toda una colección de casillas de memoria. Los
tipos de datos estudiados: entero, real, caracter, son considerados como
datos de tipo simple, puesto que una variable que se define con alguno
de estos tipos sólo puede almacenar un valor a la vez, es decir, existe
una relación de uno a uno entre la variable y el número de elementos
(valores) que es capaz de almacenar. En cambio un dato de tipo
estructurado, como el arreglo, puede almacenar más de un elemento
(valor) a la vez, con la condición de que todos los elementos deben ser
del mismo tipo, es decir, que se puede tener un conjunto de datos
enteros, reales, etc.
4.2 Datos estructurados

Estructura de Datos es una colección de datos que se caracterizan por su
organización y las operaciones que se definen en ella. Los datos de tipo

estándar pueden ser organizados en diferentes estructuras de datos:

estáticas y dinámicas.
4.2.1 Estructuras de datos estáticas
Son aquellas en las que el espacio ocupado en memoria se define en

tiempo de compilación y no puede ser modificado durante la ejecución
del programa. Corresponden a este tipo los arreglos y registros.
4.2.2 Estructuras de datos dinámicas
Son aquellas en las que el espacio ocupado en memoria puede ser

modificado en tiempo de ejecución. Corresponden a este tipo las listas,
árboles y grafos. Estas estructuras no son soportadas en todos los
lenguajes. La elección de la estructura de datos idónea dependerá de la
naturaleza del problema a resolver y, en menor medida, del lenguaje. Las
estructuras de datos tienen en común que un identificador, nombre,
puede representar a múltiples datos individuales.
4.3 Arreglos
Un arreglo es una colección de datos del mismo tipo, que se almacenan
en posiciones consecutivas de memoria y reciben un nombre común.
Para referirse a un determinado elemento de un arreglo se deberá
utilizar un índice, que especifique su posición relativa.
Un arreglo es una colección finita, homogénea y ordenada de elementos.

Finita: Todo arreglo tiene un límite; es decir, debe determinarse cuál

será el número máximo de elementos que podrán formar parte del
arreglo.
Homogénea: Todos los elementos del arreglo deben ser del mismo tipo.
Ordenada: Se puede determinar cuál es el primer elemento, el segundo,

el tercero,.... y el n-ésimo elemento.
Los arreglos se clasifican de acuerdo con el número de dimensiones que

tienen. Así se tienen:
 Unidimensionales (vectores)
 Bidimensionales (matrices)
 Tridimensionales
Elemento 1 Elemento 2 Elemento… Elemento n

1111nto 1111nto
Figura 4-1 Representación gráfica arreglo unidimensional (vector)
Elemento 1, 1 Elemento 1, 2 Elemento… Elemento 1, n
Elemento 2,1 Elemento 2, 2 Elemento…

1111nto Elemento 2, n
Elemento… Elemento… Elemento… Elemento…
Elemento m, 1 Elemento m, 2 Elemento… Elemento m, n

to
Figura 4-2 Representación gráfica arreglo bidimensional (matriz)

Figura 4-3 Representación gráfica arreglo tridimensional
4.3.1 Vectores
Un vector se define como una colección finita, homogénea y ordenada

de elementos, tiene la característica de que se puede almacenar a n
elementos distinguiéndose así dos partes en los vectores: los índices y
los componentes.
Los componentes hacen referencia a los elementos que componen o

forman el arreglo. Es decir son los valores que se almacenan en cada una
de sus casillas.
Los índices son los que permiten acceso a los componentes del arreglo
en forma individual, para hacer referencia a un componente de un
arreglo se necesitan el nombre del arreglo y el índice del elemento.
4.3.1.1 Definición de arreglos
De manera general se define un vector así:

Nombre_vector: vector[lim_inf-limi_sup] tipo
Con tipo se declara el tipo de dato para todos los elementos del arreglo.
El tipo de los elementos no tiene que ser necesariamente el mismo que
el de los índices.
Importante:
 El tipo del índice puede ser cualquier tipo ordinal (carácter,

entro…)
 El tipo de componentes puede ser cualquier tipo (entero, real,

carácter, registro, arreglo,…)
 Se utilizan corchetes [] para indicar el índice de un arreglo. Entre

los corchetes se debe escribir un valor ordinal (puede ser una
variable, una constante, o una expresión tan compleja como se
quiera, pero que de cómo resultado un valor ordinal.
4.4 Operaciones básicas con vectores

Las operaciones más comunes que se presentan en el trabajo con
vectores son:
 Lectura
 Búsqueda
 Modificación
 Eliminación

Como los vectores son datos estructurados, muchas de estas

operaciones no pueden llevarse a cabo de manera global, sino que se
debe trabajar sobre cada elemento.
4.4.1 Lectura
El proceso de lectura en un vector consiste en leer y asignar un valor a

cada uno de sus elementos.
Ejemplo No 31
Definir un vector con capacidad máxima de 10 elementos, en el cual se

puedan almacenar distintos valores numéricos. Adicional a esto se desea
imprimir el vector.
/*
Cod: T-016
Nombre: vector_1 (inserta elementos desordenado)
Fecha: mayo 2006
Descripcion: Este programa inserta elementos de forma

desordenada dentro de un arreglo, una vez
leidos los elementos, imprime el vector.
*/
variables
a:vector[10] numerico // arreglo con capacidad maxima de 10 elementos

n:numerico // almacena el número actual de elementos del vector
y:numerico // representa al elemento que se va a ingresar
i:numérico // índice del ciclo

inicio
cls()
imprimir ("\n Entre el número de elementos del vector: ")

leer (n)
si (n<10)
{
desde i=1 hasta n paso 1 // ciclo que permite
leer el vector
{
imprimir ("\n Entre el elemento: ", i,": ")
leer (y)
a[i]=y
}
sino
imprimir ("\n No hay espacio para insertar
los elementos...")
}
imprimir("\n\n El vector es :", "{")
desde i=1 hasta n paso 1 // ciclo que permite imprimir

el vector
{
imprimir( "\t " ,a[i])

}
imprimir("\t }")
fin
4.4.2 Búsqueda
El proceso de búsqueda en un vector consiste en hallar un valor deseado

dentro de los elementos del vector.

Ejemplo No 32
Definir un vector con capacidad máxima de 10 elementos, en el cual se

pueda identificar el mayor de sus elementos y la posición que ocupa
dentro del arreglo.
/*
Cod: T-016
Nombre: vector_1 (inserta elementos desordenado)
Fecha: mayo 2006
Descripcion: Este programa inserta elementos de forma

desordenada dentro de un arreglo, una vez
leidos los elementos, imprime el vector.
*/
variables
a:vector[10] numerico // arreglo con capacidad máxima de 10 elementos

n:numerico // almacena el número actual de elementos del
arreglo
y:numerico // representa al elemento que se va a ingresar
i:numerico // índice del ciclo
inicio
cls()

leer (n)
si (n<10)
{
leer el vector
{
imprimir ("\n Entre el elemento: ", i,": ")
leer (y)
a[i]=y
}

sino
los elementos...")
}
imprimir("\n\n El vector es :", "{")
desde i=1 hasta n paso 1 // ciclo que permite imprimir

el vector
{

}
imprimir("\t }")
fin
4.4.3 Modificación
Para modificar un elemento X por un elemento Y de un arreglo A que se

encuentra con elementos desordenados debe verificarse que el vector
no se encuentre vacío, y que X se encuentre en el vector. Si se cumplen
estas condiciones entonces se procederá a hacer la actualización.

inicio
Si No
n>=1
i=1
band =falso El vector se
encuentra vacío
No
i<=n
Band=falso
Si
Si A[i]=x No
y i=i+1
A[i]=y
Band=verdadero
No
Band=falso
Si
El elemento x
no está en el
vector
fin
Figura 4-4 Diagrama de flujo – modificación

/*
Cod: T-018
Nombre: vector_3 (modifica elemento desordenado)
Fecha: mayo 2006
Descripcion: Este programa lee un vector definido por el

usuario, busca un elemento y la cambia por
otro que es ingresado por el usuario; si el
elemento existe en más de una posición
dentro del vector éste será eliminado solo
de la primera de sus posiciones.
*/
variables
a:vector[10] numerico
i:numerico //variable de control del ciclo e índice del arreglo
n:numerico //almacena el número actual de elementos del arreglo
p:numerico //almacena el elemento en el vector
x:numerico //representa el elemento que se va a modificar
y:numerico //representa al elemento que se introduce y modifica
al elemento x
band: logico //cambia su valor a verdadero si encuentra el
elemento a modificar
inicio
cls()

leer (n)
si (n<10)
{
leer el vector
{
imprimir ("\n Entre el elemento: ", i,":")
leer (p)
a[i]=p
}
sino


el elemento")
}
i=1
si (n>=1)
{
imprimir ("\n Entre el elemento que se va a
modificar: ")
leer (x)
mientras (i<=n and band==FALSE)

{
si (a[i]==x)
{
imprimir("\n Entre el
el nuevo elemento: ")
leer (y)
a[i]=y
band=TRUE
sino
i=i+1
}
}
si (band==FALSE)
{
imprimir("\n El
elemento no está en el
arreglo")
}
sino
imprimir ("\n El arreglo está vacío")
}
imprimir("\n\n El nuevo vector es : ", "[")
desde i=1 hasta n paso 1 // ciclo que permite imprimir el vector

{

}
imprimir("\t ]")
fin

4.4.4 Eliminación
Para eliminar un elemento X por un elemento Y de un arreglo A

desordenado debe verificarse que el vector no esté vacío y que X se
encuentre en el vector. Si se cumplen estas condiciones entonces se
procederá a recorrer todos los elementos que están a la derecha a una
posición a la izquierda, decrementando el número de elementos del
vector.

inicio
Si n>=1 No
i=1
El elemento x
band =falso
no está en el
vector
i<=n
No
Band=falso
Si
Si No
A[i]=x
band =verdadero i=i+1

n = n-1
k=i
K<=n No
Si
A[k]=a[k+1]
k = k+1
No
Band=falso
Si
El elemento x
no está en el
vector Figura 4-5 Diagrama de flujo
Eliminación
fin

/*
Cod: T-019
Nombre: vector_4 (elimina desordenado)
Fecha: Julio 2007
Descripcion: lee un vector, una vez termina de hacerlo,

pregunta por elemento a eliminar; si el
elemento buscado se encuentra más de una vez
en el vector solo será eliminado de la
primera de las posiciones donde se encuentre
*/
variables
i:numerico // variable de control del ciclo e índice del arreglo
n:numerico // almacena el número actual de elementos del arreglo
x: numerico // almacena la variable que se ha de eliminar
y: numerico // indice que almacena el elemento cuando se lee el vector
k: numerico // variable de control del ciclo interno
band: logico // cambia su valor si encuentra el elemento a eliminar
inicio
cls()

leer (n)
/* inicia proceso que lee vector */
si (n<10)
{
{
imprimir ("\n\n Entre el elemento: ", i,": ")
leer (y)
a[i]=y
}
sino
el elemento...")
}
/* finaliza proceso que lee vector */

/* inicia proceso que elimina elemento */
si (n>=1)
{
imprimir ("\n Entre el elemento a eliminar: ")
leer (x)
i=1
band=FALSE
mientras (i<=n and band==FALSE)

{
si (a[i]==x)
{
band=TRUE
n=n-1
k=i
mientras(k<=n)
{
a[k]=a[k+1]
k=k+1
}
sino
i=i+1
}
}
si (band==FALSE)
{
imprimir ("\n El elemento ",x, " no está en
el arreglo...")
}
sino
imprimir ("\n El arreglo está vacío...")
}
/* finaliza proceso que elimina elemento */
/* inicia proceso que imprime el nuevo vector */
imprimir("\n\n El vector resultante es :", "{")

{
}
imprimir("\t }")
/* finaliza proceso que imprime el nuevo vector */
fin

Ejemplo No 35
Elaborar un programa en seudocódigo que permita calcular el área de un

predio por coordenadas, utilizando vectores.
/*
Cod: T-020
Nombre: vector_5 (area coordenadas)
Fecha: Junio 2007
Descripcion: Este programa lee un vector donde almacena

la posición Norte y otro donde se almacena
la posición Este de una cantidad de puntos
definida por el usuario, luego calcula el
area que delimitan dichos puntos.
*/
variables
norte:vector[100] numerico //arreglo donde se almacena la posición

Norte
este: vector[100] numerico // arreglo donde se almacena la posición
Este
n:numerico // almacena el número de vértices
x:numerico //representa al elemento que se va a
ingresar en el vector Norte
y:numerico //representa al elemento que se va a
ingresar en el vector Este
i:numerico // auxiliar del contador de ciclos
p1:numerico //producto de las coordenadas que descienden
p2:numerico // producto de las coordenadas que ascienden
acu1: numerico // acumulador de p1
acu2: numerico // acumulador de p2
area: numérico
inicio
cls()
imprimir ("\n Entre el número de vertices: ")

leer (n)

si (n<=100)
{
/* inicio ciclo que permite leer las coordenadas */

{
imprimir ("\n NORTE ", i ,": ")
leer (x)
norte[i]=x
imprimir ("\n ESTE ", i ,": ")

leer (y)
este[i]=y
}
/* finaliza ciclo que permite leer las coordenadas */
imprimir ("\n Entre la Norte del punto 1: ")

leer (x)
norte[i]=x
imprimir ("\n Entre la Este del punto 1: ")

leer (y)
este[i]=y
sino
las coordenadas...")
}
cls()
imprimir ("\n\n\t\t", "PUNTO", "\t\t","NORTE", " \t\t",

"ESTE")
/* inicio ciclo que permite imprimir el listado de coordenadas */

{
imprimir ("\n\n\t\t",i, "\t\t", norte[i], "\t\t",

este[i])
}
/* finaliza ciclo que permite imprimir el listado de coordenadas */
/* inicio ciclo que hace el cálculo de los productos */
desde i=1 hasta n+1 paso 1

{
p1=(norte[i]*este[i+1])
acu1=acu1+p1

p2=(este[i]*norte[i+1])
acu2=acu2+p2
}
/* finaliza ciclo que hace el cálculo de los productos */
area = abs(acu1-acu2)/2
imprimir ("\n\n\t\t\AREA: ",area, " m2")
fin
4.5 Arreglos ordenados

Considere un arreglo A de 100 elementos, del cual los primeros N
elementos tienen un valor asignado. Bajo esta condición se trabajará con
un vector ordenado de manera creciente así:
A[1]≤A[2] ≤A[3] ≤…≤A[N]
Cuando se trabaja con vectores ordenados no se debe alterar el orden al

insertar nuevos elementos o al modificar los existentes.
4.5.1 Inserción
Para insertar un elemento X en un arreglo A que se encuentra ordenado,

debe verificarse primero que exista el espacio. Luego tendrá que
encontrarse la posición en la que debería estar el nuevo valor para no
alterar el orden del vector. Una vez encontrada la posición se procederá
a correr todos los elementos desde su posición hasta la N-ésima
posición, un lugar a la derecha. Finalmente se asignará el valor X en la
posición encontrada.

Generalmente cuando se quiere hacer una inserción debe verificarse que

el elemento no se encuentre en el vector. En la mayoría de los casos
prácticos no interesa tener información duplicada, por lo tanto si el valor
a insertar ya existiera en el vector, la operación no se llevaría a cabo.
4.5.2 Búsqueda
Es de anotar que tanto en los procesos de inserción y de eliminación en

vectores ordenados es recomendable tener un procedimiento que
busque el elemento X en el arreglo ordenado. Este procedimiento dará
como resultado la posición en la que se encuentra el elemento X (en
cuyo caso elemento ya pertenece al vector y por lo tanto no debe ser
insertado) o el negativo de la posición en la que debería estar.
inicio
Si No
n<=100
Busca No hay espacio en

el vector para
nuevas inserciones
Inserta
fin
Figura 4-6 a) Diagrama de flujo – módulos búsqueda-Inserción ordenado

Busca
i=1
No
i ≤ n and a[i]<x
Si
i=i+1
Si i>n or a[i]>x No
pos=-i pos=i
Fin módulo
Busca
Figura 4-6 b) Diagrama de flujo – módulo búsqueda ordenado

Inserta
Si pos>0 No
El elemento ya n=n+1
existe pos=pos*(-1)
i=n
No
i≥(pos+1)
Si
a[i]=a[i-1]
i=i-1
a[pos]=x
Fin módulo
Inserta
Figura 4-6 c) Diagrama de flujo – módulo inserta ordenado

Ejemplo No 36
Elaborar un programa en seudocódigo que permita buscar un elemento

dentro de un vector ordenado, si dicho elemento no se encuentra debe
ser insertado de tal forma que vector continúe ordenado.
/*
Cod: T-021
Nombre: vector_6 (busca inserta ordenado)
Fecha: Julio 2007

pregunta por un nuevo elemento a insertar,
si este existe será informado al usuario,
de lo contrario será insertado en el vector.
*/
variables
x: numerico // almacena el elemento en el nuevo vector
pos: numerico // determina la posición del elemento a buscar
inicio
cls()

leer (n)
/* inicia rutina que lee vector*/
si (n<10)
{

imprimir ("\n importante....entre los elemetos del

vector en forma ordenada...")

{
leer (y)
a[i]=y
}
sino
el elemento...")
}
si (n<10)
{
/* inicia proceso que busca el nuevo elemento del vector */
imprimir ("\n Entre el nuevo elemento insertar en el

vector: ")
leer (x)
i=1
mientras (i<=n and a[i]<x)

{
i=i+1
}
si (i>n or a[i]>x)
{
pos=i*-1
sino
pos=i
}
sino
el elemento...")
}
/* termina proceso que busca el nuevo elemento del vector*/
/* inicia proceso que inserta el nuevo elemento del vector */
si (pos>0)
{

imprimir("\n El elemento ya existe...")
sino
n=n+1
pos=pos*-1
i=n
mientras (i>=(pos+1))
{
a[i]=a[i-1]
i=i-1
}
a[pos]=x
}
/* termina proceso que inserta el nuevo elemento del vector */
/* inicia proceso que imprime el nuevo vector */

{
}
imprimir("\t }")
fin
4.5.3 Eliminación
Para eliminar un elemento X de un vector ordenado de elementos A,

primero debe verificarse que el arreglo no esté vacío. Si se cumple esta
condición, entonces tendrá que buscarse la posición del elemento a
eliminar. Si el resultado del módulo BUSCA es un valor positivo, quiere
decir que elemento se encuentra en el vector y por lo tanto puede ser
eliminado; de lo contrario no se puede ejecutar la operación.
Es de anotar que si el vector no está vacío, se modulariza el problema

BUSCANDO primero si se encuentra el elemento y posteriormente, si el
resultado del módulo es positivo, será eliminado.

inicio
Si No
n>0
Busca El vector se
encuentra vacío
Elimina
fin
Figura 4-7 Diagrama de flujo Búsqueda-Eliminación ordenado
Busca
i=1
No
i ≤ n and a[i]<x
Si
i=i+1
Si No
i>n or a[i]>x
pos=-i pos=i
Fin módulo
Busca

Elimina
Si No
pos ≤ 0
El elemento no n=n-1
existe
i=pos
I≤n No
Si
a[i]=a[i+1]
i=i+1
Fin módulo
elimina
Figura 4-8 Diagrama de flujo – módulos Busca-Elimina
Ejemplo No 37:
Realice en seudocódigo un programa que permita eliminar un elemento

de un vector ordenado, luego de verificar su existencia.
/*
Cod: T-022
Nombre: vector_7 (busca elimina ordenado)
Fecha: Julio 2007


pregunta por el elemento a eliminar, si este
existe en más de una posición dentro del vector,
será eliminado solamente de la primera de sus
posiciones; si el elemento no existe le será
informado al usuario.
*/
variables
x: numerico // almacena el elemento en el nuevo vector
pos: numerico // determina la posición del elemento a buscar
inicio
cls()

leer (n)
/* inicia proceso que lee vector*/
si (n<10)
{
imprimir ("\n importante....entre los elementos del
vector en forma ordenada...")

{
leer (y)
a[i]=y
}
sino
el elemento...")
}
si (n<10)
{
/* inicia proceso que busca el nuevo elemento del vector */

imprimir ("\n Entre el elemento a eliminar en el

vector: ")
leer (x)
i=1
mientras (i<=n and a[i]<x)

{
i=i+1
}
si (i>n or a[i]>x)
{
pos=i*-1
sino
pos=i
}
sino
el elemento...")
}
/* termina proceso que busca el nuevo elemento del vector */
/* inicia proceso que borra el elemento del vector */
si (pos<=0)
{
imprimir("\n El elemento NO existe...")
sino
n=n-1
i=pos
mientras (i<=n)
{
a[i]=a[i+1]
i=i+1
}
}
/* termina proceso que borra el elemento del vector */
/* proceso que imprime el nuevo vector */


{
}
imprimir("\t }")
fin
4.6 Arreglos bidimensionales

(matrices)
Una matriz es un conjunto de datos homogéneos, finitos y organizados,
que comparten un nombre en común y que se encuentran organizados
en forma de filas y columnas en donde para referenciar cada dato es
necesario establecer claramente en qué fila y en qué columna se
encuentra. Tomemos la siguiente matriz de datos enteros como ejemplo.
[C-1] [C-2] [C-3] [C-4] [C-5] [C-6]

[F-1] 89 0 0 7 5 17
[F-2] 41 9 3 5 5 55
[F-3] 10 20 30 40 50 60
[F-4] -2 14 28 74 14 36
Figura 4-9 Arreglo bidimensional - matriz
La anterior es una matriz de números enteros cuyos datos están

organizados en 4 filas y 6 columnas. De esta manera para ubicar
exactamente un dato solo se tendrá que referenciar su posición en la fila
y en la columna.
Para referenciar un dato dentro de una matriz no se puede hacer

solamente con el subíndice de la fila o de la columna, por ejemplo qué

dato queda en la fila 1? Esta referencia no se puede hacer porque en la

fila 1 se encuentran 5 datos que son:
89 0 0 7 5 17 Por lo cual se debe notar que las
referencias deben ser hechas de manera individual para una posición
exacta dentro de la retícula. Si la pregunta es: qué dato se encuentra en
la fila 2, columna 5? En este caso la referencia se encuentra
correctamente hecha y su única respuesta es 50.
4.6.1 Declaración de arreglos

bidimensionales
Las matrices son declaradas exactamente igual que los vectores, excepto
que se especifica más de una dimensión entre los corchetes:
Nombre_arreglo : matriz [num_fil, num_col] tipo
Con num_fil se declara el número de filas que tendrá la matriz, con

num_col se declara el número de columnas. Con tipo se declara el tipo
de datos de todos los componentes del arreglo.
Al igual que en los arreglos unidimensionales (vectores), los índices

pueden ser de cualquier tipo de dato ordinal (entero, caracter), mientras
que sus componentes pueden ser de cualquier tipo (reales, enteros,
cadena de caracteres).
4.6.2 Lectura
Cuando se introdujo la lectura en vectores se iban asignando valores a
cada uno de los componentes. Lo mismo sucede con los arreglos
bidimensionales, sin embargo como sus elementos deben referenciarse

con dos índices, se deben utilizar dos ciclos para lograr la lectura de
elementos consecutivos.
Supóngase que se desean leer todos los elementos de una matriz de 4

filas por 3 columnas, el diagrama de flujo de datos sería el siguiente:
inicio
i=1
i≤4 No
Si
j=1
No
i≤3
Si
Elemento [i,j]
mat[i,j] = elemento
j = j+1
i = i+1
Fin
Figura 4-10 Diagrama de flujo - Lectura de datos de una matriz

Ejemplo No 38:
Diseñar en seudocódigo un programa que lea y muestre por pantalla una

matriz de 4 filas y 3 columnas.
/*
Cod: T-023
Nombre: matriz_1 (lectura)
Fecha: Julio 2007
Descripcion: Programa que lee una matriz de 4 filas, 3 columnas
*/
constantes
MAX_FIL=4
MAX_COL=3
variables
mat:matriz[MAX_FIL,MAX_COL] numerico
i:numerico // variable de control del ciclo e índice de la matriz para
leer filas
j: numerico // variable de control del ciclo e índice de la matriz para
leer columnas
e: numerico // variable que almacena el elemento ingresado por el
usuario
inicio
cls()
i=1
mientras (i<=4)
{
j=1
mientras (j<=3)
{
imprimir ("\n Entre el elemento de la
posición ",i,",",j, ": ")

leer (e)
mat[i,j]=e
j=j+1
}
i=i+1
}
imprimir_matriz()
fin
subrutina imprimir_matriz()
variables
f, c : numerico
inicio
imprimir ("\n\n La matriz es : ")
desde f=1 hasta MAX_FIL paso 1

{
imprimir ("\n\n")
desde c=1 hasta MAX_COL paso 1

{
imprimir (str (mat [f,c], 5,0)) // 5: ancho ; 0:
precisión decimal
}
}
fin
4.7 Características avanzadas de los

arreglos
En líneas anteriores ya se ha explicado cómo declarar vectores y
matrices. Ahora se describirá con mayor detalle otros aspectos

particularmente interesantes: creación dinámica de arreglos, y

combinación de arreglos abiertos y de tamaño fijo.
4.7.1 Creación dinámica de arreglos

Como ya se ha explicado, la siguiente declaración habilita un vector de
100 elementos numéricos:
v : vector [100] numerico
En este caso el tamaño del vector ya está definido al momento de la

compilación. Sin embargo existen algunos problemas de la vida real en
los que no es posible conocer o no es conveniente predefinir la cantidad
máxima de elementos que se requerirán. Puede incluso que el valor
máximo varíe de tiempo en tiempo. En estas situaciones se pueden usar
arreglos cuya creación sea dinámica, que se declaran así:
v : vector [*] numerico
es decir, en vez del tamaño se coloca un asterisco para indicar que dicho
valor aún no se conoce.
Ya en el cuerpo del programa, cuando se sepa la cantidad de elementos

que se necesitan, se usa la subrutina predefinida dim() que posibilita
asignar efectivamente la memoria necesaria:
leer (n)
dim (v, n)
Esta posibilidad existe también para las matrices, sin importar la

cantidad de dimensiones. Por ejemplo, lo que sigue declararía una matriz
en las que la cantidad de filas y columnas no son conocidas al momento
de la compilación:
M : matriz [*, *] numerico

inicio
leer (cant_fil, cant_col)
dim (M, cant_fil, cant_col)
A los vectores y matrices creables dinámicamente se les llama

genéricamente “arreglos abiertos”.
4.7.2 Combinaciones de arreglos

abiertos y de tamaño fijo
La definición de un arreglo puede incluir una mezcla de tamaño fijo con
tamaño abierto. Por ejemplo, si al momento de escribir un algoritmo se
necesita una matriz que tiene 8 columnas pero no está definida la
cantidad de filas, se puede escribir:
M : matriz [*, 8] numerico
inicio
leer (cant_fil)
dim (M, cant_fil)
En este caso dim() solo requiere dos parámetros: la matriz M y la

cantidad de filas. La cantidad de columnas es tomada de la definición.
Sin embargo es de recordar que, una vez especificado un valor concreto
para una dimensión, ya no es posible usar asterisco para las siguientes
dimensiones. Por lo tanto lo que sigue dará error de compilación:
M : matriz [5, *] numerico // !!! No es válido !!!
Si un programa intenta usar un arreglo abierto no inicializado, se genera

un error de ejecución y el programa se detiene.

Ejemplo No 39:
Escribir un programa en seudocódigo que ajuste una poligonal cerrada

por el método de la brújula utilizando una matriz dinámica.
/*
Cod: T-024
Nombre: matriz_2 (ajuste brujula)
Fecha: Julio 2007
Descripcion: Programa que ajusta una poligonal

geométricamente cerrada por el método del la
brújula, a partir de los datos: azimut y
distancia, ingresados por el usuario y
levantados en campo.
*/
variables
mat:matriz[*,10] numerico // matriz que almacena datos de

entrada
cant_fil: numerico // cantidad de filas del arreglo
i: numerico // indice contador del ciclo que lee
angulos y distancias
angulo: numerico // angulo ingresado por el usuario
con formato GG.MMSS
f: numerico // indice contador de filas
c: numerico // indice contador de columnas
dist: numerico // distancia
pm: numerico // proyeccion meridiana
pp: numerico // proyeccion paralela
n: numerico // coordenada NORTE
e: numerico // coordenada ESTE

acu_per: numerico // acumulador distancias (perimetro)
acu_pm: numerico // acumulador de PM (delta PM)
acu_pp: numerico // acumulador de PP (delta PP)
ec: numerico // error de cierre
gp: numerico // grado de precisión
angulo_radianes: numerico

inicio
cls()
imprimir ("\n Entre el número de vértices de la poligonal : ")

leer (cant_fil)
dim (mat, cant_fil)
imprimir ("\n Entre la coordenada Norte de delta 1: ")

leer (n)
imprimir ("\n Entre la coordenada Este de delta 1: ")

leer (e)
f=1
c=1
desde i=1 hasta cant_fil paso 1

{
si(i<= cant_fil-1)
{
imprimir ("\n Entre el azimut de la línea ", i, "-
",i+1,": " )
sino
imprimir ("\n Entre el azimut de la línea ", i, "-
",1,": " )
}
leer (angulo)
angulo_rad()
mat[f,c]=angulo
si(i<= cant_fil-1)
{
imprimir("\n Entre la distancia de la línea ",i, "-
", i+1, ": ")
sino
imprimir ("\n Entre la distancia de la línea ", i,
"-",1,": " )
}
leer (dist)
mat[f,c+1]=dist
acu_per=acu_per+dist
pm=dist*cos(angulo_radianes)
mat[f,c+2]=pm
acu_pm=acu_pm+pm
pp=dist*sin(angulo_radianes)
mat[f,c+3]=pp
acu_pp=acu_pp+pp

f=f+1
}
c=5
desde f=1 hasta cant_fil paso 1
{
mat[f,c]=(acu_pm/acu_per)*mat[f,2] // cpm
mat[f,c+1]=(acu_pp/acu_per)*mat[f,2] // cpp
mat[f,c+2]=(mat[f,3]-mat[f,5]) // pmc
mat[f,c+3]=(mat[f,4]-mat[f,6]) // ppc
mat[1,9]=n+mat[1,7] // Norte corregida

mat[1,10]=e+mat[1,8] // Este corregida
desde i=2 hasta cant_fil paso 1

{
mat[i,9]=mat[i-1,9]+mat[i,7]
mat[i,10]=mat[i-1,10]+mat[i,8]
}
imprimir_matriz()
ec=sqrt((acu_pm^2)+(acu_pp^2)) // error de cierre
gp=acu_per/ec // grado de precision
imprimir ("\n\n Delta PM : ",acu_pm)

imprimir ("\n Delta PP : ",acu_pp)
imprimir ("\n Perimetro: ",acu_per)
imprimir ("\n E.cierre : ",ec)
imprimir ("\n GP : ","1:",gp)
fin
/*****************************************************************/
subrutina angulo_rad()
variables
grados : numerico
minutos : numerico
segundos : numerico
constantes
PI = 3.141592654

inicio
fin
/*****************************************************************/
subrutina imprimir_matriz()
variables
f, c : numerico
inicio
cls()
desde f=1 hasta cant_fil paso 1

{
imprimir ("\n\n")
desde c=1 hasta 10 paso 1

{
imprimir (str (mat [f,c], 8,2)) // 8: ancho ; 2:
precisión decimal
}
}
fin

1. Elabore un algoritmo que lea un arreglo unidimensional de 20
elementos, que calcule e imprima el promedio de los elementos
de las posiciones pares.
2. Construya un algoritmo en seudocódigo que permita leer dos

vectores A y B, ambos de igual longitud, y en un tercer vector C
calcular e imprimir la suma sabiendo que C[i]=A[i]+B[i].

3. Leer un vector de N componentes, y ordenarlo de manera

ascendente, imprimir el vector antes y después de ordenarlo.
4. Construya un diagrama de flujo para almacenar en un arreglo

unidimensional los 30 primeros números primos, al final imprima
el arreglo correspondiente.
5. Dada una matriz A(m,n) de tipo entero elabore el diagrama de

flujo y el algoritmo en seudocódigo que calcule la transpuesta de
dicha matriz. La traspuesta de una matriz se obtiene al escribir las
filas de la matriz A como columnas.
6. Elabore un programa que calcule una poligonal cerrada por el

Método del Tránsito, utilizando un arreglo bidimensional.
7. Diseñe un algoritmo en seudocódigo que calcule el volumen en

corte o en relleno de una cuadrícula.

Capítulo 5
Subrutinas
Objetivo general:
Modularizar programas mediantes sub-programas que los hacen más pequeños

comprensibles y manejables.
 Utilizar procedimientos que hagan paso de parámetros por valor.
 Identificar diferencias entre funciones y procedimientos.
 Utilizar procedimientos que hagan paso de parámetros por referencia.
139
Tabla de contenido
5. Subrutinas ............................................................... 143

5.1 Introducción ................................................................... 143
5.2 Identificadores ............................................................... 144
5.3 Funciones ....................................................................... 146
5.3 Procedimientos .............................................................. 150
5.4 Definición de parámetros formales ................................. 151
5.4.1 Paso de parámetros ............................................................... 151
5.4.1.1 Por valor .................................................................................... 151
5.4.1.2 Por referencia............................................................................ 151


5. Subrutinas
5.1 Introducción
Las subrutinas son un componente fundamental de programación: ellas
permiten modularizar un programa, es decir, que un programa este
compuesto de programas más pequeños, comprensibles y manejables.
Se puede conceptualizar como un subprograma, porque ella no solo
agrupa y da un nombre a un conjunto de sentencias lógicamente
relacionadas, sino que además puede tener sus propias variables y
constantes, permitiendo así reutilizar el código y evitar su repetición
dentro de un programa.
Para utilizar una función es necesario saber el tipo de dato que devuelve,
su identificador, y los parámetros que se deben proporcionar.
Dependiendo de la función dentro del programa pueden existir dos

clases de subrutinas: los procedimientos y las funciones.

5.2 Identificadores
La mayoría de los programas tienen una estructura tipo árbol, el
programa principal es la raíz y de este penden muchas ramas
(procedimientos y funciones).
Los subprogramas en los que un identificador puede ser utilizado se

conocen como ámbito o alcance del identificador, dicho de otro modo,
es en esta sección donde el identificador es válido.
Un identificador es global si se declara por fuera de cualquier subrutina,
y por lo tanto puede ser usada por cualquier subrutina. En cambio, se
dice que es local si se declara dentro de subrutina y solo puede ser
reconocida por dicha subrutina.
La importancia de esta distinción radica en que:
1. Los identificadores locales solo pueden ser utilizados dentro de la

subrutina que contiene su definición.
2. Los identificadores globales pueden ser utilizados en cualquier

parte del programa.
Si un identificador es declarado o forma parte de los parámetros de una

subrutina y su nombre coincide con el de otro identificador declarado
globalmente, éste último queda temporalmente inaccesible durante la
ejecución de la subrutina.
Los identificadores locales son importantes porque:
1. Existe la posibilidad que dos identificadores puedan ser llamados

por el mismo nombre, teniendo así cada uno propiedades
independientes: dirección de memoria, tipo, duración (constante
o variable).

2. Mejoran la legibilidad de las subrutinas y fortalece su

independencia del contexto.
3. Permiten la escritura de subrutinas recursivas.
Ejemplo No 40:
/*
Cod: T-025
Nombre: subrutinas
Fecha: Julio 2007
Descripcion: Ejemplo de subrutinas
*/
variables
n : numerico
Variable global
inicio
Programa
principal
n = 100
sub_1()
imprimir ("\n", n)
sub_2 ("GEOMATICA")
fin
/***************************/

subrutina sub_1()
Variable local
variables
inicio
n : numerico
inicio
desde n=1 hasta 10 paso 1

Subrutinas
{
imprimir (n, " ")
}
fin parámetro
/********************/
subrutina sub_2(n : cadena)
inicio
imprimir ("\n", n)
fin
La primera línea ( 1 2 3 4 5 6 7 8 9 10 ) es impresa por la subrutina

sub_1(); la segunda línea ( 100 ) es generada por el programa principal;
mientras que la tercera ( GEOMATICA ) es impresa por la subrutina
sub_2(). Como se puede ver el valor de la variable global n no fue
afectada por la variable local n de la subrutina sub_1() pues el
compilador les asigna espacios distintos en la memoria.
5.3 Funciones
Una función es una subrutina que produce un valor que puede ser
utilizado por la parte del programa que la llamó. El valor producido y
retornado por la función puede ser de cualquier tipo.

Ejemplo No 41:
Elaborar en seudocódigo un programa que permita sumar dos números

enteros mediante una función.
/*
Cod: T-026
Nombre: subrutinas_2
Fecha: Julio 2007
Descripcion: Ejemplo de funcion (retorna valor)

*/
variables
num1: numerico
num2: numerico
res: numerico
inicio
cls()
imprimir ("\n Entre el primer número : ")

leer (num1)
imprimir ("\n Entre el segundo número :")

leer (num2)
res = suma(num1,num2)
imprimir ("\n El resultado es: ", res)

fin
/*************************************************/

subrutina suma( a,b: numerico ) retorna numerico
variables
resultado: numerico
inicio
resultado=a+b
retorna(resultado)
fin
Ejemplo No 42:
Escribir un programa en seudocódigo que permita calcular las

proyecciones meridiana y paralela a partir de los datos de entrada:
azimut y distancia; el azimut debe ser entrado con formato GG.MMSS,
además debe ser hecho con una función que convierta la magnitud
angular en radianes.
/*
Cod: T-027
Nombre: subrutinas_3
Fecha: Julio 2007
Descripcion: Ejemplo de funcion
*/
variables
angulo : numerico
pm : numerico // proyeccion meridiana

pp : numerico // proyeccion paralela

dh : numerico // distancia horizontal
constantes
PI = 3.141592654
inicio
cls()
imprimir("\n Entre el angulo con formato GG.MMSS : ")

leer (angulo)
imprimir("\n Entre la distancia horizontal : ")

leer (dh)
imprimir("\n El angulo en radianes es: ", ang_rad(angulo))
pm = dh*cos(ang_rad(angulo))
pp = dh*sin(ang_rad(angulo))
imprimir ("\n\n PM: ",pm ,"\t PP: ",pp)
fin
/********************************************************************/
subrutina ang_rad (angulo: numerico) retorna numerico
variables
grados : numerico
minutos : numerico
segundos : numerico
angulo_radianes : numerico
inicio
retorna(angulo_radianes)
fin

5.3 Procedimientos
Un procedimiento es una subrutina que no retorna un valor y que realiza
una tarea específica.
Ejemplo No 43:
Escribir un programa en seudocódigo que ejecute una subrutina de

procedimiento.
/*
Cod: T-028
Nombre: subrutinas_4 ( no retorna valor)
Fecha: Julio 2007
Descripcion: Ejemplo de procedimientos
*/
inicio
cls() // este procedimiento es preestablecido por el compilador y

permite limpiar la pantalla cada vez que se llame
imprimir_mensaje()
fin
subrutina imprimir_mensaje()
inicio
imprimir ("\n\n La exactitud está diciendo la verdad...La

precisión ","\n está contando la misma historia una y otra
vez.","\n Yiding Wang")
fin

5.4 Definición de parámetros

formales
Se llama parámetros formales a los identificadores que se ubican al inicio
de una subrutina para indicar el tipo y la cantidad de datos que recibe la
subrutina.
subrutina proyecciones (az, dist : numerico) retorna numerico
az, y dist son los parámetros formales, la sintaxis para la declaración de

estos parámetros es igual que la de declaración de variables.
5.4.1 Paso de parámetros
Existen dos maneras de realzar el paso de parámetros: por valor y por

referencia.
5.4.1.1 Por valor: la expresión que se pasa como parámetro

es copiada como valor inicial de la variable correspondiente en la lista de
parámetros de la subrutina. La principal característica del paso de
parámetros por valor es que los cambios que pueda presentar la variable
que recibe el parámetro no se ven afectados en el programa que está
llamando a la subrutina.
5.4.1.2 Por referencia: en este proceso de paso de

parámetros lo que recibe la subrutina es la dirección de memoria de la
variable original por lo tanto cualquier cambio que sufra el parámetro es
reflejado directamente en la variable original.

Ejemplo No 44:
La siguiente subrutina correccion_temperatura(l:numerico; ref to:numerico)

recibe el parámetro l por valor, y el parámetro to por referencia,
nótese que al cambiar el valor en la variable to dentro de la subrutina es
también cambiado su valor en el programa principal.
/*
Cod: T-029
Nombre: subrutinas_5 (referecia)
Fecha: Julio 2007
Descripcion: paso de parámetro "to" por referencia
*/
variables
ct: numerico // corrección por temperatura

l: numerico // longitud medida (m)
t: numerico // temperatura en la cual se hace la medicion
to: numerico // temperatura del patronamiento
inicio
cls()
imprimir ("\n Entre la temperatura ambiente al momento de hacer la

medición :")
leer (t)
imprimir ("\n Entre la distancia medida: ")

leer (l)
to=25
correccion_temperatura(l,to)
imprimir ("\n este valor cambió por la referencia: to :",to)
fin
/***********************************************/

subrutina correccion_temperatura(l:numerico; ref to:numerico)
variables
ct: numerico
inicio
to=20
ct=0.000012*l*(t-to)
imprimir ("\n Corrección: ",ct)
fin

Anexo A
Introducción a Visual
Basic
Objetivo general:
Utilizar una poderosa herramienta de programación que permita mediante objetos

visuales la creación de interfaces atractivas al usuario.
 Identificar los principales elementos de una interfaz gráfica.
 Desarrollar aplicaciones básicas que permitan solucionar problemas de

topografía mediante algoritmos apropiados en un entorno atractivo.
155
Tabla de contenido
6. Introducción a Visual Basic ........................................ 159

6.1 Introducción ................................................................... 159
6.2 Variables ........................................................................ 159
6.2.1 Nombre de las variables ....................................................... 160
6.2.2 Tipos de datos ....................................................................... 160
6.3 Constantes .................................................................... 162
6.4 Operadores .................................................................... 163
6.5 Entada y salida de datos ................................................. 164
6.5.1 Entrada de datos ................................................................... 164
6.5.2 Entada y salida de datos usando controles ......................... 169
6.5.2.1 El formulario, los controles y sus propiedades ........................ 170
6.5.3 Escribir el código .................................................................. 172
6.6 Sentencias de control .................................................... 179
6.6.1 Sentencia If ............................................................................ 179
6.6.2 Sentencia If…Then...Else ....................................................... 180
6.6.3 Sentencia Select Case ........................................................... 182
6.6.4 Sentencia For…Next ............................................................... 184
6.6.5 Sentencia While…Wend ........................................................ 185
6.6.6 Sentencia Do…Loop ............................................................... 186


6. Introducción a
Visual Basic
6.1 Introducción
La palabra “Visual” hace referencia al método que se utiliza para crear la
interfaz gráfica de usuario, la cual se puede crear arrastrando objetos
con el ratón dentro del formulario.
La palabra “Basic” se refiere al lenguaje de programación BASIC

(Beginners All-Propouse Symbolic Instruction Code). Visual Basic
evolucionó desde el lenguaje BASIC y ahora contiene cientos de
instrucciones, palabras clave y funciones, muchas de las cuales están
directamente relacionadas con la interfaz gráfica del usuario.
Este lenguaje de programación también es usado por Microsoft Excel,

Access y otras aplicaciones de Windows.
6.2 Variables
Son aquellos valores que pueden o no cambiar al resolver un problema.
Las variables poseen su nombre y su valor, los nombres de las variables

deben comenzar con una letra y pueden constar de un número de letras

y dígitos. Visual Basic tiene reservadas varias palabras que no pueden ser
usadas como nombres de variables.
Cada variable tiene atributos propios como:
Nombre: es el nombre que se utiliza para referirse a la variable en la

aplicación.
Tipo: se debe determinar la clase de valor se puede almacenar en la
variable.
6.2.1 Nombre de las variables
El nombre de una variable tiene que comenzar con una letra, puede
tener hasta 255 caracteres, y debe ser único dentro de su ámbito.
Los caracteres pueden ser letras, dígitos, y los caracteres de declaración

del tipo de la variable (%, &, !, #, @, y $).
Existen palabras reservadas dentro del lenguaje de programación que no

pueden ser usadas como variables, ejemplo: For, Val, Hide, Caption,
Long, y And.
6.2.2 Tipos de datos
Todas las variables tienen un tipo de dato que determina la clase de

datos que pueden almacenar. Una variable puede ser de alguno de los
siguientes tipos:

Tipo Descripción Car-tipo Rango
Entero
Integer % -32.768 a 32.767
(2 bytes)
Entero largo -2.147’483.648 a

Long &
(4 bytes) 2.147’483.647
Coma flotante.
Precisión
Single ! -3,40E+38 a 3,40E+38
simple
(4 bytes)
Coma flotante.
Precisión
Double # -1.79E+308 a 1.79E+308
doble
(8 bytes)
Cadena de
caracteres de
String longitud fija Ninguno 64K
(1 byte por
caracter)
Cadena de
caracteres de
longitud
String variable $ Hasta 231
(10 bytes + 1
byte por
caracter)
Byte Caracter Ninguno 0 a 255

(1 byte)

Tipo Descripción Car-tipo Rango
Bolean
Boolean Ninguno True o False
(2 bytes)
Valor mayor con 0 decs: ±

79.228.162.514.264.337.
Números con
593.543.950.335
Decimal 0 a 28 Ninguno
Valor mayor con 28 dec:
decimales
±7,9228162514264337
593543950335
Tabla 6-1 - Tipos de datos en Visual Basic
Un byte son ocho bits y un bit se representa mediante un 0 o un 1,

símbolos que componen el sistema binario que usan los computadores.
Un múltiplo es el K; 1Kbyte es igual a 210 bytes.
6.3 Constantes
Son aquellos valores que no cambian al resolver un problema. Las
constantes numéricas pueden contener: Dígitos, un signo, punto decimal
y E (Notación exponencial, E significa potencia 1 de 10).
Para nombrar una constante, se usan las mismas reglas que se aplican
para nombrar variables. Ejemplo:
Public Const nombre_constante = 100

6.4 Operadores
En Visual Basic se soportan distintos tipos de operadores, en la tabla que
a continuación los muestra se encuentran de mayor a menor prioridad
respecto a cómo se evalúan cuando varios de ellos intervienen en la
misma expresión. Los operadores que se encuentran en el mismo
renglón poseen igual prioridad. Las operaciones que se incluyen entre
paréntesis se evalúan primero, ejecutándose primero los paréntesis más
internos.
Tipo Operación Operador
Exponenciación ^
Cambio de signo -
Multiplicación y división *, /
Aritmético
División entera \
Resto de división entera Mod
Suma y resta +, -
Igual =
Diferente <>
Menor <
Relacional
Mayor >
Menor o igual <=
Mayor o igual >=
Negación Not
Y lógica And
Lógico O lógica Or
Or exclusiva Xor
Equivalencia Eqv
Tabla 6-2 - Tipos de operadores en Visual Basic

6.5 Entada y salida de datos

Visual Basic tiene una serie de controles para ser utilizados como
mecanismos de Entrada/Salida, entre ellos: las etiquetas, cajas de texto,
botones de pulsación, botones de opción, listas desplegables.
Otra posibilidad de proporcionar datos a una aplicación o visualizar

resultados es la caja de diálogo. Estas cajas son ventanas con controles
que se pueden visualizar en el momento que se necesite hacer una
entrada o salida de datos.
6.5.1 Entrada de datos
En Visual Basic se usa la función InputBox con la que visualiza una caja
de diálogo, con un mensaje que indica al usuario el tipo de información
que se debe ingresar; devuelve como resultado un valor de tipo String
que corresponde con el dato entrado por el usuario.
Sintaxis:
InputBox (mensaje, [título][,por _omisión][,posx][posy])
La cadena de caracteres mensaje contiene el mensaje que indica al

usuario la información que va a entrar.
La cadena de caracteres título será visualizada en la barra de título de la

caja de diálogo, si se omite se pone como título el nombre que la
aplicación tenga por defecto.
La cadena de caracteres por_omisión especifica el texto que aparecerá

en la caja de texto, si se omite esta aparecerá vacía.

Los argumentos posx y posy son las coordenadas x e y donde aparecerá

la caja de diálogo medidas desde la parte superior izquierda de la
pantalla, si se omiten la caja de diálogo se visualizará centrada
horizontalmente y a un tercio de la parte superior de la pantalla.
Ejemplo No 45:
Escribir el código necesario que permita mediante una aplicación entrar

el nombre, los apellidos, edad, dirección, programa académico, semestre
y fecha de nacimiento de un estudiante. Una vez ingresados los datos
visualizarlos en un formulario.
Cuando se inicia Visual Basic 6.0 aparece en la pantalla una la caja de

diálogo nuevo proyecto mostrada en la Figura 6.1
Figura 6-1 Acceso a Visual Basic
Para nuestro caso se debe seleccionar la opción EXE estándar, y luego

hacer click en abrir.
Una vez se ejecute la opción estándar de Visual Basic se ve una interfaz

similar a la de la figura 6-2.

Barra de menús: visualiza las órdenes necesarias para desarrollar una

aplicación
Barra de herramientas: facilita el acceso rápido a las órdenes más

comúnmente utilizadas
Ventana de propiedades: en la que se pueden ver las propiedades del

objeto seleccionado o del propio formulario (en el centro a la derecha).
Si esta ventana no aparece, se puede hacer visible con la tecla <F4>.
Caja de herramientas: proporciona un conjunto de herramientas que
permiten colocar los controles en el formulario durante el diseño de la
interfaz gráfica del usuario.
Formulario: es la ventana sobre la que se colocan los controles de

interfaz gráfica que el usuario utilizará para comunicarse con la
aplicación.
Barra de herramientas
Formulario
Ventana
Propiedades
Figura 6-2
Caja de herramientas
Ventana de posición del formulario

Haciendo doble clic sobre el formulario se despliega el editor de código

de Visual Basic (Figura 6-3). En este editor se escribe el código que
aparece a continuación, el cual será explicado más adelante.
Cuando una aplicación carga un formulario se produce un evento Load,

como será lo que sucede cuando se ejecute la aplicación, vamos escribir
el código necesario para realizar el ejemplo expuesto, en el
procedimiento conducido producido por el evento Load. Por lo tanto se
debe elegir de la lista de objetos en la ventana de código el objeto Form,
y de la lista de procedimientos el conducido por el evento Load (Figura 3-
3). Después se debe escribir el siguiente código:
Figura 6-3 - Editor de código
Dim nombre_apellido As String

Dim edad As Integer
Dim direccion As String
Dim programa_academico As String
Dim semestre As String
Dim fecha_nacimiento As Date
Private Sub Form_Load()
'entrada de datos
nombre_apellido = InputBox("Nombre y apellidos: ", , "Nombre y

apellido")

edad = InputBox("Edad:", , 0)
direccion = InputBox("Direccion:")
programa_academico = InputBox("Programa Academico:")
semestre = InputBox("Semestre:")
fecha_nacimiento = InputBox("Fecha nacimiento:", , #16/04/1977#)
'salida de datos
Print "Nombre:"; nombre_apellido

Print "Edad: "; edad; "años"
Print "Dirección: "; direccion
Print "Programa Académico: "; programa_academico
Print "Semestre: "; semestre
Print "Fecha de nacimiento: "; fecha_nacimiento
End Sub
De acuerdo al ejercicio anterior con la función Print se pueden visualizar

los datos en un formulario (objeto Form).
Es necesario saber que se deben declarar los tipos de dato que se van a
utilizar en la aplicación, esto se hace en la parte inicial del código
(realmente se pueden declarar en cualquier parte del código, pero se
recomienda que sea en el encabezamiento del mismo) en el ejemplo
anterior son:
Dim nombre_apellido As String

Dim edad As Integer
Dim direccion As String
Dim programa_academico As String
Dim semestre As String
Dim fecha_nacimiento As Date
Las sentencias anteriores declaran a nombre_apellido, dirección,

programa_academico y semestre como variables que contiene una
cadena de caracteres de longitud variable, edad como una variable de

tipo entero, y fecha_nacimiento como un dato de tipo fecha con formato

DD/MM/AA
Con la función Dim se indica al programa que reserve un espacio de

memoria para la variable que se está declarando. Cada variable debe ser
del tipo de dato que se quiera asignarle.
6.5.2 Entada y salida de datos usando

controles
En el entorno de Windows, el control más común de una aplicación es

una caja de texto, puesto que permiten realizar la entrada de datos para
una aplicación y visualizar los resultados producidos por cierto proceso.
Ejemplo No 46:
Realizar una aplicación que convierta a centímetros un valor entrado en

pulgadas.
Antes de empezar a crear la aplicación, es recomendable responderse las

siguientes preguntas:
Qué objetos forman la interfaz?
 Un formulario que permita implementar la interfaz

 Una caja de texto para entrar el valor en Pulgadas
 Una caja de texto para visualizar el resultado en Centímetros
 Dos etiquetas que informen al usuario de la información que
contiene cada caja de texto
 Un botón de pulsación que permita realizar los cálculos

Qué eventos hacen que la interfaz responda?
Con esta aplicación se busca que cuando el usuario entre los valores de
ángulo horario y azimut siguiente, y pulse el botón calcular, se actualice
el contenido de las otras cajas con los resultados correspondientes. Por
lo tanto el evento es pulsar el botón calcular, que en Visual Basic se
llama Click.
Para un desarrollo ordenado de la aplicación se puede resumir en: crear

una nueva aplicación, diseñar la interfaz gráfica, y unir el código a los
controles para que ejecuten las operaciones deseadas.
6.5.2.1 El formulario, los controles y sus

propiedades
Una vez conocidos los objetos y los eventos, se procede a dibujar la
interfaz. Para ello se crea una nueva aplicación de tipo EXE estándar y
cambiamos el nombre Form 1 del formulario por pulgadas a centímetros.
Esto se hace modificando el contenido de la propiedad Caption del
formulario.
Luego se dibujan los controles. Dibujamos una etiqueta (Figura 6-4), se

mueve al lugar deseado, y se cambia el título label1 por valor en
pulgadas esto se hace modificando el contenido de la propiedad Caption
del label1.
Después se dibuja una caja de texto (Figura 6-4), y se mueve al lado

derecho de la etiqueta. En el cuadro de propiedades cambie (en la
ventana de propiedades) el nombre Text1 por pul [cuando escriba el
código se dará cuenta porque pul]

Siguiendo los mismos pasos se dibuja una segunda etiqueta cambiando

label2 por Valor en Centímetros y otra caja de texto frente a la etiqueta
Valor en Centímetros. En esta caja de texto cambie (en la ventana de
propiedades) el nombre Text2 por centi [cuando escriba el código se
dará cuenta por qué centi]
Para dibujar etiquetas Para dibujar cajas de texto
Para dibujar botones

de comando
Figura 6-4 - Caja de herramientas
Por último se dibuja un botón de comando y se cambia su nombre

Command1 por Calcular.
Una vez colocados los controles y ajustados sus tamaños (los de los
controles) se ajusta el tamaño del formulario. La interfaz obtenida debe
ser como la siguiente:

Figura 6-5 - Interfaz de aplicación (conversión)
Ahora se deben borrar los contenidos de las cajas de texto (Text1 y

Text2), para hacerlo se selecciona la caja de texto número 1, y en la
ventana de propiedades se elige Text y se suprime su contenido.
En este momento se tienen listos el formulario y los controles, para

hacerlos trabajar se necesita unir a ellos el código correspondiente.
6.5.3 Escribir el código
Para hacer que una aplicación responda a los eventos que sobre ella se
producen, se debe unir a cada uno de sus objetos el código que sea
necesario como respuesta al evento ocurrido. Por esta razón se debe
escribir un procedimiento asociado con el botón Calcular y conducido
por el evento Click que actualice automáticamente el contenido de la
caja de texto Valor en Centímetros.
El valor para actualizar esta caja es:
centimetros = pulgadas * 2.54

Se debe escribir entonces el procedimiento que responda al evento Click

cuando ocurra sobre el botón calcular. La ventana de código
correspondiente a este procedimiento se visualiza haciendo doble clic
sobre el botón calcular. Una vez en el editor de código se debe escribir lo
siguiente:
Private Sub calcular_Click()
'GJC & JGB
'declaracion de variables
Dim centimetros As Double
Dim pulgadas As Double
'Procesos
pulgadas = pul.Text
centimetros = pulgadas * 2.54
'salida
centi.Text = Format(centimetros, "0.00")
End Sub
Ejemplo No 47:
Hacer una aplicación en Visual Basic que permita calcular el área de un

triángulo conociendo sus tres lados. (Fórmula de Heron)
Fórmula:
𝑎+𝑏+𝑐
𝑠=
2

𝑎𝑟𝑒𝑎 = √𝑠 ∙ (𝑠 − 𝑎) ∙ (𝑠 − 𝑏) ∙ (𝑠 − 𝑐)
Figura 6-5 - Interfaz de aplicación (área del triángulo)
Con el fin de entender el código que a continuación se expone, a la caja

de texto Text1 se le modificó su nombre (en la ventana propiedades) por
lado_a, Text2 y Text3 por lado_b y lado_c, y Text4 por resultado.
Como solo hay un procedimiento (botón calcular) el cual se genera con

el evento Clic, es en este botón donde se debe entrar el siguiente código:
'GJC & JGB
' declaracion de variables
Dim a As Single

Dim b As Single
Dim c As Single
Dim area As Single
Dim s As Single
'procesos
a = lado_a.Text
b = Lado_b.Text
c = Lado_c.Text
s = (a + b + c) / 2
area = Sqr((s * ((s - a) * (s - b) * (s - c))))
'salida
resultado.Text = Format(area, "0.00")
End Sub
Ejemplo No 48:
Hacer una aplicación en Visual Basic que permita calcular el punto de

ceros, a partir de la altura de corte, lleno y la distancia entre estas.

Figura 6-6 - Interfaz de aplicación (punto de cero)
A la caja de texto Text1 se le modificó su nombre (en la ventana

propiedades) por corte, Text2 y Text3 por relleno y distancia, y Text4 por
resultado.
Haciendo doble clic en el botón Calcular aparece el editor de código que

genera el evento Clic, donde se debe escribir el siguiente código:
'GJC & JGB
Dim c As Single
Dim r As Single
Dim d As Single
Dim x As Single
'procesos
c = corte.Text

r = relleno.Text
d = distancia.Text
x = ((c / (c + r))) * d
'salida
resultado.Text = Format(x, "0.00")
End Sub
Ejemplo No 49:
Realizar un algoritmo en Visual Basic que permita calcular la distancia

horizontal entre dos puntos dadas sus coordenadas cartesianas.
'GJC & JGB
Dim norte1 As Double

Dim este1 As Double
Dim norte2 As Double
Dim este2 As Double
Dim dh As Double
'procesos
norte1 = n1.Text
este1 = e1.Text
norte2 = n2.Text
este2 = e2.Text
dh = Sqr(((norte2 - norte1)^2)+(este2 - este1^2)

'salida
resultado.Text = Format(dh, "0.00")
End Sub
A la caja de texto Text1 se le modificó su nombre (en la ventana

propiedades) por n1, Text2, Text3 y Text4 por n2, n3, y n4 Text5 por
resultado. Al botón Command1 se le cambió el nombre por Calcular.
Figura 6-7 Interfaz de aplicación (distancia horizontal)

6.6 Sentencias de control

Las son también llamadas estructuras de control, y permiten tomar
decisiones y realizar ciclos repetidas veces. Visual Basic tiene las
siguientes:
If … Then
If … Then … Else
Select Case
For … Next
While … Wend
Do … Loop
Nota: Cualquier expresión entre corchetes [ ] es opcional, de las

expresiones que figuran entre llaves { } se puede elegir una, la necesaria
en cada caso.
6.6.1 Sentencia If
Es un condicional que permite tomar una decisión referente a la acción a

ejecutar en un proceso basándose en el resultado de la condición. Su
sintaxis es:
If condición Then acción 1[Else acción 2]
donde condición debe ser una expresión numérica, relacional o lógica. El

resultado que se obtiene al evaluar la condición es verdadero (True) o
falso (False); acción 1.
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.

Esta sentencia funciona igual que la estructura de decisión Si-entonces

del capítulo 2.
Condición No Acción 2
Si
Acción 1
Figura 6-8 - Diagrama de Flujo sentencia If
Ejemplo No 50:
If angulo > 360 Then
Print "El valor angular supera el límite"

Else
Print "El ángulo se encuentra en el rango"
End If
6.6.2 Sentencia If…Then...Else
Es una estructura lógica que permiten controlar la ejecución de varias

acciones y se utiliza 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.

If condición 1 Then
Sentencias 1
[ElseIf condicion 2 Then
sentencias 2]
[Else
sentencias n]
End If
No No
Condición 1 Condición 2
Sentencias n
Si Si
Sentencias 1 Sentencias 2
Figura 4-2 Diagrama de Flujo sentencia If…Then…Else
Ejemplo No 51:
Realizar una rutina que arroje como resultado el menor de tres números
a,b,c.
If a < b Then
If a < c
menor = a
Else
menor = c

End If
Else If b < c Then

menor = b
Else
menor = c
End If
Print menor
6.6.3 Sentencia Select Case
Permite ejecutar una de varias acciones en función del valor de una

expresión. Es muy usada cuando se necesita comparar una misma
expresión con diferentes valores. Su sintaxis es:
Select Case expresión

Case Lista1
[sentencias1]
[Case lisata2
[sentencias2]]
[Case Else
[sentencias n]]
End Select
Ejemplo No 52:
Realizar un menú de que presente distintas opciones para el ajuste de

una poligonal.

'GJC & JGB
'Delcaración de variables
Dim opcion As String
opcion = InputBox("MENU DE SELECCION METODO DE AJUSTE" & _

vbCrLf & " " & _
vbCrLf & "1. Método de la Brújula" & _
vbCrLf & "2. Método del Tránsito" & _
vbCrLf & "3. Método de Crandall" & _
vbCrLf & "4. Método X,Y" & _
vbCrLf & "5. Método Mínimos Cuadrados" & _
vbCrLf & " " & _
vbCrLf & "Elija su opción" & _
vbCrLf & " ")
Select Case opcion
Case 1:
MsgBox ("1. Ajuste por el Método de la Brújula")
Case 2:
MsgBox ("2. Ajuste por el Método del Tránsito")
Case 3:
MsgBox ("3. Ajuste por el Método de Crandall")
Case 4:
MsgBox ("4. Ajuste por el Método XY")
Case 5:
MsgBox ("5. Ajuste por el Método de Mínimos Cuadrados")
Case Else:
MsgBox ("Su opción es herrada...")
End Select
End Sub

6.6.4 Sentencia For…Next
La sentencia For se utiliza para los ciclos, cuando se conoce el número de

veces que se debe ejecutar el bucle. Su sintaxis es:
For (inicializacion) To (termino del bucle) Step [paso]

[sentencias]
[Exit For]
[sentencias]
Next
La sentencia realiza una repetición desde la inicialización hasta el

término del ciclo. Para llevar la cuenta se utiliza una variable, ya veremos
en el ejemplo cómo se utiliza esta variable. Con cada ejecución del ciclo
se ejecutan unas sentencias. Next sirve para delimitar el final del ciclo,
cuando se encuentra con el Next se vuelve otra vez al principio del For,
así hasta realizar el número de ejecuciones determinado.
Existe un valor que sirve para indicar el incremento que se quiere

realizar en los saltos entre ejecución y ejecución, es el valor Step. Un
Step 2 determinará que entre ejecución y ejecución la variable se ha de
incrementar en 2 unidades. En el caso de no indicar nada se realizan
pasos de 1 en 1. También se pueden realizar pasos en valores negativos.
El siguiente ejemplo muestra un mensaje con un número de la variable i,
utilizada para llevar la cuenta de las ejecuciones del ciclo.
Ejemplo No 53:
Realizar una aplicación con la sentencia For que permita mostrar el

número 0 y los números pares hasta el 10.

Dim i As Integer
For i = 0 To 10 Step 2
MsgBox (i)
Next
End Sub
6.6.5 Sentencia While…Wend
El ciclo While...Wend sirve para realizar un tipo de ciclo muy utilizado en

programación que es el “Mientras”, que se ejecuta mientras que se
cumpla una condición. A diferencia del ciclo For, éste se utiliza cuando
no se conoce el número de iteraciones que se van a realizar.
El ciclo funciona de la siguiente manera. Cuando se va a ejecutar, evalúa

una expresión y comprueba que ésta arroja resultados positivos. Si es
así, ejecuta el cuerpo del ciclo (las sentencias que siguen hasta el Wend),
en caso contrario se sale.
Ejemplo No 54:
Escribir un algoritmo que realice una cuenta número a número hasta

llegar al 10.
En cada iteración del ciclo se muestra una ventana el número actual y
ofrece la posibilidad de cambiarlo, ya que la ventana es una ventana
InputBox, que ofrece la oportunidad de cambiar el valor y devuelve ese
valor, cambiado o no. Si se deja el ejemplo sin que el usuario entre
ningún valor, la aplicación cuenta hasta 10, pero si se entra un número

en el InputBox continúa la cuenta por el número ingresado. Si el número

entrado es mayor que 10 se sale del ciclo.
Dim a As Integer
a = 0
While (a < 10)
a = a + 1
a = InputBox("Entre un valor entero", "", a, 200, 100)
Wend
End Sub
6.6.6 Sentencia Do…Loop
Este tipo de estructura de repetición depende de una condición. Las

instrucciones que hay dentro del ciclo se repiten mientras se cumpla la
condición, mientras la condición sea verdadera. La condición puede ser
verificada antes o después de ejecutarse las sentencias.
Existen dos tipos de estructuras Do…Loop, una en que se evalúa la

condición antes de realizar alguna instrucción, y otra en que se evalúa
después de realizar, al menos, una vez las instrucciones dentro del ciclo.
Forma1:
Do[{While¦Until} condición]
[sentencias]
[Exit Do]
[sentencias]
Loop

Forma2:
Do
[sentencias]
[Exit Do]
[sentencias]
Loop[{While¦Until} condición]
Donde condición es cualquier expresión que se evalúe a True o a False.

Sentencias: líneas de código que se ejecutan mientras la condición se
verdadera.
Ejemplo No 54:
Realizar una aplicación en la cual al momento de hacer clic sobre el

formulario se visualice la suma de los números impares entre 1 y 99.
Private Sub Form_Click()
Dim i As Integer
Dim suma As Integer
i=1
Do While (i <= 99)

Suma=suma+1
i=i+2
Loop
Print suma
End Sub
Private Sub Form_Click()
Dim i As Integer
Dim suma As Integer

i=99
Do
suma=suma+1
i=i-2
Loop Until (i < 99)
Print suma
End Sub

B
Bibliografía
189
Bibliografía
Aguilar Joyanes L., Luís Rodríguez Baena, Matilde Fernández Azuela.

Fundamentos de Programación Libro de Problemas, McGraw-Hill.
España. 1996. 392 Págs.
Aguilar Joyanes L. y Rodríguez Castran H. Microsoft Visual Basic 6.0,

McGraw-Hill. España. 1999. 318 Págs.
Anderson James M., Mikhail Edward M., Introducción a la Topografía.

McGraw Hill. México. 1988. 753 Págs.
Bannister, A. , Raymond. S. y Baker R. Técnicas Modernas en Topografía.

7a edición. Alfaomega , México 2002. 550 Págs.
Cairó Osvaldo. Metodología de la programación. 3ª edición. Alfaomega,

México. 2005. 464 Págs.
Ceballos Fco. Javier. Visual Basic 6. 8ª edición. Alfaomega & Ra-Ma.

México. 2005. 498 Págs.
Davis, Raymond E., Foote, Francis S. and Kelly Joe W.. Surveying: Theory
and Practice. 5th. Ed.. McGraw-Hill Co.. New York 1966. 1096 págs.
Gómez G., Gilberto. Jiménez C. Gonzalo. Topografía Analítica. Armenia.

2003. 223 Págs.
Jiménez Cleves Gonzalo, Informática en Topografía. Universidad del

Quindío, Armenia (Q), 1990. 114 Págs.

Segovia Silvero Juan. Introducción al lenguaje SL. Centro Nacional de

Computación, CNC. Universidad Nacional de Asunción, UNA. Asunción,
Paraguay. 1999. 134 págs.
Trejos Buriticá Omar Iván. La esencia de la lógica de programación.

Editorial Papiro. Pereira (Q). 1999. 325 Págs.
Zieske Karl. Principios Básicos de Topografía. Leyca Geosystems.

Switzerland. 2000. 35 Págs.
Sitios web:
www.leica.com
www.topcon.com
www.sokkia.com
www.profsurv.com
www.elagrimensor.com.ar

Programación para Topografía
Universidad del Quindío
Facultad de Ingeniería
Programa de Topografía
Armenia – Quindío – Colombia
2007

Programación para Topografía

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programación para Topografía

Uploaded by

Copyright:

Available Formats

2007

Gonzalo Jiménez Cleves

Julián Garzón Barrero

Universidad del Quindío

Julián Garzón Barrero

1.7.3 Variables .................................................................................. 22

2. Estructuras algorítmicas de selección ........................... 57

3. Estructuras algorítmicas de repetición ......................... 81

4. Estructuras de datos ................................................... 97

4.6.2 Lectura ................................................................................... 127

5. Subrutinas ............................................................... 143

6. Introducción a Visual Basic ........................................ 159

6.6.3 Sentencia Select Case ........................................................... 182

Proveer al estudiante de las técnicas de programación básicas que le permitan abordar

 Representar mediante diagramas de flujo la formulación de un algoritmo que

 Utilizar el seudocódigo como una técnica básica para diseñar programas.

1. Algoritmos, su representación, y programas .................... 7

Universidad del Quindío 5

1.6.1 Datos simples ........................................................................... 19

6 Universidad del Quindío

1.1 Conceptos básicos de

1.1.1 Programar: Es un proceso para convertir

1.1.2 Dato: Es la cantidad mínima de información no elaborada,

1.1.3 Información: Es un conjunto organizado de datos,

1.1.4 Procesamiento de datos: Consiste en la

Universidad del Quindío 7

1.2 Algoritmos y programas

Un algoritmo es un método para resolver un problema, presentado

La palabra algoritmo viene de un matemático Persa llamado Mohammed

Programar es planificar, concebir, escribir, articular y probar las

1.3 Características de los algoritmos

8 Universidad del Quindío

Debe ser finito. Si se sigue un algoritmo, es decir debe tener un número

1.4 Pasos del desarrollo de un

1.4.1 Análisis del problema

Esta fase requiere una clara definición donde se contemple exactamente

Dado que se busca una solución se precisan especificaciones de entrada

¿Qué entradas se requieren? (cantidad y tipo)

1.4.2 Diseño del algoritmo

En la fase de análisis en el proceso de programación, se determina que

Los métodos utilizados para el proceso del diseño se basan en el

Universidad del Quindío 9

complejo se realiza dividiendo el problema en sub-problemas y a

Cada programa bien diseñado consta de un programa principal (el

Los módulos pueden ser planeados, codificados, comprobados y

El diseño del algoritmo es independiente del lenguaje de programación

Es la generación real del programa con un lenguaje de programación. En

1.4.4 Implementación y depuración

Compilación y ejecución: Una vez que el algoritmo se ha convertido en

10 Universidad del Quindío

teclado y almacenarlo posteriormente en un dispositivo de

Figura 1-1 Esquema general de creación de un programa

El programa fuente debe ser traducido a lenguaje máquina. Este proceso

Suponiendo que no existen errores durante la ejecución (errores en

Universidad del Quindío 11

Probar el programa consiste en verificar su funcionalidad a través de

1.4.5.1 Prueba de escritorio: El programador se

1.4.5.2 Prueba manual de datos de

1.4.5.3 Prueba por un grupo selecto de

Depurar es correr el programa en una computadora y corregir las partes

12 Universidad del Quindío

Errores de sintaxis o de compilación

Son errores del programa fuente, puede deberse a palabras reservadas

Potencia 28 256