Vous êtes sur la page 1sur 73

INTRODUCCIÓN A LA

PROGRAMACIÓN
CÁTEDRA: PROGRAMACIÓN BÁSICA Y MÉTODOS NUMÉRICOS

Profesora: Mg. Zulema Beatriz Rosanigo

Universidad Nacional de la Patagonia San Juan Bosco


Facultad de Ingeniería - Sede Trelew
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 2

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

Descomposición de problema: Funciones y Procedimientos ....................................................................................... 39 


Tipos de acciones con nombre ...............................................................................................................41 
Funciones ........................................................................................................................................................... 41 
Procedimientos ................................................................................................................................................... 45 
Recursión ..................................................................................................................................................................... 48 
Ambito: variables locales y globales ............................................................................................................................ 49 
Procedimientos anidados ........................................................................................................................50 
Efectos laterales......................................................................................................................................50 
Métodos de paso de parámetros ................................................................................................................................. 51 
Estructuras de datos .................................................................................................................................................... 53 
Arreglos ...................................................................................................................................................53 
Recorridos en el arreglo ..................................................................................................................................... 54 
Accesos aleatorios en el arreglo ........................................................................................................................ 55 
Definición del rango del índice ........................................................................................................................... 55 
Llenado de datos de un arreglo .......................................................................................................................... 55 
Algoritmos básicos con arreglos ......................................................................................................................... 55 
Ejemplos de problemas que requiere la utilización de arreglos.......................................................................... 59 
Visual Basic ................................................................................................................................................................. 61 
Características Generales ......................................................................................................................61 
Archivos que componen una aplicación VisualBasic.............................................................................61 
Formularios ........................................................................................................................................................ 61 
Módulos .............................................................................................................................................................. 61 
Controles Personales ......................................................................................................................................... 62 
Archivo de Proyecto ........................................................................................................................................... 62 
Variables y Constantes ...........................................................................................................................62 
TIPOS DE VARIABLES ...................................................................................................................................... 62 
Alcance de las variables. .................................................................................................................................... 62 
Variables Estáticas ............................................................................................................................................. 63 
Arreglos (arrays) ................................................................................................................................................. 63 
Estructuras de control .............................................................................................................................64 
Sentencias condicionales. .................................................................................................................................. 64 
Estructuras de repetición .................................................................................................................................... 65 
Funciones predefinidas ...........................................................................................................................65 
Número............................................................................................................................................................... 65 
Cadena ............................................................................................................................................................... 65 
Hora/Fecha......................................................................................................................................................... 65 
Conversión de variables ..................................................................................................................................... 66 
Función InputBox ............................................................................................................................................... 66 
Función MsgBox ................................................................................................................................................. 67 
Crear Procedimientos y Funciones .........................................................................................................68 
Llamar a procedimientos Sub y Function ...............................................................................................69 
Utilizar paréntesis al efectuar llamadas a procedimientos Function ................................................................... 70 
Comprender objetos, colecciones, propiedades, método y, eventos. ...................................................70 
Algunos objetos de la planilla de cálculo ................................................................................................71 
Objeto Range ..................................................................................................................................................... 71 
Crear variables de objeto ........................................................................................................................72 
Declarar variables de objeto .......................................................................................................................... 72 
Asignar una variable de objeto a un objeto.................................................................................................... 72 
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 4

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..

Entrada Computadora 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 de Unidad de Entrada


Instrucciones Control
Mi

Memoria de Unidad Salida


Datos Aritmética
Md Lógica

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

Sistemas de representación numérica


Desde hace mucho tiempo, el hombre en su vida diaria se expresa, comunica, almacena información, la
manipula, etc. mediante letras y números. Para la representación numérica utiliza el sistema de
representación decimal, en tanto que, dependiendo del idioma, dispone de un alfabeto que representa
estas letras.
Siguiendo el mismo principio, las computadoras tienen su propio sistema de representación. Debido a su
construcción basada fundamentalmente en circuitos electrónicos digitales, utiliza un sistema binario. En
los circuitos electrónicos suele representarse la presencia de tensión (electricidad) en un punto de un
circuito por medio de un 1, en tanto que 0 representa la ausencia de dicha tensión.
Esto obliga a transformar la representación de nuestra información, tanto numérica como alfanumérica, a
una representación binaria para que la máquina sea capaz de procesarlos, se hace necesario que los
métodos de codificación internos tengan su origen en el sistema binario, y con ellos se pueda
representar todo tipo de información y órdenes que sean manejadas por la computadora, incluyendo:
números audio
texto video
gráficos e imágenes instrucciones de programa
En cierto modo, toda la información está digitalizada - dividida en trozos y representada como números.
Cada carácter, incluyendo espacios, dígitos y puntuación se almacena como un número. La misma letra
en mayúsculas y minúsculas corresponde a códigos distintos.
Tanto el sistema decimal como el binario están basados en los mismos principios. En ambos, la
representación de un número se efectúa por medio de cadenas de símbolos, los cuales representan una
determinada cantidad dependiendo de cada símbolo y la posición que ocupa dentro de la cadena con
respecto al denominado punto (o coma) decimal.
Sistemas de numeración
Un sistema de numeración es un conjunto de símbolos y reglas que se utilizan para la representación de
datos numéricos o cantidades. Se caracteriza fundamentalmente por su base, que es el número de
símbolos distintos que utiliza, y además es el coeficiente que determina cuál es el valor de cada símbolo
dependiendo de la posición que ocupe.
Los sistemas de numeración actuales son sistemas posicionales, en los que el valor relativo que
representa cada símbolo o cifra de una determinada cantidad depende de su valor absoluto y de la
posición relativa que ocupa dicha cifra con respecto a la coma decimal.
El sistema decimal
El sistema que ha usado el hombre para contar desde hace bastante tiempo es el denominado sistema
decimal, adoptado por contar con los diez dedos de la mano. Es un sistema posicional que utiliza un
conjunto de diez símbolos cuyo significado o valor depende de su posición relativa al punto (coma)
decimal. Un valor determinado o cantidad, que se denomina número decimal, se puede expresar de la
n
siguiente forma:
N° = ∑ (dígito)
i=− m
i
i
× (base)
donde:
base = 10
i = posición respecto de la coma
m = número de dígitos a la derecha de la coma
n = número de dígitos a la izquierda de la coma menos 1
dígito = cada uno de los que componen el número
Por ejemplo, la interpretación de las representaciones de las cantidades 394 y 2.71 será:
39410 = 3 x 102 + 9 x 101 + 4 x 100
2.7110 = 2 x 100 + 7 x 10-1 + 1 x 10-2

Teorema fundamental de la numeración


Se trata de un teorema que relaciona una cantidad expresada en cualquier sistema de numeración con
la misma cantidad expresada en el sistema decimal. Supongamos una cantidad expresada en un
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 7

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

29 |16 2910 = 1D16 0.42 * 16 = 6.72 0.4210= 0.6B85...16


13 1 0.72 * 16 = 11.52
0.52 * 16 = 8.32
0.32 * 16 = 5.12
0.12 * 16 = ...
29.4210 = 1.6B8516
Conversión hexadecimal-binario y binario-hexadecimal
Para convertir un número hexadecimal a binario se sustituye cada dígito hexadecimal por su
representación binaria con cuatro dígitos según la siguiente tabla. En tanto que la conversión binaria
hexadecimal se realiza un proceso inverso: se agrupan los dígitos binario de a 4 a partir del punto
decimal hacia la izquierda y hacia la derecha, sustituyendo cada cuarteto por su correspondiente dígito
hexadecimal.
Dígito Dígito octal Dígito Binario
Hexadecimal
0 0 0000
1 1 0001
2 2 0010
3 3 0011
4 4 0100
5 5 0101
6 6 0110
7 7 0111
8 10 1000
9 11 1001
A 12 1010
B 13 1011
C 14 1100
D 15 1101
E 16 1110
F 17 1111 Tabla 1
Ejemplo
Convertir 7BA3.BC a binario 7 B A 3 . B C
0111 1011 1010 0011 . 1011 1100
Convertir 1100111111000.1011012 a hexadecimal 0001 1001 1111 1000 . 1011 0110
1 9 F 8 . B 6
Conversión octal-binario y binario-octal
Se procede de manera similar al caso anterior pero cada dígito octal equivale a tres dígitos binarios, y se
toman de a tres dígitos binarios para obtener uno octal. Para ello se utiliza la Tabla 1.
Ejemplo
Convertir el número octal 75643.57 a binario. 7 5 6 4 3 . 5 7
111 101 110 100 011 . 101 111
Convertir 1100101001000.10110112 a octal 001 100 101 001 000 . 101 101 100
1 4 5 1 0 . 5 5 4
Conversión octal-hexadecimal
El mecanismo más rápido para convertir números entre estas dos bases es utilizar como pivot la
base binaria. Esto es convertir de octal a binario y luego pasar a hexadecimal o viceversa.
Conversión de cualquier base a decimal
Para ello se utiliza el teorema fundamental de la numeración y se convierte el número de la base
que se disponga a la decimal.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 10

Representación de números enteros


Las computadoras utilizan cuatro métodos para la representación interna de números enteros (positivos
y negativos); éstos son los siguientes:
o Módulo y signo
o Complemento a 1
o Complemento a 2
o Exceso a 2n-1
Estas representaciones de números utilizan el sistema binario y se considera que tenemos un número
limitado de bits para cada dato numérico. Este número de bits disponibles lo representamos por n.
También se pueden representar mediante estos métodos números reales, como veremos más adelante.
Módulo y signo
En este sistema de representación, el bit que está situado más a la izquierda representa el signo, y su
valor será 0 para el signo + y 1 para el signo -. El resto de bits (n-1) representan el módulo del número.
Suponemos en principio que los números no poseen parte decimal, por lo que la coma se supone
implícita a la derecha.
Por ejemplo, supongamos que disponemos de 8 bits, y queremos representar los números 10 y –10.
0 (+) 0 0 0 1 0 1 0 representa al número 10,
1 (-) 0 0 0 1 0 1 0 representa al número –10.
Se denomina rango de representación en un método determinado al conjunto de número representables
en el mismo. Para módulo y signo el rango de representación es, si se disponen de n bits:
-2n-1 + 1 <= X <= 2n-1 – 1
Para el caso de n = 8 bits, el rango de representación va desde –127 a 127.
La ventaja que presenta este sistema frente a otros es la de poseer rango simétrico (igual cantidad de
números positivos que negativos), mientras que su mayor inconveniente es el de poseer dos
representaciones para el número 0. El cual se representa tanto con un signo positivo (0) como con uno
negativo (1) y el resto de los bits en 0.
Complemento a 1
Este sistema de representación utiliza el bit de más a la izquierda para el signo, correspondiendo el 0
para el signo + y el 1 para el signo -. Para los números positivos, los n-1 bits de la derecha representan
el módulo (igual que en el sistema anterior). El negativo de un número positivo se obtiene
complementando todos sus dígitos (cambiando ceros por uno y viceversa) incluido el signo.
Veamos la representación en complemento a 1 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 0 1 representa al número –10.
Para el complemento a 1 el rango de representación es, si se disponen de n bits:
-2n-1 + 1 <= X <= 2n-1 – 1
Para el caso de n = 8 bits, el rango de representación va desde –127 a 127.
La ventaja que presenta este sistema es la de poseer rango simétrico (igual cantidad de números
positivos que negativos), mientras que su mayor inconveniente es el de poseer dos representaciones
para el número 0. El cual se representa tanto con todos 0 como con todos los bits en uno.
Complemento a 2
Este sistema de representación utiliza el bit de más a la izquierda para el signo, correspondiendo el 0
para el signo + y el 1 para el signo -. Para los números positivos, los n-1 bits de la derecha representan
el módulo (igual que en los dos sistemas anteriores). El negativo de un número positivo se obtiene en
dos pasos:
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 11

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

para doble precisión (64 bits)


63 62 51 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.

Errores de redondeo en una computadora


Al realizar una cantidad de operaciones matemáticas en la computadora a través de un programa,
nos podemos encontrar con distintos tipos de errores. Por ejemplo, la mayoría de las operaciones entre
números reales se realizan a través de la representación de los mismos en 64 bits. Esto introduce el
primer error, denominado error de redondeo. Los errores de redondeo son característicos del hardware.
Para ver qué tan importante puede ser esto, realice el siguiente ejercicio:
El 25 de febrero de 1991, durante la Primer Guerra del Golfo, un misil anti-misil norteamericano Patriot
falló la intercepción de un misil iraquí Scud, que cayó finalmente en una barraca norteamericana
matando a 28 soldados e hiriendo a 100 más. El tiempo en segundos en el sistema del misil era
calculado a partir de multiplicar el tiempo en décimas de segundo que proveía el reloj interno por 1/10.
Este producto se realizaba utilizando representaciones de 24 bits.

1. Pruebe que 1/10 tiene una representación binaria periódica.


2. Obtenga el error producido al estimar 1/10 con un número binario de 24 bits, en sistema decimal.
3. Si el reloj interno estuvo funcionando durante 100 horas, calcule el error acumulado durante ese
tiempo.
4. La velocidad de un misil Scud es de 1500 m/s, calcule por cuántos metros le erró el Patriot al
Scud.

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

Hacer En lugar de: Gráfico


Abs (R1 –R2) <= DELTA R1 = R2 Rango de reales con
igual representación
Abs (R1 –R2) > DELTA R1 <> R2 interna que R2
Menores
R1 > R2 + DELTA R1 > R2
R1 < R2 – DELTA R1 < R2
R1 > R2 – DELTA R1 >= R2 R2-DELTA R2 R2+DELTA

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

y numéricamente estable para el error absoluto si

Decimos que un algoritmo es numéricamente inestable para el error relativo si

y numéricamente inestable para el error absoluto si


Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 15

Problema bien o mal condicionado


El concepto es muy parecido al de la estabilidad numérica de algoritmos. Pero éste es relativo a la
sensibilidad de un problema respecto de sus datos iniciales. Se dice que un problema está mal
condicionado si pequeños cambios en los datos iniciales dan lugar a grandes cambios en las
soluciones. Para cierto tipo de problemas se puede definir un número de condición que, en general,
indicará el factor de crecimiento del error relativo final con respecto al error relativo inicial.
Ejemplo
Consideremos los sistemas
x+2y=3
2 x + 4.001 y = 6
Solución: x = 3 , y = 0

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

Estructura del algoritmo


Cabecera: Debe indicarse el nombre del algoritmo, y la lista de parámetros si los hubiera. Generalmente
se la acompaña de un comentario que sirva de documentación.
Declaración del ambiente: Se detallan los recursos que se utilizarán, indicando si se trata de
declaraciones de constantes, variables, tipos, etc.
Cuerpo: Es el conjunto de acciones que deberán realizarse. Van encerradas entre las metapalabras
Inicio y fin
Algoritmo armarListaAprobadosDesaprobados
Ambiente
Pila_Examenes
Hoja
Inicio
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.
Fin

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

Datos y tipos de datos


Los datos que maneja un programa pertenecen a un tipo determinado. El tipo define:
o el conjunto de valores posibles (rango),
o el conjunto de operaciones posibles (lo que podríamos llamar su álgebra),
o su representación interna.
Podemos clasificarlos en simples y compuestos (o estructurados). Los primeros denotan un solo valor,
los segundos representan un conjunto de valores. Los datos pueden ser variables o constantes.
Simple Ejemplo Estructurado Ejemplo
entero 290, -21 cadena “hola a todos”
real 32.17, -2.002 arreglo {3, 5, 7. 3, 15}
lógico verdadero, falso registro {“ana” , 15 , verdadero}
carácter ‘A’ , ‘5’, ‘+’ archivo
conjunto
Tipos Numéricos
Permiten representar valores escalares de forma numérica, esto incluye a los números enteros y los
reales y realizar operaciones aritméticas comunes.
Entero: tipo simple ordinal que se utiliza para representar valores numéricos enteros, en un rango finito
dado por la implementación.
Representación
Bit de signo Valor numérico
Variantes de enteros: De acuerdo con la cantidad de bytes de la implementación pueden variar en:
Entero corto: Utiliza uno o dos bytes para su implementación.
Entero normal: Utiliza dos o cuatro bytes
Entero largo: Utiliza cuatro o seis bytes.
El rango de valores de cada caso, será -2n-1.. 2 n-1-1, donde n es la cantidad de bits de la representación.
Por ejemplo, un entero corto de un byte, tendrá un rango que va desde –128 a 127.
Ejemplos:
12 (número de mes) 35.000.000 (habitantes de Argentina)
919 (páginas de un libro)
Real: tipo simple que se utiliza para representar valores numéricos del conjunto de números reales.
Pueden ser de simple y doble precisión. Utiliza implementación de punto flotante.
Representación
Bit de signo exponente mantisa
Recordar que existe un rango de valores reales cuya representación es la misma debido al límite finito
de dígitos de la mantisa y que números reales con un número finito de dígitos decimales puede tener
una mantisa con una serie infinita de números binarios, como por ejemplo el valor decimal 0.10 , por lo
que es muy importante tener presente estas cuestiones en el momento de comparar valores.
Ejemplos:
3.14159 (pi)
9.8 (aceleración de la gravedad)
PuntoFijo: Algunos lenguajes brindan un tipo especial de dato para representar montos de dinero. Ya
que la cantidad de decimales de un monto de dinero es fija (generalmente es dos, por los centavos), es
conveniente utilizar un tipo de dato de punto fijo en lugar de punto flotante. En este caso, se debe aclarar
en su definición con cuántos decimales se fija. De no poseer este tipo, magnitudes como el dinero
pueden ser repesentadas en un entero largo en centavos o miliavos, y evitar de esta manera los errores
propios del redondeo y truncamiento de números reales.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 23

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

Funciones Argumento Resultado Ejemplo


Siguiente Entero entero Sig(n)
Anterior Entero Entero Ant(n)
Valor absoluto Entero o real Entero o real Abs(n)
Redondear Real Real Redondear(x)
Truncar Real Entero Trunc(x)
Raiz cuadrada Real Real RC(x)
Valor absoluto Real o entero Real o entero Abs (x)
Trigonométricas Real Real Seno(x)
Coseno(x)
Tg(x)
Logaritmo natural Real Real Ln(x)
Exponencial Real Real Exp(x)

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

Operación Operador Ejemplo


Negación No (not) No esBueno
Conjunción Y (and) Estudia Y esBueno
Disyunción O (or) Estudia O esBueno
Tipo Caracter
Caracter: tipo simple ordinal que se utiliza para representar los distintos caracteres empleados para
formar palabras, expresiones aritmético-lógicas o para graficación. Abarca letras mayúsculas, letras
minúsculas, dígitos y caracteres especiales. Este conjunto de valores se normalizó, por un estándar
llamado ASCII (American Standard Code for Informaion Interchange), el cual permite establcer un orden
de precedencia entre los mismos. Los valores constantes de este tipo se escriben entre apóstrofos o
comillas simples.
Ejemplos:
‘B' (be mayúscula) '∗' (asterisco)
'#' (numeral) '2' (dígito 2)
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 24

Operaciones con caracteres


Funciones Argumento Resultado Ejemplo
Sig(caracter) da el siguiente caracter caracter Sig(‘B’) da la letra ‘C’
carácter de la tabla
Ant(caracter) da el carácter caracter caracter Ant(‘C’) da la ‘B’
anterior en la tabla
Ord(caracter) da el número de caracter entero Ord(‘A’) da 65
orden en la tabla de caracteres
Chr(entero) da el carácter que Entero (0-255) Caracter Chr(65) da ‘A’
se encuentra en un determinado
lugar de la tabla

Tipo cadena de caracteres


Cadena: tipo compuesto por una secuencia de caracteres que es utilizado para expresar palabras. Es
una secuencia de caracteres alfanuméricos que permiten representar valores identificables de forma
descriptiva, esto incluye nombres de personas, direcciones, etc. Es posible representar números como
alfanuméricos, pero estos pierden su propiedad matemática, es decir no es posible hacer operaciones
con ellos. Las constantes de este tipo de datos se representan encerrados entre comillas.
Ejemplos:
“Mi perro” “” (la cadena vacía) “32.324.123”
“No” “S” (cadena unitaria)
Operaciones con cadenas de caracteres

Funciones Argumento Resultado Ejemplo


Longitud(cadena) da la cantidad de Cadena entero Long(“yo” ) es 2
caracteres actual en la cadena
Concatena(cadena1,cadena2) da Dos cadenas cadena concatena(“Hola”, “ a
como resultado una cadena todos”) da como resultado
formada por las recibidas como “Hola a Todos”
argumentos
Subcadena(cadena, pos, n): da la Cadena s, cadena Subcadena(“Hola”,3,2) da
subcadena de n caracteres a partir entero pos, “la”
de la posición pos entero n

Acceso a un elemento de la cadena de caracteres


Para acceder a un elemento de la cadena (un carácter), se tiene el operador [] . Se debe indicar el índice
del carácter al que se quiere acceder, el índice es un valor entero que podrá variar entre 1 y la longitud
de la cadena. Ejemplo: Sea nombre de tipo cadena y nombre contiene el valor “Juan”.
Nombre[1] nos dará la ‘J’ y nombre[4] nos dará la ‘n’
Expresiones
Las expresiones son combinaciones de constantes, variables, símbolos de operación, paréntesis y
nombres de funciones especiales. Por ejemplo:
a + (b + 3) / c
Cada expresión toma un valor que se determina tomando los valores de las variables y constantes
implicadas y la ejecución de las operaciones indicadas.
Una expresión consta de operadores y operandos. Según sea el tipo de datos que manipulan, se
clasifican las expresiones en:
o Aritméticas
o Relacionales
o Lógicas
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 25

Operadores Aritméticos: Los operadores aritméticos permiten la realización de operaciones


matemáticas. Pueden ser utilizados con tipos de datos enteros o reales, constantes o variables. Si
ambos son enteros, el resultado es entero; si alguno de ellos es real, el resultado es real.
+ Suma - Resta
* Multiplicación / División real
div División entera Mod Modulo (residuo de la división entera)
Ejemplos:
Expresión 7.6 / 2 15 mod 4 14 + 2 * 5
Resultado 3.8 3 24
Prioridad de los Operadores Aritméticos
1. Todas las expresiones entre paréntesis se evalúan primero. Las expresiones con paréntesis
anidados se evalúan de dentro a fuera, el paréntesis más interno se evalúa primero.
2. Dentro de una misma expresión los operadores se evalúan en el siguiente orden.
a. *, /, div, mod Multiplicación, división real, división entera, módulo.
b. +, - Suma y resta.
3. Los operadores en una misma expresión con igual nivel de prioridad se evalúan de izquierda a
derecha.
Ejemplos:
14 + 2 * 5 = 24 12.2 / 2 + 5 mod 2 = 7.1
203 * 2 div 5 = 81 46.5 / 5.0 = 9.3
30 + 5 * (10 - (21 + 4)) = -45 13 mod 5 + 5 * (10 - 6) = 23

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

Op1 Op2 Op1 y Op2 Op1 o Op2 No Op1


V V V V
V
V F F V
F V F V
F
F F F F
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 26

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

Pseudocódigo Diagrama de flujo Diagrama N-S


Si C entonces
E1 ¿C?
V C F
Sino Si No
E2
Fin si E1 E2 E1 E2

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

Primitivas de control o composición


Acción elemental: ejecución de un acontecimiento elemental. Considerando que en última instancia es
una computadora la máquina que ejecutará las instrucciones de un programa, las acciones elementales
vendrán determinadas por las tareas que puede realizar una computadora. Básicamente estas tareas
son:
o realizar una serie de operaciones (aritméticas o lógicas) sobre unos operandos.
o posibilidad de obtener dichos operandos a través de un dispositivo de entrada o de la memoria
de la computadora.
o posibilidad de almacenar los resultados de dichas operaciones en memoria o enviarlos hacia un
dispositivo de salida.
Instrucción de Asignación: Operación mediante la cual se da valor a una variable. Utilizaremos el
símbolo <- para indicar que la variable del primer miembro toma el valor de la expresión del segundo
miembro. Algunos lenguajes de programación adoptan el símbolo := y otros el símbolo =.
Sintaxis: <var> <- <expresion> Ejemplo: Cant <- 0
Instrucción de entrada de datos: Operación mediante la cual se lee un dato de la entrada estándar y
se lo asigna a una variable. Hay una asignación implícita. La variable debe ser de un tipo simple o
cadena. No puede ser de tipo enumerado creado por el usuario ni de otro tipo compuesto.
Sintaxis: Ingresar(<var>) Ejemplo: Ingresar(cant)
Instrucción de salida: Operación mediante la cual se muestran datos en la salida estándar. La
expresión debe ser de un tipo simple o cadena. No puede ser de tipo enumerado creado por el usuario.
Sintaxis: Mostrar(<expresión> [,<expresión>]) Ejemplo: Mostrar(“Mes =”, mes)
Selección simple o composición condicional: sentencia que evalúa una condición, y si es cierta,
realiza la acción propuesta. Si la condición es falsa, dicha acción no es realizada.
Sintaxis:
Si (<condición>) entonces ¿C?
<acción> V Si No
Cond
fin si
accion F acción seguir
Ejemplo:
Si ( a < b) entonces
Diagrama de flujo Diagrama NS
Dif <- b – a
Fin si

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

Cuidado con los ciclos infinitos!!!!


Si en el ejemplo precedente, cant partiera de una valor negativo, la condición sería falsa y nunca entraría
al bucle; si parte con valor positivo, la condición será cierta y en cada iteración disminuye su valor por lo
que en un tiempo finito dejará de ser positiva, y el bucle finaliza. Pero si la acción a realizar en lugar de
disminuir el valor, lo aumentara, si cant fue inicialmente positiva, se produciría un ciclo infinito y el
programa nunca terminaría, dando la apariencia que la máquina está “bloqueada”.
Iteración Repetir: La acción se realiza al menos una vez y luego se evalúa la condición, si ésta es falsa,
se vuelve a repetir la acción, sino se prosigue con la sentencia siguiente.
Si la condición es siempre falsa, se produce un ciclo infinito y el algoritmo no finalizaría. Alguna de las
variables que intervienen en la condición deben ser modificadas durante la ejecución de las acciones
encerradas en el repetir, para dar la posibilidad que alguna vez la condición se haga cierta y el bucle
finalice.
Sintaxis:
Repetir Acción
<acción> acción
hasta <condición>
Repetir hasta <cond>
Ejemplo: F
Repetir Cond
Diagrama NS
Ingresar (valor) V Diagrama de flujo
hasta valor > 0 y valor < 100

Cuidado con los ciclos infinitos!!!!


Si en el ejemplo precedente, se ingresa un valor entre los limites 0 y 100, la condición se hace cierta y la
iteración finaliza; si el valor no cumple con la condición, se vuelve a ingresar un nuevo valor y
nuevamente será evaluado y es de esperar que en un tiempo finito se cumplirá la condición y el bucle
finaliza. Pero si la acción a realizar en lugar de ingresar un valor, lo mostrara, si inicialmente este valor
no cumple la condición, se produciría un ciclo infinito y el programa nunca terminaría, dando la
apariencia que la máquina está “bloqueada”.

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.

Metodología de resolución de problemas


Una metodología de resolución de problemas es el diseño TOP DOWN, como medio para desarrollar
simultáneamente algoritmos y estructuras de datos. Ambos comienzan como "cajas negras". Cada caja
negra especifica qué hace pero no cómo lo hace. A medida que el proceso de resolución avanza, las
cajas negras son refinadas gradualmente, hasta que sus acciones no se pueden seguir
descomponiendo. El nivel de descomposición al que se llega depende de los conocimientos de quien va
a implementar la solución (obviamente, el nivel de detalle al que puede arribar un experto no es el mismo
que al que llegaría un novato).
Esta metodología, también conocida como diseño descendente, consiste en establecer una serie de
niveles de mayor a menor complejidad (arriba-abajo) que den solución al problema y en efectuar una
relación entre las etapas de la estructuración, de forma que una etapa jerárquica y su inmediato inferior
se relacionen mediante entradas y salidas de información. Es decir que con esta metodología, resolver el
problema original se reduce a resolver una serie de problemas más simples o subproblemas. En cada
paso del proceso de resolución cada subproblema es refinado, hasta llegar a un punto en el que está
compuesto de acciones tan simples que ya no tiene sentido seguir refinando. Podemos decir que en el
diseño Top Down vamos de lo general a lo particular. Una regla muy importante en este proceso de
resolución de problemas es que ninguna caja negra necesita "saber" cómo otra realiza su tarea, sólo
conoce cuál es la tarea.
La utilización de la técnica de diseño Top-Down tiene los siguientes objetivos básicos:
o Simplificación del problema y de los subprogramas de cada descomposición.
o Las diferentes partes del problema pueden ser programadas de modo independiente e incluso
por diferentes personas. También permite modificar una parte de la solución sin afectar en forma
significativa a las otras partes.
o El programa final queda estructurado en forma de bloque o módulos lo que hace más sencilla su
lectura y mantenimiento.
En contraposición a esta metodología Top Down está la BOTTOM UP. En ésta, vamos de lo particular a
lo general. Es decir que se comienza por lo que serían las ramas terminales del árbol y se van juntando
las componentes hasta que se llega a obtener la solución del problema original.
Gráficamente, podemos verlo como un árbol de la siguiente manera:
problema

Bottom Up Top Down


De los Del problema
subproblemas a los
al problema subproblemas

subproblemas
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 33

Cuando nos enfrentamos a la resolución de un problema, en general encontramos que no es posible


para la mente humana atender todo a la vez. La modularidad es una solución a esto.
Qué ventaja provee la modularización? A medida que la complejidad de un problema crece, las tareas
de resolución también crecen. La modularización es un medio para disminuir la velocidad de crecimiento
de la dificultad.
Un primer programa
Se desea un programa para calcular 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
De la lectura del problema encontramos los siguientes datos de entrada y datos de salida:
Datos de entrada
Número de unidades adquiridas: unidades
Costo unitario del producto: costoUnitario
Impuesto: 18% Unidades MontoBruto
Datos de salida
CostoUnitario MontoImpuesto
Monto bruto: montoBruto
Monto del impuesto: montoImpuesto MontoPago
Impuesto = 18
Monto a pagar: montoPago
Observar que 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 obtener
datos de entrada, calcular montos y mostrar resultados.
Inicio
1. ingresar unidades y costoUnitario válidos
2. Cálculo de montos
3. mostrar montoBruto, montoImpuesto, montoPago
Fin
Primer refinamiento
Como las unidades y el costo unitario no pueden ser valores negativos, debiéramos controlar esto antes
de calcular los montos. Es decir, debemos asegurarnos que los valores ingresados sean positivos, caso
contrario, no tendría sentido el problema. Esto se puede hacer con una estructura de repetición que siga
pidiendo los datos hasta que sean correctos.
Luego de un refinamiento en el subproblema Cálculo de montos llegamos al siguiente diseño:
Inicio
1. Repetir
ingresar unidades y costoUnitario
hasta unidades > 0 y costoUnitario > 0
2. Cálculo de montos
a. Calcular montoBruto
b. Calcular montoImpuesto
c. Calcular montoPago
3. mostrar montoBruto, montoImpuesto, montoPago
Fin

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

montoBrutoTotal <- montoBrutoTotal + montoBruto


// Salida de resultados por compra
Mostrar (montoBruto, montoImpuesto, montoPago)

// Determinar si finaliza el dia o no


Mostrar(“Oprima F para finalizar o cualquier tecla para continuar”)
Ingresar (tecla)
hasta tecla = ‘F’
Mostrar (cantCompras, montoBrutoTotal)
Fin

Variables de uso particular


Contador: es una variable que se utiliza para contar. La variable cantCompras del ejemplo anterior es
un contador. Requiere que se la inicialice en cero y luego se utiliza dentro de una estructura de
repetición de la forma contador <- contador + valor_cte, donde valor_cte es un incremento
o decremento fijo.
Acumulador de suma: es una variable que se utiliza para acumular la suma de valores. La variable
montoBrutoTotal del ejemplo anterior es un acumulador. Requiere que se la inicialice en cero y luego
se utiliza dentro de una estructura de repetición de la forma acumulador <- acumulador + valor,
donde valor es un incremento o decremento variable. Toda vez que encontremos una fórmula en la
que interviene el símbolo de sumatoria, Σ, utilizaremos un acumulador de suma.
Acumulador de producto: es una variable que se utiliza para acumular el producto de valores.
Requiere que se la inicialice en uno y luego se utiliza dentro de una estructura de repetición de la forma
acumulador <- acumulador * valor, donde valor es un factor variable. Toda vez que
encontremos una fórmula en la que interviene el símbolo de productoria, Π, utilizaremos un acumulador
de producto.
Bandera: es una variable que sirve para indicar un estado el cual será consultado para tomar o no una
decisión. Puede ser de tipo lógico si la consulta es por si o no, o enumerado si el estado puede tomar
más de dos valores.

Prueba del algoritmo


La depuración es el proceso por el cual descubrimos las causas de los problemas y los resolvemos. Las
pruebas deben considerar los detalles de diseño así como en los requerimientos generales. Una manera
de probar si el algoritmo funciona o de encontrar errores, es realizando una traza, es decir ejecutando “a
mano”, usando datos representativos y anotando los valores que van tomando los objetos, acción tras
acción. Todo programa debe ejecutarse muchas veces y con diversas entradas con el fin de detectar
posibles errores.
Si probamos con todos los valores posibles que pueden tomar los datos de entrada y funciona
correctamente, podemos asegurar que el algoritmo es correcto. Si al probar la ejecución con un valor, el
algoritmo falla, debemos corregirlo y volver a probar.
Ejemplo probar que el siguiente algoritmo almacena y muestra el menor de dos valores ingresados.
Cuando son iguales almacena uno de ellos.
Algoritmo MuestraMenor
Var
Nro1, nro2, menor : entero
Inicio
1 Mostrar (“Ingrese un par de números”)
2 Ingresar (nro1, nro2)
3 Si nro1 < nro2 entonces
4 menor <- nro1
Sino
5 menor <- nro2
Fin Si
6 Mostrar (menor)
Fin
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 37

Prueba 1: ingresa 10 y 12 Prueba 2: ingresa 10 y 10 Prueba 3: ingresa 25 y 15


Traza Nro1 Nro2 menor Traza Nro1 Nro2 menor Traza Nro1 Nro2 menor
1 - - - 1 - - - 1 - - -
2 10 12 - 2 10 10 - 2 25 15 -
3 10 12 - 3 10 10 - 3 25 15 -
4 10 12 10 5 10 10 10 5 25 15 15
6 10 12 10 6 10 10 10 6 25 15 15

Validación de datos de entrada


Es de suma importancia que los datos de entrada sean válidos para el problema a resolver. Si deben
cumplir algún tipo de condición, esto debe ser controlado antes de ser usado en el cálculo. Es necesario
pedirlos una vez, y si son incorrectos volverlos a pedir. El esquema de validación puede ser realizado de
las siguientes formas:
Mostrar (“ingrese dato válido”) Repetir
Ingresar (dato) Mostrar (“ingrese dato válido”)
Mientras dato no es válido hacer Ingresar (dato)
Mostrar (“dato no válido, reingrese”) Hasta dato es válido
Ingresar dato
Fin Mientras
Las condiciones de validez dependerán de cada problema en cuestión y el mensaje a mostrar deberá
orientar al usuario para que sepa cuales son los valores esperados. Hay que tener en cuenta que a
pesar que se indique con un mensaje que el dato a ingresar debe cumplir ciertas condiciones, puede ser
que se ingrese un dato que no las cumpla, por eso la estructura de repetición se encarga de reingresarlo
hasta que sea correcto.
El primer esquema permite un mensaje especial para cuando es inválido. El segundo esquema no
distingue el primer ingreso (obligatorio) de los que se realizan por no cumplir con la validación.

Cómo finalizar la entrada de un conjunto de datos


El criterio para finalizar el ingreso de datos lo establece el programador, en función del modelo de
solución que esté programando. En general se presentan alguna de las siguientes situaciones:
o Se conoce la cantidad de datos a ingresar en tiempo de diseño del algoritmo.
o Se conoce la cantidad de datos a ingresar en tiempo de ejecución del algoritmo.
o El usuario informa la finalización a través de un valor especial de alguno de los datos de entrada.
o El usuario informa la finalización a través de contestar a una pregunta expresa, por ejemplo
contesta ‘N’ a la pregunta “Desea continuar?”
o Se cumple una cierta condición con un valor calculado del problema.
Si se conoce la cantidad de datos a ingresar en tiempo de diseño del algoritmo, el esquema de
solución a este proceso repetitivo es utilizar una estructura de repetición del tipo Desde 1 hasta la
cantidad de veces (indicada como una constante con nombre).
Ejemplo: Mostrar la suma de cien números enteros ingresados por el usuario
Algoritmo CienVeces
Const
Tope=100
Var
i, nro, suma: entero
Inicio
Suma<-0
Desde i<-1 hasta Tope hacer
Ingresar (nro)
suma <- suma + nro
Fin Desde
Mostrar ( suma)
Fin
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 38

Si se conoce la cantidad de datos a ingresar en tiempo de ejecución del algoritmo, el esquema de


solución a este proceso repetitivo es utilizar una estructura de repetición del tipo Desde 1 hasta la
cantidad de veces (previamente ingresada).
Ejemplo: Mostrar la suma de una cierta cantidad, dada por el usuario, de números enteros ingresados
por el usuario.
Tener en cuenta que el tope de números a ingresar es conocido por el usuario, por lo tanto primero
debemos solicitar este valor y debemos validar que sea positivo.
Algoritmo XVeces
Var
i, nro, suma, tope: entero
Inicio
suma<-0
Repetir
Mostrar (“Ingrese cantidad de números a sumar”)
Ingresar (tope)
Hasta Tope > 0
Desde i<-1 hasta tope hacer
Ingresar (nro)
suma <- suma + nro
Fin Desde
Mostrar (suma)
Fin

Si el usuario informa la finalización a través de un valor especial de alguno de los datos de


entrada, debe existir un valor que no pueda ser utilizado como válido para el cálculo y entonces ser
utilizado como indicación de que ya no hay más datos. Esta solución es aplicable si no se conoce la
cantidad de datos y hay un dato que puede tomar un valor que sirva para indicar la finalización.
Tenemos que tener presente que una variable puede tener valores de un solo tipo, si el dato a ingresar
fuera un número, no podemos esperar que ingrese un carácter para indicar la finalización. Si el número
debiera ser positivo, podríamos elegir un valor negativo como –1 para indicar la finalización. En cambio,
si todos los valores fueran aceptables para el problema en cuestión, no habría forma de aplicar este
esquema.
El esquema de solución consiste en una estructura de repetición en la que se solicita el dato y se lo
valida (puede tomar valores de los casos válidos del problema o el valor adoptado para finalización) Si
no es el caso de finalización, realizar las acciones correspondientes a la solución del problema. La
estructura de repetición finaliza cuando el dato toma el valor elegido para finalización.
Ejemplo: Mostrar la suma de una cierta cantidad de números enteros ingresados por el usuario. Cuando
el usuario ingresa el valor cero, finalizar el proceso y mostrar la suma.
Se puede utilizar una estructura Repetir o una estructura Mientras. Esta última solución resulta más
eficiente que la anterior.
Algoritmo Veces0r Algoritmo Veces0m
Var Var
nro, suma: entero nro, suma: entero
Inicio Inicio
suma<-0 suma<-0
Repetir Ingresar (nro)
Ingresar (nro) Mientras nro <> 0 hacer
Si nro <> 0 entonces suma <- suma + nro
suma <- suma + nro Ingresar (nro)
Fin Si Fin Mientras
Hasta nro = 0 Mostrar ( suma)
Mostrar ( suma) Fin
Fin

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

Descomposición de problema: Funciones y Procedimientos


En general un problema complejo puede ser resuelto de manera más fácil y eficiente si se divide en
problemas más pequeños y concentrándonos en cada etapa en la solución de ese "subproblema". Esto
implica que el gran problema original será resuelto por medio de varios módulos, cada uno de los cuales
se encarga de resolver un subproblema determinado. Esos módulos pueden ser representados por
“acciones con nombres” que están asociadas a un subalgoritmo que tiene la función de resolver un
subproblema.
La notación algorítmica permite agrupar bajo un nombre (identificador de la acción) a un conjunto de
acciones. Este mecanismo permite ampliar el repertorio de acciones disponibles en la notación
algorítmica (hasta ahora, compuesto por acciones elementales (asignación, lectura y escritura) y por
primitivas de composición (secuencia, decisión y repetición)) mediante la definición de una acción con
nombre. La definición de una acción con nombre consiste en expresar convenientemente el subalgoritmo
que desempeña la tarea específica requerida a dicha acción (abstracción procedimental).
Una vez definida una acción con nombre, un algoritmo puede hacer uso de ésta mediante una llamada o
invocación a la misma. La llamada o invocación a una acción con nombre es una acción válida en la
notación algorítmica que se EXPRESA mediante el nombre asociado a la acción, y cuyo SIGNIFICADO
es la ejecución de las acciones encerradas en su definición.
Los subalgoritmos se escriben sólo una vez, luego es posible hacer referencia a ellos, "llamarlos" o
“invocarlos” a través del nombre desde diferentes puntos de un pseudocódigo. La principal ventaja es
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 40

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

Problema 3: Se desea resolver el subproblema de obtener el nombre del mes correspondiente a su


orden numérico.
De la lectura del problema encontramos los siguientes datos de entrada y datos de salida:
Datos de entrada mes
Número de mes: mes
Datos de salida nombreMes
Resultado de la operación: nombreMes
Cliente nombreMes
El número de mes es un número comprendido entre 1 y 12. Una solución es imponer como precondición
que se cumpla esa condición y sólo preocuparnos por los meses correctos. Otra solución, es responder
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 44

“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

La función queda definida como:


Funcion enteroEnRango (E msg: cadena, E tope1,tope2: entero): entero
(* devuelve un valor entero dentro de un rango
precondición : msg = M y tope1=T1 y tope2= T2 y T1 <=T2
poscondición: enteroEnRango ∈ [T1,T2] *)
var
nro: entero
Inicio
Repetir
Mostrar (msg )
Ingresar (nro)
hasta nro >= tope1 y nro <= tope2
enteroEnRango <- nro
Fin Funcion

Problema 5: Se desea resolver el subproblema de conocer si el usuario confirma aceptar un mensaje.


Es decir, se muestra un mensaje al usuario y se le solicita una respuesta por sí o no, devolviendo
verdadero o falso, respectivamente.
msg
Datos de entrada: Mensaje que se solicita confirmación: msg
Datos de salida: Resultado de la operación: confirma confirma
La función queda definida como: Cliente confirma
Funcion confirma (E msg: cadena): logico
(* devuelve un valor logico verdadero si confirma o falso, si no.
precondición : msg = M
poscondición: confirma ∈ {falso,verdadero}
*)
var
resp: caracter
Inicio
Repetir
Mostrar (msg, “S/N” )
Ingresar (resp)
hasta resp = ‘n’ o resp = ‘N’ o resp = ‘S’ o resp = ‘s’
confirma ← resp = ‘s’ o resp = ‘S’
Fin Funcion
Procedimientos
Cualquier otra acción con nombre que no se corresponda con la definición de función se declarará como
un procedimiento. La mayoría de los lenguajes de programación permiten poder definir nuevas acciones
y utilizarlas de forma similar a las predefinidas. Un algoritmo de tipo procedimiento es un algoritmo
auxiliar (subalgoritmo) que encapsula la forma en que se resuelve una operación, proceso o acción. Las
operaciones mostrar e ingresar que hemos estado utilizando son procedimientos predefinidos. Al igual
que en las funciones el nombre elegido debiera ser significativo, indicar qué hace, y debe establecerse la
cantidad y tipo de parámetros que recibe. A diferencia de las funciones, no retornan un valor cuando son
invocados por lo tanto no se establece tipo de su resultado. Los procedimientos representan
sentencias mientras que las funciones representan valores.
La definición de un procedimiento 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:
Procedimiento <nombre> ( lista de parámetros formales con sus respectivos tipos ).
Por ejemplo, la cabecera del procedimiento línea(x1, y1, x2, y2) que dibuja una línea desde el punto de
coordenadas (x1, y1) al punto (x2, y2) sería:
Procedimiento línea(x1, y1, x2, y2: real)
Los nombres elegidos para los parámetros formales deberán ser significativos para lo que están
representando dentro del procedimiento. Es la manera de darle un nombre y poder referirse a los
argumentos con que será invocado. Por ejemplo, en línea(0.5,0.0,1.5,3.1), el parámetro formal x1 se
refiere al argumento actual 0.5, y1 a 0.0, x2 a 1.5 e y2 a 3.1
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 46

En el ambiente se detallan las variables o constantes auxiliares que pudieran necesitarse, y en el


cuerpo, las sentencias necesarias para resolver el problema. No hay sentencia especial ni valor de
retorno, se retorna cuando se llega a su fin.
Los parámetros pueden ser de entrada (sólo se utiliza su valor), entrada-salida (se utiliza su valor y su
dirección para poder modificarlo) o de salida (no interesa su valor inicial, se requiere su dirección para
poder asignarle valor).
Diferencias entre funciones y procedimientos:
1. Una función devuelve un único valor y un procedimiento puede devolver 0, 1 o N.
2. Ninguno de los resultados devueltos por el procedimiento se asocian a su nombre como ocurre
con la función.
3. Mientras que la llamada a una función forma siempre parte de una expresión, la llamada a un
procedimiento es una instrucción.
Qué sucede cuando se invoca a un procedimiento?
1. Se cede el control al procedimiento al que se llama y lo primero que se hace al cederle el control
es sustituir cada parámetro formal de la definición por el parámetro actual o real de la llamada
asociado a él. Esta asociación entre parámetros formales y reales se hace de izquierda a
derecha por orden de colocación y para que se pueda producir esta asociación tienen que existir
el mismo número de parámetros formales que reales, y además el tipo tiene que coincidir con el
del parámetro formal asociado, sino se cumple alguna de estas condiciones hay un error.
2. Si la asociación ha sido correcta comienzan a ejecutarse las instrucciones del procedimiento
hasta llegar a la última instrucción. Al finalizar se vuelven a asociar los parámetros formales que
devuelven los resultados a los parámetros reales asociados en la llamada, es decir, de esta
manera algunos de los parámetros reales de la llamada ya contendrán los resultados del
procedimiento.
3. Finalmente se cede el control a la siguiente instrucción a la que se hace la llamada, pero
teniendo en cuenta que en esta instrucción y en las siguientes puedo usar los parámetros reales
en los que se devolvieron los resultados del procedimiento para trabajar con ellos.
Ejemplos de definición y uso de procedimiento
Problema 1: Se desea resolver el subproblema de reemplazar en un texto todas las apariciones de un
carácter por otro. Por ejemplo, si el texto es “las casas” y se debe reemplazar la “a” por “o”, el texto que
queda es “los cosos”.
De la lectura del problema encontramos los siguientes datos de entrada y datos de salida:
Datos de entrada
Texto a reemplazar: texto Car1
Carácter a buscar: car1 Car2
Carácter de reemplazo: car2 texto
Datos de salida Cliente Reemplazo
Texto final: texto
Si bien hay un solo dato de salida, se trata de modificar el dato de entrada. Por lo tanto será un
parámetro de entrada-salida y no puede resolverse con una función. No hay precondiciones especiales
para este problema más que los parámetros de entrada o de entrada-salida vengan inicializados, porque
si el texto fuera vacío, no habría nada para cambiar y devolvería el mismo texto vacío. Como texto, car1
y car2 son datos de entrada, deberán estar inicializadas.
Para resolver el problema, se recorre el texto de principio a fin y por cada carácter del texto se lo
compara con car1, si hay coincidencia se lo reemplaza por car2.
La operación queda definida como:
Procedimiento Reemplazo (E/S texto: cadena, E car1,car2: carácter)
(* reemplaza en texto todas las apariciones de car1 por car2
precondición: texto = T1 y car1= C1 y car2 = C2
poscondición: texto = T2 y (C1 no se encuentra en T2 o C1 = C2) y (C2 se
encuentra en T2 o (C1 no se encuentra en T1 y T1 = T2))
*)
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 47

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 de este procedimiento en otro algoritmo:


Algoritmo UsaReemplazo
(* Recibir un texto y mostrarlo luego de reemplazar todas las vocales por guiones
*)
Const
Guion= ‘-’ Observar que:
Var
texto: cadena • texto es el parámetro real asociado al
Inicio parámetro formal de entrada-salida y es
una variable inicializada (por efecto de
Mostrar (“ingrese texto”) la operación ingresar
Ingresar (texto)
Reemplazo (texto, ‘a’, Guion) • la correspondencia con los parámetros
Reemplazo (texto, ‘e’, Guion) de entrada car1 y car2 se realiza con
Reemplazo (texto, ‘i’, Guion) parámetros reales constantes (por
Reemplazo (texto, ‘o’, Guion) ende, inicializados).
Reemplazo (texto, ‘u’, Guion)
Mostrar (texto)
Fin
Problema 2: Se desea resolver el subproblema de conocer las veces que se repite un carácter
determinado en un texto y el índice de su última aparición. Si el carácter no se encontrara, la cantidad
será nula y la posición cero. De la lectura del problema encontramos los siguientes datos de entrada y
datos de salida:
texto
Datos de entrada
car1
Texto donde buscar: texto
cant
Carácter a buscar: car1
pos
Datos de salida
Cliente averiguaCantPos
Cantidad de veces que se encuentra: cant
Posición de la última aparición: pos
El algoritmo que lo use deberá suministrar el texto y carácter a buscar y obtendrá como resultados la
cantidad y la posición. Se requieren dos parámetros de entrada y dos parámetros de salida, por lo tanto
no puede resolverse con una función y deberá hacerse con un procedimiento. No hay precondiciones
especiales para este problema, y como texto y car1 son datos de entrada, deberán estar inicializadas.
No importa el valor que puedan tener cant y pos, este subalgoritmo les proporcionará el valor.
Para resolver el problema, primero se debe inicializar a pos y a cant en cero, luego se recorre el texto de
principio a fin y por cada carácter del texto se lo compara con car1, si hay coincidencia se incrementa
cant y se guarda su posición en pos. La operación queda definida como:
Procedimiento averiguaCantyPos (E texto: cadena, E car1: carácter, S
cant, pos: entero)
(* Cuenta todas las apariciones de car1 en texto y da la posición de su última
aparición
precondición: Texto = T y car1 = C
poscondición: cant=N y pos=P y ((N>0 y P>0 y P <= long(T) y T[P]=C y C se
encuentra en T Nveces) o (N=0 y P=0 y C no se encuentra en T)) *)
Var
Observar que los parámetros
i: entero formales de salida (cant y pos) son
Inicio inicializados en el procedimiento
cant <-0 por cualquiera de los caminos que
pos <- 0 siga el algoritmo.
Desde i<-1 hasta long(texto) hacer
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 48

Si texto[i] = car1 entonces


cant <- cant +1
pos <- i
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

Funcion FactorialRecursiva (E nro:entero): entero


(* precondicion: nro=N y N >= 0
poscondicion: Factorialrecursiva = N! *)
Inicio
Si nro > 0 entonces
FactorialRecursiva <- FactorialRecursiva(nro –1) * nro
Sino
FactorialRecursiva <- 1
Fin Si
Fin Funcion
1 si exp = 0
Potencia de números enteros: Potencia(base,exp) base * potencia(base,exp-1) si exp > 0
1 / potencia(base,abs(exp)) si exp < 0
Datos de entrada
Número real del cual se quiere conocer su potencia: base
Número entero que representa la potencia a la que se quiere elevar la base: exponente
Datos de salida
Resultado de la operación: potencia
Funcion PotenciaRecursiva (E base, exp:entero): entero
(* precondicion: base=B y exp=E
poscondicion: PotenciaRecursiva = BE *)
base
Inicio
exponente
Si exp = 0 entonces
PotenciaRecursiva <- 1 potencia
Sino Cliente Potencia
Si exp > 0 entonces
PotenciaRecursiva <- PotenciaRecursiva(base,exp –1) * base
Sino
PotenciaRecursiva <- 1 / PotenciaRecursiva(base, abs(exp))
Fin Si
Fin Si
Fin Funcion

Ambito: variables locales y globales


¿Qué es el ámbito de un identificador?
El ámbito de un identificador (variables, constantes, funciones, procedimientos) es la parte del programa
en la que se conoce y por tanto se puede usar un identificador. Según el ámbito hay 2 tipos de variables,
locales y globales:
Local: Aquella que está declarada y definida dentro de un subprograma. Su ámbito coincidirá con el
ámbito del subprograma en la que este definida.
Esto quiere decir que la variable no tiene ningún significado, no se conoce y no se puede acceder a ella
desde fuera del subprograma y que tiene una posición de memoria distinta a la de cualquier otra, incluso
si es de una variable que tiene el mismo nombre pero que está definida fuera del subprograma.
Las variables locales a un subprograma se definen en la parte de la definición de variables del mismo.
Los parámetros formales de un subprograma se comportan dentro de él como si fueran también
variables locales a él.
Globales: Son las que están definidas a nivel del programa, es decir, su ámbito es el programa o
algoritmo principal y todos los subprogramas que van junto con él.
A esta variable podemos acceder desde cualquiera de los subprogramas y el programa principal, salvo
que alguno de esos subprogramas tenga definida una variable local con el mismo nombre que la variable
global, en este caso si utilizo el nombre de esa variable me referiré a la local, nunca a la global.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 50

Lugar en el que se definen las variables globales:


En algunos lenguajes se define en el programa principal, y esa variable será global, en otros lenguajes
se definen fuera del programa principal y fuera de cualquier otro subprograma (antes de empezar el
programa principal).
El problema de usar variables globales es que como todos los subprogramas las pueden modificar,
puede ser posible que haya usos indebidos cuando un subprograma utiliza una variable global sin saber
que otro la ha modificado, por esa razón el paso de información entre los subprogramas debiera
realizarse sólo por parámetros.
Procedimientos anidados PP
Var A,B
La anidación de procedimientos consiste en que dentro de un
procedimiento podamos definir o poner el código de otros. No PP1
todos los lenguajes la permiten. Si la anidación de procedimientos Var A,C
está permitida, se plantean más problemas en cuanto al ámbito,
desde este punto de vista, se dice que una variable local se PP2
conoce en el procedimiento en el que está definida y en todos los Var x,y
procedimientos anidados a él que son los que componen el
ámbito de dicho procedimiento, salvo que en alguno de esos PP3
procedimientos anidados esté definida una variable local con el Var x, C
mismo nombre en cuyo caso dentro de ese procedimiento
siempre nos referiremos a la variable local definida en él porque
siempre se considera el ámbito más restringido.
Variable Ámbito Variable Ámbito
A de PP PP x de PP2 PP2
B de PP PP, PP1, PP2, PP3 y de PP2 PP2
A de PP1 PP1, PP2, PP3 x de PP3 PP3
C de PP1 PP1, PP2 C de PP3 PP3

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

Métodos de paso de parámetros


Existen distintas formas en que los lenguajes resuelven el paso de parámetros: haciendo copia de valores,
pasando la dirección o camino de acceso al parámetro real, a través del nombre.
Paso de parámetros por copia:
o Por valor.
o Por resultado.
o Por valor-resultado.
La característica fundamental de este método de paso de parámetros es que el parámetro formal
siempre se considera que tiene asociada una dirección de memoria en la que está almacenado y que
por tanto se comporta igual que una variable local del subprograma en que aparece.
En este método lo que importa es el valor del parámetro actual.
Por valor: Nos interesa el valor del parámetro actual a la entrada, para ello este valor se copia en la
dirección de memoria del parámetro formal asociado. En este caso el parámetro real puede ser una
constante, expresión o variable, y nunca se va a usar para devolver resultado a través de él. Si el
parámetro actual fuera una variable y la modificásemos dentro del subprograma (algo que no
deberíamos hacer), fuera del subprograma no tendría ninguna repercusión esta modificación, es decir,
esa variable seguiría valiendo lo mismo en el programa desde el que se hace la llamada después y
antes de hacerla.
Los lenguajes utilizan este método para implementar el pasaje de parámetros de ENTRADA.
Por valor-resultado: En el valor-resultado nos interesa el valor del parámetro actual tanto a la entrada
como a la salida de la ejecución del subprograma.
Esto quiere decir que se cambia el valor del parámetro formal cambiará también el valor de su parámetro
real asociado, cosa que no ocurría antes, y esto supone por tanto que ahora el parámetro real tiene que
tener asociada obligatoriamente una dirección de memoria, por lo que siempre tendrá que ser una
variable (no una constante ni una expresión).
Es un de las maneras de implementar el pasaje de parámetros de ENTRADA-SALIDA
Por resultado: Nos interesa el valor del parámetro real solamente a la salida o fin de la ejecución del
subprograma en que aparece. Esto significa que al hacer la llamada no se copia el valor del parámetro
real en el parámetro formal asociado, sin embargo a la salida se copia el valor del parámetro formal en la
dirección del parámetro real asociado, esto significa por tanto, que el parámetro real tiene que tener
asociada una expresión que tiene que ser una variable (no puede ser una constante o una expresión).
Es una manera de implementar el pasaje de parámetros de SALIDA
Paso de parámetros por referencia
La característica principal de este tipo de paso de parámetros es que el parámetro formal va a tener
también asignada una dirección de memoria en la que se almacena, pero en esa dirección NO SE
GUARDA SU VALOR, sino que se almacena la dirección de su parámetro real asociado, es decir, el
parámetro formal apunta al parámetro real que tiene asociado y cualquier modificación que se efectúe
sobre el parámetro formal tendrá una repercusión directa en el parámetro real asociado ya que lo que
modificará será el valor almacenado en la dirección que indica el parámetro formal que es la de su
parámetro formal asociado.
El proceso será por tanto el siguiente:
o Al hacer la llamada al procedimiento en el parámetro formal que se pasa por referencia, se va a
guardar la dirección del parámetro real asociado para que apunte a él.
o Durante la ejecución cualquier referencia al parámetro formal se hará accediendo a la dirección
apuntada por dicho parámetro, es decir, accediendo directamente al parámetro real asociado,
por lo que cualquier cambio en el parámetro formal afectará directamente al parámetro real
asociado. De esta manera habremos pasado el resultado.
La mayoría de los lenguajes utiliza este método para implementar el pasaje de parámetros de
ENTRADA-SALIDA y de SALIDA.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 52

Paso de parámetros por nombre


En este caso, el parámetro formal se sustituye literalmente por el parámetro actual asociado. Esta
sustitución literal del parámetro formal por el parámetro actual no se produce hasta que no se usa el
parámetro formal.
El paso de parámetro por nombre es lo que se parece más a la substitución de parámetros en una
función matemática.
Pasaje de parámetros en los distintos lenguajes
En la práctica la mayor parte de los lenguajes utilizan el tipo de paso de parámetro por valor (para
parámetros de entrada) y por referencia (para parámetros de entrada-salida o de salida). Los otros dos
tipos de paso de parámetros por copia (por resultado y por valor-resultado), no se implementan
normalmente porque los efectos son prácticamente iguales que el paso de parámetros por referencia.
En Pascal para denotar que se utilizará pasaje por referencia se precede al parámetro formal con la
palabra reservada Var mientras que el pasaje por valor no lleva indicación especial.
En Visual Basic, las palabras ByVal y ByRef las que se utilizan para distinguir el pasaje. También es
factible declarar a una de ellas por defecto y sólo aclarar cuando es la otra.
En C, sólo existe el pasaje por valor. El pasaje por referencia debe hacerse trabajando directamente con
punteros.
En Ada, se indica con las palabras in, out e in-out para indicar por valor, resultado o valor-resultado.
En Java, no se requiere distinguirlo: si se trata de un tipo simple es por valor, si se trata de un objeto es
por referencia.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 53

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]

Lista[1] = 10 y Lista[9] > Lista[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]

Matriz[1,1] = 1.0 y Matriz[3,9] =2.2

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

Desde columna <-1 hasta Max hacer


Mostrar (Matriz [fila,columna])
Fin Desde
Fin Desde

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

Inicialización de un arreglo unidimensional


Se trata de una operación que pretende llenar un rango de celdas consecutivas del arreglo con un valor
fijo, recibido como parámetro.
Datos de entrada Primero, ultimo
Rango: primero y último del rango de celdas Val
Valor de inicialización: val lista

Datos de salida: Cliente Inicializar


Arreglo de datos: Lista
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
Inicializar con estos parámetros.
Procedimiento Inicializar(S Lista:tLista, E primero, ultimo: entero, E
val:entero)
(*Precondición: primero=P y ultimo=F y val=V y P<=F y [P,F] ⊆
rango(tLista) *)
(*Poscondición: Lista= {Li} y Li = V ∀ i ∈ [P,F]*)
Var
i: entero
Inicio
Desde i<-primero hasta ultimo hacer
Lista[i] <- val
Fin Desde
Fin Proc

Llenado secuencial de un arreglo unidimensional


Se trata de una operación que pretende llenar un rango de celdas consecutivas del arreglo con un valor
ingresado por el usuario.
Primero,
Datos de entrada
Rango: primero y fin del rango de celdas ultimo
Lista
Datos de salida:
Arreglo de datos: Lista Cliente LlenarListaSec

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

Consulta aleatoria de un arreglo unidimensional


Se trata de una operación que pretende mostrar celdas a pedido del usuario dentro de un rango de
celdas del arreglo. Primero, ultimo

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

Procedimiento MostrarListaAlea(E Lista:tLista, E primero, ultimo: entero)


(*Precondición: primero=P y ultimo=F y val=V y P<=F y [P,F]⊆ rango(tLista)
y Lista = {Li} ∀ i ∈ [P,F] *)
(*Poscondición: se mantienen las precondiciones *)
Var
pos: entero
Inicio
Repetir
Pos <- enteroEnRango(“Ingrese posición”,primero,ultimo)
Mostrar (Lista[pos])
Hasta confirma(“finaliza?”)
Fin Proc

Verificar si un arreglo unidimensional está ordenado en forma ascendente


Se trata de una operación que pretende verificar que cada elemento que está en una posición i de la lista
es menor o igual al que está en la posición i+1. Para tener la oportunidad de que el algoritmo sirva para
verificar una sublista, se requiere conocer el principio y fin del rango de celdas.
Datos de entrada Primero, ultimo
Rango: primero y fin del rango de celdas a verificar Lista
Arreglo de datos: Lista estáOrdenado

Datos de salida: Cliente EstaOrdenado


Resultado de la operación: estáOrdenado (lógico)
Como se requiere un único dato de salida de tipo simple que puede ser calculado en función de los
datos de entrada, esta operación conviene realizarse como una función. Supondremos que la lista está
ordenada y si en el proceso de verificación de que cada elemento i sea menor o igual al respectivo i+1
fallara, cortamos la verificación y devolvemos el valor falso.
Función EstaOrdenado(E lista:tLista, E primero, ultimo: entero): logico
(*Precondición: primero=P y ultimo=F y y P<=F y [P,F]⊆ rango(tLista) y
Lista = {Li} ∀ i ∈ [P,F] *)
Poscondición: EstaOrdenado = verdadero si Li<=Li+1 ∀ i ∈ [P,F-1] y
falso si no*)
Var
i: entero
verifica: logico
Inicio
verifica <- verdadero
i <- primero
Mientras i< ultimo y verifica hacer
Si lista[i] > lista[i+1] entonces
verifica <- falso
Fin Si
i <- i + 1
Fin Mientras
EstaOrdenado <- verifica
Fin Funcion

Llenado secuencial de un arreglo bidimensional


Se trata de una operación que pretende llenar un rango de celdas consecutivas del arreglo bidimensional
con un valor ingresado por el usuario. Debemos distinguir si queremos realizarlo por filas o por
columnas, cambiará el orden en que anidamos las estructuras de repetición.
Datos de entrada
Rango: primero y fin del rango de filas y primero y fin del rango de columnas
Datos de salida:
Arreglo de datos: Matriz
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 58

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

Procedimiento LlenarMatrizSecC(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 j<-1 hasta finC hacer
Desde i<-1 hasta finF hacer Cliente LlenarMatrizSecC
Mostrar (“Ingrese elemento ”,i, “,”,j, “:”)
Ingresar (matriz[i,j])
Fin Desde
Fin Desde
Fin Proc

Consulta aleatoria de un arreglo bidimensional


Se trata de una operación que pretende mostrar celdas a pedido del usuario dentro de una matriz.
Datos de entrada
Rango: principio y fin del rango de filas y
principio y fin del rango de columnas
Arreglo de datos: Matriz
No hay datos de salida, entonces definiremos un procedimiento MostrarMatrizAlea con estos
parámetros.
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 MostrarMatrizAlea(E matriz:tMatriz, E finF, finC: entero)
(*Precondición: finF=F1 y finC=F2 y [1,F1]⊆ rango1(tMatriz) y [1,F2] ⊆
rango2(tMatriz)y matriz={ Mij } ∀ i ∈ [1,F1] y ∀ j ∈ [1,F2]*)
(*Poscondición: se mantienen las precondiciones *)
Var finF, finC
posF, posC: entero Matriz
Inicio
Repetir Cliente MostrarMatrizAlea
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 59

posF <- enteroEnRango(“Ingrese fila”,1,finF)


posC <- enteroEnRango(“Ingrese columna”,1,finC)
Mostrar (matriz[posF,posC])
Hasta confirma(“finaliza?”)
Fin Proc

Verificar si una matriz cuadrada es simétrica


Se trata de una operación que pretende verificar que los elementos que están en posiciones i, j debajo
de la diagonal principal, son iguales a los que están en posiciones j,i sobre la diagonal principal. La
diagonal principal de una matriz cuadrada es aquella cuyos índices son iguales. Para tener la
oportunidad de que el algoritmo sirva para verificar una submatriz, se requiere conocer el principio y fin
del rango de celdas. Si asumiéramos que la submatriz siempre comienza desde la primer fila y columna,
el principio sería una constante y no se requeriría como parámetro. Dada que es una matriz cuadrada, el
rango de filas coincide con el rango de columnas.
Datos de entrada Primero, ultimo
Rango: principio y fin del rango de filas/columnas a verificar
Matriz
Arreglo de datos: Matriz
esSimetrica
Datos de salida:
Cliente EsSimetrica
Resultado de la operación: esSimétrica (lógico)
Como se requiere un único dato de salida de tipo simple que puede ser calculado en función de los
datos de entrada, esta operación conviene realizarse como una función. Supondremos que la matriz es
simétrica y si en el proceso de verificación de que cada elemento i,j sea igual al respectivo j,i fallara,
cortamos la verificación y devolvemos el valor falso.
Función EsSimetrica(E matriz:tMatriz, E princ, ultimo: entero): logico
Var Precondición: princ=P y ultimo=F y P<=F y [P,F] ⊆
i, j: entero rango1(tMatriz) y rango1(tMatriz) = rango2(tMatriz)
verifica: logico y matriz={Mij} ∀i ∈ [P,F] y ∀j ∈ [P,F])

Inicio Poscondición: (EsSimetrica = verdadero y (Mij=Mji


verifica <- verdadero ∀i ∈ [P,F] y ∀j ∈ [P,F]) ) o EsSimetrica=falso
i <- princ +1
Mientras i<= ultimo y verifica hacer
j <- princ
Mientras j < i y verifica hacer
Si matriz[i,j] <> matriz[j,i] entonces
verifica <- falso
Fin Si
j <- j + 1
Fin Mientras
i <- i + 1
Fin Mientras
EsSimetrica <- verifica
Fin Func
Ejemplos de problemas que requiere la utilización de arreglos.
Problema 1: Recibir una lista de 100 valores enteros y mostrarla en orden inverso al ingresado.
Para poder mostrar los valores en orden inverso, primero debo tenerlos almacenados y la forma de
hacerlo es utilizando una estructura de datos de tipo arreglo unidimensional. Este algoritmo se puede
resolver con dos procedimientos: uno para el ingreso secuencial y otro para mostrarlo en orden inverso.
Para este último caso se puede utilizar la estructura de repetición desde el fin al principio con paso –1.
Problema 2: Recibir una lista de 100 valores enteros y mostrarla ordenada en orden numérico
ascendente.
Otra vez, para poder mostrar los valores en orden ascendente, primero debo tenerlos almacenados
utilizando una estructura de datos de tipo arreglo unidimensional. Este algoritmo se puede resolver con
tres procedimientos: uno para el ingreso secuencial, otro para producir el ordenamiento y otro para
mostrarlo.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 60

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

Private dia as Integer


Global - Pueden ser accesados desde cualquier procedimiento y desde cualquier módulo. (Use Global o
Public dentro de la sección de Declaraciones Generales de un módulo).
Public dia as Integer
Variables Estáticas
El declarar variables como local en un procedimieneto/función es muy usado, porque minimiza los
efectos extraños que pueden ocurrir cuando se usan variables globales. Normalmente con una variable
local en un procedimiento VB se crea un espacio de memoria para mantener el valor de esta variable
pero cuando llega al final del procedimiento (End Sub) VB libera el espacio asignado para el valor de la
variable local. Si nos interesara conservar el valor de esa variable para la próxima vez que entremos al
procedimiento debiéramos declararla como estática en lugar de hacerlo con la sentencia Dim
Ejemplo: supongamos que tenemos un botón de comando con el siguiente código que se ejecutaría al
apretar el botón:
Sub Command1_Click () Sub Command2_Click ()
Dim numero As Integer Static numero As Integer

numero = numero + 1 numero = numero + 1


Print numero Print numero
End Sub Crea una variable End Sub
Crea una variable
local normal estática local

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:

Select Case dia_actual


Case 1
nombre_del_dia = "Domingo"
Case 2
nombre_del_dia = "Lunes"
...
Case 7
nombre_del_dia = "Sábado"
End Select

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

Minute Devuelve un valor entre 0 y 59, inclusive, que representa el


minuto de la hora correspondiente al tiempo pasado como
argumento.
Month Devuelve un valor entre 1 y 12, inclusive, que representa el
mes de la fecha pasado como argumento.
Now Devuelve la fecha actual.
Time, Devuelve la hora actual
Time$
Year Devuelve un valor entre 100 y 9999, inclusive, que representa
el año de la fecha pasado como argumento.
Conversión de variables
CCur Explicitamente convierte expressiones a tipo Currency
CDbl Explicitamente convierte expressiones a tipo Double
CInt Explicitamente convierte expressiones a tipo Integer
CLng Explicitamente convierte expressiones a tipo Long
CSnd Explicitamente convierte expressiones a tipo Single
CStr Explicitamente convierte expressiones a tipo String
CVar Explicitamente convierte expressiones a tipo Variant
CVDate Explicitamente convierte expressiones a tipo Variant (Date).

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])

La sintaxis de la función InputBox consta de estos argumentos:


Parte Descripción

prompt Requerido. Expresión de cadena que se muestra como mensaje en el cuadro de


diálogo.

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.

xpos Opcional. Expresión numérica que especifica, en twips, la distancia en sentido


horizontal entre el borde izquierdo del cuadro de diálogo y el borde izquierdo de la
pantalla. Si se omite xpos, el cuadro de diálogo se centra horizontalmente.

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])

La sintaxis de la función MsgBox consta de estos argumentos:


Parte Descripción

prompt Requerido. Expresión de cadena que representa el prompt en el cuadro de diálogo.

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.

El argumento buttons tiene estos valores:


Constante Valor Descripción

VbOKOnly 0 Muestra solamente el botón Aceptar.

VbOKCancel 1 Muestra los botones Aceptar y Cancelar.

VbAbortRetryIgnore 2 Muestra los botones Anular, Reintentar e Ignorar.

VbYesNoCancel 3 Muestra los botones Sí, No y Cancelar.

VbYesNo 4 Muestra los botones Sí y No.

VbRetryCancel 5 Muestra los botones Reintentar y Cancelar.

VbCritical 16 Muestra el icono de mensaje crítico.

VbQuestion 32 Muestra el icono de pregunta de advertencia.

VbExclamation 48 Muestra el icono de mensaje de advertencia.

VbInformation 64 Muestra el icono de mensaje de información.

VbDefaultButton1 0 El primer botón es el predeterminado.

VbDefaultButton2 256 El segundo botón es el predeterminado.

VbDefaultButton3 512 El tercer botón es el predeterminado.

VbDefaultButton4 768 El cuarto botón es el predeterminado.

VbApplicationModal 0 Aplicación modal; el usuario debe responder al cuadro de


mensajes antes de poder seguir trabajando en la aplicación
actual.
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 68

VbSystemModal 4096 Sistema modal; se suspenden todas las aplicaciones hasta


que el usuario responda al cuadro de mensajes.

VbMsgBoxHelpButton 16384 Agrega el botón Ayuda al cuadro de mensaje.

VbMsgBoxSetForeground 65536 Especifica la ventana del cuadro de mensaje como la


ventana de primer plano.

VbMsgBoxRight 524288 El texto se alinea a la derecha.

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

Crear Procedimientos y Funciones


El código de las funciones VB, se encierra la serie de instrucciones entre dos instrucciones Function y
End Function y el de los procedimientos entre Sub y End Sub, que realizan acciones específicas pero no
devuelven ningún valor.
Una Function es similar a un procedimiento Sub, aunque una función puede devolver además un valor.
Function acepta argumentos, como pueden ser constantes, variables o expresiones que le pasa el
procedimiento que efectúa la llamada. Si un Function no tiene argumentos, la instrucción Function debe
incluir un par de paréntesis vacíos. Una función devuelve un valor asignándolo a su nombre en una o
más instrucciones del procedimiento.
En el siguiente ejemplo, la función Celsius calcula grados centígrados a partir de grados Fahrenheit.
Cuando se llama a la función desde el procedimiento principal, se le pasa una variable que contiene el
valor del argumento. El resultado de los cálculos se devuelve al procedimiento que efectúo la llamada y
se presenta en un cuadro de mensaje.
Sub Principal()
temp = Application.InputBox("Por favor, introduzca la temperatura en
grados F.")
MsgBox "La temperatura es " & Celsius(temp) & " grados C."
End Sub
Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 69

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

Utilizar paréntesis al efectuar llamadas a procedimientos Function


Para utilizar el valor que devuelve una función debe asignar la función a una variable y encerrar los
argumentos entre paréntesis, tal y como muestra el siguiente ejemplo.
Respuesta3 = MsgBox("¿Está contento con su salario?", vbyesno, "Pregunta 3")

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"

Comprender objetos, colecciones, propiedades, método y, eventos.


Un objeto representa un elemento de una aplicación, como una hoja de cálculo o una celda. En código
de Visual Basic, un objeto debe identificarse antes de que se pueda aplicar uno de los métodos del
objeto o cambiar el valor de una de sus propiedades.

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

Algunos objetos de la planilla de cálculo


Objeto Range
Representa una celda, una fila, una columna, una selección de celdas que contienen uno o más bloques
contiguos de celdas.

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.

Worksheets(1).Range("C5:C10").Cells(1, 1).Formula = "=rand()"

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.

Para crear una variable de objeto:


1. Declare la variable de objeto.
2. Asigne la variable de objeto a un objeto.
Declarar variables de objeto
Para declarar una variable de objeto se ha de usar la instrucción Dim o una de las restantes
instrucciones de declaración (Public, Private, o Static). Una variable que se refiere a un objeto debe ser
una Variant, un Object, o un tipo específico de objeto. Por ejemplo, son válidas las siguientes
declaraciones:

' Declara MiObjeto como tipo de datos Variant.


Dim MiObjeto
' Declara MiObjeto como un tipo de datos Object.
Dim MiObjeto As Object
' Declara MiObjeto como un tipo Font.
Dim MiObjeto As Font

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:

Dim MiObjeto As Object ' Se declara como objeto genérico.


Dim MiObjeto As Ejemplo ' Se declara sólo como un objeto Ejemplo.

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.

Asignar una variable de objeto a un objeto


Para asignar una variable de objeto a un objeto se utiliza la instrucción Set. Es posible asignar una
expresión de objeto o Nothing. Por ejemplo, son válidas las siguientes asignaciones a una variable de
objeto:

Set MiObjeto = SuObjeto ' Asigna referencia a objeto.


Set MiObjeto = Nothing ' Deshace la relación.

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:

Set MiObjeto = Nuevo Objeto ' Crea y asigna


Cátedra: Programación Básica y Métodos Numéricos
Profesora: Mg. Ing. Zulema Beatriz Rosanigo Hoja 73

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:

If Not MiObjeto Is Nothing Then


' La variable hace referencia a un objeto válido.
. . .
End If

Vous aimerez peut-être aussi