Académique Documents
Professionnel Documents
Culture Documents
PROGRAMACIÓN
CÁTEDRA: PROGRAMACIÓN BÁSICA Y MÉTODOS NUMÉRICOS
INDICE
La computadora ............................................................................................................................................................. 4
Componentes y funcionamiento básico de una computadora ..................................................................4
Conceptos básicos ....................................................................................................................................5
Sistemas de representación numérica ........................................................................................................................... 6
Sistemas de numeración ..........................................................................................................................6
El sistema decimal ....................................................................................................................................6
Teorema fundamental de la numeración ..................................................................................................6
El sistema binario ......................................................................................................................................7
Suma Binaria ........................................................................................................................................................ 7
Resta Binaria ........................................................................................................................................................ 7
Multiplicación binaria ............................................................................................................................................ 7
División Binaria ..................................................................................................................................................... 8
El sistema hexadecimal ............................................................................................................................8
Conversiones ............................................................................................................................................8
Conversión decimal-binario .................................................................................................................................. 8
Conversión decimal-hexadecimal ......................................................................................................................... 8
Conversión hexadecimal-binario y binario-hexadecimal ...................................................................................... 9
Conversión octal-binario y binario-octal................................................................................................................ 9
Conversión octal-hexadecimal ............................................................................................................................. 9
Conversión de cualquier base a decimal .............................................................................................................. 9
Representación de números enteros ........................................................................................................................... 10
Módulo y signo ........................................................................................................................................10
Complemento a 1 ....................................................................................................................................10
Complemento a 2 ....................................................................................................................................10
Exceso a 2n-1 ...........................................................................................................................................11
Representación en coma flotante ...........................................................................................................11
Ejemplo.......................................................................................................................................................... 11
Códigos Alfanuméricos ................................................................................................................................................ 12
Errores de redondeo en una computadora .................................................................................................................. 13
Errores de truncamiento .............................................................................................................................................. 14
Estabilidad numérica .................................................................................................................................................... 14
Definición .................................................................................................................................................14
Problema bien o mal condicionado .............................................................................................................................. 15
RESOLUCION DE PROBLEMAS ................................................................................................................................ 16
No es lo mismo programar que codificar. ...............................................................................................16
ALGORITMO ............................................................................................................................................................... 18
¿Cómo expresamos un algoritmo? .................................................................................................................... 18
Diagrama de Flujo .............................................................................................................................................. 19
Diagrama Nassi-Schneiderman.......................................................................................................................... 19
Pseudocódigo..................................................................................................................................................... 19
Algunas definiciones .................................................................................................................................................... 20
Constantes y variables ................................................................................................................................................. 20
Estructura del algoritmo ............................................................................................................................................... 21
Declaración de constantes y variables ............................................................................................................... 21
Datos y tipos de datos ................................................................................................................................................. 22
Tipos Numéricos ................................................................................................................................................ 22
Tipo Lógico ......................................................................................................................................................... 23
Tipo Caracter...................................................................................................................................................... 23
Tipo cadena de caracteres ................................................................................................................................. 24
Expresiones........................................................................................................................................................ 24
Estructuras de control .................................................................................................................................................. 26
Primitivas de control o composición ................................................................................................................... 27
Combinación de estructuras de control .............................................................................................................. 30
Especificación de algoritmos........................................................................................................................................ 31
Metodología de resolución de problemas .................................................................................................................... 32
Un primer programa ................................................................................................................................33
Otro programa: variante del problema anterior................................................................................................... 34
Variables de uso particular .......................................................................................................................................... 36
Prueba del algoritmo .................................................................................................................................................... 36
Validación de datos de entrada.................................................................................................................................... 37
Cómo finalizar la entrada de un conjunto de datos ...................................................................................................... 37
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 3
La computadora
Una computadora es una máquina digital y sincrónica, con cierta capacidad de cálculo numérico y lógico,
controlada por un programa almacenado, y con posibilidad de comunicación con el mundo exterior,
capaz de aceptar datos a través de un medio de entrada, procesarlos automáticamente bajo el control de
un programa y proporcionar la información resultante a través de un medio de salida..
Es digital: las señales eléctricas que se manejan y la información que se procesa se representa en
forma discreta, por medio de valores binarios (0 y 1).
Es sincrónica: realiza las operaciones coordinada por un reloj central que envía pulsos de sincronismo
a todos los elementos que componen la computadora (todas las operaciones internas se realizan en
instantes de tiempo predefinidos y coordinados con el reloj).
Internamente posee una capacidad de cálculo numérico y lógico, en un subsistema conocido como
unidad aritmético-lógica (UAL). Normalmente las operaciones que pueden realizarse en ella son muy
simples (suma, disyunción, conjunción, comparaciones).
Es controlada por programa, lo que diferencia de una calculadora, internamente se tienen órdenes o
instrucciones almacenadas, que la computadora podrá leer, interpretar y ejecutar ordenadamente. El
programa controla todo el proceso, del principio al fin: podemos modificar su funcionamiento con solo
cambiar el programa.
Además, está comunicada con el mundo real, que es analógico, puede realizar operaciones de entrada y
salida con el mundo real, a través de dispositivos periféricos (por ejemplo el teclado o mouse para
entrada de información, y pantalla como salida). La computadora es una máquina que cambia
información de una forma a otra: recibe información (entrada), la transforma, y proporciona información
(salida).
Las computadoras en realidad sólo hacen cuatro cosas:
o recibir entradas (aceptan información desde el mundo exterior)
o producir salidas (dan información al mundo exterior)
o procesar información (llevan a cabo operaciones aritméticas o lógicas con la información) y
o almacenar información (mueven y almacenan información en la memoria).
Con estas cuatro operaciones básicas las computadoras cumplen todas sus funciones.
Componentes y funcionamiento básico de una computadora
La mayoría de las computadoras actuales de propósito general presentan una estructura interna basada
en la arquitectura definida por John Von Neumann. Podemos esquematizarla de la siguiente manera:
Bus de comunicaciones
Memoria
Principal UCP
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 5
La memoria central llamada memoria principal (o primaria) es un conjunto de celdas direccionables vía
un único nombre. Provee acceso directo por referencia para carga y recuperación de información. Los
programas residen en este tipo de memoria al ser ejecutados (en el gráfico se la ha resaltado como
memoria de instrucciones Mi ya que residen las órdenes que la computadora debe interpretar y
ejecutar). En esta memoria también se almacena la información con la cual la computadora realizará los
procesos (cálculos, decisiones, actualizaciones) que sean necesarios para la resolución del problema
(resaltado en el gráfico como memoria de datos Md).
La Unidad Central de Procesamiento (UCP) es la encargada de interpretar y llevar a cabo las
instrucciones de los programas. En las computadoras personales está representada por el
microprocesador (por ejemplo 486, 586, Pentium, etc.). Efectúa manipulaciones aritméticas y lógicas con
los datos, y se comunica con las demás partes del sistema de cómputo.
Unidad de Control:
o Carga instrucciones en memoria
o Interpreta y
o Devuelve el resultado de la ejecución
Unidad Aritmética y Lógica:
o Proceso de operaciones aritméticas y lógicas
o Provee decisión a la Unidad de Control
El bloque rotulado como entrada/salida representa los dispositivos que permiten la comunicación con el
mundo real. Por ejemplo, el controlador de video que vincula el procesador central de la computadora
con la pantalla o el circuito controlador de multimedia que permite tener salida por un parlante o entrada
por un micrófono.
Los dispositivos de entrada-salida permiten la comunicación ente el usuario y la computadora:
Dispositivos de
Dispositivos de entrada Dispositivos de salida
entrada/salida
Teclados Impresoras Placa de red
Ratón o mouse Pantalla Modem
Lectores de disco Parlantes Placa de sonido
etc. etc. Lecto-grabadoras
Las líneas de comunicación indicadas como bus de comunicaciones normalmente permiten el paso de
tres grandes categorías de información: direcciones, datos y control.
El funcionamiento de una Computadora se puede sintetizar de la siguiente manera:
1. Buscar la próxima instrucción a ejecutar Ιi de la memoria de instrucciones Mi.
2. Interpretar qué hacer con Ιi en la Unidad de Control (UC).
3. Ejecutar las operaciones interpretadas por UC, utilizando la UAL de ser necesario. Estas
operaciones pueden comprender lectura/escritura de la memoria de datos Md o entrada/salida
por los periféricos Pe o Ps.
Conceptos básicos
El hardware se refiere a las componentes físicas de la computadora. es el conjunto de dispositivos
utilizados, tanto mecánicos como eléctricos y electrónicos.
El software es la parte lógica, comprende los programas que se ejecutan sobre la computadora. El
software de una computadora puede dividirse en modo general en dos clases: los programas del
sistema, que manejan las operaciones de la computadora, y los programas de aplicación, que resuelven
los problemas de sus usuarios. El más importante de los programas de sistema es el sistema operativo.
El sistema operativo, controla los recursos de la computadora y ofrece una interface a los usuarios para
que desarrollen sus programas.
Un bit (dígito binario o binary dígit) es la unidad de información más pequeña. Solo puede tener uno de
dos valores: encendido o apagado (0 o 1, si o no, blanco o negro, etc.). Un byte es la menor unidad
direccionable, es un agrupamiento de 8 bits. Se pueden representar 28 valores diferentes. Un kilobyte o
KB es un múltiplo de byte igual a 210 bytes y un megabyte o MB es 210 KB
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 6
sistema cuya base es B y representamos por Xi cada uno de los dígitos que contiene dicha cantidad,
donde el subíndice indica la posición del dígito con respecto a la coma decimal, posición que hacia la
izquierda de la coma se numera desde 0 en adelante y de uno en uno, y hacia derecha se numera desde
–1 y con incremento –1.
El Teorema fundamental de la Numeración dice que el valor decimal de una cantidad expresada en otro
sistemas de numeración, está dado por la fórmula:
...+ d3 x B3 + d2 x B2 + d1 x B1 + d0 x B0 + d-1 x B-1 + d-2 x B-2 + ...
donde el número en base B es ...d4 d3 d2 d1 d0 d-1 d-2....
Ejemplo
Supongamos que la cantidad 201.1 está expresada en el sistema de numeración de base 3 que utiliza
los dígitos 0, 1 y 2 para representar cantidades. ¿Cuál será la representación de la misma cantidad en el
sistema decimal?
201.13 = 2 x 32 + 0 x 31 + 1 x 30 + 1 x 10-1 = 18 + 0 +1 + 0.333 = 19.333
El sistema binario
La base o número de símbolos que utiliza el sistema binario es 2, siendo estos símbolos 0 y 1, los
disponibles para representación.
Ejemplo: Qué número decimal representa el número binario 1001.1? Para el desarrollo utilizaremos el
teorema fundamental de la numeración:
1001.13 = 1x23 + 0x22 + 0x21 + 1x20 + 1x2-1 = 8 + 0 + 0 +1 + 0.5 = 9.5
Suma Binaria
Es semejante a sumar en el sistema decimal, con la diferencia que se manejan sólo dos dígitos (0 y 1),
de tal forma que cuando el resultado excede los símbolos utilizados se agrega el exceso (denominado
acarreo) a la suma parcial siguiente hacia la izquierda.
Ejemplo: Sumar los números 100100 (36) y 10110 (22)
100100 36
10110 22
111010 58
Resta Binaria
La resta binaria es similar a la decimal con la diferencia de tener sólo dos dígitos, y teniendo en cuenta
que al realizar las restas parciales entre dos dígitos de idénticas posiciones, uno del minuendo y otro del
sustraendo, si el segundo excede al primero, se sustrae una unidad del dígito de más a la izquierda en el
minuendo (si existe y vale 1) convirtiéndose este último en 0, y equivaliendo la unidad extraída a 1 * 2 en
el minuendo de resta parcial que estamos realizando. Si el dígito siguiente de la izquierda es 0, se busca
en los sucesivos teniendo en cuenta que su valor se multiplica por dos a cada desplazamiento sucesivo
a derecha.
Ejemplo: Restar los números 111010 (58) y 10110 (22)
111010 58
10110 22
100100 36
Multiplicación binaria
La multiplicación binaria se realiza de forma similar a la multiplicación decimal salvo que la suma final de
los productos parciales se hace en binario
Ejemplo: Multiplicar los números 111010 (58) y 1010 (10)
111010 58
1010 10
000000
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 8
111010
000000
111010 .
1001000100 580
División Binaria
La división binaria, al igual que las operaciones anteriores, se realiza de forma similar a la división
decimal salvo que las multiplicaciones y restas internas al proceso de la división se hacen en binario.
Ejemplo: Dividir los números 111010 (58) y 1010 (10)
111010 |1010
010010 101 Cociente=1012 y Resto=10002
01000
El sistema hexadecimal
Al igual que los anteriores, el sistema hexadecimal es un sistema posicional de base 16 en el que se
utilizan dieciséis símbolos para la representación de cantidades. Estos símbolos son los siguientes
0 1 2 3 4 5 6 7 8 9 A B C D E F
donde las letras A, B, C, D, E, F equivalen a 10, 11, 12, 13, 14 y 15 respectivamente.
Ejemplo: Qué número decimal representa el número hexadecimal 1AE.D? Para el desarrollo
utilizaremos el teorema fundamental de la numeración:
1AE.D16 = 1x162 + 10x161 + 14x160 + 13x16-1 = 256 + 160 + 14 +0.8125 = 430.8125
Conversiones
Conversión decimal-binario
El método de conversión de un número decimal a un número binario consiste en efectuar, sobre la parte
entera del número decimal, divisiones sucesivas de los cocientes por el número 2, hasta que el cociente
entre una de las divisiones tome el valor 0. La unión de todos los restos obtenidos, escritos en orden
inverso, nos proporciona el número inicial expresado en sistema binario.
Ejemplo: Convertir el número decimal 13 a binario.
13 |2
1 6 |2
0 3 |2 1310 = 11012
1 1
Para convertir una fracción decimal a su equivalente binario se debe multiplicar dicha fracción por dos,
obteniendo en la parte entera del resultado el primero de los dígitos binarios de la fracción que
buscamos. A continuación, se repite el proceso con la parte fraccionaria del resultado anterior,
obteniendo en la parte entera del nuevo resultado el segundo de los dígitos buscados. El proceso se
1 0
repite hasta que desaparezca la parte fraccionaria de los resultados parciales (se haga 0) o hasta que
tengamos los suficientes dígitos binarios.
Ejemplo: convertir la fracción 0.828125 a binario
0.828125 * 2 = 1.65625
0.65625 * 2 = 1.3125
0.3125 * 2 = 0.625
0.625 * 2 = 1.25 0.82812510 = 0.1101012
0.25 * 2 = 0.5
0.5 * 2 = 1
Conversión decimal-hexadecimal
El mecanismo consiste en dividir y multiplicar por 16.
Ejemplo: Convertir el número 29.42 a hexadecimal.
Primer paso conversión de la parte entera, luego conversión de la mantisa.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 9
Primer paso: se complementa el número positivo en todos sus bits (cambiando ceros por uno y
viceversa), incluido el bit de signo, similar a complemento a 1.
Segundo paso: al resultado obtenido se el suma 1 (en binario), despreciando el último acarreo si
existiera.
Veamos la representación en complemento a 2 de los números 10 y –10 para el caso de n=8 bits.
0 (+) 0 0 0 1 0 1 0 representa al número 10,
1 (-) 1 1 1 0 1 1 0 representa al número –10.
Para el complemento a 2 el rango de representación es, si se disponen de n bits:
-2n-1 <= X <= 2n-1 – 1
Para el caso de n = 8 bits, el rango de representación va desde –128 a 127.
La principal ventaja es la de tener una única representación para el número 0, ya que el 0 positivo o
negativo se representan igual.
Exceso a 2n-1
Este método de representación no utiliza ningún bit para el signo, con lo cual todos los bits representan
un número o valor. Este valor se corresponde con el número representado más el exceso, que para n
bits viene dado por 2n-1.
Por ejemplo, para n=8 bits el exceso será 128, con lo cual para representar un número deberá
sumársele dicho exceso. De esta manera el número 10, que veníamos representando, recibirá la adición
del número 128, con lo que representaremos el número binario 138. Por otro lado, el número –10, se
representará como el 118 (-10+128). De esta forma quedarán representados como:
1 0 0 0 1 0 1 0 representa al número 10,
0 1 1 1 0 1 1 0 representa al número –10.
En este sistema el número 0 tiene una sola representación, la cual consiste en representar el exceso,
128 en este caso.
El rango de representación en exceso a 2n-1 es asimétrico y viene dado por:
-2n-1 <= X<= 2n-1 – 1
Resulta interesante observar que todo número representado en exceso a 2n-1 tiene la misma
representación que un complemento a 2 con el bit de signo cambiado.
Representación en coma flotante
La coma o punto flotante surge de la necesidad de representar números reales y enteros con un rango
de representación mayor que el que nos ofrece la representación en punto fijo y posibilitar a la
computadora el tratamiento de números muy grandes y muy pequeños. Estas ventajas que nos ofrece
la coma flotante traen como contraprestación una disminución (relativamente pequeña) en la precisión
de los números representados. En su representación se utiliza la notación científica o exponencial
matemática en la que una cantidad se representa de la siguiente forma:
n° = mantisa * base de exponenciaciónexponente
Un número en esta notación tiene infinitas representaciones, de las que se toma como estándar la
denominada normalizada, que consiste en que la mantisa no tiene parte entera y el primer dígito o cifra a
la derecha del punto decimal es significativo (distinto de 0), salvo en la representación del número 0.
Ejemplo
Representación del número decimal 352.41 con base de exponenciación 10.
352.41 = 352.41 x 10-0 = 35241 x 10-2 = 0.35241 x 103
siendo está última expresión la que corresponde al número normalizado.
En este sistema de codificación de números, se dividen los bits disponibles en la palabra o doble palabra
de la computadora entre la mantisa y el exponente, teniendo una base de exponenciación determinada
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 12
(2 o potencia de 2). Normalmente la definición de la coma flotante de una computadora sigue las
siguientes reglas:
o El exponente se representa en uno de los siguientes sistemas de codificación: módulo y signo o
exceso a 2n-1, siendo siempre un número entero. En este sistema de codificación el exponente
también recibe el nombre de característica.
o La mantisa es un número real con el punto decimal implícito a la izquierda de sus bits,
representada normalmente en uno de los siguientes sistemas de codificación: módulo y signo,
complemento a 1 o complemento a 2.
o La base de exponenciación es una potencia de 2 determinada por el fabricante de la
computadora (2, 8 o 16)
Existen muchas formas de representación en coma flotante, variando su longitud de la palabra de la
computadora, la base de la exponenciación, el número de bits reservados para la mantisa y para el
exponente, el sistema utilizado para representar la mantisa y el exponente, etc. La coma flotante se
define particularmente en cada caso. Las definiciones más comunes son las siguientes:
Signo Exponente Mantisa
para simple precisión (32 bits)
31 30 22 0
El rango de representación en la coma flotante debe ser analizado teniendo en cuenta los máximos y
mínimos valores representables tanto con signo positivo como negativo:
máximo exponente
mínimo número negativo = -(mantisa máxima) * base
-maximo exponente
máximo número negativo = -(mantisa mínima) * base
-máximo exponente
mínimo número positivo = mantisa mínima * base
máximo exponente
máximo número positivo = mantisa máxima * base
Existen cuatro zonas de números que no pueden ser representados mediante un determinado formato
de coma flotante, estas zonas están ubicadas cercanas al 0, tanto para valores positivos como negativos
(subdesbordamiento positivo o negativo), como para valores grandes (positivos) o chicos (negativos) que
exceden el rango de representación.
Códigos Alfanuméricos
Una computadora puede trabajar internamente con un conjunto de caracteres que nos permitirán
manejar datos, informaciones, instrucciones, órdenes de control, etc. Este conjunto de caracteres
podemos subdividirlo en los siguientes grupos:
o caracteres alfabéticos
o letras mayúsculas (A..Z sin la Ñ)
o letras minúsculas (a..z sin la ñ)
o cifras decimales: los números 0, 1, ..., 9
o caracteres especiales
o caracteres como el . , ; : * @, etc.
o órdenes de control. Equivalen a las teclas enter, tabulación, esc, etc.
En general cada carácter se maneja internamente en una computadora por medio de un conjunto de 8
bits mediante un sistema de codificación binario que denominaremos código de caracteres.
Cada computadora tiene su código de caracteres definidos por el fabricante, si bien la mayoría de ellos
adaptan a sus equipos códigos estándar de los ya establecidos. En estos códigos se representa cada
carácter por medio de un byte, con lo cual todo tipo de información puede ser utilizada internamente,
formando cadenas de bytes sucesivos que representarán cadenas de caracteres para que la máquina
las maneje e interprete. No todos los tipos de códigos utilizan para la representación de caracteres los
ocho bits de un byte; en la actualidad se tiende a utilizar códigos de 8 bits aunque siguen existiendo
algunos códigos de 6 y 7 bits.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 13
Hoy los códigos utilizados son los de 8 bits, de los cuales los más conocidos son el EBCDIC (Extended
Binary Coded Decimal Interchage Code) y el ASCII extendido que agrega un bit a la representación
extendiendo la cantidad de símbolos disponibles a 256.
Como consecuencia de que la cantidad de dígitos significativo de un número real puede ser
matemáticamente infinita y la representación en la máquina es finita, se provocan redondeos y
truncamiento, pudiendo resultar que dos números reales matemáticamente distintos tengan igual
representación interna.
También puede darse el caso que dos valores matemáticamente iguales tengan representación
computacional distinta: el resultado de dos operaciones sea matemáticamente idéntico pero por surgir de
representaciones distintas antes del cálculo, den resultados computacionalmente diferente.
Por ejemplo: 5.4 – 3.1 es matemáticamente igual a 308.93 – 1006.80 + 700.17. Si el resultado de esas
operaciones almacenan respectivamente en variables R1 y R2 de tipo real, es muy probable que al
hacer la comparación R1 = R2 dé el valor falso.
Se llama épsilon de la máquina al valor del intervalo entre la representación de 1 y el menor número
mayor que 1 (pero distinto de 1). Los valores que disten de 1 la mitad de epsilon o menos tendrán igual
representación que el 1 y aunque sean matemáticamente distintos, se verán iguales. El intervalo entre
cualquier par de dos números reales consecutivos, excepto el cero, es aproximadamente igual al número
real por el épsilon de la máquina.
Los errores de redondeo son causantes de errores de cálculo. Una cantidad significativa de errores de
redondeo aparece de manera particular cuando se suma un número pequeño a uno grande o cuando se
restan números de valores similares.
Los efectos de los errores de redondeo se pueden reducir mediante el uso de doble precisión,
reescribiendo las ecuaciones y agrupando los valores según convenga (por ejemplo, en una suma, ir
sumando los valores pequeños antes para ir generando valores más grandes, producto en lugar de
sumas sucesivas, etc.).
Teniendo en cuenta el problema de redondeo y de representación, en las comparaciones de números
reales utilizaremos un valor pequeño DELTA positivo (fijado por la precisión del problema o el épsilon de
la máquina) haciendo:
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 14
Mayores
R1 < R2 + DELTA R1 <= R2
De esta manera, nos aseguramos que valores provenientes de cálculos diferentes, afectados por
redondeo y truncamiento, respeten más acertadamente la relación de orden.
Ejemplo: nos interesa que los coeficientes de la diagonal principal de una matriz sean distintos de cero.
En este caso en lugar de comparar contra cero, comparamos con el DELTA que fijemos como precisión.
Errores de truncamiento
Existe otro tipo de error, denominado de error de truncamiento, que es característico del procedimiento
numérico que estamos ejecutando. Por ejemplo, para calcular la función seno(x) podemos utilizar una
representación en serie. Evidentemente no podemos sumar la serie completamente, y sólo conviene
utilizar la mínima cantidad de términos que me aseguren determinada precisión. El resto de esa suma es
el error que se está cometiendo en el cálculo de la función.
Existen casos en los cuales el error de redondeo y el de truncamiento se combinan. Veamos el siguiente
ejemplo: Queremos calcular la derivada de f(x) = x2 aproximándola de la forma f´(x) = (f(x+h)-f(x)) / h
Definimos el error absoluto εa como εa = | f´(x) - (f(x+h)-f(x)) / h |
Si calculamos la derivada numéricamente y grafique el error obtenido para diferentes h: a) h = 10–1, 10–
2
, ...,10–20 y b) h = 2–1, 2–2, ...,2–20 ¿Qué parte del error es de truncamiento y cuál es de redondeo?
Estabilidad numérica
La estabilidad numérica es una propiedad de los algoritmos numéricos que describe cómo los errores en
los datos de entrada se propagan a través del algoritmo. En un método estable, los errores debidos a las
aproximaciones se atenúan a medida que la computación procede. En un método inestable, cualquier
error en el procesamiento se magnifica conforme el cálculo procede.
Algunas veces un mismo cálculo puede ser logrado de varias maneras, todas las cuales son
algebraicamente idénticas en términos de números ideales reales o complejos, pero en la práctica
producen resultados diferentes conforme tienen diferentes niveles de estabilidad numérica.
Definición
Dado un algoritmo f(x), con x los datos de entrada y ε el error en los datos de entrada, decimos que el
algoritmo es numéricamente estable para el error relativo si
x+2y=3
2 x + 3.999 y = 5.999
Solución: x = 1 , y = 1
Hemos cambiado [2,4.001,6] por [2,3.999,5.999]. Empleando la norma euclídea supone una
perturbación, en términos relativos, de
a = [2,4.001,6]; b=[2,3.999,5.999];
pi = norm(a-b) / norm(a)
pi = 2.9879e-04
Que causa un error relativo en la respuesta, que pasa de [3,0] a [1,1], de
a = [3,0]; b=[1,1];
pf = norm(a-b) / norm(a)
pf = 0.7454
Se tiene un factor de amplificación de pf / pi = 2.4946e+03
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 16
RESOLUCION DE PROBLEMAS
Un problema es un enunciado del que se conocen ciertos datos y que se trata de averiguar el modo de
obtener un resultado o solución.
Existen métodos sistemáticos y métodos científicos para resolver problemas. Cualquier persona puede
aprender algo de estos métodos e incrementar su capacidad para resolver problemas.
Se pueden considerar cuatro aspectos en la solución de problemas:
1. Formulación de problemas: un problema debe estar formulado en forma correcta, completa y
precisa.
2. Expresión rigurosa de la solución o "algoritmo". Un algoritmo es una enunciación sistemática y
precisa del modo de resolver un problema formulado correctamente. Implica el desarrollo de un
modelo "matemático" que represente el problema. Se debe identificar las variables pertinentes e
importantes del problema y las relaciones existentes entre dichas variables y la solución del
problema.
3. Diferentes formas de expresar algoritmos: mediante gráficos o diagramas de flujo, narraciones,
pseudocódigo.
4. Representación óptima de la información para el procesamiento sistemático o de computadora
Si tenemos un problema y hemos encontrado la manera de resolverlo por medio de una computadora,
es obvio que debemos tener métodos para indicar a la misma cómo llevar a cabo el proceso. Esto es lo
que se denomina "programación de computadoras".
No es lo mismo programar que codificar.
Programar es un proceso mental complejo dividido en varias etapas. Su finalidad es comprender
claramente el problema que se va a simular o resolver mediante la computadora, y entender también con
detalle cuál será el procedimiento mediante el cual la máquina llegará a la solución deseada.
La codificación es una etapa posterior a la programación y consiste en describir en un lenguaje de
programación la solución ya encontrada mediante la programación.
Fases de creación de un programa:
Entender el problema: Esta fase está dada por el enunciado del problema, el cual requiere una
definición clara y precisa. Implica hacer un mapa mental del problema y abarcarlo como un todo.
No hay reglas ni métodos para esta fase, pero si no se comprende bien el problema la solución
puede no ser la correcta. Es importante entender con claridad antes de abocar recursos a su
solución.
Análisis del problema: Una vez que se ha comprendido lo que se desea de la computadora, es
necesario definir:
• Los datos de entrada.
• Cuál es la información que se desea producir (salida)
• Los métodos y fórmulas que se necesitan para procesar los datos.
Implica armar el modelo del problema y abstraerlo en sus distintas estructuras. Este modelo no
puede existir sin que se hayan especificado con claridad todos y cada uno de los componentes
estructurales del sistema.
Programar el modelo de solución propuesto (diseño del algoritmo): Una vez comprendido
el problema se trata de determinar qué pasos o acciones tenemos que realizar para resolverlo.
La razón de este paso es de disponer de un programa que puede ser probado mentalmente para
averiguar si en principio es correcto, y para determinar a qué grado considera todo el análisis
hecho anteriormente.
Un programa está constituido por dos tipos de componentes: estructuras de datos y estructuras
de control. Las estructuras de control son las distintas formas que existen para dirigir el flujo de
acciones que el procesador efectuará sobre los datos que manejan en un programa. Una
filosofía a la hora de diseñar algoritmos es el refinamiento por pasos, y es partir de una idea
general e ir concretando cada vez más esa descripción hasta que tengamos algo concreto para
resolver. Pasamos de lo más complejo a lo más simple.
Si el problema es bastante complicado lo mejor es dividirlo en partes más pequeñas e intentar
resolverlas por separado. Esta metodología de “divide y vencerás” también se conoce con el
nombre de diseño descendente. Al dividir el problema en módulos o partes se comprende más
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 17
fácilmente y también resulta más sencillo mantenerlo. En cuanto a los resultados, se probarán
mucho mejor comprobando si cada módulo da el resultado correcto que si intentamos probar de
un golpe todo el programa ya que si se produce un error sabemos en qué módulo ha sido.
Los métodos usuales para representar un algoritmo son:
- Formas gráficas: diagrama de flujo y diagramas N-S (Nassi-Schneiderman)
- Lenguaje de especificación de algoritmos: pseudocódigo
Codificación: Como un programa en pseudocódigo o mediante diagramas no es ejecutable en
una computadora, se debe traducir a un lenguaje de programación. La codificación es la
operación de escribir la solución del problema (de acuerdo a la lógica del diagrama de flujo o
pseudo código), en una serie de instrucciones detalladas, en un código reconocible por la
computadora, la serie de instrucciones detalladas se le conoce como código fuente, el cual se
escribe en un lenguaje de programación.
Ejecución y ajuste: Los errores humanos dentro de la programación de computadoras son
muchos y aumentan considerablemente con la complejidad del problema. El proceso de
identificar y eliminar errores, para dar paso a una solución sin errores se le llama depuración.
Existen dos tipos de fallas que es posible encontrar en un programa ya codificado: errores de
sintaxis y errores de lógica de programación. Un error de lógica apunta claramente a omisiones
y errores en el modelado que se está tratando de hacer de la realidad, generalmente se debe a
un deficiente análisis o a una programación en pseudocódigo incompleta y apresurada.
Documentación: Es la guía o comunicación escrita en sus variadas formas, ya sea en
enunciados, procedimientos, dibujos o diagramas. A menudo un programa escrito por una
persona, es usado por otra. Por ello la documentación sirve para ayudar a comprender o usar un
programa o para facilitar futuras modificaciones (mantenimiento).
La documentación abarca tres partes:
o Documentación Interna: Son los comentarios o mensaje que se añaden al código
fuente para hacer más claro el entendimiento de un proceso.
o Documentación Externa: Se define en un documento escrito los siguientes puntos:
Descripción del Problema
Nombre del Autor
Algoritmo (diagrama de flujo o pseudocodigo)
Diccionario de Datos
Código Fuente (programa)
o Manual del Usuario: Describe paso a paso la manera cómo funciona el programa, con
el fin de que el usuario obtenga el resultado deseado.
Mantenimiento: Se lleva a cabo después de terminado el programa y se realiza a lo largo de su
vida útil, cuando se detecta que es necesario hacer algún cambio, ajuste o complementación al
programa para que siga trabajando de manera correcta. Para poder realizar este trabajo se
requiere que el programa este correctamente documentado. Hay que ser capaces de hacer
alteraciones no estructurales al sistema con un costo mínimo de análisis y programación.
Cualquiera sea el tamaño de un programa tenemos el compromiso de hacerlos claros y flexibles
para que admitan mejoras o sugerencias posteriores.
Un programa es la suma del algoritmo y las especificaciones necesarias para que éste emita un
resultado. En términos formales:
Programa = estructuras de datos + estructuras de control
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 18
ALGORITMO
La palabra algoritmo se deriva de la traducción al latín de la palabra árabe al-Khowarîzmî, nombre de un
matemático y astrónomo árabe que escribió un tratado sobre la manipulación de números y ecuaciones
en el siglo IX.
Básicamente, un algoritmo es un método para resolver un problema mediante una serie de pasos. Las
características de un buen algoritmo son:
Debe tener un punto particular de inicio.
Debe ser definido, no debe permitir dobles interpretaciones. Si se aplica partiendo de la
misma situación inicial, debe obtenerse siempre el mismo resultado.
Debe ser general, es decir, soportar la mayoría de las variantes que se puedan presentar en
la definición del problema.
Debe ser finito en tamaño y tiempo de ejecución.
Ejemplo: Algoritmo para armar la lista de aprobados y desaprobados de un examen escrito.
Tomar una hoja en blanco y dibujar dos columnas: Una para aprobados y otra para desaprobados.
Traer la pila de examenes corregidos.
Mientras la pila no esté vacia
Tomar el examen de la cima de la pila.
Si el examen está aprobado, anotarlo en la columna de aprobados sino, anotarlo en la columna
de desaprobados.
Colocar el examen en la pila de examenes pasados
Publicar la hoja con las dos columnas que se acaba de completar.
En esta descripción de pasos, podemos distinguir:
o objetos que deben existir para que el algoritmo se pueda realizar, como la pila de exámenes
corregidos y la hoja para anotar.
o Condiciones o enunciados lógicos que pueden ser verdaderos o falsos, como “la pila no esté
vacía”, “el examen está aprobado”
o Secuencias de acciones.
o Alternativas de acción: anoto en aprobados o anoto en desaprobados.
o Repetición de acciones según sea cierta una condición.
Todos los objetos que son necesarios para que el algoritmo se pueda desarrollar conforman el
“ambiente” del algoritmo. Pueden mantenerse constantes en toda la ejecución o pueden ir variando su
valor o estado.
El lenguaje con que se expresan los pasos debe ser claro y entendible por cualquier persona o entidad
que lo deba interpretar.
¿Cómo expresamos un algoritmo?
Se dispone de una notación algorítmica que permite:
o Describir las operaciones puestas en juego (acciones).
o Describir los objetos manipulados por el algoritmo (datos/informaciones).
o Controlar la realización de las acciones, indicando el modo de organización de estas acciones en
el tiempo (mediante las primitivas de composición o de control).
Debe subrayarse que la notación algorítmica no es en ningún caso un lenguaje de programación. Lo
esencial de la notación algorítmica es que las acciones elegidas sean las necesarias y suficientes para
expresar todo algoritmo. En este sentido, autores como E. Dijkstra, C.A.R. Hoare y otros consolidaron a
finales de los años 60 los fundamentos de la Programación Estructurada, mediante la proposición del
uso de un conjunto de construcciones lógicas (secuencia, decisión e iteración) con las que se podría
escribir cualquier programa.
La notación algorítmica puede realizarse mediante diagramas de flujo, diagramas estructurados Nassi-
Schneiderman y lenguaje de especificación de algoritmo o pesudocódigo.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 19
Diagrama de Flujo
Es una herramienta gráfica de descripción de algoritmos. Se caracteriza por utilizar un conjunto de
símbolos gráficos normalizados y expresar de forma clara los posibles caminos de ejecución de las
acciones (secuencia, decisión e iteración).
El principal inconveniente que plantea el diagrama de flujo es que permite realizar cualquier tipo de
construcción algorítmica, independientemente de que ésta sea correcta o no desde el punto de vista de
la programación estructurada.
Diagrama Nassi-Schneiderman
Los diagramas N-S son también un método gráfico para la descripción de algoritmos. El símbolo básico
utilizado es el rectángulo, por lo que también se los conoce como diagramas de cajas.
Presentan una serie de ventajas:
Dada su forma de construcción es imposible representar algoritmos incorrectos desde el punto
de vista de la programación estructurada.
El ámbito de cada estructura está perfectamente definido.
Y también una serie de inconvenientes:
Cada diagrama sólo refleja la estructura de un único módulo.
No pueden modificarse fácilmente. Es necesario construirlos de nuevo, aunque sea para realizar
pequeños cambios.
Pseudocódigo
El pseudocódigo es una notación algorítmica textual caracterizada por:
Permitir la declaración de los datos (constantes y/o variables) manipulados por el algoritmo.
Disponer de un conjunto pequeño y completo de palabras reservadas que permitan expresar: las
acciones elementales, las primitivas de composición de acciones y la definición de acciones con
nombre (funciones y procedimientos).
El pseudocódigo es un lenguaje neutro y completo, es decir, denota independencia respecto a alguna
máquina en particular y tiene poder suficiente para expresar cualquier idea computacional desde la
perspectiva de los procedimientos estructurados.
Cuando se escribe un pseudocódigo, lo que se hace es indicar las acciones que se tienen que realizar
para dar solución a un determinado problema, en español o en inglés estructurado permitiéndonos
escribir de forma natural, como "relatando" los pasos que se tienen que seguir.
Utilizar un pseudocódigo tiene la ventaja de que el programador no se preocupa por los detalles que
exigen los lenguajes de programación, permitiendo una mayor concentración en la lógica de la
resolución del problema.
Existen palabras específicas, denominadas metapalabras que tienen un significado y objetivo específico
dentro del pseudocódigo. Las metapalabras que utilizaremos son las siguientes, su significado y uso se
irá viendo a lo largo del curso:
Abrir Algoritmo Archivo Arreglo
Cadena Carácter Cerrar Constantes o Const
Crear Desde Entero Entonces
Eof Escribir Fin Función
hacer Hasta Ingresar Inicio
Leer Lógico Mientras Mostrar
No Ó Procedimiento Real
Registro Repetir Según Si
Sino Tipos Variables o Var Y
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 20
Algunas definiciones
Ambiente del algoritmo: es el conjunto de todos los recursos para la ejecución de un trabajo.
Acción: es un evento o acontecimiento que modifica el ambiente. Una acción es primitiva o simple si
su enunciado es suficiente para que pueda ejecutarse sin información adicional. Por el contrario, una
acción es no-primitiva o compuesta si para ejecutar su enunciado es necesario descomponerla en
acciones primitivas.
Nos interesarán solamente aquellos acontecimientos que tienen lugar durante un período de tiempo
finito y producen un resultado bien definido y previsible.
El hecho de que una acción dure un tiempo finito significa que es posible hallar un instante de inicio de la
acción (t0) y un instante de finalización de la acción (t1). Para que sea posible reconocer el resultado es
preciso observar en el sistema una serie de atributos o características que cambien su valor en ese
intervalo de tiempo.
Proceso: Conjunto de acontecimientos organizados en el tiempo y concebido como activo. En nuestro
contexto informático, describrir un proceso es interpretar un acontecimiento como un conjunto de
acciones más elementales cuyo efecto acumulativo es el mismo que el producido por el acontecimiento
completo.
Estado (de un sistema para un proceso determinado) en un instante dado t: Conjunto de los valores de
los distintos atributos o características de interés en el instante t del desarrollo del proceso.
El estado en el instante t0 de una acción define los datos de la acción, mientras que el estado en el
instante t1 define los resultados de la acción (o también datos de entrada y datos de salida,
respectivamente). Por otra parte, el hecho de que el resultado de la acción sea previsible significa que si
se conoce el estado del sistema en el instante t0 entonces se puede decir con total precisión cual será el
estado en el instante t1, incluso antes de que la acción en cuestión se produzca.
Condición: es una afirmación lógica sobre el estado del problema que puede ser verdadera o falsa en el
momento de observación.
Constantes y variables
Constante: es un objeto cuyo valor no puede variar. Puede tener un nombre que la identifique o no, si
no lo llevan, se llaman literales. 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 sustituira por
su valor. Por ejemplo, PI es el nombre de la constante 3.14159...
Variable: es un objeto cuyo valor puede variar. Debe tener un nombre que la identifique y debe indicarse
el tipo de dato que guardará. Los atributos de una variable son: nombre o identificador, valor, tipo,
dirección de memoria.
Elección de nombres: Los nombres permiten identificar a los distintos objetos del ambiente. Deben ser
significativos, es decir, deben dar idea de lo que representan. Los nombres no pueden tener espacios,
deben comenzar con alguna letra del alfabeto y puede ser seguida de otras letras, dígitos y el guión
subrayador. Dependiendo del lenguaje de programación, las reglas de nombres pueden ser sensibles a
mayúsculas y minúsculas, es decir, dos nombres que suenan iguales pero uno en mayúsculas y otro en
minúsculas como N y n son identificadores distintos, mientras que otros lenguajes los toman como
iguales. Nosotros adoptaremos la última forma.
Ejemplo:
identificadores válidos no válidos
MiCasa, este_ejemplo, total1 mi casa, 1dia, $
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 21
Inclusión de comentarios: en cualquier parte del algoritmo, se pueden incluir comentarios que sirvan
para clarificar la solución del problema. El comentario es un texto libre encerrado entre secuencias de (*
y *). También podemos utilizar // para indicar el comienzo de un comentario de linea, todo lo que sigue
al // y hasta el final del renglón es un comentario
Ejemplo: (* esto es un comentario *) // y este otro también
Declaración de constantes y variables
Dentro del ambiente del algoritmo, distinguiremos una sección para la declaración de constantes y otra
para la declaración de variables.
La sección de constantes será precedida por la metapalabra Constantes o Const, y a continuación se
declararán las constantes que se utilizarán siguiendo la sintaxis: <identificador> = <valor>
Ejemplo
Const
PI = 3.14159
Tope = 100
Universidad = “U.N.P.S.J.B.”
El tipo de una constante se deduce de su valor. PI es una constante real, Tope es entera y Universidad
es de tipo cadena de caracteres.
La sección de variables será precedida por la metapalabra Variables o Var, y a continuación se
declararán las variables que se utilizarán siguiendo la sintaxis: <identificador> : <tipo>
Ejemplo
Var
Cantidad : entero
Superficie : real
EsEstudioso: lógico
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 22
Operaciones numéricas
Operación Operador Enteros Reales PuntoFijo
Suma + Si Si Si
Resta - Si Si Si
Producto * Si Si Si
División entera div Si No No
División real / No Si Si
Resto de la división entera mod Si No No
Tipo Lógico
Lógico: tipo simple ordinal que se utiliza para representar valores booleanos (verdadero, falso).
Representan el resultado de una comparación entre otros datos (numéricos o alfanuméricos). Alcanza
un bit pero la menor unidad de direccionamiento es el byte por lo que se utiliza un byte.
Ejemplos:
verdadero (soy alumno de la Facultad de Ingeniería)
falso (estoy volando por las nubes)
Operaciones lógicas
Operadores Relacionales: Se utilizan para establecer una relación entre dos valores. Compara estos
valores entre si y esta comparación produce un resultado de certeza o falsedad (verdadero o falso).
Los operadores relacionales comparan valores del mismo tipo (numéricos, carácter, enumerados o
cadenas).
Tienen el mismo nivel de prioridad en su evaluación pero tienen menor prioridad que los aritméticos. >
Mayor que < Menor que
> = Mayor o igual que < = Menor o igual que
< > Diferente = Igual
Ejemplos: Si a vale 1, b vale 2, c vale 3, nomb1 vale “Ana” y nomb2 vale “Amalia”
a+b>c Falso a - b <= c Verdadero
“Juan” <> nomb2 Verdadero nomb1[1] = ‘A’ Verdadero
“Mara” < “Analia” Falso nomb1 < nomb2 Falso
Ejemplos no válidos:
a<b<c porque compara más de dos elementos a la vez
nomb1 < 30 porque compara operandos de distinto tipo
Operadores Lógicos: Estos operadores se utilizan para establecer relaciones entre valores lógicos, los
cuales pueden ser resultado de una expresión relacional.
No Negación Y Conjunción O Disyunción
Tablas de verdad
Ejemplos:
(10 < 20) Y (20 > 30) (10 < 20) O (20 > 30)
V F V F
F V
Prioridad de los Operadores Lógicos
No
Y
O
Prioridad de los Operadores en General: Aunque cada lenguaje de programación establece el orden
de prioridad, nosotros tomaremos el siguiente orden:
1. ()
2. *, /, Div, Mod
3. +, -
4. No
5. Y
6. O
7. >, <, > =, < =, < >, =
Estructuras de control
Las estructuras de control son construcciones lógicas que dirigen el flujo de acciones que efectuará el
procesador sobre los datos que maneja un programa.
Para que un programa funcione de manera que satisfaga plenamente los requisitos para los cuales fue
creado, debe permitir:
o Ejecutar una serie de acciones o instrucciones.
o Poder repetir un conjunto de acciones o instrucciones, según se satisfaga o no una
condición.
o El empleo de acciones alternativas para poder elegir entre una acción o un grupo de
acciones cuando la situación así lo requiera.
Para poder dar cabida a estos requisitos, existen estructuras de control perfectamente definidas:
o Secuenciación: ejecutar las acciones indicadas, una después de otra.
o Selección: Evaluar cierta condición lógica, si el resultado es verdadero ejecutar la acción 1,
en otro caso ejecutar la acción 2.
o Iteración condicional: Evaluar cierta condición lógica, cuando el resultado es verdadero,
ejecutar una acción y continuar así mientras la condición siga siendo verdadera.
En este sentido, en mayo de 1966, Böhm y Jacopini demostraron que un programa puede ser escrito
utilizando solamente estos tres tipos de estructuras de control.
Secuencia
Cuando se deben ejecutar sucesivamente distintas acciones, se escribirá la lista de dichas acciones en
el orden en el que deban ser ejecutadas.
Pseudocódigo Diagrama de flujo Diagrama N-S
E1 E1
E1
E2
E2 E2
E3
E3
E3
Selección
Construcción que evalúa una expresión, y en función de los valores de ésta, dirige el flujo del proceso.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 27
Iteración condicional
Construcción que indica la repetición de un grupo de enunciados de acuerdo al valor de determinada
condición.
Pseudocódigo Diagrama de flujo Diagrama N-S
mientras C hacer Mientras C
E1 F
C
fin mientras V E1
E1
Selección dicotómica o composición alternativa: sentencia que evalúa una condición, y en función de
ella realiza una u otra acción: si es la condición es verdadera, se realiza accionV y si es falsa la accionF.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 28
Sintaxis:
Si (<condición>) entonces V Cond F
<accionV>
sino
<accionF> accionV accionF
fin si
Ejemplo:
Si ( a < b) entonces Diagrama de flujo
Dif <- b – a ¿C?
Sino Si No
Dif <- a – b Diagrama NS
Fin si AccionV AccionF
Selección múltiple o composición selectiva: enunciado formado por una expresión discreta (entera,
carácter, enumerado), cuyo valor pertenece a un conjunto de opciones, y según el cual se ejecuta uno
sólo de los enunciados alternativos.
Sintaxis:
Según <expr> hacer
<valor1> : <accion1> expr
<valor2> : <accion2> v1 v2 ... vN otro
... Diagrama de flujo
<valorN> : <accionN>
[sino <accionD>] Accion1 Accion2
Fin según
AccionD
Ejemplo: Accion2
Según mes hacer
1 : mostrar (“enero”) expr
2 : mostrar (“febrero”)
... Valor1 ... ValorN Otro
12 : mostrar (“diciembre”)
sino mostrar(“incorrecto”) Diagrama NS
Acción1 ... acciónN acciónD
Fin según
Esta estructura se introduce para expresar de una forma cómoda las diversas condiciones y su relación
con cada una de las acciones. La ejecución de esta primitiva de control consiste en la ejecución de
aquella acción cuyo valor asociado coincida con el valor observado del indicador que aparece en la
primitiva. Para que esté bien construida esta estructura debe ejecutar una y sólo alternativa de entre
todas las que se enumeran.
Observaciones: Si ( mes = 1) entonces
mostrar (“enero”)
o Se requiere que el indicador tenga, en el Sino
momento de su evaluación, un valor del Si ( mes = 2) entonces
conjunto enumerado en la composición. mostrar (“febrero”)
o Opcionalmente, se puede indicar una acción Sino
por defecto que se realizará en el caso de Si (mes = ...)
que el indicador tome un valor distinto de los entonces
N valores explícitamente enumerados en la ...
composición. sino
Esta estructura de decisión puede ser reemplazada ...
por estructuras de selección dicotómica anidadas. fin si
fin si
Notar que la comparación que se realiza entre la Fin si
expresión (mes) y el valor constante es por igual.
Iteración mientras: La condición es evaluada antes de ejecutar por primera vez la acción y ésta se
ejecuta mientras la condición sea verdadera. Si el valor lógico de la condición es inicialmente falso, la
acción no se ejecutará.
Si la condición es siempre cierta, se produce un ciclo infinito y el algoritmo no finalizaría. Alguna de las
variables que intervienen en la condición debieran ser modificadas durante la ejecución de las acciones
encerradas en el mientras, para dar la posibilidad que alguna vez la condición se haga falsa y el bucle
finalice.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 29
Sintaxis:
Mientras <condición> hacer F Mientras C
<acción> Cond
Fin mientras V
acción
acción
Ejemplo:
Mientras cant > 0 hacer
Cant <- cant -1 Diagrama de flujo Diagrama NS
Fin mientras
Iteración Desde: En este caso, la estructura maneja un contador y tiene como parámetros el valor inicial
con que se parte, el valor final y el incremento a realizar en cada paso. El número de iteraciones a
realizar está dado por las veces que es posible incrementar a la variable que oficia de contador, en el
valor del paso sin que supere el valor final, habiendo partido del valor inicial. Existe la posibilidad de
realizar 0 iteraciones, cuando el valor inicial es mayor que el final y el paso es positivo. Cuando no se
indica paso, el incremento es 1.
Funciona de la siguiente manera:
1. se inicializa la variable con el valor inicial
2. se compara el valor de la variable con el valor final. Si el paso es positivo, la comparación es por
menor o igual, y si es negativo, se compara por mayor o igual.
Si el resultado de la comparación da falso,
3. se finaliza el bucle.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 30
Si da verdadero,
Var <- valInicial
4. se ejecuta las acciones del bucle.
5. se incrementa la variable en el valor del paso.
6. se vuelve al paso 2 F Var <= valFinal
Sintaxis:
V
Desde <var> <- <valor_inicial> hasta <valor_final>
[con paso <valor_paso>] hacer accion
<acción>
fin desde
Var <- var + paso
Ejemplo: Muestra cada caracter del nombre.
Desde i <- 1 hasta long(nombre) hacer
Mostrar (nombre[i])
fin desde
Acción con nombre: La notación algorítmica nos permite incorporar nuevas acciones al repertorio. Para
ello debemos proporcionar:
o Un nuevo nombre para la acción.
o Una especificación de la acción (qué hace).
o El cuerpo de la acción, es decir, el conjunto de acciones más elementales que
constituyen la acción.
De esta forma la notación algorítmica permite agrupar un conjunto de acciones e identificarlas mediante
un nombre, de manera que la aparición de dicho nombre en un algoritmo provoca la ejecución de todas
las acciones contenidas en el cuerpo de la acción con nombre. Este tipo de acciones se estudiará en
detalle cuando veamos Funciones y procedimientos.
Combinación de estructuras de control
Es posible combinar las estructuras de control de secuenciación, selección e iteración condicional,
utilizando para ello la secuenciación, la selección y la iteración condicional.
Esto dio origen al concepto de programación estructurada. Un programa estará bien construido si está
formado por estructuras de control válidas, de acuerdo con la regla recursiva:
Base: la secuenciación, la selección y la iteración condicional son estructuras válidas de control que
pueden ser consideradas como enunciados primitivos.
Regla: las estructuras de control que se pueden formar combinando de manera válida la secuenciación,
selección e iteración condicional también serán válidas.
Ejemplos: Decisiones anidadas Combinación de secuencia, decisión e iteración
Si ( a < b) entonces mientras ( a < b) hacer
Dif <- b – a Si ( a < c) entonces
Sino b <- c – a
Si ( a < c) entonces a <- a – 1
Dif <- c – a Sino
Sino a <- c – b
Dif <- c – b b <- b - 1
Fin si Fin si
Fin si Fin mientras
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 31
Especificación de algoritmos
Especificación de un algoritmo, proceso o acción es la definición precisa su efecto. Una posibilidad para
especificar el significado de un objeto (proceso, algoritmo o acción) sería utilizar el lenguaje natural, pero
las definiciones de este tipo suelen incorporar ambigüedades. Cuando se busca precisión es preferible
utilizar especificaciones formales, para lo cual existen múltiples métodos, uno de ellos es el de la
semántica axiomática.
Hemos visto que la ejecución de una acción (no trivial) supone un cambio en el estado del sistema. Se
puede especificar un proceso describiendo la relación entre el estado inicial y el estado final del mismo.
La semántica axiomática consiste en formalizar esta relación mediante el uso de predicados.
Un predicado es una proposición lógica, es un enunciado cuyo valor es verdadero o es falso.
Precondición: Es el predicado o condición que debe ser cierta antes de ejecutar una acción.
Poscondición: Es el predicado o condición que debe ser cierta después de ejecutar una acción.
En la precondición se expresan las condiciones que deben cumplir los datos de la acción para garantizar
un funcionamiento correcto de la misma, y la poscondición expresa la relación que debe existir entre los
datos y los resultados de la acción.
Informalmente, el significado de que una acción S cumple la especificación dada por la precondición P y
la poscondición Q, es el siguiente: si los datos de la acción S cumplen la precondición P, la acción ha de
calcular unos resultados que cumplan la poscondición Q.
Observación: Si no se cumple la precondición no se puede garantizar nada acerca de los resultados de
la acción. Además, este hecho no influye en la corrección de la acción. Ejemplo: la especificación de una
computadora indica que el equipo funciona correctamente en un rango de temperaturas comprendido
entre 0 ºC y 40 ºC. Si en algún momento el equipo se pone a funcionar fuera de este rango de
temperaturas no se puede garantizar nada sobre si el mismo funciona o no correctamente. Además, bajo
estas circunstancias, si el equipo no funciona correctamente no podremos responsabilizar al fabricante
del mal funcionamiento del mismo.
Un algoritmo S satisface una especificación con precondición P y poscondición Q, denotada {P}S{Q}, si
al ser ejecutado sobre unas variables que cumplen P, el algoritmo acaba, y lo hace de forma que dichas
variables cumplen Q.
Ejemplo 1: La especificación:
lado, sup: real
{ lado = L Λ L > 0} {P}
superficie cuadrado S
{ sup = L2} {Q}
puede interpretarse como que dada una variable lado que tiene un valor L positivo, al realizar el
algoritmo o acción denominado “superficie cuadrado” se obtiene una variable sup que es igual al
cuadrado de L.
Ejemplo 2: Dadas las siguientes especificaciones,
x, y: ENTERO
{x=X Λy=Y} {P}
intercambiar S
{x=Y Λ y=X} {Q}
puede interpretarse como que dada una variable x que tiene un valor X y una variable y con valor Y, al
realizar el algoritmo o acción denominado “intercambiar” la variable x queda con el valor Y y la variable y
queda con el valor X.
Ejemplo 3: La especificación de un algoritmo que determinase si un entero es potencia de 2 podría ser
la siguiente:
x: ENTERO
es_potencia: BOOLEANO
{x=X} {P}
potencia? S
{ x = X Λ es_potencia = ∃ n>= 1 : X = 2n } {Q}
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 32
puede interpretarse como que dada una variable x que tiene un valor X al realizar el algoritmo “potencia“
la variable x queda con el mismo X y la variable es_potencia toma el valor de la existencia o no de un
número n>=1 tal que X=2n. En esta especificación aparece tanto en la precondición como en la
poscondición que x = X con lo que se quiere indicar que el valor de la variable x es el mismo al principio
y al final del proceso.
Observar que en todos los casos que requerimos denotar que una variable tiene un valor, lo hacemos
expresándolo a través de una valor simbólico.
¿Cuál es la diferencia entre la especificación de un algoritmo y un algoritmo? Un algoritmo
describe cómo solucionar un problema, ya que el algoritmo no es más que la expresión (en una notación
algorítmica) de una sucesión de acciones (no ambiguas, predecibles y que se realizan en un tiempo
finito) para resolverlo. Por el contrario, la especificación de un algoritmo (o en general, de una acción)
describe qué hace el algoritmo (o acción). Esta descripción se realiza indicando la relación existente
entre los datos de la acción (o situación inicial previa a la realización de la acción) y los resultados de la
misma (o situación final alcanzada tras la realización de la acción). Es importante resaltar que podemos
utilizar un predicado para describir la situación (inicial y final) de un algoritmo porque podemos ver al
predicado como un conjunto de estados (situación), y viceversa.
subproblemas
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 33
Segundo refinamiento
Finalmente llegamos al algoritmo definitivo:
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 34
Algoritmo Facturacion
Const
Impuesto = 18
Var
unidades: entero
costoUnitario, montoBruto, montoImpuesto, montoPago : puntoFijo(2)
Inicio
// Ingreso de datos válidos
Repetir
Mostrar (“Ingrese unidades y costo unitario”)
ingresar (unidades, costoUnitario)
hasta unidades > 0 y costoUnitario > 0
// Cálculo de montos
montoBruto <- unidades * costoUnitario
montoImpuesto <- montoBruto * Impuesto
montoPago <- montoBruto + montoImpuesto
// Salida de resultados
mostrar montoBruto, montoImpuesto, montoPago
Fin
Otro programa: variante del problema anterior
Se desea un programa que lleve la cuenta la cantidad de compras realizadas y la sumatoria de montos
brutos al final del día, además de calcular e informar para cada compra el monto bruto, el monto del
impuesto y el monto a pagar por la compra de cierta cantidad de unidades de un mismo tipo de producto
cuyo costo por unidad es conocido. La compra esta sujeta a un impuesto del 18%.
Análisis del problema
Datos de entrada
Número de unidades adquiridas: unidades
Costo unitario del producto: costoUnitario MontoBruto
Impuesto: 18%
Unidades MontoImpuesto
Datos de salida
Monto bruto: montoBruto CostoUnitario MontoPago
Monto del impuesto: montoImpuesto MontoBrutoTotal
Monto a pagar: montoPago Impuesto = 18
cantiCompras
Cantidad de compras: cantCompras
MontoTotal: montoBrutoTotal
El número de unidades adquiridas y el costo unitario del producto son dependientes de cada compra
mientras que el porcentaje del impuesto ya tiene valor preestablecido, por lo tanto este último puede
tratarse como una constante que no requiere ser ingresada.
Diseño del algoritmo
Primer diseño descendente
En un primer momento el problema puede descomponerse de manera bastante general en repetir el
proceso de obtener datos de entrada, calcular montos y mostrar resultados de cada compra e ir
contando las compras realizadas y acumulando los montos brutos hasta finalizar el día. Luego de este
proceso repetitivo, nos queda como tarea, mostrar la cantidad y el monto bruto total.
Inicio
Repetir
ingresar unidades y costoUnitario validos
Cálculo de montos y cantidad de compras
mostrar montoBruto, montoImpuesto, montoPago
hasta finalizar el día
mostrar cantidad y montoBrutoTotal
Fin
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 35
Primer refinamiento
Debemos plantearnos cómo interpretaremos que finaliza el día. Una manera podría ser que
preguntemos después de cada compra si se trata de la última y en ese caso, finalizamos la repetición.
Esto requiere que mostremos un mensaje con la pregunta al usuario, tomemos su respuesta y de
acuerdo al valor de ella decidir si continuamos o finalizamos.
Otra manera, podría ser que se ingrese un valor especial de cantidad de unidades que signifique que ya
no hay más compras. Para este caso, debiera existir un valor que no fuera válido para dato de entrada
del problema, como un valor negativo, por ejemplo -1. Podemos informarle al usuario que ingrese la
cantidad de unidades o –1 si ya no hay más compras. Si el valor es –1 no se debe hacer ningún cálculo
y se debe finalizar el proceso.
Para este ejemplo vamos a adoptar un criterio similar al primer caso, le indicaremos después de cada
compra que oprima “F” si quiere finalizar o cualquier tecla para continuar. Luego de un refinamiento
también en el subproblema Cálculo de montos y cantidad llegamos al siguiente diseño:
Inicio
Repetir
// ingreso de datos válidos
Repetir
ingresar unidades y costoUnitario
hasta unidades > 0 y costoUnitario > 0
//Cálculo de montos y cantidad
Calcular montoBruto
Calcular montoImpuesto
Calcular montoPago
Contar compra
Acumular montoBruto
mostrar montoBruto, montoImpuesto, montoPago
mostrar “Oprima F para finalizar o cualquier tecla para terminar”
ingresar (tecla)
hasta tecla = “F”
mostrar cantidad, montoBrutoTotal
Fin
Segundo refinamiento
Contar compra significa sumar 1 a la cantidad hasta el momento, para ello antes tuvo que ser inicializada
en cero. Acumular montoBruto significa sumarle el montoBruto recientemente calculado al
montoBrutoTotal hasta el momento, para ello antes tuvo que inicializarse en cero. Finalmente llegamos
al algoritmo definitivo:
Algoritmo FacturacionDiaria
Const
Impuesto = 18
Var
unidades, cantCompras: entero
costoUnitario, montoBruto, montoImpuesto, montoPago : puntoFijo(2)
tecla: caracter
Inicio
cantCompras <- 0
montoBrutoTotal <- 0
Repetir
// Ingreso de datos válidos con mensajes aclaratorios
Repetir
Mostrar (“Ingrese unidades y costo unitario”)
Ingresar (unidades, costoUnitario)
hasta unidades > 0 y costoUnitario > 0
// Cálculo de montos y unidades
montoBruto <- unidades * costoUnitario
montoImpuesto <- montoBruto * Impuesto / 100
montoPago <- montoBruto + montoImpuesto
cantCompras <- cantCompras + 1
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 36
Si el usuario informa la finalización a través de contestar a una pregunta expresa, por ejemplo
contesta ‘N’ a la pregunta “Desea continuar?”, se realiza un proceso repetitivo de ingresar el dato y
procesarlo, mostrar la pregunta y tomar la respuesta y validarla, hasta que la respuesta signifique No.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 39
Ejemplo: Mostrar la suma de una cierta cantidad de números enteros ingresados por el usuario hasta
que el usuario no desee continuar.
Algoritmo VecesNS
Var
nro, suma: entero
resp: caracter
Inicio
suma<-0
Repetir
Ingresar (nro)
suma <- suma + nro
Repetir
Mostrar (“Desea continuar? S/N”)
Ingresar (resp)
Hasta resp = ‘n’ o resp = ‘N’ o resp = ‘S’ o resp = ‘s’
Hasta resp = ‘n’ o resp = ‘N’
Mostrar ( suma)
Fin
Si se debe cumplir una cierta condición con un valor calculado del problema, el esquema de
solución consiste en una estructura de repetición del tipo repetir-hasta, en la que se ingresa el dato y se
lo procesa.
Ejemplo: Mostrar la suma de una cierta cantidad de números enteros ingresados por el usuario. El
proceso finaliza cuando la suma supera el valor 1000.
Algoritmo VecesCond
Const
ValorTope=1000
Var
nro, suma: entero
Inicio
suma<-0
Repetir
Ingresar (nro)
suma <- suma + nro
Hasta suma > ValorTope
Mostrar ( suma)
Fin
que nos permite reutilización y evita la duplicación de código. Además, los subalgoritmos son
independientes entre sí, en el sentido de que se puede escribir y verificar cada módulo en forma
separada sin preocuparse por los demás módulos, simplemente asumiendo que los módulos que utiliza
hacen lo que tienen que hacer en forma correcta. Por ello, es menos complicado localizar un error y
también, cuando se necesita modificarlo por alguna razón (cambiaron las reglas de negocio, se prefiere
una solución más eficiente, etc.), la modificación y el testeo se concentra en ese módulo, sin tener que
variar o rehacer en todos los lugares donde se hubiera repetido ese código.
No existe un criterio fijo para determinar el tamaño, ni muy grandes ni muy pequeños, la idea
fundamental es que realicen una única cosa y muy concreta.
En todo algoritmo o programa existirá un módulo o programa principal que es al que se transfiere el
control cuando comienza la ejecución del programa, y luego desde él, se va llamando al resto de los
subprogramas. Un subprograma puede, a su vez, invocar o llamar a otros subprogramas, inclusive
puede llamarse a sí mismo (esto se conoce como recursividad y será visto más adelante). Cuando se
invoca a un subprograma, se transfiere el control al mismo, el cual se comienza a ejecutar desde el
principio, y al finalizar retorna el control al subprograma que lo llamó.
No existen limitaciones en cuanto a las acciones que pueda ejecutar un subalgoritmo, puede realizar las
mismas acciones que el algoritmo principal: aceptar datos, realizar cálculos, devolver resultados. Los
subalgoritmos pueden recibir valores del algoritmo que los invoca, trabajar con ellos y devolver un
resultado al algoritmo invocante.
Los módulos o subprogramas reciben diferentes nombres según el lenguaje de programación y según su
tipo. Se llaman procedimientos y funciones (Pascal, C), subrutinas (Basic, Fortran), secciones (Cobol).
Parámetros de una acción con nombre
Una acción con nombre al igual que cualquier otra acción, en general actuará sobre unos datos y así
habrá que expresarlo, tanto en su definición como en su invocación.
En la definición de una acción, los datos genéricos sobre los que debe actuar la misma se expresarán
mediante la lista de parámetros formales.
En la invocación de una acción, los datos concretos sobre los que actúa la acción se expresarán
mediante la lista de parámetros reales.
Los parámetros reales de una invocación se asocian con los parámetros formales de su definición de
acuerdo a un criterio posicional, es decir, el 1er parámetro formal se corresponde con el 1er parámetro
real, el 2º parámetro formal con el 2º real, y así sucesivamente. Este hecho obliga también a que el
número de parámetros coincidan y que el tipo de dato de cada asociación parámetro formal-real también
coincidan.
E
Según la relación de valores entre los parámetros formales y reales, S
se puede hablar de tres tipos de parámetros: Entrada, Salida y Cliente Servidor
E/S
Entrada/Salida.
Parámetros de Entrada. El parámetro real de la invocación SÍ tiene un valor definido, que además es el
valor que tomará inicialmente el correspondiente parámetro formal. Al finalizar la acción NO interesa que
las posibles modificaciones del parámetro formal se reflejen sobre el parámetro real asociado. En este
caso el parámetro deberá definirse como de entrada. Este tipo de parámetro se puede usar para aportar
un dato ya definido a un subalgoritmo para que éste lo utilice. Por ejemplo el tipo de parámetro de la
operación primitiva mostrar es de entrada.
Parámetros de Salida. El parámetro real de la invocación NO tiene un valor definido. Al finalizar la
acción SÍ interesa que las posibles modificaciones del parámetro formal se reflejen sobre el parámetro
real asociado. En este caso el parámetro deberá definirse como de salida. Este tipo de parámetro se
puede usar para que un subalgoritmo devuelva un dato definido en su interior. Por ejemplo el tipo de
parámetro de la operación primitiva ingresar es de salida.
Parámetros de Entrada/Salida. El parámetro real de la invocación SÍ tiene un valor definido, que
además es el valor que tomará inicialmente el correspondiente parámetro formal. Al finalizar la acción SÍ
interesa que las posibles modificaciones del parámetro formal se reflejen sobre el parámetro real
asociado. En este caso el parámetro deberá definirse como de entrada/salida.
Este tipo de parámetro se puede usar para que un subalgoritmo modifique un dato en su interior que ya
tuviera valor previamente.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 41
Podemos ver al subalgoritmo como un módulo que realiza un servicio, es un módulo “servidor”. Los
módulos que lo invocan son módulos “clientes”, son los que solicitan y utilizan el servicio. La clasificación
de los parámetros Entrada, Salida y Entrada/Salida es vista desde el servidor según le llegue
información (entrada), devuelva información (salida) o ambas cosas (entrada-salida). La relación cliente-
servidor puede verse como un contrato de servicio donde el cliente deberá cumplir las precondiciones
para dicho servicio y el servidor deberá garantizar que se cumplan las poscondiciones.
En la lista de parámetros formales se aclarará si es un parámetro de entrada, salida o entrada-salida.
Cada lenguaje de programación tiene su forma de hacerlo, por ejemplo en Pascal se precede con la
palabra clave VAR a aquellos parámetros que pueden ser de salida o entrada-salida. En el lenguaje Ada
se utilizan las palabras in, out e in-out para ese fin. Nosotros utilizaremos E, S o E/S precediendo al
parámetro formal o flechas entrantes, salientes o de ambos sentidos para aclarar que es de entrada,
salida o entrada-salida.
Los argumentos reales correspondientes a parámetros de entrada, deben ser valores constantes o
variables inicializadas (no serán modificadas), los correspondientes a entrada-salida deben ser variables
inicializadas y los de salida deben ser variables sin importar si está inicializada o no.
Tipos de acciones con nombre
Los subalgoritmos, también llamados subrutinas o subprogramas, pueden ser dos tipos: Funciones y
Procedimientos.
Funciones
Por Función se entenderá una acción con nombre similar al concepto de función matemática. La mayoría
de los lenguajes de programación permiten definir nuevas funciones y utilizarlas de forma similar a las
predefinidas. Se define como función a aquella acción con nombre que:
o tenga 1 o más parámetros exclusivamente de entrada,
o tenga 1 solo valor exclusivamente de salida
o y tal que todos los parámetros de entrada sean necesarios y suficientes para determinar el valor
de salida
Un algoritmo de tipo función es un algoritmo auxiliar (subalgoritmo) que encapsula la forma en que se
resuelve el proceso para obtener un resultado, cuyo valor es retornado cuando la función es invocada
desde otro algoritmo. Al igual que en las predefinidas, posee un nombre y debe establecerse la cantidad
y tipo de parámetros que recibe y el tipo de su resultado. El nombre elegido debe ser significativo, indicar
qué hace.
La definición de una función es similar a la de cualquier otro algoritmo: Tiene una cabecera, una
declaración del ambiente y un cuerpo. La sintaxis de la cabecera es:
Función <nombre> ( lista de parámetros formales con sus respectivos tipos ): tipo del resultado.
Por ejemplo, la cabecera de la función predefinida seno(x) sería:
Funcion seno( x: real): real.
Los nombres elegidos para los parámetros formales deberán ser significativos para lo que están
representando dentro de la función. Es la manera de darle un nombre y poder referirse a los argumentos
con que será invocada. Por ejemplo, en y ← seno(PI) , el parámetro formal x se refiere al argumento
actual PI.
En el ambiente se detallan las variables o constantes auxiliares que pudieran necesitarse, y en el
cuerpo, las sentencias necesarias para resolver el problema. Para poder indicar el valor que asume la
función cuando retorna, algunos lenguajes de programación como C y java, utilizan la sentencia return
(valor del resultado) y otros como Pascal, la asignación del valor del resultado sobre el nombre de la
función: <nombre> ← valor del resultado. En este caso, el nombre de la función actúa como una variable
en el lado izquierdo de la asignación. Nosotros utilizaremos esta última forma.
La función debe devolver un valor sea cual sea el camino de ejecución seguido. No se permiten
funciones que no devuelvan nada. Cuando se utiliza la acción Return supone la finalización de la
ejecución de la función al alcanzar dicha sentencia, devolviendo el resultado de evaluar la expresión que
acompaña al return, mientras que cuando se utiliza la asignación, como utilizaremos nosotros, la función
finaliza cuando se llega al final.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 42
La declaración de una función es equivalente a la definición de una operación: los operandos son los
parámetros de entrada y el resultado es el valor devuelto por la función. Por lo tanto una invocación a
una función es una expresión válida, y puede formar parte de expresiones más complejas. La llamada a
una función, siempre va a formar parte de una expresión, de cualquier expresión en la que en el
punto en la que se llama a la función, pudiera ir colocado cualquier valor del tipo de datos que devuelve
la función, esto se debe a que el valor que devuelve una función está asociado a su nombre.
Qué sucede cuando se invoca a una función?
1. Al hacer la llamada y ceder el control a la función, se asocia (asigna el valor) de cada parámetro
real a cada parámetro formal asociado, siempre por orden de aparición y de izquierda a derecha,
por lo que siempre que no coincidan los tipos y el número de parámetros formales y reales, se
produce un error.
2. Si todo ha ido bien, se ejecutan las acciones de la función hasta que finalice o lleguemos a una
de tipo retorno <valor> que pondrá fin a la ejecución (si el mecanismo es por sentencia retorno)
3. Se le asocia al nombre de la función el valor retornado y se devuelve el control al subprograma
que hizo la llamada pero sustituyendo el nombre de la función por el valor devuelto.
Ejemplos de definición y uso de función
Problema 1: Se desea diseñar una función para resolver la potencia entera de un número real.
De la lectura del problema encontramos los siguientes datos de entrada y datos de salida:
Datos de entrada base
Número real del cual se quiere conocer su potencia: base exponente
Número entero que representa la potencia a la que se potencia
quiere elevar la base: exponente
Cliente Potencia
Datos de salida
Resultado de la operación: potencia
La base y el exponente deberán ser comunicados desde el algoritmo que invoca mediante parámetros
de entrada y el resultado de la operación será el valor que deberá tomar la función. Debemos elegir un
nombre significativo para esta operación, y la llamaremos potencia.
La manera de resolver una potencia, es multiplicando la base por sí misma tantas veces como indica el
exponente. Por lo tanto utilizaremos una estructura de repetición y la más adecuada a este caso es el
Desde. Si el exponente es negativo, se realiza el procedimiento como si fuera positivo y luego se invierte
el resultado.
La función queda definida como:
Funcion potencia (E base: real,E exponente: entero): real
(* calcula la potencia entera base exponente
precondición : base = B y exponente = E poscondición: potencia = BE *)
Var
resultado: real
i: entero
Inicio
resultado <- 1
Desde i <- 1 hasta abs(exponente) hacer
resultado <- resultado * base
Fin Desde
Valor final que
Si (exponente < 0 ) entonces asume la función
potencia <- 1 / resultado
Sino
potencia <- resultado
Fin Si
Fin Funcion
Un algoritmo que la utiliza podría tener una sentencia como alguna de las siguientes:
Mostrar (potencia(3,2))
volCubo <- potencia(lado,3)
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 43
En la primera se muestra el cuadrado de tres, base se asocia con el valor 3 y exponente con el valor 2.
En la segunda, si lado es una variable real ya inicializada, base se asocia con el valor de lado y
exponente con el valor 3.
Problema 2: Se desea resolver el subproblema de obtener el factorial de un número.
De la lectura del problema encontramos los siguientes datos de entrada y datos de salida:
Datos de entrada nro
Número del cual se quiere conocer el factorial: nro
Datos de salida factorial
Resultado de la operación: factorial Cliente Factorial
Sabemos que el factorial no está definido para números negativos, por lo que impondremos como
precondición que nro sea mayor o igual que cero. El factorial de cero es uno y el factorial de un número
n es el producto de los primeros n números naturales, para ello requerimos de un acumulador de
producto. La generación y el producto de los n número naturales se puede realizar con una estructura
de repetición Desde
La función queda definida como:
Funcion factorial (E nro: entero): entero (* calcula el factorial de nro
precondición : nro = N y N >= 0 poscondición: factorial = N! *)
Var
resultado: entero
i: entero
Inicio
resultado <- 1
Desde i <- 1 hasta nro hacer
resultado <- resultado * i
Fin Desde
factorial <- resultado
Fin Funcion
Observemos que si el cliente de esta función no respetara la precondición, la función devolvería como
resultado el valor 1, el cual es incorrecto. La garantía de que funcione correctamente es que se cumpla
con la precondición.
Ejemplo de utilización de esta función en otro algoritmo:
Algoritmo UsaFactorial
Var
nro: entero
Inicio
Repetir
Mostrar (“ingrese nro para calcular factorial y 0 para finalizar”)
Ingresar (nro)
Si (nro > 0) entonces
Mostrar ( nro, “! = ”, factorial(nro))
Sino
Mostrar( “ingrese nuevamente, el nro no debe ser negativo”)
Fin Si
Hasta nro = 0
Fin
“Mes incorrecto” cuando mes no cumple esa condición, en este último caso, no habría precondición
para el valor del mes.
La función queda definida como:
Funcion nombreMes (E mes: entero): cadena
(* devuelve el nombre del mes
precondición : mes = M y M >= 1 y M <=12
poscondición: nombreMes ∈{enero, febrero,...,diciembre} *)
Inicio
nombreMes <- “”
Segun mes hacer
1: nombreMes <- “enero”
2: nombreMes <- “febrero”
3: nombreMes <- “marzo”
4: nombreMes <- “abril”
5: nombreMes <- “mayo”
6: nombreMes <- “junio”
7: nombreMes <- “julio”
8: nombreMes <- “agosto”
9: nombreMes <- “setiembre”
10: nombreMes <- “octubre”
11: nombreMes <- “noviembre”
12: nombreMes <- “diciembre”
Fin Segun
Fin Funcion
Recordemos que la función debe devolver un valor sea cual sea el camino de ejecución seguido, por eso
inicializamos a nombreMes al principio y lo redefinimos dentro de la estructura de decisión de acuerdo
con el mes en cuestión. Observemos que si el cliente de esta función no respetara la precondición, la
función devolvería como resultado el valor “”, el cual no representa un mes. La garantía de que funcione
correctamente es que se cumpla con la precondición. Una alternativa es la siguiente:
Funcion nombreMes (E mes: entero): cadena
(* devuelve el nombre del mes
precondición : mes = M
poscondición: (nombreMes ∈{enero,...,diciembre} y mes>=1 y mes<=12) o nombreMes
= “mes incorrecto” *)
Inicio
Segun mes hacer
1: nombreMes <- “enero”
2: nombreMes <- “febrero”
3: nombreMes <- “marzo”
4: nombreMes <- “abril”
5: nombreMes <- “mayo”
6: nombreMes <- “junio”
7: nombreMes <- “julio”
8: nombreMes <- “agosto”
9: nombreMes <- “setiembre”
10: nombreMes <- “octubre”
11: nombreMes <- “noviembre”
12: nombreMes <- “diciembre”
Sino nombreMes = “mes incorrecto”
Fin Segun
Fin Funcion
Problema 4: Se desea resolver el subproblema de obtener un valor entero que se solicita que ingrese el
usuario y que cumpla con la condición de pertenecer a un rango determinado.
Msg
Datos de entrada
tope1
Rango de validación: tope1 y tope2
tope2
Mensaje para el usuario: msg
enteroEnRango
Datos de salida
Resultado de la operación: enteroEnRango Cliente enteroEnRango
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 45
Var
i: entero
Inicio
Desde i<-1 hasta long(texto) hacer
Si texto[i] = car1 entonces
Texto[i] <- car2
Fin Si
Fin Desde
Fin Proc
Ejemplo de utilización:
Observar que
Algoritmo UsaAveriguaCantyPos
(* Recibir un texto y mostrar la cantidad Los parámetros reales, texto y car, que se
de espacios en blanco y la posición del corresponden con parámetros formales de
último espacio *) entrada, están inicializados (texto, por efecto de
la operación ingresar y car por ser una
Cons
constante).
car= ‘ ’
los parámetros reales cantidad y posición
Var
correspondientes con parámetros formales de
texto: cadena salida son variables sin inicializar en el momento
cantidad, posicion:entero de la invocación y quedan inicializadas por el
Inicio procedimiento, luego se utilizan sus valores.
Mostrar (“ingrese texto”)
Ingresar (texto)
averiguaCantyPos (texto, car, cantidad, posicion)
si (cantidad > 0) entonces
Mostrar (“hay ”, cantidad, “espacios y el último está en ”, posicion)
Sino
Mostrar(“No hay espacios en blanco”)
Fin si
Fin
Recursión
Una función o procedimiento que se puede llamar a sí mismo se llama recursivo. La recursión es una
herramienta muy potente en algunas aplicaciones, sobre todo de cálculo. Puede ser utilizada como una
alternativa a la repetición o estructura repetitiva.
Un algoritmo recursivo incluye, por definición, instrucciones que consisten en ejecutar el mismo
algoritmo, a las que se denominará “llamadas recursivas”, es decir, llamadas a sí mismo. El uso de
recursión es particularmente idóneo para la solución de aquellos problemas que pueden definirse en
forma natural en términos recursivos. Para que un problema pueda tener solución recursiva es
necesario:
1. El problema debe poder descomponerse en subproblemas del mismo tipo.
2. Debe haber uno o más casos en que la solución es directa o trivial.
3. Cada uno de los subproblemas debe ser de grado menor al que pertenece, y debe converger a
la solución trivial.
La escritura de un procedimiento o función recursiva es similar a sus homónimos no-recursivos; sin
embargo, para evitar que la recursión continúe indefinidamente, es preciso incluir una condición de
terminación. Como primera observación, se hace notar que, en todo algoritmo recursivo ha de haber al
menos una acción alternativa. El texto del algoritmo debe incluir invocaciones del propio algoritmo, por
ser éste recursivo, pero no se ejecutan en todos los casos, pues de lo contrario la recursividad no
terminaría. Se distingue pues en esa alternativa dos tipos de ramas: los casos directos o triviales, que no
provocan llamadas recursivas, y los casos recursivos o generales.
Ejemplos de funciones recursivas:
Factorial: El caso directo es cuando el valor a calcular el 1 si n = 0
factorial es cero. Cada subproblema consiste en calcular factorial(n)
n * factorial(n-1) si n > 0.
el factorial de un número menor, y en un número finito de
invocaciones el subproblema convergerá al caso directo.
Datos de entrada nro
Número del cual se quiere conocer el factorial: nro factorial
Datos de salida
Resultado de la operación: factorial Cliente Factorial
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 49
Efectos laterales
Un efecto lateral es cualquier modificación que un subprograma (sea función o procedimiento), realiza en
elementos situados fuera de él pero sin hacer esas modificaciones a través del paso de parámetros.
Los efectos laterales siempre hay que evitarlos porque no somos conscientes de las modificaciones que
pudieran realizarse y resulta difícil rastrear los errores. Para evitar los efectos laterales, la comunicación
entre subprogramas debiera hacerse sólo a través del paso de parámetro.
Los efectos laterales normalmente se producen por el uso de variables globales o variables locales que
abarcan varios procedimientos (esto solo es posible si hay anidación de subprogramas). Por lo tanto
evitaremos su uso excepto que sea imprescindible.
Ejemplo:
Var A:entero En este ejemplo, A es una variable
Algoritmo EJ global que el algoritmo principal la
Var B:entero inicializa en 2. Luego de llamar al
Inicio procedimiento PP con argumento
B <- 1 B, A sufrió un cambio de estado,
A <- 2 sin embargo, en la lectura del
PP(B) algoritmo principal nada hace
Mostrar (A) suponer que cambiaría. Sucede
Fin que el procedimiento PP la
modifica accediendo globalmente.
Procedimiento PP(E x:entero) Estos efectos laterales deben
Inicio evitarse.
A <- x+2
Fin Proc
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 51
Estructuras de datos
Una estructura de datos es un conjunto de variables (probablemente de distintos tipos) relacionadas
entre sí de diversas formas. Existe la posibilidad de definir y utilizar tipos estructurados, entre los que se
encuentran los arreglos, registros, cadenas, archivos, etc. Todos los tipos estructurados son “moldes”
para variables estructuradas, las cuales pueden contener más de un valor. Los tipos de datos
estructurados pueden ser construidos a partir de tipos simples o de otros tipos estructurados, con lo que
la variedad es enorme.
Pueden clasificarse de acuerdo al tipo de datos que las forman, en homogéneas y heterogéneas. Una
estructura de datos es homogénea si todos sus componentes son del mismo tipo. Una estructura de
datos es heterogénea si sus componentes son de distinto tipo.
Otra clasificación es en función de la cantidad de almacenamiento utilizado por la estructura durante la
ejecución del programa, dividiéndose en estáticas y dinámicas. Una estructura de datos se dice estática
si la cantidad de elementos que contiene es fija, es decir, la cantidad de memoria no varía durante la
ejecución de un programa. Una estructura de datos se dice dinámica si la cantidad de elementos que
contiene y por ende, la cantidad de memoria puede variar durante la ejecución de un programa.
Los lenguajes de programación brindan un conjunto de constructores de tipo estructurado, con los
cuales el usuario puede crear o definir tipos para trabajar con estructuras de datos compuestas que
representan los elementos del mundo real. Estos constructores son:
o Arreglo o Array para construir estructuras homogéneas estáticas accesibles por índice.
o Cadena o String para construir estructuras homogéneas estáticas de caracteres
o Registro o Record para construir estructuras heterogéneas estáticas accesibles por nombre de
componente.
o Conjunto o Set para construir estructuras homogéneas estáticas de elementos simples con
operaciones de unión, intersección, diferencia y pertenencia.
o Archivo o File para construir estructuras homogéneas o heterogéneas que crecen
dinámicamente en medio externo.
o Puntero y registros autoreferenciados para construir estructuras dinámicas.
Arreglos
En ocasiones en un programa necesitamos agrupar variables que almacenen datos de un mismo tipo.
Supongamos, por ejemplo, que deseamos registrar la temperatura promedio mensual durante un año en
nuestra ciudad. Si utilizáramos los tipos de datos simples, necesitaríamos declarar 12 variables reales
distintas, una por cada mes, para almacenar dicha información. Sería útil poder contar con alguna
estructura que nos permita agrupar estos datos bajo un mismo nombre, y acceder individualmente a
cada uno de ellos. Esta estructura se puede crear con un constructor de tipo denominado arreglo.
Un arreglo es un conjunto finito y homogéneo de celdas direccionables. Se puede acceder directamente
a cada una mediante su posición, la cual es determinada por el o los índices. En otras palabras, es una
estructura de datos indexada, estática y homogénea.
Los arreglos se clasifican en dos grupos:
o Unidimensionales (llamados también vectores): poseen una única dimensión, es decir, cada
posición es accesible mediante un único índice. En nuestro ejemplo de las temperaturas
promedio, necesitaríamos indicar sólo el mes para obtener la temperatura promedio del mismo.
o Multidimensionales (por ejemplo, las matrices): poseen más de una dimensión, cada elemento
dentro de ellos se direcciona mediante dos o más índices. Las matrices son un caso particular
de los arreglos multidimensionales, pues poseen 2 dimensiones. Ejemplo: se requiere registrar
las temperaturas promedio mensuales de las ciudades capitales de provincias en los últimos 10
años. En este caso se requiere utilizar un arreglo de 3 dimensiones una para el mes, otra para el
año y otra para la ciudad.
Para definir un tipo de arreglo, debemos dar un nombre de tipo y asociarlo con la definición adecuada, la
cual consiste en indicar el o los rangos de índice y el tipo de dato, según la siguiente plantilla:
<nombreTipo> = arreglo [<rango>] de <tipo>
El rango puede ser cualquier subrango de un tipo enumerado. El tipo del elemento debe ser de un tipo
básico o de un tipo previamente definido (simple o estructurado). Algunos lenguajes utilizan la cantidad
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 54
de elementos en lugar del rango, y en ese caso el índice solamente puede ser entero en un valor que va
de 1 a esa cantidad (Lenguaje Basic), o desde 0 al tope –1 (Lenguaje C)
Ejemplos:
Const
Max = 10
Tipo
// definir tLista como arreglo de 10 enteros
tLista= arreglo [1..Max] de enteros
// definir tMatriz como una matriz cuadrada de 10 x 10
tMatriz= arreglo [1..Max, 1..Max] de real
// definir un tipo que sirva para contadores de caracteres mayusculas
(* si utilizamos un indice de tipo carácter nos será más facil
identificar el contador de cada carácter *)
tCont= arreglo[ ‘A’.. ‘Z’] de enteros
Var
Lista: tLista
Matriz: tMatriz
ContadorLetra: tCont
Si las variables ya estuvieran inicializadas, para acceder a un elemento de ellas, debemos acompañar al
nombre de la variable con la indicación del índice o de los índices que representan la posición del dato.
Lista 10 20 25 45 58 12 21 36 98 50
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
Matriz 1.0 2.0 2.5 4.5 5.8 1.2 2.1 3.6 9.8 5.0 [1]
5.0 1.2 2.1 0.4 0.6 0.8 1.0 1.2 1.6 2.0 [2]
7.0 1.5 2.0 1.4 1.5 2.1 3.2 8.5 2.2 1.0 [3]
9.0 1.4 5.0 0.4 0.8 1.2 0.4 1.2 0 1.2 [4]
8.0 1.9 5.4 5.1 2.2 0.2 1.1 1.6 1.4 1.4 [5]
4.5 1.7 2.1 2.2 3.5 2.1 1.6 1.2 1.1 2.1 [6]
5.6 1.0 1.3 1.5 5.1 6.2 2.5 3.2 4.2 2.1 [7]
-1.1 1.0 -2.1 2.0 3.1 3.2 2.3 2.5 2.8 2.9 [8]
2.1 0 0.2 0.5 1.5 1.8 1.6 1.1 2.3 2.0 [9]
0 2.3 2.2 8.1 -9.1 -5.0 2.3 2.4 7.1 2.8 [10]
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
ContadorLetra 10 20 25 10 20 2 4 1 5 2 5 0 12 5 0 0 0 1
[A] [B] [C] [D] [E] [F] [G] [H] [I] [J] ... ... [S] [T] [U] [V] [W] [X] [Y] [Z]
ContadorLetra[‘A’] = 10 y ContadorLetra[‘Z’] = 1
Recorridos en el arreglo
Cuando se desea recorrer un arreglo en forma completa, la mejor manera de hacerlo es utilizando una
estructura de repetición del tipo Desde por cada índice del arreglo.
Si el arreglo es multidimensional, las estructuras de repetición se anidarán y dependiendo del orden de
anidamiento será el orden en que se visitarán las celdas. Si deseamos que Matriz sea recorrida por filas,
el primer Desde se asociará con el primer índice (que indica la fila). Si deseamos que sea recorrida por
columnas el "Desde" más exterior será el que se asociará con el segundo índice.
Por ejemplo, el siguiente fragmento de código mostrará los valores de la primer fila primero, luego los de
la segunda, y así hasta finalizar.
Desde fila <- 1 hasta Max hacer
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 55
En cambio, el siguiente fragmento de código mostrará los valores de la primer columna primero, luego
los de la segunda, y así hasta finalizar.
Desde columna <- 1 hasta Max hacer
Desde fila <-1 hasta Max hacer
Mostrar (Matriz [fila,columna])
Fin Desde
Fin Desde
Accesos aleatorios en el arreglo
Cuando se desea acceder en forma aleatoria a posiciones del arreglo según el pedido del usuario,
debemos solicitar la posición y validar que esté dentro del rango del índice antes de acceder al
elemento. Si se trata de Matriz, debemos pedir el valor para cada índice y validar a cada uno.
Definición del rango del índice
En general el índice será numérico y comenzará desde 1, pero dependiendo del problema puede ser
conveniente utilizar otro rango o tipo de dato para el índice.
Cuando no se sabe cuántos elementos se van a requerir, se debe pensar en definir un arreglo lo
suficientemente grande como para contener la cantidad máxima que pueden presentarse. Luego, en
tiempo de ejecución se utilizará sólo una porción del arreglo si no se presentan todos los datos. Por
ejemplo, deseo almacenar las notas del curso de Algorítmica y Programación, a razón de una por
alumno. Como pretendo que el programa sirva a lo largo de los años y la cantidad de alumnos es
variable año tras año, defino un arreglo con el máximo de alumnos que preveo puedo tener, por ejemplo
200. En un año en particular a lo mejor utilizo 100 y en otro año utilizo 120. En este caso, además del
tope real del arreglo utilizado para su definición, debo llevar una variable con la cantidad real utilizada, la
cual será menor o igual al tope, y servirá de extremo superior en el recorrido del arreglo. Cualquier
acceso a una celda del mismo deberá estar entre 1 y esa cantidad.
Llenado de datos de un arreglo
El criterio para el ingreso de datos lo establece el programador, en función del modelo que esté
programando. En general se preferirá un llenado secuencial, con una estructura de repetición Desde que
pida los datos uno tras otro. Pero si por el tipo de problema se establece como más conveniente un
recorrido aleatorio, debemos poder reconocer qué celdas han sido llenadas y cuáles no, para advertirle
al usuario cuando intenta volver a llenar una celda que tiene datos o para recordarle que hay celdas sin
datos. Para poder reconocer las celdas sin datos cargados, previo al proceso de llenado aleatorio, el
arreglo debe ser inicializado con un valor determinado que sirva de indicador o que sea el valor por
defecto que debe quedar en las celdas sin llenar.
Ejemplo:
Tengo que pasar las notas de los exámenes a un arreglo de notas donde cada índice representa un
alumno en el orden que figura en la lista alfabética. Si los exámenes los tengo ordenados como la lista,
la mejor manera de llenar las notas es con llenado secuencial: el algoritmo impone el índice de la celda
que se va a llenar, utilizando como índice la variable contador de la estructura de repetición Desde. Si
los exámenes no los tengo ordenados, sería más fácil para el usuario llenarlo en forma aleatoria,
eligiendo el propio usuario la celda que va a llenar. En este caso puedo inicializar previamente el arreglo
con –1, que no es un valor de nota posible, y si al finalizar la carga aún quedan celdas con –1 significará
que falta pasar la nota de ese alumno, si en cambio, pretendo pasar la nota del alumno 5 y en la celda 5
hay un valor distinto de –1, significa que ya ingresé su nota, y el programa debiera advertirlo.
Algoritmos básicos con arreglos
Los ejemplos siguientes representan operaciones comunes que se presentan en problemas que
requieren estructuras de datos como arreglos.
Tomaremos como ejemplo al tipo tLista definido anteriormente como un de arreglo de [1.. Max] de
enteros, para arreglos unidimensionales y el tipo tMatriz definido anteriormente como un de arreglo de
[1.. Max,1..Max] de real, para arreglos multidimensionales.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 56
Si bien hay un solo parámetro de salida, esta operación debe realizarse con un procedimiento porque las
funciones sólo pueden devolver datos simples o cadenas. Entonces definiremos un procedimiento
LlenarListaSec con estos parámetros.
Procedimiento LlenarListaSec(S Lista:tLista, E primero, ultimo: entero)
(*Precondición: primero=P y ultimo=F y P<=F y [P,F] ⊆ rango(tLista) *)
(*Poscondición: Lista = {Li} ∀ i ∈ [P,F] *)
Var
i: entero
Inicio
Desde i<-primero hasta ultimo hacer
Mostrar(“Ingresar valor”, i , “:”)
Ingresar (Lista[i])
Fin Desde
Fin Proc
Datos de entrada
Rango: primero y fin del rango de celdas Lista
Arreglo de datos: Lista Cliente MostrarListaAlea
No hay datos de salida, entonces definiremos un procedimiento MostrarListaAlea con estos parámetros.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 57
Si bien hay un solo parámetro de salida, esta operación debe realizarse con un procedimiento porque las
funciones sólo pueden devolver datos simples o cadenas. Entonces definiremos un procedimiento
LlenarMatrizSecF para llenarla por filas y LlenarMatrizSecC para llenarla por columnas.
Por razones de simplicidad, supondremos que el principio de las filas y de las columnas siempre es 1,
por lo que al ser una constante conocida en tiempo de diseño, no requerimos que sea pasada como
parámetro, de no hacer esta suposición, deberemos tener dos parámetros adicionales que informen el
principio del rango de filas y el principio del rango de columnas.
Procedimiento LlenarMatrizSecF(S matriz:tMatriz, E finF, finC: entero)
(*Precondición: finF=F1 y finC=F2 y [1,F1]⊆ rango1(tMatriz) y [1,F2] ⊆
rango2(tMatriz)*)
(*Poscondición: matriz={ Mij } ∀ i ∈ [1,F1] y ∀ j ∈ [1,F2]*)
Var finF, finC
i,j: entero
Inicio matriz
Desde i<-1 hasta finF hacer
Desde j<-1 hasta finC hacer Cliente LlenarMatrizSecF
Mostrar (“Ingrese elemento ”,i, “,”,j, “:”)
Ingresar (matriz[i,j])
Fin Desde
Fin Desde
Fin Proc
Problema 3: Se desea un programa que reciba un texto y muestre la cantidad de veces que se repite
cada carácter en el texto.
El texto será almacenado en una variable de tipo cadena pero para almacenar la cantidad de apariciones
de cada carácter, necesitaremos un contador para cada uno. Por ello, la solución es tener un arreglo de
contadores, uno por cada carácter posible, inicializado en cero. Recorriendo una vez la cadena,
incrementaremos el contador correspondiente y al final sabremos cuánto se repitió cada carácter.
Aquellos contadores que aún están en cero, será porque el carácter que representan no se encontraba
en el texto.
Problema 4: Se desea un programa que permita realizar producto de matrices.
En este problema se requiere contar con un tipo de arreglo bidimensional lo suficientemente grande para
contener cualquier matriz y tres variables de este tipo para almacenar las matrices que se multiplicarán y
a la matriz resultado. Las dimensiones de las matrices serán conocidas en tiempo de ejecución, por lo
tanto se requieren variables adicionales para las mismas. Dado que el producto de matrices requiere que
las dimensiones de las matrices a multiplicar cumplan la condición que la matriz primera tenga tantas
columnas como filas tiene la segunda, deberá verificarse esta situación antes de intentar ingresarlas
para multiplicarlas. En este algoritmo se requerirán al menos tres procedimientos: uno para el ingreso
secuencial el cual será invocado dos veces, una para cada matriz a multiplicar, otro para producir el
producto y otro para mostrar el resultado, además de haber ingresado previamente las dimensiones de
las matrices y verificar que cumplan la condición requerida.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 61
Visual Basic
Características Generales
El lenguaje de programación BASIC (Beginner's All purpose Symbolic Instruction Code ) nació en el año
1964 como una herramienta destinado a principiantes, buscando una forma sencilla de realizar
programas, empleando un lenguaje casi igual al usado en la vida ordinaria ( en inglés), y con
instrucciones muy sencillas y escasas. Teniendo en cuenta el año de su nacimiento, este lenguaje cubría
casi todas las necesidades para la ejecución de programas.
Visual-Basic es una evolución del lenguaje BASIC, conserva su sencillez e incorpora facilidades para el
diseño de aplicaciones en entornos Windows, donde el desarrollo es en una gran parte a partir del
diseño de una interface gráfica.
En una aplicación Visual - Basic, el programa está formado por una parte de código puro, y otras partes
asociadas a los objetos que forman la interface gráfica.
La creación de un programa bajo Visual Basic lleva los siguientes pasos:
Creación de una interface de usuario. Esta interface será la principal vía de comunicación
hombre máquina, tanto para salida de datos como para entrada. Será necesario partir de una
ventana - Formulario - a la que le iremos añadiendo los controles necesarios.
Definición de las propiedades de los controles - Objetos - que hayamos colocado en ese
formulario (botones, cuadros de textos, listas desplegables). Estas propiedades determinarán la
forma estática de los controles, es decir, como son los controles y para qué sirven.
Generación del código asociado a los eventos que ocurran a estos objetos. A la respuesta a
estos eventos (click, doble click, una tecla pulsada, etc.) le llamamos Procedimiento o Función, y
deberá generarse de acuerdo a las necesidades del programa.
Generación del código del programa. Un programa puede hacerse solamente con la
programación de los distintos procedimientos que acompañan a cada objeto. Sin embargo, VB
ofrece la posibilidad de establecer un código de programa separado de estos eventos. Este
código puede introducirse en unos bloques llamados Módulos, en otros bloques llamados
Funciones, y otros llamados Procedimientos. Estos Procedimientos no responden a un evento
acaecido a un objeto, sino que responden a un evento producido durante la ejecución del
programa.
En nuestro curso vamos a trabajar con VisualBasic para aplicaciones Excel, combinando las
características de la planilla de cálculo y el poder de un lenguaje de programación.
Archivos que componen una aplicación VisualBasic
Visual Basic llama a una colección de archivos que componen todo el proyecto de la aplicación. Un
proyecto consiste de:
Un archivo para cada una de los formularios o formas (.FRM)
Un archivo para cada uno de los módulos (.BAS)
Un archivo para cada uno de los controles (.VBX)
Un archivo que describe el contenido de todos los archivos que forman el proyecto (.MAK)
Al ejecutarse VB, la ventana de proyecto muestra el nombre de la forma en blanco Form1, y algunos
controles que son utilizados por default.
Formularios
Los archivos con extensión .FRM contienen toda la información asociada con la forma. Detalles de
controles, sus propiedades y el código asociado a los objetos que están en la forma.
Módulos
Aparte del código asociado a los objetos en la forma y la respuesta de los eventos a ellos, la
programación en VB involucra la escritura de procedimientos generales que son independientes a los
objetos de la forma y que pueden ser llamados desde cualquier lugar usando código. Tales módulos
tienen extensión .BAS. Note que los archivos .BAS pueden no contener declaraciones (de variables,
constantes, etc.).
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 62
Controles Personales
Los archivos con extensión .VBX contienen la información necesaria para incluir un control en la caja de
herramientas (toolbox). Para agregar un control .VBX, se utiliza el menú file, usando el comando Add
File, al agregarlo, el correspondiente icono es automáticamente insertado en la caja de herramientas y
esta lista para ser utilizado por el programador.
Archivo de Proyecto
El archivo de proyecto (.MAK) contiene los nombre de todos los archivos que componen el proyecto
(.FRMs, .VBXs, .BASs) y los detalles de sus rutas de acceso. Este archivo también guarda información
acerca del medio ambiente de VB (environment settings).
Variables y Constantes
Para declarar una variable se utiliza la siguiente sintaxis:
Declare <NombreVar> As <Tipo>
Ejemplo: Declare Apellido As String
En Visual Basic, como en Basic no es obligatorio la declaración de variables, pero esta práctica no es
recomendable ya que si por error en lugar de referirnos a Apellido, escribimos Apellido1, lo tomaría como
una nueva variable. Para hacer que VB nos exija la declaración de variables y evite el problema que trae
el crear automáticamente variables, debemos colocar en el módulo la sentencia:
OPTION EXPLICIT
Obliga a declarar previamente las variables que se vayan a usar. De no haberla declarado antes de
usarla, el programa dará una comunicación de error.
TIPOS DE VARIABLES
Tipo Tamaño Características
en bytes
Boolean 2 Admite los valores 0 y 1, o True (verdadero) y False (falso)
Byte 1 Números enteros, en el rango de 0 a 255
Integer 2 Números enteros en el rango de -32768 a 32767
Long 4 Números enteros en el rango de -2147483648 a 2147483647
Single 4 Punto flotante, simple precisión
Doble 8 Punto flotante, doble precisión.
Currency 8 Entero, con punto decimal fijo(Típico de monedas)
String * Cadenas alfanuméricas de longitud variable o fija
Date 8 Fechas
Object 4 Referencia a objetos
Variant ** Otros tipos de datos
(*) Una variable tipo String ocupa el mismo número de bytes que caracteres tenga la cadena.
(**) Una variable tipo Variant ocupa 16 bytes si se trata de un número y 22 bytes + longitud de la cadena
si se trata de un dato tipo cadena de caracteres.
Existen también variables definidas por el usuario (sentencia Type). En este tipo de variables se pueden
introducir muchos datos de distinto tipo. Los bytes necesarios para almacenar esa variable dependerá de
los datos que se hayan definido.
Dentro de las variables Object (variables que se refieren a objetos) existe una gran variedad, por ejemplo
puede ser del tipo Form - Formulario - , tipo Picture, etc.
Alcance de las variables.
El Alcance de una variable es definido como su rango de operación. Hay tres tipos de alcance en una
variable:
Local - La variable solo puede ser usada en el procedimiento actual (use Dim o Static dentro del
procedimiento requerido).
Módulo - La variables pueden ser accesadas desde cualquier procediminento del módulo actual (use
Dim o Private dentro de la sección de Declaraciones Generales del módulo).
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 63
Después de dar clic varias veces al botón de comando 1 se verá una columna de unos. El valor nunca
será mayor de uno a pesar de que el valor de la variable se incrementa en uno cada vez. Esto es porque
cada vez que el procedimiento es llamado, haciendo clic en el botón, VB esta trabajando con una
variable diferente. Esta tiene exactamente el mismo nombre en el programa pero es una variable
completamente diferente. En el comando 2 utiliza Static en el lugar de Dim. Ahora en vez de que el valor
de la variable se pierda cuando el procedimiento termina, con este cambio (static) su valor permanecerá
hasta que todo el programa termine. De esta manera, podemos ver una lista de números que se
incrementan en uno cada vez que se le da clic al botón de comando.
Nota: La nueva variable estática es una variable de alcance local, si cualquier procedimiento trata de
acceder esta variable no podrá lograrlo.
Arreglos (arrays)
Los arreglos se declaran de la siguiente forma:
Dim nombre_del_arreglo (tamaño) [As Tipo]
Ejemplo:
Dim salarios(199) As Long
En el ejemplo de arriba creamos un arreglo con 200 elementos. El tamaño marcado es de 199 porque
por default VB empieza la numeración con 0.
Si sabemos que el nombre 'Jaime ' es el empleado número 24 y tiene un salario de 25,000 pesos
mensuales, podemos introducir esta cantidad en el arreglo de la siguiente forma:
salarios(23) = 25000
Nota: Para acceder un elemento es necesario colocar el número del elemento anterior (si deseamos el
150, pedimos el 149). Esto es VB empieza un arreglo de 0, no de 1. Sin embargo VB puede ser forzado
a empezar con 1, agregando el estatuto 'Option Base 1' en la sección de declaraciones generales de la
forma o el módulo.
Dynamic Arrays
Podemos crear arreglos tantas veces lo necesitemos, pero en ciertos momentos es necesario cambiar el
tamaño del arreglo en una aplicación. Para hacer esto podemos usar un arreglo ' dinámico '. Primero el
arreglo puede ser declarado en la misma forma, pero sin el número de elementos:
Dim libros() As String
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 64
Para cambiar el tamaño de este arreglo se usa el comando 'ReDim' y se especifica el número de
elementos:
ReDim libros(99)
Normalmente el contenido de un arreglo se pierde cuando se redimensiona, sin embargo para que esto
no suceda se usa:
ReDim Preserve libros(99)
Estructuras de control
Sentencias condicionales.
La sentencia condicional más usada es:
If condición Then
Instrucciones
Else
Otras instrucciones
End If
En este ejemplo, o se cumple una condición y ejecuta unas determinadas instrucciones, o no se cumple,
y ejecuta otras condiciones distintas.
Puede ocurrir que, caso de no cumplirse la condición primera, se abra un abanico de dos o tres
posibilidades. La sentencia condicional tendría entonces la forma:
If condición 1 Then
Instrucciones1
ElseIf Condición 2
Instrucciones2
ElseIf Condición 3
Instrucciones3
Else
Otras instrucciones
End If
Existe otra:
Select Case
Su nombre casi nos define lo que es: Selecciona, dependiendo del caso, un determinado juego de
instrucciones. Ejemplo:
La expresión 'End Select' define el final del bloque de casos. Si deseamos que presente un mensaje si
se introduce un valor no definido en el bloque de casos, deberá usar 'Case Else' de la siguiente manera.
...
Case 7
nombre_del_dia = "Sábado"
Case Else
MsgBox "Error en selección, una semana tiene solamente 7 dias"
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 65
Estructuras de repetición
Los siguientes comandos pueden ser usados para repetir varias veces la ejecución de una sección de
código.
Ciclo Do while (Sintaxis): Ciclo Do while (Ejemplo):
Do While condición hoy = 1
líneas de código Do While hoy = 7
Loop hoy = hoy + 1
Loop
Ciclo Loop While (Sintaxis): Ciclo Loop While (Ejemplo):
Do temp = 0
líneas de código Do
Loop While condición temp = temp + 1
Loop While temp = 100
Ciclo For (Sintaxis): Ciclo For (Ejemplo):
For contador = valor_inicial To For dia_actual = 1 To 365
valor_final [Step incremento] lblDia.Caption = "Dia = "
líneas de código &Str$(dia_actual)
Next [contador] Next dia_actual
Funciones predefinidas
Número
Abs Devuelve el valor absoluto de un número.
Atn Devuelve el arcotangente de un número.
Cos Devuleve el coseno de un ángulo (ángulo en radianes).
Sin Devuelve el seno de un ángulo (ángulo en radianes).
Cadena
InStr Devuelve la posición de la primera ocurrencia de una cadena
dentro de otra cadena de caracteres
LCase, Devuelve una cadena de caracteres en la cuál todas las letras
LCase$ han sido convertidas a minúsculas.
Left, Devuelve los n cacarteres a la izquierda de un cierto
Left$ argumento. (cadena).
Len Devuelve el número de caracteres en una expresión de cadena o
el número de bytes necesarios para almacenar una variable.
LTrim, Devuelve una copia de una cadena eliminando todos los espacios
LTrim$ en blanco.
Mid, Devuelve una cadena qu es parte de una cadena.
Mid$
Right, Devuelve los n caracteres más a la derecha de un argumento
Right$ determinado.
RTrim, Devuelve una copia de la cadena de caracteres con los espacios
RTrim$ de la derecha eliminados.
Space, Devuelve una cadena que consiste de un número especifico de
Space$ espacios.
Trim, Devuelve una copia de una cadena con los espacios de ambos
Trim$ lados eliminados.
UCase, Devuelve una cadena con todas las letras convertidas a
UCase$ mayúsculas.
Hora/Fecha
Date, Devuelve la fecha actual.
Date$
IsDate Devuelve un valor indicando si el argumento puede ser
convertido a Date.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 66
Función InputBox
Muestra un mensaje en un cuadro de diálogo, espera que el usuario escriba un texto o haga clic en un
botón y devuelve un tipo String con el contenido del cuadro de texto.
Sintaxis
InputBox(prompt[, title][, default][, xpos][, ypos][, helpfile, context])
title Opcional. Expresión de cadena que se muestra en la barra de título del cuadro de
diálogo. Si omite title, en la barra de título se coloca el nombre de la aplicación.
default Opcional. Expresión de cadena que se muestra en el cuadro de texto como respuesta
predeterminada cuando no se suministra una cadena. Si omite default, se muestra el
cuadro de texto vacío.
ypos Opcional. Expresión numérica que especifica, en twips, la distancia en sentido vertical
entre el borde superior del cuadro de diálogo y el borde superior de la pantalla. Si se
omite ypos, el cuadro de diálogo se coloca a aproximadamente un tercio de la altura
de la pantalla, desde el borde superior de la misma.
helpfile Opcional. Expresión de cadena que identifica el archivo de Ayuda que se utilizará para
proporcionar ayuda interactiva para el cuadro de diálogo. Si se especifica helpfile,
también deberá especificarse context.
context Opcional. Expresión numérica que es el número de contexto de Ayuda asignado por el
autor al tema de Ayuda correspondiente. Si se especifica context, también deberá
especificarse helpfile.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 67
Función MsgBox
Muestra un mensaje en un cuadro de diálogo, espera a que el usuario haga clic en un botón y devuelve
un tipo Integer correspondiente al botón elegido por el usuario.
Sintaxis
MsgBox(prompt[, buttons][, title][, helpfile, context])
buttons Opcional. Expresión numérica que corresponde a la suma de los valores que
especifican el número y el tipo de los botones que se pretenden mostrar, el estilo de
icono que se va a utilizar, la identidad del botón predeterminado y la modalidad del
cuadro de mensajes. Si se omite este argumento, el valor predeterminado para
buttons es 0.
title Opcional. Expresión de cadena que se muestra en la barra de título del cuadro de
diálogo. Si se omite title, en la barra de título se coloca el nombre de la aplicación.
helpfile Opcional. Expresión de cadena que identifica el archivo de Ayuda que se utiliza para
proporcionar ayuda interactiva en el cuadro de diálogo. Si se especifica helpfile,
también se debe especificar context.
context Opcional. Expresión numérica que es igual al número de contexto de Ayuda asignado
por el autor al tema de Ayuda correspondiente. Si se especifica context, también se
debe especificar helpfile.
VbMsgBoxRtlReading 1048576 Especifica que el texto debe aparecer para ser leído de
derecha a izquierda en sistemas hebreo y árabe.
El primer grupo de valores (0 a 5) describe el número y el tipo de los botones mostrados en el cuadro de
diálogo; el segundo grupo (16, 32, 48, 64) describe el estilo del icono, el tercer grupo (0, 256, 512)
determina el botón predeterminado y el cuarto grupo (0, 4096) determina la modalidad del cuadro de
mensajes. Cuando se suman números para obtener el valor final del argumento buttons, se utiliza
solamente un número de cada grupo.
Nota Estas constantes las especifica Visual Basic. Por tanto, el nombre de las mismas puede utilizarse
en cualquier lugar del código en vez de sus valores reales.
Valores devueltos:
Constante Valor Descripción
vbOK 1 Aceptar
vbCancel 2 Cancelar
vbAbort 3 Anular
vbRetry 4 Reintentar
vbIgnore 5 Ignorar
vbYes 6 Sí
vbNo 7 No
Function Celsius(GradosF)
Celsius = (GradosF - 32) * 5 / 9
End Function
Observación: si no se indica el tipo de parámetro, VB asume Variant. Para indicar que un parametro es
por valor se lo precedo con byVal, para indicar que es por referencia se lo precede por byRef. Se puede
activar una opción que asume el pasaje de una determinada manera, ya sea por valor o por referencia,
por defecto está activado por referencia. En ese caso, sólo debe precederse con el prefijo byVal aquellos
parametros que son pasados por valor.
Un procedimiento Sub es una serie de instrucciones Visual Basic, encerradas entre un par de
instrucciones Sub y End Sub, que realizan acciones específicas pero no devuelven ningún valor.
Un procedimiento Sub puede aceptar argumentos, como constantes, variables o expresiones que le
pasa el procedimiento que ha efectuado la llamada. Si un procedimiento Sub no tiene argumentos, la
instrucción Sub debe incluir un par de paréntesis vacío.
El siguiente es un ejemplo de un procedimiento.
Sub ObtenInformacion()
Dim respuesta As String
respuesta = InputBox("¿Cómo se llama?")
If respuesta = Empty Then
MsgBox "No ha escrito su nombre."
Else
MsgBox "Su nombre es " & respuesta
End If
End Sub
Llamar a procedimientos Sub y Function
Para efectuar una llamada a un procedimiento Sub desde otro procedimiento, escriba el nombre del
procedimiento e incluya valores para todos los argumentos requeridos.
En el siguiente ejemplo, el procedimiento Sub Principal efectúa una llamada al procedimiento Sub
MultiBeep, pasando como argumento el valor 56. Después de que MultiBeep acaba su ejecución, el
control vuelve a Principal y Principal llama al procedimiento Sub Mensaje. Mensaje presenta en pantalla
un cuadro de mensaje; cuando el usuario hace clic en Aceptar, el control vuelve a Principal y Principal
termina.
Sub Principal()
MultiBeep 56
Mensaje
End Sub
Sub MultiBeep(númbips)
For contador = 1 To númbips
Beep
Next contador
End Sub
Sub Mensaje()
MsgBox "¡Es hora de descansar!"
End Sub
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 70
Si no está interesado en el valor que devuelve una función, puede efectuar la llamada a la función de la
misma forma que si llamara a un procedimiento Sub. No utilice los paréntesis, incluya una lista de
argumentos y no asigne la función a una variable, todo ello como muestra el siguiente ejemplo.
MsgBox "¡Tarea concluida!", vbokonly, "Cuadro de tarea"
Una colección es un objeto que contiene varios. En Microsoft Excel, por ejemplo, el objeto Workbooks
contiene todos los objetos Workbook abiertos.
Los elementos de una colección se pueden identificar mediante su número o su nombre. Por ejemplo, en
el siguiente procedimiento, Libro(1) identifica al primer objeto Workbook abierto.
Sub CierraPrimero()
Libro(1).Close
End Sub
También es posible operar al mismo tiempo sobre toda una colección de objetos siempre que los objetos
compartan métodos comunes. Por ejemplo, el siguiente procedimiento cierra todos los libros abiertos.
Sub CierraTodos()
Libros.Close
End Sub
Método es toda acción que puede realizar un objeto. Por ejemplo, Close es un método del objeto
Workbook ya que sirve para cerrar el libro.
Propiedad es un atributo de un objeto que define una de las características del objeto, tal como su
tamaño, color o localización en la pantalla, o un aspecto de su comportamiento, por ejemplo si está
visible o activado. Para cambiar las características de un objeto, se cambia el valor de sus propiedades.
Para dar valor a una propiedad, hay que colocar un punto detrás de la referencia a un objeto, después el
nombre de la propiedad y finalmente el signo igual (=) y el nuevo valor de la propiedad. Por ejemplo, el
siguiente procedimiento cambia el título de una hoja dando un valor a la propiedad Caption.
Sub CambiaNombre(nuevoTitulo)
hoja.Caption = nuevoTitulo
End Sub
Hay propiedades a las que no se puede dar valor. El tema de ayuda de cada propiedad indica si es
posible leer y dar valores a la propiedad (lectura/escritura), leer sólo el valor de la propiedad (sólo
lectura) o sólo dar valor a la propiedad (sólo escritura).
Evento es toda acción que puede ser reconocida por un objeto, como puede ser el clic del mouse o la
pulsación de una tecla y para la que es posible escribir código como respuesta. Los eventos pueden
ocurrir como resultado de una acción del usuario o del código de un programa, también pueden ser
originados por el sistema.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 71
Propiedad Range
Use Range(arg), donde arg asigna un nombre al rango, para devolver un objeto Range que represente
una sola celda o un rango de celdas. El ejemplo siguiente coloca el valor de la celda A1 en la celda A5.
Worksheets("Sheet1").Range("A5").Value = _
Worksheets("Sheet1").Range("A1").Value
El ejemplo siguiente rellena el rango A1:H8 con números aleatorios estableciendo la fórmula de cada
celda del rango. La propiedad Range, si se emplea sin un calificador de objeto (un objeto colocado a la
izquierda del punto), devuelve un rango de la hoja activa. Si la hoja activa no es una hoja de cálculo,
este método no se llevará a cabo con éxito. Use el método Activate para activar una hoja de cálculo
antes de usar la propiedad Range sin un calificador de objeto explícito.
Worksheets("sheet1").Activate
Range("A1:H8").Formula = "=rand()" 'Range is on the active sheet
Propiedad Cells
Use Cells(fila; columna), donde fila es el índice de fila y columna es el índice de columna, para devolver
una sola celda. El ejemplo siguiente establece en 24 el valor de la celda A1.
Worksheets(1).Cells(1, 1).Value = 24
Aunque también puede usar Range("A1") para devolver la celda A1, en algunas ocasiones la propiedad
Cells puede ser más conveniente, ya que permite usar una variable para la fila o la columna. El ejemplo
siguiente crea encabezados de fila y columna en la Hoja1. Tenga en cuenta que, después de activar la
hoja de cálculo, puede usar la propiedad Cells sin una declaración explícita de hoja (devuelve una celda
de la hoja activa).
Sub SetUpTable()
Worksheets("sheet1").Activate
For theYear = 1 To 5
Cells(1, theYear + 1).Value = 1990 + theYear
Next theYear
For theQuarter = 1 To 4
Cells(theQuarter + 1, 1).Value = "Q" & theQuarter
Next theQuarter
End Sub
Aunque podría usar funciones de cadena de Visual Basic para modificar las referencias de estilo A1, es
mucho más sencillo (y una mejor práctica de programación) usar la notación Cells(1, 1).
Para devolver parte de un rango use expresión.Cells(fila; columna), donde expresión es una expresión
que devuelve un objeto Range y fila y columna son relativas a la esquina superior izquierda del rango. El
ejemplo siguiente establece la fórmula de la celda C5.
Range y Cells
Para devolver un objeto Range use Range(celda1; celda2), donde celda1 y celda2 son objetos Range
que especifican las celdas inicial y final. El ejemplo siguiente establece el estilo de línea de los bordes de
las celdas 1:J10.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 72
With Worksheets(1)
.Range(.Cells(1, 1) _
.Cells(10, 10)).Borders.LineStyle = xlThick
End With
Observe el punto delante de cada propiedad Cells. El punto es necesario si el resultado del enunciado
With precedente se aplica a la propiedad Cells, en cuyo caso, se indica que las celdas están en la hoja
de cálculo uno (sin el punto, la propiedad Cells devolvería las celdas de la hoja activa).
Crear variables de objeto
Se puede crear una variable de objeto de la misma forma que el objeto al que hace referencia. Se
pueden activar o devolver las propiedades del objeto o utilizar cualquiera de sus métodos.
Nota Si utiliza una variable de objeto sin haberla declarado previamente, el tipo de datos predefinido de
la variable de objeto es Variant.
Se puede declarar una variable de objeto con el tipo de datos Object cuando el tipo de objeto específico
no se conoce hasta que se ejecuta el procedimiento. Utilice el tipo de datos Object para crear una
referencia genérica a cualquier objeto.
Si conoce el tipo específico de objeto, debe declarar así la variable de objeto. Por ejemplo, si la
aplicación contiene un tipo de objeto Ejemplo, se puede declarar una variable de objeto para ese objeto
empleando una cualquiera de las dos instrucciones siguientes:
Al declarar objetos específicos es posible comprobar automáticamente los tipos, el código es más rápido
de ejecución y mejora su legibilidad.
Se puede efectuar al mismo tiempo la declaración de la variable de objeto con la asignación de un objeto
a la misma, para ello se utiliza la palabra clave New en la instrucción Set. Por ejemplo:
Al asignar a una variable de objeto el valor Nothing se deshace la relación que pudiera existir entre la
variable de objeto y cualquier objeto específico. Así se evita que, accidentalmente, se pueda cambiar el
objeto al cambiar la variable. Una variable de objeto queda definida siempre como Nothing al cerrar el
objeto asociado, así es posible comprobar si la variable de objeto está asociada a un objeto válido. Por
ejemplo: