Apuntes de Algoritmos

Apuntes de algoritmos
Apuntes de algoritmos Contenido

1. Algoritmos y Programas ............................................................... 3
1.1. Computadoras y lenguaje de programacin ......................................................3 1.2. Resolucin de problemas...................................................................................5 1.3. Datos ..................................................................................................................8 1.4. Representacin de algoritmos .........................................................................13
2. Estructura general de un programa........................................... 17

2.1. Estructura general de un algoritmo en pseudocdigo .....................................17 2.2. Operacin de asignacin .................................................................................17 2.3. Conversin de tipos .........................................................................................19 2.4. Contadores.......................................................................................................20 2.5. Acumuladores ..................................................................................................21 2.6. Interruptores .....................................................................................................21
3. Estructura general de un programa........................................... 22

3.1. Programacin estructurada ..............................................................................22 3.2. Estructura secuencial .......................................................................................22 3.3. Estructura selectiva ..........................................................................................23 3.4. Estructura repetitiva .........................................................................................24 3.5. Estructura anidada ...........................................................................................27
4. Subalgoritmos, funciones y procedimientos............................ 29

4.1. Programacin modular .....................................................................................29 4.2. Funciones.........................................................................................................29 4.3. Procedimientos.................................................................................................30 4.4. Estructura general de un algoritmo ..................................................................32 4.5. Parmetros de los subalgoritmos.....................................................................32 4.6. Variables locales y globales .............................................................................34
5. Tipos de datos estructurados .................................................... 35

5.1. Datos estructurados .........................................................................................35 5.2. Arreglos ............................................................................................................35 5.3. Registros ..........................................................................................................39 5.4. Cadenas de caracteres ....................................................................................40
6. Introduccin a la programacin orientada a objetos............... 43

6.1. Objeto...............................................................................................................43 6.2. Clase ................................................................................................................44 6.3. Relacin entre clase y objeto ...........................................................................44 6.4. Atributos ...........................................................................................................45 6.5. Mtodos............................................................................................................45 6.6. Mensaje............................................................................................................46
1
6.7. Diagrama de clases .........................................................................................46 6.8. Relaciones entre clases ...................................................................................47
7. Fundamentos del enfoque orientado a objeto.......................... 50

7.1. Abstraccin.......................................................................................................50 7.2. Encapsulamiento (ocultamiento de informacin) .............................................50 7.3. Modularidad......................................................................................................51 7.4. Herencia ...........................................................................................................51 7.5. Polimorfismo.....................................................................................................51
8. Ejemplos....................................................................................... 53
8.1. Expresiones......................................................................................................53 8.2. Diagramas de flujo ...........................................................................................53 8.3. Estructuras de seleccin ..................................................................................54 8.4. Estructuras de repeticin .................................................................................56 8.5. Funciones y procedimientos ............................................................................58 8.6. Arreglos ............................................................................................................62 8.7. Registros ..........................................................................................................67 8.8. Cadenas ...........................................................................................................70 8.9. Definicin de una clase ....................................................................................73 8.10. Asociacin (ver algoritmo del Ejemplo 8.9.)...................................................74 8.11. Herencia, clase abstracta y asociacin..........................................................75 8.12. Polimorfismo, herencia, clase abstracta y asociacin ...................................77
Bibliografa ....................................................................................... 81
1. Algoritmos y Programas
1.1. Computadoras y lenguaje de programacin
1.1.1. Computador u ordenador
Dispositivo electrnico utilizado para procesar datos en forma automtica y obtener resultados los cuales pueden a su vez ser organizados y analizados para producir informacin. El computador est conformado por una parte fsica llamada hardware y por una parte lgica o de programas llamada software.
1.1.2. Datos
Es una representacin de hechos, conceptos o instrucciones, organizados de manera que se puedan procesar, interpretar o comunicar por medios humanos o automticas. Los datos, son por ejemplo, representaciones de las caractersticas de una persona, objeto, concepto o hecho. Los datos se pueden introducir en el computador como entrada y se procesan para producir resultados e informacin de salida.
1.1.3. Hardware
Es el conjunto de componentes fsicas que forman un computador. Como ejemplo tenemos los chips de los procesadores (CPU, procesadores matemticos, procesadores de video), 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 dispositivos perifricos (ratn, teclado, monitor, impresora)
1.1.4. Software
Son los programas que permiten utilizar los recursos del computador. Programacin, soporte lgico, parte no-mecnica o no-fsica de un sistema. Es un conjunto de programas y procedimientos que se incluyen en un computador o equipo con el fin de hacer posible el su uso eficaz de dicha mquina. Son las instrucciones responsables de que el hardware (la mquina) realice su tarea. Como ejemplo tenemos los sistemas operativos, el software de aplicacin, el software utilitario y los lenguajes de programacin.
Sistema operativo
Software bsico encargado de controlar diferentes procesos en el computador mediante tres grandes funciones: Coordinar y manipular el hardware del computador: como los procesadores, la memoria, las impresoras, las unidades de almacenamiento, el monitor, el teclado o el ratn; Organizar los archivos en diversos dispositivos de almacenamiento, como discos flexibles, discos duros, Cds. Gestionar los errores de hardware y la prdida de datos.
Software de aplicacin
Programa informtico diseado para facilitar al usuario la realizacin de un determinado tipo de trabajo. Algunas son aplicaciones desarrolladas a la medida que ofrecen una gran potencia y soluciones eficientes ya que estn exclusivamente diseadas para resolver un problema especfico. Son ejemplos de este tipo de
Apuntes de algoritmos software los programas que realizan tareas concretas como manejo de nmina, anlisis de estadsticas, manejo de almacn, etc.
Software utilitario
Son programas que facilitan el uso del computador como herramienta para solucionar actividades generales como la edicin de textos o la digitalizacin de materiales. En muchos casos los programas utilitarios son agrupados en paquetes integrados de software, por ejemplo el Microsoft Office o el OpenOffice, donde se ofrece soluciones ms generales, pero se incluyen varias aplicaciones (procesador de textos, de hoja de clculo, manejador de base de datos, correo electrnico, visor de imgenes, etc.).
Lenguajes de programacin
Sirven para escribir programas que permitan la comunicacin usuario/mquina y la soluciones de problemas utilizando las ventajas, poder de clculo, procesamiento y almacenamiento del computador.
Diferencias entre los tipos software

El software de aplicacin se diferencia de un sistema operativo (que hace funcionar al ordenador), de una utilidad (que realiza tareas de mantenimiento o de uso general) y de un lenguaje (con el cual se crean los programas informticos), en que suele resultar una solucin informtica para la automatizacin de tareas en un rea determinada (procesamiento de texto, edicin de imgenes, estadstica, 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 mismo dispositivo de almacenamiento para las instrucciones y para los datos (a diferencia de la arquitectura Harvard). El trmino se acu en el ao 1945, escrito por el conocido matemtico John Von Neumann, que propuso 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 el computador. Esta informacin est representada en una codificacin binaria de 0 y 1. La memoria se divide en celdas, donde cada celda tiene una direccin nica, de tal forma que el contenido de ellas puede ser buscado, extrado y utilizado.
Unidad central de proceso (CPU o Procesador)

Es el subsistema encargado de extraer las instrucciones y los datos en la memoria principal para realizar los tratamientos u operaciones correspondientes. Est conformado por la Unidad de control y la Unidad lgicoaritmtica Unidad de control (UC). Se encarga de: Obtener de la memoria la prxima instruccin a utilizar o ejecutar. Decodificar la instruccin para determinar qu debe hacerse. Segn la decodificacin hecha, enviar el comando apropiado a la ALU, memoria o controlador de entrada/salida para que realice la tarea.
Unidad lgico-aritmtica (ALU). Se encarga de realizar las operaciones aritmticas y comparaciones.
Dispositivo de entrada/salida
Es el subsistema que permite al computador interactuar con otros dispositivos, comunicarse con el mundo exterior y almacenar los datos y programas en unidades permanentes, por ejemplo, el disco duro. Est conformado por: Bus o unidades de intercambio. Permiten comunicar informacin entre los componentes del sistema, los perifricos y el mundo exterior. Memoria secundaria. Permite conservar datos y programas en forma permanente, an luego de apagar el computador. Perifricos. Son dispositivos utilizados para suministrar informacin entre el computador y el exterior (monitor, teclado, ratn, tarjeta de red, impresoras, tarjetas de memoria, escner, etc.).
1.2. Resolucin de problemas

1.2.1. Algoritmo (algorithm)
Es un conjunto bien definido de procedimientos lgicos o matemticos que se pueden seguir para resolver un problema en un nmero finito de pasos. Es una lista finita de pasos que plantean una solucin a un problema, preferiblemente pasos los ms cortos y simples posibles. Para un mismo problema pueden existir muchos algoritmos que conducen a su solucin. La eleccin del mejor algoritmo est guiada por criterios de eficiencia y eficacia, entre otras caractersticas deseables. Elementos de un algoritmo: Datos de entrada. Proceso o pasos que resuelven el problema. Datos de salida.
Caractersticas de un algoritmo
Un algoritmo debe ser preciso e indicar el orden de realizacin de cada paso. El resultado del algoritmo debe estar definido. Si se sigue un algoritmo dos veces con los mismos datos de entrada, se debe obtener el mismo resultado cada vez. Un algoritmo debe ser finito. Si se sigue un algoritmo, se debe terminar en algn momento, es decir, se debe tener un nmero finito de pasos.
1.2.2. Pseudocdigo
En un algoritmo expresado de manera ms formal. Se utiliza como una representacin intermedia, antes de traducirlo o codificarlo con un lenguaje de programacin. En las clases de Algoritmo utilizaremos el pseudocdigo para expresar las soluciones algortmicas creadas.
1.2.3. Lenguaje de programacin

En computacin es cualquier lenguaje artificial que puede utilizarse para definir una secuencia de instrucciones, a fin de que puedan ser procesadas por un computador. Conjunto de caracteres, reglas, palabras y operaciones con significados previamente asignados y que permiten escribir programas. La definicin de un lenguaje de programacin cubre tres aspectos: Lxico. Define los smbolos que sirven para la redaccin de un programa y las reglas para la formacin de palabras en el lenguaje. Por ejemplo, 10 es un nmero entero. Sintaxis. Conjunto de reglas que permiten organizar las palabras del lenguaje en frases, por ejemplo, la operacin de divisin se define como Dividendo/Divisor. Semntica. Define las reglas que dan sentido a una frase.
Los principales tipos de lenguajes de programacin utilizados en la actualidad son: Lenguajes de mquina. Lenguajes de bajo nivel y traductores (lenguaje ensamblador, compiladores, intrpretes). 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 Computacin, es el conjunto de instrucciones que definen la secuencia de eventos que un computador debe ejecutar para llevar a cabo una tarea, realizando clculos y suministrando resultados. Grupo de instrucciones compuestas con la finalidad de resolver un problema especfico mediante el uso de un computador. Un programa est codificado en un lenguaje que la mquina es capaz de entender y procesar. Es la traduccin de un algoritmo o de un pseudocdigo utilizando un lenguaje de programacin.
1.2.5. Programacin
Proceso que comprende el anlisis del problema, diseo de la solucin, escritura o desarrollo del programa, prueba del programa y su correccin. Es la disciplina de la Computacin que trata el desarrollo de programas.
1.2.6. Aspectos que miden la calidad en un programa

Algunos aspectos que se consideran para medir la calidad de un programa, tambin llamados caractersticas deseables en un programa, son: Legibilidad Robustez Eficacia Eficiencia Adaptabilidad 6
Apuntes de algoritmos Portabilidad Reusabilidad del software
1.2.7. Capacidad de abstraccin

Mecanismo intelectual principal en la actividad de la programacin, el cual durante la etapa de anlisis del problema permite la separacin de los aspectos relevantes de los irrelevantes en el contexto estudiado. Por ejemplo, si el problema consiste en determinar cul es la persona ms alta del saln, lo relevante es la estatura de cada persona, y no color de ojos, talla de calzado, etc.
1.2.8. Enfoques para solucionar un problema

Programacin modular. Consiste en dividir el problema original en diversos subproblemas que se pueden resolver por separado, para despus recomponer los resultados y obtener la solucin al problema. Enfoque divide y vencers. consiste en resolver un problema a partir de la solucin de subproblemas del mismo tipo, pero de menor tamao. Si los subproblemas son todava relativamente grandes se aplicar de nuevo esta tcnica hasta alcanzar subproblemas lo suficientemente pequeos para ser solucionados directamente. Diseo descendente (top-down). Consisten en disear los algoritmos en etapas, yendo de los conceptos generales a los detalles. Ejemplo, para el problema de indicar los pasos para ver una pelcula en el cine se podra considerar en un primer nivel los siguientes pasos: Ir al cine. Comprar una entrada. Ver la pelcula. Regresar a casa. Luego cada uno de estos pasos puede subdividirse en otros niveles donde las instrucciones sean cada vez ms especficas.
1.2.9. Fases en la resolucin de problemas

Resolver problemas a travs de un computador se basa principalmente en analizar, disear, escribir y ejecutar un programa con pasos orientados a solucionar el problema. Podemos considerar como fases de resolucin de un problema las siguientes: Anlisis del problema Diseo del algoritmo, utilizando pseudocdigo. Codificacin, traduccin del algoritmo a un lenguaje de programacin, esto nos permite crear el programa. Ejecucin del cdigo del programa. Verificacin del programa. Documentacin. Depuracin de errores. Mantenimiento y mejora del programa.
1.2.10. Ciclo de vida de desarrollo del software

Anlisis. El problema se analiza teniendo en cuanta los requerimientos o necesidades expresadas por el cliente, la empresa o las personas que utilizaran el programa. 7
Apuntes de algoritmos Diseo. Una vez analizado el problema se disea una solucin que conduce a un algoritmo general que resuelve los elementos ms significativos del programa. Este algoritmo puede ser escrito utilizando pseudocdigo. Codificacin (implementacin). La solucin expresada en pseudocdigo se traduce a un programa que el computador pueda procesar utilizando un lenguaje de programacin de alto nivel. Compilacin, ejecucin y verificacin. El programa se ejecuta (corre) y se verifica para eliminar errores de programacin o de lgica. Documentacin. Se agrega al cdigo del programa lnea de texto que ayudan al programador y a las personas que a futuro harn mantenimiento al software a entender su estructura y comportamiento. La documentacin tambin incluye escribir informes en donde se describe cmo se realizaron las diferentes fases del ciclo de vida del software (en especial los procesos de anlisis, diseo, codificacin y prueba), se agregan manuales de usuario y de referencia, as como normas para el mantenimiento. Depuracin y mantenimiento. El programa se actualiza y modifica en la medida en que sea necesario de manera que cumpla con las necesidades de los usuarios las cuales tambin cambian en el tiempo.
1.3. Datos
1.3.1. Dato
Diferentes entidades u objetos de informacin con que trabaja un programa. Determina el conjunto de valores que la entidad puede almacenar, los operadores y las operaciones definidos sobre ellos. Los datos tienen 3 caractersticas: 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 operacin.
1.3.2. Tipo de dato

Define el conjunto de valores que un elemento o un objeto (una variable, constante, expresin o funcin) de dicho 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: Estndar. Que vienen en el sistema por defecto. No estndar. Son los que crea el usuario.
Los tipos simples ms importantes son: Numricos Entero. Subconjunto finito del conjunto matemtico de los nmeros enteros. No tiene parte decimal. El rango de los valores depende del tamao que se les da en memoria. Real. Subconjunto finito del conjunto matemtico de los nmeros reales. Llevan signo y parte decimal. Se almacenan en 4 Bytes (dependiendo de los modificadores). Si se utilizan nmeros reales muy grandes, se puede usar notacin cientfica que se divide en mantisa, base y exponente; tal que el valor se obtiene multiplicando la mantisa por la base elevada al exponente. 8
Apuntes de algoritmos Lgicos o booleanos. Aquel que slo puede tomar uno de los dos valores, verdadero o falso (1/0). Carcter. Abarca al conjunto finito y ordenado de caracteres que reconoce la computadora (letras, dgitos, 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 ms modernos.
1.3.3. Posible clasificacin de los tipos de datos

Tipos de datos primitivos o elementales: tipos bsicos incluidos en cada lenguaje de programacin. En el lenguaje de programacin Java, tambin son llamados tipos integrados. Tipos de datos estructurados: tipos basados o construidos a partir de tipos de datos primitivos (por ejemplo, arreglo, registro, archivo, conjunto). Tipos de datos abstractos (TDA): tipos de datos definidos por el usuario y las operaciones abstractas aplicadas sobre ellos. Los TDA apoyan el concepto de ocultamiento de la informacin. Esconden los detalles de la representacin y permiten el acceso a los objetos slo a travs de sus operaciones, son ejemplos las representaciones de los TDA Lista, Cola, Pila, rbol y la representacin que hace el Enfoque Orientado a Objeto mediante atributos y mtodos.
Esquemas de organizacin de los tipos de datos

Esquema 1 Nmero de componentes 1 Tipos de datos n Estructurado Elemental Tipo de componentes - Entero, Real (numricos) - Carcter, Cadenas de caracteres (caracteres) - Lgico (bolanos) Homogneos (todos los elementos iguales) - Arreglos - Archivos Heterogneos (aceptan elementos distintos) - Registros
Esquema 2 Estndar
Tipos de datos
Estticos
Dinmicos
- Entero - Real - Carcter - Lgico (bolanos) - Arreglo (Vector, Matriz, Cubo) - Registro - Archivo (Fichero) - Cadena de caracteres - 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 la ejecucin. Pueden ser numricos, lgicos, carcter o cadena. Las constantes pueden llevar asociados un nombre o no, si no lo llevan, se llaman literales. Su valor hay que darlo al definir la constante y ya no puede cambiar a lo largo de la ejecucin, y en cuanto al tipo,
Apuntes de algoritmos dependiendo de los lenguajes en algunos hay que ponerlo, y en otros no hace falta ponerlo porque toma el tipo 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. Es decir, una entidad cuyo valor puede cambiar a lo largo del programa. En un programa de computador se puede asumir que una variable es una posicin de memoria donde los valores asignados pueden ser reemplazados o cambiados por otros valores durante la ejecucin del programa. Antes de usar una variable hay que definirla o declararla, al hacerlo hay que dar su nombre y su tipo. El nombre 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 tamao depende del lenguaje. 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. En cualquier caso el valor de la variable se debe inicializar o ir variarlo a lo largo de la ejecucin.
var <tipo_de_dato> : <lista_identificadores_de_variables> Ejemplo: var entero : mayor, menor real : precio lgico : 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, automticamente se reserva en memoria espacio para guardar esa variable o constante. El espacio reservado depende del tipo de la variable.
1.3.6. Operaciones de los tipos de datos elementales

Operacin. Accin por medio de la cual se obtiene un resultado de un operando. Ejemplos: sumar, dividir, unir, restar. Operando. nmero, texto, valor lgico, variable o constante sobre la cual es ejecutada una operacin. Operador. smbolo que indica la operacin que se ha de efectuar con el operando, por ejemplo, + - * >= = <> <= = /
1.3.7. Expresiones
Son combinaciones de constantes, variables, smbolos de operacin, parntesis y nombres de funciones o acciones. Cada expresin toma un valor que se determina considerando los valores de las variables, constantes y operaciones implicadas.
10
Apuntes de algoritmos Una expresin consta de operandos y operadores. Segn sea el tipo de datos que manipulan, las expresiones se pueden clasificar en Aritmticas, Lgicas o Carcter. As tenemos:
Numricas: Operadores aritmticos

Son los que se utilizan en las expresiones numricas (una combinacin de variables y/o constantes numricas con operadores aritmticos y que al evaluarla devuelve un valor numrico. +, -, *, / Operacin resto: Lo que devuelve es el resto de una divisin entera. 5 mod 3 = 2 Divisin entera: Nos devuelve el cociente de una divisin 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 sita en medio), el menos tambin puede ser unario (lleva un nico operando) y significa signo negativo. Reglas de precedencia El problema es cuando una expresin entera segn como la evale pueda dar diferentes valores. 7 * 3 + 4 25
La solucin es aplicar prioridad entre los operadores, de modo que ante la posibilidad de usar varios siempre aplicaremos primero el de mayor prioridad. Cada lenguaje puede establecer sus propias reglas de prioridad o precedencia de operadores. Si no nos acordamos, siempre podemos poner ( ). ^ ** * + / div mod
Entre dos operaciones que tienen la misma precedencia para resolver la ambigedad, hay que usar la regla de la asociatividad. La ms normal es la de la asociatividad a izquierdas (primero lo de la izquierda).
Expresiones lgicas: Operadores relacionales y lgicos

Una expresin lgica es aquella que slo puede devolver dos valores (Verdadero o Falso). Los valores que pueden aparecer en una expresin lgica son de 2 tipos: lgicos y relacionales. La particularidad de las expresiones lgicas es que mientras en una expresin numrica por devolver un valor numrico los operandos solo pueden ser nmeros, en una expresin lgica los operandos no tienen porque ser booleanos aunque se devuelva un valor booleano. Esto es lo que ocurre cuando en la expresin lgica utilizamos operadores relacionales con lo cual se obtienen valores lgicos o booleanos a partir de otros que no lo son. En cambio cuando los operadores son lgicos los operandos obligatoriamente tambin tienen que ser lgicos. Operadores relacionales <, >, =, <>, <=, >= < Operando1> operador < Operando2> 5 > 3 Verdadero
11
Apuntes de algoritmos Cmo se evala una expresin relacional? Primero se evala el primer operando y se sustituye por su valor. Luego se evala 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 El problema del tipo real: Desde la informtica, los nmeros reales son finitos, ya que tenemos un mximo de cifras decimales. Cuando trabajamos con un =, matemticamente 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 programacin. Se considera un valor de error. Trabajar con nmeros enteros siempre que sea posible. Utilizar las comparaciones <> en vez de <= => si es posible. Si hay que preguntar por igual, cambiar la condicin utilizando valores absolutos y un valor mnimo de error. Si la diferencia < 0.00000001 y ABS (A - B) < min; son iguales. < 1 Verdadero
Operadores lgicos El problema es que a veces queremos preguntar o evaluar por ms de una condicin al mismo tiempo y para esto estn los operadores lgicos. Y O No Y, O, son operadores binarios (necesitan 2 operandos de tipo lgico). Operando 1 Operador Operando 2
El No es unario, se coloca primero el No, y despus el operando. El resultado es lgico y depende de: Operando 1 V V F F El No niega: Operando V F No F V Operando 2 V F V F Y V F F F O V V V F
12
1.3.8. Precedencia
Prioridad definida entre los operadores. Indica en qu orden debe aplicarse diferentes operaciones sobre un conjunto de valores. Permiten aplicar los operadores en el orden correcto. ( ) ** div + < No mod > / O = <= >= <> * Y
De mayor prioridad a menor prioridad. En caso de haber operadores del mismo nivel en una expresin, se evalan en orden de aparicin de izquierda a derecha. En expresiones donde se combinen operadores se evala primero los aritmticos, luego los relacionales y de ltimo los operadores lgicos.
1.3.9. Funciones internas

Son funciones matemticas diferentes de las operaciones bsicas pero que se incorporan al lenguaje y que se consideran estndar. Dependen del lenguaje. Normalmente se encuentran en la librera de matemticas del lenguaje de programacin. Funcin abs (x) arctan (x) cos (x) sen (x) ent (x) exp (x) ln (x) log10 (x) redondeo (x) trunc (x) cuadrado (x) raiz2 (x) Descripcin Valor absoluto de x Arcotangente de x Coseno de x Seno de x Entero de x E elevado a x Logaritmo natural de x Logaritmo base 10 de x Redondea x al entero ms prximo Parte entera de x Cuadrado de x Raz cuadrada de x Tipo de argumento Entero o real Entero o real Entero o real Entero o real Real Entero o real Entero o real Entero o real Real Real Entero o real Entero o real Real Real Real Entero Real Real Real Entero Entero Igual que el argumento Real Resultado Igual que el argumento
1.4. Representacin de algoritmos

Un algoritmos puede ser escrito en castellano narrativo, pero esta descripcin suele ser demasiado extenso y, adems, ambigua. Para representar un algoritmo se utilizar algn mtodo que permita independizar dicho algoritmo de los lenguajes de programacin y, al mismo tiempo, que sea fcilmente codificable. Los mtodos ms usuales para la representacin de algoritmos son: Diagramas de flujo Diagramas N-S (Nassi-Schneiderman) Pseudocdigo.
13
1.4.1. Diagramas de flujo

Es una notacin grfica para implementar algoritmos. Se basa en la utilizacin de unos smbolos grficos que se denominan cajas, en las que se escribe las acciones que tiene que realizar el algoritmo. Las cajas estn conectadas entre s por lneas y eso nos indica el orden en el que tenemos que ejecutar las acciones. En todo algoritmo siempre habr una caja de inicio y otra de fin, para el principio y final del algoritmo. Smbolo Funcin Lneas de flujo. Una lnea con una flecha que sirve para conectar los smbolos del diagrama y la flecha indica la secuencia en la que se van a ejecutar las acciones. Principio y fin. Dentro del smbolo ira la palabra inicio o fin del algoritmo.
Proceso. Indica la accin que tiene que realizar la computadora. Dentro escribimos la accin.
Entrada y salida. Dentro colocaremos las acciones de lectura y escritura
Condicin. Dentro se va a colocar una condicin. Sirve para representar estructuras selectivas y repetitivas Comentario. Es una aclaracin para entender mejor el cdigo, pero no es parte de este, no se ejecuta. Ejemplo: Obtener el rea de un rectngulo.
inicio
base
altura
area = base * altura
area
fin
14
1.4.2. Diagramas N-S (Nassi-Schneiderman)

Los diagramas Nassi-Schneiderman, denominados as por sus inventores, son herramientas de programacin que favorece la programacin estructurada y rene caractersticas grficas propias de diagrama de flujo y lingsticas propias de los pseudocdigos. Consta de una serie de cajas contiguas que se leern siempre de arriba-abajo y se documentarn de la forma adecuada. En los diagramas N-S las tres estructuras bsicas de la programacin estructurada, secuencial, selectiva y repetitiva, encuentran su representacin propia. Ejemplo: Hallar el producto de varios nmeros positivos introducidos por teclado y el proceso termina cuando se meta un nmero negativo.
inicio p 1
leer num mientras num >= 0 p p*num
leer num escribir p fin
1.4.3. Pseudocdigo
Es un lenguaje de especificacin de algoritmos, pero muy parecido a cualquier lenguaje de programacin, por lo que luego su traduccin al lenguaje es muy sencillo, pero con la ventaja de que no se rige por las normas de un lenguaje en particular. Nos centramos ms en la lgica del problema. El pseudocdigo tambin va a utilizar una serie de palabras clave o palabras especiales que va indicando lo que significa el algoritmo. algoritmo <identificador_algoritmo> // declaraciones, sentencias no ejecutables inicio // acciones, sentencias ejecutables tanto simples como estructuradas fin Comentarios. Sirven para documentar el algoritmo y en ellos se escriben anotaciones generalmente sobre su funcionamiento. // comentario de una lnea { comentario que ocupa ms de una lnea } Palabras reservadas. Son las palabras que tienen un significado especial, como inicio y fin. En lugar de las palabras reservadas no deben usarse otras similares, aunque no se distingue entre mayscula y minsculas. inicio, fin si, entonces, si_no, fin_si segn_sea, hacer, fin_segn
15
Apuntes de algoritmos mientras, fin_mientras desde, hasta, incremento, decremento, fin_desde, etc. Identificadores. Son los nombres que se dan a las constantes, variables, procedimientos u otros objetivos que manipula el algoritmo.
Ejemplo: Obtener el rea de un rectngulo. algoritmo area_rectangulo entero : base, altura, area inicio leer(base) leer(altura) area base * altura escribir(area) fin Ejemplo: Hallar el producto de varios nmeros positivos introducidos por teclado y el proceso termina cuando se meta un nmero negativo. algoritmo producto_positivos entero : p, num inicio p 1 leer(num) mientras (mun >= 0) hacer p p * num leer(num) fin_mientras escribir(p) fin
16
2. Estructura general de un programa

2.1. Estructura general de un algoritmo en pseudocdigo
El pseudocdigo es la herramienta ms adecuada para la representacin de algoritmos. El algoritmo en pseudocdigo debe tener una estructura muy clara y similar a un programa, de modo que facilite al mximo su posterior codificacin. 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 datos definidos por el usuario y las variables. Bloque de instrucciones. Contiene las acciones a ejecutar para la obtencin de los resultados. Las instrucciones o acciones bsicas a colocar en este bloque se podran clasificar del siguiente modo: o o o o Inicio y fin. La primera instruccin de este bloque ser siempre la de inicio y la ltima la de fin. Asignacin. Dar un valor a una variable. Lectura / escritura. Introducir o sacar informacin por dispositivos E/S. Instrucciones de bifurcacin. Alteran El orden de ejecucin del programa. Salto a otra instruccin que no es la siguiente.
// cabecera algoritmo <nombre_del_algoritmo> // bloque de declaraciones const <listado_constantes> var <listado_variables> entero : var1, var2 // bloque de instrucciones inicio // inicio del bloque de instrucciones var1 0 // asignacin
escribir(ingresar un valor: ) // escritura leer(var2) // escritura fin // fin del bloque de instrucciones
2.2. Operacin de asignacin

Es el modo de darle un valor a una variable, el cual puede ser una constante, otra variable o el resultado de una expresin. En pseudocdigo la operacin de asignacin se representa mediante el smbolo u operador asignacin. para la
En el contexto de un lenguaje de programacin, a la operacin de asignacin, se le llama instruccin o sentencia de asignacin.
17
Apuntes de algoritmos Comportamiento: Modifica el estado de la variable. La notacin algortmica (sintaxis) que utilizaremos para la asignacin es: <nombre_de_variable> <constante_o_variable_o_expresin>
Ejemplo. Considerando la siguiente declaracin de variables: caracter : c1 entero : i lgico : enc // a continuacin se asignar a la variable c1 el carcter a c1 a // Luego de la asignacin, el valor de enc es Verdadero enc (1 > 0) // Luego de la asignacin, el valor de i es 10 i 5 + 15 div 3
Reglas de la asignacin
Sea la expresin: Operador de asignacin Izquierda Variable a quien se asigna b c*2,45 Derecha Expresin cuyo resultado se asigna
Una variable en el lado derecho de una sentencia de asignacin debe tener un valor antes de que la sentencia de asignacin se ejecute, en el ejemplo, a la variable c se le debe asignar un valor antes a fin de que la expresin c*2.45 arroje un resultado. Hasta que en el algoritmo a una variable no se le asigna (usando el operador = o a travs de una lectura) se asume que no ha sido inicializada. En la izquierda de una sentencia de asignacin slo pueden existir variables y eventualmente una constante, por lo tanto la expresin ValorNeto Tasa = Interes * 3,15 es un error.
2.2.1. Operacin de lectura o entrada simple (leer)

La operacin de lectura o de entrada permite leer determinados valores y asignarlos a determinadas constantes o variables. Almacena en una variable un valor extrado desde un dispositivo externo, del cual hacemos abstraccin aunque generalmente es el teclado. Los datos de entrada se introducen en el computador mediante dispositivos de entrada (teclado, pantalla, unidades de disco, escneres, 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 cuestin. Luego de leer un valor de un dispositivo externo, el valor de la variable cambia en forma similar a si se hiciera una asignacin y adopta el valor ledo. La notacin algortmica (sintaxis) que utilizaremos para la asignacin es: leer(<Nombre_de_variable>) Ejemplo, sean las variables: entero : i caracter : c Acciones de lectura: leer(i) leer(c)
18
2.2.2. Operacin de escritura o salida simple (escribir)

Transmite un valor (constante, variable o evaluacin de una expresin) a un dispositivo externo (que haremos abstraccin, aunque generalmente es el monitor) para ser mostrado al usuario. Comportamiento: muestra resultados. La notacin algortmica (sintaxis) que utilizaremos para la asignacin es: escribir(<Nombre_de_variable, constante_o_expresin>) Ejemplo:
entero : i
i 4 // A la variable i se le asigna el valor 4 escribir(El valor de la variable i es: + (i + 1)) // Luego de realizada la suma, se escribe el valor 5 Nota: los smbolos // (barra derecha pseudocdigo. barra derecha) se utilizarn para indicar un comentario en el
2.3. Conversin de tipos

La conversin 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 nmero entero, y a su vez, un tipo de dato real o entero se puede convertir al tipo cadena. Las conversiones de tipo pueden ser de ampliacin o de restriccin: Las conversiones de ampliacin nunca producen desbordamiento y siempre son correctas, por ejemplo, convertir del tipo entero a un conjunto ms grande como el tipo real, Las conversiones de restriccin suponen una posible prdida de informacin y pueden producir errores, por ejemplo, al convertir los datos reales a enteros, puede haber prdida de informacin al eliminarse la parte decimal.
Ambos tipos de conversin pueden ser explcitas o implcitas. Las conversiones con prdida de informacin tienen lugar cuando el tipo de datos original no tiene un anlogo en el tipo de destino de la conversin. Por ejemplo, la cadena "Pedro" no se puede convertir en un nmero. En estos casos, algunos lenguajes de programacin devuelven un valor predeterminado cuando se usa la funcin de conversin de tipo, por ejemplo el valor NaN o el nmero cero, indicando con estos valores que la conversin de tipos fall. Algunos tipos de conversiones, como de una cadena a un nmero, tardan bastante tiempo. Cuantas menos conversiones utilice el programa, ms eficaz ser.
2.3.1. Conversin implcita

La mayora de las conversiones, como la asignacin de un valor a una variable, se producen automticamente. El tipo de datos de la variable determina el tipo de datos de destino de la conversin de expresin. En otros casos, la conversin implcita viene dada tanto por los tipos de datos como por los operadores utilizados.
2.3.2. Conversin explcita

Para convertir explcitamente una expresin a un tipo de datos concreto, se utilizan funciones que se asumen predefinidas y disponibles en el pseudocdigo, colocando entre parntesis el dato, variable o expresin que se va a convertir. Las conversiones explcitas requieren ms escritura que las implcitas, pero
19
Apuntes de algoritmos proporcionan ms seguridad con respecto a los resultados. Adems, las conversiones explcitas pueden controlar conversiones con prdida de informacin. El comportamiento de la conversin explcita depende del tipo de datos originales y del tipo de datos de destino. En el ejemplo siguiente se muestra conversiones de datos implcitas y explcitas, usando valores entero, cadena, caracter y real. // Se declaran las variables indicando su tipo de dato entero : i real : d caracter : c cadena : pal // A la variable i se le asigna el valor entero 5 i 5 // A la variable real d se le asigna el entero 5, d i { Hay conversin implcita de datos cambiando el valor a 5,0 porque d es un real. } // A la variable c se le asigna el carcter a c a pal los rboles + c { A la variable pal se le asigna la unin de una cadena y un carcter, aqu el operador + significa concatenacin y no la suma algebraica. } i aEntero(d) { El valor de la variable d es convertido explcitamente de real a entero, asignando a la variable i, la parte entera del valor de d (5 en lugar de 5,0) } c aCaracter(i) { Se convierte explcitamente el tipo de dato de la variable i, transformando el valor entero 5 al carcter 5 }
2.4. Contadores
Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad constante cada vez que se produce un determinado suceso o accin. Los contadores se utilizan en estructuras repetitivas con la finalidad de contar sucesos o acciones internas del bucle. Con los contadores se debe realizar una operacin de inicializacin y, posteriormente, las sucesivas de incremento o decremento del contador. La inicializacin consiste en asignarle al contador un valor. Se situar antes y fuera del bucle. <nombre_del_contador> <valor_de_inicializacin>
En cuanto a los incrementos o decrementos del contador, puesto que la operacin de asignacin admite que la variable que recibe el valor final de una expresin intervenga en la misma, se realizarn a travs de este tipo de instrucciones de asignacin, de la siguiente forma: <nombre_del_contador> <nombre_del_contador> + <valor_constante>
dicho <valor_constante> podr ser positivo o negativo. Esta instruccin se colocar ene el interior del bucle.
20
2.5. Acumuladores
Son variables cuyo valor se incrementa o decrementa en una cantidad determinada. Necesitan operaciones de: Inicializacin: <nombre_del_acumulador> Acumulacin: <nombre_del_acumulador> <nombre_del_acumulador> + <nombre_variable> <valor_de_inicializacin>
Hay que tener en cuenta que la siguiente tambin sera una operacin de acumulacin: <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 la ejecucin de un programa, comunicando as informacin de una parte a otra del mismo. Pueden ser utilizados para el control de bucles y estructuras de selectivas. En este caso tambin es frecuente que la variable que recibe el valor final de una expresin intervenga en la misma, por ejemplo: En primer lugar el interruptor se inicializa a verdad o falso <nombre_del_interruptor> <valor_de_inicializacin>
En determinadas condiciones el interruptor conmuta <nombre_del_interruptor> no <valor_del_interruptor>
21
3. Estructura general de un programa

3.1. Programacin estructurada
La programacin estructurada es un conjunto de tcnicas para desarrollar algoritmos fciles de escribir, verificar, leer y modificar. La programacin estructurada utiliza: Diseo descendente. Consiste en disear los algoritmos en etapas, yendo de los conceptos generales a los de detalle. El diseo descendente se ver completado y ampliado con el modular. Recursos abstractos. En cada descomposicin de una accin compleja se supone que todas las partes resultantes estn ya resueltas, posponiendo su realizacin para el siguiente refinamiento. Estructuras bsicas. Los algoritmos debern ser escritos utilizando nicamente tres tipos de estructuras bsicas (secuencial, selectiva, repetitiva).
Para que la programacin sea estructurada, los programas han de ser propios. Un programa se define como propio si cumple las siguientes caractersticas: Tiene un solo punto de entrada y uno de salida. Toda accin del algoritmo es accesible, es decir, existe al menos un camino que va desde el inicio hasta el fin del algoritmo, se puede seguir y pasa a travs de dicha accin. 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 mismo orden en que son escritas. El smbolo; se utiliza para separar una instruccin de otra. <instruccin 1> <instruccin 2> ... <instruccin n> Comportamiento. Representa las acciones del algoritmo y el orden en que se realizarn. Las instrucciones (<instrucciones 1> a la <instrucciones n>) no solo tienen que ser operaciones bsicas, tambin pueden ser llamadas a acciones o funciones que realizan un procedimiento, estructuras de control de programa (seleccin y repeticin), las cuales sern explicadas en prximos temas. Ejemplo: algoritmo ejemplo { Secuenciamiento de instrucciones que inicializa un nmero, lo incrementa en 1 y lo eleva a la 5ta potencia } var entero : i inicio i 1 // en este momento i tiene el valor de 1 i i + 1 // en este momento i tiene el valor de 2 i i ** 5 // en este momento i tiene el valor de 32 escribir(El valor fin de la variable i es: + i) // se escribe un mensaje fin // Fin de la secuencia de instrucciones
22
3.3. Estructura selectiva

Una estructura selectiva es aquella en que se ejecutan unas acciones u otras segn se cumpla o no una determinada condicin.
3.3.1. Simple
En el condicional simple se evala la condicin y si sta da como resultado verdad se ejecuta una determinada accin o grupo de acciones; en caso contrario se saltan dichos grupos de acciones. Recomendacin.: utilizar indentacin o sangra para mostrar los niveles de anidacin en las instrucciones. si <condicin> entonces accin fin_si
no condicin
si
accin
3.3.2. Doble
Cuando el resultado de evaluar una condicin es verdad se ejecutar una determinada accin o grupo de acciones y si el resultado es falso se ejecutar otra accin o grupo de acciones diferentes. Recomendacin: utilizar indentacin o sangra en los algoritmos y cdigos. si <condicin> entonces accin 1 si_no accin 2 fin_si
no condicin
si
accin 2
accin 1
23
3.3.3. Mltiple
Se evala una condicin o expresin que puede tomar n valores. Segn el valor que la expresin tenga en cada momento se ejecutan las acciones correspondientes al valor. Las acciones asociadas al valor si_no se ejecutan cuando la expresin no toma ninguno de los valores que aparecen antes. El valor con el que se compara la expresin, 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 condicin. segn_sea <expresin> hacer <lista1> : accin 1 <lista2> : accin 2 ... [ si_no accin ] fin_segn
no expresin lista1 lista2 accin
accin 1
accin 2
3.4. Estructura repetitiva

Un bucle, lazo, ciclo o loop (en ingls) es un segmento de algoritmo o programa (una secuencia de instrucciones) que se repiten un determinado nmero de veces mientras se cumple una determinada condicin, en otras palabras, un bucle o ciclo es un conjunto de instrucciones que se repiten mientras una condicin es verdadera o existe. A cada repeticin del conjunto de acciones se denomina iteracin. Para que un bucle no se repita indefinidamente debe tener una condicin de parada o de fin. Esta condicin de parada o de fin se verifica cada vez que se hace una iteracin. El ciclo llega a su fin cuando la condicin de parada se hace verdadera. La condicin de parada puede estar al principio de la estructura repetitiva o al final. Al igual que las estructuras de seleccin simple o compuesta, en un algoritmo pueden utilizarse varios ciclos. Estos ciclos pueden ser independientes (una a continuacin de otro) o anidados (ciclos dentro de ciclos). Para representar los bucles o lazos utilizaremos en el curso las estructuras de control Mientras, Hacermientras, Repetir-hasta y Desde.
24
Apuntes de algoritmos Los ciclos o procesos repetitivos de instrucciones son procedimientos fundamentales en el uso de las computadoras y por lo tanto en muchos algoritmos y programas. Vamos a utilizar ciclos cuando: Necesitemos repetir instrucciones un determinado nmero de veces, mientras se cumpla una condicin, mientras un hecho sea verdadero o hasta cuando se alcance un determinado valor o condicin. Cuando necesitemos contar un determinado nmero de elementos o de acciones, por ejemplo contar las slabas de un texto, los elementos de una secuencia que verifican una determinada condicin o contar el nmero de personas que cumplen ciertas caractersticas. En este caso se incluirn contadores dentro del bucle. Los contadores son variables (generalmente de tipo entero) que tienen un valor inicial y que se incrementan o decrementan en un valor constante cada vez que ocurre una iteracin. Cuando los contadores se decrementan se habla de descontar, en lugar de contar. Tambin usaremos ciclos cuando necesitemos acumuladores determinados valores cada vez que se realiza una iteracin. Los acumuladores tambin son variables (generalmente de tipo entero, real o cadena), que almacenan valores variables resultantes de las operaciones que se realizan en cada ciclo. Por ejemplo, podemos usar para ir sumando los precios de varios vehculos y luego calcular el precio promedio general (con una variable acumulador de tipo real), para calcular la potencia o el factorial de un nmero a travs de multiplicaciones sucesivas (un acumulador de tipo entero o real) o para ir agregando a una cadena de caracteres, letras o slabas que construirn un mensaje (una variable acumulador del tipo cadena)
3.4.1. Mientras
Es una estructura iterativa que permite verificar la condicin de entrada al ciclo antes del cuerpo de instrucciones a repetir. Como la evaluacin de la condicin de entrada se realiza al inicio del bloque Mientras, puede ocurrir que las instrucciones del ciclo no se realicen ni siquiera 1 vez, a diferencia del Repetir-hasta, donde el bloque de instrucciones se realiza al menos 1 vez porque la condicin de parada se verifica al final. Las instrucciones del Mientras se pueden realizar 0 o ms veces antes de que se cumpla la condicin de terminar el ciclo. El conjunto de instrucciones dentro del Mientras se ejecuta cuando la condicin de entrada del principio se cumple (es verdadera). Dicho de otro modo, el ciclo de instrucciones dentro del Mientras se va a detener cuando la condicin se haga falsa. Se recomienda usar la estructura Mientras tienes que verificar la condicin de entrada al inicio y si se cumple, entonces, entrar al ciclo y realizar sus instrucciones. mientras <expresin_lgica> hacer accin fin_mientras
no condicin si accin
25
3.4.2. Hacer-mientras
El bucle Hacer-mientras es anlogo al bucle Mientras desde el punto de vista de que el cuerpo del bucle se ejecuta una y otra vez mientras la condicin es verdadera. La diferencia entre ellos consiste en que las sentencias del cuerpo del bucle Hacer-mientras, se ejecutan al menos una vez antes que se evale la expresin lgica. hacer accin mientras <expresin_lgica>
accin
si condicin
no
3.4.3. Repetir-hasta
Ejecuta un bloque de instrucciones varias veces hasta que se cumple la condicin que es verificada al final del bucle. Las instrucciones dentro del ciclo Repetir-hasta se van a realizar mientras la condicin de parada evaluada al final sea falsa. Dicho de otro modo, el ciclo se va a detener cuando la condicin de parada se haga verdadera. Se recomienda usar la estructura Repetir-hasta cuando las instrucciones del ciclo se pueden realizar al menos 1 vez antes de comprobar la condicin de parada. repetir accin hasta_que <expresin_lgica>
accin
no condicin
si
3.4.4. Desde
Es una estructura iterativa que es controlada por una variable (llamada tambin variable ndice), la cual se incrementa o decrementa hasta llegar a un valor lmite o valor final que representa la condicin de parada.
26
Apuntes de algoritmos La estructura Desde comienzan con un valor inicial de la variable ndice, las acciones especificadas para el ciclo se ejecutan un nmero determinado de veces, a menos, que el valor inicial de la variable ndice sea mayor que el valor lmite que se quiere alcanzar. El incremento o decremento de la variable ndice suele ser de 1 en 1, salvo cuando se indica lo contrario. La variable ndice suele ser de tipo entero y se utilizan comnmente nombres como i, j o k (no importa si en maysculas o minsculas) Se recomienda usar la estructura Desde cuando se conoce el nmero de veces que se deben ejecutar las instrucciones del ciclo, es decir, en los casos en que el nmero de iteraciones es fijo y conocido. desde v v1 hasta vf [incremento | decremento incr] hacer accin fin_desde
valor_inicial
no condicin si incremento o decremento accin
3.4.5. Observaciones
Observa que para el Mientras, Hacer-mientras y Repetir-hasta se debe incluir en el cuerpo de instrucciones una accin donde se actualice la o las variables que usas en la condicin de parada. Por el contrario, en el Desde no es necesario incluir esta instruccin dado que en el encabezado de la instruccin ya se incluye el incremento.
Comparacin de bucles
Mientras. El uso ms frecuente es cuando la repeticin no est controlada por contador; la condicin precede a cada repeticin del bucle; el cuerpo del bucle puede no ser ejecutado. Se debe utilizar cuando se desea saltar el bucle si la condicin es falsa. Desde. Bucle de conteo, cuando el nmero de repeticiones se conoce por anticipado y puede ser controlado por un contador; la condicin precede a la ejecucin 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.
27
3.5.1. Anidacin de condicionales

La ventaja de anidar sentencias condicionales, es que cuando una se cumple no hay por que mirar a las que estn debajo. Tenemos que tratar anidar la condicin en la parte si_no en vez que en la parte entonces. si <condicin 1> Entonces accin 1 si_no si <condicin 2> entonces accin 2 si_no si <condicin 3> entonces accin 3 fin_si fin_si fin_si El case siempre equivale a una anidacin de condicionales, pero no al revs.
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 iteracin del bucle mas externo se van a ejecutar todas las iteraciones del bucle mas interno por cada iteracin del mas externo. Si el bucle mas externo se repite n veces y el mas interno se repite m veces, si por cada iteracin del ms externo se repite el ms interno, el nmero 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_desde fin_desde
28
4. Subalgoritmos, funciones y procedimientos

4.1. Programacin modular
Se basa en dividir el programa en partes llamadas mdulos, que se analizan y codifican de forma independiente y 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 los distintos mdulos o subalgoritmos, los cuales, cuando terminen su tarea, devolvern el control al algoritmo que los llam. Los mdulos o subalgoritmos deben ser pequeos, seguirn todas las reglas de programacin estructurada y podrn ser representados con las herramientas de programacin habituales. El empleo de esta tcnica facilita notoriamente el diseo de los programas. Algunas de las ventajas significativas son: Varios programadores podrn trabajar simultneamente en la confeccin de un algoritmo, repartindose las distintas partes del mismo, ya que los mdulos son independientes. Se podr modificar un mdulo sin afectar a los dems. Las tareas, subalgoritmos, slo se escribirn una vez, aunque se necesiten en distintas ocasiones en el cuerpo del programa.
Existen dos tipos de subalgoritmos: funciones y procedimientos.
4.2. Funciones
Desde el punto de vista matemtico, una funcin es una operacin que toma uno o varios operandos y devuelve un resultado. Desde el punto de vista algortmico, es un subalgoritmo que toma uno o varios parmetros como entrada y devuelve, a la salida, un nico resultado. Como el resultado de la funcin 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 funcin. Luego el valor almacenado en la variable puede ser utilizado por el algoritmo que llama a la funcin.
4.2.1. Declaracin de una funcin

La estructura de una funcin es semejante a la de cualquier algoritmo. Tendr una cabecera (con el nombre y los parmetros) y un cuerpo (con la declaracin de los parmetros de la funcin y las instrucciones). <tipo_de dato> funcin <nombre_funcin> (lista_de_parmetros_formales) [ var declaraciones_locales ] inicio acciones devolver(<expresin>) fin_funcin La lista de parmetros es la informacin que se le tiene que pasar a la funcin. Los parmetros, luego dentro de la funcin, los podemos utilizar igual que si fueran variables locales definidas en la funcin y para cada parmetro hay que poner su nombre y tipo. El nombre de la funcin lo da al usuario y tiene que ser significativo. En las variables locales se declaran las variables que se pueden usar dentro de la funcin. Entre las acciones, tendr que existir entre ellas una del tipo devolver(<expresin>). Esta sentencia pondr fin a la ejecucin de la funcin y devolver el valor de la funcin, es decir, como valor asociado al
29
Apuntes de algoritmos nombre de mismo tipo que el tipo de datos que devuelve a la funcin, este valor por tanto tiene que ser del mismo tipo que el tipo de datos que devuelve la funcin, que es el que habremos indicado al declarar la funcin en la parte final de la cabecera. No se permiten funciones que no devuelvan nada. Los parmetros que aparecen en la declaracin de la funcin se denominan parmetros formales, y los parmetros que se utiliza cuando se llama a la funcin se denominan parmetros actuales o reales.
4.2.2. Llamado de una funcin

Para llamar a una funcin se pone el nombre de la funcin, y entre parntesis los parmetros reales, que podrn ser variables, expresiones, constantes, etc., pero siempre del mismo tipo que los parmetros normales asociados. <nombre_funcion>(parmetros_actuales) La funcin puede ser llamada desde el algoritmo principal o desde cualquier otro subalgoritmo. Para llamar a la funcin desde cualquier parte, implica el conocimiento previo de que sta funcin existe. A travs de los parmetros reales de la llamada se proporciona a la funcin la informacin que necesita, para ello, al hacer la llamada lo que se produce es una asociacin automtica entre parmetros reales y parmetros formales. Esta asociacin se realiza segn el orden de la aparicin y de izquierda y derecha. La llamada a una funcin, siempre va a formar parte de una expresin, de cualquier expresin en la que en el punto en la que se llama a la funcin, pudiera ir colocado cualquier valor del tipo de datos que devuelve la funcin, esto se debe a que el valor que devuelve una funcin esta asociado a su nombre. Ejemplo: real funcin mitad(E entero : n) var real : m inicio m n / 2 devolver(m) fin_funcin algoritmo calcular_mitad var entero : num inicio escribir(Introduce un nmero para hallar su mitad) leer(num) escribir(La mitad de + num + es + mitad(num)) fin
4.3. Procedimientos
La definicin de procedimientos permite asociar un nombre a un bloque de instrucciones. Luego podemos usar ese nombre para indicar en algn punto de un algoritmo que vamos a utilizar ese bloque de instrucciones, pero sin tener la necesidad de repetirlas, slo invocando al procedimiento por su nombre. Los procedimientos se caracterizan por no retornar valores al algoritmo que las llama. Sin embargo, aunque los procedimientos no retornan valores, si pueden informar al algoritmo que las llam (a veces llamado algoritmo principal) de cambios realizados por sus instrucciones en algunos valores a travs de una herramienta que se llama pase de parmetros. Los parmetros permiten utilizar la misma secuencia de instrucciones con diferentes datos de entrada. Utilizar parmetros es opcional.
30
Apuntes de algoritmos Cuando entre las instrucciones de un algoritmo vemos el nombre de un procedimiento, decimos que estamos llamando o invocando al procedimiento. Los procedimientos facilitan la programacin modular, es decir, tener bloques de instrucciones que escribimos una vez pero que podemos llamar y utilizar muchas veces en varios algoritmos. Una vez terminada la ejecucin de un procedimiento, se retorna el control al punto de algoritmo donde se hizo la llamada, para continuar sus instrucciones.
4.3.1. Declaracin de procedimientos

La declaracin de un procedimiento es similar a la de una funcin. Las pequeas deferencias son debidas a que el nombre del procedimiento no se encuentra asociado a ningn resultado. La declaracin de un procedimiento expresado en pseudocdigo es: procedimiento <nombre_procedimiento> (lista_de_parmetros_formales) [ var declaraciones_locales ] inicio acciones fin_procedimiento Los parmetros que aparecen en la declaracin del procedimiento se denominan parmetros formales, y los parmetros que se utiliza cuando se llama al procedimiento se denominan parmetros actuales o reales.
4.3.2. Llamado de un procedimiento

Para llamar a un procedimiento se realiza con una instruccin llamar_a o bien directamente con el nombre del procedimiento. [ llamar_a ] <nombre_procedimiento>[(parmetros_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 / 2 escribir(La mitad de + n + es + m) fin_procedimiento algoritmo calcular_mitad var entero : num inicio escribir(Introduce un nmero para hallar su mitad) leer(num) llamar_a mitad(num) fin
4.3.3. Diferencias entre funciones y procedimientos:

Una funcin devuelve un nico valor y un procedimiento puede devolver 0, 1 N (a travs de los parmetros). Ninguno de los resultados devueltos por el procedimiento se asocian a su nombre como ocurra con la funcin. Mientras que la llamada a una funcin forma siempre parte de una expresin, la llamada a un procedimiento es una instruccin que por s sola no necesita instrucciones. 31
4.4. Estructura general de un algoritmo

Aunque algunos lenguajes de programacin exigen que los procedimientos y funciones se escriban antes de realizar la llamada, por claridad en la escritura del pseudocdigo se escriben despus del algoritmo principal. // cabecera algoritmo <nombre_del_algoritmo> // bloque de declaraciones const <nombre_constantes> = valor1 var <nombre_del_tipo> : <nombre_de_la_variable1> [, <nombre_de_la_variable2>, ... ] // bloque de instrucciones inicio // inicio del bloque de instrucciones accin 1 accin 2 [ llamar_a ] <nombre_procedimiento>[(parmetros_actuales)] { la llamada a la funcin debe realizarse en una expresin bloque de instrucciones } escribir(<nombre_funcion>(parmetros_actuales)) ... accin N fin // fin del bloque de instrucciones <tipo_de dato> funcin <nombre_funcin> (lista_de_parmetros_formales) [ var declaraciones_locales ] inicio acciones devolver(<expresin>) fin_funcin procedimiento <nombre_procedimiento> (lista_de_parmetros_formales) [ var declaraciones_locales ] inicio acciones fin_procedimiento
4.5. Parmetros de los subalgoritmos

4.5.1. Tipo de parmetros
Las funciones y procedimientos manejan dos tipos de parmetros: Actuales. Son los valores indicados en la llamada a la funcin o procedimiento en el algoritmo principal. Son los valores que se desean pasar desde el algoritmo principal a las instrucciones de la funcin o procedimiento. Formales. Son los nombres dados a los parmetros en la definicin formal de la funcin o procedimiento. Con estos nombres se conocern a los valores de los parmetros dentro de la funcin o procedimiento y funcionan como variables locales dentro de ellos.
32
5. Tipos de datos estructurados

5.1. Datos estructurados
Es una herramienta mediante la cual es posible almacenar datos en la memoria del computador, permitiendo guardar datos conformados por varios elementos y manipularlos en forma sencilla. Estas estructuras de datos estn formadas por ms de un elemento, estos pueden ser todos del mismo tipo de dato (ED u homognea como los arreglos y los archivos) o de tipos de datos diferentes (ED heterognea, como los registros y los objetos). Los datos de tipo estndar pueden ser organizados en diferentes estructuras de datos: estticas y dinmicas.
Estructuras de datos estticas

Arreglos Registros Cadenas Conjuntos Archivos
Estructuras de datos dinmicas

Listas rboles Grafos
5.2. Arreglos
Estructuras de datos conformada por una sucesin de celdas, que permite almacenar en la memoria principal del computador un conjunto finito de elementos (hay un nmero mximo conocido) que tienen el mismo tipo de dato (son homogneos). Para hacer referencia a cualquiera de las celdas del arreglo es necesario el nombre del arreglo y el valor de uno de los elementos perteneciente al conjunto de ndices asignado, lo que permite tener acceso aleatorio.
5.2.1. Caractersticas bsicas de los arreglos

Homogneo: 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 ms que un entero que pertenece a un intervalo finito y determina la posicin de cada elemento dentro del arreglo. Acceso secuencial o directo: El acceso a cada elemento del arreglo se realiza recorriendo los anteriores segn el orden en que estn almacenados o de manera directa (operacin selectora), indicando el valor del ndice del elemento requerido. Sus elementos son tratados como variables simples: Una vez seleccionado algn elemento del arreglo este puede ser utilizado en acciones de asignacin, como parte de expresiones o como parmetros al llamar a acciones o funciones como si se tratara de una variable del tipo de dato simple declarado para todos los elementos del arreglo.
35
Apuntes de algoritmos Uso de ndice: El ndice es un valor de tipo entero (nmero entero o carcter con un cdigo entero equivalente) que determina la posicin de cada elemento en el arreglo. La cantidad de ndices determina las dimensiones del arreglo. As un arreglo unidimensional tiene un ndice, un arreglo bidimensional tiene dos 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 una correspondencia uno a uno de cada elemento con un subconjunto de los enteros (ndices). 1 ser 2 hola 3 oh ... ojo n-1 casa n bien ndice contenido celda
Declaracin de arreglos unidimensionales

Declaracin por variable. se declara la variable tipo arreglo como si se tratara de una variable de tipo de dato simple. La sintaxis a utilizar ser: var array [<limite_inf>..<limite_sup>] de <tipo_de_dato> : <nombre_del_vector> Ejemplo: const n = 51 var array [1..5] de entero : arregloA array [0..20] de real : arregloB, arregloC array [7..14] de lgico : arregloD array [-6..n] de caracter : arregloE Declaracin por tipo: se realiza en dos pasos, se declara el arreglo como un nuevo tipo de dato y se le asigna ese tipo a una o ms variables. La ventaja de esta clase de declaracin reside en que no es necesario repetir todos los datos del arreglo cada vez que se necesite uno, sino que se utilizan tantas variables como arreglos se necesiten y adems simplifica la escritura del algoritmo. Para declarar un tipo, slo hace falta anteceder a la especificacin la palabra clave Tipo La sintaxis a utilizar ser: tipo array [<limite_inf>..<limite_sup>] de <tipo_de_dato> : <nombre_del_tipo> var <nombre_del_tipo> : <nombre_del_vector> Ejemplo: const n = 51 tipo array [1..5] de entero : vectorA array [0..20] de real : vectorB array [7..14] de lgico : vectorC array [-6..n] de caracter : vectorD
36
Apuntes de algoritmos var vectorA vectorB vectorC vectorD : : : : arregloA arregloB, arregloC arregloD arregloE
El nmero de elementos del vector vendr dato por la frmula: <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 un valor en el arreglo se deben especificar dos subndices (dos posiciones), uno para la fila y otro para la columna. Los diferentes tipos de ndices no necesitan ser subrangos del mismo tipo. 1 1 2 ... . i m[1, 1] m[2, 1] ... . ... . 2 m[1, 2] m[2, 2] ... . ... . ... . ... . ... . ... . ... . j ... . ... . ... . m[i, j]
Declaracin de arreglos bidimensionales

Al igual que en los arreglos unidimensionales, los arreglos bidimensionales tambin se pueden crear con declaraciones de variable o de tipo, el cambio, es que se debe indicar dos intervalos de ndices: uno para las filas y otro para las columnas. Estos intervalos o subrangos no tienen que ser de la misma dimensin. Declaracin por variable La sintaxis a utilizar ser: var array [li..ls, li..ls] de <tipo_de_dato> : <nombre_de_la_matriz> Ejemplo: const n = 51 m = 28 var array [1..5, 1..6] de entero : arregloA array [0..20, 0..3] de real : arregloB, arregloC array [7..14, 1..5] de lgico : arregloD array [-6..n, m..n] de caracter : arregloE Declaracin por tipo La sintaxis a utilizar ser: tipo array [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 tipo array [1..5, 1..6] de entero : matrizA
37
Apuntes de algoritmos array [0..20, 0..3] de real : matrizB array [7..14, 1..5] de lgico : matrizC array [-6..n, m..n] de caracter : matrizD var matrizA matrizB matrizC matrizD : : : : arregloA arregloB, arregloC arregloD arregloE
5.2.4. Recorrido de todos lo elementos del arreglo

Esta operacin se realiza cuando se utiliza una estructura de control iterativa para tratar todos y cada uno de los elementos del arreglo de acuerdo al orden en que se almacenan. El tratamiento es el mismo para todo el arreglo, y se aplica tanto cuando se desea leer el arreglo, buscar un elemento en un arreglo, listar todo el contenido del mismo, y muchos otros. El recorrido puede ser de manera ascendente (el ms utilizado), partiendo del lmite inferior hasta el superior e incrementando en uno; o de manera descendente, partiendo del lmite superior hasta el inferior y decrementando en uno. La estructura de control desde es la ms conveniente para realizar de manera el recorrido, indicando solo el limite inferior y superior, pues el incremento en uno del ndice es automtico. Sin embargo, si existiera alguna condicin adicional o si se necesita usar una condicin lgica para finalizar el recorrido, no basta con llegar al lmite superior del ndice, hay que cambiar de la estructura iterativa desde, y utilizar un mientras o un repetir. Recorrido por filas Supuestas las siguientes declaraciones: const f = <valor1> c = <valor2> tipo array [1..f, 1..c] de real : matriz var matriz : m y que todos los elementos de la matriz contienen informacin vlida, escribir el pseudocdigo que se visualice en primer lugar el contenido de los elementos de la primera fila, a continuacin el contenido de la 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 continuacin, 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 repetitivas anidadas.
38
5.2.5. Arreglos como parmetros

Los arreglos podrn ser pasados como parmetros, tanto a procedimientos como a funciones. Para ellos se debe declarar algn parmetro formal del misto tipo que el arreglo que constituye el parmetro actual. Ejemplo: algoritmo paso_de_arreglos const f = 5 c = 7 tipo array [1..f, 1..c] de real : arr var arr : a entero : b ... inicio ... b recibeArreglo(a) ... fin entero funcin recibeArreglo(E arr: m) // Los parmetros actuales y los formales no necesitan coincidir en el nombre inicio ... ... fin_funcin
5.3. Registros
Estructura de datos formada por una coleccin finita de elementos llamados campos, no necesariamente homogneos (del mismo tipo) y que permiten almacenar una serie de datos relacionados entre s bajo un nombre y una estructura comn.
5.3.1. Caractersticas bsicas de los registros

Permiten almacenar un grupo de elementos bajo un nombre y un estructura comn Los elementos (campos) de un registro no tienen que ser homogneos, de hecho, generalmente son de diferentes tipos No estn disponibles en todos los lenguajes de programacin, razn por la cual muchas veces es necesario simularlo o definirlo. Cada campo del registro se comporta como una variable simple, de manera que puede ser usado en una expresin de asignacin, como parte de otra expresin, en operaciones o como parmetro al invocar una accin o funcin.
5.3.2. Declaracin de registros

Declaracin por variable. se declara la variable de tipo registro identificndola a travs de su nombre, se indica la estructura del registro suministrando la definicin de sus campos mediante sus tipos de dato y sus nombres La sintaxis a utilizar para declarar un registro ser:
39
Apuntes de algoritmos 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 Declaracin por tipo: Al igual que con los arreglos, para declarar un tipo de registro definido por el usuario, se antecede a la especificacin la palabra clave Tipo y luego se definen las variables del tipo. El uso de la declaracin por tipo facilita la declaracin de variables con una estructura comn, as como el pase de parmetros. tipo registro : <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 mayora de los lenguajes 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 parmetros 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 construccin de arreglos de registros. Nombre Ana Carlos ... Juan ..Edad.. 28 36 ... 34 ..Edad.. a[1] a[2] ... n[n]
Para acceder al campo nombre del 2do elemento del arreglo a se escribira a[2].nombre. Por ejemplo: escribir(a[2].nombre) presentara en consola la cadena Carlos.
5.4. Cadenas de caracteres

Es un conjunto de 0 ms caracteres. Entre estos caracteres puede estar incluido el blanco. En pseudocdigo, el blanco es el b. Las cadenas de caracteres se delimitan con dobles comillas , pero en algunos lenguajes se delimitan con . Las cadenas de caracteres se almacenan en posiciones contiguas de memoria.
40
Apuntes de algoritmos La longitud de una cadena es el nmero de caracteres de la misma. Si hubiese algn carcter que se utilizara como especial para sealar el fin de cadena, no se considerara en la longitud. Si una cadena tiene longitud 0, la llamamos cadena nula por lo que no tiene ningn carcter, pero esto no quiere decir que no tenga ningn carcter vlido, por que puede haber algn carcter especial no imprimible que forme parte de la cadena. Una subcadena es una cadena extrada de otra.
5.4.1. Datos de tipo caracter

Constantes. Una constante de tipo cadena es un conjunto de 0 o ms caracteres encerrados entre . Si dentro de la cadena quiero poner como parte de la cadena las , las pongo 2 veces. Esto depende del lenguaje. HolaAdios HolaAdios
Una constante de tipo carcter es un solo carcter encerrado entre comillas simples. Variables. Hay que distinguir entre una variable de tipo carcter y una variable de tipo cadena, el contenido de una variable de tipo cadena es un conjunto de 0 ms caracteres encerrados entre , mientras que una variable de tipo carcter es un solo carcter encerrado entre .
5.4.2. Formas de almacenamiento de cadenas en memoria

Almacenamiento esttico. La longitud de la cadena se tiene que definir antes de ser usada y siempre va a tener esa longitud, almacenndose en posiciones contiguas de memoria. Si la cadena no ocupa todo el espacio, el resto se rellena con blancos, y esos blancos se consideran parte de la cadena. Esto es muy deficiente y no se usa casi en ningn lenguaje. Almacenamiento semiesttico. Antes de usar la cadena, hay que declarar la longitud mxima que puede tener y ese es el espacio que se reserva en memoria para almacenar la cadena, siempre en posiciones contiguas. La longitud real de la cadena durante la ejecucin puede variar aunque siempre tiene que ser menor que el mximo de la cadena. Almacenamiento dinmico. No hay que definir la longitud de la cadena antes de usarla, ni siquiera la mxima. Para esto, se utiliza la memoria dinmica, y para establecer el nmero de elementos de la cadena usaremos listas enlazadas en las que cada nodo de la lista contara un carcter de la cadena y se enlazara mediante punteros. La informacin no tiene que estar almacenada en posiciones contiguas de memoria.
5.4.3. Operaciones con cadenas

Al igual que con cualquier tipo de datos, podemos hacer operaciones de entrada y salida (leer y escribir). var cadena : cad ... leer(cad) escribir(cad) Aparte de estas instrucciones, la mayor parte de los lenguajes permiten realizar operaciones especiales con las variables de tipo cadena. La mayor parte de los lenguajes tienen operaciones de tratamiento de cadenas, y esas operaciones vienen en libreras externas. Las operaciones ms usadas son: Longitud de una cadena. Es una funcin a la que se le pasa una cadena como parmetro y como resultado devuelve su longitud. entero funcin longitud(cadena : c)
41
Apuntes de algoritmos Comparacin de cadenas. Esta operacin se puede realizar porque lo que se va a comparar son los valores ASCII asociados a cada carcter. entero funcin comparacin(cadena : c1, c2) Esta funcin devuelve: 0 si c1 = c2 Un positivo si c1 > c2 Un negativo si c1 < c2 Concatenacin. Permite unir varias cadenas en una sola, manteniendo el orden de los caracteres que se unen. En pseudocdigo se usa el smbolo & +. Ejemplo: cadena1 Hola cadena2 Adios cadena3 cadena1 & + cadena2 escribir(cadena3) por consola aparecer Hola Adios Extraccin de subcadenas. Extrae parte de una cadena. cadena funcin subcadena(cadena : c; entero : ini[; entero : long]) Devuelve una subcadena de la cadena c formada por todos los caracteres a partir de la posicin ini. Si se incluye el argumento long, devuelve slo los primeros long caracteres a partir de la posicin ini. Posicin. Una operacin frecuente a realizar con cadenas es localizar si una determinada cadena forma parte de otra cadena ms grande o buscar la posicin en que aparece un determinado carcter o secuencia de caracteres de un texto. Estos problemas pueden resolverse con la funcin posicin. entero funcin posicin(cadena : c, sc) Devuelve la posicin de la primera aparicin de la subcadena sc en la cadena c. Conversin de cadenas a nmeros. Es una funcin que se le pasa una cadena caracteres numricos y devuelve el nmero asociado. entero funcin valor(cadena : c) Convierte la cadena c a un valor numrico. Si el contenido de la cadena c no puede convertirse a un valor numrico (contiene caracteres alfabticos, signos de puntuacin invlidos, etc.), devuelve 0 Conversin de nmeros a cadenas. Es una funcin a la que se le pasa un nmero y lo convierte a una cadena. cadena funcin cadena(entero : x) Convierte a cadena el valor numrico x. Funcin que devuelve el carcter ASCII de un nmero caracter funcin caracter(entero : x) Devuelve el carcter correspondiente al cdigo ASCII x. Funcin que devuelve el nmero asociado de un carcter ASCII: entero funcin cdigo(cadena : car) Devuelve el cdigo ASCII del carcter car.
42
6. Introduccin a la programacin orientada a objetos

La programacin Orientada a Objetos es una metodologa que basa la estructura de los programas en torno a los objetos. Los lenguajes de POO ofrecen medios y herramientas para describir los objetos manipulados por un programa. Ms que describir cada objeto individualmente, estos lenguajes proveen una construccin (Clase) que describe a un conjunto de objetos que poseen las mismas propiedades.
6.1. Objeto
Es una entidad (tangible o intangible) que posee caractersticas y acciones que realiza por s solo o interactuando con otros objetos. Un objeto es una entidad caracterizada por sus atributos propios y cuyo comportamiento est determinado por las acciones o funciones que pueden modificarlo, as como tambin las acciones que requiere de otros objetos. Un objeto tiene identidad e inteligencia y constituye una unidad que oculta tanto datos como la descripcin de su manipulacin. Puede ser definido como una encapsulacin y una abstraccin: una encapsulacin de atributos y servicios, y una abstraccin del mundo real. Para el contexto de la POO un objeto es una entidad que encapsula datos (atributos) y acciones o funciones que los manejan (mtodos). Tambin para la POO un objeto se define como una instancia o particularizacin de una clase. Los objetos de inters durante el desarrollo de software no slo son tomados de la vida real (objetos visibles o tangibles), tambin pueden ser abstractos. En general son entidades que juegan un rol bien definido en el dominio del problema. Un libro, una persona, un carro, un polgono, son apenas algunos ejemplos de objeto. Cada objeto puede ser considerado como un proveedor de servicios utilizados por otros objetos que son sus clientes. 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 mtodos.
Caractersticas generales
Un objeto se identifica por un nombre o un identificador nico que lo diferencia de los dems. Ejemplo: el objeto Cuenta de Ahorros nmero 12345 es diferente al objeto Cuenta de Ahorros nmero 25789. En este caso el identificador que los hace nicos es el nmero de la cuenta. Un objeto posee estados. El estado de un objeto est determinado por los valores que poseen sus atributos en un momento dado. Un objeto tiene un conjunto de mtodos. El comportamiento general de los objetos dentro de un sistema se describe o representa mediante sus operaciones o mtodos. Los mtodos se utilizarn para obtener o cambiar el estado de los objetos, as como para proporcionar un medio de comunicacin entre objetos. Un objeto tiene un conjunto de atributos. Los atributos de un objeto contienen valores que determinan el estado del objeto durante su tiempo de vida. Se implementan con variables, constantes y estructuras de datos (similares a los campos de un registro). Los objetos soportan encapsulamiento. La estructura interna de un objeto normalmente est oculta a los usuarios del mismo. Los datos del objeto estn disponibles solo para ser manipulados por los propios mtodos del objeto. El nico mecanismo que lo conecta con el mundo exterior es el paso de mensajes. 43
Apuntes de algoritmos Un objeto tiene un tiempo de vida dentro del programa o sistema que lo crea y utiliza. Para ser utilizado en un algoritmo el objeto debe ser creado con una instruccin particular (New Nuevo) y al finalizar su utilizacin es destruido con el uso de otra instruccin o de manera automtica.
6.2. Clase
La clase es la unidad de modularidad en la POO. La tendencia natural del individuo es la de clasificar los objetos segn sus caractersticas comunes (clase). Por ejemplo, las personas que asisten a la universidad se pueden clasificar (haciendo abstraccin) en estudiante, docente, empleado e investigador. La clase puede definirse como la agrupacin o coleccin de objetos que comparten una estructura comn y un comportamiento comn. Es una plantilla que contiene la descripcin general de una coleccin de objetos. Consta de atributos y mtodos que resumen las caractersticas y el comportamiento comunes de un conjunto de objetos. Todo objeto (tambin llamado instancia de una clase), pertenece a alguna clase. Mientras un objeto es una entidad concreta que existe en el tiempo y en el espacio, una clase representa solo una abstraccin. Todos aquellos objetos que pertenecen a la misma clase son descritos o comparten el mismo conjunto de atributos y mtodos. 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 abstraccin alto. La clase permite describir un conjunto de caractersticas comunes para los objetos que representa. Ejemplo: La clase Avin se puede utilizar para definir los atributos (tipo de avin, distancia, altura, velocidad de crucero, capacidad, pas de origen, etc.) y los mtodos (calcular posicin en el vuelo, calcular velocidad de vuelo, estimar tiempo de llegada, despegar, aterrizar, volar, etc.) de los objetos particulares Avin que representa. Un objeto es una instancia de una clase. Cada objeto concreto dentro de un sistema es miembro de una clase especfica y tiene el conjunto de atributos y mtodos especificados en la misma. Las clases se relacionan entre s mediante una jerarqua. Entre las clases se establecen diferentes tipos de relaciones de herencia, en las cuales la clase hija (subclase) hereda los atributos y mtodos de la clase padre (superclase), adems de incorporar sus propios atributos y mtodos.
Ejemplos: Superclase: Clase Avin Subclases de Avin: Clase Avin Comercial, Avin de Combate, Avin de Transporte. Los nombres o identificadores de las clases deben colocarse en singular (clase Animal, clase Carro, clase Alumno).
6.3. Relacin entre clase y objeto

Algortmicamente, las clases son descripciones netamente estticas o plantillas que describen objetos. Su rol 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 molde de fbrica, en base al cual son construidos los objetos. Durante la ejecucin de un programa slo existen los objetos, no las clases. La declaracin de una variable de una clase NO crea el objeto.
44
Apuntes de algoritmos La asociacin siguiente: <nombre_clase> : <nombre_variable> (por ejemplo, Rectngulo : R), no genera o no crea automticamente un objeto Rectngulo. Slo indica que R ser una referencia o una variable de objeto de la clase Rectngulo. La creacin de un objeto, debe ser indicada explcitamente por el programador, de forma anloga a como inicializamos las variables con un valor dado, slo que para los objetos se hace a travs de un mtodo Constructor (ver punto Mtodos).
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 caracterstica de un objeto. Mediante los atributos se define informacin oculta dentro de un objeto, la cual es manipulada solamente por los mtodos definidos sobre dicho objeto Un atributo consta de un nombre y un valor. Cada atributo est asociado a un tipo de dato, que puede ser simple (entero, real, lgico, carcter, cadena) o estructurado (arreglo, registro, archivo, lista, etc.). Los modos de acceso son: Pblico. Atributos (o Mtodos) que son accesibles fuera de la clase. Pueden ser llamados por cualquier clase, aun si no est relacionada con ella. Este modo de acceso tambin se puede representar con el smbolo +. Privado. Atributos (o Mtodos) que slo son accesibles dentro de la implementacin de la clase. Tambin se puede representar con el smbolo . Protegido. Atributos (o Mtodos) que son accesibles para la propia clase y sus clases hijas (subclases). Tambin se puede representar con el smbolo #.
6.5. Mtodos
Son las operaciones (acciones o funciones) que se aplican sobre los objetos y que permiten crearlos, cambiar su estado o consultar el valor de sus atributos. Los mtodos constituyen la secuencia de acciones que implementan las operaciones sobre los objetos. La implementacin de los mtodos no es visible fuera de objeto. Ejemplo: Un rectngulo es un objeto caracterizado por los atributos Largo y Ancho, y por varios mtodos, entre otros Calcular su rea y Calcular su permetro.
Cada mtodo tiene un nombre, cero o ms parmetros (por valor o por referencia) que recibe o devuelve y un algoritmo con el desarrollo del mismo. En particular se destaca el mtodo constructor, que no es ms que el mtodo que se ejecuta cuando el objeto es creado. Este constructor tiene el mismo nombre de la clase/ objeto, recibe cero o ms parmetros y lo usual es que inicialicen los valores de los atributos del objeto. En lenguajes como Java y C++ se puede definir ms de un mtodo constructor, que normalmente se diferencian entre s por la cantidad de parmetros que reciben. Los mtodos se ejecutan o activan cuando el objeto recibe un mensaje, enviado por un objeto o clase externo al que lo contiene, o por el mismo objeto de manera local.
45
Creacin de objetos y mtodos constructores

Cada objeto o instancia de una clase debe ser creada explcitamente a travs de un mtodo u operacin especial denominado constructor. Los atributos de un objeto toman valores iniciales dados por el constructor. Por convencin el mtodo constructor tiene el mismo nombre de la clase y no se le asocia un modo de acceso (es pblico). Algunos lenguajes proveen un mtodo constructor por defecto para cada clase y/o permiten la definicin de ms de un mtodo constructor. En la notacin algortmica, definimos obligatoriamente un nico mtodo constructor de la clase.
Mtodo de destructores de objetos

Los objetos que ya no son utilizados en un programa, ocupan intilmente espacio de memoria, que es conveniente recuperar en un momento dado. Segn el lenguaje de programacin utilizado esta tarea es dada al programador o es tratada automticamente por el procesador o soporte de ejecucin del lenguaje. En la notacin algortmica NO tomaremos en cuenta ese problema de administracin de memoria, por lo tanto no definiremos formas para destruir objetos. En cambio al utilizar lenguajes de programacin si debemos conocer los mtodos destructores suministrados por el lenguaje y utilizarlos a fin de eliminar objetos una vez no sean tiles.
6.6. Mensaje
Es la peticin de un objeto a otro para solicitar la ejecucin de alguno de sus mtodos o para obtener el valor de un atributo pblico. Estructuralmente, un mensaje consta de 3 partes: Identidad del receptor. Nombre del objeto que contiene el mtodo a ejecutar. Nombre del mtodo a ejecutar. Solo los mtodos declarados pblicos. Lista de Parmetros que recibe el mtodo (cero o mas parmetros)
Cuando el objeto receptor recibe el mensaje, comienza la ejecucin del algoritmo contenido dentro del mtodo invocado, recibiendo y/o devolviendo los valores de los parmetros correspondientes, si los tiene ya que son opcionales:
6.7. Diagrama de clases

La representacin grfica de una o varias clases se har mediante los denominados Diagramas de Clase. Para los diagramas de clase se utilizar la notacin que provee el Lenguaje de Modelacin Unificado (UML, ver www.omg.org), a saber: Las clases se denotan como rectngulos divididos en tres partes. La primera contiene el nombre de la clase, la segunda contiene los atributos y la tercera los mtodos. Los modificadores de acceso a datos y operaciones, a saber: pblico, protegido y privado; se representan con los smbolos +, # y respectivamente, al lado derecho del atributo. (+ pblico, # protegido, - privado).
En la figura se muestra el mtodo color que no tiene ningn parmetro y retorna un valor entero y el mtodo modificar_tamao que tiene un real como parmetro y no retorna nada (es una accin).
46
Apuntes de algoritmos Notacin: Nombre Clase Atributos Ejemplo ventana + real : rea # lgico : visible + ventana(E real : a; E lgico : v) + entero mostrarColor() + modificarTamao(E real : porcentaje)
Mtodos
6.8. Relaciones entre clases

Las clases no se construyen para que trabajen de manera aislada, la idea es que ellas se puedan relacionar entre s, de manera que puedan compartir atributos y mtodos sin necesidad de rescribirlos. La posibilidad de establecer jerarquas entre las clases es una caracterstica que diferencia esencialmente la programacin orientada a objetos de la programacin tradicional, ello debido fundamentalmente a que permite extender y reutilizar el cdigo existente sin tener que rescribirlo cada vez que se necesite. Los cuatro tipos de relaciones entre clases estudiados en este curso sern: Herencia (Generalizacin / Especializacin o Es-un) Agregacin (Todo / Parte o Forma-parte-de) Composicin (Es parte elemental de) Asociacin (entre otras, la relacin Usa-a)
Existen otros tipos de relaciones: Realizacin. Dependencia.
6.8.1. Relacin de herencia (generalizacin / especializacin, es un)

Es un tipo de jerarqua de clases, en la que cada subclase contiene los atributos y mtodos de una (herencia simple) o ms superclases (herencia mltiple). Mediante la herencia las instancias de una clase hija (o subclase) pueden acceder tanto a los atributos como a los mtodos pblicos y protegidos de la clase padre (o superclase). Cada subclase o clase hija en la jerarqua es siempre una extensin (esto es, conjunto estrictamente ms grande) de la(s) superclase(s) o clase(s) padre(s) y adems incorporar atributos y mtodos propios, que a su vez sern heredados por sus hijas. En la notacin algortmica se coloca el nombre de la clase padre despus de la frase Hereda de del encabezado de la clase y se usan sus atributos y mtodos pblicos o protegidos. Ejemplo: clase alumno hereda_de persona En el diagrama de clases, la herencia se representa generalizacin/especificacin, que se denota de la siguiente forma: subclase clase hija superclase clase padre mediante una relacin de
47
6.8.2. Clase abstracta

Una clase abstracta es aquella que construimos para derivar de ella otras clases, pero de la que no se puede instanciar. Por ejemplo, la clase animal, no existe como tal en la naturaleza, no existe ningn ser que sea tan solo animal (no hay ninguna instanciacin 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 notacin algortmica 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 relacin de Herencia entre la clase animal y sus hijas. La clase animal es abstracta.
6.8.3. Relacin de agregacin (todo / parte, forma parte de)

Es una relacin que representa a los objetos compuestos por otros objetos. Indica Objetos que a su vez estn formados por otros. El objeto en el nivel superior de la jerarqua es el todo y los que estn en los niveles inferiores son sus partes o componentes. La relacin forma parte de, no es ms que una asociacin, que se denota: Nombre del objeto de nivel superior carro
Multiplicidad
Nombre del objeto que lo compone ruedas
4 .. *
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 asociacin, se denota LI..LS. Se puede usar * en el limite superior para representar una cantidad ilimitada (ejemplo: 3..*). Ejemplo: Objeto Casa descrito en trminos de sus componentes
48
6.8.4. Relacin de composicin

Un componente es parte esencial de un elemento. La relacin es ms fuerte que el caso de agregacin, al punto que si el componente es eliminado o desaparece, la clase mayor deja de existir. La relacin de composicin, se denota de la siguiente forma: clase mayor persona clase componente corazn
6.8.5. Relacin de asociacin (uso, usa, cualquier otra relacin)

Es una asociacin que se establece cuando dos clases tienen una dependencia de utilizacin, es decir, una clase utiliza atributos y/o mtodos de otra para funcionar. Estas dos clases no necesariamente estn en jerarqua, es decir, no necesariamente una es clase padre de la otra, a diferencia de las otras relaciones de clases. El ejemplo mas comn de esta relacin es de objetos que son utilizados por los humanos para alguna funcin, como Lpiz (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 de consulta y retiro y verificar la informacin del usuario. La relacin de uso, se denota con una dependencia estereotipada: usa a clase 1 Ejemplos: clase 2
49
7. Fundamentos del enfoque orientado a objeto

El Enfoque Orientado a Objeto se basa en cuatro principios que constituyen la base de todo desarrollo orientado a objetos. Estos principios son: Abstraccin, Encapsulamiento, Modularidad y Herencia. Otros elementos a destacar (aunque no fundamentales) en la POO son: Polimorfismo, Enlace dinmico (o binding), Concurrencia y Persistencia.
7.1. Abstraccin
Es el principio de ignorar aquellos aspectos de un fenmeno observado que no son relevantes, con el objetivo de concentrarse en aquellos que si lo son. Una abstraccin denota las caractersticas esenciales de un objeto (datos y operaciones), que lo distingue de otras clases de objetos. Decidir el conjunto correcto de abstracciones de un determinado dominio, es el problema central del diseo orientado a objetos. Los mecanismos de abstraccin son usados en la POO para extraer y definir del medio a modelar, sus caractersticas y su comportamiento. Dentro de la POO son muy usados mecanismos de abstraccin: Generalizacin, Agregacin y clasificacin.
7.1.1. Generalizacin
Es el mecanismo de abstraccin mediante el cual un conjunto de clases de objetos son agrupadas en una clase de nivel superior (Superclase), donde las semejanzas de las clases constituyentes (Subclases) son enfatizadas, y las diferencias entre ellas son ignoradas. En consecuencia, a travs de la generalizacin, la superclase almacena datos generales de las subclases, y las subclases almacenan slo datos particulares. La especializacin es lo contrario de la generalizacin. La clase Mdico es una especializacin de la clase Persona, y a su vez, la clase Pediatra es una especializacin de la superclase Mdico.
7.1.2. Agregacin
Es el mecanismo de abstraccin por el cual una clase de objeto es definida a partir de sus partes (otras clases de objetos). Mediante agregacin se puede definir por ejemplo un computador, por descomponerse en: la CPU, la ULA, la memoria y los dispositivos perifricos. El contrario de agregacin es la descomposicin.
7.1.3. Clasificacin
Consiste en la definicin de una clase a partir de un conjunto de objetos que tienen un comportamiento similar. La ejemplificacin es lo contrario a la clasificacin, y corresponde a la instanciacin de una clase, usando el ejemplo de un objeto en particular.
7.2. Encapsulamiento (ocultamiento de informacin)

Es la propiedad de la POO que permite ocultar al mundo exterior la representacin interna del objeto. Esto quiere 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 de la informacin separando el aspecto correspondiente a la especificacin de la implementacin; de esta forma, distingue el "qu hacer" del "cmo hacer". La especificacin es visible al usuario, mientras que la implementacin se le oculta.
50
Apuntes de algoritmos El encapsulamiento en un sistema orientado a objeto se representa en cada clase u objeto, definiendo sus atributos y mtodos con los siguientes modos de acceso: Pblico (+). Atributos o Mtodos que son accesibles fuera de la clase. Pueden ser llamados por cualquier clase, aun si no est relacionada con ella. Privado (-). Atributos o Mtodos que solo son accesibles dentro de la implementacin de la clase. Protegido (#). Atributos o Mtodos que son accesibles para la propia clase y sus clases hijas (subclases).
Los atributos y los mtodos que son pblicos constituyen la interfaz de la clase, es decir, lo que el mundo exterior conoce de la misma. Normalmente lo usual es que se oculten los atributos de la clase y solo sean visibles los mtodos, incluyendo entonces algunos de consulta para ver los valores de los atributos. El mtodo constructor (Nuevo, New) siempre es Pblico.
7.3. Modularidad
Es la propiedad que permite tener independencia entre las diferentes partes de un sistema. La modularidad consiste en dividir un programa en mdulos o partes, que pueden ser compilados separadamente, pero que tienen conexiones con otros mdulos. En un mismo mdulo se suele colocar clases y objetos que guarden una estrecha relacin. El sentido de modularidad est muy relacionado con el ocultamiento de informacin.
7.4. Herencia
Es el proceso mediante el cual un objeto de una clase adquiere propiedades definidas en otra clase que lo preceda en una jerarqua de clasificaciones. Permite la definicin de un nuevo objeto a partir de otros, agregando las diferencias entre ellos (Programacin Diferencial), evitando repeticin de cdigo y permitiendo la reusabilidad. Las clases heredan los datos y mtodos de la superclase. Un mtodo heredado puede ser sustituido por uno propio si ambos tienen el mismo nombre. La herencia puede ser simple (cada clase tiene slo una superclase) o mltiple (cada clase puede tener asociada varias superclases). La clase Docente y la clase Estudiante heredan las propiedades de la clase Persona (superclase, herencia simple). La clase Preparador (subclase) hereda propiedades de la clase Docente y de la clase Estudiante (herencia mltiple). Cuando se desea indicar invocar a un mtodo que pertenece a la clase madre, lo indicamos con la siguiente sintaxis: super.nombre_mtodo() Para el ejemplo, la llamada en la clase hija ave del mtodo comer de la clase madre animal sera: super.comer()
7.5. Polimorfismo
Es una propiedad de la POO que permite que un mtodo tenga mltiples implementaciones, que se seleccionan en base al tipo objeto indicado al solicitar la ejecucin del mtodo. El polimorfismo operacional o sobrecarga operacional permite aplicar operaciones con igual nombre a diferentes clases o estn relacionados en trminos de inclusin. En este tipo de polimorfismo, los mtodos son interpretados en el contexto del objeto particular, ya que los mtodos con nombres comunes son implementados de diferente manera dependiendo de cada clase.
51
Apuntes de algoritmos Por ejemplo, el rea de un cuadrado, rectngulo y crculo, son calculados de manera distinta; sin embargo, en sus clases respectivas puede existir la implementacin del rea bajo el nombre comn rea. En la prctica y dependiendo del objeto que llame al mtodo, se usar el cdigo correspondiente. Ejemplo: superclase: clase animal subclases: clases perro, ave, pez
Se puede definir un mtodo comer en cada subclase, cuya implementacin cambia de acuerdo a la clase invocada, sin embargo el nombre del mtodo 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 tipo de dato de los operandos a los que se aplica. Si los dos elementos son numricos, el operador + significa suma algebraica de los mismos, en cambio si por lo menos uno de los operandos es un String o Carcter, el operador es la concatenacin de cadenas de caracteres. Otro ejemplo de sobrecarga es cuando tenemos un mtodo definido originalmente en la clase madre, que ha sido adaptado o modificado en la clase hija. Por ejemplo, un mtodo comer para la clase animal y otro comer que ha sido adaptado para la clase ave, quien est heredando de la clase animal. Para poder realizar la adaptacin o modificacin del mtodo en la clase hija, debe estar declarado como mtodo abstracto en la clase madre. Ejemplo: abstracto publico entero funcin mostrarCedula()
52
8. Ejemplos
8.1. Expresiones
Determinar el valor de la variable A. a. A A A A b. A A A A A (3 * 2 ^ 5 mod 1 + 8 * (3 - 5) < (2 + 8 - 1 mod 1) (3 * 32 mod 1 + (-16)) < 10 -16 < 10 Verdadero A o ( 3 + Verdadero Verdadero Verdadero Verdadero 5 o o o * 8) < 3 y ((-6 / 3 div 4) * 2 < 2) 43 < 3 y (0 * 2 < 2) Falso y Verdadero Falso
8.2. Diagramas de flujo

a. Establezca la codificacin que amerite la su solucin de los siguientes diagramas de flujo:
inicio
num = 1
suma = 0
Ingresar nmero:
num
suma = suma + num
si
num <> 0
no
La suma es: , suma
fin
53
Apuntes de algoritmos algoritmo ejemplo_8.2 var entero : num, suma inicio num 1 suma 0 hacer escribir(Ingresar nmero: ) leer(num) suma suma + num mientras (num <> 0) escribir(La suma es: + suma) fin
8.3. Estructuras de seleccin

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 sueldo var real : sueldo inicio // se pide el valor del sueldo al usuario escribir(Suministre el monto del sueldo de la persona) // lee el sueldo actual del empleado leer(sueldo) // el condicional compara el sueldo del empleado si (sueldo <= 605) entonces // aumenta el sueldo del empleado sueldo sueldo + 150 // mensaje con el resultado escribir(El nuevo sueldo es: + sueldo) fin_si // Fin de la secuencia de instrucciones fin b. Crea una secuencia de instrucciones que calcule el monto de un aumento, a partir del sueldo del empleado y su antigedad (cantidad de aos trabajados en la empresa). Para las personas que ganan hasta Bs. 500 se les aumenta 15% si tienen menos de 5 aos de antigedad en la empresa y 20% si tienen 5 ms aos. Para los que ganan por encima de Bs. 500 hasta 2.500 se les aumenta 5% por cada 5 aos de antigedad. algoritmo ejemplo_8.3.b { Procedimiento para aumentar el sueldo segn el monto del sueldo actual y los aos de servicio } var real : sueldo, aumento entero : aos, aux inicio escribir(Suministre el sueldo y los aos de antigedad) // se solicitan y leen valores de entrada leer(sueldo) leer(aos) //contempla sueldo menores o iguales a 500 54
Apuntes de algoritmos si (sueldo <= 500) entonces { este si anidado contempla la antigedad para los que ganan hasta Bs. 500 } si (aos < 5) entonces // trabajadores con menos de 5 aos // se calcula el monto del aumento, usando 15% aumento sueldo * 0,15 si_no // se calcula el monto del aumento, usando 20% aumento sueldo * 0,2 fin_si // contempla los que ganan ms de 500 si_no // ganan ms de 500 y hasta 2.500 si (sueldo > 500 y sueldo <= 2.500) entonces // calcula cuantas veces se le aplicar el aumento del 5% aux aos div 5 // se calcula el monto del aumento aumento sueldo * (aux * 5) / 100 si_no // no se aumenta el sueldo de los que ganan ms de 2.500 aumento 0 fin_si fin_si si (aumento = 0) entonces escribir(Sueldo actual: + sueldo + gana ms de 2.500) escribir(no se contempl aumento) si_no escribir(Sueldo actual es + sueldo) escribir(Tiene una antigedad de + aos) escribir(Recibe aumento de + aumento) escribir(Su nuevo sueldo es + (sueldo + aumento)) fin_si // Fin de la secuencia de instrucciones fin c. Dada una fecha en formato da/mes/ao determinar el nmero de das y el nombre del mes de dicha fecha, y sacar por pantalla la fecha convertida a formato de da de mes de ao. Suponer que febrero siempre tiene 28 das. algoritmo ejemplo_8.3.c var entero : dia, mes, ao, n_dias cadena : n_mes inicio escribir(Introduce la fecha en formato da mes ao) leer(dia) leer(mes) leer(ao) segn_sea (mes) hacer 1: n_mes enero n_dias 31 2: n_mes febrero n_dias 28 3: n_mes marzo n_dias 31 4: n_mes abril n_dias 30 5: n_mes mayo
55
Apuntes de algoritmos n_dias 31 6: n_mes junio n_dias 30 7: n_mes julio n_dias 31 8: n_mes agosto n_dias 31 9: n_mes septiembre n_dias 30 10: n_mes octubre n_dias 31 11: n_mes noviembre n_dias 30 12: n_mes diciembre n_dias 31 fin_segn escribir(El mes de + n_mes + tiene + n_dias + dias) escribir(La fecha es + n_dias + de + n_mes + de + ao) fin
8.4. Estructuras de repeticin

a. Se desea sumar 35 nmeros (pueden ser enteros o reales) suministrados por teclado y calcular su promedio. algoritmo ejemplo_8.4.a // instrucciones para Sumar y Promediar var real : suma, promedio, num entero : j inicio suma 0 desde j 1 hasta 35 hacer escribir(Suministre el nuevo nmero) leer(num) suma suma + num fin_desde promedio suma / (j - 1) escribir(La suma de los nmeros es + suma) escribir(El promedio de los nmeros es + promedio) fin b. Dada la siguiente serie matemtica: a1 = 0 a2 = 0 an = an-1 + (2*an-2) Determinar cual es el valor y el rango del primer trmino cuyo valor sea mayor o igual a 2000. algoritmo ejemplo_8.4.b var entero : a1, a2, an, cont inicio cont 0 a1 1
56
Apuntes de algoritmos a2 0 an a1 + (2 * a2) mientras (an < 2000) hacer a2 a1 a1 an an 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 letra y que termina con * algoritmo ejemplo_8.4.c var entero : cantA, cantE, cantI, cantO, cantU carcter : letra inicio cantA 0 cantE 0 cantI 0 cantO 0 cantU 0 escribir(suministre la primera letra) leer(letra) mientras (letra <> *) hacer segn_sea (letra) hacer a: cantA cantA + 1 e: cantE cantE + 1 i: cantI cantI + 1 o: cantO cantO + 1 u: cantU cantU + 1 fin_segn escribir(suministre prxima letra) leer(letra) fin_mientras escribir(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 materia tiene al menos un alumno. El usuario le indicar cuando termin de suministrar todas las notas. algoritmo var real : entero cadena ejemplo_8.4.d nota, promedio : numAlumnos : continuar
inicio promedio 0 numAlumnos 1 continuar Si repetir escribir(Suministre la nota del alumno) leer(nota)
57
Apuntes de algoritmos promedio (promedio + nota) / numAlumnos numAlumnos numAlumnos + 1 // actualizo la variable de la condicin de parada escribir(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. Funcin sin pase de parmetros entero funcin 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 : palabra entero : cantLos inicio cantLos 0 escribir(A continuacin se le solicitarn palabras.) escribir(Suministre la palabra fin, para terminar el algoritmo) repetir escribir(Suministre una palabra) leer(palabra) si (palabra = los) entonces cantLos cantLos + 1 fin_si hasta_que (palabra = fin) devolver(cantLos) { esta instruccin retorna o devuelve la cantidad de palabras al algoritmo que llamo a esta funcin } fin_funcin b. Procedimientos y funciones con pase de parmetros algoritmo ejemplo_8.5.b { Solicita una fecha de nacimiento y llama a acciones y funciones que hacen varios clculos con ella } var entero : diaNac, mesNac, aoNac, edad cadena : nombre lgico : esCorrecta, esBis, esMenorEdad inicio escribir(suministra tu nombre) leer(nombre) repetir escribir(suministra el da, mes y ao de tu fecha de nacimiento) leer(diaNac) leer(mesNac) leer(aoNac) // se llama a una funcin que verifica la fecha esCorrecta validarFecha(diaNac, mesNac, aoNac) hasta_que (esCorrecta) 58
Apuntes de algoritmos // se llama a una funcin que valida si el ao de nacimiento fue bisiesto esBis validarBisieto(aoNac) si no(esBis) entonces escribir(no naciste en un ao Bisiesto) si_no escribir(Naciste en un ao Bisiesto) fin_si // calcula cuando cumple aos cumpleaos(nombre, diaNac, mesNac, aoNac) edad 0 esMenorEdad
Falso
// calcula la edad y si es o no menor de edad calcularEdad(aoNac, edad, esMenorEdad) escribir(nombre + tu tienes + edad + aos) fin { declaracin formal de las funciones y procedimientos utilizados en el algoritmo principal. En muchos lenguajes de programacin estas declaraciones formales deben estar ANTES del algoritmo que las llama. } // verifica si el da (d), mes (m) y ao (a) conforman una fecha vlida lgico funcin validarFecha(E entero : d, m, a) var lgico : correcta inicio correcta = verdadero; // completa las instrucciones faltantes devolver(correcta) fin_funcin // verifica si el ao (a) es bisiesto lgico funcin validarBisiesto(E entero : a) devolver((a mod 4 = 0) y (a mod 100 <> 0) o (a mod 400 <> 0)) fin_funcin { verifica si ya la persona cumpli aos. Este algoritmo supone que existen las Funciones que devuelven el ao, mes y da actual } procedimiento cumpleaos(E cadena : nombre; E entero : dia, mes, ao) var cadena : mensaje entero : mesesFaltan inicio // 1er si, para la fecha de ejemplo aoActual() = 2007 si (ao = aoActual()) entonces mensaje todava no has cumplido el primer aito // 2do si, ya cumpli aos, para la fecha de ejemplo mesActual() = 6 si_no si (mes < mesActual()) entonces mensaje ya cumpliste aos, felicitaciones atrasadas // 3er si, ya cumpli aos, 3er si faltan = mes mod 12 + 1 si_no si (mes > mesActual()) entonces mensaje faltan aproximadamente + faltan + para tu cumpleaos
59
Apuntes de algoritmos // 4to di, ya cumpli aos, diaActual() = 4 si_no si (dia < diaActual()) entonces mensaje ya cumpliste aos, felicitaciones atrasadas // 5to si, cumple aos muy pronto, faltan = dia - 22 si_no si (dia > diaActual()) entonces mensaje algrate slo quedan + faltan mensaje mensaje + das para tu cumple si_no mensaje Cumpleaos Feliz!!! muchos deseos de salud mensaje mensaje + y prosperidad en tu da 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 aos que tiene una persona procedimiento calcularEdad(E entero : ao; E/S entero : edad; E lgico : menor) edad aoActual() ao 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 nmero que pasamos como parmetro, devolviendo el valor de dicha potencia y el exponente al que est elevado. algoritmo ejemplo_8.5.c var entero : numero, resp1, resp2 inicio escribir(Introduce un nmero) leer(numero) comprueba(numero, resp1, resp2) escribir(2^ + resp1 + = + resp2 + > + numero) fin procedimiento comprueba(E entero : num; E/S entero : n, pot) var entero : n inicio n 1 mientras (pot < n) hacer pot pot * 2 n n+1 fin_mientras fin_procedimiento d. Calcular el primer trmino de la siguiente serie que sea mayor o igual a un valor V que se le pasa como parmetro y me devuelva el lugar que ocupa en la serie y el valor. Ai = 0 An = n + (An - 1)! entero funcin factorial(E entero : num) var entero : i, acum inicio acum 1
60
Apuntes de algoritmos desde i 1 hasta num hacer acum acum * i fin_desde devolver(acum) fin_funcin procedimiento serie(E entero : v; E/S entero : an, n) var entero : a1 inicio a1 0 an 0 n 1 mientras (an <= v) hacer n n+1 an n + factorial(a1) a1 an fin_mientras fin_procedimiento e. Qu se escribe en pantalla tras la siguiente ejecucin? algoritmo ejemplo_8.5.e var entero : A, B, C inicio A 1 B 2 C A+3 P1 (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 + z y x + 1 z y * 2 fin_procedimiento procedimiento P2(E/S entero : x; E entero : y) inicio x x +1 y y 3 fin_procedimiento entero funcin F(E entero : x) inicio x x + 3 devolver(x 1) fin_funcin La solucin es A = 8; B = 2; C = 3
61
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.a const salas = 5 asientos = 20 filas = 5 var entero : f, a, s lgico : bandera array [1..filas, 1..asientos, 1..salas] de entero : cine inicio pedirDatos(s) mientras (s <> 0) hacer bandera falso a 0 f 1 repetir si (a > asientos) entonces a 1 f 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] 1 escribir(Asiento + a + , fila + a) bandera verdadero fin_si fin_si hasta_que (a[f, a, s] = 1) y (bandera = verdadero) pedirDatos(s) fin_mientras fin procedimiento pedirDatos(E/S entero : sala) inicio repetir escribir(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 los elementos de la diagonal principal por la suma de los elementos que no forman parte de ella. algoritmo ejemplo_8.6.b var array [1..M, 1..N] de real : a real : suma inicio pedirDatos(a) 62
Apuntes de algoritmos sumar(a, suma) escribirArreglo(a) fin procedimiento pedirDatos(E/S array [1..M, 1..N] de real : matriz) var entero : i, j inicio 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_desde fin_procedimiento procedimiento sumar(E array [1..M, 1..N] de real : matriz; E/S real : s) var entero : i, j inicio s 0 desde i 1 hasta M hacer desde j 1 hasta N hacer si (i <> j) entonces s s + matriz[i, j] fin_si fin_desde fin_desde fin_procedimiento procedimiento escribirArreglo(E array [1..M, 1..N] de real : matriz; E real : s) var entero : i, j inicio desde i 1 hasta M hacer desde j 1 hasta N hacer si (i = j) entonces escribir(matriz[i, j] / s) si_no escribir(matriz[i, j]) fin_si fin_desde fin_desde fin_procedimiento c. Se tiene guardado en una estructura los alumnos de una escuela, sabiendo que hay 3 cursos, M alumnos por 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.c const cursos = 3 alumnos = M materias = N tipo array [1..cursos, 1.. alumnos, 1.. materias] de real : cubo 63
Apuntes de algoritmos var cubo : nota inicio pedirDatos(nota) mediaCurso(nota) cantidadAprobados(nota) mediaAlumno(curso) fin procedimiento pedirDatos(E/S cubo : n) var entero : c, a, m inicio 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_desde fin_desde fin_desde fin_procedimiento procedimiento mediaCurso(E cubo : n) var entero : curso, a, m real : media, suma inicio suma 0.0 repetir 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, aprobados inicio reprobados 0 aprobados 0 repetir 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 64
Apuntes de algoritmos aprobados aprobados + 1 si_no reprobados reprobados + 1 fin_si fin_desde fin_desde escribir(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, curso real : suma, media, mayor inicio mayor 0.0 desde c 1 hasta cursos hacer desde a 1 hasta alumnos hacer suma 0.0 desde m 1 hasta materias hacer suma suma + n[c, a, m] fin_desde media suma / materias si (media > mayor) entonces mayor media curso c alumno a fin_si fin_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 las ventas 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 ms ventas?
algoritmo ejemplo_8.6.d const departamentos = 5 empleados = 20 meses = 12 tipo array [1.. departamentos, 1.. empleados, 1.. meses] de real : matriz var matriz : ventas real : cantidad inicio pedirDatos(ventas) ventasDepartamentoMes(ventas) ventasEmpleadoDepartamento(ventas) mejorDepartamento(ventas) fin
65
Apuntes de algoritmos procedimiento pedirDatos(E/S matriz : a) var entero : d, e, m inicio 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, mes real : venta inicio venta 0.0 repetir 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, m real : venta inicio venta 0.0 repetir 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_desde escribir(Las ventas del empleado + empleado) escribir(del departamento + departamento + son + venta) fin_procedimiento
66
Apuntes de algoritmos procedimiento mejorDepartamento(E matriz : a) var entero : d, e, m, departamento real : mayor, venta inicio mayor 0.0 desde 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_desde si (venta > mayor) entonces mayor venta departamento d fin_si fin_desde escribir(El mejor departamento es el + departamento + con + mayor) fin_procedimiento
8.7. Registros
a. Tenemos un array con la informacin de nuestros productos, por cada producto almacenamos su cdigo, descripcin, stock actual y stock mnimo. Se trata de obtener otro array que contenga los productos de los que halla que hacer pedidos porque su stock sea inferior al mnimo, tal que al proveedor le tenemos que dar como datos la identificacin del producto y la cantidad que pedimos, que coincidir con el stock mnimo. Normalmente trabajamos con 100 productos. algoritmo ejemplo_8.7.a tipo registro : producto entero : codigo cadena : descripcin entero : stock entero : stock_min fin_registro registro : pedido entero : codigo entero : cantidad fin_registro array [1..100] de producto : listaProducto array [1..100] de pedido : listaPedido var listaProducto : prod listaPedido : ped entero : i, j inicio j 1 desde i 1 hasta 100 hacer si (prod[i].stock < prod[i].stock_min) entonces ped[j].codigo prod[i].codigo ped[j].cantidad prod[i].stock_min j j + 1 67
Apuntes de algoritmos fin_si fin_desde fin b. Dado un array que contiene la informacin de los alumnos de una clase de 100 alumnos, y teniendo en cuenta que de cada uno de ellos almacenamos su nmero de expediente, nombre y nota media. Hallar la media de todos los alumnos de esa clase y dar otra opcin que pida el nombre de un alumno y me de su nota si este alumno existe. algoritmo ejemplo_8.7.b tipo registro : alumno entero : expediente cadena : nombre real : media fin_registro array[1..100] de alumno : lista var lista : estudiante entero : op, i lgico : marca cadena : nombre inicio presentar(op) mientras (op <> 0) hacer segn_sea op hacer 1: escribir(La media de la clase es + notaMedia(estudiante)) 2: escribir(Introduce un nombre) leer(nombre) marca falso i 1 repetir si (comparar(estudiante[i].nombre, nombre) = verdadero) entonces marca = verdadero si_no i i + 1 fin_si hasta_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_segn 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 opcin) leer(opcion) hasta_que (opcion >= 0) y (opcion <= 2) fin_procedimiento
68
Apuntes de algoritmos real funcin notaMedia(E lista : a) var entero : i real : acum inicio acum 0 desde i 1 hasta 100 hacer acum acum + a[i].nota fin_desde devolver(acum / 100) fin_funcin lgico funcin comparar(E cadena : c1, c2) var entero : i inicio i 1 mientras (c1[i] = c2[i]) y (c1[i] <> $) y (c2[i] <> $) hacer i i + 1 fin_mientras si (c1[i] = c2[i]) entonces devolver(verdadero) si_no devolver(falso) fin_si fin_funcin c. Tenemos un array con la indicacin de cada producto, stock, descripcin y fecha. Hallar una opcin que nos sirva 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 dice es si hay cantidad suficiente, respondiendo Pedido suministrado y actualizando el stock, y si el producto solicitado no existe o no hay suficiente cantidad, mostrar un mensaje de error explicando la causa. algoritmo ejemplo_8.7.c tipo registro : t_fecha entero: dia entero : mes entero : ao fin_registro registro : producto entero : codigo cadena : descripicion entero : stock t_fecha : fecha fin_registro array[1..10] de producto : lista var lista : prod entero : codigo, cantidad, i lgico : marca inicio escribir(Introduce el cdigo) leer(codigo) escribir(Introduce la cantidad) leer(cantidad) mientras (codigo <> 0) hacer i 1 69
Apuntes de algoritmos marca falso repetir si (codigo = prod[i].codigo) entonces marca verdadero si_no i i + 1 fin_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 cantidad escribir(pedido suministrado) fin_si fin_si fin_mientras fin
8.8. Cadenas
a. Borrar de una cadena una subcadena que forma parte de ella. Dar la posicin de inicio y final de la subcadena que quiero borrar. procedimiento borrar(E/S cadena : c; E entero : ini, fin) var entero : i, j inicio i ini f 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 posicin. procedimiento insertar(E/S cadena : c; E cadena : s; E entero : pos) var entero : p, j, i inicio 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 + 1 p p + 1 fin_mientras fin_procedimiento
70
Apuntes de algoritmos c. Crear una funcin a la que se le pasa una cadena como parmetro y como resultado devuelve la longitud de la misma. entero funcin longitud(E cadena : c) var entero : l inicio l 0 mientras (c[L + 1] <> $) hacer l l + 1 fin_mientras devolver(l) fin_procedimiento d. Intercambiar la aparicin de una subcadena dentro de una cadena, por otra subcadena. Para eso la primera subcadena tiene que aparecer en la otra. procedimiento intercambio(E/S cadena : c; E cadena : c2, c3) var entero : i, pos inicio 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 +1 fin_si si_no i I+1 fin_si fin_mientras fin_procedimiento e. Comparar 2 cadena si son iguales o no. Realizar la comparacin utilizando los valores ASCII asociados a cada carcter. En el caso de que se comparen 2 cadenas de diferente longitud tal que la cadena de menor longitud tiene N caracteres y estos N caracteres coinciden con los N primeros caracteres de la cadena ms larga, se considera mayor la cadena ms larga. entero funcin comparacion(E cadena c1, c2) var entero : i inicio i 1 mientras (c1[i] = c2[i]) y (c1[i] <> $) y (c2[i] <> $) hacer i i + 1 fin_mientras si (c1[i] = c2[i]) entonces devolver(0) si_no devolver(ascii(c1[i]) - ascii(c2[i])) fin_si fin_funcin
71
f.
Crear una funcin que dado 2 cadenas, busque si existe la cadena 1 dentro de la cadena 2. entero funcin busqueda(E cadena : c, s1) var entero : i, pos, k lgico : encontrado inicio e 1 encontrado falso mientras (c[i] <> $) y (encontrado = falso) hacer si (c[i] = s[i]) entonces pos i k 1 mientras (c[i] = s[k]) y (c[i] <> $) y (s[k] <> $) hacer i i + 1 k k + 1 fin_mientras si (s[k] = $) entonces encontrado verdadero si_no i pos + 1 pos 0 fin_si si_no i i + 1 fin_si fin_mientras devolver(pos) fin_funcin
g. Crear una funcin que extraiga parte de una cadena, sabiendo el inicio y el fin, e insertarlo de una segunda cadena. procedimiento subcadena(E cadena : c1; E entero : inicio, long; E/S cadena : c2) var entero : i, k inicio si (inicio <= 0) o (inicio > longitud(c1)) entonces c2[1] $ si_no i inicio k 1 mientras (i <= inicio + long) y (c1[i] < > $) hacer c2[k] c1[i] k k + 1 i i + 1 fin_mientras c2[k] $ fin_si fin_procedimiento
72
8.9. Definicin de una clase
clase rectngulo // Atributos var privado real : largo, ancho // Mtodos // Mtodo constructor constructor rectngulo(E real : lar, anc) inicio largo lar ancho anc fin_constructor // Mtodo que modifica el valor del atributo largo pblico procedimiento modificarLargo(E real : lar) inicio largo lar fin_procedimiento // Mtodo que retorna el valor del atributo largo pblico real funcin mostrarLargo() inicio devolver(largo) fin_funcin // Mtodo que modifica el valor del atributo ancho pblico procedimiento modificarAncho(E real : anc) inicio ancho anc fin_procedimiento // Mtodo que retorna el valor del atributo ancho pblico real funcin mostrarAncho() inicio devolver(ancho) fin_funcin // Mtodo que retorna el rea o superficie ocupada por el rectngulo pblico real funcin calcularrea() inicio devolver(largo * ancho) fin_funcin
73
Apuntes de algoritmos // Retorna el permetro del rectngulo pblico real funcin calcularPermetro() inicio devolver(2 * (largo + ancho)) fin_funcin fin_clase // Uso de la clase rectngulo clase algoritmoPrincipal // Atributos var // Se declara una variable de tipo objeto rectngulo a la cual llamaremos rect privado rectngulo : rect // Se declaran las variables reales l y a para largo y ancho del rectngulo privado real : l, a pblico mtodo principal() inicio escribir(Suministre a continuacin los valores para el largo y el ancho) leer(l) leer(a) rect = nuevo rectngulo(l, a) escribir(Resultados de los clculos) escribir(rea: + rect.calcularrea()) escribir(Permetro + rect.calcularPermetro()) fin_metodo fin_clase
8.10.
Asociacin (ver algoritmo del Ejemplo 8.9.)
74
8.11.
Herencia, clase abstracta y asociacin
abstracto clase persona // Atributos var privado entero : cedula privado cadena : nombre privado entero : edad // Mtodos // Mtodo constructor constructor persona(E entero : c; E cadena : n; E entero : e) inicio cedula c nombre n edad e fin_constructor // Mtodo que modifica el valor del atributo cedula pblico procedimiento modificarCdula(E entero: c) inicio cedula c fin_procedimiento // Mtodo que retorna el valor del atributo cedula pblico real funcin mostrarCdula() inicio devolver(cedula) fin_funcin // Mtodo que modifica el valor del atributo nombre pblico procedimiento modificarNombre(E cadena : n) inicio nombre n fin_procedimiento
75
Apuntes de algoritmos // Mtodo que retorna el valor del atributo nombre pblico real funcin mostrarNombre() inicio devolver(nombre) fin_funcin // Mtodo que modifica el valor del atributo edad pblico procedimiento modificarEdad(E cadena : e) inicio edad e fin_procedimiento // Mtodo que retorna el valor del atributo edad pblico real funcin mostrarEdad() inicio devolver(edad) fin_funcin fin_clase clase alumno hereda_de persona // Atributos var privado entero : identificacion // Mtodos // Mtodo constructor constructor alumno(E entero : c; E cadena : n; E entero : e, i) inicio super(c, n, e) identificacion i fin_constructor // Mtodo que modifica el valor del atributo identificacin pblico procedimiento modificarIdentificacin(E entero: i) inicio identificacion i fin_procedimiento // Mtodo que retorna el valor del atributo identificacin pblico real funcin mostrarIdentificacin() inicio devolver(identificacion) fin_funcin fin_clase clase algoritmoPrincipal // Atributos var privado alumno : estudiante privado entero : c, e, i privado cadena : n pblico mtodo 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: ) 76
Apuntes de algoritmos escribir(Cdula 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 asociacin
abstracto clase cudriltero var privado entero : color // Mtodos // Mtodo constructor constructor cuadriltero(E entero : c) inicio color c fin_constructor
77
Apuntes de algoritmos // Mtodo que modifica el valor del atributo color pblico procedimiento modificarColor(E entero: c) inicio color c fin_procedimiento // Mtodo que retorna el valor del atributo color pblico real funcin mostrarColor() inicio devolver(color) fin_funcin // Mtodo que calcula el rea del cudriltero abstracto pblico real funcin calcularrea() inicio fin_funcin fin_clase clase cuadrado hereda_de cuadriltero // Atributos var privado real : lado // Mtodos // Mtodo constructor constructor cuadrado(E entero : c, E real : l) inicio super(c) lado l fin_constructor // Mtodo que modifica el valor del atributo lado pblico procedimiento modificarLado(E entero: l) inicio lado l fin_procedimiento // Mtodo que retorna el valor del atributo lado pblico real funcin mostrarLado() inicio devolver(lado) fin_funcin // Mtodo que calcula el rea del cuadrado pblico real funcin calcularrea() inicio devolver(lado ** 2) fin_funcin // Mtodo que calcula el permetro del cuadrado pblico real funcin calcularPermetro() inicio devolver(4 * lado) fin_funcin fin_clase clase rectngulo hereda_de cuadriltero // Atributos var privado real : ladoA, ladoB
78
Apuntes de algoritmos // Mtodos // Mtodo constructor constructor rectngulo(E entero : c, E real : lA, lB) inicio super(c) ladoA lA ladoB lB fin_constructor // Mtodo que modifica el valor del atributo lado pblico procedimiento modificarLadoA(E entero: lA) inicio ladoA lA fin_procedimiento // Mtodo que retorna el valor del atributo ladoA pblico real funcin mostrarLadoA() inicio devolver(ladoA) fin_funcin // Mtodo que modifica el valor del atributo ladoB pblico procedimiento modificarLadoB(E entero: lB) inicio ladoB lB fin_procedimiento // Mtodo que retorna el valor del atributo ladoB pblico real funcin mostrarLadoB() inicio devolver(ladoB) fin_funcin // Mtodo que calcula el rea del rectngulo pblico real funcin calcularrea() inicio devolver(ladoA * ladoB) fin_funcin // Mtodo que calcula el permetro del rectngulo pblico real funcin calcularPermetro() inicio devolver(2 * (ladoA + ladoB)) fin_funcin fin_clase clase cubo hereda_de cuadrado // Atributos var privado real : altura // Mtodos // Mtodo constructor constructor cubo(E entero : c, E real : l, a) inicio super(c, l) altura a fin_constructor
79
Apuntes de algoritmos // Mtodo que modifica el valor del atributo altura pblico procedimiento modificarAltura(E entero: a) inicio altura a fin_procedimiento // Mtodo que retorna el valor del atributo altura pblico real funcin mostrarAltura() inicio devolver(altura) fin_funcin // Mtodo que calcula el volumen del cubo pblico real funcin calcularVolumen() inicio devolver(altura * super.calcularrea()) fin_funcin fin_clase clase algoritmoPrincipal // Atributos var privado cubo : c privado rectngulo : r privado entero : colorCubo, colorRectangulo privado real : lado, altura, ladoA, ladoB pblico mtodo 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 rectngulo(colorRectangulo, ladoA, ladoB) escribir(El volumen del cubo es: + c. calcularVolumen()) escribir(El rea del rectngulo es: + r.calcularrea()) escribir(El permetro del rectngulo es: + r.calcularPermetro()) fin_metodo fin_clase
80
Bibliografa
Joyanes, L. (2007). Fundamentos de Programacin - Algoritmos, Estructuras de Datos y Objetos. Tercera Edicin. Madrid, Espaa: Mc Graw Hill. Joyanes, L. (2003). Libro de Problemas, Fundamentos de Programacin - Algoritmos, Estructuras de Datos y Objetos. Segunda Edicin. Madrid, Espaa: Mc Graw Hill. Joyanes, L. (2006). Programacin en Pascal. Cuarta Edicin. Madrid, Espaa: Mc Graw Hill. Kimmel, P. (2007). Manual de UML. Primera Edicin. Mc Graw Hill. Leestma, S. y Nyhoff, L. (2000). Programacin en Pascal. Cuarta Edicin. Madrid, Espaa: Pretence Hall.
81

Apuntes de Algoritmos

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Apuntes de Algoritmos

Uploaded by

Copyright:

Available Formats

Apuntes de algoritmos

Apuntes de algoritmos Contenido

2. Estructura general de un programa........................................... 17

3. Estructura general de un programa........................................... 22

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

5. Tipos de datos estructurados .................................................... 35

6. Introduccin a la programacin orientada a objetos............... 43

6.7. Diagrama de clases .........................................................................................46 6.8. Relaciones entre clases ...................................................................................47

7. Fundamentos del enfoque orientado a objeto.......................... 50

Diferencias entre los tipos software

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

Unidad central de proceso (CPU o Procesador)

Unidad lgico-aritmtica (ALU). Se encarga de realizar las operaciones aritmticas y comparaciones.

1.2. Resolucin de problemas

1.2.3. Lenguaje de programacin

1.2.6. Aspectos que miden la calidad en un programa

Apuntes de algoritmos Portabilidad Reusabilidad del software

1.2.7. Capacidad de abstraccin

1.2.8. Enfoques para solucionar un problema

1.2.9. Fases en la resolucin de problemas

1.2.10. Ciclo de vida de desarrollo del software

1.3.2. Tipo de dato

1.3.3. Posible clasificacin de los tipos de datos

Esquemas de organizacin de los tipos de datos

1.3.6. Operaciones de los tipos de datos elementales

Numricas: Operadores aritmticos

Expresiones lgicas: Operadores relacionales y lgicos

1.3.9. Funciones internas

1.4. Representacin de algoritmos

1.4.1. Diagramas de flujo

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

area = base * altura

1.4.2. Diagramas N-S (Nassi-Schneiderman)

leer num mientras num >= 0 p p*num

leer num escribir p fin

2. Estructura general de un programa

2.2. Operacin de asignacin

En el contexto de un lenguaje de programacin, a la operacin de asignacin, se le llama instruccin o sentencia de asignacin.

2.2.1. Operacin de lectura o entrada simple (leer)

2.2.2. Operacin de escritura o salida simple (escribir)

2.3. Conversin de tipos

2.3.1. Conversin implcita

2.3.2. Conversin explcita

En determinadas condiciones el interruptor conmuta <nombre_del_interruptor> no <valor_del_interruptor>

3. Estructura general de un programa

3.2. Estructura secuencial

3.3. Estructura selectiva

no expresin lista1 lista2 accin

3.4. Estructura repetitiva

no condicin si incremento o decremento accin

3.5. Estructura anidada

3.5.1. Anidacin de condicionales

3.5.2. Bucles anidados

4. Subalgoritmos, funciones y procedimientos

Existen dos tipos de subalgoritmos: funciones y procedimientos.

4.2.1. Declaracin de una funcin

4.2.2. Llamado de una funcin

4.3.1. Declaracin de procedimientos

4.3.2. Llamado de un procedimiento

4.3.3. Diferencias entre funciones y procedimientos:

4.4. Estructura general de un algoritmo

4.5. Parmetros de los subalgoritmos

5. Tipos de datos estructurados

Estructuras de datos estticas