Documente Academic
Documente Profesional
Documente Cultură
vi
. : : : : : : : : : : : : : : : : : : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..
Captulo 2.
2.1.
~~~~n~~': .:..~~.~~.i.~~~
2.1.1.
~n'
' ..
2.1.4.
2.1.5.
COMPUTACIN J. Lgica, resolucin de problemas, algoritmos y programas es una obra nacida de la unin de dos textos para atender a las necesidades de la Universidad Nacional Abierta.
Dichos textos son los siguientes:
Thcker, A. B.; Bradley, W. J.; Cupper, R. D., Y Garnick, D. K.: Fundamentos de Informtica.
Lgica, resolucin de problemas, programas y computadoras. Madrid, McGrawcHiII. 1994.
2.2.
Captmo
3.3.
1
4
4
8
10
1I
13
15
16
18
20
22
24
343328
38
38
41
41
44
47
51
rfi~~~~~~~~t~:::~~~~~a~::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
52
3.2.3.
58
Reftas de
u~~2;222
3.5.
~iE~~:~~~~i~;=::::~:::::::::::~::::::::::::::::I::::::::t::::::::::::::::~::::::::::::::::::::::::::::::::::::::::
41
Al'
4:2: ~~i~~:s~:::~::::.~:~~:;~~::::~~:~~:~::~;;~~~;:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Captulo ::6.
yUSOUCD ............................................................................... ..
4.2.1.
4.2.2.
54
54
55
61
65
66
69
71
76
76
77
77
78
81
86
86
89'
90
93
93
93
95
vii
vi
viii
Contenido
4.3.
t~;.~~j~~~~~\~;;;;~si:;;~~::::::::::::::::::::::::::::::::::::::::::::::.::::::.:::::::::::::::::::::::::::::::::::::
4.3.2.
4.3.3.
4.4.
4.5.
Captulo 5.
5.1.
5.2.
5.3.
5.4.
5.5.
5.6.
Captulo 6.
6.1.
6.2.
6.3.
6.4.
6.5.
6.6.
Captulo 1.
1.1.
~~~c~~~~~~~~~ig~;ii~i~~~:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
~j!~~iciO;~:.~~.~~~.i.~~.~~~~~.:..~~~~~~~~
.. ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Resolucin de un problema utilizando la metodologa MAPS ............................................. .
5.3.1. El dilogo .................................................................................................... ,........... .
5.3.2.
Las especificaciones ................................................................................................ .
~j!~~iCiO~.:.~~~~~~.:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Definiciones de abstracciones: unificacin de rutinas viejas con ideas nuevas .... ~ .............. ..
5.4.1.
Reutilizacin de rutinas .......................................................................................... ..
5.4.2. Utilizacin de la creatividad para disear nuevas rutinas ...................................... ..
5.4.3.
Utilizacin del conocimiento del dominio en el diseo de rutinas nuevas ............ ..
Terminacin del caso de estudio ............................................................................................ .
5.5.1. Codificacin ............................................................................................................ .
5.5.2. Prueba y verificacin ............................................................................................... .
Presentacin ............................................................................................................. .
5.5.3.
Resumen ................................................................................................................................. .
Ejercicios .... " ................................... " ..................................................................................... .
~j~~~~~~~n..:..~~~~~~~~.. :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Resolucin de problemas de procesamiento de texto, utilizando MAPS: Criptografa ....... ..
Contenido
97
98
lOO
103
108
111
112
1.2.
1.3.
113
116
121
126
130
131
131
132
134
134
140
1.4.
1.5.
1.6.
144
146
147
149
150
152
156
156
158
159
161
162
163
166
167
169
169
171
171
173
174
177
1.7.
1.8.
182
!:1~: Datos
g=~~~ tipo
r~Tc~!c~so~i~~~~~
j..:: ::: :::: ::::::: ::::: ::::::: ::::::::: :::::::::::: :::::: :::: :::
carcter y tipo cadena ............................................................................ .
1.4.3.
:!f~~tj,
.
1.8.2.
1.8.3.
r~'::'~~~:~i~t~';'=~ig~~~~::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
1.8.1.
Asignacin aritmtica ............................................................................................. ..
Captulo 2.
2.4.
2.5.
178
182
187
196
196
197
202
203
203
206
209
209
212
216
217
218
221
222
2.6.
progra~a~i~":
~bl~?~s~~~~~~~~~~~..~:.~:;~~ii~;:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;:::
Captulo 3.
!j f.E~j~:;~:~
3.4.2.
3.4.3.
..
"tl:tffi~I~~~~;?,
3.5.5.
Interruptores ......................................................................................................... ..
ix
224
225
226
227
227
228
229
, 230
230
231
231
233
233
235
235
236
237
238
240
242
242
244
245
246
247
248
249
249
249
251
251
257
259
260
260
261
263
265
266
266
276
278
279
284
287
287
288
289
290
290
291
292
292
293
294
296
299
300
301
Contenido
3.6.
!:i: ~~~:~~~!~:~~?1~::6~~~~::::::::::::::::::::::::::::::::::::::::S:i:::::::::::::::::::::::::::::::::::::::::::: :
4.2.2.
4.3.
4.4.
4.5.
4.6.
4.7.
4.8.
4.9.
:~~.1~am~!~~r~~~~~~~~~0~
.. ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
4.3.2.
Diseo descendente (top-down) ........................................ :.................................... ..
4.3.3. Teorema de la programacin estructurada: estructuras bSicas .............................. .
Estructura secuencial ............................................................................................................. .
Estructuras selectivas ............................................................................................................. .
4.5.1.
Alternativa simple (si-entonces / if-then) ............................................................... ..
4.5.2.
Alternativa doble (si-entonces-sLno I if-then-else) ............................................... ..
4.5.3.
Alternativa mltiple (segn-sea, caso de / case) .................................................... ..
Estructuras repetitivas ............................................................................................................ .
4.6.1.
Estructura mientras (<<while) ................................................. :.............................. ..
4.6.2.
Estructura repetir (<<repeat) .................................................................................... .
4.6.3.
Estructura desde/para (<<for) .................................................................................. .
4.6.4.
Salidas internas de los bucles ................................................................................. ..
Estructuras de decisin anidadas .......................................................................... ;............... ..
Estructuras repetitivas anidadas ............................................................................................. .
La instruccin ir_a (<<goto) .................................................................................................. .
~:E~~t::~::::::~i~~::~~:~~~?:~:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Captulo 5.
5.1.
5.2.
5.3.
5.4.
5.5.
5.6.
5.7.
5.8.
~j~t:~:~i~~e~.~~.:.~.~.~.~~~~~~~.~..~.~~~~~~~.. :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
304
304
304
305
305
306
307
308
313
315
316
316
CAPTULO
CONJUNTOS V FUNCIONES
317
318
319
319
319
320
320
324
324
325
331
337
340
345
348
352
358
362
364
365
380
381
383
384
386
387
388
393
394
398
401
402
403
404
405
407
410
412
412
413
En este captulo introducimos las nociones matemticas bsicas sobre los con.
juntos y las funciones, junto con su notacin. Estas nociones son fundamenta.
les para la disciplina de la informtica. Ms adelante veremos cmo los con.
juntos y funciones se entremezclan con las nociones claves de la informtica y
su aplicacin. Estos conceptos y notaciones se utilizarn a lo largo de todo el
texto. (Algunos lectores encontrarn estas materias familiares. Sin embargo,
esta presentacin tiene como objetivo reorientar estas ideas, quiz familiares,
hacia aquellas partes de la informtica en que se utilizan.)
En qu forma se relacionan los conjuntos y funciones con la informtica?
Generalmente, podemos considerar un programa para una computadora,
como la realizacin de una funcin o como una correspondencia entre dos
conjuntos: la entrada del programa que representa un elemento particular del
dominio de la funcin, y la salida que representa el resultado de aplicar la
funcin a dicha entrada. Introduciremos esta idea en este captulo, ejercitndola en las prcticas de laboratorio que le acompaan. En los Captulos 4, 5 Y 6
afianzaremos este concepto, ejercitndonos en la programacin y mediante la
discusin exhaustiva de programas. Los conjuntos y las funciones estn tambin ntimamente relacionados con la propia computadora como dispositivo.
As, podemos decir que una computadora es una mquina que realiza una funcin determinada, cuando ejecuta un programa que realiza, paso a paso, dicha
funcin. Tambin se insiste en esta idea en las prcticas de laboratorio que
acompaan a este captulo. Tambin, en el Captulo 7, insistiremos sobre este
concepto al estudiar la estructura de las computadoras.
Algunos conjuntos son especialmente importantes para la programacin y
para las computadoras. Por ejemplo, los nmeros enteros y reales, los valores
booleanos, los caracteres que encontramos en el teclado de la computadora (el
conjunto de caracteres ASCII) y las cadenas * construidas con esos caracte.
414
417
422
* N. del T.: De las diversas traducciones que suelen realizarse de la palabra inglesa string,
hemos preferido la acepcin cadena o cadena de caracteres, que sern utilizadas de forma
indistinta.
res, representan conjuntos que son esenciales para la informtica; todos ellos
estn incluidos en los lenguajes de programacin y las computadoras modernas. En este captulo estudiaremos la correspondencia que existe en programacin entre estos conjuntos y el concepto de tipo. Algunas funciones resultan
de vital importancia en programacin. Entre ellas se incluyen las funciones
discretas, las funciones exponenciales y logartmicas, y funciones que se representan mediante series finitas.
Estudiaremos todas ellas en este captulo, poniendo e~p.ecial inters en destacar por qu son importantes para la informtica.
Tambin podemos definir un conjunto, estableciendo las propiedades que deben satisfacer todos sus elementos, por ejemplo:
{xix es entero y 1 .; x .; lOO}
2.1.
CONJUNTOS
menudo, los objetos que forman un conjunto comparten alguna caracterstica en comn. Un elemento de un conjunto es cualquiera de los objetos
que lo constituyen. Se dice que un elemento de un conjunto pertenece a
dicho conjunto. Si S es un conjunto que contiene el elemento x, para expresar que x pertenece a S escribiremos x E S.
Una de las formas de describir un conjunto es encerrando los elementos que lo
componen entre corchetes {y}. Por ejemplo, el conjunto de los das laborables
de la semana se puede describir como:
{Lunes, Martes, Mircoles, Jueves, Viernes}
Esta notacin requiere una variable al comienzo, una barra vertical y, al final,
una descripcin de los elementos. Con esta notacin, la Ecuacin 2.6 se lee el
conjunto de los x tales que x es un nmero entero entre 1 y 100, ambos
inclusive. Claramente, este ejemplo describe el mismo conjunto de la Ecuacin 2.5. La Ecuacin 2.7 es otro ejemplo de esta alternativa para la descripcin de conjuntos:
X2
2x
.01n 2 -
100n - 3
8000y2 - 67
(2.1)
(2.2)
(2.3)
{ +, -,
{O, 1, 2, 3, ... }
nmero naturales
(2.4)
{... , - 3, - 2, - 1, 0, 1, 2, 3, ... }
los enteros
(2.7)
Ejemplos de elementos del conjunto definido por la Ecuacin 2.7 son los siguientes:
ms importantes.
(2.6)
Definicin.
(2.5)
Por ejemplo, la cardinalidad del conjunto definido por la Ecuacin 2.3 es 26.
Existen cuatro conjuntos que tienen una importancia especial, tanto para la
informtica como para las matemticas:
z,
Conjuntos y funciones
Los tres primeros son infinitos, mientras que el ltimo es finito y tiene cardinalidad n. Por ejemplo, el conjunto Z2 = {O, 1} liene cardmahdad 2; el conjunto
ZlO = {O, 1, "., 9} tiene cardinalidad 10.
2.1.1.
a)
2.1.2.
b)
S2 E S2'
Conjuntos y funciones
y as
representa el estado de las variables x" x 2 , ... , x.. El conjunto de todos los
estados posibles de XI' x 2 , ... , x n recibe el nombre espacio de estados de esas
variables.
1..
j2
"1
-3.1
L.-----r-_____
x
..
j=O
i=5
Figura 2.2.
Ejemplo 2.2. Si los pixels controlados por un programa son XI' X , ... ,
2
XIOOOOOO, un estado de ese programa tendra 1 milln de entradas, una por
cada variable. Por ejemplo, la expresin
=
on
off
X2 =
x'oooooo
Ejemplo 2.3. Considrese un programa con tres variables, las tres del tipo
rea l (la analoga en programacin al conjunto R). Tres posibles estados
de este programa son:
x:= 1.0
O, junto con z = O
-3,1
J2 junto con z
n.
Y = 2 Junto con z
-1
on
b)
XI
/1
= 1
(
1789
"
:
:
I
I
I
1.1---1"'-_- x
z
Figura 2.3. El estado x = 1 en un programa
con tres variables reales z, x e y.
2.1.3.
A n B
AvB
T =
Los nmeros 1 y 10 son los nicos elementos que pertenecen 11 ambos conjuntos, pero existen entre S y T otros nueve elementos diferentes ...Los conceptos de
interseccin, unin y diferencia de conjuntos nos ayudan a describir en diferentes maneras la existencia de elementos comunes entre conjuntos.
Definicin. Sean A y B dos conjuntos. La unin de A y B simbolizada por
A v B, es aquel conjunto cuyos elementos pertenecen como mnimo a uno
de los dos conjuntos, A o B. La interseccin de A y B, simbolizada por A n B,
es el conjunto que incluye aquellos elementos que pertenecen tanto a A como
a B. La diferencia (o complemento relativo) de A y B, simbolizado por A \ B, es
el conjunto que contiene aquellos elementos que estn en A, pero no en B.
La Figura 2.4 representa tres diagramas de Venn, en los que las reas
sombreadas representan la unin, la interseccin y la diferencia.
A \ B
{l, 3, 5}
{-3, -1, 1,3,5,7, 9}
{7, 9}
{plp
Dos posi?les elementos ~el conjunto A seran n' + n y n' + 4,5n, mientras que
del B senan n - 3 y n + 7. Las sIgUIentes relacIOnes son ciertas:
A n B
A v B
A
\ B
{n'}
+ bn + c,
donde b = O o c = O}
{plp es un polinomio de la forma n' + bn, donde bolO}
{plp es un polinomio de la forma n'
El conjunto vaco q, es extremadamente til. Por ejemplo, si e es el conjunto de consonantes (excluida la y), y Vel conjunto de vocales (incluida la y),
entonces e n V no contIene elementos.
Definicin. Decimos que dos conjuntos son disjuntos si su interseccin es
el conjunto vaco.
al
bl
~------------~
Por ejemplo, si e y S representan el conjunto de consonantes y vocales, respectIvamente, y U es el alfabeto completo, entonces C' = V Y V' = C. Es decir,
todas las letras que no Son consonantes Son vocales y viceversa. (Se ha supuesto que la letra y es una vocal). La Figura 2.5 ilustra los conceptos de conjuntos
dIsjuntos y complementarios utilizando diagramas de Venn.
el
Figura 2.4.
,
10
Conjuntos y funciones
11
Ley de la contradiccin
AnB",BnA
AvB",BvA
Asociatividad
al
A n (B n
A v (B v
bl
u-simplificacin
e) '" (A n B) n e
e) '"
(A v B) v
AvA",A
Av<1>"'A
AvU",U
Distributividad
A n (B v C) '" (A n B) v (A n e)
A v (B n e) '" (A v B) n (A v el
Leyes de Morgan
y
n-simplificacin
AnA ",A
AnU",A
An<1>"'<1>
Propiedad de la negacin
(A')' '" A
Complementariedad
2.1.5.
2.1.4.
U' - 4l
<1>' '" U
20
resultado de eliminar la parte decimal de x, y para nmeros reales negativos que no sean ya enteros, l_x_1 es el resultado de eliminar la parte decimal y restarle uno. La grfica de esta funcin se muestra en la Figura 2.1!.
Una funcin muy relacionada es la funcin techo I-x-l que se define como el
menor entero mayor o igual que x. Se calcula eliminando la parte decimal
de x, y si x no fuera entero, sumndole uno. Las funciones suelo y techo
tambin se conocen como funciones mayor entero y menor entero, respectivamente.
_:
La funcin valor absoluto puede calcularse en Pascal, directamente, utilizando la expresin abs(x), donde x puede ser una variable o expresin del
tipo rea Lo; nteger. Sin embargo, las funciones suelo y techo no llenen una
analoga exacta en Pascal. La funcin ms prxima es la funcin t runc (x)
que convierte cualquier variable o expresin de tipo rea L en integer eliminando los decimales. Por tanto, trunC<3.14) = 3, y trunC<-3.14) = -3.
,
-2
'-1
1
2
4
7
10
O
1
f(n -
1) + f(n -
2)
cuando
cuando
cuando
n
O
n = 1
n >
,,
n f(n)
-0--0-
'1
'2
:3
---'!--+---:---:--.;--
Figura 2.".
f(n)
En algunas ocasiones es fcil deducir una frmula no-recursiva para calcular f(n) a partir de la recursiva, y en otros casos es muy dificil. Por ejemplo,
el caso del Ejemplo 2.20 es relativamente sencillo, extrayendo el criterio de
la tabla para obtener la frmula equivalente f(n) = 3n + !.
f(n)
y
n
O
n > O
Hemos visto cmo se pueden definir funciones utilizando una frmula, una
grfica xy, una tabla de dos columnas y un conjunto de pares ordenados. Las
funciones pueden definirse de varias formas alternativas.
cuando
cuando
1)
2.2.3.
1
3 + f(n -
21
1
2
3
4
5
6
7
1
1
2
3
5
8
13
21
26
p-'(b)
b
d
p-I(C)
p-'(d)
p-I(a)
Obsrvese que, puesto que ord y chr son inversas, una de la otra, se verifica:
chr(ord(x
Una lista completa de los caracteres ASCII y sus ordinales correspondientes puede encontarse en el Apndice A.
El propsito de la funcin o rd es definir un esquema de codificacin uniforme para representar los caracteres del teclado. Este esquema lo utilizan
todos los constructores de software y hardware de computadoras. La existencia de este estndar permite el intercambio fcil de informacin entre distintos
tipos de computadoras.
Obsrvese que, para ser eficaz, la funcin ord tiene que ser uno-a-uno; si
un cdigo estuviera asignado a dos caracteres distintos, no existira una forma
consistente de descodificar el cdigo. Puesto que es una funcin uno-a-uno, la
funcin ord tiene en Pascal su inversa, denominada chr (por Character). Si n
es un entero en el intervalo 0-127, entonces chr(n) es el carcter del teclado
correspondiente del entero. Por ejemplo:
chr(48)
chr(6S)
chr(61)
chr(97)
'O'
'A'
= '='
= 'a'
=
ord(chr(n
27
como
28
Conjuntos y funciones
As, si n
* N.
del T.: En castellano se suele utilizar el trmino cardinalidad o simplemente cardinal
de un
conjunto.
2, a 2
al
O, Y a o
1, entonces p(x)
= 2X3 +
1.
3, a 3
Las funciones exponenciales y logartmicas son dos clases de funciones con una
importancia tal en la informtica, que es necesario estudiarlas cuidadosamente.
Comencemos por la funcin exponencial.
29
2"
-2
-1
1/4
1/2
1
2
4
8
16
1
2
3
4
Figura 2.14.
34
2.2.6.
Los procesos acumulativos son frecuentes en la informtica. Por ejemplo, algunos programas repiten un determinado clculo. Cada repeticin consume
una cierta cantidad de tiempo y memoria. El programador tiene que ser capaz de estimar la cantidad de tiempo y espacio que consumir el programa,
sin necesidad de ejecutarlo. Tales clculos suelen iml?/icar la suma de largas listas de nmeros o expresiones. Para facilitar tod6-~1l0, y otras expresiones relacionadas, se ha desarrollado la denominada notacin sigma. Esta notacin utiliza la letra griega ~ (sigma) para simbolizar la suma, un ndice que
define el intervalo de valores para los que se realiza la suma, y la funcin que
hay que sumar. Supongamos que se quiere escribir la suma de los 20 primeros
enteros, 1 + 2 + 3 + ... + 20, utilizando notacin sigma. Escribiremos
entonces:
I f(i)
i=m
,:,
a = al
1=1
,
I= a,
+ 2 + 3 + ... +
(n -
1)
,~3i
o+
+ ... +
,~(3i + 2)
d)
.J,-,
e)
,:," i
f)
i= I
i(3i
2)
3(n -
1)
+ 8 + 11 + ... +
+ ... +
(n -
2)
(n -
+ ... +
(n -
1)
n.
16
33
f(n)
a2
+ ... +
an
(2.19)
(2.20)
+
1)
(3n -
3n.
(3n
+ ... +
(n -
+ 2).
1).
n(3n
(2.22)
11-1
a.
,~ a,
I= 1 a
I", e
1)(3n - 1)
:, a,
,~
,:, a,
,~
+ ... +
:, a,
(2.23)
"
I
I=m+
a,
SI
1 ,,-;; m < n
(2.24)
,
e)
1)
(2.21)
a,
n.
,
b)
a,
I 1 a,
f(m
Obsrvese la utilizacin de subndices en la Ecuacin (2.20). Este tipo de notacin suele utilizarse para diferencar los elementos de una lista, siendo a, el
primero, a 2 el segundo, y as sucesivamente. Utilizaremos a menudo esta idea
de lista en el diseo de programas.
i=
I== 1 i
.L
a)
f(m)
Propiedades de las series finitas. Las Ecuaciones (2.21) a (2.24) reflejan algunas
propiedades bsicas de las sumas utilizando la notacin sigma.
20
"
35
+ 2).
I"
i= 1
cf(i)
en
e
I"
i= 1
f(i)
(2.25)
(2.26)
36
"
L (I(i)
i= 1
+ g(i
L (f(i)
i= 1
Conjuntos y funciones
- g(i
(2.27)
,~ f(i)
=1
g(i)
(2.28)
L (f(i
i= 1
1) - f(i = f(n
1) - f(1)
(2.29)
1) - f(n
Gauss pudo observar que el resultado era la mitad de 101 x 100, o 5050. El
profesor de Gauss reconoci que el muchacho tena un gran talento para las
matemticas, y re.comend a su padre que lo enviara a un colegio en el que
pudIera sacar mejor partIdo de su capacIdad. De hecho, podemos utilizar el
mtodo abreviado de Gauss para sumar series en general:
+
+
(n
1)
+
+
+
1)
1)
(n
(n
+
+
,f:
+ ... +
(n -
1)
trmino a trmino:
99
101
,f:
n(n
1) +
(n
2
(n
+
1)
1
(n
1)
"
1)
(2.30)
+ 1)(2n +
1)
(2.31)
6
i3
n 2 (n
JI 2i
+ W
(2.32)
2n+ 1
(2.33)
+ lOO
2 +
+
+
+
15
+
+
+
+
Las Ecuaciones (2.30) a (2.32) se las conoce con el nombre de p-series por ser de
la forma:
Existe una ancdota interesante sobre esta serie. Carl Friedrich Gaus (17771855) fue uno de los matemticos ms destacados del siglo XIX. Cuando era
joven le enviaron a un internado, ms conocido por su estricta disciplina que
por su calidad acadmica. Como castigo, l y sus compaeros deberan realizar
el ejercicio de sumar los lOO primeros enteros. Apenas el profesor haba enunciado el problema, Gauss levant su mano dando la respuesta correcta. Gauss
haba descubierto una forma sencilla de sumar la serie aritmtica para n =
100. Gauss escribi la suma horizontalmente en orden creciente, y debajo
escribi la misma suma, pero en orden decreciente, haciendo despus la suma
1 +
2 +
3 +
+ 100 + 99 + 98 +
101 + 101 + 101 +
2)
1)
n(n
(n
1=1
n
3
(n
Puesto que hay n trminos en la suma, el resultado de la suma anterior puede escnbIrSe n(n + 1). Por tanto, la suma de la serie aritmtica original es
n(n + 1)/2, puesto que se ha sumado consigo misma para obtener la ltima
lnea. La forma compacta de la suma de esta serie, junto con la de otras tambin importantes, se muestran en las Ecuaciones (2.30) a (2.33).
donde podemos ver que todos los trminos entre f(n + 1) Yf(l) se cancelan
mutuamente, por lo que el resultado serf(n + 1) - f(I).
37
1
101
20
,~
20
,f:
JI
JI
6
15(15 + 1) ,;,
120
2
20(21)
-2-
6(7)
210 - 21
189
54
e)
f)
3.6.
p ""'" (q 1\ -q ""'" p)
(p ""'" q) v (p =- - q)
Demostrar que - (p v q) y (- P 1\
3.2.
q)
3.2.2.
Propiedades de la equivalencia
La equivalencia tiene una serie de propiedades que se verifican para todas las
proposiciones, y que son de gran utilidad en varias aplicaciones de la lgica.
En la Tabla 3.2 se resumen las ms importantes.
Equivalencia
Tabla 3.2.
Considrese la proposicin (p 1\ q) V (p 1\
tra abajo:
p
verdadero
verdadero
verdadero
falso
falso
falso
falso
verdadero
q) V (p
-q)
verdadero
verdadero
falso
falso
==
==
Asociatividad
qAp
qvp
r)
pv(qAr)
p
(q
==
r)
(pvq)A(pvr)
(p
q)
(p
==
-(pvq)
-(pAq)
p=q
pvp
==
pV(pAq)
== verdadero
== P
==
pA
A
p v verdadero
pvfalso == p
==
(q=q)A(q=p)
Ley de la contradiccin
p v ....... p == verdadero
v -simplificacin
-pA-q
-pv-q
Identidad
==
==
Lcy de la bicondicionalidad
-pvq
Propiedad de la negacin
-(-p)
(pAq)Ar
(pvq)vr
Leyes de Morgan
==
==
Ley de la implicacin
==
==
pA(qAr)
pv(qvr)
Distributividad
Los valores de la ltima columna de la tabla son exactamente los mismos que
los de la columna de la p; por tanto, podemos decir que (p 1\ q) V (p 1\ - q) es en
cierta manera equivalente a p. Por tanto, si en alguna situacin nos encontramos con (p 1\ q) V (p 1\ - q) podemos sencillamente reemplazarla por p.
En cuanto empezamos a razonar con proposiciones, se ve la necesidad de
simplificar proposiciones complejas. Nuestro propsito ahora ser el de definir
qu significa que dos proposiciones sean equivalentes, y el ver cmo esta equivalencia permite simplificar expresiones complejas.
Propiedades de la equivalencia
Conmutatividad
pAq
pvq
(p
55
3.2.1.
Lgica
== falso
-simp1ificacin
pAP
.p
== P
Averdadero ==
p A falso == falso
pA(pvq) == p
58
11. 2x=1
12. (1/2)2x = 1/2
13. 1/2)2)x = 1/2
14. Ix = 1/2
15. x = 1/2
Lgica
Ejemplo 3.11.
Simplificar la proposicin (p = (q /\ r
(q /\
s:
1. (p
(q /\r /\ (~p
(q /\ s
2. ( ~ p v (q /\r)) /\ (p V (q /\ s
3. ( ~ p v q) /\ ( ~ P v r) /\ (p V q) /\ (p V s)
4. ~P/\p)vq)/\(~pvr)/\(pvs)
5.
(q /\ ( ~ P v r) /\ (p
6.
q /\ (p
3.2.3.
/\ (~p
s)
= r) /\ (~p = s)
res.
59
de demostracin es una extensin de la metodologa desarrollada para simplificar proposiciones. Sin embargo, las demostraciones contienen un ingrediente
adicional de gran importancia: se realiza una inferencia a partir de una suposicin. Las inferencias de una demostracin se realizan aplicando un reducido
conjunto de reglas de inferencia. Es decir, las reglas de inferencia permiten
obtener proposiciones a partir de otras, de las que se conocen si son verdaderas o se supone que lo son. Estas reglas se resumen en la Tabla 3.3.
Definicin. En el clculo proposicional, una demostracin es una secuencia de pasos que sirven para demostrar que una determinada Proposicin p
es una tautologa. Cada paso de la demostracin es bien una Proposicin
ya demostrada, bien una proposicin que se ha obtenido de otra anterior
utilizando una regla de inferencia, o bien una proposicin que se introduce
como suposicin para preparar un paso posterior. Este ltimo tipo de
proposiciones (suposicin) lo simbolizamos ponindolo entre corchetes
cuadrados [y]; todos los dems pasos se acompaan de una justificacin; y
el ltimo paso de la demostracin debe ser la propia p.
La sencilla prueba del ejemplo 3. I 2 muestra que p = p es una tautologa.
Podramos demostrar esto utilizando una tabla de verdad, pero representa una
buena oportunidad para introducir la notacin y estilo de las demostraciones.
Ejemplo 3.12.
1.
[p]
2.
3.
Demostrar p
p:
I
=-introduccin, 1, 2
60
<=>-introduccin
p=q
q=p
p=q
[p]
~q-
p=q
<:>-eliminacin
=>-eliminacin
(modus ponens)
p=p
-p-
q
(modus rollens)
p=q
:::.!L
-p
p=q
p=q
[p]
ralso
-p
'" -eliminacin
/\ -introduccin
p
ralso
ralso
p
v-introduccin
~q
-p-
pAq
pvq
/\ -eliminacin
v-eliminacin
pAq
-q-
-q-
pvq
[p] [q]
pvq r r
r
.
.
SI'n
embargo
muchas
de
las
reglas
de
mferencla
no
lenen
1a '" e llmmacwn.
,
.'
nin n precedente, entre las propiedades de la eqUIvalencIa.
las reglas de inferencia pueden utilizarse como alternal1v~ a las tablas de
verdad en la demostracin de que una determinada proposlclon es una taut?loga. Sin embargo, como veremos ms adelante, las demostracIOnes son mas
1:
61
verstiles que las tablas de verdad, puesto que las tablas de verdad son inmanejables cuando analizamos las proposiciones de ms de tres o cuatro variables, y
adems no aportan ninguna base para razonar con proposiciones de forma
deductiva.
Podemos autoconvencernos, de forma intuitiva, de que las reglas de inferencia tienen sentido. Por ejemplo, la regla de la A -introduccin nos dice que si
hemos demostrado que p y q son tautologas en dos pasos anteriores cualesquiera de la demostracin, en el paso actual podemos concluir que p A q es una
tautologa. De forma similar, la regla de la =-eliminacin (conocida familiarmente como modus ponens), simplemente establece que, si en un paso anterior
q y que p es una tautologa, en el paso actual
hemos demostrado que p
podemos concluir que q es una tautologa.
En las demostraciones procederemos paso a paso para conseguir, en cada
uno de ellos, una nueva tautologa que nos acerque ms a nuestra meta -la
ltima proposicin de la prueba-. Justificaremos cada paso realizado, bien en
la utilizacin de una regla de equivalencia (mediante la sustitucin de una
parte derecha de una expresin de la Tabla 2.3, por una parte izquierda, o viceversa), bien mediante la utilizacin de una regla de inferencia. Adicionalmente a lo anterior, es preciso desarrollar estrategias de demostracin; es decir, mtodos de realizar demostraciones que puedan ser de utilidad en diferentes
situaciones. Estas situaciones se dan no slo en la lgica, sino tambin en
varias aplicaciones de la informtica, las matemticas y la ciencia en general.
'" -introduccin
p
- p
Lgica
3.2.4.
Estrategias de demostracin
En esta seccin se estudian algunas estrategias bsicas para demostrar que una
proposicin es una tautologa, mediante la utilizacin de las propiedades de la
equivalencia y las reglas de inferencia.
Una demostracin deductiva es aquella en que se
utilizan las reglas de inferencia para deducir las conclusiones, despus de haber
realizado una o ms suposiciones para comenzar el proceso de demostracin.
El ejemplo 3.13 es un ejemplo sencillo.
Demostracin deductiva.
Demostrar que p
Ejemplo 3.13.
1.
2.
3.
4.
5.
[p]
q
(q
[q]
p
P
p)
= (q = p)
Suposicin
Suposicin
1
=-introduccin, 2, 3
=>-introduccin, 1, 4
62
Lgica
((p
q) /\ (r
r = p
r
p
p = q
1.
2.
3.
4.
5.
= p) M)
6.
7.
= q) /\ (r = p) /\ r) = q
((p
= q) /\ (r = p) /\ r) = q:
1.
2.
3.
[(p
Demostrar ((p
q)/\ ~q]
q
~p
= q) /\ ~ q) = ~ p
q) /\ ~ q)
~ p:
Suposicin
t\
~p
4.
5. ((p
-eliminacin, 1
/\ -eliminacin, 1
Modus tallens, 2, 3
=>-introduccin, 1, 4
= q) /\ ~ q) =Demostrar,
p:
[(p
p
3.
4.
~q
=q
q)/\ ~q]
5.
6.
~q
7.
falso
((p =q)/\ ~q)
-eliminacin, 1
Suposicin
Modus ponens, 2
3
~ -eliminacin 5, 6
~ -introduccin, 4
=-introduccin, 1, 8
~p
8.
9.
Suposicin
A -eliminacin,
[p]
q
~p
Suposicin
A -eliminacin,
A -eliminacin,
Modus ponens, 2, 3
/\ -eliminacin, 1
Modus ponens, 4, 5
=-introduccin, 1,6
Utilizacin de la /\-eliminacin y modus tollens. En el Ejemplo 3.15 se desarrolla una demostracin utilizando una combinacin de las reglas de inferencia
/\ eliminacin y modus ponens. Como en casos anteriores, se parte de suposiciones cuidadosamente elegidas y trabajamos deductivamente a partir de ellas.
Ejemplo 3.15.
1.
2.
63
1.
2.
[p
Demostrar (p
= (q = rl]
[p
3.
4.
5.
6.
7.
8.
9. (p
= q]
[p]
q
q
r
=r
(p = q) = (p = r)
= (q = r)) = ((p = q) = (p = r))
= =
1.
2.
3.
[ ~pvq]
[ ~p]
[p]
4.
p/\
5.
falso
q
6.
7.
8.
p=q
[q]
~p
= =
Suposicin
Suposicion
Suposicin
/\-introduccin, 2, 3
~ -introduccin, 4
~ -eliminacin, 5
=-introduccin, 3, 6
Suposicin
64
Lgica
[p]
q
9.
la
11.
12.
13.
14.
p""'q
P "", q
(- p v q) "", (p "", q)
[p "", q]
15.
pv-p
[p]
16.
17.
18.
19.
20.
21.
q
-pvq
[_p]
-pvq
-pvq
(p"'" q)
=- (_ p v q)
Suposicin
8
"",-introduccin, 9, 10
v-eliminacin, 1, 2
"",-introduccin
Suposicin
Ley de exclusin del caso intermedio
Suposicin
.
Modus ponens, 14, .16 ..
v -introduccin, 17
Suposicin
v-introduccin, 19
v-eliminacin, 15, 16, 18, 19, 20
"",-introduccin, 14, 21
=--introduccin, 13, 22
2.
[-(p""'q)Ap)""'q)]
-(-p"'" q)Ap)Vq)
3.
4.
p"'" q) A p)
-q
5.
(p"'" q)
6.
7.
8.
q
Falso
9.
p"'" q) A p) "", q
Suposicin
""'-eliminacin, 1
3.2.5.
65
HF
BRD
BRCH
Los
Los
Los
Los
Es posible representar las cinco frases de que consta el problema original mediante las proposiciones siguientes, respectivamente:
1.
2.
3.
4.
5.
-HF"", W
-W"", -BRD
-(BRDA -W)"", HF
-(-HFv -BRD) "", -BRCH
BRD
lO.
11.
12.
W
-BRDvW"", HF
-BRDv W
HF
BRDAHF
(HF A BRD) "", - BRCH
-BRCH
Modus tollens, 2, 5
Leyes de Morgan, 3
v-introduccin; 6
Modus ponens, 7, 8
A-introducCin, 5, 9
Leyes de Morgan, 4
Modus ponens, lO, 11
70
* Pra una mayor informacin sobre las expresiones booleanas en Pascal, consltese el
manual de laboratorio.
Lgica
71
Definicin.
vlido.
e)
d)
e)
f)
3.3.1.
{(i,j)li<j}
{(i,j) I i 2 + / = 25)}
{tao, a" a 2 ) I a o = mx(a a 2 )}
{(S" S2) / S, es un prefijo "para S2}
{ti, j) I i < j v j = O}
{(j, j) I i 2 + j2 = 25 /\ j > 2}
que es una permutacin de otra lista A, y que tiene la propiedad de que para
entre 1 y 29, ambos inclusive, e+ 1 <; e. Esta frase es la conjuncin de dos
72
Lgica
e, +,
(a, b)
e, +, e,
~
---4------------------ x
como
o."
donde. a continuacin del smbolo V. aparece un predicado que indica el dominio de la variable i. y a continuacin de este otro predicado que indica lo que
es verdadero cuando la variable toma valores en ese dominio.
De forma general. el predicado siguiente puede construirse con los predicados R(i) y P(i):
d)
Ejemplo 3,24, Cada una de las frases de abajo va seguida de su representacin como predicado. que utiliza el cuantificador universal:
a)
b)
e)
R: i < a /\ j < b
En una lista A = (e,. e 2 .... en) los elementos hasta elj-simo. excluido
l mismo. estn colocados en orden creciente (vase Figura 3.4).
Vi
V R(i) : P(i)
73
(1
4)
e,
Figura 3.4,
e)
Ejemplo de predicado.
74
Lgica
75
La relacin entre ambos cuantificadores podemos encontrarla en la generalizacin de las leyes de Morgan siguiente:
V R(i) : P(i)
como Vi : R(i)
=;>
(Vi
=;>
e;
#- 9).
b)
e)
... ,
I}:e; = O
(3.2)
Ejemplo 3.26.
a)
- 3i
+ b
b3
b)
- 3i
1\
(3.3)
-P(2)
(3.4)
O es equivalente a
Vi
-P(1) v -P(2)
R : i < O 1\ j < O
P(2)) -
1\
f)
-(P(I)
(3.1)
La Ecuacin (3.1) dice que la frase no es cierto que todos los es en el dominio
satisfacen p es equivalente a para algn i del dominio, P es falso. La Ecuacin (3.2) tiene una interpretacin similar: la frase no es cierto que algn i en
el dominio satisfat:e P es equivalente a la frase para cada i en el dominio, P
es falso.
Estas son generalizaciones de la versin simple de las leyes de Morgan, que
fueron introducidas anteriormente en este captulo. Tngase en cuenta que los
cuantificadores utilizados ahora representan abreviaturas de conjunciones y
disyunciones. Por ejemplo, las equivalencias siguientes son interpretaciones vlidas de las Ecuaciones (3.1) y (3.2), cuando el rango de i es el conjunto {l, 2}:
3 a, b, e #- O: a
e)
3 (i, j)
)
.. ,
Existe una frase en este texto con al menos una falta de ortografia.
Vi
e; =
9.
Vi
e; = ej'
76
3.3.2.
Otros cuantificadores
En informtica suelen utilizarse otros cuantificadores junto con los dos anteriores, 3 y V. Estos cuantificadores pueden verse a continuacin:
N um R(i): P( i)
Mio R(i): P(i)
Max R( i): P( i)
Sum R(i): f(i)
Prod R(i): f(i)
3.3.3.
2
2
3
O+ O+ 2 + 6 = 8
1 x 4 x 9 x 16 = 576
Comprese
Lgica
que no estn ligadas son libres. (Veremos que la misma distincin entre variables libres y ligadas exist~ entre variables globales y locales. respectivamente.
cuando definamos procedimientos y funCIOnes en programacin.)
Considrese la expresin
Vi
Vi
{l,
o ,
29}: ei+l :( ei
{m ....
ni: e,
~ K
3.4.
PREDICADOS V PROGRAMAS
3.4.1.
El estado de un clculo
:~
77
:~
3.4.2.
79
Lgica
78
then vLido:=true
else vlido:=faLse;
then vlido:=false
to 30 do
then vl ido:=true;
> O
Una forma posible de comprobar esto sera escribir una largusima instruccin
condicional, asignando a la variable booleana v l ; do el valor verdadero o
falso:
:~1
ife[i]~O
if e[2] <~ O
then vLido:=false
if e[30] <~ O
then vlido:=false;
Ejercicios
3.18.
O /\ j
1 /\ k
(11)
1 /\ j
1 /\ k
82
Lgica
V-introduccin
V-eliminacin
R"",P
V R(i): P(i)
V R(i): P(i)
3-eliminacin
3-introduccin
V R(i): P(i)
- 3 R(i): - P(i)
3 R(i): P(i)
-V R(i): - P(i)
Supongamos que se quiere demostrar que todos los enteros pares mayores
que 2 no son primos. En este caso, R es el predicado:
i no un entero
1\
(i
> 2) 1\ i es par
y P es el predicado:
i no es primo
induccin tiene tambin una relacin muy estrecha con el concepto matemtico
de funciones recursivas (como se vio en el Captulo 2) y una gran aplicacin en la
resolucin de problemas y en programacin (vase Captulo 5).
Para demostrar la validez del predicado VR(n): P(n) en el caso especial en que
R(n) tiene la forma n E {l, 2, ... }, podemos considerar dos casos por separado.
Caso base: Demostracin de P(l).
Paso de induccin: Demostracin de P(i)
=;.
P(i
+ 1) para todo
i ;. 1.
83
P(l)
P(l)
=;.
P(2)
=;.
P(2)
P(3)
Combinando las dos primeras lneas es posible concluir, utilizando modus poque P(2) es vlido. Combinando la veracidad de P(2) con la tercera lnea, es
de nuevo posible concluir que P(3) es verdadero. Es pol;ible continuar de esta
forma indefinidamente hasta demostrar que Vi E {l, 2, ... }: P(n) es vlido.
nens,
Ejemplo 3.30.
"
j~1 j
n(n
+ 1)
84
n(n + 1)
RHS
I)((i
1)
1)
+1
j=l
1)
(i
Propiedad de
1)
r'
1 -
rl1+1
= --;---
1 -
1 -
(3.5)
+
+
(i
Suponiendo
1)
1)
2(i
+
1)((i
1)
1)
1)
r'
i(i
1)
Aritmtica
Aritmtica
,+1
LHS
A primera vista, puede parecer que la induccin matemtica es una forma circular de razonamiento. Sin embargo, lo que est realizndose es, en alguna medida,
un razonamiento hipottico. Lo que decimos es Supongamos que P(n) es
cierto. Podemos deducir de ello que P(n + 1) tambin lo es?. Esto no demuestra la validez de P(n + 1), sino slo que P(n) implica P(n + 1). Considrese de
nuevo la analoga con la ascensin de la escalinata. En realidad, lo que estamos
diciendo es Supongamos que nos encontramos en el n-simo escaln, puedo
desde aqu ir al siguiente?. Esto no supone afirmar que sepamos llegar al
n-simo escaln, sino que estando en l somos capaces de alcanzar el n + l-simo.
Es la combinacin de las capacidades de saltar de uno al siguiente, y la de
alcanzar el primer escaln (es decir, probar P(I)), lo que permite alcanzar el nsimo.
Comencemos con n
,+1
r' +
rn+ 1
i=O
RHS
1 1
1
1 -
i=O
Ejemplo 3.31.
1, para r # 1
i=O
j= 1
2
(i
1, para r # O
,+1
j= 1
i(i
-=-;:
i(i
1 -
,.0
r'
85
i=O
LHS
j= 1
Lgica
r'
,11+ 1
rn+ 1
,11+2
i=O
Ejemplo 3.32. Supongamos que S es un conjunto finito que tiene n elementos. Demostrar mediante induccin que S tiene 2' subconjuntos.
Solucin. Denotemos por P(S) la coleccin de subconjuntos de S. Supongamos que n = O. Entonces, S = <p. Por tanto, P(S) = {<P} y S tiene 1 (= 2)
subconjuntos. Este es el caso base para la prueba inductiva.
Supongamos ahora que cualquier conjunto S de n elementos tiene 2'
subconjuntos. Para probar el paso de induccin, sea T un conjunto arbitrario con n + 1 elementos.
Los subconjuntos de T pueden dividirse en dos grupos -aquellos que incluyen a t'+1 y los que no-o Cada subconjunto {tI> ~2' ... , t,} es tambin un
subconjunto de T. Por tanto, por hiptesis de la induccin 2' subconjuntos
de Tno incluyen a t,+I' Cada subconjunto que incluye t'+1 puede considerarse como la unin de un subconjunto de {tI> t 2, ... , t,} con {t,+ 1}' Luego
existen 2' subconjuntos que incluyen t,+I' Por tanto, existen 2' + 2' = 2 x
x 2' = 2' + 1 subconjuntos.
86
Lgica
Incluyendo t n + ,
</>
{tn+ d
{ti' tn+d
{td
{t2}
{t"t 2 }
{t" 't 2 ,
3.26.
{t 2 , tn + ,}
{ti' .t 2 , t n+,}
. ,
tn}
3,27.
2".
Obsrvese que, en contradiccin con su nombre, la demostracin por induccin implica razonamiento deductivo, en lugar de inductivo. El razonamiento
inductivo hace referencia a una tcnica habitual en la ciencia, denominada mtodo cientifieo; este mtodo consiste en inferir principios generales a partir de casos
particulares. Por ejemplo, el astrnomo Kepler utiliz el razonamiento inductivo
para inferir las leyes del movimiento planetario a partir de un voluminoso conjunto de datos experimentales que haba recogido. Sin embargo, la induccin
matemtica sigue un tpico proceso deductivo -partiendo de axiomas, teoremas
previamente demostrados define nuevos teoremas utilizando reglas de inferencia.
3,6.
(Nota:
"
U
A, significa Ao
u A, u ... u A.)
i=O
(Nota:
n"
i=O
RESUMEN
En este captulo hemos estudiado los fundamentos de la lgica, prestando especial atencin a su utilizacin en la informtica. La lgica proposicional, la equivalencia y las demostraciones se han revelado como inestimables herramientas
en la resolucin de problemas. El clculo de predicados tiene una utilizacin
directa en Pascal, en forma de expresiones booleanas. Se han introducido mtodos deductivos de demostracin, incluida la induccin, tiles para el estudio del
diseo de programas y la verificacin, que se vern en captulos posteriores.
a)
I:
i ==
b)
Ejercicios
3.24.
3.25.
Factorial (1)
1
Factorial (n) = n x Factorial (n -
N se define recursivamente de
1)
para
n > 1
(i(i
"
I:
j=O
e)
I:
i=O
-->
87
n(n
+ 1
n(n
l)(n + 2)
3
1)(2n + 1)
6
n 2 (n + 1)'
4
90
4.1.
ALGORITMOS V PROBLEMAS
Definicin.
En la vida cotidiana encontramos muchos problemas algortmicos, tanto dentro como fuera del campo altamente especializado de la informtica, Por ejemplo, una determinada receta para preparar pollo a la cazadora constituye un
algoritmo, mientras que el problema general de preparar pollo a la cazadora es
el problema algoi'tmico asociado. En la Tabla 4.1 se presentan algunos ejemplos comunes de algoritmos y de problemas algortmicos.
Tabla 4,1,
Algoritmo
Problema algoritmico
Tejer un jersey.
91
tiempo. Sin embargo, la ejecucin de todos los algoritmos debe terminar. Por
ello, cualquier descripcin paso a paso de un proceso que no termine no es un
algoritmo. Por ejemplo, el proceso de escribir todos los nmeros ent~ros positIvos, uno a uno, no es un algontmo, puesto que no terminara nunca.
En la informtica se asocia la nocin de algoritmo con la de un proceso
que debe ser ejecutado por una computadora, en lugar de por una persona. En
pnnclplO, cualqUIer algontmo que diseemos para una computadora puede ser
reahzado a mano (supomendoque disponemos del tiempo necesario, una pizarra o sufiCIente papel). En reahdad, encargamos a la computadora la ejecucin
de los pasos que componen un algoritmo, porque es capaz de completarlo en
un tIempo mucho menor del que nosotros emplearamos, y porque es menos
prochve a cometer errores que nosotros.
Sin embargo, no todos los algoritmos pueden ser ejecutados por computadoras. Las c?~putadoras slo pueden ejecutar algoritmos que se componen de
aC,clOnes mdlvlduales que pueden entender y realizar. Por ejemplo, la preparaclon de pollo a la cazadora implica acciones como encender el horno o
deshuesar el pollo, tareas para las que una computadora est bastante mal
preparada, Por tanto, es necesario conocer bien cules son las tareas que puede
f<;ahzar una computadora, de forma que diseemos algoritmos que contengan
solo ese tIpo de tareas,
Como punto de partida, considrese el sencillo modelo computacional de la
Figura 4.1.
L-_EN_T_R_A_D_A~~---+'I
Figura 4,1,
PROCESO
~---+'I
SALIDA
92
Paso
Paso
Paso
Paso
Paso
Cuando se escriben este tipo de descripciones de procesos, se realizan algunas suposiciones tcitas sobre el comportamiento del m?d~lo entrada-procesosalida de la Figura 4.1. La primera hiptesis es que el numero de cahficaclOnes
es indeterminado, aunque nunca infinito. La segunda hiptesis. es que p~ra
poder calcular cualquier cosa sobre las calificaciones, el algontmo necesita
obtenerlas primero --es decir, trasladarlas fisicamente a la parte proceso del
modelo, desde la parte entrada del mismo.
Cuando se utiliza una computadora en la resolucin de este problema
algortmico, las instrucciones que contienen los pasos individuales, junto con
los valores numricos de Sum, n y CM se almacenan fislcamente en un lugar
llamado memoria, que se encuentra unido a la unidad central de procesamiento
(CPU o procesador) de la computadora. Toda la informacin de entrada o
salida se encuentra fisicamente separada del procesador en dispositiVOS como
el tecl~do el monitor o un archivo en disquete. Un diagrama de las unidades
de una co~putadora que se corresponde con el modelo entrada-proceso-salida
puede verse en la Figura 4.2.
Teclado/Ratn
Figura 4.2.
Procesador/
Memoria
93
Ejercicio
4.1.
4.2.
Describir un problema algortmico que nos encontremos en la vida diaria, similar a los discutidos en la Seccin 4.1. Dar dos algoritmos alternativos para solucionar el problema.
4.2.1.
94
{post entrada =01\ sa Lida = una descripcin de todas las salidas que
pueden darse para cada entrada}
Si denotamos por Notas, la primera calificacin de la lista, por Notas la
2
segunda, y as sucesivamente, la descripcin siguiente es una descripcin precisa del problema de la calificacin media, en forma de precondicin y poscondicin:
n > O 1\
1\
n> O
Paso S. Mostrar CM
sta) ~;:c;:;
proceso
Especificaciolles
Figura 4.3.
4.2.2.
{pre: entrada = (Notas" Notasz, . "' Notas n )
Vi E {1, ... , n} :Notas, E {O, ... , 4}}
{post: entrada ~0A
salida ~ Sum i E {1, ... , n}:Notas;!n)
95
100
B~
Entrada
Qntegy
RadLi sta
Lengtt::hlista
Poslista
101
:----~~
Inserli sta
L; st~
DeleteLista
nombrelista [indiceJ
Salida
I+----
C--Rea';"i)
ReadLista (Notas);
(3 2 1 3)
102
del elemento devuelto. As, por ejemplo, un caso posible podra ser que LenghtLista (Notas) devuelva el valor integer 4, y Notas[3] devuelva el
valor real 1. Una discusin ms completa de las operaciones sobre Lis ta
mostradas en la Figura 4.7, puede encontrarse en el manual de laboratono. Es
conveniente repasar esta discusin antes de construir programas que utilicen
listas.
Limitaciones del conjunto de caracteres ASCII. Cuando se~ ncorporan asertos
y otros comentarios dentro del texto de un programa, es ne~esario recordar las
limitaciones del conjunto de caracteres ASCII, que es el estandar de los caracteres que se pueden codificar y que utilizan la mayora de los constructores de
computadoras. (ASCII es un acrnimo de American Standard Code for Infor
mation Interchange)* Utilizando un conjunto de caracteres estndar, es pOSI
ble la transferencia de informacin entre computadoras diferentes. (Como entre
Macintosh y PCs de IBM, por ejemplo). La lista completa de caracteres ASCII
y su codificacin se incluye en el Apndice A.
.
.
Los cientficos suelen utilizar letras griegas y otros slmbolos especiales,
subndices, superndices, al escribir expresiones lgicas y matemticas o al
escribir asertos. En el problema de CM se utilizaron, por ejemplo, Notas" 0
y ~ estilo matemtico, continuando con la notacin convencional de los Captulos 2 y 3. Desgraciadamente, esos caracteres no pueden aparecer dentro de
un programa Pascal, por no estar incluidos dentro del conjunto de caracteres
ASCII. Por ello, cuando convertimos un algoritmo en un programa Pascal,
utilizamos un convenio de sustitucin ASCII para la sustitucin de los smbolos
ms comunes, como el de la Tabla 4.2.
Tabla 4.2. Sustitutos ASCII para los smbolos matemticos
Smbolo
matemtico
Notas i
o}; o Sum
,;;
V
3
/\
V
E
Sustituto
ASCII
Significado
4.3.2.
1.
2.
Ambas razones para la existencia de bucles se pueden comprender si analizamos la situacin siguiente: Supongamos que es necesario disear un algoritmo
que calcule S como la suma de seis calificaciones, dadas por las variables 91 a
96. Una forma de calcularlo sera realizando la declaracin y secuencia de
instrucciones Pascal siguiente:
var 91, 92, 93, 94, 95, 96: real;
vaco
S
S
S
S
S
S
S
G=
para todo
existe
/\
or
in
Notas[i]
Sum
103
:~
:~
:~
:~
:~
:~
:~
O;
S + 91;
S + 92;
S + 93;
S + 94;
S + 95;
S + 96;
Esta alternativa es absolutamente torpe. Si tuviramos q~e extender el problema mnimamente, y necesitsemos sumar 100 calificaciones, la eleccin realiza.'
da sera bastante poco brillante.
Bastante ms dificil, e incluso bordeando lo imposible, sera extender el
algoritmo para el caso en que el nmero de calificaciones fuera impredecible
(aunque finito); por ejemplo, n. Naturalmente, el valor de n no puede predecirse
104
105
S := O;
; := 1;
S:~S+g[i];
;:=;+1;
S
:~S+g[i];
;:=;+1;
S
:~S+g[i];
;:=1+1;
S:~S+g[i];
;:=1+1;
l.
2.
S:~
S:~
S + g[4];
S + g[5];
S + g[6];
Su- i
S:~S+g[i];
;:=;+1;
S:~S+g[i];
;:=1+1:
Figura 4.8.
begin
5;5; ... ;5
end
Figura 4,9, Forma general de la instruccin whi le: b es una expresin booleana; s; s; ... ; s es cualquier secuencia de instrucciones en Pascal.
S:~S+g[i];
;:=;+1:
:s
106
Instrucciones de inicializacin
whi Le b do
begin
5;5; ... ;5
end;
begin
; := i
+1
1 <~ i <~n+ 1)
Para demostrar que esto es, sin duda, el invariante del bucle, debemos
comprobar que cada valor de i durante la ejecucin del bucle:
1.
2.
S:~S+g[i];
end
107
ESlado
iteracin
Sum
""
~ Sum j ; n (1,
A1<~1<~5
Sum
.. ,,1}: Notas[j]
Sum
... ,
... ,
3
4
~ Sum j ; n (1,
A1<~2<~5
Sum ~ Sum j ; n (1,
A1<~3<~5
Sum j ; n (1,
A1<~4<~5
Sum
O): Notas[j]
2}: Notas[j]
3}: Notas[j]
A1<~5<~5
,
Puesto que la quinta iteracin no tiene lugar (se produce la salida del whi le,
puesto que i <= n cambia a falso), el invariante conduce al cumplimiento de la
poscondicin al salir del bucle. Esto es,
Sum ~ Su. j in {1, .. "
i - 1): Notas[j]
1 <~ i <~ n + 1
108
109
Listas;
va.
Notas: Li stas;
i, n : integer
y el invariante
Sum~
Su. j
Sum, CM : real;
begin
<~
<~n+
2.
En general, los bucles no tienen que hacer ni ms ni menos que esto -todo lo
dems es irrelevante.
ReadLista (Notas);
I);
n := longLista(Notas)
ifn>Othen
begin
Sum := O;
i := 1;
whi le i <= n do
begin
Sum := Sum + Notas[; J;
; := ; + 1
end;
CM := Sum/n
4.3.3.
2.
3.
La computadora.
La gente que disea y lee el programa.
La gente que verifica la correccin del programa.
end
end. {CalculaCM}
= 1,
CM : 5 : 2)
112
{post: SumPa res = La suma de todos los elementos de L con i n.di c~ par !\
SumImpar = la suma de todos los elementos de L con sub; nd, ce lmpar}
4.8. Escribir las instrucciones de Pascal que calculen el promedio de las si~te
temperaturas de la lista del Ejercicio 4.4, asignando el valor a la vanable TemProm. Dar las precondlclOnes y postcondlclOnes de esas lllStruCciones, as como el invariante del bucle controlado que conhenen.
temper~
turas de la lista del Ejercicio 4.4, que estn por debajo de ,,:alor medIO
(TemProm) y dejen este valor en la variable ~ntera ndebaJ~. Escnblr
la precondicin y la poscondicin para esas lllstrucclOn~s.' aSI como. el
invariante del bucle que contienen. Estn esas precondlclOnes relacIOnadas con las poscondiciones del Ejercicio 4.8? Qu sU?lere esto .sobr~
el orden en que esos dos grupos de instrucciones debenan escnblfse SI
las ussemos para resolver el Ejercicio 4.4c?
4.10. Qu mostrara el siguiente fragmento de programa?:
var x, y: real;
m, n, p: integer;
begin
readln (x, m);
read (y);
read (n, p);
wri te (n, x);
writeln (p);
writeln (y, m);
end.
4.4.1.
(a;<O v a =0
b;<O)
(Post: result=a b }
ab
if b
=aa ... a~
=~
if b > O
if b < O
Lb-a es
MS PROBLEMAS ALGORTMICOS
Clculo de ah
Desarrollemosb un programa llamado Potenci a que calcule la b-sima potencia de a, o a , donde a y b son enteros y el resultado un nmero real. Por
ejemplo,3 escrito como una funcin de Pascal Potencia(2,3) calculara el
valor 2 = 8..
En la construccin de una solucin, debemos precisar previamente no slo
el resultado esperado, sino tambin el rango de enteros para los que el programa est bien definido; es decir, sus precondiciones. En particular, debemos
especificar que ciertas parejas de valores de a y b, tales como a = O Y b = - 1,
deben ser excluidas, puesto que podran conducirnos a errores computacionales. (En este caso, Potenci a (O, 1) representara 0- 1 1/0, que representa
una divisin con resultado indefinido). Tambin debemos tener en cuenta las
limitaciones del lenguaje de programacin en el que expresamos el algoritmo.
Por ejemplo, muchas versiones de Pascal restringen el rango de valores de los
15
enteros al rango - 2 ... 2 15 - 1. Si identificamos estos valores con Mi nlnt y
Maxlnt, respectivamente, entonces las precondiciones de Potenc i a pueden
descartar todos aquellos valores de a o b que conduzcan un resultado que
exceda a Mi nlnt o Maxlnt. Por ejemplo, a = 2 Y b = 16 daran como
resultado 2 '6 , que sera un valor mayor que Maxlnt para muchas versiones
Pascal.
Teniendo presentes estas condiciones, las precondiciones y poscondiciones
siguiente podran ser apropiadas para disear el programa de la potencia.
13.215
23.7
2365 75
35 46 79
4.4.
113
114
2.
3.
Este ejemplo nos sugiere nuevas ideas sobre la naturaleza del invariante del
bucle. Esto es, de la ; -sima iteracin del bucle, donde 1 .::; ; .::; b, el valor de P
viene dado por
{ ; nv: P = a'
1 <= ; <= b}
ClcuLo de a b
2
3
4
P
P
P
P
P
P
P
P
P
P
:= a
:= a;
:= P *
:= a;
:= P *
:= P *
:= 8;
:= P *
:= P *
:= P *
progra. Potencia;
{Este programa calcula la b-sima potencia de a}
var P: real;
a, b, i: integer;
begin
Valor de b
115
P := 1
else
begin
P := ai
Poscondicin
{P
a}
; nv:
{P=a*a}
do
i := ; + 1
end;
a;
a
a;
a;
a
; := 1;
while i <= abs(bl - 1
i f b < O then
P := 1/P
end;
WriteLnC'PotenciaCa,b) =',P);
{P=a *a *a *a}
Entonces, si utilizamos la variable; para controlar el nmero de iteraciones del bucle, tomar todos los valores del rango de enteros comprendidos
entre 1 y b - 1, para que el clculo de P sea correcto. Estas consideraciones
nos conducen al programa Pascal comentado, que se muestra en la Figura 4.14.
Quin comprueba las precondiciones? Cuando observamos la solucin a algn problema algortmico, tales como el de la Potenc ; a o el de la CM,
es normal preguntarse: de quin es responsabilidad comprobar el cumplimiento de las precondiciones?, del programa o del usuario del programa?
Nos gustara tener algn tipo de garanta operativa de que ninguna entrada
diferente de aquellas para las que fue diseado el programa se producir y
tendremos as garantizado que no se nos contaminar ni peligrar la integridad del programa.
Consideremos el programa Potenci a, para el que la precondicin establece que, para algunos valores de a y b, el resultado a b puede estar fuera del
conjunto de valores enteros que la computadora puede reconocer. Desgraciadamente, esta precondicin del programa Potenc ; a no puede ser comprobada explcitamente por el propio programa, puesto que la accin de calcular a b
{post: entrada
end. {PoteRe; a}
vacio
1\
salida = a b }
Estrategia 2. Disear el programa de forma que compruebe todas aquellas precondiciones que sea posible comprobar, sin provocar una termi-
116
4.4.2.
Los tipos numricos; nteger y rea l se utilizan en casi todos los problemas
algortmicos, Sin embargo, un gran nmero de problemas no se resolvera
adecuadamente con slo esos dos tipos. Muchos problemas involucran a cadenas de caracteres ASCII, como datos, y su solucin precisa la utilizacin de un
conjunto de operaciones caractersticas de este tipo de datos, La nocin de
cadena en Pascal puede definirse de la forma siguiente:
Definicin. U na cadena es una secuencia finita de cero o ms caracteres
ASCII. Cuando se escribe una cadena en un programa Pascal, se encierra
entre comillas simples ( I ) para distinguirla de las instrucciones del programa que la rodean.
,.
En la Figura 4.1 hemos visto ejemplos de cadenas, Por ejemplo, todos los
mensajes como:
117
Length
Pos
Figura 4.15.
;=
* N. del T.: Algunas implementaciones de Pascal incluyen entre los tipos incorporados el
tipo string. Por ello, cuando nos refiramos al concepto seguiremos hablando de cadenas de
caracteres y utilizaremos la palabra string cuando hablemos del tipo.
118
I Input I
'Hello World!
Length(s)
1
ReadCs);
12
poses, w)
~v:a~r~s~:~s~t~r:,~n~g~;~~~~~~~__~~~. 7
'Hello Worldl'
119
conocer.
'Mundo! '
'1 '
IOUtput I
"
Figura 4.16.
Un programa que resuelve este problema, utilizando la mayora de las funciones de la FIgura 4.16, se muestra en la Figura 4.17.
program ContadorPalabras'
, .~ 1 .
whi le'i <+ Lengh(s) - 1 do
{inv: np.alabras = palabras contadas para s[l
.
beg,n
... , - 1 J
i f (Copy (s, i, 1) <> " ) and (Copy (s, i + 1, 1) =
npa labras := npa labras + 1 .
i:=i+1;
,
ende
{npalab~as = palabras contadas en s[1 .. n + 1])
1 <~ i
1')
<~
n + 1}
then
Figura 4.17.
120
Utilizamos la expresin Copy (s, i, 1) para selecci.onar e! i -simo, carcter de s y Copy (s, i + 1, 1) para seleCCIOnar el 1 + 1-eslmo. ASI, la
expresin combinada:
(Copy(s, i, 1) <>'
1)
11)
121
4.4.3.
Aunque los tipos numricos y cadena de caracteres son la base de gran cantidad de problemas algortmicos, no sirven para caracterizar aquellos problemas
que implican la representacin de informacin grfica. Este tipo de problemas
incluye la visualizacin y anlisis de imgenes de rayos X, fotografias desde
satlites, tableros de ajedrez y otros tipos de tableros de juego, y otros tipos de
grficos utilizados habitualmente en gestin comercial y en el clculo cientfico.
Para ilustrar este tipo de problemas, consideremos el conocido juego de las
tres-en-raya. Supongamos que se nos pide que construyamos un algoritmo que
muestre los movimientos individuales del juego de las tres en raya, reflejando
cada movimiento (X o O) en un entramado rectangular de la pantalla de la
computadora.
Para poder resolver este tipo de problemas necesitamos un nuevo tipo de
datos y el correspondiente conjunto de operaciones asociadas, que permitan a
un programa dibujar y realizar transformaciones sobre un array' rectangular,
denominado entramado de celdas individuales. Cada celda puede rellenarse
de una de las cuatro formas siguientes: No (sin rellenar); S (rellena en gris); X o
O. En la Figura 4.18 se muestra un entramado de 3 x 3 celdas, las cuales
tienen valores particulares en la que las filas y columnas del entramado se han
numerado de la forma convencional. La celda de la fila 1, columna 2 es una X;
la celda en la fila 2, columna 1 es S; la celda de la fila 3, columna 3 es O; y las
seis celdas restantes son No.
El nmero de filas y columnas, as como el tamao de cada celda, se
establece en el momento en que el programa lo crea. El tamao de la celda se
mide en pixels, que son unidades grficas de la pantalla de la computadora y
que no son divisibles en unidades ms pequeas. Cada celda del entramado de
la Figura 4.18 es de 20 pixels de ancha y otros 20 de larga. El anclaje de un
entramado es la posicin en la pantalla de su esquin superior izquierda,
cuando se visualiza el entramado. La localizacin viene dada por un par de
* N. del T.: Aparece aqu por primera vez la palabra inglesa ARRAY. Como ocurriera con
string, esta palabra se ha traducido de muchas formas, en mi opinin todas ellas insatisfactorias.
Por ello prefiero, tanto en este punto como en ocurrencias posteriores. respetar el trmino ingls.
122
123
Anclaje
} Tamao de la celda
= 20 pixels
StartGrids;
Figura 4.18.
coordenadas xy, teniendo la esquina superior izquierda de la pantalla las coordenadas (O, O).
. .
. nes que pueden utilizarse para
La Figura 4.19 muestra las dlstmtas operacl~dificar el estado de sus celdas.
crear entramados de varios tamao~ ~ t:~a p~demos utilizar esas operaciones
Si declaramos una vanable de tIpo
'. bl
para realizar transformaciones sobre la vana e.
La primera de ellas borra la pantalla y crea dos ventanas, una ventana grfica a
la izquierda y una de texto a la derecha. Todos los entramados que se creen en
el programa aparecern en la ventana grfica, mientras que los textos, entradas
y salidas lo harn en la ventana de texto. Los detalles sobre esas y otras
operaciones grficas se explican extensivamente en el manual de laboratorio.
Al contrario que las variables de tipo Lista o string, las variables del tipo
Gr i d se deben crear y dibujarse en la ventana grfica antes de asignar valores
a las celdas. Por ejemplo, si queremos crear el entramado d para que tenga 3
filas y columnas, con celdas de 20 pixels y anclado en la posicin (10, 10) de la
ventana grfica, escribiremos:
MakeGrid(d, 3, 10, 10, 20);
Inexistencia I Existencia
~;;;;..--
Ce LlOn <f>ole!9>
Ce llOff
Ce llX
Ce llO
Gri d
'-.:~------
GridSize
TurnCellOn
TurnCellOff
TurnCellX
TurnCellO
(0, O)
(10, 10)
Figura 4.19.
(200,200J\
. entre tipo
.
.
os aqu el mismo convemo
y obj'eto que utilizamos entre
* N. del T.: ScgUlrem
cadena y string.
Figura 4.20.
132
problemas grandes ocupa generalmente ms de una pgina de cdigo en Pascal. Segundo, los programas largos tienen, adems de su longitud, alguna otra
caracteristica que los hace ms complejos. Tercero, las soluciones para problemas ms complicados se expresa mejor si se utiliza una sistemtica que si se
escribe directamente el cdigo que se nos ocurre. Es necesario que los primeros
pasos describan el problema y que el algoritmo resultante sea fruto de un
diseo, fruto de una sistemtica paso a paso. De hecho, en muchos casos, la
solucin a un problema grande es el resultado del trabajo de un grupo de
trabajo numeroso ms que de una sola persona.
'.
Las soluciones a los problemas grandes comparten con las de los pequeos
tres caractersticas: legibilidad, eficiencia y correccin. Legibilidad significa que
cualquiera que conozca el lenguaje Pascal y el dominio al que pertenece el
problema, es capaz de entender el problema y el programa sin ms que leer
cuidadosamente el programa y los comentarios que le acompaan, independientemente de lo largo que sea el programa o lo complejo que sea el problema. La eficiencia es deseable porque los recursos informticos son relativamente costosos, y las aplicaciones deben intentar minimizarlos. La
correccin significa que todas las ejecuciones del programa deben conducir
a resultados vlidos para cualquier entrada permitida por las especificaciones
del programa.
Estas tres caractersticas de los problemas complejos tienden a dotarlos de
una identidad dual. En un extremo, la legibilidad de los programas permite
que stos constituyan una explicacin de la solucin a problemas algortmicos
para un lector interesado. En el otro extremo, la eficiencia y fiabilidad de los
programas les permite ser un mecanismo a travs del cual la computadora
puede ser utilizada para resolver problemas. En la construccin de programas
utilizando la metodologa MAPS, siempre tendremos en mente esta doble
identidad de los programas. i El proceso de codificacin de un programa en
Pascal es slo una parte de la complicada tarea de resolver un problema
algortmico!
5.1.1.
l.
nuestro conocimiento del enunciado del problema. Escribir pre y poseo ndiciones que sean completas y consistentes. Es decir, asegurarse de que
las precondiciones cubren todas (y slo esas) las posibles entradas, que
las poscondiciones definen la salida para todas las posibles entradas, y
133
que tanto las precondiciones como las poscondiciones son interna y mutuamente conSistentes.
Etapa 3: La divisin. Subdividir, de forma sistemtica, el proceso en una
coleccin de pasos diferentes. Repetir este proceso para cada paso hasta
que la subdivisin no tenga sentido. Identificar las relaciones de control
entre los distintos pasos. Es decir, qu paso debe preceder a cul?, qu
pasos son parte de otro ms complejo?, qu pasos deben repetirse dentro de un bucle?, y asi sucesivamente. Documentar cada paso escribiendo
una breve descripcin de sus objetivos. Asignar un nombre apropiado a
cada nueva variable que incorporemos en cada paso, en funcin de cul
es su cometido.
Etapa 4: Definicin de abstracciones. Determinar cules de los pasos que
solucin, identificando rutinas nuevas y reutilizando aquellas que resulten apropiadas para realizar cada paso individual. Conectar cada paso
utilizando la estructura de control apropiada (bucles, invocaciones a procedimientos, secuencias de instrucciones, selecciones condicionales, etc.)
de una forma compatible con lo diseado en el paso 3. Respetar como
comentarios toda la informacin generada durante el paso 3 para cada
paso individual y las variables correspondientes.
Etapa 6: Prueba y verificacin. Probar o validar de forma sistemtica el
134
5.2.
1,
Algunas rutinas son tan comunes que estn incluidas en el lenguaje de programacin Pascal para utilizarlas en los programas. Estas rutinas incluyen los
operadores numricos (+, -, *, / , di v y mod); las expresiones aritmticas,
las estructuras de control (i f, whi le y for); los operadores de entrada,
salida y asignacin (read, wri te y :=) y los operadores de cadenas (copy,
pos y length). Se pueden aadir al lenguaje otras rutinas para manipular
listas (ReadL i sta, WriteL i s tal y entramados (Ma keG ri d, Gr i dSi ze y
TurnCe llOn).
Existe una gran variedad de rutinas para diferentes dominios de la resolucin de problemas. Varios de ellos se introducirn en este captulo.
5.2.1.
135
136
problema observamos que parte de nuestro viejo programa CM puede utilizarse para encontrar la solucin. iNuestra solucin de promediado acaba de
alcanzar el rango de rutina!
Pero, antes de reutilizar nuestro programa debemos convertirlo en un procedimiento o funcin equivalente; es decir, debemos aplicar los tres pasos de la
abstraccin procedimental a su definicin. Para el paso 1, la eleccin del nombre Promedi ol i sta es una buena eleccin, pues indica con claridad lo que
har la rutina. Para el paso 2a, parametrizacin de la eJ).trada y la salida,
incluimos el parmetro l, en lugar de la entrada, para simbolizar la lista de
valores de la que deseamos calcular el promedio, y el parmetro resu l tado
en lugar de la salida, indicando as que el promedio resultante se devolver al
contexto del programa en que se utilice, en lugar de visualizarse por la pantalla. Para el paso 3, generalizacin del tipo, cambiamos nuestra rutina de promediado para que trabaje sobre nmeros en un intervalo apropiado, y no slo
en el rango de O a 4 original.
Por tanto, los pasos 1 y 2 de la abstraccin procedimental del problema
CM conducen a las especificaciones revisadas siguientes:
Promediolista(L):
{pre: L= (el' el' ... , en) I\n~O" 'Vi E {1, ... , n}:: el es un nmero}
{post: n>O" resultado=Sum ; E {1, ... , n}: e/n
v n = O A resultado = O}
"
137
va.
i, n: integer;
sum: real;
begin
{pre: l= (e" e u ... ,
n:= Lenghtlista(l).
ifn>Othen
'
begin
Sum := O;
i := 1;
whi le i <= n do
begin
Sum :~ Sum
en)
n~O
'Vi
{1
)
' ... , n :: e i es un nmero}
+ L[i]'
i:=i+1
'
end;
resul tado := Surn/n
end {if)
,
etse
resul tado := O
{post: n > O A resultado = Sum "
v n = O 1\ resul tado = O}
end; {PromedioLista}
Figura 5.1.
'1
"
,n}:ei/n
f En ambas abstracciones hay que destacar algunas caractersticas. Si con;onta~os ambas con el programa original (vase Figura 4.6), a partir del cual
an SI o co~strU1da.s, podemos ver que todas las instrucciones de entrada
~a]da an SIdo su~tltU1das por referencias a los parmetros l y resultado E~
e~lr, a abstracclOn proc~dimental delega la tarea de hacer la entrada . la
~a~da al programa que utl]za la abstraccin resultante. De hecho el progrIma
e e summlstrar los. ~rgument~s apropiados para que sirvan de entrada al
Procelddlmlento,o funclOn, y debe Interpretar de forma apropiada la informacin
de sa I a que este le proporcIOne.
Podemos observar tambin que el fundamento lgico del programa ori inal se ha preservado. En el procedimiento Promediolista (Figura 51) g I
En el a
caso de I funclOn
., P rome. ,e
resultado
d'
l" se asocIa con un parmetro va r,
r ' 0..' s ta (FIgura 5.2), el resultado se asocia con el propio nombre de la
unclOn. Otras vana bIes declaradas en el programa original (Sum i
a~qU1er~n la,categora de v~riables locales dentro de la abstraccin, p~estoYq~~
a Ora solo tIenen un Interes local exclusivo para el clculo del promedio
h En la FIgura 5.2 se puede ob~ervar que el parmetro de salida resultado se
d: reefmPI~.zado por la aSlgnaclOn del promedio resuItallte al propio nombre
~ ~nc~on. -sta es la fon~a en que Pascal permite especificar el resultado
q~e ~ e evo ver ~na funclOn. En otras palabras, el procedimiento PromedlOl,.sta de la FIgura 5.1 y la funcin Promediolista de la Figura 52
son Identlcos.
'
138
var
i, n: integer;
sum: reaL;
begin
L = (el' el' ... , en) 1\ n? O /\ Vi E {1, , n}:
{1, . "' n}:: e, es un numero}
1\
O 1\
LenghtLista(l);
> O then
begin
Sum := O;
begin
:~
Pro~edioLista := Sum/n;
n ~ O 1\
"hi le ; <= n do
begin
Sum :~ Sum + L[i];
i := i + 1
Su. i
end; {PromediLista}
end {if)
else
PromedioL i sta := O
E
begin
pre: entrada = (Notas u Notas u .. , Notas n )
Vi E (1, ... , n) :Notas, E {O, ... , 4})
prograll calculaCM;
{esto es un programa que calcula la CM de una serie de una o ms
calificaciones numricas, cada una de ellas en el rango O 4,
que se introducirn por el teclado}
uses
Listas;
var
Notas: listas;
CM: real;
function Promediolista (l: lista): real;
{Esta funcin calcula la media de los valores de una lista}
uses
listas;
var
i, n: integer;
sum: rea l;
/\
n> O /\
Figura 5.3.
1"
1\
begin
Sum := O;
i := 1;
else
PromedioLista := O
{pos t: n > O /\ resu l tado
v n ~ O A resultado ~ O)
Sum + L[i];
+1
endo
.,'
,."
PromedioLista :=Sum/n;
end {it)
.,hi le ; <= n do
; := i
end;
; := 1;
Sum
139
begin
{pre: L = (e" el' .. "' en) 1\ n ~ O 1\ Vi
Vi E {1, .. , n}:: e; es un nmero}
n := Lenghtlista(l);
if n>O then
Listas;
{pre:
Vi E
n :=
if n
La revisin de la Figura 5.3 podr perfectamente haber utilizado el procedimiento en lugar de la funcin. En este caso, la instruccin
CM := Promediolista (Notas);
140
141
llamarla Sumal i sta y escribir sus especificaciones para una lista arbitraria l
'
como las SIgUientes:
5.2.2.
El programa Potenci a es otro candidato a convertirse en rutina, y podemos conve~tIrlo de programa ~ funcin con facilidad. De las especificaciones
de la SecclOn 4.4.1, la abstracclOn procedimental de Potenci a puede definirse
como en la FIgura 5.6:
Una destreza importante que se debe adquirir al resolver problemas algortmicos es la de reconocer rutinas cuando aparecen en contextos de resolucin de
problemas diferentes. Una vez identificada la rutina, puede ser abstrada con
facilidad en forma de procedimiento o funcin -ilo importante es reconocer la
rutina, no su abstraccin!
En el Captulo 4 introdujimos algoritmos para resolver el problema CM,
para calcular a b , y para contar el nmero de palabras de una cadena de texto.
Trate de identificar las rutinas que incluyen. Algunas de ellas saltan a la vista.
Por ejemplo, consideremos el clculo de la suma de los elementos de una lista
de enteros arbitraria, que est incluido dentro del programa Ca lculaCM (y
tambin dentro de Promedi ol i sta). Calcular la suma de los elementos de
una lista es seguramente una rutina, puesto que puede ser til en una gran
variedad de problemas, tales como el de calcular el balance de un libro de
contabilidad o totalizar la recaudacn obtenida en un evento deportivo.
Cmo sera el aspecto de una rutina que realice este proceso? Podramos
SumaLista(l):
{pre: L= (e 1, el' .. ".' e,,> 1\ n ~o 1\ Vi E {1, ... , n}:: e; es un nmero}
{post: result ~ Sum, E {1, ... , nJ: e;}
Figura 5.5.
Potencia(a, b):
{Pre: a y b son enteros
(Post: resultado ~ a b )
Figura 5.6.
Entrada
(3 2 1 3)
--~ 2.25
1\
(a
=1=
Ov a
O 1\ b f=- O)
J\
Minlnt ~ a b ~ Maxlnt}
Considrese tambin la posibilidad de encapsular como una rutina el programa CuentaPa labras. De las especificaciones del Captulo 4, la abstraccin
de la FIgura 5.7 resulta evidente:
CuentaPalabras(s):
{pre: : ~ 'e [1] e [2] : .. e [n]' A n >~ a A eada e [i] es un ea reter ASe ll}
{post. resultado = numero de palabras en s}
Figura 5.7.
Salida
1\
MinLista(L, m):
Figura 5.4.
Figura 5.8.
1\
144
5.2.3.
,..
Figura 5.12.
145
begin
{p~e: L = (el' e u .. "' e m ,
En el Captulo 2 vimos que las funciones matemticas pueden definirse utilizando una relacin de recurrencia, o recursivamente. Esta idea ha sido trasladada al lenguaje Pascal, de forma que ste nos permite definir funciones recursivas. El hecho de que la funcin MaxL i sta fuera originalmente concebida de
forma recursiva no es, por tanto, ninguna traba para su traslacin a una
funcin de Pascal. Es decir, podemos escribir una funcin Pascal que incluya la
relacin de recurrencia original. Este tipo de funciones de Pascal reciben el
nombre de funciones recursivas. En la Figura 5.13 puede verse una implementacin recursiva de la funcin MaxL i S tao La funcin refleja directamente la
relacin de recurrencia de la Figura 5.11.
Podemos ver que la relacin de recurrencia original se ha codificado en
Pascal utilizando una serie de instrucciones i f anidadas. El efecto de la iteracin se consigue en la tercera instruccin i f de la serie, donde los aspectos
recursivos de la funcin han sido subrayados. La funcin MaxL i sta se invoca
a s misma de forma recurrente, con los argumentos L y m - 1. As se activan
una serie completa de invocaciones a MaxL i sta, para poder determinar:
,.
MaxLi sta := O;
;:-:
1\
resultado
j v
end;
Figura 5.13.
Para ilustrar la semntica (el significado) de las funciones recursivas, supongamos que se invoca a la funcin con MaxL i sta (L, 4), siendo L = (2 5
4 3 8 6). La secuencia de eventos que se producen en el proceso de clculo
para calcular el resultado (que es el ndice 2), se muestra en la Tabla 5.1.
Tabla 5.1.
Invocacin
de
MaxLista
1
2
3
4
4
3
2
1
Sublista
de L
Clculo de MaxLista(L, 4)
Invocacin
activa
(2 5 4 3)
2
(2 54)
3
(2 5)
4
(2)
ninguno
Comparacin
em >MaxLista(L,m-1)
3> MaxLista(L, 3)
4> MaxLista(L, 2)
5> MaxLista(L, 1 )
ninguno
Devuelve
el re-
sultado
2
2
2
1
Cada invocac!?n sucesiva a MaxL i s ta, comenzando por la primera, realiza una comparaclOn entre e m y el valor mximo de la sublista que contiene un
elemento menos, hasta que se realiza una invocacin para la que la longitud de
la lIsta es 1. (En este caso, esto ocurre en la cuarta invocacin). En ese momento se devuelve el resultado, que confirma que e, es siempre el mximo valor de
la list~ de longitud 1. El resultado se pasa a la invocacin 3, por lo que
M~xL, sta comp~ra los valores de e, Y e,. Puesto que , es mayor, la invocaClOn 3 devuelve el mdlce 2 a la llamada 2. La invocacin 2 compara los valores
de e, Y e 3 , determmando que e, es mayor, por lo que pasa a la invocacin 1 el
ndice 2. Aqu se realiza finalmente la comparacin e. > e" devolvindose el
valor 2 al programa que invoc la funcin.
Una forma grfica de ver el proceso de recursin es dibujando una estruc-
146
5.2.4.
2~ ' ) MaxLista(L, 4)
(0
2~')MaXList(L,3)
(0
2~')MaXList(L, 2)
.
0"
1~
MaxList<L,n
o
Figura 5.14. Estructura de la invocacin recursiva de MaxLista(L, 4).
El nmero de la invocacin est dentro de un crculo; las flechas
descendentes simbolizan argumentos y las ascendentes resultados.
147
En el manu~l de laboratorio puede encontrarse una discusin ms detallada sobre esos tIpoS y otros de Pascal igualmente tiles, junto con sus rutinas
relaCIOnadas. Las definiciones siguientes de algunas de estas rutinas estn escritas ~~ el ya famIlIar estilo de definicin procedimental que se introdujo en la
SecclOn 5.2.1.
ReadL ista(L):
{pre: .entrada = Ce 1 , e u :.", en) cua.lquier secuencia 1\ n ~ O}
{post. entrada = cualquler secuenCla J\ L = (e" e u .. "' en)}
L[ i 1 :
{pre: L = Ce 1 , ez' .. "' en) 1\ 1 ~ i .:;;:; n}
{post: el es un nmero 1\ resultado = el v e i no es un nmero
resultado
O}
WritelnCs" Su . . , sn):
{pre: entrada = cualquier secuencia 1\ Vi E {1, .. "' n}:
o una cadena}
{post: sal ida = cualquier secuencia s l ' s 2 " ' "
. s}
n
Si
1\
es un nmero
poses, t):
{pre: t = 't" tz, ... , tn' 1\ 5= '51' Su . , S .. ' 1\ n ~ O}
{~ost: 5= t j t 1+1... ti+II_1 (1:0;;;; ;:0;;;; i + m - 1:0;;;; n) es la ocurrencia ms a la
lzqulerda de s en t 1\ resultado = i v s no est en t 1\ resultado = O}
Aqu, la nocin cua lqu; er secuenc; a asociada a las rutinas ReadLi s ta y Wr ite l n significan, literalmente, cualquier secuencia de valores de
entrada o salida existentes en el momento en que las rutinas son ejecutadas. En
el c~so de ReadL~sta, l~ notacin entrada = (e" e" .. , en) cualqUler secuencla, slgmfica que existe una lista al principio de la secuencia
de entrad~, segUIda de una secuencia arbitraria de otros posibles valores (que
pue~e no Inc1.U1r mng~no). La utilizacin de cualquier secuencia en la especificaClOn de Wr1 teln, slgmfica que coloca la salida a la cola de todas las salidas
que se hayan generado antes de la ejecucin de la instruccin writeln.
5.2.5.
Sabemos ya que es importante para su reutilizacin la identificacin y encapsulamIento de rutmas. Tambin debemos ejercitarnos en ser cuidadosos cuando seleccionamos tipos de datos y estructuras para diferentes problemas con
los que estamos familiarizados.
. Hemo~ trabajado ya con los tipos numricos bsicos (rea le; nteger), el
lIpa strlng y con los IIpos Llsta y Array, que se 'utilizan para definir
estructuras lIneales sImples. Sabemos, por la experiencia adquirida, que las
operacIOnes par~ el lIpa rea l tambin pueden aplicarse, aunque con algunas
restncclOnes, al 1 nteger. Sabemos tambin que rutinas con nombre similares
para los tipos L; s t a y s t r; ng, tienen significados similares. Por ejemplo, la
rutma Pos (s, t), que devuelve la posicin donde aparece por primera vez la
148
(donde s simboliza una variable cadena) son inco~~ectas. Del mismo .modo,
podemos leer y almacenar en una lista una colecclOn completa de numeros
reales tanto de un archivo externo como desde el teclado, utIhzando la operacin ReadL i sta. Sin embargo, no podemos hacer lo mismo si queremos leer
y almacenar una coleccin de cadenas. Podemos utilizar un a r r a y en 1ugar de
una lista para almacenar una coleccin de cadenas, pero carecemos de la
flexibilidad para leerlas y almacenarlas si no inventamos y construimos las
rutinas que tengan la capacidad funcional de ReadL i sta .. Estas diferencias
estn resumidas en la Figura 5.15, que muestra, en una especie de diagrama de
Venn, el solapamiento funcional que existe entre arrays y listas. El mensaje bsico de estos prrafos es que ninguna estructura de dato~ ofre~e todas
las ventajas de otra sin acarrear algunas desventajas. Esta sltuaclOn es tIplca en
la informtica; los profesionales de la informtica se refieren a ella como el
compromiso y las consecuencias de tomar una decisin .
El tipo cadena es el ms bsico de los tipos construidos con valores elementales, puesto que puede contener cualquier nmero de caracteres separados por
blancos u otros caracteres ASCII no imprimibles (caracteres de control tales
como saltos de lnea y tabuladores). As, cualquier carcter es una cadena' pero
no cualqUier cadena es un carcter; por ejemplo, el carcter a es una c;dena
pero la cadena :epe no ~s un carcter. Continuando con esta lnea de razona~
miento, cada. dlgllo n~menco es. un carcter, pero un carcter individual no
tiene por que ser un dlglto numenco. Por ejemplo, el dgito 3 es un carcter
pero el carcter x no es dgito numrico. Igualmente, si colocamos un nmer;
e~tre comil!as simples tendremos una cadena, pero no toda cadena es un
numero. ASI, '3.5' es una cadena, pero' Ivn' no es un nmero.
5.2.6.
camin RET
3 RET
ki lmet ros RET
hasta RET
el RET
colegio RET
a RET
una RET
velocidad RET
Figura 5.15.
149
de RET
2,5 RET
ki lmetros RET
por RET
hora RET
RET
150
Es posible declarar el tipo de array siguiente, y una variable del mismo que
permite almacenar cada palabra del texto:
type palabra ~ string[16];
ListaStrings ~ array[1 100] 01 palabra;
var Frase: listaStrings;
LongitudFrase: integer;
Apalabra: palabra;
'
De forma anloga, es posible implementar inserciones, eliminaciones y bsquedas de palabras aisladas utilizando abstracciones procedurales. De esta forma,
podemos manipular listas de palabras de la misma forma que manipulamos
listas de reaLes, posibilidad que es de gran utilidad en gran cantidad de
aplicaciones.
5.2.7.
1.
151
O si la coercin
,.
l""
j;1
lo,
152
b)
Por tanto, si queremos tratar el i-simo elemento de una lista L como un entero,
debemos convertirlo explcitamente utilizando una de las rutinas round o
trunco Por ejemplo, la instruccin siguiente asigna la parte entera (ignorando
la parte decimal) del i -simo elemento de L a la variable in tege r j.
153
progra .. fn;
var
k: integer
function nd (m: integer): integer;
var
n: integer;
begin
:~
truncCL[i]);
nd := O;
n := m"
while'n >= 1 do
begin
n:=ndiv10;
nd
end
:~
nd
+1
end"
begin'
whi le not eof do
begin
re~dln (k);
wrlteln ('ans
= "
nd(k
end
end.
L = (Enero 2,5
Mayo 2,1
Junio 1,3
Novi embre 0,3
Di ei embre 2,2
Jul io 5,9
Marzo 0,3
Abril 5,7
Agosto 1,0
Octubre 0,0)
5.3.
,.,..
1
tnangulo. ConstrUIr una funcin que devuelva t rue si A By C
, s o n os
lados de un tringulo rectngulo.
>'
,..
"
1
Ejercicios
5.1.
5.5. ~n qu condiciones puede convertirse un procedimiento en una fun~lOn e~uRIvalente? En qu condiciones puede realizarse la operacin
Inversa.
azonar la respuesta.
~mp~m~n~ar como un procedimiento de Pascal la abstraccin Con.a r a a ra (s) de la Figura 5.7. Comprobar su integridad reutili~an~~lal P4ar(a. resoh:er el programa original que contaba palabras del
apI u o
vease FIgura 4.17).
3.
5.19.
5.3.
157
156
Ya estamos en condiciones de utilizar nuestro mtodo de resolucin de problemas (MAPS) y utilizarlo en un caso concreto, desde el principio hasta el final.
Durante todo el proceso enfatizaremos la importacia de identificar y reutilizar
rutinas en una forma creativa. Una de las caractersticas destacables de MAPS
es que no slo sirve como gua en la resolucin de problemas particulares, sino
que en este proceso se van creando rutinas que el programador podr reutilizar en la resolucin de otros problemas ms complejos.
5.3.1.
El dilogo
4.
ENTRADA
ESTADISTICAS PLUVIOMETRICAS
(Enero 2,5
Febrero 4,4
Marzo 0,3
Abril 5,7
Mayo 2,1
Junio 1,3
Julio 5,9
Agosto 1,0
Septiembre 6,0
Octubre 0,0
Novi embre 0,3
Diciembre 2,2)
med; a = 2,64
mxima = 6,0
minima = 0,0
Meses por debajo de la med; a:
Enero
Marzo
Mayo
Junio
Agosto
Octubre
Noviembre
Diciembre
Mes(es) mxima:
Septiembre
Figura 5.16.
158
(Enero, Febrero
Marzo, Abr l
Mayo, Junio
(2.5 4.4
0.3 5.7
2.1 1.3
2.5 4.4
0.3 5.7
2.1 1.3
,.-
5.9 1.0
6.0 0.0
5.9 1.0
6.0 0.0
0.3 2.2)
0.3 2.2)
b)
a)
5.3.3.
5.3.2.
Las especificaciones
{m,: e;
1~j~12} }
159
La particin
162
5.4.
163
ReadL i S ta para el paso 1.2. Podemos combinar dos rutinas, Promedi 0Li sta y WriteLn para resolver el paso 2.1 (el clculo del promedio y la
visualizacin del resultado son dos acciones separadas, y por tanto deben
realizarlas rutinas diferentes). De forma similar, podemos combinar las rutinas
MaxL i s ta y WriteLn para el paso 2.2, y las rutinas Mi nL i sta y Wri teLn
para el paso 2.3.
Ni el paso 3 ni el 4 parecen resolubles mediante la aplicacin directa ni la
combinacin de rutinas. No hemos visto hasta ahora ninguna rutina que resuelva directamente problemas como ste, y tenemos que crear una solucin
nueva para cada uno de los casos. Sin embargo, en la mayora de las situaciones
de resolucin de problemas algortmicos, los diseadores de software emplean
ms tiempo combinando o reutilizando rutinas que crendolas nuevas desde el
principio. Es decir, el proceso de resolucin de problemas algortmicos tiende a
cumplir la regla 90 por 100 de transpiracin y 10 por 100 de inspiracin.
Apliquemos la transpiracin (Seccin 5.4.1) y la inspiracin (Seccin 5.4.2).
5.4.1.
Reutilizacin de rutinas
Como hemos dividido suficientemente el problema original, de forma que podemos tratar cada parte de forma independiente, debemos explorar la presencia de rutinas conocidas o viejas entre los pasos individuales. Por cierto,
algunas rutinas que son conocidas para unos resolutores de problemas, son
desconocidas para otros. Por ello, no debe descorazonarse si desconoce algunas rutinas con las que otros parecen estar muy familiarizados. Estamos aprendiendo un lenguaje nuevo, y nuestro vocabulario crecer con la experiencia.
Existen cuatro mecanismos que podemos utilizar para adaptar o reutilizar
rutinas ya existentes para propsitos nuevos: empalmndolas, anidndolas,
adaptndolas y mezclndolas.
Empalmado. Es el mtodo ms sencillo de crear rutinas nuevas. Si RI Y R2
son dos rutinas ya existentes, el empalmado de ambas crea una rutina nueva R,
que se compone de RI seguida secuencialmente de R2. Por ejemplo, en el
problema de la pluviometra. Las cuatro rutinas (pasos del 1 al 4) son empalmadas para formar una rutina nueva como es la solucin al problema. De la
misma forma, las rutinas PromedioLista y WriteLn se empalman para
construir la solucin al paso 2.1, como se ilustra en la Figura 5.21.
Anidamiento. Tambin se puede construir una rutina nueva anidando una
rutina R 1 ya existente de otra R2. El anidamiento se produce cuando utilizamos una rutina como argumento de la invocacin a un procedimiento, o
cuando la colocamos dentro de una instruccin condicional o dentro de un
bucle. Esto se ilustra en la figura 5.22, donde el clculo del promedio de
pluviometra, ha sido anidado dentro del propio proceso de visualizacin del
E. SOLOWA y: Learning to program: Learning to construct mechanisms and explanaCommunicarions of the ACM (septiembre 1986),29(9): 850.
tions~~,
164
165
if (O<m) and
Rl
(m<~
LengthLista(L
then
begin
Rl
PluviometraProm:= PromedioListaepluviometrias)
R2
WriteLnC 'media
j :~ 1
for k : = 2 to m do
ifjL~!]~\L[j]_
then
_
R
=
1, PluviometriaProm}
1.-:
end
else
j := O;
Figura 5.21.
R2
WriteLn( 'media =
Rll
1,
promedioListaePluviometrias>!
Figura 5.22.
~XL ; sta
:=y
~ ~nLista ::J:>
Figura 5.23.
------@
Rl
Adaptacin. Es posible crear una rutina nueva R adaptando otra Rl ya existente. Es decir, el propsito original de Rl puede ser ligeramente modificado,
generalizado o particularizado de forma que realice la funcin requerida por R.
Supongamos que adaptamos la rutina MaxL i sta (que encuentra la posicin
que ocupa el elemento mximo de una lista) para utilizarla como una rutina
Mi nL i sta (que encuentra la posicin que ocupa el elemento mnimo de una
lista). Qu necesitamos modificar en rutina MaxL i sta de forma que cumpla
las especificaciones de Mi n Li s t a? Es casi evidente que es necesario realizar
unas modificaciones mnimas, y el resultado se obtiene mucho ms rpida y
fcilmente que si la construyramos de cero. Las modificaciones se resumen en
la Figura 5.23.
if (O < m) and (m
begin
Mezcla. Se puede construir una rutina nueva R mediante la mezcla o entrelazamiento de los pasos individuales de otras Rl y R2 ya existentes. Esto se
muestra de forma abitracta en la Figura 5.24, donde se han mezclado los pasos
de la rutina MaxL i sta con los de la Mi nL i s ta, para obtener una nueva que
obtiene el valor mximo y mnimo en una nica pasada (bucle for) por la
lista, en lugar de dos.
Obsrvese que, en la Figura 5.24, hemos alterado la sintaxis y renombrado
algunas de las variables de las rutinas Ma xLi s t a y Mi n Lis t a originales, con
objeto de que la nueva rutina MaxMi nL i s ta devuelva dos valores en lugar de
uno. En una implementacin completa, la cabecera podra ser:
else
<~
LengthLista(L
then
Max := 1;
R2
IMin:-1;
for k
:~
begin
2 to m do
end
end
begin
Max := O;
I Min :=0
end;
Figura 5.24.
"
166
,.'
5.4.2.
'
En los casos en los que no existe ninguna rutina dsponible, debemos emplear
nuestra creatividad para construir las abstracciones procedimentales apropiadas. En el problema de la pluviometra tenemos que utilizar nuestra creatividad para encontrar una solucin a los pasos 3, que debe escribir los meses
cuya pluviometra est por debajo de la media, y el 4, que debe mostrar el(los)
mes(es) cuya pluviometra es la mxima.
Aparentemente, ambos pasos requieren utilizar el mismo tipo de estrategia
-una bsqueda dentro de la lista de pluviometras para encontrar los valores
que cumplen una determinada propiedad-o El ndice de la lista P l uv i ometri apuede utilizarse para encontrar el nombre del mes correspondiente, en el
array Meses. Considerando el ejemplo de entrada de la Figura 5.17b, el promedio de lecturas pluviomtricas de esta entrada es de 2,64 ltsfm 2 . El valor
pluviomtrico para Pluvi omet r i a [1] es 2,5, que se encuentra por debajo
de la media. Por tanto, el paso 3 debe mostrar el valor de Meses[1] o Enero
como una de las salidas. Para encontrar todos los meses que satisfacen la
misma condicin, es necesario explorar los doce valores pluviomtricos. Esto
se consigue con el bucle siguiente:
l'
"
"
!:::
1:, '
"
11" .' . .
'
167
fo~ i := 1 to LengthLista(Pluv;ometrias) do
1f Pluviometrias[i] = MaxPluviometra then
WriteLn(' " Mes(es)[i]>;
9ue resuelva el
5.4.3.
y'" x)
168
1
1,5
1,41667
1,41422
(1 + 2)/2 = 1,5
(1,5 + 1,33333)/2 = 1,41667
(1,41176 + 1,41667)/2 = 1,41422
Existe una forma alternativa de calcular races cuadradas que nos permite
esquivar el necesario conocimiento del dominio que supone el mtodo de Newton. Sin embargo, esta alternativa nos obliga a conocer el dominio de las caractersticas ms avanzadas de las bibliotecas de funciones estndar de Pascal.
En concreto, Pascal incorpora las funciones exp(x) y ln(x) que calculan las funciones eX y el logaritmo neperiano de x, respectivamente. Combinando esta informacin con los conocimientos adquiridos en el Captulo 2, podemos obtener:
b In (a)
In (ah)
e1n(a)
= a
1/2 In x
XI/2
el/2 In (x)
exp (1/2 In x)
ln(x
5.5.
Vo~viendo al caso de estudio, nos 9uedan por aplicar tres pasos de la metodologIa MAPS propuesta: codlficacIOn, verificacin y prueba, y presentacin.
}2 por el mtodo
Clculo de y'
2/1 = 2
2/1,5 = 1,33333
2/1,41667 = 1,41176
o bien:
y := exp<O,5
x/y
169
y + x/y
2
Estimacin (y)
5.5.1.
Codificacin
En pocas, palabras, la codificacin es la traslacin de la solucin de un proble~a algont~ico a un p~og~ama, junto con su documentacin, En la resolucin
e un pro ema. algontmlCo, la mayora del cdigo se obtiene durante las
~~~as de partlcIOn y abstraccin. Por ejemplo, hemos completado la codificade lo~ pasos 3 y 4, del problema de la pluviometra, en la bs ueda de
nu~vas rutmas qu~ sean apropiadas para ellos. Tambin los pasos l ~ 2 estn
prac~.camednte c<;,dlficados; sabemos que pueden implementarse reutilizando y
com man o rutmas de otros problemas ya existentes,
El proceso de, codificacin implica el juntar las partes de la solucin al
problema,. asegurandonos de que el resultad? conjunto es coherente, inteli ible, yl satIsface
las
, .pre
. .y poscondlcIOnes onginales . C uan d o co d'fi
l lcamos gen
P
l
asca sue e ser utll utlhzar una plantilla como la siguiente:
program <nombre>;
{Breve
que describa el problema ' l a estructura general de
lcomentario
'6
l
a so UCl n, el autor y la fecha}
uses <Bi b l ; atecas de las que se toma rn algunas rut ; nas>.,
<.D,eclaracin de las variables identificadas en el proceso de partiClan>
begin
{pre: <Precondicin del problema>}
{Paso 1. <Descripcin del primer paso de la partic:jn>}
{Paso 2. <Descripcin del segundo paso de la particin}
{post: <Poscondi ci ones de l problema>}
end.
170
, .
f in de problemas, algoritmos Y programas
Computacin l. Log/ca, reso uc
,0. '.
program Pluviometrias;
tersticas pluviomtricas
{El programa calcula algunas ca.rac_ d r' Allen Tucker, 30 de marzo
a partir de datos mensuale~. Dlsen~.Ot~ MinLista Y PromedioLista.}
de 1990. Reutiliza las rutl~as Ma.x lS ,
uses L1 s tas , HerramientasLlstas,
type NombreMeses = array [ 1 .. 12] 01 string[10];
var Meses: NombreMeses;
PLuviometrias: Lista;
PLuviometriaProm: reaL;
MaxPluviometra: real;
MinPluviometria: real;
begin
e ) 1\ Vi E {1, ... , 12} e; es el vaLor
{pre: entrada = (e l l .e '1.! : .. , 1'1. d lao}
pLuviomtrico deL l-eSlmo mes e
{Paso 1. Inicializar lista de meses Y pluviometrias}
{Paso 2. Mostrar pLuviometria prome d'la, ma'ximayminima}
{Paso 3. Mostrar meses por debajo del promedio}
171
duzca los datos correctamente. Lo que hay que hacer se refleja en el esquema
del paso 1 siguiente:
{Paso 1. Inicializar lista de meses y pluviometrias}
InicializarMeses(Meses);
WriteLn(IIntroducir la lista de los 12 valores pluviomtricos mensuales: 1);
ReadLista(pluviometrias);
Es posible comprobar que se introduce exactamente una lista de doce elementos con las instrucciones:
repeat
WriteLn('introducir la lista de Los 12 valores pluviomtricos
mensuaLes: I};
ReadLista(pluviometras};
until LengthLista(Pluviometras} = 12;
El cdigo de los pasos 2 a 4 se ha completado en el programa de la Figura 5.27. Obsrvese que se ha omitido el cuerpo del procedimiento 1 n; c; al;za rMeses, que se deja como ejercicio.
5.5.2.
Prueba y verificacin
Mes(es) max,ma:
{mj: ej=Max 1
end.
Figura 5.26.
{1
"
12}' e.
.
. . d I s asas de entrada de datos, es necesaPara completar la codlficacIOn e. o p
. s para que el usuario introrio que el programa emita los mensajes necesartO
5.5.3.
Presentacin
Cuando la solucin a un problema algortmico ha sido desarrollada completamente, el programa debe ser suficientemente autodocumentado, para cuando
172
sea ledo por alguien no familiarizado con la solucin obtenida, pero s con la
t dologa y el dominio al que pertenece el problema. Es decir, el texto ~~I
n:~ rama --con su documentacin, estructura paso a paso, y pre y posc'.JU 1~io;es- debe ser fcilmente legible por un colega profesIOnal, como lo sena un
artculo del ABe para cualquier persona bIen educada.
, .
La presentacin de una solucin completa de un problema al~or~tmlc~
debe incluir, adems del propio texto del programa, los elementos sIgUIentes.
,.'
,"
WriteLn('Meses[i]);
{Paso 4. Mostrar mes(es) con pluviometria ms alta.}
Writeln( 'Mes(es) mxima:')
tor i := 1 to LengthLi sta(Pluviometrias) do
if Pluviometras[i] = MaxPluviometria then
WriteLn(' " Meses[iJ);
'
1.
program Pluv,iometras;
. '
.
{El programa calcula algunas caracteristlcas Pluvlom tncas
a artir de datos mensuales. Diseador: Allen Tucker, 30 de. ma~zo
d:1990. Reutiliza las rutinas MaxLsta, MinLista Y PromedloLlsta.}
uses Listas, HerramientasListas;
begin
. {1
12) e es el valor
{pre: entrada = (el'.e u : .. , e u ) 1\ Vl_E
, ... ,
i
pluviomtrico del l-slmo mes del ano}
{Paso 1. Inicializar lista de meses Y pluviometras}
InicializarMeses(Meses)
.
.
WriteLn('lntroducir la lista de los 12 valores pluvlom tncos
mensuales:');
ReadLista(Pluviometras);
{Paso 2. Mostrar pluviometra promedio, ~xima y mnima}
WriteLn('ESTADISTICAS PLUVIOMETRICAS
pluviometriaProm := PromedioLista(Pluvlometrias);
WriteLn(' media = " PluviometraProm:5:2);
.
._
MaxPluviometria :=MaxLista(Pluviometras, LengthLlsta(PluvlOme
)?
trias;
, 5 2)
WriteLn(' mxima = " MaxPluviometrla::;
.
.
MinPluviometra :=MinLista(Pluviometras, LengthLlsta(PluvlOmetrias
.
)
WriteLn( I mnima = " MinPluviometrla:5:2
173
~0
Figura 5,27,
5,6,
RESUMEN
En el Captulo 4 introdujimos las tcnicas y herramientas bsicas para construir programas sencillos en Pascal a partir de sus especificaciones. En este
captulo hemos aprendido cmo analizar un problema y a desarrollar su solucin, identificando elementos del programa ms pequeos (rutinas) y combinndolas todas en un programa completo.
Aprendimos algo del proceso de abstraccin y de su realizacin en Pascal.
La creacin de rutinas que puedan ser reutilizadas, es una de las tareas fundamentales del proceso de resolucin de problemas algortmicos. Podemos reutilizar rutinas y recombinarlas en cuatro formas fundamentales --empalmndolas, anidndolas, adaptndolas y mezclndolas durante el proceso de creacin
de una solucin a un problema nuevo. Fuera de estos lmites, es preciso utilizar
la creatividad y el conocimiento del dominio. Los 0\fos aspectos de la resolucin de problemas algortmicos son evidentes en la metodologa MAPS --el
dilogo, la especificacin, la particin, definicin de abstracciones, codificacin,
verificacin y prueba, y presentacin.
Pero entender no es lo mismo que hacer. Antes de proseguir con el libro,
tmese algn tiempo para disear y escribir programas para los problemas
178
6.1.
CORRECCiN V ROBUSTEZ
,"
.'.." ,
Definicin. Un programa es correcto si. para cualquier entrada que satisfaga la precondicin. termina generando una salida que satisface sus poscondiciones. De forma anloga. un procedimiento (o funcin) es correcto si.
para todos los posibles valores de los parmetros de entrada que satisfacen
las precondiciones. termina Y. adems. los parmetros de salida (resultados)
satisfacen las poscondiciones.
Por ejemplo, el programa que calcula la calificacin media Ca lculaCM. del
Captulo 4. es correcto en este sentido. Es decir. para todas las entradas del
tipo (Notas!, Notas 2 ..... Notas,). donde n > O Y cada Notas; es un nmero en
el intervalo {O, ... , 4} el programa calcula y escribe la calificacin media y
termina. A continuacin, se demuestran algunas entradas y sus correspondientes salidas. para diferentes ejecuciones del programa.
Entrada
(3124)
(2)
(2 3 3 3 3 3 3 2)
179
begin
..
Salida
2,50
2,00
2,75
Un estudio cuidadoso del programa de la Figura 4.6 hace que nos planteemos algunas dudas sobre lo que ocurre cuando las entradas no satisfacen las
especificaciones de las precondiciones. Por ejemplo. qu ocurre si la entrada
es la lista vaca( )? Qu ocurre si la lista de entrada contiene valores fuera del
intervalo {O, .... 4}. como la lista de pluviometras mensuales utilizadas en la
Figura 5.17b, utilizadas para un problema completamente distinto? Qu ocurre si la lista contiene algo distinto de nmeros. como la lista de los doce
nombres de meses de la Figura 5.17a?
Una posible alternativa para responder a esas preguntas es correr el programa con varias entradas alternativas que no satisfacen las precondiciones. y
ver qu ocurre en cada caso. Observemos el cuerpo del programa Ca lculaCM
y analicemos cmo tratar cada uno de los distintos casos (vase Figura 6.1).
Este es un programa tan sencillo que resulta conveniente un anlisis tan
directo. En el caso en que la lista de entrada est vaca. no se satisface la
condicin n > O. por lo que el programa no genera ninguna salida. Sin embargo, en el caso en que los valores de la entrada no estn en el intervalo {O..... 4}.
el programa calcula sin problemas el promedio y escribe (errneamente) el
valor de la CM, aunque algunas entradas numricas no sean calificaciones
vlidas. segn las especificaciones.
1\
n > OA
ifn>Othen
begin
{entrada =0/\ n>O}
{Paso 3. Calculamos Sum = la suma de las calificaciones de la lista}
Sum := O;
; := 1;
whi le ; <= n do
begin
Sum := Sum + Notas[i]:
; := ; + 1
end
end;
{Paso 40 Calculamos CM ~ Sum/n)
CM
Sum/n;
{Sum ~ Su. ;
CM ~ Sum/n)
end {;t)
{post: entrada ~0A
sal;da ~ Sum; E (1,
end. {CalculaCM)
Figura 6.1.
= 1,
CM; 5 : 2)
n): NotasJn)
180
la referencia a Notas [3] devuelve el valor para esta lista en concreto, por
lo que el valor promedio es, por tanto, 1,50.
Tenemos que destacar, por tanto, que el programa Ca l cu laCM es correcto
en el sentido de la definicin anterior. Sin embargo, no es robusto.
,." "
"~O
l" .
Definicin. Se dice que un programa es robusto si rene las dos condiciones siguientes:
1.
2.
Es correcto.
Para todas las entradas que no satisfacen las precondiciones, el
programa termina y produce una salida que refleja el hecho de que
ha ocurrido un error en la entrada.
entradavlida := false;
end;
i f not ent radav l ; da then
WriteLn(lEntrada no vlida. Programa terminado!)
else begin
181
2.
Es correcto.
Para todas las entradas que no se ajusten a las precondiciones, el
programa indica el tipo de error de entrada y concede al usuario la
oportunidad de corregirlo y continuar.
Cmo podemos convertir el programa Ca lcu laCM en un programa amigable? Podemos revisar el paso 1 en la forma siguiente:
{Paso 1. Obtenemos la lista de calificaciones}
repeat
WriteLn('Introducir la lista de calificaciones:');
ReadLista(Notas);
n := LengthLista(Notas);
if ListError or (n = O) then
entradavlida :=false
else
begin
entradavlida!= true;
for i : = 1 to n do
i f Notas[i] < O) oc (Notas[i] > 4) then
entradavl ida := false;
end;
until entradavlida;
196
a)
b)
Ejercicio
6.6.
a)
6.4.
b)
e)
La metodologa de resolucin de problemas MAPS proporciona una estructura que, si se manipula cuidadosamente, puede conducirnos a la obtencin de
programas robustos ~programas que no slo funcionan bien para entradas
correctas, sino que tambin se comportan elegantemente para un amplio
197
6.4.1.
198
. d onos d e que~ en
aseguran
. cada caso, el resultado del procedimiento es consist te con sus poscondlclones.
.
. d'
en Puesto que es Imp
. osible
probar (odo.' los pOSibles valores
de' entra .d,cut.u
ten,
. T
os que seleccionar un subconjunto de ellos que sea slgm Icatlvo, y eJe. '
~rel~o ram~ e imprimir el resultado con cada uno de los elementos de ese
~u~COl~junto. Una forma bastante til de rcallzar este proceso ~s c~nstrlllr,.~n
. ro rama ('onductor. Se denomina as porque, hter~~mente. gU1~ la ,eJ.cc~~I~ln
~ i~presin de resultados del procedimiento o funclOn con. los v,tlores seleccIOnados para la prueba.
.
.
l. f
."
Ilustremos estas ideas construyendo un .luego de pruebas pa;a . ,1 un~1( n
MaxL i sta (vase Figura 5.12). Cul seria un conJunto de pru~b~s dPro~Jadol
..
un. conductor
pard estudJar e
para esta funClon,
y ca. mo. podemos dIsear
"
.<,
comport'lmiento de MaxL, sta frente a estos datos..
. .'
Los i~cgos de prueba pueden crecer rpid~lInente. Consl~~rc~l.~lS :1 nUl~~~ o
tot'\1 d~ posibles entradas vlidas quc podnamos construll pal ,\ 11.1 funelon
Ma~L i sta utilizando O l ms elementos. Supongamos que cada c omento es
, elrango
'
un entero en
--?" d. I 2" - 1, habrn?- I h ='(' 65.536 dlIStas diferentes
1 ""nt)O
de un solo elemento. El nmero de posibles listas dl,erentc.' , e 11 ee~~ (~
resulta astronmico ----seguramente excesIvo para tnclUlllds en un Juego de
pruebas.
.
l'Istas que PUC(I'n
ser P'\S'\
Pensemos un momento sobre algunas poslhles
t:,
.. , < das a M'axL i s tao y a lo que esperamos que MaxL i sta produzca como respuesta. En la Tabla 6.1 se ofrecen algunas eJemplos ohvlOs.
Tabla 6.2
Resultado esperado
(3 1 2 8)
(8 1 2 3)
(3 8 1 2)
(-12 -3 -8)
program conductor;
{Este programa conductor prueba el procedimiento <p(x, y}
{uti l ; zando un juego de pruebas como datos de ent rada}
{del archivo <archivo juego pruebas>}
(3 1 2 8)
begin
Parmetros de entrada L
procedure <p(x, y;
(3 1 2 8)
(3 1 2 8)
end
Los dos primcros datos dc pruebas son il~porlanlcs ~orqllc el valor l~~x~~~~
ocupa la ltima y primera posicin de la lIsta. re~p~ctlvamcntc. :1 l~n.;~~ ~~~~s
tambin es importante. pucs represcnta el caso llplCO que puede OCUfllI
-
199
begin
WriteLn( 'Comienza la prueba del procedimiento <p(x, yI);
readarchivo juego pruebas, <x;
while not eofarchivo juego pruebas
do
200
begin
end;
d' .
( ) ')
WriteLn(IFinal de la prueba deL proce lmlento <p x, y>
end.
201
va,. L: Lista;
m, j: integer;
Figura 6.10.
4
4
4
4
3
2
1
4
O
juegopruebasmax: text;
begin
Wr; teLn( I Comienza la prueba de la funcin MaxLi sta(L, m)')
WriteLn( 'Introduci r el nombre del archivo del juego de pruebas!
ReadLista(L);
while not eof(juegopruebasmax) do
begin
WriteLn('Lista de entrada L =1); Writelista(L);
Write(lntroducir valor de m: '}; ReadLn(m);
j := MaxLista(L, m);
WriteLn('Resultadode MaxLista(L, m) = " j);
ReadLista(L);
1);
end;
WriteLn('Final de la prueba de la funcin MaxLista(L, m)
end.
La salida que produce este conductor cuando se le suministra el archivo j uegopruebasmax se muestra en la Figura 6.11.
Comienza la prueba de la funcin MaxLista(L, m)
Introducir el nombre del archivo del juego de pruebas:
milista
Lista de entrada L =
(3 1 2 8)
MaxLista := j;
(post: n > O 1\ Vi E {1, .""' n}: e j ~ e i
n = O 1\ resul tado = O}
end;
.
1\
resultado
1v
Introducir valor de m: 4
Resultado de MaxLista(L, m) = 4
Lista de entrada L=
(8 1 2 3)
Introducir valor de m: 4
ResuLtado de MaxLista(L, m) = 1
Lista de entrada L =
()
Introducir valor de m: O
Resultado de MaxLista(L, m) = O
Final de la prueba de la funcin MaxLista(L,
m)
Como puede verse, la construccin y utilizacin de un conductor de pruebas es casi un proceso mecnico. Sin em bargo, cuando se utiliza con cuidado,
no slo nos permite descubrir errores ocultos, sino 'Iue nos sugiere formas de
conseguir que el programa sea ms robusto y amigable. Utilizar el procesamiento con un juego de datos desconocido puede conducirnos a resultados
sorprendentes! Sin embargo, es preferible realizar esos descubrimientos en el
momento de la prueba, que no despus. cuando se ha entregado el procedimiento a una persona desconocida para cualquier utilizacin.
202
.,~ ~
,,0,
l'! "
, !'
'.,
"
:1
progra. calculaCM
uses
Listas;
var
Notas: Li stas;
i, n: integer
Sum, CM: reaL;
entradavlida: Boolean;
begin
repeat
{pre: entrada
(Notas" Notas u
AV; E {1, " . , n}: Notas; E {O,
repeat.
WriteLn (lIntroduc1r la lista
ReadLista(Notas);
n := LongL i sta (Notas);
entradavl ida := true;
for i := 1 to n do
if not isNumeric(Notas[i] or
entradavlida := false;
until entradavlida;
if n>Othen
begin
Sum :~O:
i := 1;
while i <= n do
begin
Sum := Sum + Notas[;];
=
N t
... , o aSn
" . , 4})
1\
n > O
.
,)
de calificac10nes: ;
.
) h
Notas[1] < O) or (Notas[i] > 4 ten
203
i := ; + 1
end
6.4.2.
,.,"
CM = Sum/n
WriteLn('LaCMdeesascalificacioneses=',CM
end {; f}
{post entrada =0/\
salida = Sum ; E {1, ... , n}:Notas;ln}
untiln=O
end.
Figura 6.12.
6.5.
2)
6.5.1.
Tableau de demostracin
Para verificar un programa, desarrollamos una prueba del lab/eau. Un comienzo de prueba del tab/eau, o tab/eau vaco, es un listado del programa con sus
precondiciones, poscondiciones y comentarios vacos antes y despus de cada
216
Ahora tendremos que demostrar por, induccin, que tras una ejecucin de
todo el cuerpo del bucle, se garantiza que:
5um
SU" j
{1, ... , ;
1}: j
1\
1 <= ;
<= 6
donde ; ' = ; + 1.
.
.
Podemos hacer esto examinando el efecto de las mstrucclones sobre el
invariante original. Es decir, una simple ejecucin de la instruccin sum : =
sum + 1 conduce a
sum ~ ; + Su.
~ Su .. j E
~ Su", j E
~ Su .. j E
<= 6
6.5.6.
Las tcnicas que se han introducido en este captul<;> ~eciben. habituallll:ent~ ,el
nombre de tcnicas de verificacin formal. Como es faclllmagmar, la aphcaclOn
de las tcnicas de verificacin formal a un programa razonablemente largo se
convierte rpidamente en algo inabarcable. Adicionalmente, existe una amplia
gama de problemas de programacin para los que no se h~n d~~arrollado
suficientemente las tcnicas de verificacin. El proceso de venficaclOn form~l
de programas est todava en la infancia -:-hace falta hacer mucho todavla
para que pueda utilizarse como una herramIenta que garanttce la robustez de
los programas.
.
Sin embargo, existen diferentes niveles de granulandad de programas, en
los que se puede aplicar las tcnicas de verificacin de programas. El proceso
de la verificacin informal parece aportar medIOs de argumentar, de forma
convincente sobre la correccin de los programas, eVItando muchos de los
inconvenientes de la demostracin lnea-a-lnea de los mtodos formales. Este
proceso es similar al que se sigue en Matemticas, en la demostracin, de un
teorema, o en una simplificacin algebraica, tal como se VIO en el CapItulo 3.
Es decir cuando simplificamos una expresin algebraica, no solemos enumerar
todos lds pasos que se siguen ni su justificacin formal en trminos de propie-
217
dades algebraicas bsicas (asociatividad, conmutatividd, etc.). En su lugar solemos saltarnos los pasos que son evidentes para el lector concentrndono~ slo
en aquellos esenciales y dificiles de comprender.
'
E,ste es el caso de l~ verificacin informal. En lugar de construir una demostr~clOn completa medIante una prueba tableau, nos centramos en los aspectos
mas complejOS del programa, y argumentamos en castellano sobre la forma en
que esa~ partes complejas satisfacen las especificaciones. As las nociones de
precondlcin, poscondicin e invariante juegan an un papel esencial en este
pr?ceso, pero las argumentaciones sobre la correccin del programa se realizan
mas mformalmente.
6.6.
RESUMEN
cI<;>n de la estrategIa de resolucin de problemas MAPS, ilustrando su utilizaclon en la resolucin de un problema de tratamiento de textos, y otro grfico.
Hemos present~?o y desarrollado dos metodologas complementarias para
~segurar la ~orrecclOn y robustez de nuestros programas: prueba y verificacin.
Estas permIten desarrollar. buenos programas, aun a los ms escpticos, si
tte~en una mentahdad posItIva. Es evidente que tendremos que realizar un
anahsls acttvo de n,uestros propios diseos y los programas que resultan a
medIda que sean mas complejos los problemas que queremos resolver.
. El metodo de prueba que se ha estudiado en este captulo aporta herramIentas que nos permiten adquirir una mayor confianza sobre la correccin de
los programas. Aunque el proceso de prueba no garantiza la inexistencia de
errores, nos ayuda a adquirir confianza en la validez de nuestras soluciones. La
prueba es uno de los fundamentos pragmticos en el campo de la garantizacin de la calidad del software.
Cuando es posible aplicar los mtodos de verificacin estudiados en este
captul~, garantizan la ausen~ia de errores. A su vez, inciden en la importancia
de la loglca para la mformat~ca. Es decir, l~s principios de la lgica y las
demostr~cl.ones que se mtroduJer?n en el CapItulo 3, son la base notacional y
metodologl~a para la combmaclOn de precondiciones y poscondiciones en la
especlficaclOn de problemas, con las reglas de inferencia en la verificacin de
pr~gramas. Sin embargo, la verificacin tiene limitaciones prcticas, y es necesano que,las conozcamos bIen cuando tengamos que decidirnos entre prueba o
venflcaclOn de programas. En el Volumen TI de esta serie, veremos tcnicas de