apuntes de algoritmos

5/16/2018 Apuntes de Algoritmos - slidepdf.com

http://slidepdf.com/reader/full/apuntes-de-algoritmos-55ab53a50a5fe 1/81

Apuntes de algoritmos

1


Contenido

1. Algoritmos y Programas ............................................................... 31.1. Computadoras y lenguaje de programación ......................................................31.2. Resolución de problemas...................................................................................51.3. Datos ..................................................................................................................81.4. Representación de algoritmos .........................................................................13

2. Estructura general de un programa........................................... 172.1. Estructura general de un algoritmo en pseudocódigo .....................................172.2. Operación de asignación .................................................................................172.3. Conversión de tipos .........................................................................................19

2.4. Contadores.......................................................................................................202.5. Acumuladores ..................................................................................................212.6. Interruptores .....................................................................................................21

3. Estructura general de un programa........................................... 223.1. Programación estructurada..............................................................................223.2. Estructura secuencial .......................................................................................223.3. Estructura selectiva ..........................................................................................233.4. Estructura repetitiva .........................................................................................243.5. Estructura anidada ...........................................................................................27

4. Subalgoritmos, funciones y procedimientos............................ 29

4.1. Programación modular .....................................................................................294.2. Funciones.........................................................................................................294.3. Procedimientos.................................................................................................304.4. Estructura general de un algoritmo ..................................................................324.5. Parámetros de los subalgoritmos.....................................................................324.6. Variables locales y globales.............................................................................34

5. Tipos de datos estructurados .................................................... 355.1. Datos estructurados .........................................................................................355.2. Arreglos ............................................................................................................355.3. Registros ..........................................................................................................39

5.4. Cadenas de caracteres ....................................................................................406. Introducción a la programación orientada a objetos............... 43

6.1. Objeto...............................................................................................................436.2. Clase ................................................................................................................446.3. Relación entre clase y objeto ...........................................................................446.4. Atributos ...........................................................................................................456.5. Métodos............................................................................................................456.6. Mensaje............................................................................................................46




2

6.7. Diagrama de clases .........................................................................................466.8. Relaciones entre clases ...................................................................................47

7. Fundamentos del enfoque orientado a objeto.......................... 507.1. Abstracción.......................................................................................................507.2. Encapsulamiento (ocultamiento de información) .............................................507.3. Modularidad......................................................................................................517.4. Herencia ...........................................................................................................517.5. Polimorfismo.....................................................................................................51

8. Ejemplos....................................................................................... 538.1. Expresiones......................................................................................................538.2. Diagramas de flujo ...........................................................................................538.3. Estructuras de selección ..................................................................................548.4. Estructuras de repetición .................................................................................568.5. Funciones y procedimientos ............................................................................588.6. Arreglos ............................................................................................................628.7. Registros ..........................................................................................................678.8. Cadenas ...........................................................................................................708.9. Definición de una clase ....................................................................................738.10. Asociación (ver algoritmo del Ejemplo 8.9.) ...................................................748.11. Herencia, clase abstracta y asociación..........................................................758.12. Polimorfismo, herencia, clase abstracta y asociación ...................................77

Bibliografía ....................................................................................... 81




3

1. Algoritmos y Programas

1.1. Computadoras y lenguaje de programación

1.1.1. Computador u ordenadorDispositivo electrónico utilizado para procesar datos en forma automática y obtener resultados los cualespueden a su vez ser organizados y analizados para producir información. El computador está conformadopor una parte física llamada hardware y por una parte lógica o de programas llamada software.

1.1.2. Datos

Es una representación de hechos, conceptos o instrucciones, organizados de manera que se puedanprocesar, interpretar o comunicar por medios humanos o automáticas. Los datos, son por ejemplo,representaciones de las características de una persona, objeto, concepto o hecho.

Los datos se pueden introducir en el computador como entrada y se procesan para producir resultados einformación de salida.

1.1.3. Hardware

Es el conjunto de componentes físicas que forman un computador.

Como ejemplo tenemos los chips de los procesadores (CPU, procesadores matemáticos, procesadores devideo), las tarjetas (la tarjeta madre, las tarjetas de memoria como la memoria RAM, las tarjetas de video,red, sonido), las unidades de almacenamiento (disco duro, disquete, cd, dvd, pen drive), los dispositivosperiféricos (ratón, teclado, monitor, impresora)

1.1.4. Software

Son los programas que permiten utilizar los recursos del computador. Programación, soporte lógico, parteno-mecánica o no-física de un sistema. Es un conjunto de programas y procedimientos que se incluyen enun computador o equipo con el fin de hacer posible el su uso eficaz de dicha máquina. Son las instruccionesresponsables de que el hardware (la máquina) realice su tarea.

Como ejemplo tenemos los sistemas operativos, el software de aplicación, el software utilitario y loslenguajes de programación.

Sistema operativo

Software básico encargado de controlar diferentes procesos en el computador mediante tres grandesfunciones:

• Coordinar y manipular el hardware del computador: como los procesadores, la memoria, las impresoras,las unidades de almacenamiento, el monitor, el teclado o el ratón;

• Organizar los archivos en diversos dispositivos de almacenamiento, como discos flexibles, discos duros,Cds.

• Gestionar los errores de hardware y la pérdida de datos.

Software de aplicación

Programa informático diseñado para facilitar al usuario la realización de un determinado tipo de trabajo.Algunas son aplicaciones desarrolladas “a la medida” que ofrecen una gran potencia y soluciones eficientesya que están exclusivamente diseñadas para resolver un problema específico. Son ejemplos de este tipo de




4

software los programas que realizan tareas concretas como manejo de nómina, análisis de estadísticas,manejo de almacén, etc.

Software utilitario

Son programas que facilitan el uso del computador como herramienta para solucionar actividades generalescomo la edición de textos o la digitalización de materiales. En muchos casos los programas utilitarios sonagrupados en paquetes integrados de software, por ejemplo el Microsoft Office o el OpenOffice, donde se

ofrece soluciones más generales, pero se incluyen varias aplicaciones (procesador de textos, de hoja decálculo, manejador de base de datos, correo electrónico, visor de imágenes, etc.).

Lenguajes de programación

Sirven para escribir programas que permitan la comunicación usuario/máquina y la soluciones de problemasutilizando las ventajas, poder de cálculo, procesamiento y almacenamiento del computador.

Diferencias entre los tipos software

El software de aplicación se diferencia de un sistema operativo (que hace funcionar al ordenador), de unautilidad (que realiza tareas de mantenimiento o de uso general) y de un lenguaje (con el cual se crean losprogramas informáticos), en que suele resultar una solución informática para la automatización de tareas enun área determinada (procesamiento de texto, edición de imágenes, estadística, manejo de

correspondencia, etc.).

1.1.5. Estructura funcional de un computador (arquitectura Von Neumann)

La arquitectura Von Neumann se refiere a las arquitecturas de computadoras que utilizan el mismodispositivo de almacenamiento para las instrucciones y para los datos (a diferencia de la arquitecturaHarvard). El término se acuñó en el año 1945, escrito por el conocido matemático John Von Neumann, quepropuso el concepto de programa almacenado.

Los ordenadores con arquitectura Von Neumann constan de las siguientes partes:

Memoria principal

Es el subsistema donde se almacenan temporalmente los datos e instrucciones que son utilizados por elcomputador. Esta información está representada en una codificación binaria de 0 y 1. La memoria se divideen celdas, donde cada celda tiene una dirección única, de tal forma que el contenido de ellas puede serbuscado, extraído y utilizado.




5

Unidad central de proceso (CPU o Procesador)

Es el subsistema encargado de extraer las instrucciones y los datos en la memoria principal para realizar lostratamientos u operaciones correspondientes. Está conformado por la Unidad de control y la Unidad lógico-aritmética

• Unidad de control (UC). Se encarga de:

- Obtener de la memoria la próxima instrucción a utilizar o ejecutar.

- Decodificar la instrucción para determinar qué debe hacerse.

- Según la decodificación hecha, enviar el comando apropiado a la ALU, memoria o controlador deentrada/salida para que realice la tarea.

• Unidad lógico-aritmética (ALU). Se encarga de realizar las operaciones aritméticas y comparaciones.

Dispositivo de entrada/salida

Es el subsistema que permite al computador interactuar con otros dispositivos, comunicarse con el mundoexterior y almacenar los datos y programas en unidades permanentes, por ejemplo, el disco duro.

Está conformado por:

• Bus o unidades de intercambio. Permiten comunicar información entre los componentes del sistema,

los periféricos y el mundo exterior.

• Memoria secundaria. Permite conservar datos y programas en forma permanente, aún luego de apagarel computador.

• Periféricos. Son dispositivos utilizados para suministrar información entre el computador y el exterior(monitor, teclado, ratón, tarjeta de red, impresoras, tarjetas de memoria, escáner, etc.).

1.2. Resolución de problemas

1.2.1. Algoritmo (algorithm)

Es un conjunto bien definido de procedimientos lógicos o matemáticos que se pueden seguir para resolverun problema en un número finito de pasos.

Es una lista finita de pasos que plantean una solución a un problema, preferiblemente pasos los más cortosy simples posibles. Para un mismo problema pueden existir muchos algoritmos que conducen a su solución.La elección del mejor algoritmo está guiada por criterios de eficiencia y eficacia, entre otras característicasdeseables. Elementos de un algoritmo:

• Datos de entrada.

• Proceso o pasos que resuelven el problema.

• Datos de salida.

Características de un algoritmo• Un algoritmo debe ser preciso e indicar el orden de realización de cada paso.

• El resultado del algoritmo debe estar definido. Si se sigue un algoritmo dos veces con los mismos datosde entrada, se debe obtener el mismo resultado cada vez.

• Un algoritmo debe ser finito. Si se sigue un algoritmo, se debe terminar en algún momento, es decir, sedebe tener un número finito de pasos.




6

1.2.2. Pseudocódigo

En un algoritmo expresado de manera más formal. Se utiliza como una representación intermedia, antes detraducirlo o codificarlo con un lenguaje de programación. En las clases de Algoritmo utilizaremos elpseudocódigo para expresar las soluciones algorítmicas creadas.

1.2.3. Lenguaje de programación

En computación es cualquier lenguaje artificial que puede utilizarse para definir una secuencia deinstrucciones, a fin de que puedan ser procesadas por un computador.

Conjunto de caracteres, reglas, palabras y operaciones con significados previamente asignados y quepermiten escribir programas.

La definición de un lenguaje de programación cubre tres aspectos:

• Léxico. Define los símbolos que sirven para la redacción de un programa y las reglas para la formaciónde palabras en el lenguaje. Por ejemplo, 10 es un número entero.

• Sintaxis. Conjunto de reglas que permiten organizar las palabras del lenguaje en frases, por ejemplo, laoperación de división se define como Dividendo/Divisor.

• Semántica. Define las reglas que dan sentido a una frase.

Los principales tipos de lenguajes de programación utilizados en la actualidad son:

• Lenguajes de máquina.

• Lenguajes de bajo nivel y traductores (lenguaje ensamblador, compiladores, intérpretes).

• Lenguajes de alto nivel (C, C++, C#, Visual Basic, Java, Turbo Pascal, Prolog, JavaScript, VBScript,PHP, VB.Net, Fortran, Delphi, etc.).

1.2.4. Programa

En Computación, es el conjunto de instrucciones que definen la secuencia de eventos que un computadordebe ejecutar para llevar a cabo una tarea, realizando cálculos y suministrando resultados.

Grupo de instrucciones compuestas con la finalidad de resolver un problema específico mediante el uso deun computador. Un programa está codificado en un lenguaje que la máquina es capaz de entender yprocesar.

Es la traducción de un algoritmo o de un pseudocódigo utilizando un lenguaje de programación.

1.2.5. Programación

Proceso que comprende el análisis del problema, diseño de la solución, escritura o desarrollo del programa,prueba del programa y su corrección.

Es la disciplina de la Computación que trata el desarrollo de programas.

1.2.6. Aspectos que miden la calidad en un programaAlgunos aspectos que se consideran para medir la calidad de un programa, también llamados característicasdeseables en un programa, son:

• Legibilidad

• Robustez

• Eficacia

• Eficiencia

• Adaptabilidad




7

• Portabilidad

• Reusabilidad del software

1.2.7. Capacidad de abstracción

Mecanismo intelectual principal en la actividad de la programación, el cual durante la etapa de análisis delproblema permite la separación de los aspectos relevantes de los irrelevantes en el contexto estudiado. Por

ejemplo, si el problema consiste en determinar cuál es la persona más alta del salón, lo relevante es laestatura de cada persona, y no color de ojos, talla de calzado, etc.

1.2.8. Enfoques para solucionar un problema

• Programación modular. Consiste en dividir el problema original en diversos subproblemas que sepueden resolver por separado, para después recomponer los resultados y obtener la solución alproblema.

• Enfoque divide y vencerás. consiste en resolver un problema a partir de la solución de subproblemasdel mismo tipo, pero de menor tamaño. Si los subproblemas son todavía relativamente grandes seaplicará de nuevo esta técnica hasta alcanzar subproblemas lo suficientemente pequeños para sersolucionados directamente.

• Diseño descendente (top-down). Consisten en diseñar los algoritmos en etapas, yendo de losconceptos generales a los detalles. Ejemplo, para el problema de indicar los pasos para ver una películaen el cine se podría considerar en un primer nivel los siguientes pasos:

Ir al cine.

Comprar una entrada.

Ver la película.

Regresar a casa.

Luego cada uno de estos pasos puede subdividirse en otros niveles donde las instrucciones sean cadavez más específicas.

1.2.9. Fases en la resolución de problemas

Resolver problemas a través de un computador se basa principalmente en analizar, diseñar, escribir yejecutar un programa con pasos orientados a solucionar el problema. Podemos considerar como fases deresolución de un problema las siguientes:

• Análisis del problema

• Diseño del algoritmo, utilizando pseudocódigo.

• Codificación, traducción del algoritmo a un lenguaje de programación, esto nos permite crear elprograma.

• Ejecución del código del programa.

• Verificación del programa.• Documentación.

• Depuración de errores.

• Mantenimiento y mejora del programa.

1.2.10. Ciclo de vida de desarrollo del software

• Análisis. El problema se analiza teniendo en cuanta los requerimientos o necesidades expresadas por elcliente, la empresa o las personas que utilizaran el programa.




8

• Diseño. Una vez analizado el problema se diseña una solución que conduce a un algoritmo general queresuelve los elementos más significativos del programa. Este algoritmo puede ser escrito utilizandopseudocódigo.

• Codificación (implementación). La solución expresada en pseudocódigo se traduce a un programa queel computador pueda procesar utilizando un lenguaje de programación de alto nivel.

• Compilación, ejecución y verificación. El programa se ejecuta (corre) y se verifica para eliminarerrores de programación o de lógica.

• Documentación. Se agrega al código del programa línea de texto que ayudan al programador y a laspersonas que a futuro harán mantenimiento al software a entender su estructura y comportamiento. Ladocumentación también incluye escribir informes en donde se describe cómo se realizaron las diferentesfases del ciclo de vida del software (en especial los procesos de análisis, diseño, codificación y prueba),se agregan manuales de usuario y de referencia, así como normas para el mantenimiento.

• Depuración y mantenimiento. El programa se actualiza y modifica en la medida en que sea necesariode manera que cumpla con las necesidades de los usuarios las cuales también cambian en el tiempo.

1.3. Datos

1.3.1. Dato

Diferentes entidades u objetos de información con que trabaja un programa. Determina el conjunto devalores que la entidad puede almacenar, los operadores y las operaciones definidos sobre ellos.

Los datos tienen 3 características:

• Un nombre que los diferencia del resto.

• Un tipo que nos determina las operaciones que podemos hacer con ese dato.

• Un valor que puede variar o no a lo largo de la operación.

1.3.2. Tipo de datoDefine el conjunto de valores que un elemento o un objeto (una variable, constante, expresión o función) dedicho tipo puede asumir y las operaciones asociadas a tales valores.

Es un conjunto de entidades o de objetos y las operaciones definidas sobre ellos.

Los datos pueden ser:

• Simples. Un elemento.

• Compuestos. Varios elementos.

Los tipos pueden ser:

• Estándar. Que vienen en el sistema por defecto.

• No estándar. Son los que crea el usuario.Los tipos simples más importantes son:

• Numéricos

Entero. Subconjunto finito del conjunto matemático de los números enteros. No tiene parte decimal.El rango de los valores depende del tamaño que se les da en memoria.

Real. Subconjunto finito del conjunto matemático de los números reales. Llevan signo y partedecimal. Se almacenan en 4 Bytes (dependiendo de los modificadores). Si se utilizan números realesmuy grandes, se puede usar notación científica que se divide en mantisa, base y exponente; tal queel valor se obtiene multiplicando la mantisa por la base elevada al exponente.




9

• Lógicos o booleanos. Aquel que sólo puede tomar uno de los dos valores, verdadero o falso (1/0).

• Carácter. Abarca al conjunto finito y ordenado de caracteres que reconoce la computadora (letras,dígitos, caracteres especiales, ASCII).

• Cadena o String. Conjunto de caracteres, que van a estar entre “”.

En algunos lenguajes se definen tipos especiales de fecha y hora, sobre todo en los más modernos.

1.3.3. Posible clasificación de los tipos de datos

• Tipos de datos primitivos o elementales: tipos básicos incluidos en cada lenguaje de programación.En el lenguaje de programación Java, también son llamados tipos integrados.

• Tipos de datos estructurados: tipos basados o construidos a partir de tipos de datos primitivos (porejemplo, arreglo, registro, archivo, conjunto).

• Tipos de datos abstractos (TDA): tipos de datos definidos por el usuario y las operaciones abstractasaplicadas sobre ellos. Los TDA apoyan el concepto de ocultamiento de la información. Esconden losdetalles de la representación y permiten el acceso a los objetos sólo a través de sus operaciones, sonejemplos las representaciones de los TDA Lista, Cola, Pila, Árbol y la representación que hace elEnfoque Orientado a Objeto mediante atributos y métodos.

Esquemas de organización de los tipos de datos

Esquema 1 Número decomponentes

Tipo de componentes

- Entero, Real (numéricos)1 Elemental - Carácter, Cadenas de caracteres (caracteres)

- Lógico (boléanos)

Tipos de datos

n Estructurado

Homogéneos (todos los elementos iguales)- Arreglos- ArchivosHeterogéneos (aceptan elementos distintos)- Registros

Esquema 2 Estándar

- Entero- Real- Carácter- Lógico (boléanos)

Tipos de datos Estáticos

- Arreglo (Vector, Matriz, Cubo )- Registro- Archivo (Fichero)- Cadena de caracteres

Dinámicos

- Lista (y las variaciones pila, cola, dipolo)- Lista enlazada

- Árbol- Grafo

1.3.4. Constante

Tienen un valor fijo que se le da cuando se define la constante y que ya no puede ser modificado durante laejecución. Pueden ser numéricos, lógicos, carácter o cadena.

Las constantes pueden llevar asociados un nombre o no, si no lo llevan, se llaman literales. Su valor hay quedarlo al definir la constante y ya no puede cambiar a lo largo de la ejecución, y en cuanto al tipo,




10

dependiendo de los lenguajes en algunos hay que ponerlo, y en otros no hace falta ponerlo porque toma eltipo del dato que se le asigna.

const

<nombre_de_constante> = <valor>

Ejemplo:

const

PI = 3.1415

1.3.5. Variable

Nombre asignado a una entidad que puede adquirir un valor cualquiera dentro de un conjunto de valores. Esdecir, una entidad cuyo valor puede cambiar a lo largo del programa.

En un programa de computador se puede asumir que una variable es una posición de memoria donde losvalores asignados pueden ser reemplazados o cambiados por otros valores durante la ejecución delprograma.

Antes de usar una variable hay que definirla o declararla, al hacerlo hay que dar su nombre y su tipo. Elnombre que le damos tiene que ser un nombre significativo, va a ser un conjunto de caracteres que

dependiendo del lenguaje hay restricciones. Tiene que empezar por una letra, y el tamaño depende dellenguaje.

• Identificador. Palabra que no es propia del lenguaje.

• El valor de la variable si al declararla no se la inicializa, en algunos lenguajes toma una por defecto. Encualquier caso el valor de la variable se debe inicializar o ir variarlo a lo largo de la ejecución.

var

<tipo_de_dato> : <lista_identificadores_de_variables>

Ejemplo:

var

entero : mayor, menor

real : precio

lógico : encontrado

La ventaja de usar constantes con nombre es que en cualquier lugar donde quiera que vaya la constante,basta con poner su nombre y luego el compilador lo sustituirá por su valor.

Al detectar una variable o una constante con nombre, automáticamente se reserva en memoria espacio paraguardar esa variable o constante. El espacio reservado depende del tipo de la variable.

1.3.6. Operaciones de los tipos de datos elementales

• Operación. Acción por medio de la cual se obtiene un resultado de un operando. Ejemplos: sumar,

dividir, unir, restar. • Operando. número, texto, valor lógico, variable o constante sobre la cual es ejecutada una operación.

• Operador. símbolo que indica la operación que se ha de efectuar con el operando, por ejemplo, + /- * >= = <> <= =

1.3.7. Expresiones

Son combinaciones de constantes, variables, símbolos de operación, paréntesis y nombres de funciones oacciones. Cada expresión toma un valor que se determina considerando los valores de las variables,constantes y operaciones implicadas.




11

Una expresión consta de operandos y operadores.

Según sea el tipo de datos que manipulan, las expresiones se pueden clasificar en Aritméticas, Lógicas oCarácter. Así tenemos:

Numéricas: Operadores aritméticos

Son los que se utilizan en las expresiones numéricas (una combinación de variables y/o constantesnuméricas con operadores aritméticos y que al evaluarla devuelve un valor numérico.

+, -, *, /

Operación resto: Lo que devuelve es el resto de una división entera.

5 mod 3 = 2

División entera: Nos devuelve el cociente de una división entera (en la que no se sacan decimales).

5 div 3 = 1

Potencia:

5 ^ 2 = 25 ó 5 ** 2 = 25.

Todos estos operadores son binarios (el operador se sitúa en medio), el menos también puede ser unario(lleva un único operando) y significa signo negativo.

Reglas de precedencia

El problema es cuando una expresión entera según como la evalúe pueda dar diferentes valores.

7 * 3 + 4 25

La solución es aplicar prioridad entre los operadores, de modo que ante la posibilidad de usar varios siempreaplicaremos primero el de mayor prioridad.

Cada lenguaje puede establecer sus propias reglas de prioridad o precedencia de operadores. Si no nosacordamos, siempre podemos poner ( ).

• ^ ó **

•

* / div mod

• + -

Entre dos operaciones que tienen la misma precedencia para resolver la ambigüedad, hay que usar la reglade la asociatividad. La más normal es la de la asociatividad a izquierdas (primero lo de la izquierda).

Expresiones lógicas: Operadores relacionales y lógicos

Una expresión lógica es aquella que sólo puede devolver dos valores (Verdadero o Falso). Los valores quepueden aparecer en una expresión lógica son de 2 tipos: lógicos y relacionales.

La particularidad de las expresiones lógicas es que mientras en una expresión numérica por devolver unvalor numérico los operandos solo pueden ser números, en una expresión lógica los operandos no tienenporque ser booleanos aunque se devuelva un valor booleano. Esto es lo que ocurre cuando en la expresión

lógica utilizamos operadores relacionales con lo cual se obtienen valores lógicos o booleanos a partir deotros que no lo son.

En cambio cuando los operadores son lógicos los operandos obligatoriamente también tienen que serlógicos.

Operadores relacionales

<, >, =, <>, <=, >=

< Operando1> operador < Operando2>

5 > 3 Verdadero




12

¿Cómo se evalúa una expresión relacional?

• Primero se evalúa el primer operando y se sustituye por su valor.

• Luego se evalúa el segundo operando y se sustituye por su valor.

• Finalmente se aplica el operador relacional y se devuelve el valor booleano correspondiente.

((3 * 2) + 1 – 5 ^ 2) < (2 - 1)

-18 < 1 Verdadero

El problema del tipo real:

Desde la informática, los números reales son finitos, ya que tenemos un máximo de cifras decimales.Cuando trabajamos con un =, matemáticamente da un valor exacto, pero informaticamente no es exacto.

1 / 5 * 5 = 1

1.0 / 5.0 * 5.0 <> 1.0

Soluciones:

• La que nos aporte el propio lenguaje de programación. Se considera un valor de error.

• Trabajar con números enteros siempre que sea posible.

• Utilizar las comparaciones <> en vez de <= => si es posible.

• Si hay que preguntar por igual, cambiar la condición utilizando valores absolutos y un valor mínimo deerror.

• Si la diferencia < 0.00000001 y ABS (A - B) < min; son iguales.

Operadores lógicos

El problema es que a veces queremos preguntar o evaluar por más de una condición al mismo tiempo y paraesto están los operadores lógicos.

Y

O

No

Y, O, son operadores binarios (necesitan 2 operandos de tipo lógico).

Operando 1 Operador Operando 2

El No es unario, se coloca primero el No, y después el operando.

El resultado es lógico y depende de:

Operando 1 Operando 2 Y O

V V V V

V F F V

F V F V

F F F F

El No niega:

Operando No

V F

F V




13

1.3.8. Precedencia

Prioridad definida entre los operadores. Indica en qué orden debe aplicarse diferentes operaciones sobre unconjunto de valores. Permiten aplicar los operadores en el orden correcto.

• ( )

• ** No

• div mod / * Y

• + - O

• < > = <= >= <>

De mayor prioridad a menor prioridad. En caso de haber operadores del mismo nivel en una expresión, seevalúan en orden de aparición de izquierda a derecha.

En expresiones donde se combinen operadores se evalúa primero los aritméticos, luego los relacionales yde último los operadores lógicos.

1.3.9. Funciones internas

Son funciones matemáticas diferentes de las operaciones básicas pero que se incorporan al lenguaje y quese consideran estándar. Dependen del lenguaje. Normalmente se encuentran en la librería de matemáticasdel lenguaje de programación.

Función Descripción Tipo de argumento Resultado

abs (x) Valor absoluto de x Entero o real Igual que el argumento

arctan (x) Arcotangente de x Entero o real Real

cos (x) Coseno de x Entero o real Real

sen (x) Seno de x Entero o real Real

ent (x) Entero de x Real Entero

exp (x) E elevado a x Entero o real Real

ln (x) Logaritmo natural de x Entero o real Reallog10 (x) Logaritmo base 10 de x Entero o real Real

redondeo (x) Redondea x al entero más próximo Real Entero

trunc (x) Parte entera de x Real Entero

cuadrado (x) Cuadrado de x Entero o real Igual que el argumento

raiz2 (x) Raíz cuadrada de x Entero o real Real

1.4. Representación de algoritmos

Un algoritmos puede ser escrito en castellano narrativo, pero esta descripción suele ser demasiado extenso y,además, ambigua. Para representar un algoritmo se utilizar algún método que permita independizar dichoalgoritmo de los lenguajes de programación y, al mismo tiempo, que sea fácilmente codificable.

Los métodos más usuales para la representación de algoritmos son:

• Diagramas de flujo

• Diagramas N-S (Nassi-Schneiderman)

• Pseudocódigo.




14

1.4.1. Diagramas de flujo

Es una notación gráfica para implementar algoritmos. Se basa en la utilización de unos símbolos gráficosque se denominan cajas, en las que se escribe las acciones que tiene que realizar el algoritmo.

Las cajas están conectadas entre sí por líneas y eso nos indica el orden en el que tenemos que ejecutar lasacciones.

En todo algoritmo siempre habrá una caja de inicio y otra de fin, para el principio y final del algoritmo.

Símbolo Función

Líneas de flujo. Una línea con una flecha que sirve para conectar los símbolosdel diagrama y la flecha indica la secuencia en la que se van a ejecutar lasacciones.

Principio y fin. Dentro del símbolo ira la palabra inicio o fin del algoritmo.

Proceso. Indica la acción que tiene que realizar la computadora. Dentroescribimos la acción.

Entrada y salida. Dentro colocaremos las acciones de lectura y escritura

Condición. Dentro se va a colocar una condición. Sirve para representarestructuras selectivas y repetitivas

Comentario. Es una aclaración para entender mejor el código, pero no es partede este, no se ejecuta.

Ejemplo: Obtener el área de un rectángulo.

inicio

base

altura

area = base * altura

area

fin




15

1.4.2. Diagramas N-S (Nassi-Schneiderman)

Los diagramas Nassi-Schneiderman, denominados así por sus inventores, son herramientas deprogramación que favorece la programación estructurada y reúne características gráficas propias dediagrama de flujo y lingüísticas propias de los pseudocódigos. Consta de una serie de cajas contiguas quese leerán siempre de arriba-abajo y se documentarán de la forma adecuada.

En los diagramas N-S las tres estructuras básicas de la programación estructurada, secuencial, selectiva y

repetitiva, encuentran su representación propia.Ejemplo: Hallar el producto de varios números positivos introducidos por teclado y el proceso terminacuando se meta un número negativo.

inicio

p 1

leer num

mientras num >= 0

p p*num

leer num

escribir p

fin

1.4.3. Pseudocódigo

Es un lenguaje de especificación de algoritmos, pero muy parecido a cualquier lenguaje de programación,

por lo que luego su traducción al lenguaje es muy sencillo, pero con la ventaja de que no se rige por lasnormas de un lenguaje en particular. Nos centramos más en la lógica del problema.

El pseudocódigo también va a utilizar una serie de palabras clave o palabras especiales que va indicando loque significa el algoritmo.

algoritmo <identificador_algoritmo>// declaraciones, sentencias no ejecutables

inicio

// acciones, sentencias ejecutables tanto simples como estructuradasfin

• Comentarios. Sirven para documentar el algoritmo y en ellos se escriben anotaciones generalmentesobre su funcionamiento.

// comentario de una línea{ comentario que ocupa másde una línea }

• Palabras reservadas. Son las palabras que tienen un significado especial, como inicio y fin. En lugar delas palabras reservadas no deben usarse otras similares, aunque no se distingue entre mayúscula yminúsculas.

inicio, fin

si, entonces, si_no, fin_si

según_sea, hacer, fin_según




16

mientras, fin_mientras

desde, hasta, incremento, decremento, fin_desde, etc.

• Identificadores. Son los nombres que se dan a las constantes, variables, procedimientos u otrosobjetivos que manipula el algoritmo.

Ejemplo: Obtener el área de un rectángulo.

algoritmo area_rectanguloentero : base, altura, area

inicio

leer(base)leer(altura)area base * alturaescribir(area)

fin

Ejemplo: Hallar el producto de varios números positivos introducidos por teclado y el proceso terminacuando se meta un número negativo.

algoritmo producto_positivosentero : p, num

inicio

p 1leer(num) mientras (mun >= 0) hacer

p p * numleer(num)

fin_mientrasescribir(p)

fin




17

2. Estructura general de un programa

2.1. Estructura general de un algoritmo en pseudocódigo

El pseudocódigo es la herramienta más adecuada para la representación de algoritmos. El algoritmo enpseudocódigo debe tener una estructura muy clara y similar a un programa, de modo que facilite al máximo suposterior codificación. Interesa por lo tanto conocer las secciones en las que se divide un programa-.

• La cabecera. Contiene el nombre del programa.

• El cuerpo. Tiene a su vez 2 partes:

Bloque de declaraciones. Se definen o declaran las constantes con nombre, los tipos de datosdefinidos por el usuario y las variables.

Bloque de instrucciones. Contiene las acciones a ejecutar para la obtención de los resultados. Lasinstrucciones o acciones básicas a colocar en este bloque se podrían clasificar del siguiente modo:

o Inicio y fin. La primera instrucción de este bloque será siempre la de inicio y la última la de f in.

o Asignación. Dar un valor a una variable.

o Lectura / escritura. Introducir o sacar información por dispositivos E/S.

o Instrucciones de bifurcación. Alteran El orden de ejecución del programa. Salto a otra instrucciónque no es la siguiente.

// cabeceraalgoritmo <nombre_del_algoritmo>

// bloque de declaracionesconst

<listado_constantes>

var

<listado_variables>

entero : var1, var2

// bloque de instruccionesinicio // inicio del bloque de instrucciones

var1 0 // asignación

escribir(“ingresar un valor: ”) // escritura

leer(var2) // escritura

fin // fin del bloque de instrucciones

2.2. Operación de asignación

Es el modo de darle un valor a una variable, el cual puede ser una constante, otra variable o el resultado de unaexpresión.

En pseudocódigo la operación de asignación se representa mediante el símbolo u operador para laasignación.

En el contexto de un lenguaje de programación, a la operación de asignación, se le llama instrucción osentencia de asignación.




18

Comportamiento: Modifica el estado de la variable.

La notación algorítmica (sintaxis) que utilizaremos para la asignación es:

<nombre_de_variable> <constante_o_variable_o_expresión>

Ejemplo. Considerando la siguiente declaración de variables:

caracter : c1entero : ilógico : enc// a continuación se asignará a la variable c1 el carácter ‘a’c1 ‘a’// Luego de la asignación, el valor de enc es Verdaderoenc (1 > 0)// Luego de la asignación, el valor de i es 10i 5 + 15 div 3

Reglas de la asignación

Sea la expresión:

b c*2,45

• Una variable en el lado derecho de una sentencia de asignación debe tener un valor antes de que lasentencia de asignación se ejecute, en el ejemplo, a la variable c se le debe asignar un valor antes a fin deque la expresión c*2.45 arroje un resultado. Hasta que en el algoritmo a una variable no se le asigna(usando el operador = o a través de una lectura) se asume que no ha sido inicializada.

• En la izquierda de una sentencia de asignación sólo pueden existir variables y eventualmente unaconstante, por lo tanto la expresión ValorNeto – Tasa = Interes * 3,15 es un error.

2.2.1. Operación de lectura o entrada simple (leer)

La operación de lectura o de entrada permite leer determinados valores y asignarlos a determinadasconstantes o variables.

Almacena en una variable un valor extraído desde un dispositivo externo, del cual hacemos abstracciónaunque generalmente es el teclado.

Los datos de entrada se introducen en el computador mediante dispositivos de entrada (teclado, pantalla,unidades de disco, escáneres, entre otros). Los datos de salida pueden aparecer en un dispositivo de salida(pantalla, impresora, cornetas, entre otros).

Comportamiento: Cambia el valor en la variable en cuestión.

Luego de leer un valor de un dispositivo externo, el valor de la variable cambia en forma similar a si sehiciera una asignación y adopta el valor leído.

La notación algorítmica (sintaxis) que utilizaremos para la asignación es:leer(<Nombre_de_variable>)

Ejemplo, sean las variables:

entero : i caracter : c

Acciones de lectura:

leer(i)leer(c)

IzquierdaVariable a quien se asigna

Derecha

Expresión cuyo resultado se asigna

Operador de asignación




19

2.2.2. Operación de escritura o salida simple (escribir)

Transmite un valor (constante, variable o evaluación de una expresión) a un dispositivo externo (queharemos abstracción, aunque generalmente es el monitor) para ser mostrado al usuario.

Comportamiento: muestra resultados.

La notación algorítmica (sintaxis) que utilizaremos para la asignación es:

escribir(<Nombre_de_variable, constante_o_expresión>)

Ejemplo:

entero : ii 4// A la variable i se le asigna el valor 4escribir(“El valor de la variable i es: ” + (i + 1))// Luego de realizada la suma, se escribe el valor 5

Nota: los símbolos // (barra derecha barra derecha) se utilizarán para indicar un comentario en elpseudocódigo.

2.3. Conversión de tiposLa conversión de tipos es el proceso de cambiar un valor de un tipo de dato a otro. Por ejemplo, la cadena"1234" se puede convertir a un número entero, y a su vez, un tipo de dato real o entero se puede convertir altipo cadena.

Las conversiones de tipo pueden ser de ampliación o de restricción:

• Las conversiones de ampliación nunca producen desbordamiento y siempre son correctas, por ejemplo,convertir del tipo entero a un conjunto más grande como el tipo real,

• Las conversiones de restricción suponen una posible pérdida de información y pueden producir errores,por ejemplo, al convertir los datos reales a enteros, puede haber pérdida de información al eliminarse laparte decimal.

Ambos tipos de conversión pueden ser explícitas o implícitas.

Las conversiones con pérdida de información tienen lugar cuando el tipo de datos original no tiene un análogoen el tipo de destino de la conversión. Por ejemplo, la cadena "Pedro" no se puede convertir en un número. Enestos casos, algunos lenguajes de programación devuelven un valor predeterminado cuando se usa la funciónde conversión de tipo, por ejemplo el valor NaN o el número cero, indicando con estos valores que laconversión de tipos falló.

Algunos tipos de conversiones, como de una cadena a un número, tardan bastante tiempo. Cuantas menosconversiones utilice el programa, más eficaz será.

2.3.1. Conversión implícita

La mayoría de las conversiones, como la asignación de un valor a una variable, se producenautomáticamente. El tipo de datos de la variable determina el tipo de datos de destino de la conversión deexpresión. En otros casos, la conversión implícita viene dada tanto por los tipos de datos como por losoperadores utilizados.

2.3.2. Conversión explícita

Para convertir explícitamente una expresión a un tipo de datos concreto, se utilizan funciones que seasumen predefinidas y disponibles en el pseudocódigo, colocando entre paréntesis el dato, variable oexpresión que se va a convertir. Las conversiones explícitas requieren más escritura que las implícitas, pero




20

proporcionan más seguridad con respecto a los resultados. Además, las conversiones explícitas puedencontrolar conversiones con pérdida de información.

El comportamiento de la conversión explícita depende del tipo de datos originales y del tipo de datos dedestino.

En el ejemplo siguiente se muestra conversiones de datos implícitas y explícitas, usando valores entero,cadena, caracter y real.

// Se declaran las variables indicando su tipo de datoentero : ireal : dcaracter : ccadena : pal

// A la variable i se le asigna el valor entero 5i 5// A la variable real d se le asigna el entero 5,d i{ Hay conversión implícita de datos cambiando el valor a 5,0 porque d es

un real. }

// A la variable c se le asigna el carácter ‘a’c ‘a’pal “los árboles” + c{ A la variable pal se le asigna la unión de una cadena y un carácter,

aquí el operador + significa concatenación y no la suma algebraica. }

i aEntero(d){ El valor de la variable d es convertido explícitamente de real a

entero, asignando a la variable i, la parte entera del valor de d (5 enlugar de 5,0) }

c aCaracter(i){ Se convierte explícitamente el tipo de dato de la variable i,

transformando el valor entero 5 al carácter ‘5’ }

2.4. Contadores

Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad constante cada vez quese produce un determinado suceso o acción. Los contadores se utilizan en estructuras repetitivas con lafinalidad de contar sucesos o acciones internas del bucle.

Con los contadores se debe realizar una operación de inicialización y, posteriormente, las sucesivas deincremento o decremento del contador.

La inicialización consiste en asignarle al contador un valor. Se situará antes y fuera del bucle.

<nombre_del_contador> <valor_de_inicialización>

En cuanto a los incrementos o decrementos del contador, puesto que la operación de asignación admite que lavariable que recibe el valor final de una expresión intervenga en la misma, se realizarán a través de este tipo deinstrucciones de asignación, de la siguiente forma:

<nombre_del_contador> <nombre_del_contador> + <valor_constante>

dicho <valor_constante> podrá ser positivo o negativo. Esta instrucción se colocará ene el interior del bucle.




21

2.5. Acumuladores

Son variables cuyo valor se incrementa o decrementa en una cantidad determinada. Necesitan operaciones de:

• Inicialización:

<nombre_del_acumulador> <valor_de_inicialización>

•

Acumulación:<nombre_del_acumulador> <nombre_del_acumulador> + <nombre_variable>

Hay que tener en cuenta que la siguiente también sería una operación de acumulación:

<nombre_del_acumulador> <nombre_del_acumulador> + <valor>

2.6. Interruptores

Un interruptor o bandera (switch) es una variable que puede tomar los valores verdad y falso a lo largo de laejecución de un programa, comunicando así información de una parte a otra del mismo. Pueden ser utilizadospara el control de bucles y estructuras de selectivas. En este caso también es frecuente que la variable querecibe el valor final de una expresión intervenga en la misma, por ejemplo:

En primer lugar el interruptor se inicializa a verdad o falso

<nombre_del_interruptor> <valor_de_inicialización>

En determinadas condiciones el interruptor conmuta

<nombre_del_interruptor> no <valor_del_interruptor>




22

3. Estructura general de un programa

3.1. Programación estructurada

La programación estructurada es un conjunto de técnicas para desarrollar algoritmos fáciles de escribir,verificar, leer y modificar. La programación estructurada utiliza:

• Diseño descendente. Consiste en diseñar los algoritmos en etapas, yendo de los conceptos generales alos de detalle. El diseño descendente se verá completado y ampliado con el modular.

• Recursos abstractos. En cada descomposición de una acción compleja se supone que todas las partesresultantes están ya resueltas, posponiendo su realización para el siguiente refinamiento.

• Estructuras básicas. Los algoritmos deberán ser escritos utilizando únicamente tres tipos de estructurasbásicas (secuencial, selectiva, repetitiva).

Para que la programación sea estructurada, los programas han de ser propios. Un programa se define comopropio si cumple las siguientes características:

• Tiene un solo punto de entrada y uno de salida.

• Toda acción del algoritmo es accesible, es decir, existe al menos un camino que va desde el inicio hasta elfin del algoritmo, se puede seguir y pasa a través de dicha acción.

• No posee lazos o bucles infinitos.

3.2. Estructura secuencial

Consiste en presentar un conjunto de instrucciones en un orden. Las instrucciones se realizan en el mismoorden en que son escritas. El símbolo; se utiliza para separar una instrucción de otra.

<instrucción 1>

<instrucción 2>...<instrucción n>

Comportamiento. Representa las acciones del algoritmo y el orden en que se realizarán.

Las instrucciones (<instrucciones 1> a la <instrucciones n>) no solo tienen que ser operacionesbásicas, también pueden ser llamadas a acciones o funciones que realizan un procedimiento, estructuras decontrol de programa (selección y repetición), las cuales serán explicadas en próximos temas.

Ejemplo:

algoritmo ejemplo{ Secuenciamiento de instrucciones que inicializa un número, lo incrementa en 1y lo eleva a la 5ta potencia }

varentero : i

inicio

i 1 // en este momento i tiene el valor de 1 i i + 1 // en este momento i tiene el valor de 2i i ** 5 // en este momento i tiene el valor de 32escribir(“El valor fin de la variable i es: ” + i) // se escribe un mensaje

fin // Fin de la secuencia de instrucciones




23

3.3. Estructura selectiva

Una estructura selectiva es aquella en que se ejecutan unas acciones u otras según se cumpla o no unadeterminada condición.

3.3.1. Simple

En el condicional simple se evalúa la condición y si ésta da como resultado verdad se ejecuta unadeterminada acción o grupo de acciones; en caso contrario se saltan dichos grupos de acciones.

Recomendación.: utilizar indentación o sangría para mostrar los niveles de anidación en las instrucciones.

si <condición> entonces acción

fin_si

condiciónno si

acción

3.3.2. Doble

Cuando el resultado de evaluar una condición es verdad se ejecutará una determinada acción o grupo deacciones y si el resultado es falso se ejecutará otra acción o grupo de acciones diferentes.

Recomendación: utilizar indentación o sangría en los algoritmos y códigos.

si <condición> entonces acción 1

si_no

acción 2fin_si

condición

no si

acción 1acción 2




24

3.3.3. Múltiple

Se evalúa una condición o expresión que puede tomar n valores. Según el valor que la expresión tenga encada momento se ejecutan las acciones correspondientes al valor.

Las acciones asociadas al valor si_no se ejecutan cuando la expresión no toma ninguno de los valores queaparecen antes.

El valor con el que se compara la expresión, va a depender de los lenguajes, de lo que sea ese valor. En

general ese valor puede ser un valor constante, un rango de valores o incluso otra condición.según_sea <expresión> hacer

<lista1> : acción 1<lista2> : acción 2

...[ si_no

acción ]fin_según

expresión

lista1

no

acción

acción 1 acción 2

lista2

3.4. Estructura repetitiva

Un bucle, lazo, ciclo o loop (en inglés) es un segmento de algoritmo o programa (una secuencia deinstrucciones) que se repiten un determinado número de veces mientras se cumple una determinada condición,en otras palabras, un bucle o ciclo es un conjunto de instrucciones que se repiten mientras una condición esverdadera o existe.

A cada repetición del conjunto de acciones se denomina iteración.

Para que un bucle no se repita indefinidamente debe tener una condición de parada o de fin. Esta condición deparada o de fin se verifica cada vez que se hace una iteración. El ciclo llega a su fin cuando la condición deparada se hace verdadera.

La condición de parada puede estar al principio de la estructura repetitiva o al final.

Al igual que las estructuras de selección simple o compuesta, en un algoritmo pueden utilizarse varios ciclos.Estos ciclos pueden ser independientes (una a continuación de otro) o anidados (ciclos dentro de ciclos).

Para representar los bucles o lazos utilizaremos en el curso las estructuras de control Mientras, Hacer-mientras, Repetir-hasta y Desde.




25

Los ciclos o procesos repetitivos de instrucciones son procedimientos fundamentales en el uso de lascomputadoras y por lo tanto en muchos algoritmos y programas.

Vamos a utilizar ciclos cuando:

• Necesitemos repetir instrucciones un determinado número de veces, mientras se cumpla una condición,mientras un hecho sea verdadero o hasta cuando se alcance un determinado valor o condición.

• Cuando necesitemos contar un determinado número de elementos o de acciones, por ejemplo contar las

sílabas de un texto, los elementos de una secuencia que verifican una determinada condición o contar elnúmero de personas que cumplen ciertas características. En este caso se incluirán contadores dentro delbucle.

• Los contadores son variables (generalmente de tipo entero) que tienen un valor inicial y que se incrementano decrementan en un valor constante cada vez que ocurre una iteración. Cuando los contadores sedecrementan se habla de descontar, en lugar de contar.

• También usaremos ciclos cuando necesitemos acumuladores determinados valores cada vez que se realizauna iteración. Los acumuladores también son variables (generalmente de tipo entero, real o cadena), quealmacenan valores variables resultantes de las operaciones que se realizan en cada ciclo.

• Por ejemplo, podemos usar para ir sumando los precios de varios vehículos y luego calcular el preciopromedio general (con una variable acumulador de tipo real), para calcular la potencia o el factorial de unnúmero a través de multiplicaciones sucesivas (un acumulador de tipo entero o real) o para ir agregando auna cadena de caracteres, letras o sílabas que construirán un mensaje (una variable acumulador del tipocadena)

3.4.1. Mientras

Es una estructura iterativa que permite verificar la condición de entrada al ciclo antes del cuerpo deinstrucciones a repetir.

Como la evaluación de la condición de entrada se realiza al inicio del bloque Mientras, puede ocurrir que lasinstrucciones del ciclo no se realicen ni siquiera 1 vez, a diferencia del Repetir-hasta, donde el bloque deinstrucciones se realiza al menos 1 vez porque la condición de parada se verifica al final. Las instruccionesdel Mientras se pueden realizar 0 o más veces antes de que se cumpla la condición de terminar el ciclo.

El conjunto de instrucciones dentro del Mientras se ejecuta cuando la condición de entrada del principio secumple (es verdadera). Dicho de otro modo, el ciclo de instrucciones dentro del Mientras se va a detenercuando la condición se haga falsa.

Se recomienda usar la estructura Mientras tienes que verificar la condición de entrada al inicio y si secumple, entonces, entrar al ciclo y realizar sus instrucciones.

mientras <expresión_lógica> hacer

acción

fin_mientras

condición

no

si

acción




26

3.4.2. Hacer-mientras

El bucle Hacer-mientras es análogo al bucle Mientras desde el punto de vista de que el cuerpo del bucle seejecuta una y otra vez mientras la condición es verdadera. La diferencia entre ellos consiste en que lassentencias del cuerpo del bucle Hacer-mientras, se ejecutan al menos una vez antes que se evalúe laexpresión lógica.

hacer

acción mientras <expresión_lógica>

condiciónnosi

acción

3.4.3. Repetir-hasta

Ejecuta un bloque de instrucciones varias veces hasta que se cumple la condición que es verificada al finaldel bucle.

Las instrucciones dentro del ciclo Repetir-hasta se van a realizar mientras la condición de parada evaluadaal final sea falsa. Dicho de otro modo, el ciclo se va a detener cuando la condición de parada se hagaverdadera.

Se recomienda usar la estructura Repetir-hasta cuando las instrucciones del ciclo se pueden realizar al

menos 1 vez antes de comprobar la condición de parada.repetir

acciónhasta_que <expresión_lógica>

condiciónsino

acción

3.4.4. Desde

Es una estructura iterativa que es controlada por una variable (llamada también variable índice), la cual seincrementa o decrementa hasta llegar a un valor límite o valor final que representa la condición de parada.




27

La estructura Desde comienzan con un valor inicial de la variable índice, las acciones especificadas para elciclo se ejecutan un número determinado de veces, a menos, que el valor inicial de la variable índice seamayor que el valor límite que se quiere alcanzar.

El incremento o decremento de la variable índice suele ser de 1 en 1, salvo cuando se indica lo contrario. Lavariable índice suele ser de tipo entero y se utilizan comúnmente nombres como i, j o k (no importa si enmayúsculas o minúsculas)

Se recomienda usar la estructura Desde cuando se conoce el número de veces que se deben ejecutar las

instrucciones del ciclo, es decir, en los casos en que el número de iteraciones es fijo y conocido.desde v v1 hasta vf [incremento | decremento incr] hacer

acciónfin_desde

condición

si

no

acciónincremento o

decremento

valor_inicial

3.4.5. ObservacionesObserva que para el Mientras, Hacer-mientras y Repetir-hasta se debe incluir en el cuerpo deinstrucciones una acción donde se actualice la o las variables que usas en la condición de parada. Por elcontrario, en el Desde no es necesario incluir esta instrucción dado que en el encabezado de la instrucciónya se incluye el incremento.

Comparación de bucles

• Mientras. El uso más frecuente es cuando la repetición no está controlada por contador; la condiciónprecede a cada repetición del bucle; el cuerpo del bucle puede no ser ejecutado. Se debe utilizar cuandose desea saltar el bucle si la condición es falsa.

• Desde. Bucle de conteo, cuando el número de repeticiones se conoce por anticipado y puede sercontrolado por un contador; la condición precede a la ejecución del cuerpo del bucle.

• Hacer-mientras y repetir-hasta. Es adecuada para asegurar que al menos se ejecuta el bucle una vez.

3.5. Estructura anidada

Tanto las estructuras selectivas como los bucles se pueden anidar unos dentro de otros.




28

3.5.1. Anidación de condicionales

La ventaja de anidar sentencias condicionales, es que cuando una se cumple no hay por que mirar a las queestán debajo. Tenemos que tratar anidar la condición en la parte si_no en vez que en la parte entonces.

si <condición 1> Entonces

acción 1

si_no si <condición 2> entoncesacción 2si_no si <condición 3> entonces

acción 3fin_si

fin_sifin_si

El case siempre equivale a una anidación de condicionales, pero no al revés.

3.5.2. Bucles anidados

Al igual que podemos colocar unas expresiones dentro de otras, unos bucles pueden estar dentro de otros,pero nunca pueden cruzarse. Al anidar bucles hay que tener en cuenta que el bucle mas interno funciona

como una sentencia mas del bloque mas externo y por tanto en cada iteración del bucle mas externo se vana ejecutar todas las iteraciones del bucle mas interno por cada iteración del mas externo.

Si el bucle mas externo se repite n veces y el mas interno se repite m veces, si por cada iteración del másexterno se repite el más interno, el número total de iteraciones será m*n.

Los bucles que se anidan pueden se de igual o distinto tipo.

desde i 1 hasta 8 hacer

desde j 1 hasta 5 hacer

escribir(“Profesor” + i + “introduzca su asignatura nº” + j)leer(asignatura)

fin_desdefin_desde




29

4. Subalgoritmos, funciones y procedimientos

4.1. Programación modular

Se basa en dividir el programa en partes llamadas módulos, que se analizan y codifican de forma independientey que realizan una determinada tarea que será en realidad una parte del problema total a resolver.

Cuando se trabaja de este modo, existirá un algoritmo principal o conductor que transferirá el control a losdistintos módulos o subalgoritmos, los cuales, cuando terminen su tarea, devolverán el control al algoritmo quelos llamó. Los módulos o subalgoritmos deben ser pequeños, seguirán todas las reglas de programaciónestructurada y podrán ser representados con las herramientas de programación habituales.

El empleo de esta técnica facilita notoriamente el diseño de los programas. Algunas de las ventajassignificativas son:

• Varios programadores podrán trabajar simultáneamente en la confección de un algoritmo, repartiéndose lasdistintas partes del mismo, ya que los módulos son independientes.

• Se podrá modificar un módulo sin afectar a los demás.

• Las tareas, subalgoritmos, sólo se escribirán una vez, aunque se necesiten en distintas ocasiones en elcuerpo del programa.

Existen dos tipos de subalgoritmos: funciones y procedimientos.

4.2. Funciones

Desde el punto de vista matemático, una función es una operación que toma uno o varios operandos y devuelveun resultado. Desde el punto de vista algorítmico, es un subalgoritmo que toma uno o varios parámetros comoentrada y devuelve, a la salida, un único resultado.

Como el resultado de la función es retornado al algoritmo principal, debe usarse una variable para almacenar

este resultado, es decir, en una variable del algoritmo principal se “captura” el valor retornado por la función.Luego el valor almacenado en la variable puede ser utilizado por el algoritmo que llama a la función.

4.2.1. Declaración de una función

La estructura de una función es semejante a la de cualquier algoritmo. Tendrá una cabecera (con el nombrey los parámetros) y un cuerpo (con la declaración de los parámetros de la función y las instrucciones).

<tipo_de dato> función <nombre_función> (lista_de_parámetros_formales)[ var

declaraciones_locales ]inicio

acciones

devolver(<expresión

>)fin_función

La lista de parámetros es la información que se le tiene que pasar a la función. Los parámetros, luego dentrode la función, los podemos utilizar igual que si fueran variables locales definidas en la función y para cadaparámetro hay que poner su nombre y tipo.

El nombre de la función lo da al usuario y tiene que ser significativo. En las variables locales se declaran las variables que se pueden usar dentro de la función.

Entre las acciones, tendrá que existir entre ellas una del tipo devolver(<expresión>). Esta sentenciapondrá fin a la ejecución de la función y devolverá el valor de la función, es decir, como valor asociado al




30

nombre de mismo tipo que el tipo de datos que devuelve a la función, este valor por tanto tiene que ser delmismo tipo que el tipo de datos que devuelve la función, que es el que habremos indicado al declarar lafunción en la parte final de la cabecera.

No se permiten funciones que no devuelvan nada.

Los parámetros que aparecen en la declaración de la función se denominan parámetros formales, y losparámetros que se utiliza cuando se llama a la función se denominan parámetros actuales o reales.

4.2.2. Llamado de una función

Para llamar a una función se pone el nombre de la función, y entre paréntesis los parámetros reales, quepodrán ser variables, expresiones, constantes, etc., pero siempre del mismo tipo que los parámetrosnormales asociados.

<nombre_funcion>( parámetros_actuales)

La función puede ser llamada desde el algoritmo principal o desde cualquier otro subalgoritmo.

Para llamar a la función desde cualquier parte, implica el conocimiento previo de que ésta función existe.

A través de los parámetros reales de la llamada se proporciona a la función la información que necesita,para ello, al hacer la llamada lo que se produce es una asociación automática entre parámetros reales yparámetros formales. Esta asociación se realiza según el orden de la aparición y de izquierda y derecha.

La llamada a una función, siempre va a formar parte de una expresión, de cualquier expresión en la que enel punto en la que se llama a la función, pudiera ir colocado cualquier valor del tipo de datos que devuelve lafunción, esto se debe a que el valor que devuelve una función esta asociado a su nombre.

Ejemplo:

real función mitad(E entero : n) var

real : m inicio

m n / 2devolver(m)

fin_función

algoritmo calcular_mitadvar

entero : numinicio

escribir(“Introduce un número para hallar su mitad”)leer(num)escribir(“La mitad de ” + num + “ es ” + mitad(num))

fin

4.3. Procedimientos

La definición de procedimientos permite asociar un nombre a un bloque de instrucciones. Luego podemos usarese nombre para indicar en algún punto de un algoritmo que vamos a utilizar ese bloque de instrucciones, perosin tener la necesidad de repetirlas, sólo invocando al procedimiento por su nombre.

Los procedimientos se caracterizan por no retornar valores al algoritmo que las llama. Sin embargo, aunque losprocedimientos no retornan valores, si pueden informar al algoritmo que las llamó (a veces llamado algoritmoprincipal) de cambios realizados por sus instrucciones en algunos valores a través de una herramienta que sellama pase de parámetros. Los parámetros permiten utilizar la misma secuencia de instrucciones con diferentesdatos de entrada. Utilizar parámetros es opcional.




31

Cuando entre las instrucciones de un algoritmo vemos el nombre de un procedimiento, decimos que estamosllamando o invocando al procedimiento.

Los procedimientos facilitan la programación modular, es decir, tener bloques de instrucciones que escribimosuna vez pero que podemos llamar y utilizar muchas veces en varios algoritmos. Una vez terminada la ejecuciónde un procedimiento, se retorna el control al punto de algoritmo donde se hizo la llamada, para continuar susinstrucciones.

4.3.1. Declaración de procedimientos

La declaración de un procedimiento es similar a la de una función. Las pequeñas deferencias son debidas aque el nombre del procedimiento no se encuentra asociado a ningún resultado. La declaración de unprocedimiento expresado en pseudocódigo es:

procedimiento <nombre_procedimiento> (lista_de_parámetros_formales)[ var


accionesfin_procedimiento

Los parámetros que aparecen en la declaración del procedimiento se denominan parámetros formales, y los

parámetros que se utiliza cuando se llama al procedimiento se denominan parámetros actuales o reales.

4.3.2. Llamado de un procedimiento

Para llamar a un procedimiento se realiza con una instrucción llamar_a o bien directamente con el nombredel procedimiento.

[ llamar_a ] <nombre_procedimiento>[( parámetros_actuales)]

El procedimiento puede ser llamado desde el algoritmo principal o desde cualquier otro subalgoritmo.

Ejemplo:

procedimiento mitad(E entero : n) var

real : m inicio

m n / 2escribir(“La mitad de ” + n + “ es ” + m)

fin_procedimiento

algoritmo calcular_mitadvar

entero : numinicio

escribir(“Introduce un número para hallar su mitad”)leer(num)llamar_a mitad(num)

fin

4.3.3. Diferencias entre funciones y procedimientos:

• Una función devuelve un único valor y un procedimiento puede devolver 0, 1 ó N (a través de losparámetros).

• Ninguno de los resultados devueltos por el procedimiento se asocian a su nombre como ocurría con lafunción.

• Mientras que la llamada a una función forma siempre parte de una expresión, la llamada a unprocedimiento es una instrucción que por sí sola no necesita instrucciones.




32

4.4. Estructura general de un algoritmo

Aunque algunos lenguajes de programación exigen que los procedimientos y funciones se escriban antes derealizar la llamada, por claridad en la escritura del pseudocódigo se escriben después del algoritmo principal.

// cabeceraalgoritmo <nombre_del_algoritmo>

// bloque de declaracionesconst

<nombre_constantes> = valor1var

<nombre_del_tipo> : <nombre_de_la_variable1> [, <nombre_de_la_variable2>, ... ]

// bloque de instruccionesinicio // inicio del bloque de instrucciones

acción 1acción 2

[ llamar_a ] <nombre_procedimiento>[( parámetros_actuales)]

{ la llamada a la función debe realizarse en una expresión bloque deinstrucciones }escribir(<nombre_funcion>( parámetros_actuales))...acción N

fin // fin del bloque de instrucciones

<tipo_de dato> función <nombre_función> (lista_de_parámetros_formales)[ var


accionesdevolver(<expresión>)

fin_función

procedimiento <nombre_procedimiento> (lista_de_parámetros_formales)[ var


accionesfin_procedimiento

4.5. Parámetros de los subalgoritmos

4.5.1. Tipo de parámetrosLas funciones y procedimientos manejan dos tipos de parámetros:

• Actuales. Son los valores indicados en la llamada a la función o procedimiento en el algoritmo principal.Son los valores que se desean pasar desde el algoritmo principal a las instrucciones de la función oprocedimiento.

• Formales. Son los nombres dados a los parámetros en la definición formal de la función oprocedimiento. Con estos nombres se conocerán a los valores de los parámetros dentro de la función oprocedimiento y funcionan como variables locales dentro de ellos.




35

5. Tipos de datos estructurados

5.1. Datos estructurados

Es una herramienta mediante la cual es posible almacenar datos en la memoria del computador, permitiendoguardar datos conformados por varios elementos y manipularlos en forma sencilla. Estas estructuras de datosestán formadas por más de un elemento, estos pueden ser todos del mismo tipo de dato (ED u homogéneacomo los arreglos y los archivos) o de tipos de datos diferentes (ED heterogénea, como los registros y losobjetos).

Los datos de tipo estándar pueden ser organizados en diferentes estructuras de datos: estáticas y dinámicas.

Estructuras de datos estáticas

• Arreglos

• Registros

• Cadenas

• Conjuntos• Archivos

Estructuras de datos dinámicas

• Listas

• Árboles

• Grafos

5.2. ArreglosEstructuras de datos conformada por una sucesión de celdas, que permite almacenar en la memoria principaldel computador un conjunto finito de elementos (hay un número máximo conocido) que tienen el mismo tipo dedato (son homogéneos).

Para hacer referencia a cualquiera de las celdas del arreglo es necesario el nombre del arreglo y el valor de unode los elementos perteneciente al conjunto de índices asignado, lo que permite tener acceso aleatorio.

5.2.1. Características básicas de los arreglos

• Homogéneo: los elementos del arreglo son todos del mismo tipo de dato.

• Ordenado: cada elemento del arreglo puede ser identificado por el índice que le corresponde. El índice

no es más que un entero que pertenece a un intervalo finito y determina la posición de cada elementodentro del arreglo.

• Acceso secuencial o directo: El acceso a cada elemento del arreglo se realiza recorriendo losanteriores según el orden en que están almacenados o de manera directa (operación selectora),indicando el valor del índice del elemento requerido.

• Sus elementos son tratados como variables simples: Una vez seleccionado algún elemento delarreglo este puede ser utilizado en acciones de asignación, como parte de expresiones o comoparámetros al llamar a acciones o funciones como si se tratara de una variable del tipo de dato simpledeclarado para todos los elementos del arreglo.




36

• Uso de índice: El índice es un valor de tipo entero (número entero o carácter con un código enteroequivalente) que determina la posición de cada elemento en el arreglo. La cantidad de índices determinalas dimensiones del arreglo. Así un arreglo unidimensional tiene un índice, un arreglo bidimensional tienedos índices y uno n-dimensional tiene n índices.

5.2.2. Vectores (arreglos unidimensionales)

Tipos de Datos Estructurados (TDE) donde todos sus elementos pertenecen al mismo tipo y existe unacorrespondencia uno a uno de cada elemento con un subconjunto de los enteros (índices).

1 2 3 ... n-1 n ← índice

“ser” “hola” “oh” “ojo” “casa” “bien” ← contenido celda

Declaración de arreglos unidimensionales

• Declaración por variable. se declara la variable tipo arreglo como si se tratara de una variable de tipode dato simple.

La sintaxis a utilizar será:

var

array [<limite_inf>..<limite_sup>] de <tipo_de_dato> : <nombre_del_vector>

Ejemplo:

constn = 51

vararray [1..5] de entero : arregloAarray [0..20] de real : arregloB, arregloCarray [7..14] de lógico : arregloDarray [-6..n] de caracter : arregloE

• Declaración por tipo: se realiza en dos pasos, se declara el arreglo como un nuevo tipo de dato y se leasigna ese tipo a una o más variables.

La ventaja de esta clase de declaración reside en que no es necesario repetir todos los datos del arreglocada vez que se necesite uno, sino que se utilizan tantas variables como arreglos se necesiten y ademássimplifica la escritura del algoritmo.

Para declarar un tipo, sólo hace falta anteceder a la especificación la palabra clave Tipo


tipo

array [<limite_inf>..<limite_sup>] de <tipo_de_dato> : <nombre_del_tipo> var

<nombre_del_tipo> : <nombre_del_vector>

Ejemplo:

const

n = 51tipo

array [1..5] de entero : vectorAarray [0..20] de real : vectorBarray [7..14] de lógico : vectorCarray [-6..n] de caracter : vectorD




37

var

vectorA : arregloAvectorB : arregloB, arregloCvectorC : arregloDvectorD : arregloE

El número de elementos del vector vendrá dato por la fórmula:

<limite_sup> - <limite_inf> + 1

5.2.3. Arreglos bidimensionales (matrices o tablas)

Un arreglo bidimensional (tabla o matriz) es un arreglo que tiene dos índices. Para localizar o almacenar unvalor en el arreglo se deben especificar dos subíndices (dos posiciones), uno para la fila y otro para lacolumna. Los diferentes tipos de índices no necesitan ser subrangos del mismo tipo.

1 2 ... . j

1 m[1, 1] m[1, 2] ... . ... .

2 m[2, 1] m[2, 2] ... . ... .

... . ... . ... . ... . ... .

i ... . ... . ... . m[i, j]

Declaración de arreglos bidimensionales

Al igual que en los arreglos unidimensionales, los arreglos bidimensionales también se pueden crear condeclaraciones de variable o de tipo, el cambio, es que se debe indicar dos intervalos de índices: uno para lasfilas y otro para las columnas. Estos intervalos o subrangos no tienen que ser de la misma dimensión.

• Declaración por variable


vararray [li..ls, li..ls] de <tipo_de_dato> : <nombre_de_la_matriz>

Ejemplo:

const

n = 51 m = 28

vararray [1..5, 1..6] de entero : arregloAarray [0..20, 0..3] de real : arregloB, arregloCarray [7..14, 1..5] de lógico : arregloDarray [-6..n, m..n] de caracter : arregloE

• Declaración por tipo


tipoarray [li..ls, li..ls] de <tipo_de_dato> : <nombre_del_tipo>

var

<nombre_del_tipo> : <nombre_de_la_matriz>

Ejemplo:

const

n = 51 m = 28

tipoarray [1..5, 1..6] de entero : matrizA




38

array [0..20, 0..3] de real : matrizBarray [7..14, 1..5] de lógico : matrizCarray [-6..n, m..n] de caracter : matrizD

var

matrizA : arregloAmatrizB : arregloB, arregloCmatrizC : arregloD

matrizD : arregloE

5.2.4. Recorrido de todos lo elementos del arreglo

Esta operación se realiza cuando se utiliza una estructura de control iterativa para tratar todos y cada uno delos elementos del arreglo de acuerdo al orden en que se almacenan. El tratamiento es el mismo para todo elarreglo, y se aplica tanto cuando se desea leer el arreglo, buscar un elemento en un arreglo, listar todo elcontenido del mismo, y muchos otros.

El recorrido puede ser de manera ascendente (el más utilizado), partiendo del límite inferior hasta el superiore incrementando en uno; o de manera descendente, partiendo del límite superior hasta el inferior ydecrementando en uno.

La estructura de control desde es la más conveniente para realizar de manera el recorrido, indicando solo el

limite inferior y superior, pues el incremento en uno del índice es automático. Sin embargo, si existieraalguna condición adicional o si se necesita usar una condición lógica para finalizar el recorrido, no basta conllegar al límite superior del índice, hay que cambiar de la estructura iterativa desde, y utilizar un mientras oun repetir.

• Recorrido por filas

Supuestas las siguientes declaraciones:

constf = <valor1>c = <valor2>

tipoarray [1..f, 1..c] de real : matriz

var

matriz : m

y que todos los elementos de la matriz contienen información válida, escribir el pseudocódigo que sevisualice en primer lugar el contenido de los elementos de la primera fila, a continuación el contenido dela segunda, etc.

desde i 1 hasta f hacer

desde j 1 hasta c hacer

escribir([i, j])fin_desde

fin_desde

• Recorrido por columnas

Tal y como aparece a continuación, se mostrará el contenido de los elementos de la primera columna,

luego el de la segunda, etc.desde j 1 hasta c hacer

desde i 1 hasta f hacer

escribir([i, j])fin_desde

fin_desde

Para recorrer los elementos de una matriz de n dimensiones, se utilizará n estructuras repetitivasanidadas.




39

5.2.5. Arreglos como parámetros

Los arreglos podrán ser pasados como parámetros, tanto a procedimientos como a funciones. Para ellos sedebe declarar algún parámetro formal del misto tipo que el arreglo que constituye el parámetro actual.

Ejemplo:

algoritmo paso_de_arreglos

constf = 5c = 7

tipoarray [1..f, 1..c] de real : arr

var

arr : aentero : b...

inicio ...b recibeArreglo(a)...

fin

entero función recibeArreglo(E arr: m)// Los parámetros actuales y los formales no necesitan coincidir en el nombreinicio

...

...fin_función

5.3. Registros

Estructura de datos formada por una colección finita de elementos llamados campos, no necesariamentehomogéneos (del mismo tipo) y que permiten almacenar una serie de datos relacionados entre sí bajo unnombre y una estructura común.

5.3.1. Características básicas de los registros

• Permiten almacenar un grupo de elementos bajo un nombre y un estructura común

• Los elementos (campos) de un registro no tienen que ser homogéneos, de hecho, generalmente son dediferentes tipos

• No están disponibles en todos los lenguajes de programación, razón por la cual muchas veces esnecesario simularlo o definirlo.

• Cada campo del registro se comporta como una variable simple, de manera que puede ser usado en unaexpresión de asignación, como parte de otra expresión, en operaciones o como parámetro al invocar unaacción o función.

5.3.2. Declaración de registros

• Declaración por variable. se declara la variable de tipo registro identificándola a través de su nombre,se indica la estructura del registro suministrando la definición de sus campos mediante sus tipos de datoy sus nombres

La sintaxis a utilizar para declarar un registro será:




40

var

registro : <nombre_de_la_variable><tipo_de_dato1> : <nombre_de_campo1> [,<nombre_de_campo1>] [...]<tipo_de_dato1> : <nombre_de_campo1> [,<nombre_de_campo1>] [...]<tipo_de_dato1> : <nombre_de_campo1> [,<nombre_de_campo1>] [...]

fin_registro

• Declaración por tipo: Al igual que con los arreglos, para declarar un tipo de registro definido por el

usuario, se antecede a la especificación la palabra clave Tipo y luego se definen las variables del tipo. Eluso de la declaración por tipo facilita la declaración de variables con una estructura común, así como elpase de parámetros.

tiporegistro : <nombre_del_tipo>

<tipo_de_dato1> : <nombre_de_campo1> [,<nombre_de_campo1>] [...]<tipo_de_dato1> : <nombre_de_campo1> [,<nombre_de_campo1>] [...]<tipo_de_dato1> : <nombre_de_campo1> [,<nombre_de_campo1>] [...]

fin_registro

Para declarar una variable de tipo registro:

var

<nombre_del_tipo> : <nombre_de_la_variable>

Para acceder a un determinado campo de un registro se utilizará, como suelen emplear la mayoría de loslenguajes el nombre de la variable del tipo de registro unido por un punto al nombre del campo.

<nombre_de_la_variable>.<nombre_de_campo1>

Si los campos del registro fueran a su vez otros registros habrá que indicar:

<nombre_de_la_variable>.<nombre_de_campo1>.<nombre_de_campo_de_campo1>

Los datos de tipo registro se pueden pasar como parámetros tanto a procedimientos como a funciones.

5.3.3. Arreglos de registros

Los elementos de un arreglo pueden ser de cualquier tipo, por lo tanto es posible la construcción de arreglos

de registros. Nombre ..Edad.. ..Edad..

“Ana” 28 a[1]

“Carlos” 36 a[2]

... ... ...

“Juan” 34 n[n]

Para acceder al campo nombre del 2do elemento del arreglo a se escribiría a[2].nombre. Por ejemplo:

escribir(a[2].nombre)

presentaría en consola la cadena Carlos.

5.4. Cadenas de caracteres

Es un conjunto de 0 ó más caracteres. Entre estos caracteres puede estar incluido el blanco.

En pseudocódigo, el blanco es el b. Las cadenas de caracteres se delimitan con dobles comillas “ ”, pero enalgunos lenguajes se delimitan con ‘ ’.

Las cadenas de caracteres se almacenan en posiciones contiguas de memoria.




41

La longitud de una cadena es el número de caracteres de la misma. Si hubiese algún carácter que se utilizaracomo especial para señalar el fin de cadena, no se consideraría en la longitud.

Si una cadena tiene longitud 0, la llamamos cadena nula por lo que no tiene ningún carácter, pero esto noquiere decir que no tenga ningún carácter válido, por que puede haber algún carácter especial no imprimibleque forme parte de la cadena.

Una subcadena es una cadena extraída de otra.

5.4.1. Datos de tipo caracter

• Constantes. Una constante de tipo cadena es un conjunto de 0 o más caracteres encerrados entre “ ”.

Si dentro de la cadena quiero poner como parte de la cadena las “, las pongo 2 veces. Esto depende dellenguaje.

“Hola””Adios” Hola”Adios

Una constante de tipo carácter es un solo carácter encerrado entre comillas simples.

• Variables. Hay que distinguir entre una variable de tipo carácter y una variable de tipo cadena, elcontenido de una variable de tipo cadena es un conjunto de 0 ó más caracteres encerrados entre “ ”,mientras que una variable de tipo carácter es un solo carácter encerrado entre ‘ ’.

5.4.2. Formas de almacenamiento de cadenas en memoria

• Almacenamiento estático. La longitud de la cadena se tiene que definir antes de ser usada y siempreva a tener esa longitud, almacenándose en posiciones contiguas de memoria. Si la cadena no ocupatodo el espacio, el resto se rellena con blancos, y esos blancos se consideran parte de la cadena. Estoes muy deficiente y no se usa casi en ningún lenguaje.

• Almacenamiento semiestático. Antes de usar la cadena, hay que declarar la longitud máxima quepuede tener y ese es el espacio que se reserva en memoria para almacenar la cadena, siempre enposiciones contiguas. La longitud real de la cadena durante la ejecución puede variar aunque siempretiene que ser menor que el máximo de la cadena.

• Almacenamiento dinámico. No hay que definir la longitud de la cadena antes de usarla, ni siquiera lamáxima. Para esto, se utiliza la memoria dinámica, y para establecer el número de elementos de lacadena usaremos listas enlazadas en las que cada nodo de la lista contara un carácter de la cadena y seenlazaría mediante punteros. La información no tiene que estar almacenada en posiciones contiguas dememoria.

5.4.3. Operaciones con cadenas

Al igual que con cualquier tipo de datos, podemos hacer operaciones de entrada y salida (leer y escribir).

varcadena : cad

...leer(cad)

escribir(cad) Aparte de estas instrucciones, la mayor parte de los lenguajes permiten realizar operaciones especiales conlas variables de tipo cadena. La mayor parte de los lenguajes tienen operaciones de tratamiento de cadenas,y esas operaciones vienen en librerías externas.

Las operaciones más usadas son:

• Longitud de una cadena. Es una función a la que se le pasa una cadena como parámetro y comoresultado devuelve su longitud.

entero función longitud(cadena : c)




42

• Comparación de cadenas. Esta operación se puede realizar porque lo que se va a comparar son losvalores ASCII asociados a cada carácter.

entero función comparación(cadena : c1, c2)

Esta función devuelve:

0 si c1 = c2

Un positivo si c1 > c2

Un negativo si c1 < c2

• Concatenación. Permite unir varias cadenas en una sola, manteniendo el orden de los caracteres quese unen.

En pseudocódigo se usa el símbolo & ó +.

Ejemplo:

cadena1 “Hola”cadena2 “Adios”cadena3 cadena1 & “ ” + cadena2escribir(cadena3)

por consola aparecerá “Hola Adios”

• Extracción de subcadenas. Extrae parte de una cadena.

cadena función subcadena(cadena : c; entero : ini[; entero : long])

Devuelve una subcadena de la cadena c formada por todos los caracteres a partir de la posición ini. Sise incluye el argumento long, devuelve sólo los primeros long caracteres a partir de la posición ini.

• Posición. Una operación frecuente a realizar con cadenas es localizar si una determinada cadena formaparte de otra cadena más grande o buscar la posición en que aparece un determinado carácter osecuencia de caracteres de un texto. Estos problemas pueden resolverse con la función posición.

entero función posición(cadena : c, sc)

Devuelve la posición de la primera aparición de la subcadena sc en la cadena c.

• Conversión de cadenas a números. Es una función que se le pasa una cadena caracteres numéricos ydevuelve el número asociado.

entero función valor(cadena : c)

Convierte la cadena c a un valor numérico. Si el contenido de la cadena c no puede convertirse a unvalor numérico (contiene caracteres alfabéticos, signos de puntuación inválidos, etc.), devuelve 0

• Conversión de números a cadenas. Es una función a la que se le pasa un número y lo convierte a unacadena.

cadena función cadena(entero : x)

Convierte a cadena el valor numérico x.

• Función que devuelve el carácter ASCII de un número

caracter función caracter(entero : x)

Devuelve el carácter correspondiente al código ASCII x.

• Función que devuelve el número asociado de un carácter ASCII:

entero función código(cadena : car)

Devuelve el código ASCII del carácter car.




43

6. Introducción a la programación orientada aobjetos

La programación Orientada a Objetos es una metodología que basa la estructura de los programas en torno alos objetos.

Los lenguajes de POO ofrecen medios y herramientas para describir los objetos manipulados por un programa.Más que describir cada objeto individualmente, estos lenguajes proveen una construcción (Clase) que describea un conjunto de objetos que poseen las mismas propiedades.

6.1. Objeto

Es una entidad (tangible o intangible) que posee características y acciones que realiza por sí solo ointeractuando con otros objetos.

Un objeto es una entidad caracterizada por sus atributos propios y cuyo comportamiento está determinado porlas acciones o funciones que pueden modificarlo, así como también las acciones que requiere de otros objetos.

Un objeto tiene identidad e inteligencia y constituye una unidad que oculta tanto datos como la descripción desu manipulación. Puede ser definido como una encapsulación y una abstracción: una encapsulación deatributos y servicios, y una abstracción del mundo real.

Para el contexto de la POO un objeto es una entidad que encapsula datos (atributos) y acciones o funcionesque los manejan (métodos). También para la POO un objeto se define como una instancia o particularización deuna clase.

Los objetos de interés durante el desarrollo de software no sólo son tomados de la vida real (objetos visibles otangibles), también pueden ser abstractos. En general son entidades que juegan un rol bien definido en eldominio del problema. Un libro, una persona, un carro, un polígono, son apenas algunos ejemplos de objeto.

Cada objeto puede ser considerado como un proveedor de servicios utilizados por otros objetos que son susclientes. Cada objeto puede ser a al vez proveedor y cliente. De allí que un programa pueda ser visto como un

conjunto de relaciones entre proveedores clientes. Los servicios ofrecidos por los objetos son de dos tipos:• Los datos, que llamamos atributos.

• Las acciones o funciones, que llamamos métodos.

Características generales

• Un objeto se identifica por un nombre o un identificador único que lo diferencia de los demás. Ejemplo: el objeto Cuenta de Ahorros número 12345 es diferente al objeto Cuenta de Ahorros número25789. En este caso el identificador que los hace únicos es el número de la cuenta.

• Un objeto posee estados. El estado de un objeto está determinado por los valores que poseen susatributos en un momento dado.

• Un objeto tiene un conjunto de métodos. El comportamiento general de los objetos dentro de unsistema se describe o representa mediante sus operaciones o métodos. Los métodos se utilizarán paraobtener o cambiar el estado de los objetos, así como para proporcionar un medio de comunicación entreobjetos.

• Un objeto tiene un conjunto de atributos. Los atributos de un objeto contienen valores que determinanel estado del objeto durante su tiempo de vida. Se implementan con variables, constantes y estructurasde datos (similares a los campos de un registro).

• Los objetos soportan encapsulamiento. La estructura interna de un objeto normalmente está oculta alos usuarios del mismo. Los datos del objeto están disponibles solo para ser manipulados por los propiosmétodos del objeto. El único mecanismo que lo conecta con el mundo exterior es el paso de mensajes.




44

• Un objeto tiene un tiempo de vida dentro del programa o sistema que lo crea y utiliza. Para serutilizado en un algoritmo el objeto debe ser creado con una instrucción particular (New ó Nuevo) y alfinalizar su utilización es destruido con el uso de otra instrucción o de manera automática.

6.2. Clase

La clase es la unidad de modularidad en la POO. La tendencia natural del individuo es la de clasificar losobjetos según sus características comunes (clase). Por ejemplo, las personas que asisten a la universidad sepueden clasificar (haciendo abstracción) en estudiante, docente, empleado e investigador.

La clase puede definirse como la agrupación o colección de objetos que comparten una estructura común y uncomportamiento común.

Es una plantilla que contiene la descripción general de una colección de objetos. Consta de atributos y métodosque resumen las características y el comportamiento comunes de un conjunto de objetos.

Todo objeto (también llamado instancia de una clase), pertenece a alguna clase. Mientras un objeto es unaentidad concreta que existe en el tiempo y en el espacio, una clase representa solo una abstracción.

Todos aquellos objetos que pertenecen a la misma clase son descritos o comparten el mismo conjunto deatributos y métodos. Todos los objetos de una clase tienen el mismo formato y comportamiento, son diferentesúnicamente en los valores que contienen sus atributos. Todos ellos responden a los mismos mensajes.


Una clase es un nivel de abstracción alto. La clase permite describir un conjunto de características comunespara los objetos que representa. Ejemplo: La clase Avión se puede utilizar para definir los atributos (tipo deavión, distancia, altura, velocidad de crucero, capacidad, país de origen, etc.) y los métodos (calcularposición en el vuelo, calcular velocidad de vuelo, estimar tiempo de llegada, despegar, aterrizar, volar, etc.)de los objetos particulares Avión que representa.

• Un objeto es una instancia de una clase. Cada objeto concreto dentro de un sistema es miembro deuna clase específica y tiene el conjunto de atributos y métodos especificados en la misma.

• Las clases se relacionan entre sí mediante una jerarquía. Entre las clases se establecen diferentes

tipos de relaciones de herencia, en las cuales la clase hija (subclase) hereda los atributos y métodos dela clase padre (superclase), además de incorporar sus propios atributos y métodos.

Ejemplos:

Superclase: Clase Avión

Subclases de Avión: Clase Avión Comercial, Avión de Combate, Avión de Transporte.

• Los nombres o identificadores de las clases deben colocarse en singular (clase Animal, clase Carro,clase Alumno).

6.3. Relación entre clase y objeto

Algorítmicamente, las clases son descripciones netamente estáticas o plantillas que describen objetos. Surol es definir nuevos tipos conformados por atributos y operaciones.

Por el contrario, los objetos son instancias particulares de una clase. Las clases son una especie de moldede fábrica, en base al cual son construidos los objetos. Durante la ejecución de un programa sólo existen losobjetos, no las clases.

La declaración de una variable de una clase NO crea el objeto.




45

La asociación siguiente: <nombre_clase> : <nombre_variable> (por ejemplo, Rectángulo : R), nogenera o no crea automáticamente un objeto Rectángulo. Sólo indica que R será una referencia o una variablede objeto de la clase Rectángulo.

La creación de un objeto, debe ser indicada explícitamente por el programador, de forma análoga a comoinicializamos las variables con un valor dado, sólo que para los objetos se hace a través de un métodoConstructor (ver punto Métodos).

6.4. Atributos

Son los datos o variables que caracterizan al objeto y cuyos valores en un momento dado indican su estado.

Un atributo es una característica de un objeto. Mediante los atributos se define información oculta dentro de unobjeto, la cual es manipulada solamente por los métodos definidos sobre dicho objeto

Un atributo consta de un nombre y un valor. Cada atributo está asociado a un tipo de dato, que puede sersimple (entero, real, lógico, carácter, cadena) o estructurado (arreglo, registro, archivo, lista, etc.).

Los modos de acceso son:

• Público. Atributos (o Métodos) que son accesibles fuera de la clase. Pueden ser llamados por cualquier

clase, aun si no está relacionada con ella. Este modo de acceso también se puede representar con elsímbolo +.

• Privado. Atributos (o Métodos) que sólo son accesibles dentro de la implementación de la clase. Tambiénse puede representar con el símbolo –.

• Protegido. Atributos (o Métodos) que son accesibles para la propia clase y sus clases hijas (subclases).También se puede representar con el símbolo #.

6.5. Métodos

Son las operaciones (acciones o funciones) que se aplican sobre los objetos y que permiten crearlos, cambiarsu estado o consultar el valor de sus atributos.

Los métodos constituyen la secuencia de acciones que implementan las operaciones sobre los objetos. Laimplementación de los métodos no es visible fuera de objeto.

Ejemplo: Un rectángulo es un objeto caracterizado por los atributos Largo y Ancho, y por varios métodos, entreotros Calcular su área y Calcular su perímetro.


• Cada método tiene un nombre, cero o más parámetros (por valor o por referencia) que recibe o devuelvey un algoritmo con el desarrollo del mismo.

• En particular se destaca el método constructor, que no es más que el método que se ejecuta cuando el

objeto es creado. Este constructor tiene el mismo nombre de la clase/ objeto, recibe cero o másparámetros y lo usual es que inicialicen los valores de los atributos del objeto.

• En lenguajes como Java y C++ se puede definir más de un método constructor, que normalmente sediferencian entre sí por la cantidad de parámetros que reciben.

• Los métodos se ejecutan o activan cuando el objeto recibe un mensaje, enviado por un objeto o claseexterno al que lo contiene, o por el mismo objeto de manera local.




46

Creación de objetos y métodos constructores

Cada objeto o instancia de una clase debe ser creada explícitamente a través de un método u operaciónespecial denominado constructor. Los atributos de un objeto toman valores iniciales dados por elconstructor. Por convención el método constructor tiene el mismo nombre de la clase y no se le asocia unmodo de acceso (es público).

Algunos lenguajes proveen un método constructor por defecto para cada clase y/o permiten la definición demás de un método constructor. En la notación algorítmica, definimos obligatoriamente un único métodoconstructor de la clase.

Método de destructores de objetos

Los objetos que ya no son utilizados en un programa, ocupan inútilmente espacio de memoria, que esconveniente recuperar en un momento dado. Según el lenguaje de programación utilizado esta tarea esdada al programador o es tratada automáticamente por el procesador o soporte de ejecución del lenguaje.

En la notación algorítmica NO tomaremos en cuenta ese problema de administración de memoria, por lotanto no definiremos formas para destruir objetos. En cambio al utilizar lenguajes de programación sidebemos conocer los métodos destructores suministrados por el lenguaje y utilizarlos a fin de eliminarobjetos una vez no sean útiles.

6.6. Mensaje

Es la petición de un objeto a otro para solicitar la ejecución de alguno de sus métodos o para obtener el valor deun atributo público.

Estructuralmente, un mensaje consta de 3 partes:

• Identidad del receptor. Nombre del objeto que contiene el método a ejecutar.

• Nombre del método a ejecutar. Solo los métodos declarados públicos.

• Lista de Parámetros que recibe el método (cero o mas parámetros)

Cuando el objeto receptor recibe el mensaje, comienza la ejecución del algoritmo contenido dentro del método

invocado, recibiendo y/o devolviendo los valores de los parámetros correspondientes, si los tiene ya que sonopcionales:

6.7. Diagrama de clases

La representación gráfica de una o varias clases se hará mediante los denominados Diagramas de Clase. Paralos diagramas de clase se utilizará la notación que provee el Lenguaje de Modelación Unificado (UML, verwww.omg.org), a saber:

• Las clases se denotan como rectángulos divididos en tres partes. La primera contiene el nombre de laclase, la segunda contiene los atributos y la tercera los métodos.

• Los modificadores de acceso a datos y operaciones, a saber: público, protegido y privado; se representancon los símbolos +, # y – respectivamente, al lado derecho del atributo. (+ público, # protegido, - privado).

En la figura se muestra el método “color” que no tiene ningún parámetro y retorna un valor entero y el método“modificar_tamaño” que tiene un real como parámetro y no retorna nada (es una acción).




47

Notación: Ejemplo

Nombre Clase ventana

Atributos+ real : área

# lógico : visible

Métodos

+ ventana(E real : a; E lógico : v)

+ entero mostrarColor()

+ modificarTamaño(E real : porcentaje)

6.8. Relaciones entre clases

Las clases no se construyen para que trabajen de manera aislada, la idea es que ellas se puedan relacionarentre sí, de manera que puedan compartir atributos y métodos sin necesidad de rescribirlos.

La posibilidad de establecer jerarquías entre las clases es una característica que diferencia esencialmente laprogramación orientada a objetos de la programación tradicional, ello debido fundamentalmente a que permiteextender y reutilizar el código existente sin tener que rescribirlo cada vez que se necesite.

Los cuatro tipos de relaciones entre clases estudiados en este curso serán:• Herencia (Generalización / Especialización o Es-un)

• Agregación (Todo / Parte o Forma-parte-de)

• Composición (Es parte elemental de)

• Asociación (entre otras, la relación Usa-a)

Existen otros tipos de relaciones:

• Realización.

• Dependencia.

6.8.1. Relación de herencia (generalización / especialización, es un)

Es un tipo de jerarquía de clases, en la que cada subclase contiene los atributos y métodos de una (herenciasimple) o más superclases (herencia múltiple).

Mediante la herencia las instancias de una clase hija (o subclase) pueden acceder tanto a los atributos comoa los métodos públicos y protegidos de la clase padre (o superclase).

Cada subclase o clase hija en la jerarquía es siempre una extensión (esto es, conjunto estrictamente másgrande) de la(s) superclase(s) o clase(s) padre(s) y además incorporar atributos y métodos propios, que a suvez serán heredados por sus hijas.

• En la notación algorítmica se coloca el nombre de la clase padre después de la frase Hereda de delencabezado de la clase y se usan sus atributos y métodos públicos o protegidos.

Ejemplo: clase alumno hereda_de persona • En el diagrama de clases, la herencia se representa mediante una relación de

generalización/especificación, que se denota de la siguiente forma:

clase hija clase padre

subclase superclase




48

6.8.2. Clase abstracta

Una clase abstracta es aquella que construimos para derivar de ella otras clases, pero de la que no sepuede instanciar. Por ejemplo, la clase animal, no existe como tal en la naturaleza, no existe ningún ser quesea tan solo animal (no hay ninguna instanciación directa de esa clase), existen humanos, gatos, conejos,etc. Todos ellos son animales, pero no existe un ser vivo que sea solo animal.

• En la notación algorítmica se coloca el nombre la palabra abstracto delante del nombre de la clase.

Ejemplo: abstracto clase persona Ejemplo: El siguiente diagrama de clases muestra la relación de Herencia entre la clase animal y sus hijas.La clase animal es abstracta.

6.8.3. Relación de agregación (todo / parte, forma parte de)

Es una relación que representa a los objetos compuestos por otros objetos. Indica Objetos que a su vezestán formados por otros. El objeto en el nivel superior de la jerarquía es el todo y los que están en losniveles inferiores son sus partes o componentes.

La relación forma parte de, no es más que una asociación, que se denota:

Si motor forma parte de carro, la flecha apunta a la clase motor, y el diamante va pegado a carro.La multiplicidad es el rango de cardinalidad permitido que puede asumir la asociación, se denota LI..LS. Sepuede usar * en el limite superior para representar una cantidad ilimitada (ejemplo: 3..*).

Ejemplo: Objeto Casa descrito en términos de sus componentes

carro ruedas 4 .. *

Nombre del objetode nivel superior

Nombre del objetoque lo compone

Multiplicidad




49

6.8.4. Relación de composición

Un componente es parte esencial de un elemento.

La relación es más fuerte que el caso de agregación, al punto que si el componente es eliminado odesaparece, la clase mayor deja de existir.

La relación de composición, se denota de la siguiente forma:

6.8.5. Relación de asociación («uso», usa, cualquier otra relación)

Es una asociación que se establece cuando dos clases tienen una dependencia de utilización, es decir, unaclase utiliza atributos y/o métodos de otra para funcionar. Estas dos clases no necesariamente están en

jerarquía, es decir, no necesariamente una es clase padre de la otra, a diferencia de las otras relaciones declases.

El ejemplo mas común de esta relación es de objetos que son utilizados por los humanos para algunafunción, como Lápiz (se usa para escribir), tenedor (se usa para comer), silla (se usa para sentarse), etc.Otro ejemplo son los objetos Cajero y Cuenta. El Cajero “usa a” la cuenta para hacer las transacciones deconsulta y retiro y verificar la información del usuario.

La relación de uso, se denota con una dependencia estereotipada:

Ejemplos:

clase mayor clase componente

clase 1 clase 2usa a

persona corazón




50

7. Fundamentos del enfoque orientado a objeto

El Enfoque Orientado a Objeto se basa en cuatro principios que constituyen la base de todo desarrolloorientado a objetos. Estos principios son: Abstracción, Encapsulamiento, Modularidad y Herencia.

Otros elementos a destacar (aunque no fundamentales) en la POO son: Polimorfismo, Enlace dinámico (o

binding), Concurrencia y Persistencia.

7.1. Abstracción

Es el principio de ignorar aquellos aspectos de un fenómeno observado que no son relevantes, con elobjetivo de concentrarse en aquellos que si lo son. Una abstracción denota las características esenciales deun objeto (datos y operaciones), que lo distingue de otras clases de objetos. Decidir el conjunto correcto deabstracciones de un determinado dominio, es el problema central del diseño orientado a objetos.

Los mecanismos de abstracción son usados en la POO para extraer y definir del medio a modelar, suscaracterísticas y su comportamiento. Dentro de la POO son muy usados mecanismos de abstracción:Generalización, Agregación y clasificación.

7.1.1. Generalización

Es el mecanismo de abstracción mediante el cual un conjunto de clases de objetos son agrupadas en unaclase de nivel superior (Superclase), donde las semejanzas de las clases constituyentes (Subclases) sonenfatizadas, y las diferencias entre ellas son ignoradas. En consecuencia, a través de la generalización, lasuperclase almacena datos generales de las subclases, y las subclases almacenan sólo datos particulares.La especialización es lo contrario de la generalización. La clase Médico es una especialización de la clasePersona, y a su vez, la clase Pediatra es una especialización de la superclase Médico.

7.1.2. Agregación

Es el mecanismo de abstracción por el cual una clase de objeto es definida a partir de sus partes (otrasclases de objetos). Mediante agregación se puede definir por ejemplo un computador, por descomponerseen: la CPU, la ULA, la memoria y los dispositivos periféricos. El contrario de agregación es ladescomposición.

7.1.3. Clasificación

Consiste en la definición de una clase a partir de un conjunto de objetos que tienen un comportamientosimilar. La ejemplificación es lo contrario a la clasificación, y corresponde a la instanciación de una clase,usando el ejemplo de un objeto en particular.

7.2. Encapsulamiento (ocultamiento de información)Es la propiedad de la POO que permite ocultar al mundo exterior la representación interna del objeto. Estoquiere decir que el objeto puede ser utilizado, pero los datos esenciales del mismo no son conocidos fuera deél.

La idea central del encapsulamiento es esconder los detalles y mostrar lo relevante. Permite el ocultamiento dela información separando el aspecto correspondiente a la especificación de la implementación; de esta forma,distingue el "qué hacer" del "cómo hacer". La especificación es visible al usuario, mientras que laimplementación se le oculta.




51

El encapsulamiento en un sistema orientado a objeto se representa en cada clase u objeto, definiendo susatributos y métodos con los siguientes modos de acceso:

• Público (+). Atributos o Métodos que son accesibles fuera de la clase. Pueden ser llamados por cualquierclase, aun si no está relacionada con ella.

• Privado (-). Atributos o Métodos que solo son accesibles dentro de la implementación de la clase.

• Protegido (#). Atributos o Métodos que son accesibles para la propia clase y sus clases hijas (subclases).

Los atributos y los métodos que son públicos constituyen la interfaz de la clase, es decir, lo que el mundoexterior conoce de la misma.

Normalmente lo usual es que se oculten los atributos de la clase y solo sean visibles los métodos, incluyendoentonces algunos de consulta para ver los valores de los atributos. El método constructor (Nuevo, New) siemprees Público.

7.3. Modularidad

Es la propiedad que permite tener independencia entre las diferentes partes de un sistema. La modularidadconsiste en dividir un programa en módulos o partes, que pueden ser compilados separadamente, pero quetienen conexiones con otros módulos. En un mismo módulo se suele colocar clases y objetos que guarden unaestrecha relación. El sentido de modularidad está muy relacionado con el ocultamiento de información.

7.4. Herencia

Es el proceso mediante el cual un objeto de una clase adquiere propiedades definidas en otra clase que lopreceda en una jerarquía de clasificaciones. Permite la definición de un nuevo objeto a partir de otros,agregando las diferencias entre ellos (Programación Diferencial), evitando repetición de código y permitiendo lareusabilidad.

Las clases heredan los datos y métodos de la superclase. Un método heredado puede ser sustituido por uno

propio si ambos tienen el mismo nombre.La herencia puede ser simple (cada clase tiene sólo una superclase) o múltiple (cada clase puede tenerasociada varias superclases). La clase Docente y la clase Estudiante heredan las propiedades de la clasePersona (superclase, herencia simple). La clase Preparador (subclase) hereda propiedades de la clase Docentey de la clase Estudiante (herencia múltiple).

Cuando se desea indicar invocar a un método que pertenece a la clase madre, lo indicamos con la siguientesintaxis:

super.nombre_método()

Para el ejemplo, la llamada en la clase hija ave del método comer de la clase madre animal sería:

super.comer()

7.5. Polimorfismo

Es una propiedad de la POO que permite que un método tenga múltiples implementaciones, que se seleccionanen base al tipo objeto indicado al solicitar la ejecución del método.

El polimorfismo operacional o sobrecarga operacional permite aplicar operaciones con igual nombre adiferentes clases o están relacionados en términos de inclusión. En este tipo de polimorfismo, los métodos soninterpretados en el contexto del objeto particular, ya que los métodos con nombres comunes sonimplementados de diferente manera dependiendo de cada clase.




52

Por ejemplo, el área de un cuadrado, rectángulo y círculo, son calculados de manera distinta; sin embargo, ensus clases respectivas puede existir la implementación del área bajo el nombre común Área. En la práctica ydependiendo del objeto que llame al método, se usará el código correspondiente.

Ejemplo: superclase: clase animal subclases: clases perro, ave, pez

Se puede definir un método comer en cada subclase, cuya implementación cambia de acuerdo a la claseinvocada, sin embargo el nombre del método es el mismo.

perro.comer() ≠ ave.comer() ≠ pez.comer()Otro ejemplo de polimorfismo es el operador +. Este operador tiene dos funciones diferentes de acuerdo al tipode dato de los operandos a los que se aplica. Si los dos elementos son numéricos, el operador + significa sumaalgebraica de los mismos, en cambio si por lo menos uno de los operandos es un String o Carácter, el operadores la concatenación de cadenas de caracteres.

Otro ejemplo de sobrecarga es cuando tenemos un método definido originalmente en la clase madre, que hasido adaptado o modificado en la clase hija. Por ejemplo, un método comer para la clase animal y otro comerque ha sido adaptado para la clase ave, quien está heredando de la clase animal.

Para poder realizar la adaptación o modificación del método en la clase hija, debe estar declarado como métodoabstracto en la clase madre.

Ejemplo: abstracto publico entero función mostrarCedula()




53

8. Ejemplos

8.1. Expresiones

Determinar el valor de la variable A.

a. A (3 * 2 ^ 5 mod 1 + 8 * (3 - 5) < (2 + 8 - 1 mod 1) A (3 * 32 mod 1 + (-16)) < 10A -16 < 10A Verdadero

b. A A o ( 3 + 5 * 8) < 3 y ((-6 / 3 div 4) * 2 < 2)A Verdadero o 43 < 3 y (0 * 2 < 2)A Verdadero o Falso y Verdadero A Verdadero o Falso A Verdadero

8.2. Diagramas de flujo

a. Establezca la codificación que amerite la su solución de los siguientes diagramas de flujo:

num <> 0

num = 1

suma = 0

“La suma es: ”, suma

inicio

“Ingresar número: ”

num

suma = suma + num

fin

si no




54

algoritmo ejemplo_8.2var

entero : num, suma

inicio

num 1suma 0hacer

escribir(“Ingresar número: ”)leer(num) suma suma + num

mientras (num <> 0) escribir(“La suma es: ” + suma)

fin

8.3. Estructuras de selección

a. Escribir un procedimiento que aumenta Bs. 150 al sueldo de las personas que ganan Bs. 605 o menos.

algoritmo ejemplo_8.3.a// Procedimiento para calcular el monto de un aumento de sueldovarreal : sueldo

inicio

// se pide el valor del sueldo al usuarioescribir(“Suministre el monto del sueldo de la persona”)

// lee el sueldo actual del empleadoleer(sueldo)

// el condicional compara el sueldo del empleadosi (sueldo <= 605) entonces

// aumenta el sueldo del empleadosueldo sueldo + 150

// mensaje con el resultadoescribir(“El nuevo sueldo es: ” + sueldo)

fin_si

// Fin de la secuencia de instruccionesfin

b. Crea una secuencia de instrucciones que calcule el monto de un aumento, a partir del sueldo del empleadoy su antigüedad (cantidad de años trabajados en la empresa). Para las personas que ganan hasta Bs. 500se les aumenta 15% si tienen menos de 5 años de antigüedad en la empresa y 20% si tienen 5 ó másaños. Para los que ganan por encima de Bs. 500 hasta 2.500 se les aumenta 5% por cada 5 años deantigüedad.

algoritmo ejemplo_8.3.b{ Procedimiento para aumentar el sueldo según el monto del sueldo actualy los años de servicio }

var

real : sueldo, aumentoentero : años, aux

inicioescribir(“Suministre el sueldo y los años de antigüedad”)

// se solicitan y leen valores de entradaleer(sueldo)leer(años)

//contempla sueldo menores o iguales a 500




55

si (sueldo <= 500) entonces { este si anidado contempla la antigüedad para los que ganan hastaBs. 500 }

si (años < 5) entonces // trabajadores con menos de 5 años // se calcula el monto del aumento, usando 15%

aumento sueldo * 0,15si_no

// se calcula el monto del aumento, usando 20%

aumento sueldo * 0,2fin_si

// contempla los que ganan más de 500si_no

// ganan más de 500 y hasta 2.500si (sueldo > 500 y sueldo <= 2.500) entonces

// calcula cuantas veces se le aplicará el aumento del 5%aux años div 5

// se calcula el monto del aumentoaumento sueldo * (aux * 5) / 100

si_no

// no se aumenta el sueldo de los que ganan más de 2.500aumento 0

fin_sifin_sisi (aumento = 0) entonces

escribir(“Sueldo actual: ” + sueldo + “ gana más de 2.500”)escribir(“no se contempló aumento”)

si_noescribir(“Sueldo actual es ” + sueldo)escribir(“Tiene una antigüedad de ” + años)escribir(“Recibe aumento de ” + aumento)escribir(“Su nuevo sueldo es ” + (sueldo + aumento))

fin_si

// Fin de la secuencia de instruccionesfin

c. Dada una fecha en formato día/mes/año determinar el número de días y el nombre del mes de dicha fecha,y sacar por pantalla la fecha convertida a formato de día “de” mes “de” año. Suponer que febrero siempretiene 28 días.

algoritmo ejemplo_8.3.cvar

entero : dia, mes, año, n_diascadena : n_mes

inicio

escribir(“Introduce la fecha en formato día mes año”)leer(dia)leer(mes)

leer(año)según_sea (mes) hacer 1: n_mes “enero”

n_dias 312: n_mes “febrero”

n_dias 283: n_mes “marzo”

n_dias 314: n_mes “abril”

n_dias 305: n_mes “mayo”




56

n_dias 316: n_mes “junio”

n_dias 307: n_mes “julio”

n_dias 318: n_mes “agosto”

n_dias 319: n_mes “septiembre”

n_dias 3010: n_mes “octubre”

n_dias 3111: n_mes “noviembre”

n_dias 3012: n_mes “diciembre”

n_dias 31fin_segúnescribir(“El mes de ” + n_mes + “ tiene ” + n_dias + “ dias”)escribir(“La fecha es ” + n_dias + “ de ” + n_mes + “ de ” + año)

fin

8.4. Estructuras de repetición

a. Se desea sumar 35 números (pueden ser enteros o reales) suministrados por teclado y calcular supromedio.

algoritmo ejemplo_8.4.a// instrucciones para Sumar y Promediar

varreal : suma, promedio, numentero : j

inicio

suma 0desde j 1 hasta 35 hacer

escribir(“Suministre el nuevo número”)leer(num)suma suma + num

fin_desde

promedio suma / (j - 1)escribir(“La suma de los números es ” + suma)escribir(“El promedio de los números es ” + promedio)

fin

b. Dada la siguiente serie matemática:

a1 = 0

a2 = 0an = an-1 + (2*an-2)Determinar cual es el valor y el rango del primer término cuyo valor sea mayor o igual a 2000.

algoritmo ejemplo_8.4.bvar

entero : a1, a2, an, cont

inicio

cont 0 a1 1




57

a2 0an a1 + (2 * a2) mientras (an < 2000) hacer

a2 a1a1 anan a1 + (2 * a2)cont cont + 1

fin_mientras

escribir(“El rango es ” + cont + “ y el resultado es ” + an)fin

c. Se desea conocer cuantas veces se repiten las vocales en un texto que el usuario suministra letra por letray que termina con ‘* ’


entero : cantA, cantE, cantI, cantO, cantUcarácter : letra

inicio

cantA 0

cantE 0cantI 0

cantO 0cantU 0escribir(“suministre la primera letra”)leer(letra) mientras (letra <> ‘*’) hacer

según_sea (letra) hacer ‘a’: cantA cantA + 1‘e’: cantE cantE + 1‘i’: cantI cantI + 1‘o’: cantO cantO + 1‘u’: cantU cantU + 1

fin_segúnescribir(“suministre próxima letra”)leer(letra)

fin_mientrasescribir(“La cantidad de vocales A es ” + cantA)escribir(“La cantidad de vocales E es ” + cantE)escribir(“La cantidad de vocales U es ” + cantU)

fin

d. Calcule el promedio general de notas de un grupo de alumnos para una materia. Se sabe que la materiatiene al menos un alumno. El usuario le indicará cuando terminó de suministrar todas las notas.

algoritmo ejemplo_8.4.dvar

real : nota, promedioentero : numAlumnoscadena : continuar

inicio

promedio 0numAlumnos 1continuar “Si”repetir

escribir(“Suministre la nota del alumno”)leer(nota)




58

promedio (promedio + nota) / numAlumnos

numAlumnos numAlumnos + 1// actualizo la variable de la condición de paradaescribir(“¿Desea suministrar otra nota? Indique Si ó No”)leer(continuar)

hasta_que (continuar = “No”) escribir(“El promedio general es ” + promedio)

fin

8.5. Funciones y procedimientos

a. Función sin pase de parámetros

entero función cantidadPalabrasLos(){ solicita al usuario palabras, verifica si se suministra la palabra “los”y en ese caso se cuenta. El algoritmo termina cuando se lea la palabra “fin” }

var

cadena : palabraentero : cantLos

iniciocantLos 0escribir(“A continuación se le solicitarán palabras.)escribir(“Suministre la palabra fin, para terminar el algoritmo”)repetir

escribir(“Suministre una palabra”)leer(palabra)si (palabra = “los”) entonces

cantLos cantLos + 1fin_si

hasta_que (palabra = “fin”)devolver(cantLos){ esta instrucción retorna o devuelve la cantidad de palabras al algoritmo

que llamo a esta función }fin_función

b. Procedimientos y funciones con pase de parámetros

algoritmo ejemplo_8.5.b{ Solicita una fecha de nacimiento y llama a acciones y funciones que hacenvarios cálculos con ella }

var

entero : diaNac, mesNac, añoNac, edadcadena : nombrelógico : esCorrecta, esBis, esMenorEdad

inicioescribir(“suministra tu nombre”)leer(nombre)

repetirescribir(“suministra el día, mes y año de tu fecha de nacimiento”)leer(diaNac)leer(mesNac)leer(añoNac)

// se llama a una función que verifica la fechaesCorrecta validarFecha(diaNac, mesNac, añoNac)

hasta_que (esCorrecta)




59

// se llama a una función que valida si el año de nacimiento fue bisiestoesBis validarBisieto(añoNac)

si no(esBis) entonces escribir(“no naciste en un año Bisiesto”)

si_noescribir(“Naciste en un año Bisiesto”)

fin_si

// calcula cuando cumple añoscumpleaños(nombre, diaNac, mesNac, añoNac)

edad 0esMenorEdad Falso

// calcula la edad y si es o no menor de edadcalcularEdad(añoNac, edad, esMenorEdad)

escribir(nombre + “ tu tienes ” + edad + “ años”)fin

{ declaración formal de las funciones y procedimientos utilizados en elalgoritmo principal. En muchos lenguajes de programación estas declaracionesformales deben estar ANTES del algoritmo que las llama. }

// verifica si el día (d), mes (m) y año (a) conforman una fecha válidalógico función validarFecha(E entero : d, m, a)var

lógico : correctainicio

correcta = verdadero;

// completa las instrucciones faltantes

devolver(correcta)fin_función

// verifica si el año (a) es bisiestológico función validarBisiesto(E entero : a)

devolver((a mod 4 = 0) y (a mod 100 <> 0) o (a mod 400 <> 0))fin_función

{ verifica si ya la persona cumplió años. Este algoritmo supone que existen lasFunciones que devuelven el año, mes y día actual }

procedimiento cumpleaños(E cadena : nombre; E entero : dia, mes, año)var

cadena : mensajeentero : mesesFaltan

inicio// 1er si, para la fecha de ejemplo añoActual() = 2007si (año = añoActual()) entonces

mensaje “todavía no has cumplido el primer añito”// 2do si, ya cumplió años, para la fecha de ejemplo mesActual() = 6si_no si (mes < mesActual()) entonces

mensaje “ ya cumpliste años, felicitaciones atrasadas”// 3er si, ya cumplió años, 3er si faltan = mes mod 12 + 1si_no si (mes > mesActual()) entonces

mensaje “ faltan aproximadamente ” + faltan +“ para tu cumpleaños”




60

// 4to di, ya cumplió años, diaActual() = 4si_no si (dia < diaActual()) entonces

mensaje “ ya cumpliste años, felicitaciones atrasadas”// 5to si, cumple años muy pronto, faltan = dia - 22si_no si (dia > diaActual()) entonces

mensaje “ alégrate sólo quedan ” + faltanmensaje mensaje + “ días para tu cumple”

si_no

mensaje “ ¡¡¡Cumpleaños Feliz!!! muchos deseos de salud”mensaje mensaje + “ y prosperidad en tu día”

fin_si // cerrando si 5 fin_si // cerrando si 4

fin_si // cerrando si 3 fin_si // cerrando si 2

fin_si // cerrando si 1 escribir(nombre + mensaje)

fin_procedimiento

// Calcula la cantidad aproximada de años que tiene una persona procedimiento calcularEdad(E entero : año; E/S entero : edad; E lógico : menor)

edad añoActual() – año

menor (edad < 18)escribir(“¿La persona es menor de edad? ” + menor)

fin_procedimiento

c. Implementar un subprograma que me halle cual es la primera potencia en base 2 mayor que un número quepasamos como parámetro, devolviendo el valor de dicha potencia y el exponente al que está elevado.


entero : numero, resp1, resp2inicio

escribir(“Introduce un número”)leer(numero)comprueba(numero, resp1, resp2)

escribir(“2^” + resp1 + “ = ” + resp2 + “ > ” + numero)fin

procedimiento comprueba(E entero : num; E/S entero : n, pot)var

entero : ninicio

n 1 mientras (pot < n) hacer

pot pot * 2n n+1

fin_mientras

fin_procedimiento

d. Calcular el primer término de la siguiente serie que sea mayor o igual a un valor V que se le pasa comoparámetro y me devuelva el lugar que ocupa en la serie y el valor.

Ai = 0An = n + (An - 1)!

entero función factorial(E entero : num)var

entero : i, acuminicio

acum 1




61

desde i 1 hasta num hacer acum acum * i

fin_desde

devolver(acum)fin_función

procedimiento serie(E entero : v; E/S entero : an, n)var

entero : a1inicio

a1 0an 0n 1 mientras (an <= v) hacer

n n+1an n + factorial(a1)a1 an

fin_mientrasfin_procedimiento

e. ¿Qué se escribe en pantalla tras la siguiente ejecución?

algoritmo ejemplo_8.5.evar

entero : A, B, Cinicio

A 1B 2C A+3P1 (A, B - C, C)C C – F(A)P2 (A, C)P1 (C, B, A)escribir(A + “, ” + B + “, ” + C)

fin

procedimiento P1(E/S entero : x; E entero : y; E/S entero : z)inicio

x y + zy x + 1z y * 2

fin_procedimiento

procedimiento P2(E/S entero : x; E entero : y)inicio

x x +1 –yy 3

fin_procedimiento

entero función F(E entero : x)inicio

x x + 3devolver(x – 1)

fin_función

La solución es A = 8; B = 2; C = 3




62

8.6. Arreglos

a. Hay unos multicines con 5 salas, y cada sala con 100 personas distribuidas en 20 asientos y 5 filas.

Si se pide la entrada para una sala, implementar un algoritmo que me diga si hay sitio en la sala.

algoritmo ejemplo_8.6.aconst

salas = 5asientos = 20filas = 5

var

entero : f, a, slógico : banderaarray [1..filas, 1..asientos, 1..salas] de entero : cine

inicio

pedirDatos(s) mientras (s <> 0) hacer

bandera falsoa 0

f

1repetir

si (a > asientos) entonces a 1f f + 1

fin_si

si (a = asientos) y (f >= filas) entonces escribir(“Sala llena”)bandera verdadero

si_no

si (a[f, a, s] = 0) entonces a[f, a, s] 1escribir(“Asiento ” + a + “, fila ” + a)bandera verdadero

fin_si

fin_sihasta_que (a[f, a, s] = 1) y (bandera = verdadero)pedirDatos(s)

fin_mientrasfin

procedimiento pedirDatos(E/S entero : sala)inicio

repetirescribir(“¿En qué sala quieres entrar?”)leer(sala)

hasta (sala >= 0) y (sala <= salas)

fin_procedimiento

b. Dada una matriz A de M*N elementos, actualizarla tal que la matriz resultante tenga divididos a loselementos de la diagonal principal por la suma de los elementos que no forman parte de ella.

algoritmo ejemplo_8.6.bvar

array [1..M, 1..N] de real : areal : suma

inicio

pedirDatos(a)




63

sumar(a, suma)escribirArreglo(a)

fin

procedimiento pedirDatos(E/S array [1..M, 1..N] de real : matriz)var

entero : i, jinicio

desde i 1 hasta M hacer desde j 1 hasta N hacer

escribir(“Introduce el elemento” + i + “, ” + j)leer(matriz[i, j])

fin_desde

fin_desdefin_procedimiento

procedimiento sumar(E array [1..M, 1..N] de real : matriz; E/S real : s)var

entero : i, jinicio

s 0


si (i <> j) entonces s s + matriz[i, j]

fin_sifin_desde


procedimiento escribirArreglo(E array [1..M, 1..N] de real : matriz; E real : s)var

entero : i, jinicio


si (i = j) entonces escribir(matriz[i, j] / s)

si_noescribir(matriz[i, j])

fin_sifin_desde


c. Se tiene guardado en una estructura los alumnos de una escuela, sabiendo que hay 3 cursos, M alumnospor curso y N materias por estudiante, determinar mediante subprogramas:

• ¿Cual es la nota media de un determinado curso?• ¿Cuantos aprobados y reprobados hay en una determinada materia?

• ¿Cual es el alumno de la escuela con mejor nota media?

algoritmo ejemplo_8.6.cconst

cursos = 3alumnos = Mmaterias = N

tipo

array [1..cursos, 1.. alumnos, 1.. materias] de real : cubo




64

var

cubo : nota

inicio

pedirDatos(nota)mediaCurso(nota)cantidadAprobados(nota)mediaAlumno(curso)

fin

procedimiento pedirDatos(E/S cubo : n)var

entero : c, a, minicio

desde c 1 hasta cursos hacer

desde a 1 hasta alumnos hacer

desde m 1 hasta materias hacer repetir

escribir(“Nota del alumno ” + a + “ materia ” + m + “curso ” + c)leer(n[c, a, m])

hasta_que (n[c, a, m] >= 0) y (n[c, a, m] <= 20)

fin_desdefin_desde

fin_desde

fin_procedimiento

procedimiento mediaCurso(E cubo : n)var

entero : curso, a, mreal : media, suma

inicio

suma 0.0repetir

escribir(“¿De qué curso quieres hacer la media?”)leer(curso)

hasta_que (curso <= 1) y (curso <= cursos)desde a 1 hasta alumnos hacer

desde m 1 hasta materias hacer suma suma + n[curso, a, m]

fin_desde

fin_desde

media suma / (alumnos * materias)escribir(“La nota media del curso ” + curso + “ es ” + media)

fin_procedimiento

procedimiento cantidadAprobados(E cubo : n)var

entero : c, a, materia, reprobados, aprobadosinicio

reprobados 0aprobados 0repetir

escribir(“¿Qué materia quieres ver?”)leer(materia)

hasta_que (materia >= 1) y (materias <= materias)desde c 1 hasta cursos hacer

desde a 1 hasta alumnos hacer si (n[c, a, materia] >= 10) entonces




65

aprobados aprobados + 1si_no

reprobados reprobados + 1fin_si

fin_desde

fin_desdeescribir(“En la materia ” + materia + “ hay ” + aprobados + “ aprobados”)escribir(“En la materia ” + materia + “ hay ” + reprobados + “ reprobados”)

fin_procedimiento

procedimiento mediaAlumno(E cubo : n)var

entero : c, e, a, alumno, cursoreal : suma, media, mayor

inicio

mayor 0.0desde c 1 hasta cursos hacer

desde a 1 hasta alumnos hacer suma 0.0desde m 1 hasta materias hacer

suma suma + n[c, a, m]

fin_desdemedia suma / materiassi (media > mayor) entonces

mayor mediacurso calumno a

fin_sifin_desde

fin_desde

escribir(“El alumno con mayor media es el ” + alumno + “ del curso ” + curso)escribir(“y su nota es de ” + mayor)

fin_procedimiento

d. Una empresa consta de 5 departamentos con 20 empleados cada departamento, si se tiene todas lasventas en una estructura, determinar:

• Ventas de un determinado departamento en un determinado mes.

• Ventas de un determinado empleado en un determinado departamento.

• ¿Cual es el departamento con más ventas?

algoritmo ejemplo_8.6.dconst

departamentos = 5empleados = 20meses = 12

tipo

array [1.. departamentos, 1.. empleados, 1.. meses] de real : matrizvar

matriz : ventasreal : cantidad

inicio

pedirDatos(ventas)ventasDepartamentoMes(ventas)ventasEmpleadoDepartamento(ventas)mejorDepartamento(ventas)

fin




66

procedimiento pedirDatos(E/S matriz : a)var

entero : d, e, minicio

desde d 1 hasta departamentos hacer desde e 1 hasta empleados hacer

desde m 1 hasta meses hacer escribir(“Ventas del departamento ” + d)

escribir(“empleado ” + e)escribir(“mes ” + m)leer(a[d, e, m])

fin_desde fin_desde

fin_desde

fin_procedimiento

procedimiento ventasDepartamentoMes(E matriz : a)var

entero : departamento, e, mesreal : venta

inicio

venta 0.0repetir

escribir(“Departamento”)leer(departamento)

hasta_que (departamento >= 1) y (departamento <= departamentos)repetir

escribir(“Mes”)leer(mes)

hasta_que (mes >= 1) y (mes <= 12)desde e 1 hasta empleados hacer

venta venta + a[departamento, e, mes]fin_desde

escribir(“Las ventas del departamento” + departamento)escribir(“en el mes” + mes + “son” + venta)

fin_procedimiento

procedimiento ventasEmpleadoDepartamento(E matriz : a)var

entero : departamento, empleado, mreal : venta

inicio

venta 0.0repetir

escribir(“Empleado”)leer(empleado)

hasta_que (empleado >= 1) y (empleado <= empleados)repetir

escribir(“Departamento”)leer(“departamento”)

hasta_que (departamento >= 1) y (departamento <= departamentos)desde m 1 hasta meses hacer

venta venta + a[departamento, empleado, m]fin_desdeescribir(“Las ventas del empleado ” + empleado)escribir(“del departamento ” + departamento + “ son ” + venta)

fin_procedimiento




67

procedimiento mejorDepartamento(E matriz : a)var

entero : d, e, m, departamentoreal : mayor, venta

inicio

mayor 0.0desde d 1 hasta departamentos hacer

venta 0

desde e 1 hasta empleados hacer desde k 1 hasta meses hacer

venta venta + a[d, e, m]fin_desde

fin_desdesi (venta > mayor) entonces

mayor ventadepartamento d

fin_si

fin_desdeescribir(“El mejor departamento es el ” + departamento + “ con ” + mayor)

fin_procedimiento

8.7. Registros

a. Tenemos un array con la información de nuestros productos, por cada producto almacenamos su código,descripción, stock actual y stock mínimo.

Se trata de obtener otro array que contenga los productos de los que halla que hacer pedidos porque sustock sea inferior al mínimo, tal que al proveedor le tenemos que dar como datos la identificación delproducto y la cantidad que pedimos, que coincidirá con el stock mínimo.

Normalmente trabajamos con 100 productos.

algoritmo ejemplo_8.7.a

tiporegistro : productoentero : codigocadena : descripciónentero : stockentero : stock_min

fin_registroregistro : pedido

entero : codigoentero : cantidad

fin_registro

array [1..100] de producto : listaProductoarray [1..100] de pedido : listaPedido

var

listaProducto : prodlistaPedido : pedentero : i, j

inicio

j 1desde i 1 hasta 100 hacer

si (prod[i].stock < prod[i].stock_min) entonces ped[j].codigo prod[i].codigoped[j].cantidad prod[i].stock_minj j + 1




68

fin_si

fin_desdefin

b. Dado un array que contiene la información de los alumnos de una clase de 100 alumnos, y teniendo encuenta que de cada uno de ellos almacenamos su número de expediente, nombre y nota media. Hallar lamedia de todos los alumnos de esa clase y dar otra opción que pida el nombre de un alumno y me de sunota si este alumno existe.

algoritmo ejemplo_8.7.btipo

registro : alumnoentero : expedientecadena : nombrereal : media

fin_registro

array[1..100] de alumno : listavar

lista : estudianteentero : op, ilógico : marcacadena : nombre

inicio

presentar(op) mientras (op <> 0) hacer

según _sea op hacer 1: escribir(“La media de la clase es ” + notaMedia(estudiante))2: escribir(“Introduce un nombre”)

leer(nombre)marca falsoi 1repetir

si (comparar(estudiante[i].nombre, nombre) = verdadero) entonces marca = verdadero

si_noi i + 1

fin_sihasta_que (i > 100) o (marca = verdadero)si (marca = verdadero) entonces

escribir(“La nota de ” + nombre + “ es ” + estudiante[i].media)si_no

escribir(“El alumno no existe”)fin_si

fin_según

presentar(op)fin_mientras

fin

procedimiento presentar(E/S entero : opcion)inicio

repetir

escribir(“0. Salir”)escribir(“1. Hallar nota media”)escribir(“2. Hallar la nota de un alumno”)escribir(“Introduce una opción”)leer(opcion)

hasta_que (opcion >= 0) y (opcion <= 2)fin_procedimiento




69

real función notaMedia(E lista : a)var

entero : ireal : acum

inicio

acum 0desde i 1 hasta 100 hacer

acum acum + a[i].nota

fin_desdedevolver(acum / 100)

fin_función

lógico función comparar(E cadena : c1, c2)var

entero : iinicio

i 1 mientras (c1[i] = c2[i]) y (c1[i] <> ’$’) y (c2[i] <> ’$’) hacer

i i + 1fin_mientrassi (c1[i] = c2[i]) entonces

devolver(verdadero)si_no

devolver(falso)fin_si

fin_función

c. Tenemos un array con la indicación de cada producto, stock, descripción y fecha. Hallar una opción que nossirva iterativamente para hacer pedidos de productos y que termina cuando pidamos el producto 0.

Por cada pedido se da el identificador de producto que se pide, y la cantidad de producto, y lo que nos dicees si hay cantidad suficiente, respondiendo “Pedido suministrado” y actualizando el stock, y si el productosolicitado no existe o no hay suficiente cantidad, mostrará un mensaje de error explicando la causa.

algoritmo ejemplo_8.7.c

tiporegistro : t_fechaentero: diaentero : mesentero : año

fin_registro

registro : productoentero : codigocadena : descripicionentero : stockt_fecha : fecha

fin_registroarray[1..10] de producto : lista

var

lista : prodentero : codigo, cantidad, ilógico : marca

inicio

escribir(“Introduce el código”)leer(codigo)escribir(“Introduce la cantidad”)leer(cantidad) mientras (codigo <> 0) hacer

i 1




70

marca falsorepetir

si (codigo = prod[i].codigo) entonces marca verdadero

si_no

i i + 1fin_si

hasta_que (marca = verdadero) o (i > 100)

si (marca = falso) entonces escribir(“No existe el producto”)

sino

si (prod[i].stock < cantidad) entonces escribir(“No hay cantidad suficiente”)

si_no

prod[i].stock prod[i].stock – cantidadescribir(“pedido suministrado”)

fin_sifin_si

fin_mientrasfin

8.8. Cadenas

a. Borrar de una cadena una subcadena que forma parte de ella. Dar la posición de inicio y final de lasubcadena que quiero borrar.

procedimiento borrar(E/S cadena : c; E entero : ini, fin)var

entero : i, jinicio

i inif fin + 1 mientras (c[f] <> ’$’) hacer

c[i] c[f]i i + 1

fin_mientras

c[i] ‘$’fin_procedimiento

b. Insertar una cadena dentro de otra a partir de una determinada posición.

procedimiento insertar(E/S cadena : c; E cadena : s; E entero : pos)var

entero : p, j, iinicio

p pos

j 1 mientras (s[j] <> ’$’) hacer desde i longitud(c) +1 hasta p hacer

c[i + 1] c[i]fin_desde

c[p] s[j]j j + 1p p + 1

fin_mientras

fin_procedimiento




71

c. Crear una función a la que se le pasa una cadena como parámetro y como resultado devuelve la longitudde la misma.

entero función longitud(E cadena : c)var

entero : linicio

l 0

mientras (c[L + 1] <> ‘$’) hacer l l + 1fin_mientrasdevolver(l)

fin_procedimiento

d. Intercambiar la aparición de una subcadena dentro de una cadena, por otra subcadena. Para eso la primerasubcadena tiene que aparecer en la otra.

procedimiento intercambio(E/S cadena : c; E cadena : c2, c3)var

entero : i, posinicio

i 1

mientras (c1[i] <>’$’) hacer si (c1[i] = c2[i]) entonces

pos buscar(c1, c2)si (pos <> 0) entonces borrar(c1, pos, pos + longitud(c2) - 1)insertar(c1, c3, pos)i pos + longitud(c3)si_no

i i +1fin_si

si_no

i I+1fin_si

fin_mientrasfin_procedimiento

e. Comparar 2 cadena si son iguales o no. Realizar la comparación utilizando los valores ASCII asociados acada carácter. En el caso de que se comparen 2 cadenas de diferente longitud tal que la cadena de menorlongitud tiene N caracteres y estos N caracteres coinciden con los N primeros caracteres de la cadena máslarga, se considera mayor la cadena más larga.

entero función comparacion(E cadena c1, c2)var

entero : iinicio

i 1 mientras (c1[i] = c2[i]) y (c1[i] <> ‘$’) y (c2[i] <> ‘$’) hacer

i i + 1fin_mientrassi (c1[i] = c2[i]) entonces

devolver(0)si_no

devolver(ascii(c1[i]) - ascii(c2[i]))fin_si

fin_función




72

f. Crear una función que dado 2 cadenas, busque si existe la cadena 1 dentro de la cadena 2.

entero función busqueda(E cadena : c, s1) var

entero : i, pos, klógico : encontrado

inicio

e

1encontrado falso mientras (c[i] <> ’$’) y (encontrado = falso) hacer

si (c[i] = s[i]) entonces pos ik 1 mientras (c[i] = s[k]) y (c[i] <> ’$’) y (s[k] <> ’$’) hacer

i i + 1k k + 1

fin_mientras

si (s[k] = ’$’) entonces encontrado verdadero

si_no

i

pos + 1pos 0fin_si

si_no

i i + 1fin_si

fin_mientras

devolver(pos)fin_función

g. Crear una función que extraiga parte de una cadena, sabiendo el inicio y el fin, e insertarlo de una segundacadena.

procedimiento subcadena(E cadena : c1; E entero : inicio, long; E/S cadena : c2)

varentero : i, k

inicio

si (inicio <= 0) o (inicio > longitud(c1)) entonces c2[1] ‘$’

si_no

i iniciok 1 mientras (i <= inicio + long) y (c1[i] < > ‘$’) hacer

c2[k] c1[i]k k + 1i i + 1

fin_mientras

c2[k] ‘$’fin_si

fin_procedimiento




73

8.9. Definición de una clase

clase rectángulo

// Atributosvar

privado real : largo, ancho// Métodos// Método constructorconstructor rectángulo(E real : lar, anc)inicio

largo larancho anc

fin_constructor

// Método que modifica el valor del atributo largo público procedimiento modificarLargo(E real : lar)inicio

largo larfin_procedimiento

// Método que retorna el valor del atributo largo público real función mostrarLargo()inicio

devolver(largo)fin_función

// Método que modifica el valor del atributo ancho público procedimiento modificarAncho(E real : anc)inicio

ancho ancfin_procedimiento

// Método que retorna el valor del atributo ancho público real función mostrarAncho()inicio

devolver(ancho)fin_función

// Método que retorna el área o superficie ocupada por el rectángulo público real función calcularÁrea()inicio

devolver(largo * ancho)fin_función




74

// Retorna el perímetro del rectángulo público real función calcularPerímetro()inicio

devolver(2 * (largo + ancho))fin_función

fin_clase

// Uso de la clase rectánguloclase algoritmoPrincipal

// Atributosvar

// Se declara una variable de tipo objeto rectángulo a la cual llamaremosrect privado rectángulo : rect// Se declaran las variables reales l y a para largo y ancho delrectángulo privado real : l, a

público método principal() inicio

escribir(“Suministre a continuación los valores para el largo y el ancho”)

leer(l)leer(a)rect = nuevo rectángulo(l, a)escribir(“Resultados de los cálculos”)escribir(“Área: ”+ rect.calcularÁrea())escribir(“Perímetro ” + rect.calcularPerímetro())

fin_metodo

fin_clase

8.10. Asociación (ver algoritmo del Ejemplo 8.9.)




75

8.11. Herencia, clase abstracta y asociación

abstracto clase persona

// Atributosvar

privado entero : cedula privado cadena : nombre privado entero : edad

// Métodos// Método constructor

constructor persona(E entero : c; E cadena : n; E entero : e)inicio

cedula cnombre nedad e

fin_constructor

// Método que modifica el valor del atributo cedula público procedimiento modificarCédula(E entero: c)inicio

cedula cfin_procedimiento

// Método que retorna el valor del atributo cedula

público real función mostrarCédula()iniciodevolver(cedula)

fin_función

// Método que modifica el valor del atributo nombre público procedimiento modificarNombre(E cadena : n)inicio

nombre nfin_procedimiento




76

// Método que retorna el valor del atributo nombre público real función mostrarNombre()inicio

devolver(nombre)fin_función

// Método que modifica el valor del atributo edad público procedimiento modificarEdad(E cadena : e)

inicioedad efin_procedimiento

// Método que retorna el valor del atributo edad público real función mostrarEdad()inicio

devolver(edad)fin_función

fin_clase

clase alumno hereda_de persona

// Atributosvar

privado entero : identificacion

// Métodos// Método constructorconstructor alumno(E entero : c; E cadena : n; E entero : e, i)inicio

super(c, n, e)identificacion i

fin_constructor

// Método que modifica el valor del atributo identificación público procedimiento modificarIdentificación(E entero: i)inicio

identificacion i

fin_procedimiento

// Método que retorna el valor del atributo identificación público real función mostrarIdentificación()inicio

devolver(identificacion)fin_función

fin_clase

clase algoritmoPrincipal

// Atributosvar

privado alumno : estudiante

privado entero : c, e, i privado cadena : n

público método principal()inicio

escribir(“Suministre los datos del alumno”)leer(c)leer(n)leer(e)leer(i)estudiante = nuevo alumno(c, n, e, i)escribir(“Los datos del alumno son: ”)




77

escribir(“Cédula de identidad: ”+ estudiante.mostrarCedula())escribir(“Nombre: ” + estudiante.mostrarNombre())escribir(“Edad: ” + estudiante.mostrarEdad())escribir(“N° de carnet: ” + estudiante.mostrarIdentificacion())

fin_metodo

fin_clase

8.12. Polimorfismo, herencia, clase abstracta y asociación

abstracto clase cudrilátero

var privado entero : color

// Métodos// Método constructorconstructor cuadrilátero(E entero : c)inicio

color cfin_constructor




78

// Método que modifica el valor del atributo color público procedimiento modificarColor(E entero: c)inicio

color cfin_procedimiento

// Método que retorna el valor del atributo color público real función mostrarColor()

iniciodevolver(color)fin_función

// Método que calcula el área del cudrilátero abstracto público real función calcularÁrea()iniciofin_función

fin_clase

clase cuadrado hereda_de cuadrilátero

// Atributosvar

privado real : lado

// Métodos// Método constructorconstructor cuadrado(E entero : c, E real : l)inicio

super(c)lado l

fin_constructor

// Método que modifica el valor del atributo lado público procedimiento modificarLado(E entero: l)inicio

lado lfin_procedimiento

// Método que retorna el valor del atributo lado público real función mostrarLado()inicio

devolver(lado)fin_función

// Método que calcula el área del cuadrado público real función calcularÁrea()inicio

devolver(lado ** 2)fin_función

// Método que calcula el perímetro del cuadrado público real función calcularPerímetro()

iniciodevolver(4 * lado)

fin_función

fin_clase

clase rectángulo hereda_de cuadrilátero

// Atributosvar

privado real : ladoA, ladoB




79

// Métodos// Método constructorconstructor rectángulo(E entero : c, E real : lA, lB)inicio

super(c)ladoA lAladoB lB

fin_constructor

// Método que modifica el valor del atributo lado público procedimiento modificarLadoA(E entero: lA)inicio

ladoA lAfin_procedimiento

// Método que retorna el valor del atributo ladoA público real función mostrarLadoA()inicio

devolver(ladoA)fin_función

// Método que modifica el valor del atributo ladoB público procedimiento modificarLadoB(E entero: lB)inicio

ladoB lBfin_procedimiento

// Método que retorna el valor del atributo ladoB público real función mostrarLadoB()inicio

devolver(ladoB)fin_función

// Método que calcula el área del rectángulo público real función calcularÁrea()inicio

devolver(ladoA * ladoB)

fin_función

// Método que calcula el perímetro del rectángulo público real función calcularPerímetro()inicio

devolver(2 * (ladoA + ladoB))fin_función

fin_clase

clase cubo hereda_de cuadrado

// Atributosvar

privado real : altura

// Métodos// Método constructorconstructor cubo(E entero : c, E real : l, a)inicio

super(c, l)altura a

fin_constructor




80

// Método que modifica el valor del atributo altura público procedimiento modificarAltura(E entero: a)inicio

altura afin_procedimiento

// Método que retorna el valor del atributo altura público real función mostrarAltura()

iniciodevolver(altura)fin_función

// Método que calcula el volumen del cubo público real función calcularVolumen()inicio

devolver(altura * super.calcularÁrea())fin_función

fin_clase

clase algoritmoPrincipal

// Atributosvar

privado cubo : c privado rectángulo : r privado entero : colorCubo, colorRectangulo privado real : lado, altura, ladoA, ladoB

público método principal()inicio

escribir(“Suministre los datos de las figuras”)leer(colorCubo)leer(lado)leer(altura)leer(ladoA)leer(ladoB)leer(colorRectangulo)c = nuevo cubo(colorCubo, lado, altura)r = nuevo rectángulo(colorRectangulo, ladoA, ladoB)escribir(“El volumen del cubo es: ” + c. calcularVolumen())escribir(“El área del rectángulo es: ”+ r.calcularÁrea())escribir(“El perímetro del rectángulo es:” + r.calcularPerímetro())

fin_metodo

fin_clase




Bibliografía

• Joyanes, L. (2007). Fundamentos de Programación - Algoritmos, Estructuras de Datos y Objetos .Tercera Edición. Madrid, España: Mc Graw Hill.

• Joyanes, L. (2003). Libro de Problemas, Fundamentos de Programación - Algoritmos, Estructuras de

Datos y Objetos. Segunda Edición. Madrid, España: Mc Graw Hill.• Joyanes, L. (2006). Programación en Pascal. Cuarta Edición. Madrid, España: Mc Graw Hill.

• Kimmel, P. (2007). Manual de UML. Primera Edición. Mc Graw Hill.

• Leestma, S. y Nyhoff, L. (2000). Programación en Pascal. Cuarta Edición. Madrid, España: Pretence Hall.

apuntes de algoritmos

Documents