Вы находитесь на странице: 1из 185

Introducción a la

Programación
Los propietarios del © tiene reservados todos los derechos. Cualquier reproducción, total o parcial de este texto, por
cualquier medio, o soporte sonoro, visual o informático, así como su utilización fuera del ámbito estricto de la información
del alumno comprador, sin la conformidad expresa por escrito de los propietarios de los derechos, será perseguida con
todo el rigor que prevé la ley y se exigirán las responsabilidades civiles y penales, así como las reparaciones procedentes.

Introducción a la Programación

Autor: SEAS, Estudios Superiores Abiertos

Imprime: El depositario, con autorización expresa de SEAS, S.A.


ÍNDICE ASIGNATURA

UNIDAD 1. PRINCIPIOS BÁSICOS

1.1. Sistemas de procesamiento de la información


1.2. La resolución de problemas
1.2.1. Definición de algoritmo
1.2.2. Características de los algoritmos
1.3. Los lenguajes de programación
1.3.1. Lenguajes máquina
1.3.2. Lenguajes de bajo nivel
1.3.3. Lenguajes de alto nivel

Introducción a la Programación 1
UNIDAD 2. TIPOS DE DATOS SIMPLES

2.1. Clasificación de los datos


2.2. Tipos de datos
2.2.1. Tipo de datos estándar
2.2.2. Tipos de datos simples definidos por el programador
2.3. Constantes y variables
2.4. Expresiones y operadores
2.4.1. Expresiones y operadores lógicos
2.5. Asignación de valores a las variables
2.6. Conversión de tipos
2.7. Funciones definidas internamente

UNIDAD 3. DESARROLLO DE ALGORITMOS

3.1. Los algoritmos


3.2. Expresión de los algoritmos
3.3. Entrada y salida de información
3.4. Diagramas de flujo
3.4.1. Desarrollo diagrama de flujo
3.5. Pseudocódigo
3.6. Desarrollo de pseudocódigo

Introducción a la Programación 2
UNIDAD 4. PROGRAMACIÓN ESTRUCTURADA

4.1. Programación estructurada


4.1.1. Programación estructurada
4.1.2. Recursos abstractos
4.1.3. Diseño descendente
4.2. Estructuras básicas
4.2.1. Estructura secuencial
4.2.2. Estructura selectiva
4.2.3. Estructura selectiva múltiple
4.3. Estructura repetitiva
4.3.1. Estructura repetitiva mientras
4.3.2. Estructura repetitiva repetir
4.3.3. Errores en los bucles

UNIDAD 5. TIPOS DE DATOS ESTRUCTURADOS

5.1. Arrays unidimensionales o vectores


5.1.1. Declaración de vectores
5.1.2. Operaciones con vectores
5.1.3. Métodos de Ordenación
5.1.4. Búsqueda
5.2. Arrays de varias dimensiones
5.3. Cadenas de caracteres
5.3.1. Datos de tipo cadena
5.3.2. Lista de Cadenas

Introducción a la Programación 3
01 Introducción a la
Programación

Principios básicos
Introducción a la Programación 01

 Índice

 OBJETIVOS .......................................................................................................... 3
 INTRODUCCIÓN .................................................................................................. 4
1.1. Sistemas de procesamiento de la información ........................................ 5
1.2. La resolución de problemas ...................................................................... 8
1.2.1. Definición de algoritmo .......................................................................... 8
1.2.2. Características de los algoritmos ........................................................ 10
1.3. Los lenguajes de programación .............................................................. 13
1.3.1. Lenguajes máquina ............................................................................. 13
1.3.2. Lenguajes de bajo nivel ...................................................................... 14
1.3.3. Lenguajes de alto nivel ....................................................................... 16
1.3.3.1. Intérpretes .................................................................................... 17
1.3.3.2. Compiladores ............................................................................... 18
 RESUMEN .......................................................................................................... 21

Principios básicos 1
Introducción a la Programación 01

 Objetivos

 Conocer lo que es un “sistema de información” y la relación que existe con los


lenguajes de programación.

 Saber qué es un algoritmo y cuáles son las características principales que lo


definen.

 Conocer qué es un lenguaje de programación, principales lenguajes de


programación y características.

Principios básicos 3
Formación Abierta

 Introducción

El objetivo principal de esta unidad es acercar al alumno al mundo de la


programación.

En esta unidad conoceremos lo que es un algoritmo. Antes de empezar a


programar, se desarrolla un algoritmo mediante el cual pretende llegar a la solución
del problema que se desea solucionar.

Para solucionar un problema lo primero que hemos de conocer son los datos de los
que disponemos y, con estos datos, qué resultados queremos obtener. El proceso
necesario para llegar a los datos finales desde los datos de partida es lo que
constituye un sistema de procesamiento de información.

4 Principios básicos
Introducción a la Programación 01

1.1. Sistemas de procesamiento de la


información
Un sistema de procesamiento de la información es aquél que partiendo de unos
datos (datos de entrada) es capaz de generar unos resultados (datos de salida) que
son significativos y útiles para el usuario. A estos datos significativos y útiles es a lo
que llamamos información.

Por lo tanto, hacemos distinción entre dos tipos de datos, por un lado los datos de
entrada, que son los datos necesarios para que el sistema “los procese” y llegue a
la información útil para el usuario o programador. Por otro lado, los datos de salida,
que es la información a la cual se llega después de haber procesado la información
de entrada.

En la figura 1.1 se pueden observar los tres componentes que forman parte de un
sistema de procesamiento de la información. El procesador, que puede ser bastante
complicado, es representado por una caja que acepta unos datos de entrada y
produce unos datos de salida.

Datos de entrada Procesador Información

Figura 1.1. Esquema básico del sistema de procesamiento de la información.

Según esta representación, muchos dispositivos pueden considerarse sistemas de


procesamiento de la información. Por ejemplo, un despertador tiene como entradas
la hora actual y la hora de alarma y como salidas el encendido del sistema para
despertar (la radio, timbre, luces). Otro sistema de procesamiento de la información
más complejo puede ser el sistema encargado de regular la temperatura en una
persona.

En este texto trataremos los sistemas de procesamiento de la información desde el


punto de vista informático, es decir, el procesador en este caso va a ser el
ordenador o computadora y más concretamente el procesador interno. El
procesador se apoyará en otros elementos para facilitar el procesamiento de la
información.

Dentro de los sistemas de procesamiento de la información, desde el punto de vista


informático, existen dos partes que hay que diferenciar:

 Hardware: está formado por el conjunto de componentes físicos de un


ordenador (equipo físico). Es la parte tangible de un ordenador.

 Software: está formado por el conjunto de programas que controlan el


funcionamiento del ordenador (equipo lógico). Es la parte no tangible de un
ordenador.

Principios básicos 5
Formación Abierta

Dentro del hardware (Figura 1.2) podemos distinguir como componentes principales
los siguientes elementos.

 Unidad Central de Proceso, CPU (Central Processing Unit): es un conjunto


de circuitos electrónicos capaces de realizar operaciones básicas tales como
sumas o productos. Un ordenador es tanto más potente cuanto mayor es la
velocidad y la fiabilidad de la CPU.

 Memoria central o principal: la memoria de un ordenador se encuentra


dividida en varias celdas o localidades, las cuales se direccionan (acceden a su
contenido) individualmente. El direccionamiento de una celda significa que el
CPU pueda identificar la posición particular dentro de la memoria para poder
almacenar un valor específico de información. La mayoría de las memorias no
saben distinguir los datos de las instrucciones o basura (información sin
significado alguno) contenidos dentro de una localidad. El usuario debe hacerse
responsable de esta tarea antes de procesar la información asignada a dichas
localidades.

 Unidades o dispositivos de almacenamiento secundario: suele ser mucho


mayor que la memoria principal (entre diez y cien veces mayor) y para un
manejo más sencillo suele estar dividida en archivos. Dispositivos de
almacenamiento típicos son los discos, CD y memorias USB. Si se quiere
procesar los datos almacenados en estos dispositivos, entonces tales datos han
de llevarse a la memoria principal. Estos tipos de dispositivos también son
conocidos como memoria auxiliar.

 Periféricos: a través de estos dispositivos el usuario puede comunicarse con el


ordenador. Algunos periféricos típicos son la impresora, monitor, teclado, ratón,
etc. A los periféricos también se les conoce como dispositivos de E/S.

Memoria
CPU Central

Dispositivos de Periféricos
Almacenamiento

Figura 1.2. Partes principales que componen el hardware de un ordenador.

En las instalaciones grandes o en grandes ordenadores es habitual tener varias


CPU´s trabajando de forma simultánea, en tales casos la memoria principal está
compartida. Al igual ocurre con los periféricos y dispositivos de almacenamiento
secundario, se pueden encontrar en diferentes partes de un mismo edificio o incluso
en diferentes ciudades o países.

6 Principios básicos
Introducción a la Programación 01

Una vez vistas las partes principales que componen el hardware de un ordenador
vamos a pasar a ver cuáles son los pasos previos que todo programador debe dar
antes de desarrollar un software para resolver un problema concreto.

Esta asignatura tiene como objetivo prioritario que el alumno asiente las bases para
poder desarrollar programas en cualquier tipo de lenguaje, es decir, en el desarrollo
del software. Los programadores desarrollan programas (algoritmos) para resolver
problemas específicos, pero antes deben dar unos pasos previos que iremos
detallando en las secciones sucesivas

Principios básicos 7
Formación Abierta

1.2. La resolución de problemas


Como se ha comentado anteriormente el objetivo principal de esta asignatura es
resolver problemas utilizando un ordenador a través de un lenguaje de
programación.

Un ordenador por sí solo no es capaz de resolver problemas por muy sencillos que
sean éstos. Para que un ordenador pueda resolver cualquier tipo de problema, éste
ha de seguir o ejecutar un conjunto de órdenes que el programador le ha
proporcionado. Este conjunto de órdenes son los pasos necesarios para resolver el
problema, lo que se conoce como algoritmo. Aunque haremos ahora una breve
introducción, será en la siguiente unidad didáctica donde desarrollaremos mejor
este concepto.

1.2.1. Definición de algoritmo


La palabra algoritmo se deriva de la traducción al latín de la palabra árabe
alkhowarizmi, nombre de un matemático y astrónomo árabe que escribió un tratado
sobre manipulación de números y ecuaciones en el siglo IX.

Un algoritmo es un conjunto de operaciones que se utilizan para resolver un


problema específico. En este conjunto de instrucciones se indica la secuencia de
operaciones que se deben realizar para, a partir de los datos de entrada, obtener el
resultado buscado. El concepto de algoritmo es anterior a los ordenadores, y
ampliamente utilizado en el mundo de la ciencia para la resolución metódica de
problemas. Sin embargo, con la aparición de los ordenadores se comprobó que era
una herramienta ideal, ya que cualquier algoritmo puede transformarse en un
programa informático.

Los pasos para resolver un problema usando un computador, a través de un


algoritmo, son los siguientes:

1. Análisis del problema: se conocen los datos de entrada y los resultados


que deseamos obtener.
2. Diseño del algoritmo: se describe la secuencia ordenada de pasos que
conducen a la solución del problema a resolver. Esta secuencia de pasos
debe ser clara, sin ambigüedades, que permitan llegar a distintas soluciones
con los mismos datos de partida. Se puede expresar mediante gráficos
(diagramas de flujo, diagramas de Nessie Sheneiderman, cartas de
estructura) o mediante texto (pseudocódigo).

8 Principios básicos
Introducción a la Programación 01

3. Expresar el algoritmo: mediante un lenguaje de programación, en un


programa que pueda ejecutar el ordenador. A este paso se le conoce como
codificación y al código primero resultante, código fuente, el cual debe ser
traducido a código máquina para que pueda ser entendido y ejecutado por el
ordenador. Esta traducción se realiza de manera automática, utilizando
programas compiladores o intérpretes.

 Compilador: hace la traducción de una vez, generando y almacenado el


código máquina que podrá ser ejecutado directamente siempre que lo
necesitemos.

 Intérprete: transforma y ejecuta, simultáneamente, línea a línea el código


fuente del programa.
4. Ejecución y validación del programa por el ordenador: no siempre los
programas diseñados funcionan en todos los ordenadores. Se debe probar
el programa con varios datos de entrada, buscando y corrigiendo posibles
errores de la fase de codificación.

Cabe citar que no acaba aquí el ciclo de vida de un programa ya que después de
las vistas, existe siempre la fase de mantenimiento, donde el programa entregado
ya al cliente debe mantenerse ‘vivo’, es decir, se corrige o modifica cada vez que
sea necesario, de modo que se cumplan todas las necesidades de cambio de sus
usuarios.

En resumen, se puede decir que para resolver un problema en un ordenador, antes


se ha tenido que diseñar un algoritmo, es el paso previo a introducir un programa
en un ordenador.

Los algoritmos siempre son independientes tanto del lenguaje de programación en


el que se quiere expresar como del ordenador en el cual se va a ejecutar el
programa. El algoritmo se podrá expresar de distintas formas en función del
lenguaje de programación elegido y se puede ejecutar en ordenadores distintos,
pero en todos los casos el algoritmo siempre será el mismo.

En programación siempre son más importantes los algoritmos que los ordenadores
o los lenguajes de programación. El lenguaje de programación sirve para expresar
el algoritmo y el ordenador es el procesador que sirve de medio para ejecutar el
programa. Los lenguajes de programación y los ordenadores son los medios
utilizados para conseguir el objetivo propuesto: resolver el algoritmo. Por ejemplo,
podemos tener un algoritmo y lo podemos resolver mediante el lenguaje de
programación Pascal o C y utilizando un ordenador cuyo procesador es un Intel o
un procesador AMD. En todos los casos el algoritmo es el mismo, lo único que
cambia es la forma de expresar el algoritmo en un programa y el compilador o
programa encargado de pasar el programa expresado en código fuente a código
ejecutable, que es entendible por el procesador.

Principios básicos 9
Formación Abierta

Como se ha visto anteriormente el desarrollo de algoritmos es la base de todo


programador. Este texto está enfocado a que el lector vaya aprendiendo a diseñar
algoritmo y que conozca las distintas herramientas de que se dispone para
desarrollar dicho algoritmo.

Fases para la solución de un problema computable

Solución de
un problema
complutable

Diseño y Codificación
Análisis Ejecución Prueba
verificación del
del del del
del algoritmo
problema programa programa
algoritmo Lenguaje C

Identificar Herramientras de
Definir y Identificar
los datos Diseño Refinamiento programación:
entender el los datos
de salida = descendente por pasos -Diagramas de flujo
problema de entrada
resultado -Pseudocódigo

Figura 1.3. Fases en la solución de un problema.

1.2.2. Características de los algoritmos


Todo algoritmo, para que esté correctamente desarrollado, debe cumplir tres
características básicas que son:

1. Un algoritmo debe ser preciso. Debe indicar en todo momento la


secuencia de realización de los pasos del algoritmo.
2. Un algoritmo debe estar definido. Un algoritmo que se sigue dos veces o
más y tiene los mismos datos de entrada, debe de llegar al mismo resultado
final.
3. Un algoritmo debe ser finito. Un algoritmo debe finalizar después de un
número finito de pasos, es decir, no se pueden diseñar algoritmos en los
cuales no se llega al fin nunca.

10 Principios básicos
Introducción a la Programación 01

En la definición de un algoritmo para que éste se pueda desarrollar correctamente


debe contener o describir tres partes fundamentales que son:

 Entrada: los datos de entrada del algoritmo, es decir, qué datos necesita el
algoritmo para que se pueda ejecutar.
 Proceso: los pasos necesarios que se han de dar para llegar a la solución
del algoritmo.
 Salida: es la solución del algoritmo.

Ejemplo 1.1

Se quiere diseñar un algoritmo para sumar dos números. En este caso la entrada
del algoritmo son los dos números a sumar, mientras que la salida es la suma de
los dos números. El proceso es la secuencia de pasos que hemos de dar para,
partiendo de los datos de entrada, llegar a los datos de salida. Para este ejemplo
concreto el proceso es el siguiente:

 Pedir el primer número.


 Pedir el segundo número.
 Hacer la suma de los dos números.
 Dar el resultado.

Éste es un sencillo ejemplo para ilustrar el desarrollo de un algoritmo. En este


ejemplo se “piden” los números. Esto quiere decir que se solicitan al usuario de este
algoritmo que diga qué números quiere sumar.

En general el proceso del algoritmo va a depender de la entrada y la salida, es


decir, que si el número de entradas que se necesita es distinto, el proceso
cambiará. Si la salida del algoritmo cambia, el proceso seguido en el algoritmo
cambiará.

Para ilustrar la explicación anterior vamos a poner ejemplos concretos para el


algoritmo anterior.

Ejemplo 1.2

Hacer la suma de los números 6 y 3. Los pasos del proceso son los que
anteriormente se han comentado:

 Pedir el primer número. (6)


 Pedir el segundo número. (3)
 Hacer la suma de los dos números. (6+3=9)
 Dar el resultado. (9)

Principios básicos 11
Formación Abierta

¿Sirve este mismo algoritmo para hacer la suma de tres


números?

Veamos, las entradas del algoritmo son tres números y la salida es la suma de los
tres números, puesto que las entradas y las salidas son distintas, el algoritmo es
distinto. Se va a desarrollar el algoritmo y entre paréntesis se expone un ejemplo
concreto de resolución del algoritmo.

 Pedir el primer número. (6)


 Pedir el segundo número. (3)
 Pedir el tercer número. (5)
 Hacer la suma de los dos primeros números. (6+3=9)
 Hacer la suma del resultado anterior con el tercer número. (9+5=14)
 Dar el resultado. (14)

12 Principios básicos
Introducción a la Programación 01

1.3. Los lenguajes de programación


Una vez que se ha desarrollado el algoritmo y se pretende ejecutar en un ordenador
necesitamos herramientas que nos permitan pasar de un lenguaje entendible por
las personas, a un lenguaje que entienda el ordenador y sea capaz de trabajar con
él, y más concretamente el procesador del ordenador. Por lo tanto, el procesador
va a ser el encargado de realizar la segunda parte fundamental en el desarrollo del
algoritmo como es el proceso.

Los lenguajes de programación sirven para expresar el algoritmo de forma que sea
entendible, tanto para las personas como para el ordenador. Cuando expresamos
un algoritmo mediante un lenguaje de programación lo llamamos programa. Al
hecho de desarrollar un programa se llama programación, y por lo tanto, a las
personas que desarrollan y diseñan programas se les llama programadores.

Hay distintos lenguajes de programación y la principal clasificación de los mismos


es la siguiente:

 Lenguaje máquina.

 Lenguaje de bajo nivel o ensamblador.

 Lenguaje de alto nivel.

1.3.1. Lenguajes máquina


Los lenguajes máquina son lenguajes de programación que son directamente
entendibles por la máquina, ya que las instrucciones utilizadas para desarrollar los
programas son cadenas binarias (ceros lógicos y unos lógicos). Los procesadores
de los ordenadores están formados por circuitos electrónicos que manejan niveles
de tensión de 0 voltios (cero lógico) y 3.3 ó 5 voltios (uno lógico). Mediante esta
cadena binaria lo que se hace es dar unos valores lógicos a determinados registros
del procesador, en general especifican la operación a realizar y las posiciones
(direcciones de memoria) donde se encuentran los operandos. El lenguaje máquina
también se conoce como código máquina.

En la figura 1.4 se puede ver un ejemplo de instrucciones máquina utilizadas para


programar el procesador:

Dirección Contenido

0100 0010 0000 0100


0101 0100 0000 0101
0102 0011 0000 0110
0103 0111 0000 0111

Figura 1.4. Instrucciones en lenguaje máquina.

Principios básicos 13
Formación Abierta

Las instrucciones en lenguaje máquina dependen del procesador que se esté


programando, es decir dependen del hardware del ordenador, en consecuencia si
cambiamos de ordenador, más concretamente de procesador, el lenguaje máquina
utilizado probablemente no sea el mismo.

Las principales ventajas de utilizar los lenguajes máquina para programar son la
posibilidad de cargar en memoria el programa a ejecutar sin tener que utilizar un
programa de traducción. Esto supone una velocidad de ejecución mayor respecto a
los otros lenguajes de programación, que requieren la utilización de programas que
traduzcan a lenguaje máquina, puesto que en última instancia es lo que el
procesador entiende.

Los principales inconvenientes de los lenguajes máquina son los siguientes:

 Dificultad y lentitud en la codificación: esto es debido al tipo de


instrucciones que se manejan, cadenas binarias. Además se ha de conocer
la arquitectura interna del procesador para programar adecuadamente.
 Poca fiabilidad: debido al tipo de instrucciones que se manejan es fácil
equivocarse.
 Verificación y puesta a punto de los programas dificultosa: si se
producen errores es difícil detectar dónde se han producido y por qué se
han producido.
 Los programas sólo son ejecutables en ordenadores que utilicen el
mismo procesador: si se cambia de procesador el programa ya no sirve.

Por todas estas razones no son muy utilizados estos lenguajes de programación,
excepto por los programadores expertos encargados de desarrollar aplicaciones
informáticas muy concretas.

Además, el tiempo empleado para formar a un programador es muy grande,


respecto al utilizado para formar a un programador utilizando otros tipos de
lenguajes, los cuales se sirven de instrucciones que manejan expresiones muy
cercanas al lenguaje cotidiano como son los lenguajes de bajo nivel y los lenguajes
de alto nivel.

1.3.2. Lenguajes de bajo nivel


Los lenguajes de bajo nivel son lenguajes que están a mitad de camino entre los
lenguajes máquina y los lenguajes de alto nivel. Son más fáciles de usar que los
lenguajes máquina puesto que en este caso las instrucciones utilizadas no son
cadenas binarias sino nemotécnicas.

El lenguaje de bajo nivel por excelencia es el ensamblador.

14 Principios básicos
Introducción a la Programación 01

Los programas escritos en lenguaje ensamblador, a diferencia de los programas


escritos en lenguaje máquina no pueden ser ejecutados directamente por el
ordenador (procesador), sino que necesita ser “traducido” al lenguaje máquina. Por
lo tanto, se añade una fase más, la fase de traducción lo cual implica que se
necesita un programa que haga de traductor entre los dos lenguajes. Al programa
traductor se le llama programa ensamblador.

En los lenguajes máquina, el programador escribe el programa y una vez finalizado


se carga en el ordenador. En este caso, puesto que el programa se escribe en
lenguaje ensamblador, al programa de partida se le llama programa fuente,
mientras que al programa al que llegamos después de utilizar el ensamblador y
obtener el código que se va a cargar en el ordenador se le llama programa objeto.

Programa
Programa Programa
Objeto en código
Fuente en esamblador Ensamblador
máquina

Figura 1.5. Fase de traducción mediante programa ensamblador.

Hay que diferenciar entre programa ensamblador, que como hemos visto es el
programa encargado de traducir el programa fuente, escrito en lenguaje
ensamblador, a programa fuente expresado en lenguaje máquina directamente
entendible por el ordenador.

Las ventajas de los lenguajes ensambladores son las siguientes:

 Velocidad: la traducción a lenguaje máquina es muy rápida, ya que están


orientados a un hardware concreto.
 Tamaño: al traducir el lenguaje se generan las líneas de código máquina
necesaria.
 Flexibilidad: se pueden seleccionar instrucciones específicas de una
arquitectura para determinadas operaciones

Los inconvenientes de los lenguajes ensambladores son:

 Tiempo para programar: el lenguaje ensamblador requiere más


instrucciones para realizar el mismo proceso que un lenguaje de alto nivel.
Es difícil de leer y escribir.
 Tamaño de los programas fuente: al especificar cada operación de forma
determinada para la máquina, se generan muchas líneas de código en los
programas fuentes.
 Falta de portabilidad: los programas están hechos para una máquina o
arquitectura específica.

Principios básicos 15
Formación Abierta

 La aplicación principal de los lenguajes ensamblador es la programación


de micros, en los cuales la velocidad de ejecución es más importante que el
programa en sí. También se utilizan para programar micros que controlan
procesos industriales, así como dispositivos electrónicos. En definitiva,
utilizan principalmente para aplicaciones muy concretas.

1.3.3. Lenguajes de alto nivel


En la actualidad, son los lenguajes más utilizados por los programadores para
desarrollar sus aplicaciones. Estos lenguajes utilizan expresiones muy cercanas al
lenguaje humano, lo cual implica que un programa escrito en este tipo de lenguaje
es más fácil de entender que los programas escritos en lenguaje máquina o
lenguaje ensamblador.

La principal razón de que este tipo de lenguajes sean los más utilizados es la
portabilidad o transportabilidad, esto es, el mismo programa fuente escrito en un
lenguaje de alto nivel puede ejecutarse en distintos ordenadores o procesadores
con pocos o ningún cambio. Esto es debido a que este tipo de lenguajes son
independientes de la arquitectura física de la máquina, al contrario que ocurre con
los otros dos tipos de lenguajes que sólo se pueden ejecutar los programas en
determinadas máquinas.

El término "alto nivel" significa que el lenguaje está más orientado hacia la gente, en
contraste con los lenguajes de "bajo Nivel", ensambladores, que están más
orientados hacia la máquina Por su mayor orientación hacia el usuario, los
lenguajes de alto nivel tienen más relación con el lenguaje hablado que con el
lenguaje de máquina y por ello resultan más fáciles de comprender.

Las principales ventajas de los lenguajes de alto nivel son las siguientes:

 Transportabilidad: ésta es característica principal. Como se ha comentado


anteriormente el programa fuente escrito en un ordenador puede ejecutarse
en otro ordenador realizando pocos o ningún cambio.
 Los programas están escritos utilizando expresiones muy parecidas a las
utilizadas en lenguajes humano tales como READ, WRITE, IF THEN ELSE,
etc.
 Debido al tipo de instrucciones utilizadas las modificaciones de los
programas, así como la puesta a punto de los mismos es mucho más fácil
que en los otros lenguajes.
 El tiempo empleado para la formación de los programadores es más corto,
puesto que además de que la sintaxis de los lenguajes de alto nivel es más
sencilla, el programador no necesita conocer la arquitectura física del
ordenador o procesador sobre la que está trabajando.

16 Principios básicos
Introducción a la Programación 01

 Como consecuencia de todo lo anterior se reduce el coste del desarrollo de


los programas.

Las principales inconvenientes de los lenguajes de alto nivel son:

 Puesto que no es necesario conocer la arquitectura física de la máquina,


tampoco se aprovechan las posibles ventajas de éstas.
 El tiempo empleado para su ejecución, en general, es mayor puesto que el
programa fuente tiene que traducirse a lenguaje máquina, y normalmente se
genera más código que si se programase en lenguaje máquina o lenguaje
ensamblador.
 Mayor uso de memoria durante el proceso de compilación o traducción del
lenguaje de alto nivel.

Como se ha comentado anteriormente, en el ordenador o procesador sólo se puede


ejecutar código máquina, en consecuencia, para que un programa escrito en
lenguaje de alto nivel se pueda ejecutar necesitamos pasar a código máquina dicho
programa. Existen dos tipos de programas que traducen de lenguaje de alto nivel a
lenguaje máquina que son los intérpretes y los compiladores y que se van a
describir en los siguientes apartados.

1.3.3.1. Intérpretes
Un intérprete es un programa que lee, analiza, traduce y ejecuta un programa
fuente escrito en un leguaje de programación.

El esquema general del funcionamiento de un intérprete es el siguiente:

Programa
Fuente

Intérprete

Programa
Objeto

Figura 1.6. Esquema general del funcionamiento de un intérprete.

A cada instrucción de alto nivel le suelen corresponder varias de lenguaje máquina,


tantas más cuanto más compleja sea la instrucción.

Principios básicos 17
Formación Abierta

Debido a la forma de traducir que utilizan los intérpretes, éstos tienen, básicamente,
la siguiente serie de características importantes:

 Los programas objeto se ejecutan de forma lenta. Esto es debido a que,


además de ejecutar el código máquina, hay que realizar el análisis y la
traducción de cada bloque, cada vez que se ejecute.
 Los programas objeto se pueden detener, modificar el programa fuente y
continuar con la ejecución del nuevo programa objeto.
 Los programas objeto son muy robustos, pues se pueden hacer chequeos,
durante la ejecución, de situaciones anómalas y/o peligrosas.
 Fácilmente transportables entre distintas máquinas, puesto que es el propio
programa fuente lo que se mueve. Suelen ser lenguajes independientes de
la máquina.

En general, se utilizan intérpretes para lenguajes de alto nivel, donde predomine el


procesamiento simbólico y abstracto. Ejemplos de lenguajes interpretados son LISP
y BASIC

1.3.3.2. Compiladores
Los compiladores son traductores que realizan su tarea globalmente, de forma que
se analiza todo el programa fuente, se genera el código máquina correspondiente, y
se almacena, todo de una vez. Una vez realizada la traducción, el programa objeto,
que se ha almacenado, se puede ejecutar tantas veces se quiera sin tener que
volver a traducir. Así, el análisis y la traducción son secuenciales, y la ejecución es
independiente. El esquema general del funcionamiento de un compilador es el
siguiente:

Programa
Fuente

Compilador

Programa
Objeto

Figura 1.7. Esquema general del funcionamiento de un compilador.

18 Principios básicos
Introducción a la Programación 01

Debido a la forma de traducir que utilizan los compiladores, éstos tienen,


básicamente, las siguientes características importantes:

 Los programas objeto se ejecutan de forma muy rápida. Esto es debido a


que, una vez traducido el programa fuente, no hay que volver a traducirlo
cada vez que se ejecute.
 Los programas objeto no se pueden detener, modificar el programa fuente, y
continuar con la ejecución. Cada vez que se detienen hay que volver a
ejecutar el programa de nuevo.
 Los programas objeto son poco robustos, pues no se hacen chequeos,
durante la ejecución, de situaciones anómalas y/o peligrosas, por motivos de
rendimiento (éstos ralentizarían la ejecución).
 Difícilmente transportables entre distintas máquinas, puesto que es
programa objeto lo que se mueve. Suelen ser lenguajes cuyos programas
objetos son dependientes de la máquina.

En general, se utilizan compiladores para lenguajes de bajo nivel, donde predomine


la programación de sistemas y grandes volúmenes de cálculos. Un ejemplo de
lenguaje compilado es C.

Principios básicos 19
Introducción a la Programación 01

 Resumen

 La principal razón para que las personas aprendan lenguajes de programación


es utilizar un ordenador como una herramienta para la resolución de
problemas. Tres fases pueden ser identificadas en el proceso de resolución :

 Fase de identificación (qué nos plantean).


 Fase de resolución del problema.
 Fase de implementación (realización) en un lenguaje de programación.

 Desde el punto de vista informático, un sistema de procesamiento de la


información está compuesto por dos partes: hardware y software. El hardware
es la parte física de un ordenador, mientras que el software es el programa
que se almacena y ejecuta en el hardware.

 Los algoritmos son independientes del lenguaje de programación, es decir, son


la base de todos los lenguajes de programación, ya que un programador
cuando desarrolla un programa previamente ha desarrollado un algoritmo,
aunque sea de forma inconsciente.

 Hay varios lenguajes de programación, lenguajes máquina, lenguajes de bajo


nivel y por último lenguajes de alto nivel. Los lenguajes máquina y los
lenguajes de bajo nivel dependen totalmente de la arquitectura de la máquina,
es decir, que se cambia de máquina (procesador), y por tanto los lenguajes
cambian. Por el contrario en los lenguajes de alto nivel, el programa fuente es
independiente de la máquina.

 Diseño del algoritmo. Un algoritmo puede ser definido como la secuencia


ordenada de pasos, sin ambigüedades, que conducen a la resolución de un
problema dado y expresado en lenguaje natural, por ejemplo el castellano,
Todo algoritmo debe ser:

 Preciso: indicando el orden de realización de cada uno de los pasos.


 Definido: si se sigue el algoritmo varias veces proporcionándole los mismos
datos, se deben obtener siempre los mismos resultados.
 Finito: al seguir el algoritmo, este debe terminar en algún momento, es decir
tener un número finito de pasos.

Principios básicos 21
02 Introducción a la
Programación

Tipos de datos simples


Introducción a la programación 02

 Índice

 OBJETIVOS .......................................................................................................... 3
 INTRODUCCIÓN .................................................................................................. 4
2.1. Clasificación de los datos .......................................................................... 5
2.2. Tipos de datos ............................................................................................. 7
2.2.1. Tipo de datos estándar ......................................................................... 7
2.2.2. Tipos de datos simples definidos por el programador......................... 10
2.3. Constantes y variables ............................................................................. 12
2.4. Expresiones y operadores ....................................................................... 16
2.4.1. Expresiones y operadores lógicos ...................................................... 20
2.5. Asignación de valores a las variables .................................................... 26
2.6. Conversión de tipos .................................................................................. 29
2.7. Funciones definidas internamente .......................................................... 31
 RESUMEN .......................................................................................................... 33

Tipos de datos simples 1


Introducción a la programación 02

 Objetivos

 Conocer lo que es un dato, así como los datos básicos que se disponen
en todos los lenguajes de programación, partiendo de los tipos de datos
generales utilizados para el desarrollo de algoritmos.

 Conocer, en un programa, lo que es una constante y lo que es una


variable.

 Principales operadores que se utilizan para operar con los datos.

 Expresiones que se pueden generar con los datos y operadores, y saber


interpretarlas y el tipo de resultado que producen.

Tipos de datos simples 3


Formación Abierta

 Introducción

Como se ha comentado en la unidad anterior, para que un proceso pueda


ejecutarse normalmente necesita unas entradas y, en función de esas
entradas, genera unas salidas.

A esas entradas es a lo que llamamos datos de entrada. Antes de diseñar el


algoritmo hemos de conocer cómo podemos representar estos datos de
entrada, para que el ordenador pueda trabajar con ellos. No sólo los datos de
entrada, sino los que se puedan generar durante el desarrollo del algoritmo.

Ejemplos de datos que se pueden manejar son la nómina de un empleado de


una determinado empresa, los nombres de los empleados, el número de
kilómetros que separan dos ciudades, o si un empleado trabaja de día o de
noche.

Un dato es una abstracción de algo que se quiere representar, por ejemplo, el


número 2 puede representar dos kilómetros, dos manzanas, el número de
veces que un empleado tiene que coger el coche para desplazarse o
simplemente el número dos. Por lo tanto, un dato es la representación de un
hecho o concepto.

La mayoría de los ordenadores maneja distintos tipos de datos que facilitan


la representación de conceptos. Puesto que los ordenadores manejan datos,
los algoritmos y programas desarrollados por los programadores han de
operar sobre los datos.

Las instrucciones, tanto de los algoritmos como de los programas,


modificarán los datos de entrada o los datos iniciales para finalmente,
después de las operaciones necesarias, producir los datos de salida o
información.

Por lo tanto, antes de ver cómo desarrollar algoritmos, vamos a conocer de


qué tipos de datos disponemos. En esta unidad nos centraremos en los
simples, pues con ellos es suficiente de momento para avanzar en nuestro
estudio.

4 Tipos de datos simples


Introducción a la programación 02

2.1. Clasificación de los datos


Los datos se pueden dividir en datos simples y datos estructurados. Los datos
simples son los datos básicos; es decir, que no están basados en otros datos,
al contrario que los datos estructurados, los cuales son agrupaciones de
datos simples.

Datos

Numérico Carácter Lógico

Real Entero

Figura 2.1. Clasificación de los tipos de datos simples o estándar.

Dentro de los datos simples se encuentran los datos estándar y los datos
definidos por el usuario. Los tipos de datos estándar son los datos básicos a
partir de los cuales se forman todos los demás. Los datos definidos por el
programador son datos que el programador define por comodidad o
conveniencia.

Los tipos de datos estándar se dividen en numéricos -dentro de los cuales


encontramos los enteros y los reales, ambos para representar cantidades
numéricas-, carácter -que sirven para representar caracteres de texto o
agrupaciones de estos (cadenas)-, y por último están los datos lógicos.

Los tipos de datos definidos por el programador pueden ser sub-rango, y


como su nombre indica son un sub-rango de los tipos de datos estándar que
el programador define en función del cual va a utilizar. También pueden ser
enumerados, siendo el usurario el que define expresamente que datos se
manejan, por ejemplo colores del arco iris.

Los tipos de datos estructurados únicamente se van a enumerar, pero sin


entrar en detalle puesto que no es el objetivo de este texto.

Tipos de datos simples 5


Formación Abierta

Cuando agrupamos los datos, simples en diferentes estructuras tenemos los


datos estructurados, estos pueden ser estáticos o dinámicos. Los datos
estructurados estáticos o simples son aquellos en los que antes de ejecutarse
el programa se define el número máximo de ellos que puede tener y, en
consecuencia, se reserva la cantidad de memoria necesaria para albergar esa
cantidad de datos. Estas estructuras son los arrays (equivalente a los
vectores y matrices de matemáticas), registros, ficheros, y conjuntos.

Por otro lado, los tipos de datos estructurados dinámicos o compuestos no


tienen limitación del número de elementos que pueden almacenar al
comenzar el programa, sino que a medida que aparecen nuevos datos se va
reservando espacio en memoria para dichos datos.

Un dato simple es indivisible (atómico), es decir, no se


puede descomponer. Un año es un dato simple. Año...:
2006

Un año se expresa con un número entero, el cual no se


puede descomponer. Sin embargo, un dato estructurado
está formado por otros datos. Una fecha es un dato
compuesto por tres datos simples (día, mes, año).

Fecha: Día...: 30 Mes...: 11 Año...: 2006

6 Tipos de datos simples


Introducción a la programación 02

2.2. Tipos de datos


Los tipos de datos simples son los datos más básicos que existen. A partir de
estos tipos de datos se forman todos los demás. Los tipos de datos simples
se dividen en estándar y son definidos por el programador.

2.2.1. Tipo de datos estándar


Los tipos de datos estándar también llamados simples, a su vez se dividen
en:

 Numéricos.
 Lógicos.
 Carácter.

Tipos de datos numéricos

El tipo de dato numérico sirve para representar los valores numéricos. En


analogía con las matemáticas se pueden representar de dos formas distintas:

 Tipo numérico entero. La principal diferencia entre cada uno de los


tipos de enteros es su tamaño, que va desde 1 byte de
almacenamiento hasta los 8 bytes, son los correspondientes a los
enteros tradicionales vistos en matemáticas. Los enteros se
caracterizan porque son números que no tienen parte decimal. A nivel
algorítmico, podemos utilizar cualquier número entero, pero no ocurre
así a la hora de plasmar el algoritmo en programa. Los ordenadores
tienen una capacidad limitada para representar números, es por ello
que, en los ordenadores, únicamente se pueden representar un
subconjunto finito de los números enteros. Este subconjunto
representable, en general, depende del ordenador.

Algunos ejemplos de números enteros son: 12, -15, 30, -123, 1349,
etc. A veces también se hace referencia a los números enteros como
números de punto fijo o coma fijo en contraposición a los números
reales que también son conocidos como números de coma flotante.

Es decir, subconjunto finito de los números enteros, cuyo rango


dependerá del lenguaje en el que posteriormente codifiquemos el
algoritmo y del ordenador.

El rango depende de cuantos bits utilice para codificar el número,


normalmente 2 bytes.

Tipos de datos simples 7


Formación Abierta

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.

 Tipo numérico real: los tipos de datos reales son los


correspondientes a los números reales vistos en matemáticas Al igual
que ocurre con los números enteros cuando desarrollamos el
algoritmo podemos trabajar con cualquier número real, pero no ocurre
lo mismo al expresar este algoritmo como programa, puesto que en el
ordenador sólo podemos trabajar con un subconjunto de los números
reales. El tamaño de este subconjunto depende del ordenador.

Los números reales se componen de una parte entera, parte decimal y


punto decimal y además pueden ser negativos o positivos.

Algunos ejemplos de número reales son: 0.008, 352.16, -145.23,


2.3156 etc. El rango de representación de números reales es mucho
mayor que en los números enteros. Hay distintas formas de
representación de número reales, y en función del tamaño del número
se utiliza una u otra, esto es debido a que el ordenador sólo puede
representar un número finito de dígitos. Si el número es muy grande
no se representa adecuadamente, para evitar esto se utiliza la
notación exponencial o científica. Ejemplos:

 45729000000000000 = 45 729 000 000 000 000 = 4.5729 x 10 16

 0.000000000015245 = 1.5245 x 10 –11

En la notación exponencial o científica la parte entera es siempre


menor que diez y mayor que cero. Como generalización de la
representación exponencial está la representación en coma flotante,
que es una generalización de la notación científica en la cual la parte
entera ya no tiene que estar comprendida entre cero y diez. Así por
ejemplo para los números anteriores:

 4.5729 x 10 16 = 45.729 x 1015 = 0.45729 x 1017

 1.5245 x 10 –11 = 15.245 x 10 –12 = 152.45 x 10-13

En los números anteriores, a la base se le llama mantisa y al número


que está elevado el número diez se le llama exponente.

8 Tipos de datos simples


Introducción a la programación 02

Tipos de datos lógicos

A los tipos de datos lógicos también se les llama booleanos debido a que son
utilizados en el álgebra de Boole. Estos tipos de datos sólo pueden tomar uno
de los dos siguientes valores:

 Cierto o verdadero.
 Falso.

Este tipo de datos se utilizan para representar decisiones a determinadas


condiciones o expresiones. Por ejemplo, un número es divisible por 5 (cierto)
o no lo es (falso). Para generar un dato o valor lógico a partir de otros tipos de
datos, típicamente, se emplean los operadores relacionales (u operadores de
relación), por ejemplo: 0 es igual a falso y 1 es igual a verdadero:

 (3>2)= 1 = verdadero
 (7>9)= 0 = falso

Una vez se dispone de uno o varios datos de tipo booleano, éstos se pueden
combinar en expresiones lógicas mediante los operadores lógicos (AND, OR,
NOT,...). Un ejemplo de este tipo de expresiones sería:

 Verdadero AND falso --> falso


 Falso OR verdadero --> verdadero
 NOT verdadero --> falso

Datos de tipo carácter

El tipo carácter sirve para representar un único carácter. Al igual que con los
tipos de datos numéricos el ordenador sólo reconoce un conjunto limitado de
caracteres. El conjunto de caracteres que reconoce el ordenador no siempre
coincide, aunque la mayoría de los ordenadores reconoce los siguientes
subconjuntos:

 Caracteres alfabéticos mayúsculas (A, B, C,...,Z)


 Caracteres alfabéticos minúsculas (a, b, c,..., z)
 Caracteres especiales (+, -, *, /,..., <, >,...)

Los caracteres se representan, en los algoritmos (y generalmente en los


programas) entre comillas, ‘A’, ‘1’, ‘$’.

Tipos de datos simples 9


Formación Abierta

Hay un tipo de datos que trata los caracteres como agrupaciones de éstos. A
este tipo de datos se les llama cadenas y siempre contienen una sucesión de
caracteres. La principal característica de las cadenas es la longitud que indica
el número máximo de caracteres que puede almacenar. Habitualmente una
cadena se representa entre comillas dobles, por ejemplo:

 “Esto es una cadena”.


 “Introducción a la programación”.
 “¡Mañana es día 23!”.

2.2.2. Tipos de datos simples definidos por el


programador
Podemos tener dos tipos de datos definidos por el programador, uno es el tipo
de dato sub-intervalo o subrango y el otro es el tipo de dato enumerado. Estos
tipos de datos sirven para mejorar la autodocumentación de los programas,
así mismo ayudan a garantizar su correcta ejecución.

Tipo de dato subrango o subvalor

En determinados algoritmos o programas es posible que sólo se utilicen un


subrango determinado del rango total de datos que se pueden utilizar. En
tales casos es conveniente definir un subrango. Por ejemplo, si se pretende
hacer un algoritmo para hacer la media de las notas de una clase y las notas
están comprendidas entre 0 y 10 se puede definir un tipo de dato para tratar
con las notas.

Más adelante veremos cómo se pueden declarar este tipo de datos, para ello
se escribe de la siguiente forma:

 Notas: 1..10

Notas, en este caso, es un tipo de dato que sólo puede tener valores enteros
mayores o iguales que cero y menores o iguales que 10. En este caso
estamos tomando un subintervalo de los números enteros, por lo tanto, es
tipo anfitrión o tipo base.

Hay una restricción a la hora de utilizar o crear nuevos tipos de datos


subrango y es que el tipo anfitrión o tipo base tiene que ser un tipo ordinal. Un
tipo ordinal, como veremos más adelante, es un conjunto de datos en el cual
podemos especificar todos los posibles valores en orden, es decir, se puede
decir cuál es el primero de la lista, el segundo y así sucesivamente.

10 Tipos de datos simples


Introducción a la programación 02

Una propiedad semejante es que todo elemento de un tipo de dato ordinal


tiene un sucesor y un predecesor, excepto el primero y el último elemento de
la lista.

De los tipos de datos vistos hasta ahora el único tipo de dato que no es un
tipo ordinal es el tipo de dato numérico real, puesto que para un número real
dado no se conoce el sucesor ni el predecesor, por lo tanto, de todos los
demás tipos de datos podemos definir subrangos.

Otro ejemplo de tipo de datos subrango puede ser:

(A..F) Subconjunto finito de caracteres que puede tomar


los valores A, B, C, D, E, F.

Tipo de dato enumerado

Los tipos de datos enumerados son aquellos cuyos valores se han listado
explícitamente en orden, es decir, enumerados. Por ejemplo se puede
declarar un tipo de dato llamado ColoresPrimarios, que puede tomar los
valores Rojo, Verde y Azul. Para definir un tipo de dato de esta forma se
haría:

 ColoresPrimarios = (Rojo, Verde y Azul)

Una vez declarado el tipo de dato ya podríamos trabajar con él. Los tipos de
datos enumerados también son un tipo de dato ordinal, puesto que en la
declaración se han listado todos los posibles valores que pueden tomar y en
consecuencia todos los elementos tienen un sucesor y predecesor,
exceptuando el primero y el último de la lista. Otros ejemplos de tipos de
datos enumerados son:

 DíasSemana =(Lunes, Martes, Miércoles, Jueves, Viernes, Sábado y


Domingo)
 DíasLaborables = (Lunes, Martes, Miércoles, Jueves y Viernes)

Tipos de datos simples 11


Formación Abierta

2.3. Constantes y variables


Una variable o constante es la estructura más sencilla que nos podemos
encontrar para almacenar datos.

Vamos a poner un poco de imaginación, una variable es una caja en la que


podemos guardar números, textos o cualquier otra cosa; es decir, valores. El
valor de una variable se puede manipular, simplemente con la operación de
asignación. Ésa es de las primeras instrucciones que se enseñan en
programación y suele escribirse utilizando el signo ‘=’ o el símbolo ‘<-’. La
instrucción ‘A=5′ asignaría el valor ’5′ a la variable que se denomina ‘A’.

Figura 2.2. Asignación dato a variable.

Observamos la siguiente ilustración, donde vemos dos cajas (dos variables)


recibiendo cada una un valor numérico. La caja de nombre ‘A’ recibe el valor
’5′ y la caja de nombre ‘B’, el valor ’2′. Eso se puede hacer con las
instrucciones: ‘A=5′ y ‘B=2′.

Figura 2.3. Asignación dato a variables.

Las variables funcionan de la siguiente forma: si después de asignar un


valor concreto a una variable le damos otro diferente, el primero se pierde y el
que permanece es el último asignado.

12 Tipos de datos simples


Introducción a la programación 02

En la siguiente figura podemos observar que en la variable B tenemos un


valor guardado de 2, pero si realizamos la operación B=5, el valor anterior se
borrará y pasará a tomar un valor de 5 la variable B.

Figura 2.4. Cambiar datos a variable.

Vamos a complicar un poco la situación, y ahora el problema consiste en


intercambiar los valores de ambas variables. Que B tenga el valor de A y ésta
el de B, cualesquiera que sean dichos valores.

Figura 2.5. Intercambiar datos de variables.

Lo más lógico sería pensar en escribir las dos instrucciones siguientes: “A=B’
y ‘B=A’. Siempre con la idea de que lo que queremos hacer es: ‘A<-B’ y ‘B<-
A’. Pero con eso sólo lograríamos que A y B tuvieran el valor ’2′. Entender eso
es la primera parte del ejercicio. Con ‘A=B’ se consigue que A valga 2, ya que
B valía 2. Y, a continuación, si A vale ahora 2, con ‘B=A’ terminamos
asignando 2 a B, con lo que A y B tendrán el mismo valor que tenía B al
principio.

La forma de resolver el problema es utilizar una tercera variable auxiliar. En


primer lugar, guardamos en C (la variable auxiliar) el valor de A. Después,
introducimos en A el valor de B. Ahora no importa que hayamos perdido el
valor de A porque lo habíamos guardado en C. Y por último, almacenamos en
B el valor de C.

Tipos de datos simples 13


Formación Abierta

Dicho esto vamos a pasar a una definición más formal de variables y


constantes. Durante la ejecución del programa los datos pueden ir variando
su valor o bien permanecer fijo. Se denominan constantes a aquellos datos
cuyo valor no cambia durante la ejecución del programa. Por el contrario, se
denominan variables a aquellos datos cuyo valor puede cambiar durante la
ejecución del programa.

Variables

Una variable es un espacio de memoria que tiene


asociados un nombre y un tipo de dato. Además,
almacena un valor que puede cambiar durante el tiempo
de ejecución.

Constantes

Una constante representa un espacio de memoria que


tiene asociados: un nombre o identificador, y un valor que
no puede modificarse en tiempo de ejecución.

Existen tantos tipos de constantes y de variables como tipos de datos hay; es


decir, que una variable o una constante siempre va a manejar valores de los
tipos de datos vistos anteriormente.

Como ejemplo podemos ver una variable A = 1,


B=”Montse”, C =FALSO, D=’€’

En la mayoría de los lenguajes de programación permiten


utilizar constantes de los tipos entero, real, caracteres,
lógicos, subrango y enumerados.

Los tipos de variables existentes son los mismos que los tipos de datos que
existen, es decir, entero, real, carácter, lógico y cadena. Además, si se han
definido tipos de datos subrango o enumerado entonces se podrán utilizar
variables de este tipo de datos; si no se han definido, no es posible utilizarlas.

14 Tipos de datos simples


Introducción a la programación 02

En general, a una variable definida para almacenar datos de un tipo concreto


no se pueden asignar o intentar dar valores distintos de los del tipo de dato
que pueden almacenar, si se intenta hacer esto obtendremos un error de tipo.

Identificador o nombre variable


Las variables vienen identificadas por el nombre (identificador) y por el tipo de
dato que puede almacenar o manejar dicha variable y que describe el uso de
la variable. Al principio del programa, se deben declarar todas las variables a
usar posteriormente (es decir, listar su nombre y el tipo de dato que pueden
almacenar). A los nombres de las variables se les llama identificadores. Para
formar un identificador se puede utilizar cualquier carácter alfanumérico con la
salvedad de que, en general, el primer carácter debe ser una letra.
En general, la mayoría de los programas no permiten usar como
identificadores las palabras reservadas del lenguaje. Estas palabras son las
que se utilizan para construir toda la sintaxis del programa.

Ejemplos de nombres de variables válidas son: A1, A2,


primero, último, _media, máximo, mínimo, _a1, etc.

Como norma general de programación, se recomienda que los nombres de


las variable o identificadores sean significativos y tengan relación con aquello
que están representando. Ejemplos:

 Máximo para representar la temperatura máxima de un día.


 Sueldo para representar el salario que percibe un empleado.
 Kilómetros para representar el número de kilómetros que recorre un
coche.

 Un identificador es un nombre que define a una


variable, una función o un tipo de datos.
 Un identificador válido ha de empezar por una letra o
por el carácter de subrayado _, seguido de cualquier
cantidad de letras, dígitos o subrayados.
 Se distinguen mayúsculas de minúsculas.
 No se pueden utilizar palabras reservadas
como entero, real, escribir, printf, etc.
 Muchos compiladores no permiten letras acentuadas o
eñes.

Tipos de datos simples 15


Formación Abierta

2.4. Expresiones y operadores


Para poder transformar los datos de entrada de un algoritmo en datos de
salida o información, normalmente tendremos que operar con los datos. Para
operar con los datos se utilizarán operadores y expresiones.

Una expresión es una combinación de operadores y


operandos. Los datos u operandos pueden ser
constantes, variables y llamadas a funciones. Además,
dentro de una expresión pueden encontrarse
subexpresiones encerradas entre paréntesis.

Por ejemplo, la siguiente expresión matemática, la solución de la ecuación de


segundo grado se escribe, en la siguiente forma:

x= (-b+raiz((b*b)-(4*a*c)))/(2*a)

Donde:

raíz Raíz cuadrada

Donde, estrictamente hablando, sólo lo que está a la derecha del operador de


asignación (=) es una expresión aritmética. En las expresiones se pueden
introducir espacios en blanco entre operandos y operadores.

En las expresiones combinadas con las variables, símbolos de operación,


paréntesis y nombre de funciones especiales, componemos instrucciones
para generar salidas y resultados en los algoritmos. Por ejemplo expresiones
son:

 3 + 8 – 7 * 2 * (3 – 1)
 3>1
 (base * altura)/2

Para determinar el valor resultante de la expresión se efectúan las


operaciones indicadas entre las constantes y variables que intervienen en la
expresión.

A los símbolos que representan la operación a realizar entre las constantes y


variables (en la expresión se denominan operandos, igual que en
matemáticas), se les llama operadores.

16 Tipos de datos simples


Introducción a la programación 02

Por lo tanto, una expresión consta de operandos y operadores. Al igual que


ocurre con los datos, los tipos de expresiones pueden ser:

 Expresiones aritméticas: el resultado de este tipo de expresiones


siempre es de tipo numérico.
 Expresiones relacionales: el resultado de este tipo de expresiones
siempre es de tipo lógico o booleano.
 Expresiones lógicas: el resultado, al igual que en las expresiones
anteriores, es de tipo lógico.
 Expresiones de tipo carácter: el resultado de este tipo de
expresiones es de tipo carácter.

Expresiones y operadores aritméticos

En las expresiones aritméticas sólo pueden intervenir operandos (tipos de


datos) numéricos, o bien tipos subrango cuyo tipo anfitrión sea un tipo
numérico. Por lo tanto, las variables y constantes tienen valores enteros o
reales y sólo se pueden efectuar operaciones aritméticas.

En la siguiente tabla se pueden observar los símbolos que representan a las


operaciones aritméticas, el significado de cada una (la operación aritmética a
la que representan), el tipo de operador sobre el que intervienen y la prioridad
u orden de evaluación.

Resultado
Ejemplo de
Operador Descripción del Prioridad
expresión
ejemplo

Operador unario de
-/+ -4 -4 1
cambio de signo

+ Suma 2,5+7,1 9,6 3

- Resta 235,6-103,5 132,1 3

* Producto 1,2x1,1 1,32 2

División real
(independientemente de 6/8 0,75
/ 2
si los operados son 0,050/0,2 0,25
enteros o reales

div 20 div 7 2 2

Resto de la división
mod entera (sólo permite 20 mod 7 6 2
operandos enteros)

Figura 2.6. Operadores aritméticos.

Tipos de datos simples 17


Formación Abierta

Todos los operadores se utilizan igual que en matemáticas. No


todos los operadores aparecen en todos los lenguajes de
programación, por ejemplo, en PHP no aparecen los
operadores div y el mod; mientras que en lenguaje C no
aparece el operador de exponenciación. Algunas operaciones
aritméticas se representan mediante otros símbolos diferentes
en algunos lenguajes de programación, por ejemplo en
PASCAL el operador mod se representa por %.

En la tabla también podemos ver el tipo de dato sobre el que puede actuar
cada uno de los operadores y el tipo de resultado que producen, aunque
luego esto depende de cada lenguaje de programación.

Operadores div y mod

Los operadores div y mod no se han visto como tal en matemáticas, por lo
tanto se va a explicar con más detenimiento en este apartado.

El operador div, aplicado a una división entre dos números enteros, da como
resultado el cociente entero de dicha división (sin sacar decimales), mientras
que el operador mod, aplicado a dos números enteros, da como resultado el
resto de la división. Estos operadores no se pueden aplicar a números reales.
En la siguiente figura tenemos varios ejemplos:

 6 div 4 = 1
 6 mod 4 = 2 6 4
 21 div 3 = 7 2 1
 21 mod 3 = 0

Estos operadores, por ejemplo se pueden utilizar para saber si un número es


par o impar. Un número es par cuando el resto de la división entera entre dos
es cero, por el contrario un número es impar cuando el resto de la división
entera entre dos es distinto de cero.

Ejemplos
 4 mod 3 = 1 (4 no es divisible entre 3)
 8 div 1 = 8
 8 mod 1 = 0 (8 es divisible entre uno)
 121 div 6 = 20
 121 mod 11 = 0 (121 es divisible entre 11)

18 Tipos de datos simples


Introducción a la programación 02

Reglas de prioridad

Cuando en una expresión hay más de un operador hay que determinar qué
operación se va a efectuar en primer lugar. Para ello, nos basamos en el
orden de prioridad de los distintos operadores.

 Las operaciones que están encerradas entre paréntesis se evalúan


primero. Si hay varios paréntesis anidados, se evalúan primero los
más internos.
 En una expresión el orden de evaluación es el que se puso en la figura
2.6. en la columna número cinco:

 Operador exponencial, , ^, **

 Operadores *, /

 Operadores +, -

 Operadores div y mod


 En caso de coincidir operadores con la misma prioridad en la misma
expresión o subexpresión (aquella que está encerrada entre
paréntesis), se evalúa de izquierda a derecha.

Ejemplo

Obtener el resultado de la siguiente expresión:

2,5 + 3 * 2 + 8 / 4 – (7 – 2 * 2 + 5 - (18 / 6))

 Aplicamos la regla número 1 y evaluamos la subexpresión dentro del


paréntesis más interno, 18 / 6 =3, con lo que la expresión queda:

2,5 + 3 * 2 + 8 / 4 – (7 – 2 * 2 + 5 - 3)

 Volvemos a aplicar la regla número uno y evaluamos la expresión


contenida dentro del paréntesis. Dentro del paréntesis aplicamos la
regla número dos con lo que la primera operación a evaluar es el
producto:

2,5 + 3 * 2 + 8 / 4 – (7 – 4 + 5 - 3)

 Aplicamos la regla número 3 a la expresión dentro del paréntesis:

2,5 + 3 * 2 + 8 / 4 – (3 + 5 - 3)

2,5 + 3 * 2 + 8 / 4 – (8 - 3)

2,5 + 3 * 2 + 8 / 4 – 5

Tipos de datos simples 19


Formación Abierta

 Aplicamos la regla número 2 y 3 a las operaciones producto y división:

2,5 + 6 + 8 / 4 – 5

2,5 + 6 + 2 – 5

 Aplicamos la regla número 3

8,5 + 2 – 5

10,5 – 5

5,5

2.4.1. Expresiones y operadores lógicos


A la expresión y operadores lógicos también se les llama booleanos. El
resultado que produce una expresión de este tipo es siempre uno de los dos
valores lógicos, falso o verdadero; así mismo, a las constantes y variables
booleanas sólo se les puede dar o asignar uno de estos dos valores.

Las expresiones lógicas pueden estar formadas por constantes y variables


lógicas por los operadores lógicos y, no, o, y los operadores relacionales >, <,
=, >=, <=, <>, también llamados de relación o comparación.

Operadores relacionales

Los operadores relacionales permiten hacer comparaciones entre los valores


de tipo de datos simples. En los algoritmos sirven para expresar condiciones.
En la figura 2.7 se pueden ver los operadores relacionales y el significado de
los mismos.

Operador Significado

> Mayor que


< menor que
=, = = igual que
>= mayor o igual que
<= menor o igual que
<>, != distinto de

Figura 2.7. Operadores relacionales.

Los operadores relacionales se pueden aplicar a constantes, variables o


expresiones. El operador de relación siempre va situado en medio de dos de
los elementos anteriores.

20 Tipos de datos simples


Introducción a la programación 02

Ejemplos: En los siguiente ejemplos la variable A toma el


valor 6, y la variable B el valor 3.

A=6 B=3

Expresión lógica Resultado

A<3 Falso

B >= 3 Verdadero

8*5>A*B Verdadero (40 > 18)

(A mod 2) = 0 Verdadero

(B mod 2) = 0 Falso

‘A’ > ‘B’ Falso

‘2’ >= ‘1’ Verdadero

En las dos últimas comparaciones se han comparado caracteres (recordar


que las constantes de tipo carácter van encerradas entre comillas), esto es
posible gracias al código ASCII que ordena los caracteres según un código
numérico asignado a cada número (es el número decimal correspondiente al
código binario utilizado para representar internamente cada uno de los
caracteres). Por lo tanto, se utiliza este código para poder compararlos.

No en todos los ordenadores el juego de caracteres es el mismo, pero sí que


se respetan ciertas representaciones u ordenaciones de caracteres como son:

 Los caracteres utilizados para representar valores numéricos siguen el


orden natural, es decir ‘0’ < ‘1’ < ‘2’ ...< ‘8’ < ‘9’
 Las letras mayúsculas se ordenan de siguiente manera: ‘A’ < ‘B’ < ‘C’
<...<’Y’ < ‘Z’.
 Las letras minúsculas se ordenan de la misma forma que las letras
mayúsculas: ‘a’ < ‘b’ < ‘c’ <...<’y’ < ‘z’.
 Otros caracteres tales como !, ”, ·, $, %, &, /, (, ), =,... etc, es
aconsejable consultar el código de ordenación.

En general, los tres primeros grupos están ordenados de forma que los
caracteres numéricos son menores que las letras mayúsculas que a su vez
son menores que las letras minúsculas, es decir ‘1’ < ‘A’ < ‘a’, aunque para
tener completa seguridad se recomienda consultar el código de caracteres de
cada ordenador.

Tipos de datos simples 21


Formación Abierta

Los operadores lógicos también se pueden comparar puesto que están


ordenados de forma que falso es menor que verdadero.

Para números reales, a la hora de compararlos en el ordenador hay que tener


en cuenta que hay un límite de precisión, de forma que algunos números
reales no pueden ser almacenados de manera exacta. Esto quiere decir que
al hacer determinadas comparaciones puede que el resultado no coincida con
el valor esperado de dicha comparación. Por ejemplo:

(10 / 6) * 6 = 6

El resultado de la división de 10 entre 6 es 1.6666666 que multiplicado por 6


da como resultado 9.9999996 que es distinto de 10. Por consiguiente, en la
mediada de lo posible se evitará la comparación de números reales.

Operadores lógicos

Los operadores lógicos, también llamados booleanos, son no, y y o. El


funcionamiento de estos operadores es equivalente al funcionamiento de las
puertas lógicas not, and y or de electrónica, y la correspondencia es no-not,
y-and, o-or.

Los operadores o e y actúan sobre dos operandos u expresiones lógicas,


mientras que el operador de negación no actúa sobre un único operando u
expresión lógica. En las siguientes tablas se puede ver el resultado que
producen estos operadores cuando se aplican a dos variables de tipo lógico.
Se representa el resultado en función de las combinaciones de los valores
que pueden tomar las variables A y B.

Cuando se aplica el operador lógico y, el resultado produce el valor lógico


verdadero si y sólo si los dos operandos o expresiones tienen el valor lógico
verdadero.

A B AyB

verdadero verdadero verdadero


verdadero falso falso
falso verdadero falso
falso falso falso

Figura 2.8. Resultado del operador lógico Y.

22 Tipos de datos simples


Introducción a la programación 02

Cuando se aplica el operador lógico o, el resultado produce el valor lógico


verdadero si y sólo si al menos uno de los dos operandos o expresiones
tienen el valor lógico verdadero.

A B AoB

verdadero verdadero verdadero


verdadero falso verdadero
falso verdadero verdadero
falso falso falso

Figura 2.9. Resultado del operador lógico O.

Como se ha comentado anteriormente el operador lógico no se aplica a un


operador o expresión de tipo booleano, el resultado que produce se puede ver
en la figura 2.11.

A no A

verdadero falso
falso verdadero

Figura 2.10. Resultado del operador lógico NO.

Estos operadores guardan también analogía con los operadores


matemáticos, de forma que el operador y se corresponde con el
producto (*), el operador o con la suma (+).

En este caso estos operadores matemáticos operan sobre números, de forma


que el valor lógico falso equivale al cero y cualquier otro número equivale al
valor lógico verdadero, de manera que:

3*6 18 Equivale a VyV V

5*0 0 Equivale a VyF F

4+5 9 Equivale a VoV V

4+0 4 Equivale a VoF V

Figura 2.11. Operadores lógicos.

Los operandos sobre los que actúan los operadores lógicos pueden ser
expresiones, con la condición de que el resultado que produce dicha
expresión debe ser un valor lógico (verdadero o falso), de forma que en estas
expresiones se pueden tener mezclados operadores relacionales, que como
es sabido dan un resultado booleano.

Tipos de datos simples 23


Formación Abierta

1. (3 < 5) o (6 > 8) es verdadero puesto que 3 < 5 es verdadero y 6 > 8


es falso, verdadero o falso = verdadero.

2. (10 > 0) y (2 < 9) es verdadero puesto que 10 > 0 es verdadero y 2 < 9


es verdadero, verdadero y verdadero = verdadero.

Veamos un ejemplo de expresión: ¿Qué resultado tiene


la siguiente expresión teniendo los siguientes valores?

Sea: a = 10 b = 12 c = 13 d =10

(( a>b) or (a<c)) and ((a=c) or (a>=b))

Figura 2.12. Solución ejemplo.

Sintaxis de operadores lógicos

Según la fuente de información consultada, verás diferentes representaciones


para los caracteres de operandos lógicos como mostramos en el siguiente
cuadro.

Y& ......................................................................................... (&&), AND…

O ............................................................................................ |,||, OR…

No .......................................................................................... N ! ~

Así por ejemplo;

 (2==1) || (-1== -1) // el resultado es 1


 (2==2) && (3==-1) // el resultado es 0
 ((2==2) && (3==3)) || (4==0) // el resultado es 1
 ((6==6) || (8==0)) && ((5==5) && (3==2)) // el resultado
es 0
 ((250)&&(330)) 250>0,330>0 // el resultado es 1

24 Tipos de datos simples


Introducción a la programación 02

Prioridad de los operadores

Cuando en una misma expresión tenemos varios operadores, hay que decidir
qué operación se realiza primero, para ello nos basamos en las prioridades
generales de los operadores. No hay una regla general puesto que cada
lenguaje de programación tiene las suyas y no suelen coincidir, por lo tanto a
la hora de efectuar o escribir estas expresiones es conveniente ayudarnos de
los paréntesis para que quede claro cual es nuestra intención.

No obstante, para escribir los algoritmos, utilizaremos las prioridades de la


figura 2.13.

Prioridad Operadores Significado

1 No Negación.

2 +, - signo

3 *, /, % multiplicación, división, resto

4 +, - adición, sustracción

5 = asignación

Figura 2.13. Prioridad de operadores.

Tipos de datos simples 25


Formación Abierta

2.5. Asignación de valores a las


variables
Hasta ahora hemos visto que los datos con los que podíamos trabajar en un
algoritmo pueden ser constantes o variables. Las variables pueden ir
cambiando su valor durante la ejecución del algoritmo, por lo tanto hemos de
darle valores. Para realizar esta operación se dispone del operador de
asignación. El operador de asignación, en los algoritmos, se representa por el
símbolo . A la operación de asignación de valor a una variable, en los
lenguajes de programación, se le conoce como sentencia o instrucción de
asignación, y tiene el siguiente formato:

Nombre de la variable  expresión

Donde nombre de la variable es el identificador o nombre con el que nos


referimos a dicha variable, y expresión es el valor que va a tomar la variable,
que puede ser un valor concreto o el resultado de evaluar una expresión
(siempre y cuando coincidan el tipo de datos que maneja tanto la variable
como la expresión).

El operador de asignación, dependiendo del lenguaje de programación, es


sustituido por diferentes símbolos, así en PASCAL el operador de asignación
es :=, mientras que en C, el operador de asignación es = igual que en java.

En este curso cuando pasemos a programar, se puede


utilizar <- como el símbolo de igual (=)

Algunos ejemplos de asignación:

 A  9, la variable A (que tiene que ser de tipo entero) se le asigna el valor


9 o lo que es lo mismo almacena el valor 9.

 A  9+2*3, la variable A (que es de tipo entero) se le asigna el valor del


resultado de la expresión 9+2*3 que es 15, luego almacena el valor 15.

 B  (7 > 10), la variable B (que es de tipo lógico) se le asigna el valor del


resultado de evaluar la expresión 7 > 10 que es el falso.

26 Tipos de datos simples


Introducción a la programación 02

 C  A + 2, la variable A (que es de tipo entero) se le asigna el valor del


resultado de sumar el contenido de la variable A, 15, y se le suma 2, por lo
tanto almacena el valor 17.

 B  C, no se puede hacer esta asignación puesto que B es de tipo lógico,


mientras que C es de tipo entero, por lo tanto no tienen el mismo tipo y se
produce un error de concordancia de tipos.

Como se ha visto anteriormente podemos tener distintos tipos de


asignaciones en función del tipo de expresiones, éstas pueden ser
aritméticas, lógicas, carácter, subrango y enumeradas.

Antes de pasar a ver los tipos de asignaciones básicas hay que comentar que
la operación de asignación es destructiva, es decir, una vez que asignamos
un valor a una variable perdemos el valor anterior, se borra.

Asignación aritmética

En este tipo de expresiones podemos tener constantes, variables y otras


expresiones de tipo numéricas, y además operadores aritméticos, de ahí el
nombre. Ejemplos de asignaciones aritméticas son:

 suma  13 + 9 – 7

 total1  4.5 * 3.2 +13.2

 total2  2.2 * 9.6 / 1.6

 media  (total1 + total2) / 2

En cada uno de los ejemplos anteriores, se evalúan las expresiones a la


derecha del operador de asignación y una vez que se han efectuado todas las
operaciones se asigna el valor a la variable situada a la izquierda del
operador de asignación, de forma que la variable suma tendrá el valor 15,
total1 27.6, total2 13.2 y media 20.4.

Asignación lógica

En este caso, el resultado de las expresiones a la izquierda va a producir


como resultado un valor lógico o booleano. Si se produce un valor booleano,
al menos debe haber una constante, variable u operador lógico o de relación
que de como resultado este valor. También puede aparecer otro tipo de
operadores. Las variables a las que se les da valor deben de ser de tipo
lógico. Algunos ejemplos de asignaciones lógicas son:

 Menor  15 < 30. 15 es menor que 30, por lo tanto, menor tendrá el valor
lógico verdadero.

Tipos de datos simples 27


Formación Abierta

 Mayor  8 > 1. 8 es mayor que 1, por lo tanto mayor tendrá el valor lógico
verdadero
 A  2 * 6 < 2 * 2. 12 no es menor que 4, por lo tanto A tendrá el valor
lógico falso.
 B  mayor o menor o A. Sustituyendo cada variable por el valor lógico
que almacena tenemos verdadero o verdadero o falso. Hay dos
operadores o que tienen igual nivel de prioridad, evaluamos de izquierda a
derecha verdadero o verdadero es verdadero. Evaluamos ahora
verdadero o falso cuyo resultado es verdadero.

Asignación de caracteres

En este tipo de asignaciones se asignan caracteres a variables de tipo


carácter. Hay que recordar que, cuando se asignan caracteres, éstos deben ir
entre comillas simples. Algunos ejemplos de este tipo de asignaciones son:

 Letra  ‘A’
 Minúscula  ‘o’
 Carácter_especial  ‘%’
 Fin_frase  ‘.’

También están las variables de tipo cadena que son agrupaciones de


caracteres. El funcionamiento para dar valor a este tipo de variables es el
mismo que para las variables de tipo carácter, sólo que en este caso se
asigna una cadena que debe ir entre comillas. Las variables deben ser de tipo
cadena para poder hacer esta asignación. Algunos ejemplos de estas
asignaciones son:

 Fecha  “14 de abril de 2000”


 Nombre  “Montse”
 Ciudad  “Zaragoza”

Sentencias

Las expresiones son ítems elementales de unas entidades que son las
sentencias. Si nos fijamos en las expresiones anteriores, la variable que está
a la izquierda del signo () el operador de asignación y la expresión
aritmética constituyen una sentencia.

 media  (total1 + total2) / 2

Las sentencias son unidades completas, ejecutables en sí mismas. Como ya


se ha visto en este punto hay muchos tipos de sentencias que incorporan
expresiones aritméticas, lógicas o generales como componentes de dichas
sentencias.

28 Tipos de datos simples


Introducción a la programación 02

2.6. Conversión de tipos


Cuando se asignen valores a las variables se ha de tener cuidado de que
haya correspondencia entre los tipos de los valores a asignar y los tipos de
las variables, puesto que si no coinciden se obtendrá un error.

Hay lenguajes de programación que permiten trabajar con variables o valores


de diferente tipo, haciendo promociones de un tipo a otro como es el ejemplo
de C. En cambio otros no permiten trabajar con variables de distinto tipo y se
produce un error en caso de que se trate de hacerlo, como es el caso de
Java. Se puede hacer promoción de tipos mediante un operador.

En este texto, para dar valores a una variable, la variable y los datos o
expresiones que se pretenden asignar a dicha variable deben ser del mismo
tipo, en caso contrario se considerará un error.

A continuación se van a presentar algunos ejercicios de errores en la


asignación. Antes hay que comentar que en dichos ejemplos las variables:

A y B son de tipo entero.

C y D de tipo real.

E y F de tipo lógico.

Letra es de tipo carácter.

Nombre de tipo cadena.

 A  ‘ñ’. Error A es de tipo entero mientras que ‘ñ’ es una constante de

tipo carácter. 
 A <-6+3. es una asignación correcta. 
 B  3.6 * 4. Error B es de tipo entero mientras que 3.6 es un número
real y al multiplicar por 4 obtendremos un resultado de 14.4 que es

real. 
 C  8 mod 3. el resultado de la expresión es 5 que es de tipo entero
mientras que C es de tipo real en consecuencia no se produce un

error, pero se expresaría 5,000; es decir con decimales. 


 C  8 / 3. Es una asignación correcta. 

Tipos de datos simples 29


Formación Abierta

 D  ‘i’. Error ‘i’ es una contante de tipo carácter mientras que D es de

tipo real. 
 E  10 ó 20. Error, no se puede aplicar el operador lógico a dos
valores numéricos, tienen que ser valores lógicos, en este caso la

expresión es incorrecta. 
 E  15. Error E es una variable de tipo lógico mientras que 15 es de

tipo entero. 
 E  verdadero o falso. Es una asignación correcta, y el resultado es

verdadero .
 F  F y ‘F’. Error F es una variable de tipo lógico mientras que ‘F’ es
una constante de tipo carácter, por lo tanto, no se puede aplicar el

operador lógico a esta expresión. 


 F  no E. Es una asignación correcta .
 Letra  A. Error A no es carácter, sino una variable de tipo entero. 
 Letra  ‘A’. Es una asignación correcta .
 Nombre  Luis. Error Luis no es una cadena puesto que no va

encerrada entre comillas. 


 Nombre  “Luis”. Es una asignación correcta .

30 Tipos de datos simples


Introducción a la programación 02

2.7. Funciones definidas internamente


En general, muchos de los algoritmos y programas necesitan de funciones
matemáticas para poder evaluar determinadas expresiones, además de las
operaciones aritméticas ya vistas.

Todos los lenguajes de programación tienen funciones definidas internamente


que permiten al usuario utilizarlas sin preocuparse de cómo están
programadas.

Algunos ejemplos de estas funciones son la función seno que permite calcular
el seno de un ángulo, la función ln que permite calcular el logaritmo neperiano
de un número dado. En la figura 2.15 se puede ver las funciones internas más
habituales. Todas estas funciones actúan sobre un argumento que en este
caso se representa por x. Hay que prestar especial atención al tipo de
argumento que puede tomar la función y sobre todo al tipo de resultado que
producen las funciones, puesto que no siempre coinciden ambos tipos.

Tipo de
Función Descripción Tipo de resultado
argumento

Abs (x) Valor absoluto de x Entero o real Igual al argumento recibido


arctan (x) arco tangente de x Entero o real real
Cos (x) coseno de x Entero o real real
exp (x) exponencial de x Entero o real real
ln (x) logaritmo neperiano de x Entero o real real
log10 (x) logaritmo decimal de x Entero o real real
redondeo (x) redondeo de x real entero
seno (x) seno de x Entero o real real
cuadrado (x) cuadrado de x Entero o real igual al argumento recibido
raizcua (x) raíz cuadrada de x Entero o real real
Trunc (x) truncamiento de x real entero

Figura 2.14. Funciones definidas internamente.

Tipos de datos simples 31


Introducción a la programación 02

 Resumen

 En este tema se han visto los tipos de datos básicos con los que se va a
trabajar en el desarrollo de los algoritmos en la siguiente unidad didáctica.
Éstos son los tipos de datos más frecuentes con los que trabajan la mayoría de
los lenguajes de programación.

 Los datos con los que se va a trabajar en esta unidad didáctica son los tipos de
datos simples. Dentro de los tipos de datos simples están el tipo de dato
numérico, el tipo de dato carácter y el tipo de dato lógico. Dentro del tipo de
dato numérico está el tipo de dato entero y el tipo de dato real.

 También hemos visto cómo podemos definir nuestro propio conjunto de datos,
es decir, los tipos de datos definidos por el programador. Dentro de estos,
encontramos los tipos de datos subrango, que son un conjunto finito de datos
de un tipo de dato estándar, y el tipo de dato enumerado, en el cual se
“enumeran” cada uno de los datos que forman parte del conjunto.

 Una vez vistos los tipos de datos hemos visto lo que es una constante y lo que
es una variable. Una constante es un valor que no cambia (no puede cambiar)
durante la ejecución del programa. Por el contrario, una variable es un valor
que puede (tiene la posibilidad) cambiar durante la ejecución de un programa.

 Para poder transformar los datos de entrada de un algoritmo en datos de


salida o información se utilizan los operadores y las expresiones. Las
expresiones son combinaciones de constantes, variables, símbolos de
operación, paréntesis y nombres de funciones especiales ya definidas y que
por los tanto se pueden usar.

 Para obtener el resultado de una expresión en la que intervienen varios


operadores hay que tener en cuenta la prioridad de cada uno de ellos para
ejecutar en el orden preciso las operaciones.

 Hemos visto que algunos operadores sólo pueden operar con operandos de un
determinado tipo, mientras que otros operadores pueden actuar sobre varios
tipos de datos.

Tipos de datos simples 33


Formación Abierta

 El operador de asignación , = se utiliza para dar valores a las variables. Una


variable es una zona de memoria del ordenador donde se guarda un
determinado valor. Hemos visto que la operación de asignación es destructiva,
es decir, que al asignar un valor a una variable, se pierde el valor que contenía
anteriormente.

 A la hora de trabajar con variables hemos de tener cuidado de asignar valores


que sean del mismo tipo que la variable, puesto que en caso contrario se
produce un error.

 Por último, se han visto algunas funciones que se pueden utilizar sin que el
usuario tenga que definirlas. Éstas son las funciones más comunes que
disponen la mayoría de los lenguajes de programación.

34 Tipos de datos simples


03 Introducción a la
Programación

Desarrollo de algoritmos
Introducción a la Programación 03

 Índice

 OBJETIVOS .......................................................................................................... 3
 INTRODUCCIÓN .................................................................................................. 4
3.1. Los algoritmos ............................................................................................ 5
3.2. Expresión de los algoritmos ...................................................................... 9
3.3. Entrada y salida de información .............................................................. 11
3.4. Diagramas de flujo .................................................................................... 14
3.4.1. Desarrollo diagrama de flujo ............................................................... 17
3.5. Pseudocódigo ........................................................................................... 20
3.6. Desarrollo de pseudocódigo .................................................................... 21
 RESUMEN .......................................................................................................... 25

Desarrollo de algoritmos 1
Introducción a la Programación 03

 Objetivos

 El alumno aprenderá a expresar un algoritmo mediante diagrama de flujo y


mediante pseudocódigo.

 Uno de los objetivos es que el alumno entienda que hay varias formas de
expresar un algoritmo y todas ellas son correctas.

 Los algoritmos, si no los expresamos mediante un lenguaje de programación,


es decir, un programa, no existe una forma de evaluar si están desarrollados
de forma correcta.

 Los algoritmos, expresados mediante diagrama de flujo o mediante


pseudocódigo sirven para todos los lenguajes de programación; es decir, son
independientes del lenguaje de programación.

Desarrollo de algoritmos 3
Formación Abierta

 Introducción

En esta unidad didáctica vamos a estudiar cómo se pueden expresar los algoritmos,
que son el paso previo a la creación de un programa.

Para expresar los algoritmos hay herramientas gráficas, en los que se puede seguir
el flujo de información de “forma visual”, y el lenguaje de especificación de
algoritmos, también llamado pseudocódigo, en el cual se expresan las distintas
acciones mediante texto escrito.

Dentro de las herramientas gráficas utilizadas para la expresión de algoritmos están


los diagramas de flujo, y el diagrama de Nassi-Scheiderman. Ambas herramientas
son muy similares, aunque actualmente se utiliza diagrama de flujo para un nivel de
programación inicial.

En los diagramas de flujo se utilizan una serie de “cajas” que indican unas acciones
en función de la forma de dicha caja. Dentro de estas cajas se escriben una serie
de acciones como expresiones o asignaciones.

La mayoría de los algoritmos o programas suelen ser interactivos, es decir,


intercambian información con el usuario. Este intercambio de información lo hacen
a través de unas órdenes muy concretas como son las sentencias leer y escribir.
Veremos cuál es la sintaxis de estas dos instrucciones.

Por último, vamos a ver cuáles son las partes principales que forman un algoritmo
que se expresa en pseudocódigo.

Para representar el diagrama de flujo y el pseudocódigo


utilizaremos software gratuito PSeInt para el
pseudocódigo y Dia (diagramas) para dibujar diagramas
de flujo, pero el alumno puede seleccionar cualquiera
que esté en el mercado.

4 Desarrollo de algoritmos
Introducción a la Programación 03

3.1. Los algoritmos


Como vimos en la primera unidad, cuando se quiere resolver un problema mediante
el uso de un ordenador, utilizando un determinado lenguaje de programación, se
han de seguir unos pasos, que son:

 Análisis del problema.

 Diseño del algoritmo.

 Resolución del algoritmo con el ordenador.

Resolución del
Análisis del Diseño del
algoritmo con el
problema algoritmo
ordenador

Figura 3.1. Etapas en la resolución de problemas usando un ordenador.

Análisis del problema

En el análisis del problema, el programador debe entender en qué consiste el


problema, definiendo las características principales de éste en base a las
especificaciones de entrada -que normalmente serán los datos que se le piden al
usuario o se extraen de un fichero-, y a las especificaciones de salida -que
normalmente serán los resultados que ha de producir nuestro algoritmo o
programa-. Las etapas se pueden observar en la figura 3.2.

Análisis del
problema

Definición del Especificaciones Especificaciones


problema de entrada de salida

Figura 3.2. Etapas en el análisis del problema.

En la definición del problema se describirá, a grandes rasgos, cómo se puede


resolver el algoritmo y los pasos que se han de dar. Es la etapa previa, pero a
veces viene condicionada por las etapas posteriores.

En las especificaciones de entrada, se definen los datos que se introducirán en el


algoritmo y que son necesarios para su correcta ejecución.

En las especificaciones de salida, se definen los resultados que generará el


algoritmo, es lo que llamaremos datos de salida y que en capítulos anteriores
llamábamos información (datos procesados).

Desarrollo de algoritmos 5
Formación Abierta

Diseño del algoritmo

En el diseño del algoritmo se definirán los pasos que se han de dar, para que,
partiendo de los datos de entrada, se pueda llegar a obtener los datos de salida.
Estos pasos son cada una de las instrucciones del algoritmo o las sentencias
en los programas.

Normalmente, se llegará a la solución después de sucesivas mejoras o


refinamientos del algoritmo inicial, puesto que a medida que se va avanzando en el
desarrollo del algoritmo, se van corrigiendo los errores que salen sobre la marcha.

Si el algoritmo o problema es muy grande, lo que se hace es dividirlo en problemas


más pequeños que se resuelven independientemente en función de unas entradas
y unas salidas que nosotros mismos definimos, pero siempre en función de las
entradas y salidas generales.

Lo ilustramos con un ejemplo: se pretende evaluar si un número es primo o no.


Para ello, los pasos que se han de dar son:

 Saber cuándo un número es primo. Un número es primo cuando sólo es


divisible por sí mismo y por la unidad.
 Luego un número es primo cuando sólo tiene dos divisores (excepto el 'uno' que
únicamente tiene un divisor).
 En consecuencia, para saber si un número es primo hay que contar el número
de divisores que tiene.
 ¿Cuándo un número es divisor de otro? Un número es divisor de otro cuando al
dividir esos dos números el resto de la división es cero.
 Luego, para saber si un número es primo hay que evaluar si es divisible por
todos los números anteriores a él (incluido él mismo).
 Si tiene más de dos divisores el número no es primo, por el contrario si tiene
dos divisores o menos (el 'uno' sólo tiene un divisor), el número es primo.
 A la descomposición de un problema en problemas más pequeños se le llama
diseño descendente (top-down design), ya que se va desde lo más general
hacia lo más particular.
 A la hora, tanto de diseñar el algoritmo como de desarrollar el programa en un
lenguaje de programación, se suele ir mejorando el diseño puesto que casi
nunca la primera versión es la definitiva. Se conoce como refinamiento del
algoritmo al proceso sucesivo de mejora del algoritmo. En general, cuanto más
complejo o dificultoso es el problema, más niveles de refinamiento son
necesarios.

6 Desarrollo de algoritmos
Introducción a la Programación 03

Por lo tanto las ventajas más importantes del diseño descendente son las
siguientes:

 El problema es más fácil de resolver y de entender al dividirlo en módulos.

 Al utilizar módulos, las modificaciones son más fáciles de efectuar puesto que
estos módulos funcionan con unas entradas y producen unas salidas; mientras
siga funcionando en base a estas dos condiciones podemos modificar el diseño
del módulo.

 Se puede verificar el problema más fácilmente a través de los resultados


intermedios producidos por los módulos.

 En la figura 3.3 se pueden ver las fases en el diseño del algoritmo y que se han
comentado anteriormente.

Diseño de un
algoritmo

Diseño Refinamiento Herramienta de


descendente por pasos programación

Figura 3.3. Fases en el diseño del algoritmo.

Resolución del algoritmo con el ordenador

Para resolver el algoritmo en el ordenador debe plasmarse en un programa


utilizando un lenguaje de programación. Previamente al desarrollo del programa, el
algoritmo se habrá expresado en una de las diversas formas de expresar el
algoritmo (diagrama de flujo, diagrama N-S o pseudocódigo).

Las fases en las que se descompone esta resolución son las siguientes:

 Codificar el algoritmo en un programa: se desarrollará el programa utilizando


las sentencias del lenguaje de programación, basándose en el algoritmo.

 Ejecución del programa: una vez que se ha desarrollado el programa, se


comprueba que se pueda ejecutar, depurando los posibles fallos.

 Comprobación del programa: va relacionado con lo anterior, se comprueba


que el programa produce los resultados esperados, ya que puede funcionar (se
puede ejecutar) y no producirse los resultados esperados.

 Depuración: si el programa tiene fallos se modificará el programa fuente, y se


volverá a ejecutar y comprobar hasta que produzca los resultados esperados.

Desarrollo de algoritmos 7
Formación Abierta

A
B
A
C
B
D
C D E
E

Figura 3.4. Diseño de un algoritmo.

Vamos a dar un ejemplo de un algoritmo, pero observadlo y no estudiadlo ya que


posteriormente veremos como se desarrollan:

EJEMPLO: UN ALGORITMO COTIDIANO

 Algoritmo Leer_Libro
1. Inicio.
2. Abrir el libro en la primera página.
3. Leer la página.
4. ¿Es la última que quiero leer?

 Si: ir al paso 7.

 No: ir al paso 5.
5. Pasar a la siguiente página.
6. Ve al paso 3.
7. Cerrar el libro.
8. Fin.

8 Desarrollo de algoritmos
Introducción a la Programación 03

3.2. Expresión de los algoritmos


A lo largo de este texto, como se ha podido ir viendo, se va a hacer especial
hincapié en el desarrollo de algoritmos y en la forma de expresarlos. Éste es el
paso previo que debe hacer todo programador antes de expresar el algoritmo
mediante un programa.

El algoritmo es el mismo, independientemente del lenguaje de programación, de ahí


que se insista tanto en este aspecto; una vez que se domina el desarrollo y
expresión de algoritmos, programar es mucho más fácil, sólo hace falta conocer
los recursos del lenguaje; esto no quiere decir que ésta no sea una tarea exenta
de trabajo.

Hay varias formas de expresar el algoritmo, entre las más habituales se encuentran
las siguientes:

 Diagrama de flujo: es un diagrama que utiliza un conjunto de símbolos


estándar para mostrar “el camino que recorre la información”. El recorrido se
puede ver de forma visual.

 Pseudocódigo: es el lenguaje estándar utilizado para expresar los algoritmos.


El flujo de la información no se aprecia de forma visible. El flujo de información
es controlado a través de sentencias que son escritas en lenguaje natural con
una sintaxis determinada.

Podemos observar la diferencia de expresar los algoritmos de las dos formas.

Pseudocódigo

Algoritmo hablar_teléfono

Inicio
1. Levanta el auricular.
2. Espere el tono.
3. Marque número.
4. Hable con la otra persona.
5. Cuelgue auricular.

Fin

Desarrollo de algoritmos 9
Formación Abierta

Diagrama de Flujo

Pseudocodigo Diagrama flujo

Algoritmo hablar_teléfono Inicio

Inicio:

1. Levanta el auricular. Levantar auricular

2. Espere el tono.
3. Maque número. Espere tono

4. Hable con la otra


persona.
Marcar número
5. Cuelgue auricular.

Fin.
Esperar a que contesten

Hablar con la otra persona

Colgar

Fin

Figura 3.5. Representación de pseudo y diagrama.

10 Desarrollo de algoritmos
Introducción a la Programación 03

3.3. Entrada y salida de información


En general, todos los algoritmos necesitarán de unos datos para que puedan
ejecutarse, como hemos estudiado en la unidad anterior, esos datos se almacenan
en variables. Con mucha frecuencia estos datos son introducidos por el usuario del
programa, a través de cualquiera de los periféricos de entrada, el ratón, el teclado y
la memoria (mediante ficheros o archivos sobre los que trabaja el algoritmo).

Periféricos de entrada Periféricos de salida

1.teclado 1.Monitor
Back Up

2.Ratón

3.Scanner 3.Impresora

4.Micrófono 4.Filmadora

5.Cámara digital

5. Plotter

6.Video player
Diskette
Disco Duro

Figura 3.6. Periféricos de entrada/salida.

El objetivo de todo algoritmo es procesar datos para proporcionar una información.


Esta información, normalmente se proporcionará a través de cualquiera de los
periféricos de salida, la impresora, la pantalla o la memoria (a un fichero).

Desarrollo de algoritmos 11
Formación Abierta

Para efectuar estas entradas y salidas existen, en los algoritmos, sentencias de


escritura y de lectura.

Entrada de datos (leer)

La instrucción Leer permite ingresar información a las variables mediante teclado.


Pueden incluirse una o más variables, por lo tanto, el comando leerá uno o más
valores.

Si la variable tiene un valor ya almacenado y hacemos una lectura se pierde su


valor anterior ya que tomará el valor nuevo, razón por la cual se dice que la lectura
es "destructiva" (destruye el valor que tenía previamente la variable).

Para la entrada de datos la sentencia es:

leer lista_de_variables_de_entrada;

Debe ir, obligatoriamente, la palabra leer y después los nombres de las variables en
las que se van a guardar dichos datos de entrada. Al declarar una variable,
reservaremos un espacio de memoria donde almacenamos esos datos de interés.

Se quiere desarrollar un algoritmo para calcular el


perímetro de un triángulo equilátero. Escribir las
sentencias de lectura que han de escribirse.

Solución:

Un triángulo equilátero tiene los tres lados iguales, luego


para calcular el perímetro sólo necesito conocer un lado
del triángulo (dato de entrada), por lo tanto la sentencia
de lectura para este algoritmo será:

Leer lado:

Lado es el nombre de la variable donde voy a guardar el


valor correspondiente que haya introducido el usuario.

Salida de datos (escribir)

Esta instrucción escribe en pantalla los valores obtenidos de evaluar las


expresiones. Dado que puede incluir una o más expresiones, mostrará uno o más
valores. Si hay más de una expresión, se escriben una a continuación de la otra.

La sentencia para mostrar la información obtenida por el usuario es la siguiente:

Escribir lista_de_variables_de_salida;

12 Desarrollo de algoritmos
Introducción a la Programación 03

Debe ir, obligatoriamente, la palabra escribir y después los nombres de las


variables en las que contienen los datos de salida.

Se quiere desarrollar un algoritmo para calcular el área y


el perímetro de un triángulo equilátero. Escribir las
sentencias de salida de información que han de
escribirse en el algoritmo.

Solución

El objetivo del algoritmo es calcular el área y el


perímetro, por lo tanto tendremos que escribir el
resultado de la variable donde se almacena el área, y
donde se almacena el perímetro y área, se escribirán tras
calcular el sus valores correspondientes, es decir:

Opción 1:

 Escribir área, perímetro.

Opción 2:

 Escribir área.
 Escribir perímetro.

Si hay más de una variable y se escriben a la vez, se


separan mediante comas, o bien se utiliza una sentencia
escribir con cada variable, como se puede observar en la
segunda opción.

Desarrollo de algoritmos 13
Formación Abierta

3.4. Diagramas de flujo


El diagrama de flujo es la técnica de representación de algoritmos más antigua. Su
uso es muy extendido aunque disminuido debido a la aparición de los lenguajes
estructurados.

En un diagrama de flujo se utilizan unos símbolos estándar (también llamados


cajas). Cada una de estas cajas representa un paso en el algoritmo; dentro de
estas cajas tenemos texto que expresan la sentencia concreta que ejecutan o la
expresión que se va a evaluar. Estas cajas están unidas con unos conectores que
se representan mediante flechas y que se denominan líneas de flujo.

Siguiendo las líneas de flujo, y en función de las expresiones que se evalúan en las
cajas, se puede ir siguiendo el recorrido de la información al ejecutarse el algoritmo.

Los diagramas de flujo (o flujogramas) son diagramas


que emplean símbolos gráficos para representar los
pasos o etapas de un proceso. También permiten
describir la secuencia de los distintos pasos o etapas y su
interacción.

Ventajas

 Favorecen la comprensión del proceso a través de mostrarlo como un dibujo. El


cerebro humano reconoce fácilmente los dibujos. Un buen diagrama de flujo
reemplaza varias páginas de texto.

 Permiten identificar los problemas y las oportunidades de mejora del algoritmo.

 Muestran las interfases y las transacciones que en ellas se realizan, facilitando


a los programadores el análisis de las mismas.

 Son una excelente herramienta para capacitar a los nuevos programadores de


un algoritmo ya empezado o terminado.

Símbolos en los diagramas de flujo

Los símbolos tienen significados específicos y se conectan por medio de flechas


que indican el flujo entre los distintos pasos o etapas.

A continuación se pueden ver los principales símbolos utilizados para representar


los algoritmos:

14 Desarrollo de algoritmos
Introducción a la Programación 03

 Terminal: se utiliza para representar el inicio y el final del algoritmo. También


puede representar una parada o interrupción programada que sea necesaria en
un programa.

Inicio / Fin

Figura 3.7. Terminal.

 Entrada/salida: sirve para representar cualquier tipo de proceso que represente


una entrada (desde un periférico, habitualmente es el teclado) o salida de datos
del algoritmo (hacia un periférico, habitualmente el monitor, aunque podría ser
la impresora el disquete etc.). Es representado por la siguiente caja:

Entrada

Figura 3.8. Entrada-salida.

En algunos casos veremos representada la salida o


entrada de datos de otras formas, pero otra forma muy
común de entrada y salida es escribir en el interior la
instrucción leer, que en este caso se identifica con la
entrada de datos, o escribir que es el caso de la salida,
en ambos caso siempre va acompañado de la variable a
leer o escribir.

 Proceso: cualquier tipo de operación que suponga un cambio de valor en una


variable, o en una posición de memoria, operaciones aritméticas, etc. Tiene
varias formas de representación pero las más conocidas son las siguientes:

Procesos

Figura 3.9. Proceso.

 Decisión: se utiliza para representar operaciones lógicas o de comparación


entre datos, y en función del resultado de la misma , se determina cuál de los
dos caminos se debe seguir. Normalmente tiene dos posibles salidas, pero
podría tener más.

Decisión

Figura 3.10. Decisión

Desarrollo de algoritmos 15
Formación Abierta

 Conector: sirve para enlazar dos partes cualesquiera de un ordinograma a


través de un conector en la salida y otro en la entrada. Este tipo de conexiones
están en la misma página.

Figura 3.11. Conector.

 Línea de flujo: representa el sentido de ejecución de las operaciones.

Figura 3.12. Línea de flujo.

Reglas para la creación de diagramas

 Los diagramas de flujo deben escribirse de arriba hacia abajo, y/o de izquierda
a derecha.

 Los símbolos se unen con líneas, las cuales tienen en la punta una flecha que
indica la dirección que fluye la información. En procesos se deben de utilizar
solamente líneas de flujo, horizontales o verticales (nunca diagonales).

 Se debe evitar el cruce de líneas, para lo cual se puede separar el flujo del
diagrama a un sitio distinto o se puede realizar utilizando los conectores. Se
debe tener en cuenta que sólo se deben utilizar conectores cuando sea
estrictamente necesario.

 No deben quedar líneas de flujo sin conectar.

 Todo texto escrito dentro de un símbolo debe ser legible, preciso, evitando el
uso de muchas palabras.

 Todos los símbolos pueden tener más de una línea de entrada, a excepción del
símbolo final.

 Sólo los símbolos de decisión pueden y deben tener más de una línea de flujo
de salida.

Dentro del diagrama podemos incorporar el texto


perteneciente al objeto Si deseamos añadir un texto
referente al diagrama general, añadiremos un cuadro al
principio de la hoja, donde insertaremos todos los
cometarios referentes como por ejemplo: autor, fecha,
enunciado del problema, nombre del diagrama, etc.

16 Desarrollo de algoritmos
Introducción a la Programación 03

3.4.1. Desarrollo diagrama de flujo


Para el desarrollo o la realización de un diagrama de flujo lo primero hay que
establecer el alcance del proceso a describir. De esta manera quedará fijado el
comienzo y el final del diagrama.

Identificar y enumerar las principales actividades/subprocesos que están incluidos


en el proceso a describir y su orden cronológico, en el ejemplo de la suma de dos
números, primero tendremos que identificar los dos números y posteriormente
realizar la suma de estos dos.

Identificar y listar los puntos de decisión, por ejemplo la comparación de dos


números y listar cual es el mayor. Construir el diagrama respetando la secuencia
cronológica y asignando los correspondientes símbolos, después asignar un título al
diagrama y verificar que esté completo y describa con exactitud el proceso elegido.

Veamos todo esto con un ejemplo práctico para que podamos entenderlo.

Práctica paso a paso

Escribir un algoritmo y expresarlo mediante diagrama de flujo para calcular el área y


el perímetro de un triángulo equilátero.

3
P  3./ A  . 2

1 I
h

Figura 3.13. Perímetro y área de triángulo.

1. Para poder resolver este algoritmo tenemos que conocer los datos de
entrada y los datos de salida:

 Datos de entrada: lado.

 Datos de salida: área y perímetro.


2. Lo primero que debemos dibujar es un terminal donde demos el inicio de
diagrama.

Inicio

Desarrollo de algoritmos 17
Formación Abierta

3. Para poder calcular el área y el perímetro se necesita conocer el lado del


triángulo, por lo tanto, hay que solicitarlo al usuario mediante la sentencia de
lectura. Esta sentencia es una entrada de datos, luego tenemos que usar la
caja de variable, y dentro escribiremos la sentencia de escritura. La variable
utilizada para guardar estos datos es: lado.

Leer lado

4. Una vez conocido el lado, el algoritmo ya puede calcular el área y el


perímetro, por lo tanto, la caja utilizada será el rectángulo de proceso puesto
que cambiaremos el valor de los variables área y lado.

Perímetro = 3* lado

Área = (rc (3)/4) * (lado^2)

5. Ya se ha calculado el área y el perímetro, luego los mostramos. Para ello


utilizamos la sentencia escribir dentro de la caja trapezoidal usada para
efectuar una salida.

Escribir área

Escribir perímetro

6. Con esto, tenemos finalizado el algoritmo, pero debemos cerrarlo con un


terminal fin.

Fin

18 Desarrollo de algoritmos
Introducción a la Programación 03

7. Para finalizar debemos unir todas las cajas mediantes flechas, para poder
seguir la secuencia, por lo que nos quedará representado el diagrama de
esta manera:

Inicio

Leer lado

Perímetro = 3* lado

Área = (rc (3)/4) * (lado^2)

Escribir área

Escribir perímetro

Fin

Desarrollo de algoritmos 19
Formación Abierta

3.5. Pseudocódigo
Otra forma de representar el algoritmo es utilizando pseudocódigo, que es un
lenguaje intermedio entre nuestro lenguaje y el que utilizamos para programar.

El objetivo es expresar el algoritmo de la forma más detallada posible.

La ventaja del pseudocódigo es que es muy parecido a los lenguajes de


programación, puesto que prácticamente utiliza las mismas estructuras, con la
única salvedad de que casi todos los lenguajes de programación la sintaxis se
expresa en inglés y el pseudocódigo se expresa en español. Nos permite
representar el algoritmo de una forma sencilla y fácil de manipular, y además de
facilitarnos el paso a un lenguaje de programación.

El algoritmo es el mismo independientemente del lenguaje de programación, por lo


que, una vez comprobado en pseudocódigo, lo escribimos en el lenguaje de
programación que vayamos a utilizar.

Para expresar un algoritmo mediante pseudocódigo se utiliza un número de


palabras limitadas; son las palabras reservadas del lenguaje que únicamente se
pueden utilizar para la construcción sintáctica del algoritmo y en consecuencia no
pueden ser identificadores.

Forma general de un algoritmo en pseudocódigo

Todo algoritmo en pseudocódigo tiene la siguiente estructura general:

Proceso SinTitulo

accion 1;

accion 2;

. .

accion n;

FinProceso

Comienza con la palabra clave “Proceso” seguida del nombre del programa, luego
le sigue una secuencia de instrucciones y finaliza con la palabra “FinProceso”. Una
secuencia de instrucciones es una lista de una o más instrucciones, cada una
terminada en punto y coma.

Las acciones incluyen operaciones de entrada y salida, asignaciones de variables,


condicionales si-entonces o de selección múltiple y/o lazos mientras, repetir o para.

20 Desarrollo de algoritmos
Introducción a la Programación 03

3.6. Desarrollo de pseudocódigo


Vamos a ver cómo se desarrolla un algoritmo en pseudocódigo explicándolo con el
ejemplo que hemos realizado hasta ahora, cálculo de perímetro y área de un
triángulo equilátero.

Todos los algoritmos en pseudocódigo están desarrollados


en los apuntes y están realizados con la aplicación PseInt.

El algoritmo tendrá el siguiente resultado, posteriormente pasaremos a la


explicación de cada línea de código.

1 Proceso Triangulo_equi
2 //declaracion de variables
3 definir lado Como entero; //dato entrada
4 definir area, perimetro Como Real; //dato salida
5 Escribir "Algoritmo Triangulo equilatero";
6 //solicito al usuario que introduzca el lado por teclado
7 Escribir "Introduce el valor del lado: ";
8 leer lado;
9 //calculamos el area y perimetro
10 perimetro<-lado*3;
11 area<-(rc(3)/4)*(lado^2);
12 //escribimos la solucion por pantalla
13 Escribir "el resultado del perimetro es:", perimetro;
14 Escribir "el resultado del area es: ", area;
15 FinProceso
Figura 3.14. Algoritmo triángulo equilátero.

A continuación, se va a describir cada una de las sentencias que forman el


algoritmo para que el alumno pueda entender qué es lo que se hace en cada paso;
no obstante cada una de las instrucciones se explicarán con más detenimiento en
unidades sucesivas.

Línea 1 Proceso Triangulo_equi: Comienza con la palabra clave “Proceso”


seguida del nombre del programa, luego le sigue una secuencia de
instrucciones y finaliza con la palabra “FinProceso” que la podemos
observar el la línea 15.

Desarrollo de algoritmos 21
Formación Abierta

Línea 2 Se pueden introducir comentarios después de una instrucción, o en


líneas separadas, mediante el uso de la doble barra ( // ).

Línea 3 Sección de declaración de variables, que se identifica mediante la


palabra clave “Definir”. Es aquí donde, en caso de que nuestro
programa utilice variables, se deben declarar. En el ejemplo:

Definir lado Como entero;

En nuestro caso hacemos uso de tres variables, una de ellas de


entrada, y dos salidas que nos van a guardar los resultados. La variable
dato es de tipo entero, pero las de salida son reales, ya que las
operaciones que utilicemos nos pueden dar resultados con decimales
(línea 4).

En general es muy aconsejable elegir los nombres de las


variables de forma que permitan conocer a simple vista
qué tipo de variable o función representan. Esto simplifica
enormemente la tarea de programación y sobre todo de
corrección y mantenimiento de los programas.

Línea 5 La siguiente instrucción sirve para mostrar un mensaje por pantalla al


usuario para informar de cuál es el propósito del programa.

Línea 6 Comentario en línea programa.

Línea 7 La siguiente instrucción también muestra un mensaje en pantalla, en


este caso el mensaje es: Introduce el valor del lado.

Línea 8 A continuación el programa espera a que el usuario introduzca un valor


de tipo real para leerlo y almacenarlo en la variable lado.

Línea 9 Comentario en línea programa.

Línea 10 Asignación. Al ejecutarse la asignación, primero se evalúa la expresión


de la derecha y luego se asigna el resultado a la variable de la
izquierda. El tipo de la variable y el de la expresión deben coincidir, por
lo tanto, en el ejemplo: multiplica el valor del lado por tres y lo guarda
en la variable perímetro.

22 Desarrollo de algoritmos
Introducción a la Programación 03

En algunos lenguajes la asignación se realiza mediante el


símbolo de igualdad, pero en Pseint la instrucción de
asignación, que permite almacenar un valor en una
variable, se expresa con la flecha hacia la izquierda.

<variable > <- <expresión> ;

Línea 11 La siguiente asignación tiene una expresión más larga ya que la


fórmula lo requiere, se detallan paso a paso las operaciones
aritméticas:

 Raíz cuadrada de tres.


 El valor anterior lo divide por 4.
 Efectúa el cuadrado del lado.
 Multiplica el valor obtenido en 3 por el valor obtenido en 2.
 El valor anteriormente calculado lo almacena en la variable
área.

Línea 12 Comentarios código.

Línea 13 Una vez calculado el área y el perímetro se muestra el mensaje por


pantalla al usuario en el que se le informa del valor que se ha obtenido,
para ello se utiliza la instrucción escribir.

Esta instrucción informa al ambiente (en este caso escribiendo en


pantalla) de los valores obtenidos de evaluar N expresiones. Dado que
puede incluir una o más expresiones, mostrará uno o más valores. Si
hay más de una expresión, se escriben una a continuación de la otra
sin separación, por lo que el algoritmo debe explicitar los espacios
necesarios para diferenciar dos resultados si así lo requiere.

Desarrollo de algoritmos 23
Introducción a la Programación 03

 Resumen

 En esta unidad didáctica hemos visto cuáles son las etapas que se deben dar
para la resolución de un problema en un ordenador. Son tres: análisis del
problema, diseño del algoritmo y resolución del problema en el ordenador. Las
dos primeras etapas son independientes del lenguaje de programación y es de
lo que trata fundamentalmente esta asignatura.

 Hemos visto que para que un algoritmo sea interactivo, es decir pueda pedir
datos al usuario, debe utilizar la sentencia Leer lista_de_variables; que permite
al algoritmo dar valor a una variable que utiliza. Para mostrar el resultado del
algoritmo al usuario, es decir, la información o datos procesados (o mensajes
de información), se utiliza la sentencia Escribir lista_de_expresiones;

 Tanto las sentencias Leer lista_de_variables; como Escribir


lista_de_expresiones; pueden introducir o mostrar más de un valor en la
misma sentencia, para ello cada uno de los valores o variables deben ir
separadas por comas.

 Para diseñar algoritmos se utilizan varias herramientas, de las cuales las más
importantes son el diagrama de flujo y el pseudocódigo. El pseudocódigo es la
herramienta para diseñar algoritmos que es la más parecida al lenguaje de
programación. En él, se expresa el algoritmo únicamente mediante sentencias
escritas, mientras que en el diagrama de flujo se combina el lenguaje escrito
con el dibujo de una serie de símbolos gráficos.

 Hemos visto las partes básicas que forman un algoritmo expresado en


pseudocódigo y hemos hecho ejemplos didácticos que nos han permitido
aclarar los principales conceptos al respecto.

Desarrollo de algoritmos 25
04 Introducción a la
Programación

Programación
estructurada
Introdución a la Programación 04

 Índice

 OBJETIVOS .......................................................................................................... 3
 INTRODUCCIÓN .................................................................................................. 4
4.1. Programación estructurada ....................................................................... 5
4.1.1. Programación estructurada ................................................................... 6
4.1.2. Recursos abstractos ............................................................................. 6
4.1.3. Diseño descendente ............................................................................. 7
4.2. Estructuras básicas .................................................................................... 8
4.2.1. Estructura secuencial ............................................................................ 8
4.2.2. Estructura selectiva ............................................................................... 9
4.2.2.1. Estructura selectiva simple ........................................................... 10
4.2.2.2. Estructura selectiva doble............................................................. 14
4.2.3. Estructura selectiva múltiple ............................................................... 18
4.3. Estructura repetitiva ................................................................................. 22
4.3.1. Estructura repetitiva mientras ............................................................. 23
4.3.2. Estructura repetitiva repetir ................................................................. 29
4.3.2.1. Estructura repetitiva: Para….hasta .............................................. 39
4.3.3. Errores en los bucles .......................................................................... 43
 RESUMEN .......................................................................................................... 47

Programación estructurada 1
Introdución a la Programación 04

 Objetivos

 En esta unidad didáctica vamos a ver las estructuras básicas de programación


que son empleadas en la mayoría de los lenguajes.

 Conocer los tipos de programación que existen y cuáles son las diferencias
entre ellos, para luego entrar en detalle con la programación estructurada.

 Conocer la estructura secuencial, ésta es la estructura más básica en


programación. Esta estructura ya la hemos visto en las anteriores unidades
didácticas, pero sin hacer la referencia a ella como tal. Veremos qué sentencias
forman parte de la estructura secuencial.

 Conocer la estructura selectiva, para qué se utilizan y cómo se forman. Dentro


de la estructura selectiva hay varios tipos, veremos cuáles son, cuándo se
utilizan y cómo se forman.

 Conocer las estructuras iterativas, también conocidas como estructuras


repetitivas. Conocer los tipos que existen, cuándo es más recomendable utilizar
cada una de ellas y cómo se forman.

Programación estructurada 3
Formación Abierta

 Introducción

En esta unidad didáctica vamos a ver las estructuras básicas con las que se
construyen todos los programas. Hasta ahora los programas que se han
desarrollados únicamente ejecutaban instrucciones básicas como son la estructura
de asignación y las de lectura/escritura, es decir, se ejecutaban sentencias de
forma secuencial, una tras otra.

Vamos a ver las estructuras de selección, que sirven para ejecutar una sentencia
en función de una condición o condiciones determinada, es decir, que no tiene que
ejecutarse siempre. Dentro de este tipo de estructura se encuentran las estructuras
anidadas que sirven para evaluar más de una condición.

Una vez vistas las anteriores estructuras, veremos las estructuras repetitivas. En
determinados programas se repiten una serie de instrucciones; para evitar escribir
líneas de código de forma innecesaria, se utilizan las estructuras repetitivas. Estas
estructuras además de evitar escribir líneas de código también hacen que el
programa sea más legible. El grupo de sentencias contenido dentro de la estructura
repetitiva se ejecuta en función de una expresión booleana. Veremos qué formas
hay de controlar estas estructuras repetitivas (también llamadas estructuras
iterativas o bucles).

Estas estructuras son básicas en programación, puesto que todos los lenguajes
de programación utilizan este tipo de estructuras, por lo cual esta unidad didáctica
es muy importante: no sólo en esta asignatura, sino en cualquier asignatura de
programación.

Estudiaremos estos tres tipos de estructuras (secuencia,


selección y repetición), empleando algoritmos en
pseudocódigo y los programas están desarrollados en
PSEINT como en unidades anteriores.

4 Programación estructurada
Introdución a la Programación 04

4.1. Programación estructurada


Existen dos tipos básicos de programación, la programación estructurada y la
programación modular.

La programación estructurada es la base de la programación clásica y es utilizada


para resolver problemas de pequeña y mediana complejidad. Por el contrario,
cuando se quieren resolver problemas complejos se utiliza la programación
modular. Consiste en dividir el problema inicial en pequeños subproblemas que se
implementan de forma totalmente independiente. La programación modular se basa
en la programación estructurada, puesto que se utilizan todas las estructuras
propias de la programación estructurada.

La ventaja de la programación modular es que al dividir el problema inicial en


subproblemas más pequeños, como se puede ver en la siguiente figura, cada uno
de los módulos se puede implementar de forma totalmente independiente. Esto
hace posible que programas muy grandes y muy complejos puedan ser
desarrollados por varios programadores al mismo tiempo sin necesidad de que un
programador tenga que esperar a que otro termine. Además, hace más sencillo la
depuración de errores en un programa, es decir, solucionar fallos existentes en el
programa.

Raíz

Módulo 1 Módulo 2 Módulo 3 Módulo 4

Módulo 1.1 Módulo 1.2 Módulo 2.1 Módulo 3.1 Módulo 3.2 Módulo 4.1

Módulo 4.1.1

Figura 4.1. Programación modular.

Los subproblemas o subprogramas, también llamados módulos, son controlados


desde el módulo base también llamado programa principal.

Programación estructurada 5
Formación Abierta

4.1.1. Programación estructurada


El término programación estructurada hace referencia a un conjunto de técnicas
que toman como base los primeros trabajos de Edgar Dijkstra y que han ido
evolucionando. Mediante estas técnicas se reduce el tiempo para escribir, verificar y
mantener los programas con lo que la productividad del programa aumenta.
Mediante la programación estructurada se utilizan muy pocas estructuras de control
lo cual repercute en que la complejidad de los problemas disminuye y por tanto el
número de errores también disminuye.

Este tipo de programación se basa en el uso de las siguientes técnicas:

 Utilización de recursos abstractos.


 Utilización de diseño descendente.
 Utilización de las estructuras básicas.

4.1.2. Recursos abstractos


Cuando nos referimos a recursos abstractos nos estamos refiriendo a la capacidad
de abstraer un problema determinado, es decir, al resolver un problema concreto
hemos de pasar del problema en sí a la secuencia de pasos que nos permita
resolver dicho problema.

Un ejemplo, en la vida cotidiana “conducir un automóvil” o “hacer el desayuno”, los


detalles exactos de cómo se conduce un automóvil o cómo se prepara el desayuno
están “ocultos” dentro del nombre proceso, y se espera que cualquiera que
entienda nuestro lenguaje sepa a qué nos estamos refiriendo cuando usamos el
nombre del proceso en vez de los detalles exactos del proceso.

En programación, abstraer un programa consiste en determinar la secuencia de


pasos, es decir, descomponer una acción compleja en acciones más sencillas. A
través de las acciones más sencillas llegamos a la solución de la acción más
compleja.

Evaluar si un número es primo. Bien, todos sabemos


cuando un número es primo, cuando únicamente es
divisible por sí mismo y por la unidad.

Por la tanto, para un número dado hemos de evaluar si


tiene más de dos divisores, en cuyo caso no será primo.

6 Programación estructurada
Introdución a la Programación 04

Para encontrar los divisores, hay que saber cuándo un número es divisible entre
otro. Un número es divisible entre otro cuando el resto de la división entera es cero.

En el ejemplo anterior hemos abstraído el problema inicial, determinar si un número


es primo, descomponiendo el problema inicial en acciones más simples.

4.1.3. Diseño descendente


El diseño descendente también es conocido como diseño top-down (de lo más alto
a lo más bajo) y consiste en la transformación mediante la cual un problema se
descompone en una serie de niveles sucesivos de refinamiento. Cada nivel tiene
una entrada o entradas y una salida o salidas, y se relacionan entre ellos a través
de las entradas y las salidas, puesto que las salidas de uno sirven como entradas
de otro.

Así, por ejemplo, podemos considerar el problema de encontrar el máximo común


divisor (mcd) de dos números. El mcd se calcula como el producto de los divisores
comunes elevados a la mínima potencia. Este problema se podría descomponer en
las siguientes tareas:

 Encontrar los divisores de cada número.


 Evaluar si son comunes.
 Hacer el producto de los divisores comunes.

En la siguiente figura se puede ver la transformación del problema anterior


mediante un nivel de refinamiento.

Figura 4.2. Ejemplo de diseño descendente.

Programación estructurada 7
Formación Abierta

4.2. Estructuras básicas


La programación estructurada es un estilo con el cual se busca que el programador
elabore programas sencillos y fáciles de entender. Para ello, la programación
estructurada hace uso de tres estructuras básicas de control.

 Secuenciales.

 Selectivas.

 Repetitivas.

Corrado Böhm y Giuseppe Jacopini demostraron en 1966


que un programa propio se puede escribir únicamente
utilizando estos tres tipos de estructuras de control.

Como ya hemos comentado en otras unidades, para que un programa pueda


definirse como propio ha de cumplir tres características.

 Un programa debe tener un único punto de entrada y uno de salida o fin


para el control del programa.
 Todos los caminos deben ir desde la entrada hasta la salida y además
pasan por todas las partes del programa.
 Todas las instruciones se deben poder ejecutar y no deben existir bucles
infinitos (estructuras repetitivas que no acaban nunca).

4.2.1. Estructura secuencial


Una estructura secuencial es aquella en la que una acción, instrucción o sentencia
va a continuación de otra. En este tipo de estructura, la salida de una instrucción es
la entrada de la siguiente instrucción, esto se repite hasta el fin del proceso. Toda
estructura secuencial debe tener una entrada y una salida.

En las siguientes figuras podemos ver cómo se puede representar o expresar la


estructura secuencial en las dos formas de representación de algoritmos con las
que vamos a trabajar: diagramas de flujo y pseudocódigo.

8 Programación estructurada
Introdución a la Programación 04

Figura 4.3. Estructura secuencial en diagrama de flujo.

Las cajas A y B pueden ser definidas para ejecutar desde una simple instrucción
hasta un módulo o programa completo, siempre y cuando éstos también sean
programas apropiados.

Ponemos como ejemplo de un pseudocódigo secuencial el realizar la suma y resta


de dos números leídos desde teclado, donde el resultado es el siguiente:

1 Proceso ejemplo

2 Definir A,B Como Entero;

3 definir Suma, Resta Como Entero;

4 Leer A;

5 Leer B;

6 Suma =A+B;

7 Resta=A-B;

8 Escribir "la suma: ", suma;

9 Escribir "la resta: ",resta;

10 FinProceso

Figura 4.4. Estructura secuencial en pseudocódigo.

4.2.2. Estructura selectiva


Utilizando únicamente la estructura secuencial se pueden abordar muy pocos
problemas, puesto que en ningún momento podemos evaluar ningún tipo de
condición.

Las estructuras selectivas permiten ejecutar una sentencia o un grupo de


sentencias en función de una o varias condiciones. Si el resultado de evaluar la
condición o condiciones es verdadero, se ejecuta el grupo de instrucciones.

Las condiciones que se evaluarán en las estructuras selectivas se especifican


usando expresiones lógicas. El resultado de evaluar cualquier expresión lógica es
un valor booleano (también llamado lógico) verdadero o falso.

Programación estructurada 9
Formación Abierta

Hay tres tipos de estructuras selectivas que veremos a continuación y que son:

 Estructura selectiva simple.


 Estructura selectiva doble.
 Estructura selectiva múltiple.

4.2.2.1. Estructura selectiva simple


En la estructura selectiva simple se ejecuta una acción o un grupo de acciones en
función de una condición. Si la condición (booleana o lógica) es verdadera se
ejecuta el grupo de acciones.

La estructura de selección simple evalúa una condición,


si ésta es verdadera ejecuta una o varias instrucciones, si
es falsa continúa la ejecución normal del programa.

La representación gráfica utilizando el diagrama de flujo es la que se puede


observar en la siguiente figura. En el diagrama de flujo se escribe dentro del rombo
la condición que se quiere evaluar. Si la condición es verdadera, se ejecuta el grupo
de sentencias o instrucciones que vienen a continuación, en caso contrario, se pasa
a ejecutar la siguiente instrucción.

Falso Verdadero
Expresión
Booleana

Instrucciones

Figura 4.5. Diagrama de flujo estructura selectiva simple.

La representación en el lenguaje de especificación de algoritmos, pseudocódigo, es


la que se puede observar en la siguiente figura. La interpretación es muy similar a la
anterior, sólo que en este caso se utiliza únicamente la expresión escrita.

10 Programación estructurada
Introdución a la Programación 04

Si el resultado de evaluar la condición es verdadero, se ejecuta la acción o grupo de


acciones o sentencias comprendido entre el entonces y el finsi, en caso contrario,
se pasa a la siguiente instrucción.

1 Si expresion_logica Entonces

2 Acción 1;

3 Acción 2;

4 .

5 .

6 Acción n;

7 FinSi

Figura 4.6. Estructura selectiva simple en pseudocódigo.

En la figura anterior podemos observar el “indentado” o “tabulado” de las


sentencias. Esto no afecta en nada al correcto funcionamiento del algoritmo, pero sí
es recomendable hacerlo puesto que ayuda a identificar más rápidamente la
condición que debe de cumplirse para ejecutar las sentencias, es decir, en la figura
anterior se puede observar que las n-acciones sólo se ejecutan si la condición es
verdadera.

A continuación vamos a ver una serie de ejemplos que nos ayuden a entender el
funcionamiento de dichas instrucciones.

Práctica para estructura selectiva simple

La práctica consiste en hacer un algoritmo para calcular el área y el volumen de un


cilindro. Resolver el algoritmo mediante diagrama de flujo y mediante
pseudocódigo. Pero debemos verificar que los datos necesarios para hacer los
cálculos son positivos, mayor a 0, en caso contrario no se calcula nada y el
programa finaliza.

 Datos de entrada: radio y altura.


 Datos de salida: área y volumen.

Los pasos que hay que seguir para resolver este algoritmo son los siguientes:

 Pedir los datos a usuario, radio y altura.


 Si los datos anteriores son positivos:
 Calcular el área.
 Calcular el volumen.
 Escribir los resultados para que el usuario los pueda ver.

Programación estructurada 11
Formación Abierta

El algoritmo expresado en diagrama de flujo es el siguiente:

Proceso cilindro

Inicio

Definir radio, altura, volumen como real;

“Introduce el radio”

Radio

“Introduce la altura:”

Altura

(Radio>0) y (Altura>0)

Área 2*3.1416*Radio ^2+2*3.1416*Radio*Altura

Volumen 3.1416*Radio ^2*Altura

“El Área es:”, Área

“El Volumen es:”, Volumen

Fin

Figura 4.7. Diagrama flujo.

12 Programación estructurada
Introdución a la Programación 04

El diagrama resuelto mediante pseudocódigo es el siguiente:

Figura 4.8. Pseudocódigo.

Vamos a ver paso a paso la ejecución del mismo:

 Como es sabido, todo algoritmo debe de tener la cabecera, línea 1, y fin de


proceso en la línea 14.
 A continuación, declaramos las variables necesarias en nuestro algoritmo,
línea 2. En nuestro caso son cuatro. El tipo de las variables es el real,
puesto que el radio y la altura pueden tomar cualquier valor real (positivo) y
en consecuencia el área y el volumen también.
 Se piden los datos al usuario, el radio y la altura, para ello se muestran los
mensajes correspondientes, y una vez tecleado el valor por el usuario se
guarda el valor en la variable correspondiente, líneas 5 a 7.
 Una vez obtenidos los valores, se comprueba si son mayores, línea 8. Para
que se pueda calcular el área y el volumen, ambos valores deben ser
mayores a cero, por ello se utiliza el operador lógico y (&) para evaluar esta
condición. En caso de que se cumplan las dos condiciones se ejecutan las
siguientes instrucciones (se puede observar que se tabula para identificar
que el grupo de instrucciones están contenidas dentro de la instrucción de
selección simple si-entonces):
 Se calcula el área del cilindro y el volumen en las líneas 9 y 10.
 Se muestra mensaje al usuario (en la pantalla), líneas 11 y 12, para
informar del valor del área y del volumen.
 Una vez finalizadas el grupo de instrucciones, se finaliza la instrucción si
mediante la palabra finsi, línea 13.
 Por último, se finaliza el programa mediante la palabra fin, línea 14.

Programación estructurada 13
Formación Abierta

4.2.2.2. Estructura selectiva doble


Mediante la estructura selectiva doble se permite elegir entre dos grupos distintos
de acciones o sentencias; es decir, si la condición de evaluación de la instrucción
es evaluada como verdadera, se ejecutan un grupo de sentencias, mientras que si
es evaluada como falsa, se ejecuta otro grupo de instrucciones distintas.

La representación gráfica mediante diagrama de flujo se puede observar en la


siguiente figura. La condición a evaluar se escribe dentro de un rombo. Si la
condición es evaluada como verdadera se ejecuta un grupo de acciones, que se
escriben dentro de un rectángulo, mientras que si la condición es evaluada como
falsa se ejecutan otro grupo de acciones distintas que se escriben dentro de otro
rectángulo.

Si No
Condición

Acciones Acciones

Figura 4.9. Diagrama de flujo estructura selectiva doble.

La representación en el lenguaje de especificación de algoritmos, pseudocódigo,


puede observarse en la siguiente figura. En este caso si la condición es evaluada
como verdadera se ejecuta la acción a grupo de acciones que se encuentran a
continuación de la palabra entonces, por el contrario, si la condición es evaluada
como falsa se ejecuta la sentencia o grupo de sentencias que se encuentran a
continuación de la palabra sino.

1 Si expresion_logica Entonces

2 acciones_por_verdadero

3 Sino

4 acciones_por_falso

5 FinSi

Figura 4.10. Instrucción correspondiente a la estructura selectiva doble.

14 Programación estructurada
Introdución a la Programación 04

La diferencia con la estructura selectiva simple es que en el caso de la estructura


selectiva simple únicamente se ejecuta una acción o grupo de acciones en caso de
que la condición sea verdadera, y no se ejecuta ninguna acción si la condición es
evaluada como falsa. En el caso de la estructura selectiva doble hay un grupo de
acciones a ejecutar si la condición es evaluada como verdadera, pero también hay
un grupo de instrucciones o sentencias a ejecutar si la condición es evaluada como
falsa.

Vamos a ver un ejemplo que aclare la utilización de la estructura selectiva doble.

Práctica para estructura selectiva doble

Hacer un algoritmo para calcular el área y el volumen de un cilindro. Resolver el


algoritmo mediante diagrama de flujo y mediante pseudocódigo. Si no se puede
calcular el área y el volumen se mostrará un mensaje de error.

Este ejercicio es muy similar al anterior, la única


diferencia es que en caso de que la condición sea
evaluada como falsa se mostrará un mensaje indicando
que ha habido un error al introducir los datos.

 Datos de entrada: radio y altura.


 Datos de salida: área y volumen o mensaje de error.

Los pasos que hay que seguir para resolver este algoritmo son los siguientes:

 Pedir los datos a usuario, radio y altura.


 Si los datos anteriores son positivos:
 Calcular el área.
 Calcular el volumen.
 Escribir los resultados para que el usuario los pueda ver.
 Si alguno de los datos son negativos o 0 se muestra el mensaje de error.
Esto equivale a que la condición anterior es evaluada como falsa, puesto
que será evaluada de esta forma en el caso de que alguna de las
condiciones sea falsa, es decir, el radio o la altura son menores o igual que
cero.

Programación estructurada 15
Formación Abierta

El algoritmo expresado en diagrama de flujo es el siguiente:

Proceso cilindro 2

Inicio

Definir radio, altura, volumen como real;

“Introduce el radio”

Radio

“Introduce la altura:”

Altura

(Radio>0) y (Altura>0)

“Los datos introducidos son erróneos!!!” Área 2*3.1416*Radio ^2+2*3.1416*Radio*Altura

Volumen 3.1416*Radio ^2*Altura

“El Área es:”, Área

“El Volumen es:”, Volumen

Fin

Figura 4.11. Diagrama flujo.

16 Programación estructurada
Introdución a la Programación 04

El diagrama resuelto mediante pseudocódigo es el siguiente:

Figura 4.12. Pseudocódigo.

En este ejemplo se han añadido dos líneas nuevas de código con respecto al
ejemplo de la estructura selectiva simple que son las líneas 13 y 14 que sirven para
mostrar el mensaje de error, en el caso de que alguno de los datos sea negativo.

Para ilustrar mejor la diferencia entre los dos algoritmos, vamos a ejecutar los dos
programas suponiendo que el usuario introduce el valor 1.2 cuando el programa
solicita el radio y –2.6 cuando se solicita el valor de la altura.

Cuando ejecutamos el algoritmo podemos observar que muestra lo que el usuario


vería en la pantalla del ordenador. Por lo tanto, sólo se verá en pantalla lo que
indiquen las instrucciones de escritura. También hay que tener en cuenta que
cuando hay instrucciones de lectura, y dentro de la instrucción hay uno o más
nombre de variables, el algoritmo espera que se introduzca un valor desde el
teclado.

Si se ejecuta el algoritmo correspondiente al último ejemplo de estructura selectiva


doble, el resultado es el siguiente:

Figura 4.13. Salida del algoritmo.

Programación estructurada 17
Formación Abierta

4.2.3. Estructura selectiva múltiple


En muchos algoritmos se presentan más de dos opciones de elección de
alternativas, en tales casos es más conveniente utilizar la estructura selectiva
múltiple, frente a una estructura selectiva doble (o anidada). El funcionamiento de la
estructura selectiva múltiple es similar a la estructura selectiva doble.

En el caso de la estructura selectiva doble las alternativas son dos, en función de


una condición cuyo resultado será un valor lógico falso o verdadero, cada una de
las cuales lleva asociada la ejecución de una o varias acciones.

En el caso de la estructura selectiva múltiple las


alternativas pueden ser dos o más, pero en general
suelen ser más de dos. A diferencia de la estructura
selectiva múltiple, la condición de evaluación, no tiene
que ser una condición cuyo resultado sea un valor lógico,
sino que puede ser cualquier tipo de expresión cuyo
resultado sea un valor de tipo ordinal.

Como ya se ha comentado, los tipos ordinales son el booleano, el carácter, el


entero y cualquier tipo de dato derivado de los tipos de datos anteriores.

Para la estructura selectiva múltiple, se define para qué valores se ejecuta un


conjunto determinado de acciones.

La representación gráfica mediante diagrama de flujo se puede ver en la siguiente


figura. Dentro del rombo se escribe la expresión o condición a evaluar, la cual en
función de los valores que puede tomar ejecuta una serie de instrucciones.

Condición

1 2 3 4 5

Acciones Acciones Acciones Acciones Acciones

Figura 4.14. Diagrama de flujo estructura selectiva múltiple.

18 Programación estructurada
Introdución a la Programación 04

La representación en el lenguaje de especificación de algoritmos, pseudocódigo, es


la que se puede observar en la siguiente figura. Se hace una enumeración de los
valores para los cuales hay que ejecutar una sentencia o grupo de sentencias, en la
figura siguiente, la expresión puede tomar los valores según variable_numérica,
opcion1, opcion2, …,opción_n. Opcionalmente, puede ir la sentencia DeOtroModo,
la acción o acciones asociadas se ejecutarán cuando el resultado de evaluar
expresión no tome ninguno de los valores enumerados para los cuales hay que
ejecutar un grupo de sentencias, es decir para aquellos valores que no estén dentro
de la lista de valores opcion1, opcion2, …, opción. En el caso de que no se
encuentre esta sentencia y la expresión tome algún valor distinto de la lista de
valores no se ejecutaría nada.

La estructura de selección múltiple empieza con la palabra Según y acaba con la


palabra FinSegun.

1 Segun variable_numerica Hacer

2 opcion_1:

3 secuencia_de_acciones_1

4 opcion_2:

5 secuencia_de_acciones_2

6 opcion_3:

7 secuencia_de_acciones_3

8 De Otro Modo:

9 secuencia_de_acciones_dom

10 FinSegun

Figura 4.15. Estructura selectiva doble en pseudocódigo.

A continuación se van a exponer algunos ejemplos que clarifiquen el uso de esta


estructura.

Práctica para estructura selectiva múltiple

Hacer un programa para que, dada una nota (entero), muestre la calificación
obtenida para dicha nota. Las calificaciones son:

 10: matrícula de honor.


 9: sobresaliente.
 7, 8: notable.
 6: bien.
 5: suficiente.

Programación estructurada 19
Formación Abierta

 0, 1, 2, 3, 4: insuficiente.

El algoritmo debe pedir una nota al usuario y posteriormente en función de dicho


valor mostrará la calificación. Si la calificación no está entre los valores
anteriormente expuestos se mostrará un mensaje de error.

 Datos de entrada: un número entero.


 Datos de salida: un mensaje.

Los pasos que hay que seguir para resolver el algoritmo son:

 Pedir un número.
 Leer un número.
 Escribir la calificación.

El algoritmo resuelto mediante diagrama de flujo es el siguiente:

Proceso cilindro

Inicio

Definir nota como entero;

“Este programa muestra la calificación obtenida

“Introduce la nota:”

Nota

10 9 8 7 6 5 4,3,2,1,0 De otro modo

“La calificación “La calificación “La calificación “Error, valor


“La calificación “La calificación “La calificación “La calificación
es Matrícula es es fuera de
es Notable” es Notable” es Bien” es Suficiente”
de Honor” Sobresaliente” Insuficiente” rango”

Fin

Figura 4.16. Diagrama flujo.

20 Programación estructurada
Introdución a la Programación 04

El algoritmo resuelto mediante pseudocódigo es el siguiente:

Figura 4.17. Pseudocódigo.

En el ejemplo anterior podemos ver que la expresión que se va a evaluar, en la


estructura de selección múltiple, es la variable nota que es de tipo entero. Esta
instrucción compara el valor introducido por el usuario, con los valores enumerados
dentro de la lista de valores; si el resultado de la comparación es el valor lógico
verdadero, se ejecuta la instrucción o instrucciones asociadas a ese valor. Si la
variable nota toma un valor distinto a cualquier valor de la lista de valores, se
ejecuta la acción o acciones asociadas a la sentencia de otro modo.

Si la acción o grupo de acciones a ejecutar es el mismo para una serie de valores


se puede poner separados por comas dentro de la opción, tal y como podemos
observar en la línea 19.

Programación estructurada 21
Formación Abierta

4.3. Estructura repetitiva


Las estructuras repetitivas sirven para ejecutar una acción o un grupo de acciones,
un número determinado de veces que pueden o no conocerse a priori. La ventaja
de utilizar este tipo de estructuras es que únicamente hay que escribir una vez las
instrucciones que se quieren repetir; esto facilita tanto la lectura como la escritura
de los mismos.

Las estructuras repetitivas también son conocidas como


bucles. A cada ejecución de las instrucciones contenidas
dentro del bucle se le conoce como iteración.

Algunos ejemplos donde son muy evidentes las ventajas de utilizar una estructura
iterativa son:

 Cálculo de la nota media de una clase de 20 alumnos. Hay que solicitar la


nota de cada uno de los alumnos.
 Si se leen notas que están comprendidas entre 0 y 10 se puede forzar al
usuario a que introduzca un valor que esté dentro de este rango.
 Encontrar el número de divisores de un número.

Cuando se está empezando a programar no es fácil identificar el bucle o estructura


repetitiva que se quiere construir. Para construir una estructura repetitiva hay que
identificar las siguientes partes:

1. ¿Qué contiene el bucle? es decir qué sentencias o instrucciones deben


estar comprendidas dentro del bucle, de forma que se ejecutan en cada
iteración.
2. ¿Cuántas veces se ejecuta el bucle? es decir el número de veces que se
ejecutan las instrucciones comprendidas dentro del bucle.

En función del número de veces que se tiene que ejecutar un bucle se elige una de
las tres estructuras repetitivas, que son:

 Estructura repetitiva mientras: se ejecuta entre 0 y N veces.


 Estructura repetitiva repetir: se ejecuta entre 1 y N veces, pero siempre se
ejecuta al menos una vez.
 Estructura repetitiva desde: se utiliza cuando el número de iteraciones es
conocido a priori.

22 Programación estructurada
Introdución a la Programación 04

4.3.1. Estructura repetitiva mientras


En la estructura repetitiva mientras, se ejecuta el grupo de instrucciones contenidas
dentro del bucle si la condición de evaluación del bucle es evaluada como
verdadera, en caso contrario se finaliza el bucle. Debido a que se evalúa la
condición del bucle al inicio, la estructura repetitiva mientras puede ejecutarse entre
0 y N veces.

La representación gráfica utilizando el diagrama de flujo es la que se puede


observar en la siguiente figura. En el diagrama de flujo se escribe dentro del rombo
la condición que se quiere evaluar para que se ejecute el bucle. Si la condición es
verdadera, se ejecuta el grupo de sentencias o instrucciones que vienen a
continuación, después de lo cual se vuelve al inicio del bucle para volver a evaluar
la condición de ejecución del bucle. Por el contrario, si la condición es evaluada
como falsa, no se ejecuta el grupo de instrucciones contenida dentro del bucle sino
que se finaliza el bucle y en consecuencia se pasa a la instrucción a continuación
del bucle.

No

Condición

Si

Acciones

Figura 4.18. Estructura mientras.

La representación en el lenguaje de especificación de algoritmos, pseudocódigo, de


la estructura repetitiva mientras es la que se puede observar en la siguiente figura.
Al igual que en el caso anterior, antes de ejecutar el grupo de instrucciones se
evalúa la condición. Si el resultado de evaluar la condición es verdadero, se
ejecutan las n-instrucciones comprendidas dentro del bucle. Una vez ejecutadas se
llega a la sentencia FinMientras, momento en el cual se vuelve al inicio del bucle
para evaluar de nuevo la condición.

Programación estructurada 23
Formación Abierta

Esto se realiza de forma reiterada hasta que la condición sea evaluada como
[falsa], momento en el cual se pasa a ejecutar la instrucción que se encuentra a
continuación de la sentencia FinMientras:

1 Mientras expresion_logica Hacer

2 secuencia_de_acciones

3 FinMientras

Figura 4.19. Estructura repetitiva mientras en pseudocódigo.

Para ilustrar el funcionamiento de las estructuras iterativas vamos a ver una serie
de ejemplos, en los cuales, partiendo de un programa sin estructuras iterativas
llegamos a identificar las sentencias o acciones que se repiten para,
posteriormente, construir la estructura repetitiva.

Ejemplo de estructuras repetitiva mientras

Hacer un programa que sirva para hacer la media de 5 valores que se pedirán al
usuario.

Para hacer este programa o algoritmo hay que conocer cómo se calcula la media
de una serie de valores. Para hacer la media, se hace la suma de los 5 valores y
posteriormente se divide para 5. Los 5 valores se van pidiendo al usuario y, una vez
que se tiene, se suma a la cantidad anterior, hasta que se han leído los 5 valores.

 Datos de entrada: un valor.


 Datos de salida: la media de los 5 valores.

Los pasos que hay que seguir para resolver el algoritmo anterior son los siguientes:

 Se necesita una variable para leer el valor y otra para ir almacendo la suma
parcial (inicialmente vale cero).
 Se pide la primera nota.
 Se suma la primera nota a la suma parcial.
 Se pide la segunda nota.
 Se suma la segunda nota a la suma parcial.
 Se pide la tercera nota.
 Se suma la tercera nota a la suma parcial.
 Se pide la cuarta nota.
 Se suma la cuarta nota a la suma parcial.
 Por último, se divide la suma parcial entre 5 y se muestra el resultado.

24 Programación estructurada
Introdución a la Programación 04

El algoritmo anterior resuelto utilizando pseudocódigo es el siguiente:

Figura 4.20. Pseudocódigo

Para construir cualquier estructura repetitiva hay que seguir los siguientes pasos:

1. Identificar el grupo de sentencias que se repiten y que formarán el cuerpo


del bucle.

Se puede observar claramente que el grupo de sentencias que se repiten


son las sentencias que se encuentran en las líneas 5, 6 y 7. En
consecuencia, ésas serán las instrucciones que van situadas dentro del
bucle (también llamado cuerpo del bucle).

2. Identificar la condición o expresión que controla la ejecución del bucle.

En este caso se puede observar que hay que pedir 5 notas, de modo que
necesitaremos una variable que cuente el número de notas que se han
leído.

Hay que tener presente que las instrucciones contenidas dentro del bucle se
ejecutan mientras la condición que controla el bucle sea verdadera. En nuestro
caso, hay que seguir pidiendo notas hasta que lleguemos a 5.

Programación estructurada 25
Formación Abierta

Podemos observar que el diagrama de flujo queda de la siguiente:

Proceso medial

Inicio

Definir valor, suma, contador como reall;

Suma 0

Contador 1

F
Contador<=5

V
“Introduce el valor” , Contador

Valor

Suma Suma + Valor

Contador Contador+1

“La media es. “(suma/5)

Fin

Figura 4.21. Diagrama flujo.

26 Programación estructurada
Introdución a la Programación 04

El algoritmo queda de la siguiente forma.

Figura 4.22. Pseudocódigo.

 Se ha añadido una nueva variable, contador, que sirve


para contar cuántas notas se han leído.
 Inicialmente, el contador lo inicializamos a 1 de ahí la
instrucción de la línea 5.
 En cada iteración se incrementa contador en 2, línea
10; es decir, se ha leído una nota más. A las variables
que aparecen a la izquierda y a la derecha del
operador asignación, = se les conoce como
acumuladores puesto que lo que hacen es
incrementar el valor que ya tenían, en la cantidad que
se indica a continuación. Todos los acumuladores se
han de inicializar, normalmente fuera del bucle, a un
valor inicial que se determina en función del programa.
 La condición que controla el bucle es que contador
sea menor o igual que 5, línea 6. En este caso menor
estricto, puesto que si contamos desde 1 hasta 5
incluido se cuentan 5 valores. Esto es debido a que se
ha inicializado la variable a 1.
 El resultado es el mismo si se inicializa a 0 la variable
contador y la condición es contador < 5.
 La variable suma también es un acumulador, puesto
que suma al valor que contenía anteriormente el valor
que se lee en cada iteración. Puesto que es un
acumulador hay que inicializarlo (dar un valor inicial a
la variable) fuera de la estructura iterativa.
 Por último, la media se ha de calcular fuera de la
estructura repetitiva.

Programación estructurada 27
Formación Abierta

A continuación vamos a ver en una tabla el valor que toma la condición que controla
el bucle, y las variables valor, suma y contador.

Valor
Iteración contador < =5 (introducido por Suma contador
teclado)

0 - 0 1

1 1<=5 (verdadero) 10 10 (0+10) 2 (1+1)

2 2<=5 (verdadero) 2 12 (10+2) 3 (2+1)

3 3<=5 (verdadero) 6 18 (12+6) 4 (3+1)

4 5<=5 (verdadero) 7 25 (18+7) 5 (4+1)

4 <=5
5 4 29 (25+4) 6 (5+1)
(verdadero)

6 5 <= 5 (falso) - 29 6

Figura 4.23. Tabla salida de variables.

En la iteración cero se muestran los valores que tienen cada una de las variables
antes de llegar a la instrucción de la línea 6 (recordar que en este caso se quiere
hacer la media de 5 valores). Por lo tanto, el valor para la variable valor es
desconocido.

En las iteraciones 1, 2, 3, 4 y 5 podemos ver qué valores van tomando cada una de
las variables, así como el valor que toma la condición del bucle.

Se puede ver que cada iteración supone evaluar las instrucciones o sentencias de
la línea 6-11.

Después de ejecutar la instrucción de la línea número 11, se vuelve a evaluar la


condición del bucle, instrucción de la línea número 6. Se ejecutan las sentencias
contenidas dentro del bucle cuando el resultado de evaluar la condición o
expresión que controla la ejecución del bucle sea verdadera.

En la iteración número 6, antes de ejecutarla, se evalúa la condición contador <=5,


puesto que la variable contador tiene el valor 6, la condición es falsa y, por lo tanto,
no se “entra” a ejecutar las sentencias del bucle.

Podemos observar que, efectivamente, el programa ha hecho la media de 5


valores, luego, la inicialización y control de la estructura iterativa es correcto.

28 Programación estructurada
Introdución a la Programación 04

4.3.2. Estructura repetitiva repetir


La estructura repetitiva repetir es similar en funcionamiento a la estructura repetitiva
mientras. Las principales diferencias son dos:

 La estructura repetir, se ejecuta al menos una vez. Luego se usará esta


estructura en aquellos casos en los que al menos hay que ejecutar una vez
las acciones contenidas dentro del bucle.
 Las acciones contenidas dentro del cuerpo del bucle se repiten mientras la
condición que controla el bucle repetir sea falsa, o lo que es lo mismo, deja
de ejecutarse en el momento que la condición es evaluada como verdadera.

La representación gráfica mediante diagrama de flujo de la estructura repetitiva


repetir se puede observar en la siguiente figura. En el diagrama de flujo podemos
observar que la condición de evaluación del bucle está al final del mismo. El bucle
se puede identificar por el conjunto de símbolos comprendidos o abarcados por la
línea de flujo que “vuelve hacia arriba”. Recordad que únicamente en las
estructuras repetitivas hay líneas de flujo que vuelven hacia atrás. Puesto que la
condición de evaluación del bucle está al final del mismo, siempre se ejecutarán al
menos una vez las acciones comprendidas dentro del mismo.

Acciones

Condición

Figura 4.24. Diagrama de flujo de la estructura repetir.

El pseudocódigo de la estructura repetitiva repetir se muestra en la siguiente figura.


Se ejecutan las instrucciones contenidas dentro del cuerpo del bucle mientras la
condición sea evaluada como falsa, pero teniendo en cuenta que se ejecuta al
menos una vez. Las instrucciones contenidas dentro del bucle son aquellas que
están comprendidas entre las palabras repetir y hasta_que.

El funcionamiento de esta estructura iterativa es la siguiente:

 Se entra en el bucle y se ejecutan las acciones hasta que se llega al final del
mismo (hasta_que (condición)).

Programación estructurada 29
Formación Abierta

 Se evalúa la condición del bucle. Si el resultado de evaluar la condición o


expresión que controla la ejecución del bucle es falsa se vuelve al inicio del
bucle; es decir, a la instrucción que se encuentra a continuación de la
palabra repetir. Si el resultado de evaluar la condición es el valor verdadero
se finaliza la ejecución del bucle y se pasa a la instrucción que se encuentra
a continuación.

1 Repetir

2 secuencia_de_acciones

3 Hasta Que expresion_logica

Figura 4.25. Repetir….hasta que.

Para ilustrar el funcionamiento de las estructuras iterativas vamos a ver una serie
de ejemplos, en los cuales, partiendo de un programa sin estructuras iterativas
llegamos a identificar las sentencias o acciones que se repiten para,
posteriormente, construir la estructura repetitiva.

Ejemplo de estructuras repetitiva repetir…hasta que

Hacer un programa que sirva para encontrar el valor máximo y el valor mínimo de
10 valores que se han de solicitar al usuario. El programa mostrará el valor máximo
y el mínimo de ellos.

En este programa se trata de pedir 10 números al usuario, y para cada número que
se lee, comparar el valor introducido con el máximo; si es mayor, el máximo tomará
el nuevo valor; por el contrario, si el valor introducido es menor, el mínimo tomará
este nuevo valor. Esto lo podemos hacer para los 9 últimos valores, pero no para el
primero, puesto que no hay un valor máximo y mínimo, por lo tanto, máximo y
mínimo tomarán el valor del primer valor introducido.

Datos de entrada: un valor.

Datos de salida: máximo y mínimo.

Los pasos que hay que seguir para resolver el algoritmo anterior son los siguientes:

 Pedir primer valor.


 Máximo y mínimo toman el valor del primer dato introducido.
 Pedir segundo valor.
 Si el segundo valor es mayor que el máximo, a máximo se le asigna el
segundo valor. Si el segundo valor es menor que el mínimo, a mínimo se le
asigna el segundo valor.
 Pedir tercer valor.

30 Programación estructurada
Introdución a la Programación 04

 Si el tercer valor es mayor que el máximo, a máximo se le asigna el tercer


valor. Si el tercer valor es menor que el mínimo, a mínimo se le asigna el
tercer valor.
 Pedir décimo valor.
 Si el décimo valor es mayor que el máximo, a máximo se le asigna el
décimo valor. Si el décimo valor es menor que el mínimo, a mínimo se le
asigna el décimo valor.

El algoritmo anterior resuelto utilizando pseudocódigo es el siguiente.

Figura 4.26. Pseudocódigo.

Programación estructurada 31
Formación Abierta

Para construir cualquier estructura repetitiva hay que dar los siguientes pasos:

1. Identificar el grupo de sentencias que se repiten y que formarán el cuerpo


del bucle.

Se puede observar claramente que el grupo de sentencias que se repiten


son las sentencias que se encuentran en las líneas 9 a 16. En consecuencia
esas serán las instrucciones que van situadas dentro del bucle (también
llamado cuerpo del bucle).

2. Identificar la condición o expresión que controla la ejecución del bucle.

En este caso se puede observar que hay que pedir 9 valores puesto que
para el primer valor no se repiten las mismas instrucciones, en
consecuencia el primer valor lo pediremos fuera del bucle.

Hay que tener presente que las instrucciones contenidas dentro del bucle se
ejecutan mientras la condición que controla el bucle sea falsa. En nuestro caso,
hay que seguir pidiendo notas hasta que lleguemos a 10, pero teniendo en cuenta
que una la hemos pedido fuera del bucle. El algoritmo queda de la siguiente forma.

Figura 4.27. Pseudocódigo.

32 Programación estructurada
Introdución a la Programación 04

Se ha añadido una nueva variable, contador, que sirve


para contar cuántos valores se han leído. Inicialmente el
contador es cero de ahí la instrucción de la línea4. Como
vemos contador es un acumulador y, por lo tanto, hay
que inicializarlo al valor adecuado.
La condición que controla el bucle es que contador sea
igual que 10, línea 21. Para comprobar esta condición
podemos evaluar si el bucle funciona correctamente,
vemos que leemos un valor fuera del bucle, e
incrementamos en uno a contador. Vemos que leemos e
incrementamos, después al leer la segunda nota, al final
del bucle contador tiene valor 2. Luego la condición que
controla el bucle es correcta.
Podemos observar cómo se evalúa si el valor introducido
es mayor o menor que el que contiene las variables
máximo y mínimo. Sólo si el valor introducido es mayor y
menor que máximo y mínimo respectivamente se
intercambian los valores.
Por último, fuera del bucle, se muestra el valor del
máximo y del mínimo.

En la siguiente tabla se puede ver cada uno de los valores que toma cada una de
las variables, así como el valor que toma la condición que controla la ejecución del
bucle. Se ejecuta el mismo algoritmo pero suponiendo que únicamente hay que leer
5 valores, puesto que el algoritmo es el mismo y lo que hay que controlar es el inicio
del bucle y la finalización del mismo. Las iteraciones intermedias no causan
problema alguno.
A continuación vamos a ver en una tabla el valor que toma la condición que controla
el bucle, y las variables valor, máximo, mínimo y contador.
Iteración valor máximo mínimo contador contador=10

0 5 5 5 1 (0+1) -

1 2 5 2 2 (1+1) 2=10 falso

2 8 8 2 3 (2+1) 3=10 falso

3 4 8 2 4 (3+1) 4=10 falso

4 13 13 2 5 (4+1) 5=10 falso

5 6 13 2 6 (5+1) 6=10 falso

6 7 13 2 7 (6+1) 7=10 falso

7 21 21 2 8 (7+1) 8=10 falso

8 1 21 1 9 (8+1) 9=10 falso

9 3 21 1 10 (9+1) 10=10 verdadero

Figura 4.28. Tabla de variables.

Programación estructurada 33
Formación Abierta

En la iteración cero se muestran los valores que tienen cada una de las variables
antes de entrar en el bucle, es decir no es una iteración, sino que son los valores
que toman las variables en las líneas 8, 9, 10. Por lo tanto, no se evalúa la
condición del bucle.

En las iteraciones 1 a 9 podemos ver qué valores van tomando cada una de las
variables, así como el valor que toma la condición del bucle. Se puede ver que cada
iteración supone evaluar las instrucciones o sentencias de las líneas 12 a 20.
Después de ejecutar la instrucción de la línea número 21, se vuelve a evaluar la
condición del bucle. Si el resultado de evaluar la condición proporciona el valor
falso, se vuelve a la línea número 12 (iteraciones 1 a 8). Si el resultado de evaluar
la condición resulta verdadero (iteración 9), se finaliza la ejecución del bucle.

Otra forma
Si examinanos detenidamente el algoritmo, se puede identificar que podemos tener
todas las sentencias que solicitan datos, dentro del bucle. ¿Cómo se pueden
incorporar las sentencias de las líneas 5 a 10 dentro del bucle? Podemos ver que
se pide la nota, lo que cambia es la asignación de valores; además, el valor de
contador es cero.

Por lo tanto podemos incorporar estas sentencias al cuerpo del bucle; únicamente
hay que evaluar cuánto vale contador, si es cero se asignan el valor que se ha leído
a las variables máximo y mínimo, en caso contrario se evalúa si es mayor o menor
que el máximo y mínimo, respectivamente. La modificación del algoritmo anterior es
la siguiente.

De esta forma, todos los valores son leídos dentro de la estructura repetitiva.
Podemos ver que esta estructura se ejecutará al menos una vez, puesto que la
condición de evaluación del bucle se efectúa al final del mismo.

34 Programación estructurada
Introdución a la Programación 04

Figura 4.29. Pseudocódigo.

El programa anterior aún admite alguna mejora más. Para cada valor introducido en
cada iteración, excepto en la primera, se evalúa si es mayor y menor que el máximo
y el mínimo respectivamente.

Programación estructurada 35
Formación Abierta

Esto no tiene sentido puesto que a partir de la segunda iteración será mayor o
menor, pero nunca a la vez mayor y menor. Por lo tanto, sólo hay que evaluar una
condición si la anterior es falsa. La modificación es la siguiente:

Figura 4.30. Pseudocódigo.

En este caso no se ahorra en líneas de código pero sí en efectividad, puesto que


sólo se evalúa si es menor que el máximo, si el valor introducido no es mayor que el
máximo.

Ejemplo 2 de estructuras repetitiva repetir…hasta que

Escribimos un programa que sume valores introducidos por el usuario. Los valores
se pedirán de forma reiterada hasta que el usuario introduzca un número
negativo, momento en el cual finalizará el programa.

Éste es un ejemplo evidente de utilización del bucle repetir, puesto que al menos
hay que solicitar un dato el usuario. Si el primer dato que introduce el usuario es un
número negativo al programa finalizará, en caso contrario se continuará pidiendo
datos.

 Datos de entrada: un valor.


 Datos de salida: la suma de los valores positivos.

36 Programación estructurada
Introdución a la Programación 04

El algoritmo anterior resuelto utilizando diagrama de flujo es el siguiente:

Proceso repetir 2

Inicio

Definir valor, suma como entero;

Suma 0

“Introduce Un valor: ”

Valor

V
Valor>=0

Suma suma+valor

F Valor>=0

“La suma de los valores positivos introducidos es: “ Suma

Fin

Figura 4.31. Diagrama flujo.

El algoritmo anterior resuelto utilizando pseudocódigo es el siguiente.

Programación estructurada 37
Formación Abierta

Figura 4.32. Pseudocódigo.

Las instrucciones que se repiten son la 5 y la 6. La instrucción 7 a la 9 sirve para


sumar el valor introducido únicamente si dicho valor es positivo, puesto que si lo
sumamos tendremos un error (el valor negativo no hay que sumarlo).

El bucle repetir se ejecuta hasta que la condición de evaluación sea verdadera,


momento en el cual finaliza la ejecución de dicho bucle, es decir, el bucle repetir se
ejecuta mientras la condición de evaluación sea falsa. Debido a la forma de
funcionamiento de este bucle la condición para este ejercicio es la que se encuentra
en la línea 10.

La variable suma es un acumulador, por lo tanto, hay que inicializarla al valor


apropiado (línea 3).

En la siguiente tabla se pueden ver los valores que van tomando cada una de las
variables, así como el resultado de evaluar la condición.

Iteración Valor Suma Valor < 0

0 - 0 -

1 2 2 (0+2) 2 < 0 Falso

2 3 5 (2+3) 3< 0 Falso

3 9 14 (5+9) 14 < 0 Falso

4 1 15 (14+1) 1 < 0 Falso

5 6 21 (15+6) 6 <0 Falso

6 -2 21 -2 < 0 Verdadero

Figura 4.33. Tabla de variables.

La iteración cero no es tal puesto que no se ha entrado dentro del bucle; son los
valores iniciales de las variables.

Podemos ver que, mientras en cada una de las iteraciones, se suman los valores
positivos, los negativos no se suman (iteración 6).

Se ejecuta el cuerpo del bucle una vez antes de evaluar la condición (iteración 1).

38 Programación estructurada
Introdución a la Programación 04

Por otro lado, el bucle únicamente se ejecuta si la condición es falsa (iteración 2 a


5).

Se finaliza la ejecución del bucle en el momento en que la condición que controla su


ejecución es evaluada como verdadera (iteración 6).

4.3.2.1. Estructura repetitiva: Para….hasta


En las estructuras repetitivas mientras y repetir el número de iteraciones no suele
ser conocido a priori. En ocasiones el número de iteraciones que debe efectuar una
estructura iterativa es conocida a priori. En tales caso es más conveniente utilizar la
estructura repetitiva Para.

En la estructura repetitiva Para se ejecutan las acciones o sentencias comprendidas


dentro del cuerpo del bucle un número determinado de veces y de modo automático
se controla el número de iteraciones que debe ejecutar el bucle. En esta estructura
hay una variable de tipo acumuladora que tiene un valor inicial que especificamos
nosotros y un valor final que también lo especificamos nosotros. En cada iteración,
al llegar al final del bucle se incrementa la variable en el valor que se especifique.

Acciones
Vi Vf p

Dónde:

I Variable.
Vi Valor Inicial.
Vf Valor Final.
p Paso.

Figura 4.34. Diagrama de flujo correspondiente a una estructura selectiva.

Al ingresar al bloque, la variable <variable> recibe el valor <inicial> y se ejecuta la


secuencia de instrucciones que forma el cuerpo del ciclo. Luego se incrementa la
variable <variable> en <paso> unidades y se evalúa si el valor almacenado en
<variable> superó al valor <final>. Si esto es falso se repite hasta que <variable>
supere a <final>. Si se omite la cláusula Con Paso <paso>, la variable <variable> se
incrementará en 1.

Programación estructurada 39
Formación Abierta

La representación en pseudocódigo, la vemos en la siguiente figura:

Para <variable> <- <inicial> Hasta <final> Con Paso <paso> Hacer

<Instrucciones>

FinPara

Figura 4.35. Estructura repetitiva Para…

La estructura repetitiva Para en Pseint es ascendente, es


decir, es aquella en la que el valor inicial que toma la
variable que controla el bucle es menor que el valor final
de comparación que detiene la ejecución del bucle. El
incremento en este tipo de bucles es siempre positivo. La
ejecución del cuerpo del bucle continúa hasta que el
valor de la variable exceda el valor final que controla el
número máximo de iteraciones. Configurando las
opciones del lenguaje con sintaxis flexible si no se
especifica el paso, el valor final es menor al inicial, el
bucle recorrerá los valores en orden inverso como si el
paso fuera -1.

Para ilustrar el funcionamiento de estas estructuras repetitivas vamos a ver un


ejemplo en el cual, partiendo de un programa sin estructuras repetitivas, llegamos a
identificar las sentencias o acciones que se repiten para, posteriormente, construir
la estructura repetitiva.

Ejemplo 2 de estructuras repetitiva para…hasta que…

Haremos un programa que sirva para hacer la suma de 20 primeros números


naturales.

Para hacer este programa hay que hacer la suma de los números comprendidos
entre 1 y 20, ambos inclusive, por lo tanto hay que contar 20 números empezando
en uno.

 Datos de entrada: ninguno.


 Datos de salida: la suma de los 20 primeros números.

40 Programación estructurada
Introdución a la Programación 04

Los pasos que hay que seguir para resolver el algoritmo anterior son los siguientes:

 Se necesita una variable para acumular la suma de los números.


Inicialmente el valor de esta variable debe ser cero.
 Se suma uno a la variable suma.
 Se suma dos a la variable suma.
 Se suma tres a la variable suma.
 .
 .
 Se suma veinte a la variable suma.
 Se escribe (en pantalla) el valor encontrado para la suma de los 20 primeros
números.

El algoritmo anterior resuelto utilizando pseudocódigo es el siguiente.

Figura 4.36. Pseudocódigo.

Para construir cualquier estructura repetitiva hay que dar los siguientes pasos:

1. Identificar el grupo de sentencias que se repiten y que formarán el cuerpo


del bucle.

En este caso es evidente que la instrucción que se repite es la que se


encuentra en las líneas 4 a 10. La única diferencia es que cambia en cada
instrucción el valor que se suma a la variable suma.

2. Identificar la condición o expresión que controla la ejecución del bucle.

En este caso se puede observar que hay que sumar los 20 primeros
números. El valor inicial es uno, el valor final es 20 y el incremento 1.

Hay que tener presente que las instrucciones contenidas dentro del bucle se
ejecutan mientras el valor de la variable que controla el bucle sea menor que el
valor final. Por lo tanto, el algoritmo queda de la siguiente forma.

Programación estructurada 41
Formación Abierta

Figura 4.37. Pseudocódigo.

En este caso hemos aprovechado el valor que va


tomando la variable de control para ir sumando cada uno
de los valores.

El incremento se produce al final del bucle, es decir, al


llegar a la línea 6 se incrementa la variable en uno (en
este caso el incremento vale uno). Después se vuelve al
inicio del bucle, línea 4, y se comprueba si el nuevo valor
es menor o igual que el valor final, en cuyo caso se
vuelve a ejecutar el cuerpo del bucle (acciones
comprendidas entre la sentencia Para y la sentencia
finpara). Si el valor de la variable es superior al valor final
se detiene la ejecución del bucle y se pasa a ejecutar la
instrucción que se encuentra a continuación del bucle, en
nuestro ejemplo línea 7.

Antes de ejecutar el bucle, en la primera iteración, se


comprueba que el valor inicial es menor o igual que el
valor final, en cuyo caso se ejecuta el cuerpo del bucle.

A continuación vamos a ver en una tabla el valor que toma la condición que controla
el bucle, y las variables i y suma.

Iteración i<=20 Suma i

0 - 0 -

1 1<=20 verdadero 1 (0+1) 2 (1+1)

2 2<=20 verdadero 3 (1+2) 3 (2+1)

3 3<=20 verdadero 6 (3+3) 4 (3+1)

19 19<=20 verdadero 190 (171+19) 20 (19+1)

20 20<=20 verdadero 210 (190+20) 21 (20+1)

21 21<=21 falso

Figura 4.38. Tabla de valores.

42 Programación estructurada
Introdución a la Programación 04

La iteración cero no es propiamente una iteración, puesto que no se ha entrado


dentro del bucle, sino que son los valores iniciales, de esta forma el número toma el
valor 1. A continuación se evalúa si este valor es menor o igual que el valor final,
20. Puesto que uno es menor o igual que 20 se ejecuta el cuerpo del bucle; se
suma uno a la variable acumuladora suma y finalmente se incrementa la variable en
uno, es decir, pasa a valer dos.

Los valores de la columna dos se corresponden con la línea 4; los valores de la


columna 3 se corresponden con la línea 6 y los valores de la columna 4 se
corresponden con los incrementos que se efectúan al final del bucle, es decir, se
efectúan al llegar a la línea 7.

4.3.3. Errores en los bucles


A continuación vamos a comentar algunos errores que suelen ser muy frecuentes
cuando se trabaja con estructuras de tipo repetitivo.

No ejecución de un bucle

Este caso puede darse en las estructuras repetitivas mientras y en las estructura
repetitivas Para. En las estructuras repetitivas repetir no se puede producir, puesto
que como ya sabemos esta estructura repetitiva al menos siempre se ejecuta una
vez.

En las estructuras repetitivas, como es sabido, se ejecuta el cuerpo del bucle si la


condición es evaluada como verdadera. A veces olvidamos inicializar las variables
al valor correcto para que se ejecute el cuerpo del bucle. En el siguiente caso que
calcula la suma de los 20 primeros múltiplos de 5 o 7, se utiliza una variable
boolena para controlar el bucle, en la línea 9. Si quitamos esta línea del algoritmo,
el bucle no se ejecuta puesto que no tiene ningún valor la variable nofin.

Programación estructurada 43
Formación Abierta

Bucles infinitos

Como es sabido, todos los algoritmos son programas que deben finalizar en algún
momento. En las estructuras repetitivas algunas veces ocurre que no finalizan
nunca, en tal caso tendremos un bucle infinito, y por lo tanto, el algoritmo no es
correcto. En el caso de trabajar con Pseint, el error es más grave puesto que el
ordenador se “queda colgado”, ejecutando continuamente el bucle.

Los bucles infinitos se pueden dar en cualquiera de las tres estructuras iterativas.

Ejemplo de bucle infinito en una estructura iterativa


mientras es el siguiente:

El bucle anterior toma valor inicial uno, puesto que la


condición de evaluación es verdadera, se ejecuta el
cuerpo del bucle, escribiendo uno en la pantalla. Pero
puesto que la variable i no se incrementa siempre vale
uno y en consecuencia siempre se ejecuta el bucle, con
lo cual nunca termina de ejecutarse el bucle.

44 Programación estructurada
Introdución a la Programación 04

En muchos casos ocurre que nos olvidamos de incrementar la variable que controla
la ejecución del bucle. Éste es un error muy frecuente.

Estructuras repetitivas anidadas

En muchos algoritmos o programas suele ser habitual solicitar al usuario un valor


que esté comprendido dentro de un determinado rango. El algoritmo está diseñado
para trabajar con valores dentro de ese rango, pero ¿qué ocurre si el usuario
introduce un valor fuera del rango? Pueden ocurrir dos cosas, que el programa
no proporcione los valores esperados o que simplemente no haga nada, puesto que
sea un valor fuera de rango se finaliza el programa.

Mediante la estructura repetitiva repetir podemos forzar al usuario a que introduzca


un valor dentro del rango, en el caso de que no lo haga se vuelve a solicitar el valor,
¿hasta cuándo? Hasta que el valor esté comprendido dentro del rango de trabajo.

Hacemos un programa que pida al usuario un valor comprendido entre 0 y 10,


ambos inclusive. Si el valor no está en este rango, se volverá a pedir el dato y
mostrara un mensaje de error.

Los pasos que hay que seguir para resolver el algoritmo anterior son los siguientes:

 Se pide un valor al usuario.


 Si está fuera del rango, se muestra el mensaje correspondiente de error y
vuelve a pedir el dato.

El algoritmo anterior resuelto en pseudocodigo y diagrama de flujo es el siguiente:

Figura 4.39. Pseudocódigo.

Programación estructurada 45
Formación Abierta

Proceso valor en rango

Inicio

Definir valor como entero;

“Introduce el valor comprendido entre 0 y 10: ”

Valor

V
(Valor>=0) y (Valor<=10)

Error

F
(Valor>=0) y (Valor<=10)

Fin

Figura 4.40. Diagrama de flujo.

46 Programación estructurada
Introdución a la Programación 04

 Resumen

 En esta unidad didáctica se han presentado las estructuras básicas con las que
se construyen todos los algoritmos utilizando la programación estructurada.

 Las principales estructuras son las selectivas y las repetitivas.

 En las estructuras selectivas simples se ejecuta una acción o un grupo de


acciones, si la condición de control es evaluada como verdadera.

 En las estructuras selectivas dobles se ejecuta una acción o un grupo de


acciones si la condición de control es evaluada como verdadera, en caso
contrario se ejecuta otra acción o grupo de acciones.

 En las estructuras selectivas múltiples se ejecuta una acción o un grupo de


acciones en función del valor que tome la expresión a evaluar. En este caso las
alternativas pueden ser dos o más de dos, ésta es la diferencia con los casos
anteriores.

 Las estructuras repetitivas sirven para ejecutar un grupo de acciones


determinadas mientras se cumpla una determinada condición. Este tipo de
estructuras facilita la escritura de los programas y la comprensión de los
mismos, puesto que las líneas e código se reducen notablemente.

 La estructura repetitiva mientras se ejecuta si el resultado de evaluar la


condición de control es verdadero. Esta estructura puede ejecutarse entre 0 y N
veces.

 La estructura repetitiva Repetir se ejecuta si el resultado de evaluar la condición


de control es falso, es decir, termina de ejecutarse cuando la condición de
control es evaluada como verdadera. Esta estructura puede ejecutarse entre 1 y
N veces, pero siempre se ejecuta una vez.

 La estructura repetitiva Para se ejecuta si el resultado de evaluar la condición de


control es verdadero. Esta estructura puede ejecutarse entre 0 y N veces,
aunque es habitual utilizarla cuando el número de iteraciones es conocido. Hay
dos tipos de estructuras la ascendente y la descendente.

 En la estructuras iterativas hay que tener cuidado de no ejecutar bucles infinitos,


ya que esto es muy grave en el caso de que se esté trabajando en un ordenador
puesto que hace que éste se quede bloqueado.

Programación estructurada 47
05 Introducción a la
Programación

Tipos de datos
estructurados
Introducción a la Programación 05

 Índice

 OBJETIVOS .......................................................................................................... 3
 INTRODUCCIÓN .................................................................................................. 4
5.1. Arrays unidimensionales o vectores ........................................................ 5
5.1.1. Declaración de vectores ........................................................................ 9
5.1.2. Operaciones con vectores .................................................................. 10
5.1.3. Métodos de Ordenación ..................................................................... 15
5.1.4. Búsqueda ............................................................................................ 23
5.2. Arrays de varias dimensiones ................................................................. 27
5.3. Cadenas de caracteres ............................................................................. 30
5.3.1. Datos de tipo cadena .......................................................................... 31
5.3.2. ¨Lista de Cadenas ............................................................................... 31
 RESUMEN .......................................................................................................... 39

Tipos de datos estructurados 1


Introducción a la Programación 05

 Objetivos

 Presentar los tipos de datos estructurados, después de haber visto los tipos de
datos simples.

 Conocer qué son los arrays (unidimensionales y multidimensionales) y cuáles


son las operaciones que pueden realizarse con ellos.

 Profundizar en un tipo de dato estructurado concreto, la cadena. Una cadena es


una agrupación de caracteres, cada uno de los cuales ocupa una posición
determinada. Se aprenderá a acceder a cada elemento de la cadena, tanto
directamente como secuencialmente.

 Aprender a realizar ordenación de array búsquedas de elementos de un array.

Tipos de datos estructurados 3


Formación Abierta

 Introducción

En la unidad anterior estudiamos el concepto de datos de tipo simple que sirven


para representar, por ejemplo, un número o un carácter. Sin embargo, en muchas
situaciones se necesita procesar una colección de valores que están relacionados
entre sí de alguna forma. No sólo importa el propio valor escalar de cada elemento
sino su conjunto. En informática usamos para este tipo de datos los llamados
estructurados.

Empezaremos explicando los arrays como primer tipo de la colección de datos


estructurados para después continuar con los registros y acabar la unidad
profundizando en un tipo particular de dato estructurado muy usado, las cadenas de
caracteres. Hoy en día, hay que tratar la información como texto y no sólo como
números. En aplicaciones de gestión (inventarios, bases de datos etc.) se está
continuamente generando y actualizando datos, como nombres, dirección, códigos
postales, nombre de producto, destino, procedencia etc. En todos estos casos la
información alfabética es lo más importante y determinará las operaciones a
realizar.

Otros ejemplos de tratamiento de cadena de caracteres son los propios lenguajes


de programación. Se pasa de un fichero de tipo texto a un fichero binario que se
ejecutará en el ordenador. El compilador ha de ser capaz de identificar cada una de
las letras o palabras que introducimos en el editor de texto y convertirlas en la
sentencia o grupo se sentencias correspondiente.

4 Tipos de datos estructurados


Introducción a la Programación 05

5.1. Arrays unidimensionales o vectores

Vectores o matrices

En programación, vectores o matrices (llamados en inglés


arrays) es una zona de almacenamiento contiguo, que
contiene una serie de elementos del mismo tipo. Desde
el punto de vista lógico un vector se puede ver como un
conjunto de elementos ordenados en fila (o filas y
columnas si tuviera dos dimensiones).

0 1 2 3 4 5 6 7 8 9

Figura 5.1. Matriz unidimensional con 10 elementos.

Un array unidimensional, es una colección ordenada de elementos de un mismo


tipo de datos, agrupados de forma consecutiva. Cada elemento del array tiene
asociado un índice, un número natural, que lo identifica inequívocamente y nos
permite acceder a él.

Ejemplo de un array, que contiene las notas de 50 alumnos:

Tipos de datos estructurados 5


Formación Abierta

Calificaciones
Calificaciones [1] 7.50
Calificaciones [2] 4.75
Calificaciones [2] 5.25
... ...
... ...
... ...
Calificaciones [50] 6

Nombre del vector:Calificaciones

Subíndice: [1], [2], [3],... [50]

Contenido: Calificaciones [1] = 7.50


Calificaciones [2] = 4.75
Calificaciones [3] = 5.25
...
...
...
...
Calificaciones [50] = 6

Figura 5.2. Ejemplo calificaciones array de 50 posiciones.

Podemos encontrarnos los siguientes términos para definir


lo mismo, estos son: vector, array, arreglo, matriz.
Nosotros en este texto lo llamaremos array, pero en Pseint
usan el término arreglo.

Se puede acceder a cada uno de los componentes de un array de forma individual


a través del índice correspondiente.

6 Tipos de datos estructurados


Introducción a la Programación 05

Los arreglos se clasifican de acuerdo con el número de dimensiones que tienen. Así
se tienen los:

 Unidimensionales (vectores): como podemos observar en la siguiente imagen


podemos tener una columna o fila.

Elemento 1

Elemento 2

Elemento 3

……………….

Elemento N

Figura 5.3. Unidimensional.

 Bidimensionales (tablas o matrices): cuando tenemos unos datos ordenados


en dos dimensiones, o filas y columnas.

Elemento 1,1 ………………. Elemento 1,n

Elemento 2,1 ………………. Elemento 2,n

Elemento 3,1 ………………. Elemento 3,n

………………. ………………. ……………….

Elemento m,1 ………………. Elemento m,n

Figura 5.4. Array bidimensional.

Tipos de datos estructurados 7


Formación Abierta

 Multidimensionales (tres o más dimensiones): son poco usados, pero


tenemos la disposición de realizarlos.

Elemento 1,1,2 Elemento 1,n,2

Elemento 1,1,1 Elemento 1,n,1 Elemento 1,n,1

Elemento 1,1,1 …………... Elemento 1,n,1

Elemento 2,1,1 …………... Elemento 2,n,1

Elemento 3,1,1 …………... Elemento 3,n,1

…………... …………... …………...

Elemento m,1,1 …………... Elemento m,n,1

Figura 5.5. Array multidimensional.

Índice

Todo vector se compone de un determinado número de elementos. Cada elemento


es referenciado por la posición que ocupa dentro del vector. Dichas posiciones son
llamadas índice y siempre son correlativos. Existen tres formas de indexar los
elementos de un array:

 Indexación base-cero (0): en este modo el primer elemento del vector será la
componente cero ('0') del mismo, es decir, tendrá el índice '0'. En consecuencia,
si el vector tiene 'n' componentes la última tendrá como índice el valor 'n-1'. El
lenguaje C, java es un ejemplo típico que utiliza este modo de indexación.

 Indexación base-uno (1): en esta forma de indexación, el primer elemento de


la matriz tiene el índice '1' y el último tiene el índice 'n'.

 Indexación base-n (n): este es un modo versátil de indexación en la que el


índice del primer elemento puede ser elegido libremente; en algunos lenguajes
de programación se permite que los índices puedan ser negativos e incluso de
cualquier tipo escalar (también cadenas de caracteres).

8 Tipos de datos estructurados


Introducción a la Programación 05

5.1.1. Declaración de vectores


Como todas las variables que se han utilizado hasta ahora, antes de ser utilizados,
los vectores, tienen que estar declarados. La sintaxis para declarar un vector es la
siguiente:

Dimension <identificador> (elementos);

Donde cada una de las palabras significa:

 Dimensión: siempre que se defina un vector es obligatorio ponerlo.


 Identificador: es nombre que el usuario le da al vector. Puesto que es un
identificador, sigue las mismas reglas de construcción vistas para los
identificadores de variables.
 Elementos: es número de elementos que tiene el vector (su profundidad).
Debe ser un valor de tipo entero.

Figura 5.6. Declaración de Array unidimensional.

Figura 5.7. Declaración de Array bidimensiosal.

Debido a las opciones de lenguaje de pseint que tenemos configuradas para este
curso, a parte de declarar el array debemos definir de qué tipo va a ser, es decir
qué tipo de datos va a contener, si numéricos, carácter, lógicos… Para ello siempre
que declaremos un vector debemos definirlo como hasta ahora hemos hecho con
las variales.

Cuando declaremos un array, debemos definir el tipo de


éste, con la instrucción Definir nombre_array como
TipodeDatos.

Tipos de datos estructurados 9


Formación Abierta

Veamos un ejemplo donde declaramos un array de 50 para introducir las notas de


los alumnos. Tenemos que tener claro que las notas que vayamos a introducir son
numéricas, por lo que el tipo de array es entero con 50 posiciones. Las
instrucciones que tenemos que introducir en el pseint para declarar el array son las
siguientes:

Figura 5.8. Declaración de Array.

En la primera instrucción hemos declarado el array y en la segunda definimos el


tipo de dato que va a guardar.

En la mayoría de lenguaje de programación, java, C, C++,


C#, estas dos instrucciones están comprendidas en la
misma línea, siendo sólo una declaración.

5.1.2. Operaciones con vectores


Las operaciones que se pueden realizar con un vector para realizar un programa
son las siguientes:

 Asignación. Se pueden almacenar valores en cada uno de los elementos


del vector.
 Lectura y escritura: se pueden leer valores introducidos por el usuario para
cada una de las componentes del vector, así mismo se pueden escribir los
valores de las componentes.
 Recorrido: se puede recorrer el vector en busca de un determinado valor.
 Actualizar: se pueden efectuar diversas operaciones para actualizar los
valores de las componentes de un vector. Tales actualizaciones pueden ser
 Añadir elementos a un vector.
 Borrar elementos de un vector.
 Insertar elementos en un vector.
 Ordenación: se pueden ordenar los elementos de un vector como veremos
en esta unidad didáctica.
 Búsqueda: como también vermos en esta unidad se pueden buscar
elementos en el vector.

10 Tipos de datos estructurados


Introducción a la Programación 05

Asignación

Para asignar valores a un elemento de un vector se utiliza los operadores de


asignación () (=). Los valores se asignan a componentes particulares del vector y
no al vector de forma genérica, por ejemplo:

Dimension Semana[7];

semana[0]="lunes";

semana[1]="martes";

semana[2]="miercoles";

semana[3]="jueves";

semana[4]="viernes";

semana[5]="sábado";

En casi todos los lenguajes de programación los vectores


empiezan o indexan desde 0, es decir el primer elemento
de un vector de N elementos el primero estará en la
posicion 0, y el ultimo en la n-1.

Se utilizará este formato para el pseint, por lo que te


recomiendo que te leas el manual de pseint, para que
puedas configurar las opciones del lenguaje y activar la
opcion de “Utilizar arreglos en base 0”.

Continuando con el ejemplo podemos observar en la siguiente instrucción:

semana[6]="domingo";

En este caso, la asignación de valores se ha hecho componente a componente, es


decir de forma directa se aplica el contenido al vector con la posición.

Pero, si quisiéramos que todos los componentes del vector tomasen el mismo valor,
la asignación de valores podría hacerse mediante una estructura iterativa, por
ejemplo la estructura iterativa desde, como en el siguiente ejemplo:

Figura 5.9. Recorrido del array o vector.

Tipos de datos estructurados 11


Formación Abierta

En este ejemplo todos los elementos del array semana tienen como valor “lunes”.
Es decir tendría la siguiente composición como muestra la siguiente imagen:

0 1 2 3 4 5 6 7 8 9

Lunes Lunes Lunes Lunes Lunes Lunes Lunes Lunes Lunes Lunes

Figura 5.10. Array semana.

Lectura y escritura de un vector

Lo más usual en un vector es que se soliciten los datos al usuario para poder
almacenarlos correctamente y luego efectuar las operaciones correspondientes.

La instrucción de lectura es la misma que se ha visto para otras variables, en


unidades anteriores. En este caso particular, puesto que cada una de las
componentes va a tener un valor distinto, se indica en qué índice o posición se va a
guardar. Por ejemplo para rellenar con datos pedidos al usuario un vector de cuatro
elementos, se puede utilizar la siguiente estructura iterativa.

Figura 5.11. Recorrido de lectura del vector.

Para escribir un array hay que hacerlo componente a componente desde el inicio
hasta el final, es decir como dicen los programadores recorrerlo,

No tiene por qué ser necesario leer o escribir todo el vector, se pueden leer o
escribir componentes individualmente como por ejemplo:

 Leer hermano[3];
 Escribir hermano[2];

Veamos un ejemplo completo de lectura, con el anterior supuesto: imagina que


tenemos que guardar la edad de 4 personas, y esta edad va a ser introducida por
teclado. Lo primero que se nos ocurre, es que debemos crear un array de 4
posiciones para guardar la edad de esas 4 personas, posteriormente recorreremos
el array, pidiendo que introduzca una edad, y la guardaremos en la posición 1, la
siguiente edad en la posición 2, y así sucesivamente hasta tener el total de edades.

12 Tipos de datos estructurados


Introducción a la Programación 05

Figura 5.12. Pseudocódigo programa edad.

Figura 5.13. Solicitud de datos.

Como podemos observar en la línea 6 debemos definir


también de qué tipo es el array; si no lo hacemos, nos
dará un error al ejecutar el algoritmo, ya que como hemos
dicho anteriormente, no sabe qué tipo de datos vamos a
introducir, estas opciones pueden ser variadas en el pseint
a través de opciones lenguaje.

Actualizar

Dentro de las actualizaciones de un array, podemos encontrarnos, el añadir un


dato; asignar un valor a una posición, se realiza con la lectura o asignación del
valor.

 Leer Tnotas[2];
 Tnotas[2]=4;

En el borrado de datos, lo único que debemos realizar es asignar un valor nulo a los
elementos de la tabla, por ejemplo si se trata de caracteres, insertar un espacio en
blanco, y si son datos numéricos, insertar 0. En los lenguajes de programación de
alto nivel, si es posible darle un valor nulo, en muchos casos llamado NULL.

Tipos de datos estructurados 13


Formación Abierta

Recorrido

Ahora que ya conocemos qué son los arrays, debemos conocer cómo recorrerlos
para extraer o comprobar los valores que contiene cada uno de los elementos del
array. Esta es una tarea habitual en programación que en general va a tener gran
utilidad para nosotros.

Lo arrays se pueden recorrer de muchas formas, nosotros no las explicaremos


todas. Trataremos de ver en principio la más habitual y sencilla.

 Recorrido de arrays mediante Para…hasta

Veamos un ejemplo, tenemos una tabla con 5 posiciones donde vamos a guardar
las notas de los alumnos. Las notas son introducidas en línea de programa, y luego
vamos a recorrer la Tabla o array para mostrar la posición y el contenido de la tabla.

Figura 5.14. Recorrido array.

Veamos paso a paso el desarrollo del algoritmo.

 En las líneas 2 y 3, declaramos y definimos la tabla.


 De la línea 4 hasta la 8, desde línea de programa introducimos los datos a la
tabla.
 la línea 9, recorremos la tabla notas desde la posición 0 hasta la 4, con paso
uno para que recorra todos los datos de la tabla, en este ejemplo hemos
definido la variable i para recorrer el array.
 línea 10, escribimos en pantalla un mensaje texto y luego la posición i, y el
contenido de la tabla en dicha posición. en primer lugar será la 0,
recorriendo de en uno en uno los valores de la tabla hasta llegar a 4. La
pantalla resultante de este algoritmo será la siguiente:

14 Tipos de datos estructurados


Introducción a la Programación 05

Figura 5.15. Salida del algoritmo.

5.1.3. Métodos de Ordenación


Los algoritmos de ordenamiento nos permiten, como su nombre lo dice, ordenar. En
este caso, nos servirán para ordenar array con valores asignados.

Para poder ordenar una cantidad determinada de números almacenadas en un


vector o matriz, existen distintos métodos con distintas características y
complejidad. Existe desde el método más simple, como el Método Burbuja, que son
simples iteraciones, hasta el Quicksort, Método Rápido, que al estar optimizado
usando recursión, su tiempo de ejecución es menor y es más efectivo.

Nos centraremos en el método de la burbuja ya que con el


resto de métodos los estudiaras, en los distintos leguajes
de programación, analizaremos la cantidad de
comparaciones, el tiempo de demora, …

Existen dos tipos de algoritmos para la ordenación.

 Métodos iterativos: estos métodos son simples de entender y de


programar ya que son iterativos, simples ciclos y sentencias que hacen que
el vector pueda ser ordenado. Dentro de los Algoritmos iterativos
encontramos: Burbuja, Inserción, Selección, Shellsort.
 Métodos recursivos: estos métodos son aún más complejos, requieren de
mayor atención y conocimiento para ser entendidos. Son rápidos y efectivos,
utilizan generalmente la técnica “Divide y vencerás”, que consiste en dividir
un problema grande en varios pequeños para que sea más fácil resolverlos.
Mediante llamadas recursivas a si mismas, es posible que el tiempo de
ejecución y de ordenación sea más óptimo. Dentro de los algoritmos
recursivos encontramos: Ordenamiento por Mezclas, Ordenamiento
Quick.

Tipos de datos estructurados 15


Formación Abierta

Método de inserción directa

En este método se debe recorrer la tabla tantas veces como elementos tenga
menos 1. En la primera pasada, se toma el segundo elemento y en las siguientes
se toman como referencia los siguientes elementos de forma sucesiva.

En cada pasada se saca el elemento seleccionado, se compara con todos los


anteriores a él y, en caso de ser mayores, se van desplazando una posición. El
elemento tomado se inserta en el hueco que le corresponda según su valor.

El método de inserción directa es el que generalmente


utilizan los jugadores de cartas, de ahí que también se
conozca con el nombre de método de la baraja.

La idea principal de este algoritmo consiste en insertar un elemento del array en la


parte izquierda del mismo, que ya se encuentra ordenada. Este proceso se repite
desde el segundo hasta el n-esimo elemento.

Ejemplo:

Se desean ordenarse los siguientes datos de un array A [8]:

A: 15, 67, 08, 16, 44, 27, 12, 35

1 2 3 4 5 6 7 8

 Primera pasada

A [2] < A [1] 67 < 15 No hay intercambio

A: 15, 67, 08, 16, 44, 27, 12, 35

 Segunda pasada

A[3] < A[2] 08 < 67 Si hay intercambio

A[2] < A[1] 08 < 15 Si hay

A: 15, 08, 67, 16, 44, 27, 12, 35

 Tercera pasada

A[4] < A[3] 08 < 15 Si hay intercambio

A[3] < A[2] 08 < 15 Si hay intercambio

A: 08, 15, 67, 16, 44, 27, 12, 35

16 Tipos de datos estructurados


Introducción a la Programación 05

 Hasta la séptima pasada el arreglo queda ordenado:

A: 08, 12, 15, 16, 27, 35, 44, 67

Ejemplo del algoritmo, solo cinco elementos:

Donde la salida correspondiente seria la siguiente:

Figura 5.16. Salida del algoritmo método de inserción directa.

Tipos de datos estructurados 17


Formación Abierta

Método de la burbuja

El método de la burbuja es uno de los más simples, es tan fácil como comparar
todos los elementos de una lista contra todos, si se cumple que uno es mayor o
menor a otro, entonces los intercambia de posición.

Veámoslo con un ejemplo, imaginemos que tenemos los siguientes valores:

82 16 48 86 55

0 1 2 3 4

Figura 5.17. Asignación de datos a la tabla.

Lo que haría una burbuja simple, sería comenzar recorriendo los valores de
izquierda a derecha, comenzando por el 82. Lo compara con el 16, con el 48, con el
86 y con el 55, si es mayor o menor; dependiendo si el orden es ascendiente o
descendiente, se intercambian de posición. Luego continua con el siguiente
elemento y lo compara con todos los elementos de la lista, esperando ver si se
cumple o no la misma condición que con el primer elemento. Así, sucesivamente,
hasta el último elemento de la lista.

18 Tipos de datos estructurados


Introducción a la Programación 05

Figura 5.18. Método de la burbuja PseInt.

Este algoritmo realiza el ordenamiento de una lista a de n valores, en este caso de


n términos numerados del 0 al n-1, consta de dos bucles anidados uno con el
índice i, que da un tamaño menor al recorrido de la burbuja en sentido inverso de
2 a n, y un segundo bucle con el índice j, con un recorrido desde 0 hasta n-i, para
cada iteración del primer bucle, que indica el lugar de la burbuja.

En la líneas 19 a la 23, con la sentencia SI: compara j y j+1, si el primero es menor


que el segundo sus valores se intercambian.

Esta comparación se repite en el centro de los dos bucles,


dando lugar a la postre a una lista ordenada; puede verse
que el número de repeticiones sólo depende de n, y no del
orden de los términos, esto es, si pasamos al algoritmo
una lista ya ordenada, realizará todas las comparaciones
exactamente igual que para una lista no ordenada; esta es
una característica de este algoritmo, luego veremos una
variante que evita este inconveniente.

Tipos de datos estructurados 19


Formación Abierta

Para comprender el funcionamiento, veamos paso a paso el ejemplo sencillo:

 Tenemos una lista de números que hay que ordenar, en el ejemplo 5


términos, que se asignan desde código (Línea 5..9).

Figura 5.19. Asignación de datos a Tabla.

 El índice i hará un recorrido de 2 hasta n:

 Que en este caso será de 2 a 5. Para cada uno de los valores de i, j tomará
sucesivamente los valores de 0 hasta n-i

 Para cada valor de j, obtenido en ese orden, se compara el valor del índice j
con el siguiente valor.

 Si el termino j es menor, en su caso podría se mayor, que el termino j+1, los


valores se permutan, en caso contrario se continúa con la iteración.

 Para el caso del ejemplo, tenemos que: n=5; Para la primera iteración del
primer bucle: i=2; y j tomara los valores de 0 hasta 3 (n-i5-2=3).
 Cuando j vale 0, se comparan, el 55 y el 86, dado que 55 < 86 no se
permutan el orden.

j=0 j=1 j=2 j=3

A4 82 82 82 → 82 86

A3 16 16 → 16 → 86 82

A2 48 → 48 → 86 16 16

A1 → 86 → 86 48 48 48

A0 → 55 55 55 55 55

Figura 5.20. Tabla de valores.

 Ahora j vale 1 y se comparan el 86 y el 48 Como 86 > 48, se permutan,


dando lugar a una nueva lista.

20 Tipos de datos estructurados


Introducción a la Programación 05

 Se repite el proceso hasta que j valga 3, dando lugar a una lista


parcialmente ordenada, podemos ver que el termino de mayor valor esta en
el lugar más alto.
 Ahora i vale 3, y j hará un recorrido de 0 a 2.

j=0 j=1 j=2

A4 86 86 86 86

A3 82 82 → 82 82

A2 16 → 16 → 55 55

A1 → 48 → 55 16 16

A0 → 55 48 48 48

Figura 5.21. Tabla de valores.

 Primero j vale 0, se comparan, el 55 y el 48, como 55 > 48 se permutan


dando lugar a la nueva lista.
 Para j = 1 se compara el 55 con el 16 y se cambian de orden.
 Para j = 2 se compara el 55 y el 82 y se dejan como están, finalizando el
bucle con una lista mejor ordenada, puede verse que los dos valores más
altos ya ocupan su lugar. No se ha realizado ninguna comparación con el
término cuarto, dado que ya se sabe que después del primer ciclo es el
mayor de la lista.

El algoritmo consiste en comparaciones sucesivas de dos


términos consecutivos, ascendiendo de abajo a arriba en
cada iteración, como la ascensión de las burbujas de aire
en el agua, de ahí el nombre del procedimiento, en la
primera iteración el recorrido ha sido completo, en el
segundo se ha dejado él último termino, al tener ya el
mayor de los valores, en los sucesivos sé ira dejando de
realizar las ultimas comparaciones, como se puede ver.

 Ahora ya i vale 4 y j recorrerá los valores de 0 a 1.

j=0 j=1

A4 86 86 86

A3 82 82 82

A2 55 → 55 55

A1 → 16 → 48 48

A0 → 48 16 16

Figura 5.22. Tabla de valores.

Tipos de datos estructurados 21


Formación Abierta

 Cuando j vale 0, se comparan el 48 y el 16 dado que 48 es mayor que 16 se


permutan los valores, dando lugar a una lista algo más ordenada que la
anterior, desde esta nueva ordenación, j pasa a valer 1, con lo que se
comparan los términos el 48 y el 55 que quedan en el mismo orden.
 En este caso la burbuja ha ascendido menos que en los casos anteriores, y
la lista esta ya ordenada, pero el algoritmo tendrá que completarse,
realizando una última iteración.
 Por último i vale 5 y j sólo puede valer 0, con lo que sólo se realizará una
comparación del 16 y el 48, que ya están ordenados y se dejan igual.

j=0

A4 86 86

A3 82 82

A2 55 55

A1 → 48 48

A0 → 16 16

Figura 5.23. Tabla de valores.

 Los bucles finalizan y también el procedimiento, dejando la lista ordenada.

La salida del algoritmo seria el siguiente:

Figura 5.24. Salida de la aplicación.

Existen varios métodos de búsqueda, que el alumno puede


investigar ya que en este manual sólo se explican 2, el
más sencillo pero más lento es el método de la burbuja.

22 Tipos de datos estructurados


Introducción a la Programación 05

5.1.4. Búsqueda
Otra de las operaciones más importantes que realizan los algoritmos y que
consumen gran parte del tiempo empleado en algunas aplicaciones es la búsqueda
de un elemento concreto del vector.

Ejemplos de búsqueda pueden ser:

 La búsqueda del número de teléfono de un habitante de una ciudad.


 El saldo bancario de un determinado cliente.
 Búsqueda de un libro en un catálogo.

Los métodos de búsqueda más básicos son los siguientes:

 Búsqueda secuencial: Consiste en recorrer todo el array, desde el primer


elemento hasta el último en busca de un valor determinado
 Búsqueda binaria: Se efectúa sobre vectores ordenados, consistiendo en
divisiones sucesivas por la mitad del vector.

Los algoritmos se eligen en función del tamaño del vector o array a clasificar, el tipo
de dato que almacena el vector y de la cantidad de memoria disponible.

Búsqueda secuencial

Se utiliza cuando el array no está ordenado o no puede ser ordenado previamente.

Consiste en buscar el elemento comparándolo secuencialmente con cada elemento


del array hasta encontrarlo, o hasta que se llegue al final. La existencia se puede
asegurar cuando se localiza el elemento, pero no podemos asegurar la no
existencia hasta no haber analizado todos los elementos del arreglo.

A continuación se muestra el pseudocódigo del algoritmo con un ejemplo:

Tenemos una tabla con edades de personal y tenemos que buscar la edad que
introducimos por teclado y debemos buscarlo en la tabla Tedad, si está en la tabla
muestra un mensaje: “ha encontrado la edad”.

Tipos de datos estructurados 23


Formación Abierta

Figura 5.25. Búsqueda de un dato.

La salida del algoritmo sería de la siguiente manera; el mensaje aparecerá tantas


veces encuentre el dato. Esto es un ejemplo para compresión de modo de
búsqueda secuencial.

Figura 5.26. Salida del programa.

Búsqueda dicotómica (binaria)

Se utiliza cuando el array en el que queremos buscar la existencia de un elemento


está previamente ordenado.

Aviso: Este algoritmo reduce el tiempo de búsqueda considerablemente, ya que


disminuye exponencialmente el número de iteraciones necesarias. Está altamente
recomendado para buscar en arrays de gran tamaño.

24 Tipos de datos estructurados


Introducción a la Programación 05

Para implementar este algoritmo se compara el elemento a buscar con un elemento


cualquiera del array (normalmente el elemento central): si el valor de éste es mayor
que el elemento buscado se repite el procedimiento en la parte del array que va
desde el inicio de éste hasta el elemento tomado, en caso contrario se toma la parte
del array que va desde el elemento tomado hasta el final. De esta manera
obtenemos intervalos cada vez más pequeños, hasta que se obtenga un intervalo
indivisible. Si el elemento no se encuentra dentro de este último entonces se
deduce que el elemento buscado no se encuentra en todo el array.

Lista por clasificar


Valor
deseado

4 6 8 10 12 14 16

4 6 8
8

8
Valor
obtenido
8

Figura 5.27. Búsqueda binaria.

Tipos de datos estructurados 25


Formación Abierta

A continuación se presenta el pseudocódigo del algoritmo, tomando como elemento


inicial el elemento central del array.

Figura 5.28. Pseudocódigo del Algoritmo.

La salida del programa seria la siguiente:

Figura 5.29. Salida del programación.

26 Tipos de datos estructurados


Introducción a la Programación 05

5.2. Arrays de varias dimensiones


Los arrays vistos hasta ahora se denominan unidimensionales, ya que cada
elemento se referencia únicamente por un subíndice. Puede ser, sin embargo, que
un grupo de datos se representen mejor en forma de tabla o matriz con 2 o más
subíndices. Por ejemplo, podemos querer guardar un array cuyos elementos sean
las casillas del juego de los barcos, y allí puede sernos útil referenciar cada
elemento con 2 subíndices, uno de ellos será para las filas y otro para las
columnas.

Los índices de filas y columnas se les suele declarar como


i, j.

Los arrays bidimensionales son un conjunto de elementos del mismo tipo, con su
orden significativo y en el que se necesita especificar 2 subíndices para identificar
un elemento concreto del array.

También se les conoce como tabla o matriz. El primer subíndice se refiere a la fila
de la tabla y el segundo a la columna. Es decir M[1,2] es el elemento del array M
que ocupa la fila 1 y la columna 2, como se puede observar en la siguiente tabla,
asignamos un numero 52.

Columnas

56
1

4
Filas

0 1 2 3

M[1,2] = 56

Figura 5.30. Array de dos dimensiones.

Tipos de datos estructurados 27


Formación Abierta

Su declaración también será parecida a la de los arrays, sólo que con 2 subíndices:

Dimension identificador [Numero_filas, Numero_columnas]

Ejemplo si quisiéramos guardar las 5 ciudades


principales de cada comunidad autónoma española,
tendríamos que declarar la tabla de la siguiente manera:

 17 comunidades autónomas x 5 ciudades principales.

Recorrido de un array bidimensional

Para el proceso de ingreso de datos en una posición de la matriz, debemos indicar


su posición relativa con respecto a filas y columnas. Por ejemplo, si quisiéramos
almacenar el valor 8 en la segunda fila y primera columna, diríamos algo como esto:

matriz[1, 0]=8;

Al igual que en los vectores, cuando queremos ingresar o leer múltiples datos,
hacemos uso de ciclos. La diferencia ahora es que para las matrices debemos
utilizar 2 ciclos, uno que recorra las filas y otro las columnas.

Ejemplo si quisiéramos introducir por teclado los valores de una matriz de 3X2,
deberemos recorrerla en dos ciclos, uno recorrerá las filas con un índice que lo
llamaremos (i), y otro para las columnas que se llamará (j):

Figura 5.31. Recorrido de matriz.

Veamos ahora un ejemplo completo, donde primero declararemos una matriz, luego
le diremos a un usuario que ingrese valores y finalmente los mostraremos:

28 Tipos de datos estructurados


Introducción a la Programación 05

Figura 5.32. Algoritmo de matriz de 2x2.

Tendría la siguiente salida:

Figura 5.33. Salida del programa.

Tipos de datos estructurados 29


Formación Abierta

5.3. Cadenas de caracteres


Una cadena de caracteres (string) es una secuencia ordenada de caracteres; en
realidad, una cadena es un array de caracteres.

E s t a e s u n a c a d e n a

Figura 5.34. Almacenamiento de una cadena.

Una de las características más importantes de la cadena es la longitud, que es el


número de caracteres que contiene una cadena, y puede ser entre 0 y 255. No
podemos tener cadenas cuya longitud sea negativa (no tiene sentido). A una
cadena que no contiene ningún carácter la denominamos cadena nula o cadena
vacía.

Representaremos las cadenas entre comillas simples o dobles, según el lenguaje


de programación (en C se utilizan las comillas dobles), en pseudocódigo
representaremos las cadenas entre comillas dobles. Ejemplos de cadenas son:

 ‘”cadena de ejemplo”
 “30 de septiembre del 2003”
 “a”
 “” (cadena vacía o cadena nula)

Las longitudes de las cadenas anteriores son 17, 25, 1 y 0


respectivamente. La tercera cadena está formada por un
único carácter por lo tanto no hay que confundir con el tipo
de dato carácter. Esto lo veremos más claramente cuando
se vea cómo se declara un tipo de dato cadena. La cuarta
cadena es la cadena nula o vacía que no tiene ningún
carácter y en consecuencia su longitud es cero.

Los caracteres que podemos utilizar dentro de una cadena son cualquiera que
maneje el ordenador: letras, números, signos, etc.

Una subcadena, es una cadena extraída de otra cadena como por ejemplo:

 “Cadena” es una subcadena de “Cadena de ejemplo”


 “septiembre” es una subcadena de “30 de septiembre del 2003”

30 Tipos de datos estructurados


Introducción a la Programación 05

5.3.1. Datos de tipo cadena


El tipo de dato cadena es una generalización del tipo de dato carácter, por lo tanto
puede estar formado por el conjunto de cualquier carácter válido.

Una constante de tipo cadena está formada por un conjunto de


caracteres válidos encerrados entre comillas. De la misma forma
que ocurre con todo tipo de constantes, no podemos modificarlas
durante la ejecución de un programa.

Por ejemplo, utilizaremos este tipo de datos cuando escribimos


un mensaje en la pantalla:

Escribir "Esto es una cadena constante ";

Variables de tipo cadena

Una variable de tipo cadena es la que puede almacenar varios caracteres y que
puede modificar su contenido durante la ejecución del programa.

Las variables de tipo cadena se declaran igual que el resto de las variables, con la
salvedad de que el tipo se llama Cadena.

Definir nombre Como Cadena;

Podemos realizar la lectura y escritura de este tipo de variables mediante las


instrucciones de leer y escribir, como el resto de variables.

5.3.2. Lista de Cadenas


Para entender como se realiza una lista de tipo cadena de caracteres, aplicaremos
un ejemplo, que desarrollaremos a PseInt, para ver paso a paso y entender como
se realiza,

Esta práctica consiste en ingresar una lista de nombres, solicitadas al usuario e


introducidas por teclado, el programa debe mostrar la lista de nombres pero
ordenada.

Para ello vamos a indicar una serie de condiciones para el funcionamiento de la


aplicación.

 Cuando se ingresa un nombre en blanco, damos por finalizada la lista.


 Cuando ingresa un nombre repetido muestra error nombre repetido.
 Muestra la lista en orden alfabético por la primera letra de la palabra.

Tipos de datos estructurados 31


Formación Abierta

La salida de la aplicación deberá tener la siguiente salida en pantalla:

Figura 5.35. Salida de aplicación.

Como podemos observar en la salida por pantalla, es que ordena los nombres en
orden descendentes, del mayor al menor, por lo que tenemos que aplicar un
sistema de ordenación, en este caso lo haremos secuencial.

Tenemos que pensar cómo guarda los datos, identificar las variables a utilizar etc.
Por lo que vamos a pasar a declarar las variables, que son las mostradas a
continuación:

 Lista[200]: declaramos una lista de tipo carácter para guardar los nombres
que debemos ordenar.

Dimension lista[200];

Definir lista Caracter;

Dimensionamos hasta 200, porque no sabemos que capacidad va a tener,


ya que finalizará cuando el usuario no introduce ningún nombre.

0 1 2 3 4

Luis Ana Pepe Juan Zaida

Lista [200]

Figura 5.36. Tabla Lista.

32 Tipos de datos estructurados


Introducción a la Programación 05

 lista, nombre, aux, realizamos la declaración de la siguientes variables


como carácter, ya que las utilizaremos para guardar nombre de la tabla;
como hemos indicado anteriormente, el array que utilizaremos es de tipo
carácter o cadena de caracteres. Nombre y aux, las declararemos para la
lectura del nombre por teclado y aux para el intercambio de ordenación.
 cant, i, pos_menor: estas variables son declaradas para contar el número
de nombres introducidos (cont), para recorrer el vector (i), y para el sistemas
de ordenación (pos_menor), todas ellas son de tipo entero, numérico, ya
que nos servirá de índice para el array.
 se_repite: esta variable de tipo lógico; nos servirá para llevar el control de
los nombres repetidos.

Veamos el algoritmo para ir explicando la solución del mismo:

Tipos de datos estructurados 33


Formación Abierta

Figura 5.37. Algoritmo.

34 Tipos de datos estructurados


Introducción a la Programación 05

Tenemos tres grupos identificados en el algoritmo:

 Leer lista.
 Ordena lista.
 Mostrar lista.

Leer lista

Para este proceso, lo primero que hacemos es la lectura de un nombre introducido


por teclado, que vamos a guardar en la variable nombre.

leer nombre (línea 11)

Cuando tenemos el nombre introducido, debemos filtrar que no sea repetido y


además no sea un retorno o nulo para darle fin a la lista, por lo que necesitamos de
sentencias de control repetitivas (mientras…) y selectivas (si...).

Figura 5.38. Validación de valores para la tabla-lista.

Línea 12-24: en la primera estructura repetitiva, mientras, filtramos que lo que ha


introducido el usuario no sea un retorno o nada, porque esto daría fin a nuestra
lista, por lo que el bucle se repite hasta que sea un nulo.

Línea 13: sumamos a cant un 1, para saber cuántos nombres vamos introduciendo
en la lista, es decir la cantidad de celdas que tiene que tener el array, además nos
servirá de índice para el array. Tenemos que observar que la hemos inicializado a
0, antes de entrar en el bucle.

Línea 14: introducimos o asignamos al array el nombre introducido por teclado al


array lista en la posición cant, que la primera vez que pasa es 1, ya que primero
realizar la suma, como hemos indicado anteriormente, y luego introduce el nombre
a la primera posición del array.

Línea 15-23: en esta estructura repetir, vamos a filtrar que el nombre se repita con
una variable booleana o lógica, que es se_repite.

Tipos de datos estructurados 35


Formación Abierta

Línea 16: leemos el nombre.

Línea 17: asignamos un valor falso de forma inicial a la variable, ya que todavía no
hemos controlado si se repite o no.

Línea 18-22: tenemos que ver que el nombre que hemos leído segundo, no se
repite con los anteriores, que están guardados en la lista, por lo que tenemos que
recorrerla, hasta el número de nombres que ya hayamos introducido y la variable
está en falsa, ya que si está repetido, esta variable cambiará a verdadera, y nos
pedirá el nombre hasta que introduzcamos uno correcto.

Linea19-21: filtramos con un si, si el nombre de la lista corresponde con el último


introducido, si es así, cambiamos el valor a la variable booleana se_repite.
Podemos añadir un mensaje de nombre repetido, como se puede observar en el
siguiente código.

Si nombre=lista[i] Entonces

se_repite<-Verdadero;

Escribir "nombre repetido";

FinSi

En el original no aparece el mensaje, y repite que volvamos a introducir código


hasta que el usuario teclee un nombre que no se repita, y éste lo introducirá en el
array.

Ordena lista

Para el proceso de ordenar la lista utilizaremos un sistema secuencial, es decir


vamos leyendo y comparando con el siguiente; que es mayor lo leído que el
siguiente dato lo intercambiamos, si no, pasamos a lectura del siguiente dato.

Figura 5.39. Pseudocódigo ordenar lista.

36 Tipos de datos estructurados


Introducción a la Programación 05

Línea 28-40: recorremos el array donde tenemos los nombres a ordenar, para ello
hacemos un “para” desde la posición 1 hasta la última que la guardamos en la
variable cant.

Línea 30: introducimos en la variable Pos_menor, el valor del índice de dato


primero leído. Esto es para luego comparar con el siguiente y si es mayor
intercambiar los datos; y si no, seguir leyendo.

Línea 31-35: Realizamos otro para comparar el primero con el resto de la lista, y
así consecutivamente con el resto.

37-38-39: realizamos el cambio de posiciones para ello utilizamos una variable


auxiliar.

Mostrar lista

Lo único que realizamos, es recorrer el array que está guardada en “lista” y


mostramos por pantallas los datos.

Figura 5.40. Muestra los datos lista.

Como hemos hecho en ocasiones anteriores, para recorrer un vector o array


utilizamos un “para”…y mostramos los datos en pantalla. .

Tipos de datos estructurados 37


Introducción a la Programación 05

 Resumen

 Un array 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 arrays multidimensionales son idénticos pero con más de un subíndice.

 Todo array se compone de un determinado número de elementos. Cada


elemento es referenciado por la posición que ocupa dentro del vector. Dichas
posiciones son llamadas índice y siempre son correlativos.

 Una cadena es una secuencia de caracteres que se almacenan de forma


secuencial. La instrucción leer almacena la cadena introducida por el usuario a
partir de la posición uno. En la posición cero se almacena el carácter que indica
la longitud de la cadena almacenada.

 Los métodos de búsqueda más básicos son las búsquedas secuenciales:


Consiste en recorrer todo el array, desde el primer elemento hasta el último en
busca de un valor determinado y búsqueda binaria: Se efectúa sobre vectores
ordenados, consistiendo en divisiones sucesivas por la mitad del vector.

 Para poder ordenar una cantidad determinada de números almacenadas en un


vector o matriz, existen distintos métodos con distintas características y
complejidad. Existe desde el método más simple, como el Método Burbuja, que
son simples iteraciones, hasta el Quicksort, Método Rápido.

Tipos de datos estructurados 39