FT

Introducci
on a la Programaci
on
Gerardo M. Sarria M. - Mario Julian Mora

DR
A

Borrador de 3 de agosto de 2012

FT

DR
A

Este libro fue creado usando LATEX.

Ning
un animal fue maltratado durante el desarrollo de este escrito.
c 2012 - Gerardo M. Sarria M. y Mario Julian Mora
Copyright

FT

DR
A

Dedicado a las todas las hamburguesas y las gaseosas del mundo...

DR
A
FT

Indice de figuras
Indice de cuadros
Indice de algoritmos

FT

Indice general
7

11

13
13
14
16

2. Noci
on de Sistema
2.1. Sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2. Observaci
on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

19
19
24
27

3. Noci
on de Estado
3.1. Estado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

29
29
37

4. Noci
on de Abstracci
on
4.1. Abstracci
on de Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

39
39
52

5. Noci
on de Condici
on
5.1. Condici
on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

53
53
63

6. Noci
on de Repetici
on
6.1. Iteraci
on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2. Recursi
on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.3. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

65
65
74
83

DR
A

1. Introducci
on
1.1. Sobre este libro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2. Sobre los algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3. Para los profesores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Indice general

7. Noci
on de Abstracci
on de Datos
87
7.1. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
7.2. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
111

DR
A

FT

Bibliografa

FT

Indice de figuras
Sistema Solar . . . . . . . . . . . . . . . . . . . . . . .
Cajero electr
onico . . . . . . . . . . . . . . . . . . . .
Wiimote y consola Wii . . . . . . . . . . . . . . . . . .
Algunos sistemas y un modelo computacional de ellos

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

19
20
21
23

3.1.
3.2.
3.3.
3.4.
3.5.
3.6.

Mundo de la Tortuga . . . . . . . . . . . . . . . . . . .
Cambios de estado en el Mundo de la Tortuga . . . . .
Estado inicial y final para dibujar una persona . . . .
Problema de sacar la tortuga del laberinto . . . . . . .
Soluci
on al problema de sacar la tortuga del laberinto
Problema de llevar la tortuga donde su mama . . . . .

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

30
31
33
36
36
38

DR
A

2.1.
2.2.
2.3.
2.4.

4.1. Resultado de aplicar el algoritmo para dibujar una casa cuatro veces . . . . 43
4.2. Resultado esperado de aplicar el algoritmo para dibujar una casa cuatro veces 44

5.1.
5.2.
5.3.
5.4.

Estado inicial del problema de mayora de edad . . . . .

Los dos posibles casos del problema de mayora de edad
Flujo de ejecuci
on de la funci
on esMayorDeEdad() . . .
Tablero de tiro al blanco . . . . . . . . . . . . . . . . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

55
56
57
58

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

68
69
75
77
78
78
79
79
81
82

7.1. Juego Ahorcado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

88

6.1. Flujo de ejecuci

on de la funci
on adivinar() . .
6.2. Posiciones del juego Triqui . . . . . . . . . . . .
6.3. Fractal . . . . . . . . . . . . . . . . . . . . . . .
6.4. Flujo de ejecuci
on de la funci
on factorial(5)
6.5. Torres de Hanoi - Configuraci
on inicial . . . . .
6.6. Torres de Hanoi - Configuraci
on final . . . . . .
6.7. Torres de Hanoi - Configuraci
on intermedia 1 .
6.8. Torres de Hanoi - Configuraci
on intermedia 2 .
6.9. Torres de Hanoi - Proceso completo para n = 4
6.10. Triangulo de Sierpinski . . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

INDICE DE FIGURAS

Saludo Inicial en el juego Ahorcado

Etapas del ahorcado . . . . . . . .
Estados finales del juego ahorcado
Buscaminas en Windows 7 . . . . .
Ventana del juego de las elecciones

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

. 92
. 96
. 99
. 103
. 109

DR
A

FT

7.2.
7.3.
7.4.
7.5.
7.6.

FT

Indice de cuadros
3.1. Operaciones b
asicas en el Mundo de la Tortuga . . . . . . . . . . . . . . . .
3.2. Operaciones de colores en el Mundo de la Tortuga . . . . . . . . . . . . . .

33
37

4.1.
4.2.
4.3.
4.4.

.
.
.
.

46
48
49
50

5.1. Operaciones y constantes cl

asicas de un sistema Booleano . . . . . . . . . .
5.2. Operaciones b
asicas de un sistema de n
umeros aleatorios . . . . . . . . . . .
5.3. Operaciones b
asicas de un sistema de cadenas de texto . . . . . . . . . . . .

54
59
62

6.1. Operaciones b
asicas de entrada y salida . . . . . . . . . . . . . . . . . . . .
6.2. Operaciones b
asicas del sistema Tkinter . . . . . . . . . . . . . . . . . . . .
6.3. Operaciones para dibujar en un Canvas de Tkinter . . . . . . . . . . . . . .

69
81
84

7.1.
7.2.
7.3.
7.4.
7.5.

90
91
94
94
96

DR
A

Operaciones de posicionamiento y orientacion en el Mundo de la Tortuga

Operaciones y constantes cl
asicas de un sistema matematico . . . . . . . .
Porcentaje de notas de un curso Introduccion a la Programacion . . . . .
Operaci
on de escritura en el Mundo de la Tortuga . . . . . . . . . . . . .

Operaciones
Operaciones
Operaciones
Operaciones
Operaciones

b
asicas
b
asicas
b
asicas
b
asicas
b
asicas

del sistema de listas . . . . . . . . . . . . . . . . . . .

y algunas constantes del sistema Pygame . . . . . . .
del m
odulo de fuentes en el sistema Pygame . . . . .
del m
odulo de superficies en el sistema Pygame . . .
del m
odulo de rutas de archivos del sistema operativo

.
.
.
.
.

DR
A

FT

INDICE DE CUADROS

10

FT

Indice de algoritmos

DR
A

1.1. Carga del sistema matem

atico . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2. Carga del sistema de la Tortuga . . . . . . . . . . . . . . . . . . . . . . . . .
3.1. Dibuja una persona . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2. Sale del laberinto cuadrado . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1. Dibuja las extremidades de una persona . . . . . . . . . . . . . . . . . . . . .
4.2. Dibuja el tronco de una persona . . . . . . . . . . . . . . . . . . . . . . . . .
4.3. Dibuja la cabeza de una persona . . . . . . . . . . . . . . . . . . . . . . . . .
4.4. Dibuja completamente una persona . . . . . . . . . . . . . . . . . . . . . . .
4.5. Dibuja una casa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.6. Dibuja cuatro casas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.7. Dibuja una casa con posici
on . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.8. Dibuja cuatro casas especificando las posiciones . . . . . . . . . . . . . . . .
4.9. Dibuja la letra A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.10. Retorna la nota final del curso . . . . . . . . . . . . . . . . . . . . . . . . . .
4.11. Escribe la nota final del curso . . . . . . . . . . . . . . . . . . . . . . . . . .
4.12. Retorna la longitud de la hipotenusa de un triangulo rectangulo . . . . . . .
4.13. Retorna el da del Domingo de Pascua . . . . . . . . . . . . . . . . . . . . . .
5.1. Retorna si un n
umero es mayor o igual a 18 . . . . . . . . . . . . . . . . . . .
5.2. Retorna el puntaje dado un disparo . . . . . . . . . . . . . . . . . . . . . . .
5.3. Simula un juego de tiro al blanco . . . . . . . . . . . . . . . . . . . . . . . . .
5.4. Escribe correctamente la fecha del domingo de Pascua . . . . . . . . . . . . .
5.5. Retorna el medio de transporte para ir a un sitio de acuerdo a unas condiciones
6.1. Juego de adivinar un n
umero, sin ciclo . . . . . . . . . . . . . . . . . . . . .
6.2. Juego de adivinar un n
umero, con ciclo . . . . . . . . . . . . . . . . . . . . .
6.3. Juego de Triqui incompleto . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4. Desglose de dinero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.5. Imprime la lista de n
umero primos entre 1 y n . . . . . . . . . . . . . . . . .
6.6. Recibe lneas de c
odigo y quita los comentarios . . . . . . . . . . . . . . . . .
6.7. Halla el factorial de un n
umero n . . . . . . . . . . . . . . . . . . . . . . . .
6.8. Imprime el proceso para solucionar las torres de hanoi de n discos . . . . . .
6.9. Dibuja el tri
angulo de Sierpinski . . . . . . . . . . . . . . . . . . . . . . . . .
7.1. Juego ahorcado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

14
15
34
35
40
40
41
41
42
43
45
46
47
49
49
50
51
56
59
60
61
63
66
67
70
71
72
74
76
80
83
89

11

INDICE DE ALGORITMOS

. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
pistas .
que no
. . . . .

93
95
97
98
100
101
102
104
105
106
107

DR
A

FT

7.2. Pantalla de inicio del juego ahorcado . . . . . . . . . . . . . . . . .

7.3. Dibuja/Actualiza la pantalla principal del juego ahorcado . . . . . .
7.4. Retorna la letra que el usuario presione en el juego ahorcado . . . .
7.5. Termina el juego ahorcado . . . . . . . . . . . . . . . . . . . . . . .
7.6. Simulador de elecciones . . . . . . . . . . . . . . . . . . . . . . . . .
7.7. Retorna un candidato en el juego de elecciones . . . . . . . . . . . .
7.8. Ordena las listas de candidato y votos en el juego de elecciones . . .
7.9. Juego buscaminas . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.10. Crea y retorna una matriz de dimensiones ancho alto . . . . . . .
7.11. Llena el tablero del buscaminas con minas y pistas . . . . . . . . . .
7.12. Modificaci
on del algoritmo para llenar el tablero del buscaminas con
7.13. Funci
on que determina si se han descubierto todas las ubicaciones
tienen mina . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

12

108

FT

1 Introducci
on

DR
A

La programaci
on se ha convertido en una ciencia basica. Su importancia dentro de todas
las ingenieras se ha vuelto notoria dado que cualquiera de las corrientes de ingeniera tiene
componentes que involucran nociones de programacion: problemas que pueden ser resueltos
siguiendo una serie de pasos (noci
on de algoritmo), variables que deben ser tomadas en
cuenta al realizar observaciones, datos que deben ser procesados, e incluso el mismo uso
del computador.
En las actividades cotidianas de los adolescentes actuales tambien podemos ver nociones
de programaci
on: comprar un reproductor mp3, descargar una cancion de internet (de las
que s se pueden descargar sin romper ninguna ley) y copiarla en el reproductor, practicar
un deporte, etc. Mucho m
as en actividades mas cercanas a las profesiones de ingeniera:
construccion de una va, transporte de mercanca, inter-conectar una red de celulares,
instalar un computador/servidor con un sistema operativo como linux, entre otros.

1.1.

Sobre este libro

La mayora de libros de introducci

on a la programacion usan la metodologa de ense
nanza
de programaci
on teach-a-languague, es decir, mediante un lenguaje de programacion. Esta
metodologa presume que si el estudiante aprende un lenguaje de programacion entonces
aprende a programar. Nosotros pensamos que esta metodologa ya no es apropiada para la
actual generaci
on de estudiantes. Por esta razon proponemos una nueva metodologa y como
creemos en los metodos formales, este libro esta basado en las nociones de programacion
en vez de herramientas y lenguajes.
En este escrito usamos la idea del paradigma del paracaidista [1] utilizado en especificacion de modelos formales de sistemas. Vamos a pasar por muchas nociones, empezando
por la de sistema, la noci
on de observaci
on, la de estado, abstraccion, condicion, iteracion,
recursion, abstracci
on de datos y terminando en la nocion de persistencia. En este libro no
ense
namos como se escribe una lnea de codigo, esperamos que eso se aprenda de una manera natural. Sabemos que es necesario usar un lenguaje de programacion para practicar,
de manera que usaremos Python (como veremos en la siguiente seccion) ya que tenemos
confianza en que mejora el proceso de ense
nanza, que es el cuarto principio en un curso
inicial a la programaci
on [6]. Sin embargo, como veremos, el uso de Python no es el n
ucleo

13

1 Introducci
on

FT

1.2.

Sobre los algoritmos

Los algoritmos mostrados en este documento siguen la sintaxis del lenguaje de programaci
on Python. De esta manera si se quieren probar los programas se debe instalar el
compilador del lenguaje, que puede ser descargado gratis de la pagina web de Python
(http://www.python.org/).
Las funciones y procedimientos que se definan tendran la documentacion permitida por
el lenguaje. Esta se especifica entre comillas debajo de la declaracion de la funci
on o
procedimiento (en color verde).
Para probar los algoritmos que usan operaciones de distintos sistemas es necesario cargar
dichos sistemas. Para cargar el sistema matematico de Python (math), por ejemplo, antes
del c
odigo es necesario agregar una lnea fundamental para cargar el sistema, la cual se
puede ver en el algoritmo 1.1.

DR
A

Nocion

del libro porque las nociones de programacion son aquellas que estaran en la vida diaria
de los estudiantes por siempre.
El profesor Edsger W. Dijkstra dijo alguna vez: Las nociones son fundamentales en
toda actividad de programaci
on. Ellas son tan fundamentales que no ser
an divididas en
conceptos m
as primitivos.. Entonces para resaltarlas, las nociones de programacion podr
an
verse marcadas al lado del texto, como una nota al margen.
Los cuadros que se muestran en este documento describen solo unas cuantas operaciones
(a veces incompletas) que pueden aplicarse y que pertenecen a algunos sistemas desarrollados para Python. Sin embargo con ellos no pretendemos que los estudiantes tomen este
libro como un manual de referencia de las libreras del lenguaje, por el contrario, deseamos
que los estudiantes se motiven a consultar y estudiar mas las libreras de Python (en su
documentaci
on en lnea en http://www.python.org/doc/) de manera que sus programas
contengan mejores caractersticas. El lector que desee un libro tecnico sobre Python puede
ver [3]
o [4].

# Se carga el sistema matemtico

import math

Algoritmo 1.1: Carga del sistema matematico

Por otro lado, para ejecutar los programas en el contexto del Mundo de la Tortuga
se debe hacer tal y como se carga el sistema matematico antes de la aplicacion de cualquier operaci
on. Adicionalmente, para que el resultado de la ejecucion de los algoritmos

14

1.2 Sobre los algoritmos

sea exacto a aquellos que se muestra en este libro, se deben aplicar algunas operaciones
inmediatamente despues de la carga del sistema, que se pueden ver en el algoritmo 1.2.

FT

# Se carga el sistema Mundo de la Tortuga

import turtle
# Operacion para cambiar el titulo de la ventana
turtle.title("El Mundo de la Tortuga")
# Operacion para cambiar el tamao de la ventana
turtle.setup(500,500)
# Operacion para cambiar la forma de la Tortuga
turtle.shape("turtle")
# Operacion para reiniciar el sistema
turtle.reset()

Algoritmo 1.2: Carga del sistema de la Tortuga

DR
A

Puede notarse que para aplicar las operaciones de los sistemas es necesario anteponer
el nombre del sistema (turtle en este caso). Los sistemas que se usaran como ejemplo en
este libro se listan a continuaci
on:
turtle Sistema de la Tortuga
math Sistema matem
atico

random Sistema de n
umeros aleatorios
string Sistema de cadenas de texto

Tkinter Sistema de interfaces gr

aficas
pygame Sistema de creaci
on de juegos

os Sistema de manejo de operaciones del sistema operativo

Adicionalmente en aquellos problemas donde se tiene un estado inicial determinado, es

necesario cargar dicho estado inicial como en la segunda lnea de los algoritmos anteriores
cambiando el nombre del sistema (math y turtle, respectivamente) por el nombre del
archivo sin la extensi
on pyc. Todos los archivos deben estar guardados en la misma carpeta.
En la pagina web del libro est
an enumerados los estados iniciales de los ejemplos y ejercicios
que los requieran.

15

1 Introducci
on

1.3.

Para los profesores

FT

En [5] propusimos una metodologa para la ense

nanza de la programacion. En ella nosotros concebimos un curso de Introduccion a la Programacion como una secuencia de
sesiones de clase. Consideramos la duracion de un curso como un perodo de 16 semanas,
por lo que contamos con 32 sesiones de 2 horas. Tomamos entonces dos o mas sesiones
para cada noci
on incluyendo teora y practica (esperamos que mas practica que teora). A
continuaci
on detallamos un poco la idea que proponemos con cada nocion:
Sistema Nosotros pensamos la nocion de sistema como un conjunto de elementos interactivos en un dominio muy especfico. No hay que profundizar en la definici
on de
la palabra sino en la aplicacion del concepto. Es bueno empezar con ejemplos que
todos los estudiantes conocen como el sistema solar, el sistema digestivo y el sistema
econ
omico. Luego se puede mover a los sistemas actuales y populares (con los que
el estudiante convive diariamente) como los cajeros automaticos, la televisi
on, las
consolas de juego y los computadores, por supuesto.

DR
A

La idea en esta noci

on es mostrar que todo lo que nos rodea es un sistema y la
mayora (sino todos) de sistemas son modelables. Los programas de computador
son finalmente modelos computacionales de sistemas reales. Los estudiantes deben
identificar los elementos de los sistemas y describir sus interacciones. Es una buena idea pedir a los estudiantes que vacen sus bolsillos para encontrar una gran
cantidad de sistemas que sirven como material para la clase: iPods, celulares, tarjetas de credito, CDs,/DVDs, memorias USB, etc. Adicionalmente, en la pagina web
http://www.howstuffworks.com/ se encuentra una cantidad suficiente de artculos
de los dispositivos y sistemas recientemente nombrados los cuales pueden motivar a
los estudiantes.
Se pueden emplear dos sesiones en esta nocion.

Observaci
on Una vez los estudiantes entienden un sistema, deben ser capaces de describirlo. En este punto nos interesamos en los elementos y no en el sistema como un
todo. Siguiendo el paradigma del paracaidista bajamos un poco de manera que nos
acerquemos al sistema y podamos preguntarles a los estudiantes que es est
atico y
que cambia en el. Lo que se mantiene estatico lo llamaremos una constante y los
elementos que cambian seran llamados variables. Adicionalmente, para cada elemento detectamos los valores que puede tener. Este conjunto de valores define el tipo
de dato del elemento.
Esta noci
on no necesita mas de dos sesiones para ser entendida.

16

1.3 Para los profesores

FT

Estado Bajando un poco m

as en el sistema, se hace que los estudiantes noten que algunas veces unas variables tienen un valor y algunas veces ellas tienen otro valor. La
valuacion de todas las variables define el estado del sistema. Los estudiantes deben
identificar c
omo cambia el sistema de un estado a otro, de manera que se den cuenta
que algunas operaciones tienen que ejecutarse para cambiar los valores de las variables (y consecuentemente cambiar el estado). Aqu es donde la definicion del concepto
de algoritmo surge: la secuencia de operaciones que lleva un estado a otro.
Las operaciones que se usan aqu pueden ser descritas en notacion Python para que
los estudiantes se familiaricen con el lenguaje. En este punto las operaciones son
consideradas cajas negras con entradas y salidas. Como Python es un lenguaje de
programaci
on tipado implcito, esta caracterstica evita el ruido que incorpora la
declaraci
on de tipos de datos en los llamados a funciones.

DR
A

Motivamos a los profesores a que se armen de ayudas pedagogicas para que los estudiantes entiendan muy bien esta nocion, la cual es vital para el exito del aprendizaje.
Cambiar el modo de pensar de una persona hacia un pensamiento sistemico (i.e. pensar todo el tiempo en terminos de secuencia de pasos, algoritmos) es muy difcil. Usar
el Mundo de la Tortuga, el robot LightBot (http://armorgames.com/play/2205)
o un Lego MindStorm, son algunas alternativas.
Cuatro sesiones son una buena cantidad para esta nocion. Ademas, este es un buen
punto para hacer una primera evaluacion en el curso.

Abstracci
on Entre mas complejos se vuelven los problemas, mas largos se vuelven los
programas. De esta manera el estudiante siente la necesidad de tener una forma de
programar con menos lneas de c
odigo. As se les ense
na a organizar varias operaciones
en una sola. Las cajas negras se vuelven cajas blancas. Los estudiantes ahora pueden
construir sus propias operaciones llamando las basicas. Con las nuevas operaciones
ellos pueden construir otras y as sucesivamente. La nocion de niveles de abstraccion
llega de una manera natural.
Otras cuatro sesiones pueden usarse en esta nocion.

Condici
on Si el estado del sistema es desconocido el estudiante siente la necesidad de tener
una estructura de control para considerar varios casos. Esto hace que se introduzca la
nocion de condici
on. Sin embargo, para entender mejor el mecanismo de esta nocion
se tienen que empezar por hacer ejercicios de los fundamentos basicos de la logica
proposicional: tablas de verdad y conectivos logicos. Tal como las nociones anteriores
esto debe hacerse usando expresiones cercanas al conocimiento de los estudiantes.
Como las expresiones l
ogicas son elementos muy abstractos se deben utilizar cuatro
sesiones para esta noci
on. El final de esta nocion es otro buen punto para hacer una

17

1 Introducci
on

evaluaci
on.
Iteraci
on Aunque pensamos que la recursion es la forma mas simple de repeticion ya que no
cambia el estado de las variables, parece ser mas natural para los estudiantes aplicar
otra estructura de repeticion que si cambie las variables. Ella es llamada iteraci
on.

FT

En esta noci
on es bueno quedarse un buen tiempo (ocho sesiones) ya que las nociones
son introducidas gradualmente, y con la inclusion de una nueva nocion se contin
ua
usando y practicando las anteriores. Ademas, los estudiantes ahora tienen todas las
herramientas para solucionar la mayora de problemas. De all que al finalizar esta
noci
on se pueda hacer otra evaluacion.
Recursi
on Como dijimos arriba, nosotros creemos que la recursion es la forma basica de repetici
on en programacion. Sin embargo esta nocion puede ser muy difcil de entender.
Por esta raz
on consideramos que ella puede ser opcional.

DR
A

Nosotros simplificamos la idea considerando solo la recursion numerica y ense

nando
esta noci
on como lo que es: un llamado a funcion. Sabemos que se debe ense
nar todo
sobre el caso base y las reglas para reducir los otros casos, pero tal como las otras
nociones, debe hacerse con ejemplos de la vida real que los estudiantes conozcan, y
usando herramientas graficas.
Se podran usar dos o tres sesiones para practicar la recursion.

Abstracci
on de Datos Esta nocion viene con la necesidad de agrupar una gran cantidad
de informaci
on. Se puede pedir a los estudiantes, por ejemplo, que se calcule el promedio de todas las clases que han tomado. Si el n
umero de clases es poco entonces
no hay problema, pero si el estudiante ha tomado siete o mas clases, manejar esta
cantidad de variables es inconveniente (imagine la cantidad de variables de entrada
a las funciones).
De todas las estructuras de datos hemos escogido listas por dos razones: son estructuras de datos b
asicas y su mecanismo de uso en Python es muy comodo.
Usamos las u
ltimas ocho sesiones para esta nocion y se puede hacer la cuarta y u
ltima
evaluaci
on.

Persistencia Al igual que recursion, dejamos esta nocion como opcional ya que ella nace
de la necesidad de mantener los datos incluso despues de ejecutar los programas.
Se debe ense
nar entonces un poco sobre sistemas de archivos (sin entrar mucho en
detalle sobre los sistemas operativos) y dispositivos de almacenamiento fsico como
discos duros o memorias USB.
Aqu tambien se podran usar dos o tres sesiones.

18

2.1.

Sistema

FT

2 Noci
on de Sistema

DR
A

Un sistema es un conjunto de elementos que interact

uan en un dominio especfico y
cumplen ciertas propiedades. Dichos elementos se relacionan entre ellos y act
uan con un
proposito especfico. El resultado del comportamiento y conectividad de los elementos describe el objetivo del sistema.

Figura 2.1: Sistema Solar

Ejemplos de sistemas pueden verse en todos los ambitos. Entre los mas conocidos tenemos
el sistema solar, el sistema digestivo y el sistema economico. La figura 2.11 muestra el
sistema solar. En este sistema el conjunto de elementos esta compuesto por el Sol, los ocho
1

Imagen tomada de http://www.ifir.edu.ar/planetario/nssolar.htm/

19

Sistema

2 Noci
on de Sistema

FT

planetas, los cinco planetas enanos y otra cantidad de astros. Todos estos elementos se
relacionan entre s por medio de la gravedad del Sol, la cual ocasiona que los planetas y
astros se muevan en una
orbita casi circular sobre el denominado plano eclptico.
Existen otros m
ultiples ejemplos de sistemas que tal vez ignoramos debido a que hacen
parte de nuestra vida cotidiana y no llevan en su nombre la palabra sistema. Ejemplos de
ellos son los cajeros autom
aticos, la television, las consolas de juego y los computadores.
Los ejemplos 2.1 y 2.2 muestran algunos de estos sistemas.

DR
A

Ejemplo 2.1
La figura 2.22 muestra un ejemplo de cajero automatico. Muy a grosso modo un cajero
autom
atico es una terminal que acepta peticiones y se comunica, por medio de una red de
datos, con los computadores de un banco para atender dichas peticiones.

Figura 2.2: Cajero electronico

Los elementos que componen el cajero son: los botones, el teclado del cajero, el lector
de tarjetas, la ranura de depositos, la pantalla, el parlante, el dispensador de dinero y la
impresora de recibos.
Una de tantas interacciones que tiene un cajero electronico es la siguiente: un usuario
realiza una petici
on por intermedio de una tarjeta que es introducida al lector de tarjetas.
Algunos cajeros, una vez acepta la tarjeta, pide a traves de la pantalla y/o el parlante
2

Imagen modificada de http://www.howstuffworks.com/

20

2.1 Sistema

FT

que introduzca la clave (otros cajeros la piden justo antes de realizar la transaccion). Por
medio los botones y el teclado se introduce la clave y se selecciona los datos apropiados del
men
u para efectuar la transacci
on deseada. Si es un retiro, entonces el cajero podra proveer
el dinero por medio del dispensador o podra enviar un mensaje por la pantalla y/o el
parlante diciendo que no se pudo efectuar la operacion (falta de dinero o alguna otra razon);
si es una consulta simplemente se muestran los datos en la pantalla; y si es una consignacion
se abre la ranura de dep
ositos para entregar el dinero. Una vez termina cualquiera de las
transacciones anteriores, el cajero imprime un recibo y termina la interaccion.
? ? ?

DR
A

Ejemplo 2.2
Wii (figura 2.33 ) es una consola de juego lanzada en 2006 por la empresa de videojuegos
Nintendo. Como toda consola de juego el Wii es un computador de entretenimiento interactivo que produce una se
nal de video, la cual puede ser interpretada por un televisor o
monitor.

Figura 2.3: Wiimote y consola Wii

Al igual que un computador actual, el Wii cuenta con un procesador central, un procesador de video, 88 Mb de memoria interna, una memoria flash de 512 Mb (no cuenta con
3

Imagen tomada de http://wii.com/.

21

2 Noci
on de Sistema

FT

disco duro), tarjetas de video y sonido, y un lector de discos, entre otras cosas.
Sin embargo, el Wii es reconocido por el Wii Remote, tambien conocido como Wiimote.
Este dispositivo es el control principal de la consola. El Wiimote cuenta con un sistema de
detecci
on de movimiento en el espacio que permite manipular objetos en la pantalla, un
apuntador
optico y una serie de botones para interactuar con el usuario.
El funcionamiento del Wii es relativamente sencillo ya que la clave de la consola de
Nintendo se centra en el control. El sistema cuenta con un barra llamada sensor bar que
emite luz infraroja y que es detectada por el Wiimote. De esta manera el sistema determina
la posici
on y orientaci
on relativa en 3D del control. El Wiimote se conecta a la consola
usando Bluetooth (la tecnologa abierta para el intercambio de datos entre dispositivos
electr
onicos en distancias cortas). Este dise
no permite a los usuarios controlar los juegos
usando movimientos corporales y las presiones de botones tradicionales.
? ? ?

DR
A

Incluso si dejamos a un lado la electronica, podemos ver ejemplos de sistemas mucho

m
as simples como por ejemplo un banco (sin la parte automatizada), una sala de cine, un
club social, una biblioteca, un telefono y una tienda de m
usica. Todos estos son sistemas
y en cada uno de ellos se pueden identificar sus elementos e interacciones. De esta manera
podemos construir modelos de dichos sistemas.
Un modelo es la representacion de un objeto o sistema. Los modelos pueden ser fsicos
(e.g. un carro de juguete que represente un carro real) o no fsicos (e.g. una ecuaci
on
matem
atica que represente el movimiento del carro), pero todos tienen en com
un que
sirven para hacer simulaciones y probar propiedades en los sistemas.
Existe un tipo de modelo no fsico llamado modelo computacional. Este es un modelo
abstracto que se desarrolla en computadores y es denominado com
unmente como programa.
En la actualidad es muy frecuente el uso de dispositivos computacionales como PCs, iPads
y Blackberrys. Todos ellos pueden ejecutar programas que sirven para una tarea especfica.
Sin embargo, si se mira bien dichos programas, puede verse que son representaciones de
sistemas reales. El lector que este familiarizado con programas como Skype, puede notar
que son modelos de un sistema telefonico; aquel que este familiarizado con iTunes, podr
a ver
que es un modelo de una tienda de m
usica; Kindle es un modelo de una biblioteca; Windows
Media Player es un modelo de una sala de cine; y Facebook es un modelo de un club social.
En la figura 2.44 pueden verse otros ejemplos de sistemas reales y un modelo computacional
de cada uno de ellos.

Modelo

Programa

Im
agenes tomadas de http://recursos.cnice.mec.es/biosfera/alumno/1ESO/planeta_habitado/
index.htm (Tierra), http://www.olympiaph.com.ph/crm/typewriters.html (m
aquina de escribir), y
http://www.revivesoundproductions.com/djseminar.html (dj)

22

FT

2.1 Sistema

DR
A

(a) La Tierra y Google Earth

(b) Una M
aquina de Escribir y MSWord

(c) Un DJ y VirtualDJ

Figura 2.4: Algunos sistemas y un modelo computacional de ellos

23

2 Noci
on de Sistema

2.2.

Ejemplo 2.3
Las siguientes tablas listan las constantes y variables de los sistemas: una sala de cine, una
tienda de barrio y un rompecabezas.

DR
A

Variable

Al conocer los sistemas, existen muchas propiedades y caractersticas interesantes que

podemos observar de ellos. Las descripciones que hagamos de los sistemas nos permiten
identificar los aspectos est
aticos y dinamicos de ellos. Si tomamos un carro, por ejemplo,
y observamos detenidamente sus caractersticas, podemos encontrar que algunas de ellas
cambian a traves del tiempo, mientras que otras se quedan estaticas: la velocidad cambia, el
kilometraje cambia, el nivel de gasolina cambia, el estado del motor (encendido o apagado)
cambia y su posici
on geogr
afica cambia, mientras que la placa se mantiene, el color del
carro se mantiene (en terminos generales) y la forma se mantiene (si no se choca). Muchas
otras cosas del carro cambian y muchas otras se mantienen igual a traves del tiempo, sin
embargo, en primera instancia, estas son las mas notorias.
Aquellas caractersticas que se mantienen igual en un sistema son llamadas constantes.
Las constantes tienen un papel muy importante en los sistemas dado que estan completamente fijas y, por lo tanto, sirven como referentes.
Por otro lado, aquellos componentes que cambian de un sistema son denominados variables. En el ejemplo 2.3 se muestran algunas constantes y variables de algunos sistemas.

FT

Constante

Observaci
on

Una sala de cine:

Constantes
N
umero de Sillas
Pantalla

Variables
N
umero de Asistentes
Pelcula
Configuracion de los Asistentes

Un rompecabezas:

Constantes
N
umero de fichas
Tama
no
Forma de las fichas

Una tienda de barrio:

24

Variables
Ubicacion de las fichas

2.2 Observacion
Variables
Cantidad de productos
Dinero
N
umero de clientes
Organizacion de los productos
Precio de los productos

FT

Constantes
El local
El vendedor(*)

(*) Aunque el vendedor puede variar se puede decir que siempre hay un vendedor.

? ? ?

DR
A

Como se pudo notar en el ejemplo anterior, es normal que en la mayora de sistemas

existan mas variables que constantes. A nivel general, las variables son conjuntos logicos
de atributos, es decir, smbolos o nombres simbolicos dados a una cantidad de informacion.
Esta informaci
on pertenece a un dominio de valores, esto es, una asociacion de datos
que se clasifican de la misma manera (e.g. n
umeros, letras, objetos). Estos dominios que
determinan los posibles valores de las variables son llamados tipos de datos 5 . En el ejemplo
del carro tenemos que las variables observadas son la velocidad, el kilometraje, el nivel de
gasolina, estado del motor y la posici
on geografica. Para encontrar los tipos de datos para
estas variables hacemos el siguiente an
alisis:

La velocidad del carro es un valor numerico que varia dependiendo de la marca y el

modelo del carro, sin embargo tiene dos lmites, uno inferior y uno superior. El lmite
inferior es cero ya que lo mnimo que el carro puede hacer es quedarse quieto. Por
otro lado, el lmite superior es una constante k, la cual es definida en el tiempo de
dise
no del carro. Un Renault Logan, por ejemplo, tiene una velocidad maxima de 185
km/h. Por lo anterior esta variable tiene el dominio de valores en el rango [0, k], y
entonces su tipo de dato es Natural.
El kilometraje es tambien un valor numerico que comienza en 0 (cero) cuando el carro
es nuevo y nunca ha sido manejado. Este valor se incrementa a medida que el carro
es usado y jam
as decrece. De all que el dominio de valores es el de los n
umeros reales
positivos, luego su tipo de dato es Real.
El nivel de gasolina es otro valor numerico similar a la velocidad. Tiene un lmite
inferior (cuando el carro no tiene nada de gasolina) y un lmite superior (cuando
el carro est
a tanqueado). La diferencia entre este dominio de valores y el de la

Aunque las constantes no cambian su valor, dicho valor pertenece a un dominio especfico y por lo tanto
podemos decir que las constantes tienen tambien un tipo de dato.

25

Tipo de Datos

2 Noci
on de Sistema

velocidad est
a en que el dominio del nivel de gasolina representa un porcentaje, esto
es, la variable tiene un valor entre 0 y 100. Por lo anterior el tipo de dato de la
variable nivel de gasolina es Real.

FT

El estado del motor tiene uno de dos valores posibles: encendido o apagado. Esto
quiere decir que si preguntan esta encendido el carro?, en la observacion podemos
contestar Verdadero o Falso. Por esto su tipo de dato es Booleano6 .
La posici
on geogr
afica del carro es un poco mas complicada ya que involucra dos
ejes. Estos ejes son com
unmente llamados Latitud (posicion con respecto al norte o
sur del ecuador) y Longitud (posicion con respecto al oriente u occidente del primer
meridiano
o Greenwich). Ellos tienen sus valores en unidades de medida angular
(UMA), es decir, grados, minutos y segundos. Entonces el tipo de datos para la
posici
on geogr
afica es UMA UMA.
Ejemplo 2.4
Supongamos que tenemos los siguientes juegos: un buscaminas, una sopa de letras y un
ahorcado, cu
ales son sus variables y tipos de datos correspondientes?

DR
A

Un buscaminas:

Variable
N
umero de minas
Ubicacion de la mina i
N
umero de marcas
Ubicacion de la marca j
N
umero de espacios destapados
Espacio destapado k

Tipo de Dato
Entero
Entero Entero
Entero
Entero Entero
Entero
Entero Entero

Una sopa de letras:

Variable
N
umero de filas
N
umero de columnas
N
umero de palabras
Letra de la ubicacion i, j
Palabras encontradas

Tipo de Dato
Entero
Entero
Entero
Caracter
Lista de palabras

El conjunto de valores Booleanos est

a compuesto por dos elementos 1 (Verdadero) y 0 (Falso). Este

conjunto es la base fundamental del Algebra

L
ogica de Boole, desarrollada por el matem
atico brit
anico
George Boole en 1854.

26

2.3 Ejercicios

Un ahorcado:
Tipo de Dato
Lista de palabras
Entero
Caracter
Entero
Entero
Entero
Booleano

FT

Variable
Palabras
N
umero total de letras de la palabra
Letra correspondiente a la ubicacion i
N
umero de letras descubiertas de la palabra
N
umero total de partes del mu
neco
N
umero de partes del mu
neco dibujadas
Se ahorc
o

? ? ?

2.3.

Ejercicios

2.1 De los siguientes sistemas escoja cinco (5) y describa sus elementos e interacciones:
DVD Player
Casino
Kinect
Pizzera
Celular

iPod
Supermercado
Estacion Espacial
Dispensador de Gaseosas
Discoteca

DR
A

Carro
Gobierno
Televisor
MIO
Monopoly

Partido de F
utbol
Universidad
Minicomponente
Laboratorio de Fsica
Su Casa

2.2 Cuales de los anteriores sistemas tienen un modelo computacional? Provea una descripcion del programa.
2.3 Tome cinco sistemas de los enumerados anteriormente (diferentes de los escogidos en
el primer ejercicio) y muestre cu
ales de sus elementos son constantes y cuales son
variables.
2.4 De los siguientes juegos determine sus variables y sus constantes, con sus respectivos
tipos de datos: blackjack, triqui, pinball.

27

DR
A

FT

2 Noci
on de Sistema

28

3.1.

Estado

FT

3 Noci
on de Estado

Las variables de un sistema cambian su valor a traves del tiempo. Cada vez que una
variable cambia su valor, el estado en el cual se encuentra sistema cambia. Un estado de
un sistema es una configuraci
on u
nica de los elementos que componen dicho sistema. El
estado del sistema est
a definido entonces por la valuacion de todas sus variables.
Para ejemplificar la noci
on de estado vamos a introducir un sistema muy simple llamado
el mundo de la tortuga:

DR
A

La tortuga vive en un mundo de dos dimensiones en el cual puede moverse.

Ella siempre inicia en el centro del mundo. Este mundo es ilimitado y el centro
de el est
a en la posici
on 0,0. La tortuga puede dibujar mientras se mueve y
sus movimientos pueden ser: ir en lnea recta hacia adelante o hacia atras una
distancia determinada, cambiar su orientacion (a la izquierda o la derecha k
grados), moverse en un crculo y escribir un texto. Adicionalmente la tortuga
puede desplazarse sin dibujar a una posicion x, y y se le puede preguntar su
posicion y orientaci
on.

En la figura 3.1 puede verse el mundo de la tortuga. En esta figura la tortuga ha dibujado
una casita. Para llegar a este estado del sistema, se ha debido pasar por varios estados
intermedios donde se ha cambiado el valor de las variables del sistema. En la figura 3.2 se
detallan los diferentes estados.
A continuaci
on se explica en detalle los cambios de estado de la figura 3.2.
1. Todo comienza en el estado inicial (Figura 3.2a), donde la tortuga esta en el centro
del mundo (posici
on x = 0, y = 0) y su orientacion o sentido es cero ( = 0).
2. La tortuga se mueve luego 50 unidades hacia adelante (Figura 3.2b). Su posicion ha
cambiado a x = 50, y = 0 y su orientacion queda igual.
3. Despues la tortuga cambia su orientacion a = 90, pero su posicion permance igual
en x = 50, y = 0 (Figura 3.2c).

4. Acto seguido (Figura 3.2d) la tortuga se desplaza 100 unidades hacia adelante quedando en x = 50, y = 100. Su orientacion se mantiene en = 90.

29

Estado

FT

3 Noci
on de Estado

DR
A

Figura 3.1: Mundo de la Tortuga

5. Ahora la tortuga rota noventa grados a la izquierda sin desplazarse cambiando su

orientaci
on a = 180 (Figura 3.2e).
6. Una vez m
as la tortuga se mueve 100 unidades hacia adelante modificando su posici
on
a x = 50 y y = 100 (Figura 3.2f).
7. De nuevo rota noventa grados a la izquierda sin trasladarse y su orientacion es ahora
= 270 (Figura 3.2g).
8. Otra vez viaja la tortuga hacia adelante 100 unidades (Figura 3.2h). Su nueva posici
on
es x = 50 y y = 0.
9. Luego la tortuga gira noventa grados a la izquierda volviendo a su orientacion inicial
= 0 (Figura 3.2i).

10. La tortuga termina el cuadrado yendo hacia adelante 50 unidades y finalizando en la

misma posici
on inicial x = 0, y = 0 (Figura 3.2j).
11. Para dibujar el techo de la casa, la tortuga primero se desplaza sin dibujar cincuenta
unidades en el eje horizontal x = 50 (Figura 3.2k).

30

(b) Estado 2

(e) Estado 5

(f) Estado 6

(c) Estado 3

(d) Estado 4

(g) Estado 7

(h) Estado 8

DR
A

(a) Estado Inicial

FT

3.1 Estado

(i) Estado 9

(j) Estado 10

(k) Estado 11

(l) Estado 12

(m) Estado 13

(n) Estado 14

(
n) Estado 15

(o) Estado Final

Figura 3.2: Cambios de estado en el Mundo de la Tortuga

31

3 Noci
on de Estado

12. Despues se mueve cien unidades en el eje vertical y = 100 (Figura 3.2l) tambien sin
dibujar.

FT

13. Como el techo tiene dos lneas diagonales, la tortuga tiene que rotar 135 grados
(Figura 3.2m) y cambia su orientacion a = 135.
14. Dibuja la primera lnea desplazandose 70.7 unidades1 (Figura 3.2n). Su posici
on
cambia a x = 0 y y = 150
15. Posteriormente la tortuga rota noventa grados a la izquierda, dejando = 215 (Figura
3.2
n).
16. Finalmente la tortuga se mueve otras 70.7 unidades llegando al estado final x = 50,
y = 100 y = 215 (Figura 3.2o).

DR
A

Algoritmo

Los anteriores son los pasos para llevar el sistema del estado inicial al estado final. De
manera general, el conjunto ordenado de pasos que llevan un sistema de un estado a otro
es com
unmente llamado algoritmo. Los pasos que se ejecutan en un algoritmo realizan
operaciones que modifican las variables del sistema y, por ende, el estado del mismo. Las
operaciones son acciones que pueden efectuarse dentro del sistema y son definidas en el
tiempo de creaci
on del sistema. Para el caso del mundo de la tortuga, el conjunto n
ucleo
de operaciones2 se encuentra en el cuadro 3.1.

Comentario

Ejemplo 3.1
Dados los estados inicial y final en la figura 3.3, cuales son las operaciones necesarias para
llevar al sistema del estado inicial al estado final?
El algoritmo 3.1 muestra los pasos para llevar el sistema de un estado al otro. Las lneas
rojas que comienzan con el smbolo # son denominados comentarios. Los comentarios
son anotaciones en algoritmos que sirven para documentar el codigo y hacerlo mas f
acil de
entender, pero que no se tienen en cuenta a la hora de ejecutar el algoritmo.

? ? ?

Este valor es determinado f

acilmente aplicando el teorema de Pit
agoras: En todo tri
angulo rect
angulo el
cuadrado de la hipotenusa es igual a la suma de loscuadrados de los catetos. Como los catetos de este
tri
angulo miden 50 unidades se tiene entonces d = 502 + 502 = 70,7.
2
Existen muchas m
as acciones que se ir
an introduciendo a medida que se necesiten.

32

3.1 Estado

left(a)
penup()
pendown()
position()
heading()
undo()
clear()
home()
reset()

Acci
on
Avanza u pixeles (dibuja dependiendo del estado del lapiz)
En la posici
on actual realiza una porcion del un crculo de radio
r (la porci
on y direccion dibujada depende del parametro a, 360
para todo)
A partir de la orientacion actual, rota la tortuga a grados en sentido contrario a las manecillas del reloj
Levanta el l
apiz (cualquier movimiento no dibujara su recorrido)
Baja el l
apiz (cualquier movimiento dibujara su recorrido)
Reporta el valor de la posicion de la tortuga
Reporta el valor de la orientacion de la tortuga
Deshace la u
ltima accion ejecutada por la tortuga
Borra todo lo dibujado por la tortuga (no mueve la tortuga)
Lleva la tortuga al centro del mundo (no borra lo dibujado)
Reinicia todo el sistema y posiciona la tortuga en la posicion x = 0
y y = 0, con orientacion = 0

FT

Operaci
on
forward(u)
circle(r,a)

DR
A

Cuadro 3.1: Operaciones basicas en el Mundo de la Tortuga

Figura 3.3: Estado inicial y final para dibujar una persona

33

3 Noci
on de Estado

# Dibuja la cabeza
turtle.pendown()
turtle.circle(50,360)
# Dibuja el cuerpo
turtle.left(270)
turtle.forward(200)

FT

# Se posiciona para dibujar la cabeza

turtle.penup()
turtle.left(90)
turtle.forward(100)
turtle.left(270)

# Dibuja la pierna izquierda

turtle.left(45)
turtle.forward(100)

DR
A

# Se posiciona para dibujar la pierna derecha

turtle.penup()
turtle.left(180)
turtle.forward(100)
turtle.left(90)
# Dibuja la pierna derecha
turtle.pendown()
turtle.forward(100)

# Se posiciona para dibujar los brazos

turtle.penup()
turtle.left(180)
turtle.forward(100)
turtle.left(45)
turtle.forward(150)
turtle.left(90)
turtle.forward(75)
turtle.left(180)
# Dibuja los dos brazos
turtle.pendown()
turtle.forward(150)

Algoritmo 3.1: Dibuja una persona

Cuando se tiene un sistema cuyo estado actual no es el deseado, se dice que se tiene un

34

3.1 Estado

problema. La soluci
on a un problema es una serie de pasos (ejecuciones de operaciones)
que llevan del estado en que est
an las cosas en el sistema al estado que se desean, es decir,
un algoritmo.

# Se cambia el color del lpiz

turtle.pencolor("red")

DR
A

# Sale del laberinto

turtle.forward(350)
turtle.left(90)
turtle.forward(150)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(100)
turtle.left(270)
turtle.forward(200)
turtle.left(270)
turtle.forward(150)
turtle.left(270)
turtle.forward(100)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(150)
turtle.left(270)
turtle.forward(100)
turtle.left(270)
turtle.forward(300)
turtle.left(90)
turtle.forward(50)

FT

Ejemplo 3.2
La tortuga Junior se encuentra atrapada en el laberinto de la figura 3.4. Resuelva el problema de sacar a Junior del laberinto. Inicialmente la tortuga se encuentra en la posicion
(-175,175). Los lados del cuadrado externo del laberinto tienen una longitud de 400 pixeles,
la esquina superior izquierda est
a en (-200,200) y el ancho de los pasadizos del laberinto es
de 50 pixeles.

Problema

Algoritmo 3.2: Sale del laberinto cuadrado

El algoritmo 3.2 muestra los pasos para resolver el problema. Si se aplica dicho algoritmo
en el estado inicial del problema, se obtendra como resultado el estado en la figura 3.5.
? ? ?

35

FT

3 Noci
on de Estado

DR
A

Figura 3.4: Problema de sacar la tortuga del laberinto

Figura 3.5: Solucion al problema de sacar la tortuga del laberinto

36

3.2 Ejercicios

El algoritmo 3.2 usa una nueva operacion llamada pencolor(c) para cambiar el color
del lapiz con el cual dibuja la tortuga. Otras operaciones similares para hacer mas vistoso
el mundo estan en la tabla 3.2.

fillcolor(c)
begin fill()

end fill()
bgcolor(c)

Acci
on
Cambia el color del lapiz a c (c debe ser una cadena de texto, e.g.
red, orange, green)
Cambia el color de rellenado de las figuras a c (c debe ser una
cadena de texto, e.g. red, orange, green)
Las figuras cerradas que dibuje la tortuga seran rellenas con el
color definido en la operacion fillcolor(c). Para que las figuras
se coloreen, se debe llamar a end fill() despues de dibujar
Termina el proceso de rellenar las figuras cerradas
Cambia el color de fondo de la ventana a c (c debe ser una cadena
de texto, e.g. red, orange, green)

FT

Operaci
on
pencolor(c)

Cuadro 3.2: Operaciones de colores en el Mundo de la Tortuga

Ejercicios

DR
A

3.2.

3.1 Haga un algoritmo que ponga a la tortuga a dibujar su nombre y apellido.

3.2 Mejore el algoritmo de dibujar una persona. Agregue los ojos, la nariz, la boca,
camiseta, pantal
on, manos y pies. Use colores.
3.3 Resuelva el problema de llevar a la tortuga Junior (tortuga negra) donde su mama (tortuga roja). El laberinto del problema se puede ver en la figura 3.6.
La tortuga mam
a se encuentra en el centro del mundo (0,0) mientras que Junior se
encuentra en (-150,180). Los semi-crculos que rodean a la mama son concentricos y
si se enumeraran desde el m
as interno hasta el mas externo, el semi-crculo 1 tiene
un radio de 33 pixeles, el semi-crculo 2 tiene un radio de 60 pixeles, el semi-crculo
3 tiene un radio de 90 pixeles, el semi-crculo 4 tiene un radio de 120 pixeles y el
semi-crculo 5 tiene un radio de 150 pixeles.

3.4 Desarrolle un algoritmo para que la tortuga construya una sopa de letras.

37

DR
A

FT

3 Noci
on de Estado

Figura 3.6: Problema de llevar la tortuga donde su mama

38

4.1.

Abstracci
on de Control

FT

4 Noci
on de Abstracci
on

DR
A

Normalmente, a medida que se van resolviendo problemas mas complicados, la cantidad

de operaciones b
asicas que deben realizarse y la cantidad de datos a procesar es mayor.
Adicionalmente, muchas veces el algoritmo que resulta no es lo suficientemente intuitivo
como para entenderlo f
acilmente, por el contrario, se puede ver como una lista de comandos cuyo prop
osito es indefinido. Por ejemplo, si tomamos el algoritmo 3.1 (ejemplo 3.1),
eliminamos los comentarios y omitimos el proposito del algoritmo, una persona solo con
mirar el codigo tendra dificultad en encontrar su objetivo. Esto se debe a que el nivel de
abstraccion del algoritmo es bajo.
Abstracci
on es el proceso en el que datos y algoritmos son agrupados de acuerdo a una
semantica particular, de manera que se reduzcan los detalles. El proceso de abstraccion
puede aplicarse a operaciones o a datos. En este captulo veremos la abstraccion que involucra algoritmos, llamada abstracci
on de control. En el captulo 7 se vera la abstraccion de
datos.
El nivel de abstracci
on de un sistema define la cantidad de detalles a tener en cuenta al
realizar el modelo computacional del sistema. El mundo de la tortuga, por ejemplo, tiene un
alto nivel de abstracci
on ya que las operaciones basicas son claras en cuanto a su proposito
y el programador sabe que si ejecuta una operacion, el resultado se vera graficamente, no
importa el computador en el que se ejecute. Si el nivel de abstraccion del mundo de la
tortuga fuera bajo, el programador tendra que lidiar con operaciones del procesador y la
tarjeta de video del computador en el que quiera ejecutar el programa, es decir, rutinas
propias de la m
aquina. En el ejemplo 4.1 se muestra como aumentar el nivel de abstraccion
del algoritmo 3.1.

Ejemplo 4.1
Si queremos dibujar una persona, podemos dividir el dibujo en las partes del cuerpo: cabeza,
tronco, y extremidades, y definimos cada una de estas partes como una operacion diferente.
Las nuevas operaciones para dibujar las extremidades, el tronco y la cabeza estan definidas en los algoritmos 4.1, 4.2 y 4.3.

39

Abstracci
on

4 Noci
on de Abstracci
on

FT

def dibujarExtremidades():
"Dibuja las extremidades de una persona"
# Dibuja la pierna izquierda
turtle.left(45)
turtle.forward(100)
# Se posiciona para dibujar la pierna derecha
turtle.penup()
turtle.left(180)
turtle.forward(100)
turtle.left(90)
# Dibuja la pierna derecha
turtle.pendown()
turtle.forward(100)

DR
A

# Se posiciona para dibujar los brazos

turtle.penup()
turtle.left(180)
turtle.forward(100)
turtle.left(45)
turtle.forward(150)
turtle.left(90)
turtle.forward(75)
turtle.left(180)
# Dibuja los dos brazos
turtle.pendown()
turtle.forward(150)

Algoritmo 4.1: Dibuja las extremidades de una persona

def dibujarTronco():
"Dibuja el tronco de una persona"
# Dibuja el cuerpo
turtle.left(270)
turtle.forward(200)

Algoritmo 4.2: Dibuja el tronco de una persona

40

4.1 Abstraccion de Control

# Dibuja la cabeza
turtle.pendown()
turtle.circle(50,360)

FT

def dibujarCabeza():
"Dibuja la cabeza de una persona"
# Se posiciona para dibujar la cabeza
turtle.penup()
turtle.left(90)
turtle.forward(100)
turtle.left(270)

Algoritmo 4.3: Dibuja la cabeza de una persona

El algoritmo para dibujar una persona se reduce ahora a cargar y aplicar las operaciones
recien creadas, como en el algoritmo 4.4. Note que si a dicho algoritmo le quitamos los
comentarios, a
un as el usuario que lea el algoritmo tiene una idea de cual es su proposito
solo con echarle un vistazo.

DR
A

# Dibuja la cabeza
dibujarCabeza()
# Dibuja el cuerpo
dibujarTronco()

# Dibuja las extremidades

dibujarExtremidades()

Algoritmo 4.4: Dibuja completamente una persona

? ? ?

En los algoritmos 4.3, 4.2, y 4.1 se han definido las operaciones dibujarExtremidades(),
dibujarTronco() y dibujarCabeza(). La definici
on de una operacion especifica un identificador (que va a ser usado para aplicar la operacion) y el cuerpo de dicha operacion. La
especificacion del cuerpo de una operaci
on es denominada implementaci
on de la operacion.
En el algoritmo 4.4 se usan las operaciones previamente definidas. Cuando una operacion
es usada de esta manera, se dice que se hace una aplicaci
on de la operacion. Aplicar una
operacion es, finalmente, hacer el llamado a la operacion.
Ejemplo 4.2
Supongamos que queremos dibujar un conjunto de casas. La manera mas sencilla es crear

41

Definici
on
Implementaci
on
Aplicaci
on

4 Noci
on de Abstracci
on

def dibujarCasa():
"Dibuja una casa"
# Dibuja la pared
turtle.pendown()
turtle.left(270)
turtle.forward(100)
turtle.left(270)
turtle.forward(100)
turtle.left(270)
turtle.forward(100)
turtle.left(270)
turtle.forward(100)

DR
A

# Dibuja el techo
turtle.left(135)
turtle.forward(70.7)
turtle.left(90)
turtle.forward(70.7))

FT

una operaci
on para dibujar una sola casa y luego ejecutar dicha operacion tantas veces
como n
umero de casas se quiera. El algoritmo 4.5 define una operacion para dibujar una
casa.

# Dibuja la puerta y termina

turtle.penup()
turtle.left(45)
turtle.forward(100)
turtle.left(90)
turtle.forward(40)
turtle.left(90)
turtle.pendown()
turtle.forward(30)
turtle.left(270)
turtle.forward(20)
turtle.left(270)
turtle.forward(30)
turtle.left(90)
turtle.penup()
turtle.forward(40)
turtle.left(90)
turtle.forward(100)

Algoritmo 4.5: Dibuja una casa

Luego ejecutamos la operacion para dibujar una casa varias veces, como en el algoritmo
4.6, en el cual se dibujan cuatro casas.

42

4.1 Abstraccion de Control

FT

# Dibuja cuatro casas

dibujarCasa()
dibujarCasa()
dibujarCasa()
dibujarCasa()

Algoritmo 4.6: Dibuja cuatro casas

? ? ?

DR
A

Podemos ver que el nivel de abstracci

on del algoritmo 4.5 puede aumentarse separando
las partes de la casa y definiendolas como operaciones separadas.
Por otra parte, el lector que pruebe el algoritmo 4.6 puede darse cuenta que el resultado
que se obtiene no es el esperado. La figura 4.1 muestra lo que la tortuga dibuja despues de
aplicado el algoritmo.

Figura 4.1: Resultado de aplicar el algoritmo para dibujar una casa cuatro veces

Es claro que la tortuga dibuja cuatro casas, pero no es el resultado esperado; el resultado
que se quisiera es el que se muestra en la figura 4.2.

43

FT

4 Noci
on de Abstracci
on

DR
A

Figura 4.2: Resultado esperado de aplicar el algoritmo para dibujar una casa cuatro veces

Parametro

Argumento

El problema que ocurre es que la posicion y la orientacion inicial de la tortuga en cada

ejecuci
on de la operaci
on no es la correcta. Por lo tanto, debemos darle a la operaci
on estos
datos para que la tortuga pueda dibujar las casas como deseamos. En el algoritmo 4.7 se
define la operaci
on con la posicion en x y en y como datos de entrada.
Cuando se definen operaciones, a los datos de entrada de ellas se les llama parametros.
Un par
ametro de una operacion es entonces, un tipo especial de variable que provee datos
necesarios que pueden ser usados en la operacion.
Con la nueva definici
on de la operacion para dibujar una casa, se puede hacer un algoritmo m
as adecuado para dibujar cuatro casas y que, de hecho, queden como en la figura
4.2. El resultado es el algoritmo 4.8.
Los valores que se proveen como datos de entrada a la ejecucion de una operaci
on son
llamados los argumentos de la operacion. En el algoritmo 4.8, por ejemplo, 100 y 0 son
los argumentos de la primera aplicacion de la operacion dibujarCasa().
En el algoritmo 4.7 se incorporan nuevas operaciones del mundo de la tortuga. Estas
operaciones sirven para posicionar y orientar la tortuga en un lugar particular del mundo
sin necesidad de llevarla hasta alla con left() y forward(). Estas y otras operaciones
est
an en el cuadro 4.1.

44

4.1 Abstraccion de Control

# Dibuja la pared
turtle.pendown()
turtle.left(270)
turtle.forward(100)
turtle.left(270)
turtle.forward(100)
turtle.left(270)
turtle.forward(100)
turtle.left(270)
turtle.forward(100)

DR
A

# Dibuja el techo
turtle.left(135)
turtle.forward(70.7)
turtle.left(90)
turtle.forward(70.7))

FT

def dibujarCasa(x,y):
"Dibuja una casa dada una posicion"
# Se posiciona donde quiere dibujar la casa y orienta a la
# tortuga en 0 grados
turtle.penup()
turtle.setx(x)
turtle.sety(y)
turtle.seth(0)

# Dibuja la puerta y termina

turtle.penup()
turtle.left(45)
turtle.forward(100)
turtle.left(90)
turtle.forward(40)
turtle.left(90)
turtle.pendown()
turtle.forward(30)
turtle.left(270)
turtle.forward(20)
turtle.left(270)
turtle.forward(30)
turtle.left(90)
turtle.penup()
turtle.forward(40)
turtle.left(90)
turtle.forward(100)

Algoritmo 4.7: Dibuja una casa con posicion

45

4 Noci
on de Abstracci
on

FT

# Dibuja cuatro casas especificando su posicion

dibujarCasa(-100,0)
dibujarCasa(0,0)
dibujarCasa(100,0)
dibujarCasa(200,0)

Algoritmo 4.8: Dibuja cuatro casas especificando las posiciones

Operaci
on
goto(x,y)
setx(x)
sety(y)

DR
A

seth(h)
xcor()
ycor()

Acci
on
Traslada la tortuga a la posicion x = x, y = y. La orientaci
on
permanece igual
Traslada la tortuga a la coordenada x = x sin cambiar la coordenada y. La orientacion permanece igual
Traslada la tortuga a la coordenada y = y sin cambiar la coordenada x. La orientacion permanece igual
Orienta la tortuga al angulo a = h
Reporta el valor de la posicion de la tortuga en el eje x
Reporta el valor de la posicion de la tortuga en el eje y

Cuadro 4.1: Operaciones de posicionamiento y orientacion en el Mundo de la Tortuga

Ejemplo 4.3
Ahora queremos que la tortuga escriba la letra A pero en diferentes escalas, es decir, con
un tama
no que depende de un valor de entrada. Para esto se necesita definir una operaci
on
que tenga un par
ametro escala cuyo dominio de valores se encuentre entre 1 y 100. Este
par
ametro ser
a usado para determinar las longitudes de las lneas que componen la letra
A y los
angulos que debe usar la tortuga para hacer el dibujo. El algoritmo 4.9 resuelve
este problema.
Se asume que la letra a una escala 100 ocupa la mayor parte de la ventana y el dibujo de
la letra m
as peque
na tiene una escala 1. Como la ventana es de 500 500 pixeles, entonces
la tortuga se mover
a inicialmente a una posicion determinada por la escala y un factor de
2,3. As, si la escala es 100, la posicion inicial sera (230, 230), mientras que si la escala
es 1, la posici
on ser
a (2,3, 2,3).
Como puede verse para hallar las longitudes de las lneas diagonales se usa (de nuevo) el
teorema de Pit
agoras, y para hallar el angulo que debe tomar la tortuga para dibujar las
diagonales se usa la funci
on trigonometrica arcoseno. Estas operaciones necesarias en este
problema (y en algunos siguientes) hacen parte de un sistema matematico; algunas de las

46

4.1 Abstraccion de Control

operaciones m
as usadas de este sistema se encuentran en el cuadro 4.2.

FT

def letraAescala(escala):
"Dibuja la letra 'A' con una escala dada"
# Se posiciona para dibujar
turtle.penup()
turtle.setx(-2.3*escala)
turtle.sety(-2.3*escala)
turtle.seth(0)

# Calcula los valores necesarios para la letra, a partir de

# la escala
longitud = math.sqrt((2.3*escala * 2.3*escala) + \
(4.6*escala * 4.6*escala))
angulo = (math.asin(4.6*escala/longitud)*360)/(2*math.pi)
# Dibuja la primera diagonal
turtle.pendown()
turtle.left(angulo)
turtle.forward(longitud)

DR
A

# Dibuja la segunda diagonal

turtle.seth(0)
turtle.left(360-angulo)
turtle.forward(longitud)

# Se posiciona para dibujar la linea intermedia

turtle.left(180)
turtle.penup()
turtle.forward(longitud/3)
# Dibuja la linea intermedia
turtle.seth(180)
turtle.pendown()
linea = turtle.xcor()*2
turtle.forward(linea)

# Mueve la tortuga a una posicion que permita ver el resultado

turtle.penup()
turtle.goto(-235,235)
turtle.seth(0)

Algoritmo 4.9: Dibuja la letra A

? ? ?

47

4 Noci
on de Abstracci
on

Operaci
on
pow(x,y)
sqrt(x)
log(x,b)
sin(v)
cos(v)
tan(v)
asin(v)
acos(v)
atan(v)
degrees(a)
radians(a)

Acci
on
Retorna
Retorna
Retorna
Retorna
Retorna
Retorna
Retorna
Retorna
Retorna
Retorna
Retorna

Constante
pi
e

Valor
El valor matematico = 3,141592...
El valor matematico e = 2,718281...

x elevado a la y
la raiz cuadrada de x
el logaritmo base b de x
el seno de a, en radianes
el coseno de a, en radianes
la tangente de a, en radianes
el arcoseno de a, en radianes
el arcocoseno de a, en radianes
la arcotangente de a, en radianes
la conversion del angulo a de radianes a grados
la conversion del angulo a de grados a radianes

DR
A

Alcance

FT

Declaracion

El lector puede notar que en el algoritmo 4.9 se han usado unas variables longitud,
angulo y linea. Estas variables se dice que son locales ya que son declaradas (usadas por
primera vez o por lo menos anunciadas de que existen) dentro del contexto de la operaci
on
definida. Por fuera del contexto (en el caso de las variables longitud, angulo y linea, por
fuera de la operaci
on letraAescala()), dichas variables no son visibles o accesibles. Por
otro lado, las variables globales son aquellas que pueden ser usadas en cualquier contexto,
es decir, en cualquier parte del codigo del modelo computacional. Por lo tanto, el contexto
en el que son declaradas las variables define su alcance, esto es, la visibilidad o accesibilidad
de las variables en diferentes partes del modelo computacional.

Cuadro 4.2: Operaciones y constantes clasicas de un sistema matematico

Funcion

Los valores de las variables locales longitud,

angulo y linea son obtenidos al aplicar las
operaciones sqrt(), asin() y xcor(), respectivamente. Estas operaciones en su definici
on
han hecho aplicaciones de otras operaciones y calculos internos, y al final ellas (sqrt(),
asin() y xcor()) reportan un valor, el cual es retornado a la operacion donde fueron
aplicadas (en este caso letraAescala()) y se asignan a las variables longitud, angulo y
linea. Cuando una operaci
on reporta un valor que es retornado al final de su definici
on,
a dicha operaci
on se le denomina funci
on.
Ejemplo 4.4
El curso de Introducci
on a la programacion se eval
ua con tres examenes parciales, tareas

48

4.1 Abstraccion de Control

y un proyecto. El cuadro 4.3 muestra los porcentajes que tienen estos elementos en la nota
final del curso.
Porcentaje
25 %
20 %
20 %
15 %
20 %

FT

Evaluaci
on
Examen Parcial 1
Examen Parcial 2
Examen Parcial 3
Tareas
Proyecto

Cuadro 4.3: Porcentaje de notas de un curso Introduccion a la Programacion

Si quisieramos que la tortuga escribiera la nota final del curso dados los datos de las
evaluaciones, primero tenemos que hacer la funcion que retorne la nota final y luego hacer
que la tortuga escriba este valor reportado. La funcion esta definida en el algoritmo 4.10.

DR
A

def notaFinal(p1, p2, p3, t, pry):

"Funcion que haya la nota final del curso"
nota = (p1*0.25) + (p2*0.2) + (p3*0.2) + (t*0.15) + (pry*0.2)
return nota

Algoritmo 4.10: Retorna la nota final del curso

Esta funcion puede usarse entonces en un algoritmo que haga dibujar a la tortuga la
nota final, como el algoritmo 4.11.
def escribirNotaFinal():
"Escribe la nota final de un curso"
# Halla el dia del domingo de Pascua
valor = notaFinal(4.5, 4.0, 5.0, 4.0, 5.0)

# Escribe la nota y termina

turtle.write(valor, False, align="center", \
font=("Arial",32,"normal"))
turtle.penup()
turtle.goto(-235,235)

Algoritmo 4.11: Escribe la nota final del curso

? ? ?

En el algoritmo 4.11 se usa una operacion para escritura. Esta operacion esta descrita

49

4 Noci
on de Abstracci
on

en el cuadro 4.4.
Acci
on
Escribe en la posicion actual el texto t. El parametro m es un
valor logico (True o False) que especifica si la tortuga se desplazar
a cuando escriba el texto. El parametro a define la alineaci
on
del texto (left, center, o right). El parametro f es una estructura que describe la fuente del texto (esta estructura se codifica entre parentesis con los datos separados por comas, as:
(nombre, tama
no, tipo), e.g. (Arial,18,italic))

FT

Operaci
on
write(t,m,a,f)

Cuadro 4.4: Operacion de escritura en el Mundo de la Tortuga

Procedimiento

DR
A

Composicion

Las operaciones que no reportan un valor y, por lo tanto, no es retornado a la operaci

on
donde se aplica se les llama procedimientos. Todas las operaciones que se han definido hasta
el momento, excepto notaFinal(), son procedimientos.
Las funciones, dado que retornan un valor que puede asignarse a una variable y, por
lo tanto, puede usarse en otras operaciones, pueden aplicarse como argumento de otra
aplicaci
on. Este proceso es conocido como composici
on de funciones. El ejemplo 4.5 muestra
un algoritmo con composici
on de funciones.
Ejemplo 4.5
Supongamos que queremos construir la funcion que retorna la longitud de la hipotenusa
de un tri
angulo rect
angulo, dadas las longitudes de los dos catetos (esto nos sirve de ayuda
en varios ejemplos vistos). Para resolver este problema se usa el teorema de pitagoras. El
algoritmo 4.12 muestra su uso de dos maneras diferentes.
def longitudHipotenusa1(cateto1, cateto2):
"Retorna la longitud de la hipotenusa de un triangulo rectangulo"
valor1 = math.pow(cateto1,2)
valor2 = math.pow(cateto2,2)
hipotenusa = math.sqrt(valor1+valor2)
return hipotenusa
def longitudHipotenusa2(cateto1, cateto2):
"Retorna la longitud de la hipotenusa de un triangulo rectangulo"
return math.sqrt(math.pow(cateto1,2)+math.pow(cateto2,2))

Algoritmo 4.12: Retorna la longitud de la hipotenusa de un triangulo rectangulo

Las dos funciones retornan exactamente lo mismo. La primera funcion declara dos variables locales que contendran el valor resultado de elevar al cuadrado las longitudes de

50

4.1 Abstraccion de Control

FT

los dos catetos y luego aplica la funci

on de raz cuadrada con la suma de las dos variables
como argumento. El resultado de la funcion raz cuadrada se asigna a una u
ltima variable
local, cuyo valor ser
a retornado por la funcion.
La segunda funci
on se ahorra la declaracion de las variables aplicando directamente la
funcion de raz cuadrada con el resultado de la funcion de elevar al cuadrado los catetos y
sumarlos, es decir, componiendo las funciones.
? ? ?

DR
A

Ejemplo 4.6
A principio de cada a
no una de las preguntas mas frecuentes entre nosotros es en que fecha
cae Semana Santa?
La tortuga Sabelotodo encontr
o que una formula para calcular la fecha del Domingo de
Pascua en los a
nos 19822048, inclusive, es as1 : sea a = ano %19, b = ano %4, c = ano %7,
d = (19a + 24) %30, e = (2b + 4c + 6d + 5) %7, entonces el da del Domingo de Pascua es
Marzo 22 + d + e.
Esta formula la podemos usar para crear la funcion Pascua. Esta funcion tiene como
parametro un a
no y retorna el da del Domingo de Pascua de ese a
no. El algoritmo 4.13
muestra la funci
on.
def Pascua(ano):
"Funcion que halla el da del domingo de pascua"
a = ano%19
b = ano%4
c = ano%7
d = (19*a + 24)%30
e = (2*b + 4*c + 6*d + 5)%7
dia = 22 + d + e
return dia

Algoritmo 4.13: Retorna el da del Domingo de Pascua

Usando esta funci

on, podemos poner a la tortuga a escribir la fecha del Domingo de
Pascua (o toda la Semana Santa) con un algoritmo similar al algoritmo 4.11.
? ? ?

Si el lector prueba el algoritmo 4.13, aplicandolo con diferentes a

nos como argumento,
podra notar que en algunas ocasiones se obtendran resultados inconsistentes cronologicamente. Por ejemplo, la funci
on Pascua con un argumento 2000 retorna 54. Sin embargo no
1

La operaci
on m
odulo % halla el residuo de la divisi
on entera entre dos n
umeros.

51

4 Noci
on de Abstracci
on

4.2.

Ejercicios

FT

existe la fecha Marzo 54 de 2000, Marzo tiene solo 31 das y el da siguiente es Abril 1. De
esta manera, es necesario considerar los casos para los que la fecha esta en Marzo y aquellos
donde la fecha est
a en Abril. La estructura de control para tener dichas consideraciones se
ver
a en el captulo 5.

4.1 Mejore los procedimientos 4.1, 4.2 y 4.3, creandoles parametros que especifiquen las
posiciones donde van a ser dibujados.
4.2 Baje el nivel de abstraccion del dibujo de una persona, desarrollando los procedimientos y funciones para dibujar todas partes del cuerpo humano. Por ejemplo, en vez de
dibujarCabeza(), puede construir las operaciones dibujarOjos(), dibujarNariz(),
dibujarBoca(), dibujarOrejas(), etc., con sus respectivos parametros de posici
on y
otros par
ametros que se deseen (e.g. dibujarOjos() puede tener ademas un par
ametro que especifique el color de los ojos).

DR
A

4.3 Desarrolle un procedimiento para que la tortuga escriba su nombre en diferentes

escalas.
4.4 Se quiere que la tortuga dibuje una peque
na ciudad con un carro en ella. Cree entonces
un procedimiento que lo haga y que permita dibujar el carro en diferentes calles de
ella. Adicionalmente el procedimiento debe tener la capacidad de hacer zoom en
cualquier parte de la peque
na ciudad (piense en un Google Maps http://maps.
google.com/ muy muy sencillo).
4.5 Escriba una funci
on con dos parametros correspondientes a la base y la altura de un
tri
angulo is
osceles y haga que la tortuga dibuje el triangulo. La funcion debe retornar
el valor del
area del triangulo.
4.6 Desarrolle un algoritmo para que la tortuga construya un sudoku y luego defina las
operaciones para resolver cualquier sudoku.

52

5.1.

Condici
on

FT

5 Noci
on de Condici
on

Cuando el estado en que se encuentra un sistema se desconoce, no podemos garantizar

que un algoritmo desarrollado llegue al estado deseado. Lo anterior debido a que no tenemos
forma de saber que operaciones deben realizarse a partir de dicho estado desconocido para
lograr llegar al estado final. Sin embargo si consideraramos todos los casos posibles, entonces
s garantizaramos llegar al estado final. Para diferenciar un caso de otro es necesario que
el estado del sistema cumpla una condici
on.
Una condici
on es:
una relaci
on l
ogica entre variables, o

DR
A

una funci
on que retorna un valor de tipo Booleano.

Una relacion l
ogica entre variables se construye utilizando operadores de relacion. Los
operadores de relaci
on entre variables son ==, <, >, <=, >=, ! =, <>. Por ejemplo, si
tenemos la siguiente relaci
on:
x >= 5

esta relacion es verdadera en el caso en que la variable x sea asignada con valores mayores
o iguales a 5. De lo contrario la relaci
on es falsa. La semantica de los operadores de relacion
es como sigue:
el operador < significa menor que.
el operador > significa mayor que.

el operador == significa igual que.

el operador <= significa menor o igual que.

el operador >= significa mayor o igual que.

los operadores ! = y <> significan distinto de.

53

Condici
on

5 Noci
on de Condici
on
Operaci
on
p and q

Acci
on
Retorna True cuando los valores de ambas variables p y q son
True. De lo contrario retorna False. Esto se ve mas claramente
en la siguiente tabla de verdad:

p or q

q
True
False
True
False

Retorna True cuando el valor de cualquiera de las dos variables

p y q es True. De lo contrario retorna False. Esto se ve mas
claramente en la siguiente tabla de verdad:
q
True
False
True
False

DR
A

p
True
True
False
False

not p

p or q
True
True
True
False

Retorna True cuando el valor de la variable p es False. De lo

contrario retorna False. Esto se ve mas claramente en la siguiente
tabla de verdad:
p
True
False

Constante
True
False

p and q
True
False
False
False

FT

p
True
True
False
False

not p
False
True

Valor
El valor Booleano 1
El valor Booleano 0

Cuadro 5.1: Operaciones y constantes clasicas de un sistema Booleano

De otro lado, la implementacion de funciones que retornan valores de tipo Booleano se

logra combinando constantes logicas (True y False), variables logicas (i.e. con tipo de dato

54

5.1 Condicion

Booleano) y operaciones l
ogicas. Las operaciones logicas son aquellas que al ser aplicadas
producen un valor Booleano. Algunas de estas operaciones se pueden ver en el cuadro 5.1.
Un condicional es una sentencia que eval
ua una condicion y de acuerdo al resultado de
dicha evaluacion, ejecuta o no, un conjunto de operaciones.

DR
A

FT

Ejemplo 5.1
Supongamos que la tortuga Junior tiene dos opciones para divertirse esta noche. Una opcion
es ir a una discoteca mientras que la otra es ir a comer helado. La decision depende de la
edad que tenga Junior dado que para entrar a las discotecas se requiere tener mas de 18
a
nos.
La figura 5.1 muestra el estado inicial del problema, con Junior al frente de ambos
edificios.

Condicional

Figura 5.1: Estado inicial del problema de mayora de edad

El algoritmo 5.1 desarrolla la funci

on esMayorDeEdad() la cual recibe como parametro un
n
umero natural que representa la edad y retorna True o False dependiendo si el argumento
pasado a la funci
on en su aplicaci
on es mayor o igual a 18, o no.
Para hacer que Junior vaya a la discoteca, debemos entonces aplicar la funcion
esMayorDeEdad() del algoritmo 5.1 con un n
umero mayor o igual a 18 como argumento.
Esto hace que la funci
on retorne True y el estado final del sistema sea el de la figura 5.2a.
Por otro lado, si aplicamos la funci
on con un n
umero menor a 18, ella retornara False (ya
que la condicion no se cumple (edad >= 18), la variable mayor no se modifica y se queda

55

5 Noci
on de Condici
on

con el valor que se le dio en su declaracion, es decir, False) y el estado final del sistema
ser
a el de la figura 5.2b.

FT

def esMayorDeEdad(edad):
"Funcion que retorna si es mayor de edad o no"
mayor = False
if edad >= 18:
mayor = True
return mayor

DR
A

Algoritmo 5.1: Retorna si un n

umero es mayor o igual a 18

(a) Soluci
on 1

(b) Soluci
on 2

Figura 5.2: Los dos posibles casos del problema de mayora de edad

Flujo de Ejecucion

? ? ?

En el ejemplo 5.1 puede notarse que en algunos casos se ejecutan unas operaciones y
en otros se ejecutan otras operaciones. El orden de ejecucion de las operaciones de un
programa determina el flujo de ejecuci
on del programa. La figura 5.3 da una explicaci
on
gr
afica del flujo de la funci
on esMayorDeEdad(). La asignacion mayor = False siempre se

56

5.1 Condicion

FT

ejecuta. La condici
on edad >= 18 es evaluada y de acuerdo al resultado se puede ir por
uno de dos caminos: si el resultado de la condicion es True entonces se ejecuta la asignacion
mayor = True y luego se retorna la variable mayor (es decir se retorna True); si el resultado
de la condicion es False entonces simplemente se retorna la variable mayor, que en este
caso tiene asignado el valor original False.
edad

mayor = False

edad >= 18?

Cierto

DR
A

mayor = True

Falso

return mayor

Figura 5.3: Flujo de ejecucion de la funcion esMayorDeEdad()

Ejemplo 5.2
Supongamos que la tortuga Junior ha dibujado un tablero de tiro al blanco para jugar un
rato. El tablero que ha dibujado se muestra en la figura 5.4.
Como puede apreciarse, un tablero de tiro al blanco consiste en un n
umero fijo de circunferencias concentricas separadas por una distancia usualmente constante. En este caso
particular, el tablero tiene ocho circunferencias concentricas cada una separada 25 unidades
de la siguiente. La circunferencia m
as peque
na (negra) tiene un radio de 25 unidades.
El juego consiste en disparar al tablero y de acuerdo al lugar donde ocurrio el disparo,
se obtiene un puntaje. Este puntaje es acumulado hasta que se acaben los disparos. El
jugador que m
as puntaje obtenga al final sera el ganador.

57

FT

5 Noci
on de Condici
on

DR
A

Figura 5.4: Tablero de tiro al blanco

Lo primero que debemos hacer es construir una funcion que, dado un disparo, retorne el
puntaje correspondiente. Un disparo se puede ver como una posicion en el mundo, es decir,
una posici
on en el eje x y una posicion en el eje y. De all que si hallamos la distancia desde
ese punto hasta el origen (0,0), podramos saber entre que par de crculos cayo el disparo y,
por lo tanto, saber el puntaje asociado. Entonces la distancia podemos conocerla aplicando
una de las funciones para hallar la hipotenusa del ejemplo 4.5. Luego comparamos el valor
obtenido en la aplicaci
on con cada una de las distancias de las circunferencias y de esta
manera conocemos el puntaje. El algoritmo 5.2 muestra la funcion.
Vemos que si se aplica esta funcion con un disparo
en la posicion (100,100), el puntaje

obtenido es 300 ya que la distancia calculada ( 1002 + 1002 = 141,42) se encuentra entre
125 y 150. Podemos notar ademas que si se calcula una distancia mayor a 200, el puntaje
retornado es cero; de all que se puede asumir que el disparo no le pego al tablero.
Ahora hacemos el procedimiento para simular un juego. Para realizar la simulaci
on usamos un sistema de n
umeros aleatorios. Este sistema nos permite asumir disparos al azar,
es decir, no tenemos que inventarnos unos n
umeros y cada vez que ejecutemos la simulaci
on obtendremos disparos diferentes (un sistema inicial desconocido). Las operaciones del
sistema de n
umeros aleatorios se encuentra en el cuadro 5.2.
El procedimiento para la simulacion se encuentra en el algoritmo 5.3. Primero se hallan
los disparos utilizando la funcion randint(), luego se hallan los puntajes y con ellos se

58

5.1 Condicion

randint(a,b)

Acci
on
Retorna el siguiente n
umero real aleatorio en el rango [0,0, 1,0)
Retorna n
umero aleatorio en la lista de n
umeros entre i y f con
intervalos de p. Por ejemplo, si queremos un n
umero aleatorio par
entre 0 y 10, le enviamos los argumentos a la funcion: i=0, f=10,
p = 2 (la lista de n
umeros entre 0 y 10 con intervalos de 2 es
{0, 2, 4, 6, 8, 10})
Retorna un n
umero entero aleatorio n de manera que a n b

FT

Operaci
on
random()
randrange(i,f,p)

Cuadro 5.2: Operaciones b

asicas de un sistema de n
umeros aleatorios

encuentra el ganador.

DR
A

def puntajeXdisparo(x,y):
"Funcion que retorna el puntaje dado el disparo"
distancia = longitudHipotenusa2(x,y)
puntaje = 0
if distancia <= 25:
puntaje = 1000
if distancia > 25 and distancia <= 50:
puntaje = 800
if distancia > 50 and distancia <= 75:
puntaje = 600
if distancia > 75 and distancia <= 100:
puntaje = 500
if distancia > 100 and distancia <= 125:
puntaje = 400
if distancia > 125 and distancia <= 150:
puntaje = 300
if distancia > 150 and distancia <= 175:
puntaje = 200
if distancia > 175 and distancia <= 200:
puntaje = 100
return puntaje

Algoritmo 5.2: Retorna el puntaje dado un disparo

En el algoritmo 5.3 pueden notarse algunas cosas. El juego consiste en tres disparos que
se representan con seis variables (la posicion en x y y de cada disparo). Con estas seis
variables se calculan los tres puntales obtenidos en los tres disparos, que se suman para
tener el puntaje total. Lo anterior se realiza para los dos jugadores. Puede verse que todas

59

5 Noci
on de Condici
on

FT

las variables (excepto las de puntaje total) son asignadas dos veces, esto esta bien ya que
una vez se usan las variables para realizar los calculos, su valor deja de ser necesario. Por
otro lado, cada posici
on de un disparo se tiene despues de aplicar la funcion randint() con
argumentos 0 y 250; como la distancia maxima para obtener un punto es 200, este valor
(250) permite simular un jugador que realiza un tiro malo.
def tiroAlBlanco():
"Procedimiento que simula un juego de tiro al blanco"
# Jugador 1
disparo1x = random.randint(0,250)
disparo1y = random.randint(0,250)
disparo2x = random.randint(0,250)
disparo2y = random.randint(0,250)
disparo3x = random.randint(0,250)
disparo3y = random.randint(0,250)
puntaje1 = puntajeXdisparo(disparo1x,disparo1y)
puntaje2 = puntajeXdisparo(disparo2x,disparo2y)
puntaje3 = puntajeXdisparo(disparo3x,disparo3y)
puntajeTotalJugador1 = puntaje1 + puntaje2 + puntaje3

DR
A

# Jugador 2
disparo1x = random.randint(0,250)
disparo1y = random.randint(0,250)
disparo2x = random.randint(0,250)
disparo2y = random.randint(0,250)
disparo3x = random.randint(0,250)
disparo3y = random.randint(0,250)
puntaje1 = puntajeXdisparo(disparo1x,disparo1y)
puntaje2 = puntajeXdisparo(disparo2x,disparo2y)
puntaje3 = puntajeXdisparo(disparo3x,disparo3y)
puntajeTotalJugador2 = puntaje1 + puntaje2 + puntaje3
# Ganador
if puntajeTotalJugador1 > puntajeTotalJugador2:
turtle.write("El ganador es el jugador 1")
if puntajeTotalJugador1 < puntajeTotalJugador2:
turtle.write("El ganador es el jugador 2")
if puntajeTotalJugador1 == puntajeTotalJugador2:
turtle.write("El juego quedo empatado")

Algoritmo 5.3: Simula un juego de tiro al blanco

? ? ?

En algunas ocasiones solo se tiene una posible condicion en el sistema que se est
a mode-

60

5.1 Condicion

lando. Por esto si la condici

on se cumple entonces el flujo de ejecucion del programa va por
un camino, pero si no se cumple el flujo debe ir por otro. En estos casos, se puede hacer uso
del complemento opcional de un condicional (if) llamada la condici
on por defecto (else).
El ejemplo 5.3 muestra el uso de la condicion por defecto.

FT

Ejemplo 5.3
Retomando el ejemplo 4.6, si quisieramos que la tortuga escribiera la fecha cronologicamente bien (que no escriba Marzo 54 de 2000, por ejemplo) entonces despues de aplicar
la funcion Pascua() debemos tener en cuenta los casos. Si el n
umero retornado es menor
o igual que 31, entonces la tortuga debe escribir la fecha en Marzo, de lo contrario debe
escribir la fecha en Abril.
El algoritmo 5.4 muestra el c
odigo para la escritura correcta de la fecha del domingo
de Pascua de cualquier a
no. Es claro que si el da no es menor o igual a 31 entonces debe
ser mayor a 31 (es la u
nica otra opci
on), por lo tanto se puede utilizar la condicion por
defecto, es decir, no hay necesidad de especificar if d
a > 31:. Adicionalmente, para
escribir la fecha correcta es necesario utilizar unas operaciones para manejo de cadenas de
texto. El cuadro 5.3 describe algunas operaciones basicas de cadenas de texto.

Condici
on por Defecto

DR
A

def PascuaMejorado(ano):
"Escribe el da del domingo de Pascua de acuerdo a un ano"
# Halla el da del domingo de Pascua
dia = Pascua(ano)
# Si el dia pertenece a Marzo o a Abril
if(dia <= 31):
fecha = "Marzo " + str(dia) + " de " + str(ano)
else:
dia = dia - 31
fecha = "Abril " + str(dia) + " de " + str(ano)
# Escribe la fecha
turtle.write(fecha, False, align="center",
font=("Arial",32,"normal"))
turtle.penup()
turtle.goto(-235,235)

Algoritmo 5.4: Escribe correctamente la fecha del domingo de Pascua

? ? ?

61

5 Noci
on de Condici
on

len(w)
find(w,s)

capitalize(w)
w1 + w2
w * n
c in w

Acci
on
Retorna una cadena de texto que contiene una representacion imprimible del objeto w
Retorna el n
umero de caracteres de la cadena w
Retorna la posicion mas cercana al inicio donde se encuentre la
subcadena s dentro de la cadena w. Si la subcadena no se encuentra
en w, retorna -1
Retorna la cadena w en may
usculas
Retorna la concatenacion de las cadenas w1 y w2
Retorna n copias de la cadena w concatenadas
Retorna un booleano que indica si el caracter c se encuentra en la
cadena w

FT

Operaci
on
str(w)

Cuadro 5.3: Operaciones basicas de un sistema de cadenas de texto

DR
A

Ejemplo 5.4
Supongamos que la tortuga Junior debe ir a un sitio particular de la ciudad. Las opciones
de transporte son: Bus, Taxi o Carro Particular. Si Junior necesitase llegar antes de 15
minutos y tuviera $30000, entonces Junior escoge mejor irse en Taxi, sin embargo si tuviera
un poco mas de tiempo e igual cantidad de dinero, sera indiferente el medio de transporte.
Si tuviera 1 hora o m
as para llegar a su destino, la tortuga preferira ahorrar el dinero e
irse en Bus. Lo anterior se calcula solo si Junior no tuviera a nadie que lo lleve en Carro
Particular.

Para resolver este problema es necesario tener en cuenta todas las condiciones necesarias
para cada opci
on de transporte. El algoritmo 5.5 muestra una forma de solucionar el
problema.
La funci
on transporte() tiene tres parametros: dinero, tiempo y carro. El dinero
y el tiempo son entonces variables de tipo entero, mientras que carro es una variable
de tipo Booleano. Por comodidad, el transporte por defecto sera Carro Particular (la
variable local transporte se declara con este valor). Si el argumento que se manda para el
par
ametro carro en la aplicacion de esta funcion es True entonces simplemente se retorna
el transporte por defecto. De lo contrario, se debe verificar el tiempo: si es mayor o igual a
una hora entonces el transporte sera Bus, sino tenemos que consultar el dinero: si se tienen
los $30000 pero no hay problema con el tiempo (la tortuga necesita llegar entre 15 y 60
minutos) entonces se toma el Bus, sin embargo si hay prisa (15 minutos o menos) se tiene
que tomar Taxi.

62

? ? ?

5.2 Ejercicios

return transporte

FT

def transporte(dinero, tiempo, carro):

"Decide el medio de transporte para ir a un sitio"
transporte = "Carro Particular"
if not carro:
if tiempo >= 60:
transporte = "Bus"
else:
if dinero == 30000:
if tiempo > 15 and tiempo < 60:
transporte = "Bus"
else:
transporte = "Taxi"
else:
transporte = "Bus"

Algoritmo 5.5: Retorna el medio de transporte para ir a un sitio de acuerdo a unas

condiciones

Ejercicios

DR
A

5.2.

5.1 Dado el estado inicial del problema de mayora de edad (ejemplo 5.1) y la funcion
esMayorDeEdad(), escriba el algoritmo necesario para que la tortuga vaya al sitio
adecuado dependiendo de la edad que tiene, deje una lnea punteada por el camino
que recorre y se abran las puertas del sitio, como en la figura 5.2.
5.2 Modifique los algoritmos necesarios del ejemplo 5.2 para que graficamente se muestren
los disparos cuando se realicen (i.e. en las posiciones retornadas por la operacion del
sistema aleatorio).
5.3 La formula de Pascua del ejemplo 4.6 funciona para cualquiera a
no en el rango
de 19002099 excepto para 1954, 1981, 2049 y 2076. Para estos 4 a
nos la formula
produce una fecha que est
a una semana despues. Escriba la funcion Pascua2() con
las modificaciones necesarias para que la formula funcione para todos los a
nos.
5.4 Un a
no es bisiesto si es divisible por 4, a menos que sea un a
no que no es divisible
por 400 (1800 y 1900 no son bisiestos, mientras que 1600 y 2000 s lo son). Escriba
la funcion Bisiesto() que retorne True si el a
no que le entra es bisiesto, y retorne
False de lo contrario.

63

5 Noci
on de Condici
on

5.5 Escriba la funci

on FechaValida() que tenga tres parametros correspondientes a una
fecha (da, mes y a
no), y retorne True si la fecha es valida, y False de lo contrario.
Por ejemplo hda: 24, mes: 5, a
no: 1962i es valida, pero hda: 31, mes: 9, a
no: 2000i
no lo es (Septiembre solo tiene 30 das).

FT

5.6 Los das del a

no pueden numerarse del 1 al 365 (o 366). Este n
umero puede ser
calculado en tres pasos usando un sistema de n
umeros enteros:
a) N umeroDia = 31(mes 1) + dia

b) si el mes est
a despues de Febrero, reste (4mes + 23)/10
c) si es un a
no bisiesto y despues de Febrero 29, sume 1

DR
A

Escriba la funci
on NumeroDia() que tome una fecha (igual que el problema anterior,
es decir, representada en tres entradas da, mes y a
no), verifique que es una fecha
v
alida (usando la funcion del problema anterior), y calcule el n
umero asociado al da
del a
no.

64

FT

6 Noci
on de Repetici
on

DR
A

En la mayora de sistemas existen operaciones que se repiten una y otra vez. En el sistema
solar, por ejemplo, se ve que la traslaci
on de los planetas se repite, al igual que la rotacion
de la Tierra; en un sistema de producci
on las maquinas repiten un proceso de fabricacion;
en la formula 1 los carros repiten un recorrido un n
umero partcular de veces. Todas las
repeticiones mencionadas se hacen hasta que el sistema llega un estado deseado (algunas
de ellas son tantas que su cantidad podra entenderse como infinito).
En modelos computacionales las repeticiones pueden hacerse de manera explcita o
implcita, es decir, con estructuras que controlan el flujo de la ejecucion o con aplicaciones circulares de funciones que vayan reduciendo las entradas hasta un caso base. Una
repeticion explcita es com
unmente llamada iteracion mientras que la aplicacion circular de
una funcion (repetici
on implcita) es denominada recursion. A continuacion se vera cada
una de ellas.

6.1.

Iteraci
on

Un ciclo es una secuencia de aplicaci

on de operaciones que se especifican una sola vez
pero son ejecutadas un n
umero determinado de veces de manera sucesiva. Cada repeticion
de la secuencia es llamada una iteraci
on. El estado en el que queda el sistema despues de
una iteracion resulta ser el estado inicial de la siguiente iteracion. Las iteraciones terminan
cuando se llega a un estado particular, es decir, se continua la ejecucion del ciclo mientras
se cumpla una condici
on. Por ejemplo, la Tierra seguira dando vueltas alrededor del Sol
mientras el sistema solar se encuentre en un estado en el que el Sol exista, i.e. mientras
se cumpla la condici
on de que el Sol siga ah; los corredores de la formula 1 dan vueltas
mientras el sistema se encuentre en un estado en el que los corredores no hayan dado un
n
umero particular de vueltas, i.e. mientras se cumpla la condicion de que el n
umero de
vueltas de los corredores sea menor a un n
umero k.
En modelos computacionales funciona igual. Supongamos que queremos crear un juego
muy simple de adivinar un n
umero del 1 al 100. El jugador que quiere adivinar el n
umero
solo tiene cinco oportunidades de adivinar. Cada vez que el jugador intenta adivinar se le
da una pista que consiste en decirle si el n
umero a adivinar es menor o mayor al n
umero
que acaba de decir. El algoritmo 6.1 codifica el juego anterior.

65

Ciclo
Iteraci
on

6 Noci
on de Repetici
on

DR
A

FT

def adivinar(n):
"Procedimiento para jugar a adivinar un numero"
# Primera oportunidad
numero = input("Cual es el numero?")
if numero == n:
print("Adivino!!!")
else:
if numero > n:
print("El numero es menor")
else:
print("El numero es mayor")
# Segunda oportunidad
numero = input("Cual es el numero?")
if numero == n:
print("Adivino!!!")
else:
if numero > n:
print("El numero es menor")
else:
print("El numero es mayor")
# Tercera oportunidad
numero = input("Cual es el numero?")
if numero == n:
print("Adivino!!!")
else:
if numero > n:
print("El numero es menor")
else:
print("El numero es mayor")
# Cuarta oportunidad
numero = input("Cual es el numero?")
if numero == n:
print("Adivino!!!")
else:
if numero > n:
print("El numero es menor")
else:
print("El numero es mayor")
# Quinta oportunidad
numero = input("Cual es el numero?")
if numero == n:
print("Adivino!!!")
else:
print("Perdio, el numero era" + str(n))

Algoritmo 6.1: Juego de adivinar un n

umero, sin ciclo

66

6.1 Iteracion

FT

Si se aprecia bien el algoritmo de adivinar un n

umero, puede detallarse que una porcion
del codigo se repite varias veces haciendo que el codigo se torne aburrido y sin elegancia.
Adicionalmente, si el juego se extiende un poco, por ejemplo si el n
umero de intentos se
incrementa, la implementaci
on de este algoritmo se vuelve inmanejable. Por esta razon
es mas conveniente utilizar un ciclo en este problema. El algoritmo 6.2 es equivalente al
anterior algoritmo solo que utilizando ciclos. Utilizamos una variable temporal llamada
oportunidad para saber cuantas veces se ha repetido el ciclo, y mientras dicha variable sea
menor o igual a cinco repetimos el proceso de pedir un n
umero y saber si lo adivino o no.
Es de notar que cuando se adivina el n
umero se actualiza dicha variable temporal a cinco
para que el ciclo termine sin realizar el resto de iteraciones.

DR
A

def adivinar(n):
"Procedimiento para jugar a adivinar un numero"
oportunidad = 1
while oportunidad <= 5:
numero = input("Cual es el numero?")
if numero == n:
print("Adivino!!!")
oportunidad = 5
else:
if oportunidad == 5:
print("Perdio, el numero era" + str(n))
else:
if numero > n:
print("El numero es menor")
else:
print("El numero es mayor")
oportunidad = oportunidad + 1

Algoritmo 6.2: Juego de adivinar un n

umero, con ciclo

Tal como puede verse en los anteriores algoritmos, para solicitar un dato al usuario e
imprimir informaci
on en pantalla, pueden usarse tres operaciones basicas de entrada y
salida, las cuales pueden verse en el cuadro 6.1.
El flujo de ejecuci
on del algoritmo 6.2 (figura 6.1) muestra la semantica de un ciclo: el
cuerpo de un ciclo se ejecuta repetidamente mientras la condicion sea cierta. Una vez la
condicion sea falsa el ciclo termina. Cabe anotar que la condicion de un ciclo, en este caso,
se prueba al comienzo del ciclo (llamado ciclo while ), lo que hace que si inicialmente la
condicion es falsa, no se ejecute nada del cuerpo del ciclo.1
1

Existen otros tres tipos de ciclo: (1) aquel en el que la condici

on se prueba al final del ciclo, lo que

67

Ciclo while

6 Noci
on de Repetici
on

n
adivinar(n)

FT

oportunidad = 1

oportunidad <= 5?

Falso

Cierto

numero = input()

numero == n?
Cierto

print()
oportunidad = 5

Falso

oportunidad == 5?

DR
A

Cierto

Falso

print()

numero > n?
Cierto

print()

Falso

print()

oportunidad = oportunidad + 1

Figura 6.1: Flujo de ejecucion de la funcion adivinar()

garantiza que el cuerpo del ciclo se ejecute por lo menos una vez (ciclo do-while), (2) aquel en el que
no se prueba una condici
on sino que se especifica explcitamente cu
antas iteraciones se har
an en el ciclo
(ciclo for) y (3) aquel en el que se hace una iteraci
on sobre los elementos de una lista (ciclo for-each).

68

6.1 Iteracion
Operaci
on
input(t)
raw input(t)

FT

print(t)

Acci
on
Solicita al usuario un dato por medio del texto t y retorna lo que
el usuario entre con el tipo de dato apropiado
Solicita al usuario un dato por medio del texto t, pero retorna lo
que el usuario entre como una cadena de texto
Imprime en pantalla el texto t
Cuadro 6.1: Operaciones basicas de entrada y salida

Los siguientes ejemplos muestran otros modelos computacionales que usan ciclos y las
operaciones del cuadro 6.1.

DR
A

Ejemplo 6.1
El juego Triqui (Tic-Tac-Toe en ingles) consiste en una grilla de 3 3, donde dos jugadores X y O se turnan colocando su marca en una posicion vaca de la grilla. Cuando un
jugador logra colocar tres de sus marcas en lnea (vertical, horizontal o diagonal) gana el
juego. Luego, cada jugador lo que debe hacer es escoger una posicion y marcarla, y esto se
debe hacer mientras el juego no haya terminado (i.e. no haya un ganador o el tablero no
este lleno).

p1

p2

p3

p4

p5

p6

p7

p8

p9

Figura 6.2: Posiciones del juego Triqui

El algoritmo 6.3 muestra el c

odigo incompleto del juego. Dicho algoritmo esta dividido en
tres partes: la inicializaci
on de las variables locales, el juego como tal y la finalizacion donde
se conoce si hubo un ganador o qued
o empatado el juego. En la primera parte puede verse
que el juego de Triqui se considera como un conjunto de nueve posiciones (p1 . . . p9) como
en la figura 6.2. Cada posici
on, inicialmente con la cadena vaca, puede contener el smbolo
del jugador (X
o O). Como el juego es una secuencia de turnos, donde cada jugador realiza
En el captulo 7 se ver
a el ciclo for-each.

69

6 Noci
on de Repetici
on

FT

def JuegoTriqui():
"Programa para jugar Triqui"
# Inicializa las variables locales
jugador = "X"
p1 = p2 = p3 = p4 = p5 = p6 = p7 = p8 = p9 = ""

DR
A

# Juego
while not TriquiTerminado(p1,p2,p3,p4,p5,p6,p7,p8,p9):
jugada = input(jugador + ", escribe tu posicion")
if jugada == 1:
p1 = jugador
elif jugada == 2:
p2 = jugador
elif jugada == 3:
p3 = jugador
elif jugada == 4:
p4 = jugador
elif jugada == 5:
p5 = jugador
elif jugada == 6:
p6 = jugador
elif jugada == 7:
p7 = jugador
elif jugada == 8:
p8 = jugador
elif jugada == 9:
p9 = jugador
ImprimirTriqui(p1,p2,p3,p4,p5,p6,p7,p8,p9)
if jugador == "X":
jugador = "O"
else:
jugador = "X"
# Final del Juego y Ganador
ganador = QuienGanoTriqui(p1,p2,p3,p4,p5,p6,p7,p8,p9)
if ganador == "X":
print("Gano la X")
elif ganador == "0":
print("Gano la O")
else:
print("Empatado")

Algoritmo 6.3: Juego de Triqui incompleto

70

6.1 Iteracion

FT

la misma accion (decide en que posici

on escribe su smbolo) hasta que termine el juego,
esto se representa con segunda parte del algoritmo: mientras que el juego no esta terminado (la negaci
on de lo que retorna la funcion TriquiTerminado()) se pide al jugador la
posicion donde decide colocar su smbolo, se actualiza el tablero cambiando los valores de
las variables locales, se imprime (con la funcion ImprimirTriqui()) y se cambia el turno.
En la u
ltima parte se determina quien gana el juego con la funcion QuienGanoTriqui() y
se imprime el resultado.
? ? ?

Ejemplo 6.2
En un negocio de venta de productos al detal (e.g. una tienda de barrio, un supermercado o
restaurante) un cliente paga por un producto y si el dinero que entrega es mayor al precio
del producto, la empresa debe devolverle al cliente la cantidad excedente de dinero (el
cambio). Dicha cantidad debe ser desglosada en una denominacion que sea factible dadas
las restricciones de billetes y monedas que existen, por ejemplo, si el excedente es 12500,
pero solo se tienen billetes de 10000, entonces no es posible dar el cambio, pero si se tienen
billetes de 10000, de 2000 y monedas de 500, entonces el cambio es factible de dar.

DR
A

def desglose():
"Procedimiento que imprime el desglose de una cantidad de dinero"
producto = 17500
dinero = input("Con cuanto va a pagar?")
cambio = dinero - producto
print("Su cambio es:")
denominacion = 50000
while cambio > 0:
cantidad = cambio/denominacion
if cantidad > 0:
print(str(cantidad) + "de" + str(denominacion))
cambio = cambio%denominacion
denominacin = siguienteDenominacion(denominacion)

Algoritmo 6.4: Desglose de dinero

El algoritmo 6.4 es un procedimiento que pide al cliente el dinero para comprar un

producto e imprime la cantidad de billetes y monedas que debe dar como cambio. Se
asume un solo producto con un costo fijo de 17500 e igualmente se asume la funcion
siguienteDenominacion() la cual, dado un n
umero que representa una denominacion de
dinero, retorna la siguiente denominaci
on en orden descendente, i.e. si se le pasa como
argumento (un billete de) 50000, retornara (un billete de) 20000 (es decir, la siguiente

71

6 Noci
on de Repetici
on
denominaci
on), si se le pasa 20000, retornara 10000, y as sucesivamente.2
? ? ?

FT

Ejemplo 6.3
Supongamos que queremos imprimir la lista de los n
umeros primos del 1 al n. Para hacer
esto debemos hacer un ciclo desde 1 hasta n imprimiendo el n
umero i (1 i n) en
cada iteraci
on. Sin embargo i se debe imprimir solo si es primo y esto lo sabemos si dicho
n
umero es divisible solo entre 1 y el mismo, es decir, si el residuo de la division entre i y
todos los n
umeros entre 2 y i 1 es diferente de cero. Para esto u
ltimo debemos hacer otro
ciclo. El algoritmo 6.5 muestra el anterior procedimiento.
def primos(n):
"Procedimiento que imprime los nmeros primos de 1 a n"
i = 1
while i < n:
esprimo = True
j = 2
while j <= i-1:
if i%j == 0:
esprimo = False
j = j + 1
if esprimo == True:
print(i)
i = i + 1

DR
A

Ciclos Anidados

Existen algunos problemas cuya solucion requiere que en el cuerpo del ciclo, es decir, en
medio de las operaciones que se quieren repetir, hayan otros ciclos. Estos son com
unmente
llamados ciclos anidados.

Algoritmo 6.5: Imprime la lista de n

umero primos entre 1 y n
? ? ?

Es normal que en algunos problemas el objetivo que se quiere lograr al realizar un ciclo
se cumpla antes de terminar el ciclo, es decir, cuando todava la condicion es cierta. Para
2

Es de notar que en el algoritmo 6.4 el desglose comienza desde la denominaci

on m
as alta hasta la mas
peque
na. Esta es la forma m
as simple de hacerlo, pero no es la u
nica. Un estudiante puede afirmar que
se podra dar cambio de 12500 solo con monedas de 500 y no como se mencion
o arriba. Lo importante
aqu es saber que el problema de encontrar todos los posibles desgloses de dinero es un problema
combinatorio, y por lo tanto, muy difcil de resolver.

72

6.1 Iteracion

Rompimiento

FT

estos casos resulta ineficiente continuar realizando iteraciones ya que lo que se pretenda ya
se ha cumplido. Hay dos posibles soluciones para estos problemas: (1) forzar manualmente
a que se incumpla la condici
on del ciclo, o (2) usar una instruccion de rompimiento. Un
3
rompimiento es una estructura de control que altera la forma de proceder de una iteracion, causando que el ciclo m
as interno en el que se encuentra el rompimiento se termine
inmediatamente cuando es ejecutado.
De igual manera, en algunos ciclos resulta u
til que en alg
un punto de la iteracion el flujo
de ejecucion se mueva a la siguiente iteracion sin continuar mas alla en el cuerpo de la
actual iteracion. Estas estructuras de control son llamadas continuaciones.
En el ejemplo 6.4 se muestra una situacion com
un donde el uso de los rompimientos y
continuaciones es adecuado.

DR
A

Ejemplo 6.4
Supongamos que necesitamos hacer un interpretador on-line del lenguaje de programacion
Python. Esta es una tarea bastante laboriosa y requiere un conocimiento muy avanzado,
por lo que queremos empezar simplemente quitando los comentarios, ya que estos, por
definicion, son solo anotaciones y siempre son ignorados por los interpretadores. Para esto,
entonces, debemos pedir al usuario que vaya ingresando lnea por lnea, el codigo del programa que esta desarrollando, y cada vez que el usuario escribe una lnea, revisar el primer
caracter de dicha lnea y si es un smbolo # significa que esa lnea es un comentario y
no debe ser interpretada. El algoritmo 6.6 muestra este procedimiento.
Puede notarse que la condici
on del ciclo es la constante True, esto significa que la condicion siempre ser
a cierta y por lo tanto el n
umero de iteraciones esta indeterminado. Lo
anterior es necesario ya que de antemano no se sabe cuantas lneas de codigo va a ingresar el usuario. Una vez se obtiene la lnea de codigo (un texto), se pregunta si el primer
caracter de dicho texto es el smbolo # y si la respuesta es afirmativa no hay necesidad
de seguir con el resto del cuerpo del ciclo sino que simplemente se vuelve a pedir una lnea
de codigo. Si la respuesta es negativa se revisa si lo que hizo fue presionar enter en cuyo
caso se revisa si se ha presionado enter dos veces seguidas y se termina la interpretacion,
es decir, se interrumpe el ciclo. Si no pasa lo anterior, entonces se aplica el procedimiento
para interpretar el c
odigo que se ha introducido, el cual no sera implementado aqu.

? ? ?

Hasta el da de hoy existe una fuerte discusi

on sobre si usar rompimientos es una buena o mala pr
actica de
programaci
on. Nosotros pensamos que todo depende del uso que se haga de la instrucci
on, e invitamos a
los lectores a desarrollar varios ejemplos us
andola y leer el famoso artculo de Donald Knuth, Structured
Programming with go to Statements [2] para sacar sus propias conclusiones.

73

Continuaci
on

6 Noci
on de Repetici
on

FT

def quitarComentarios():
"Procedimiento que recibe lineas codigo en python"
"las envia a interpretar, excepto los comentarios"
print("Comienzo de la Interpretacion")
enter = 1
# Ciclo para capturar todas las lineas
while True:
# Pide una linea de codigo al usuario
linea = raw_input(">>> ")
# Verifica si la linea es un comentario
if string.find(linea,"#") == 1:
continue

DR
A

# Verifica si termina el codigo

if linea == "":
if enter == 2:
print("Fin de la Interpretacion")
break
else:
enter = enter + 1
# Envia la linea a interpretar y continua
else:
Interpretar(linea)
enter = 1

Algoritmo 6.6: Recibe lneas de codigo y quita los comentarios

6.2.

Recursi
on

A diferencia de la repetici
on por medio de iteracion, la repeticion por medio de recursi
on
no cambia el estado del sistema en cada repeticion. Lo que hace es abstraer el c
odigo a
repetir y luego repite la aplicacion de dicha abstraccion reduciendo los argumentos en cada
repetici
on hasta cumplir una condicion. De esta manera la recursion hace que el problema
que se est
a resolviendo se divida en dos o mas piezas conceptuales (i.e. idea matem
atica
de dividir y conquistar), cada una de ellas siendo una version mas peque
na del problema
original.
Los fractales son ejemplos reales de la idea de recursion. En la figura 6.34 puede verse
un helecho, el cual est
a constituido de helechos con una medida mas peque
na, que a su vez
4

Imagen tomada de http://www.fresh-paper.com/

74

6.2 Recursion

DR
A

FT

estan constituidos de helechos mas peque

nos, y as sucesivamente.

Figura 6.3: Fractal

Como en recursi
on el conjunto de operaciones que se quiere repetir es abstrado en un
procedimiento o funci
on, la forma de hacer repeticion es aplicando dicho procedimiento o
funcion dentro de la misma abstracci
on. De all que la nocion de recursi
on sea descrita
como una operaci
on definida en terminos de s misma. Por ejemplo, encontrar el factorial
de un n
umero n es igual a encontrar el factorial del n
umero anterior, n 1, y multiplicar
su resultado por n, es decir, f act(n) = f act(n 1) n.
Sin embargo, si desarrollamos la recursion del factorial as como esta: f act(n) = n

75

Recursi
on

6 Noci
on de Repetici
on
f act(n 1), podemos ver que es infinita, es decir, nunca para:
f act(n) = n f act(n 1)
f act(n 1) = (n 1) f act(n 2)

FT

f act(n 2) = (n 2) f act(n 3)
..
.

Para evitar esto es necesario garantizar que en alg

un punto la recursion se detenga. Ese
punto donde la recursi
on para es llamado el caso base. El caso base de la funcion factorial es
el factorial de cero, ya que esta funcion no esta definida para n
umero negativos. Entonces si
decimos que f act(0) = 1, vemos que la funcion general (tambien llamada paso de reducci
on)
funciona hasta que llega a este punto, donde se termina la recursion. La implementaci
on
completa de la funci
on factorial esta en el algoritmo 6.7.

DR
A

def factorial(n):
"Funcion que halla el factorial de un numero"
if n == 0:
return 1
else:
return n * factorial(n-1)

Algoritmo 6.7: Halla el factorial de un n

umero n

Seguir el flujo de ejecuci

on de un algoritmo recursivo no es algo intuitivo ya que es
necesario estar muy atento al nivel de recursion en el que se encuentra la ejecuci
on. El
nivel de recursi
on est
a dado por el n
umero de aplicaciones del paso de reduccion: cada
vez que se aplica el paso de reduccion se aumenta el nivel de recursion hasta que se llega
al caso base, una vez all se comienza a devolver en los niveles hasta volver a la primera
aplicaci
on (nivel cero). La figura 6.4 muestra graficamente el flujo de la aplicacion de la
funci
on factorial del algoritmo 6.7 para n = 5. Cada cuadro de la figura representa una
aplicaci
on de la funci
on factorial(); cuando se hace la primera aplicacion (nivel 0), n es
igual a 5, luego la condici
on es falsa y el flujo de ejecucion se va por el paso de reducci
on
(return 5*factorial(n-1)). Como el resultado de factorial(5-1) no se conoce, esto
hace que se haga una nueva aplicacion de la funcion y, por lo tanto, aumente el nivel de
recursi
on (nivel 1). En esta nueva aplicacion n es igual a 4, entonces la condicion es falsa y,
con factorial(4-1) desconocido, de nuevo el flujo se va por el paso de reduccion, se hace
una nueva aplicaci
on de la funcion (nivel 2). Esto se repite tres veces mas hasta que en la
aplicaci
on de la funci
on n sea igual a cero; en este caso la condicion es cierta y entonces el

76

6.2 Recursion

n=5
factorial(5)
nivel 0

n == 0?
Cierto
return 1

Falso
return 5 * factorial(n-1)

n=4

factorial(4)
nivel 1

n == 0?
Cierto
return 1

Falso
return 4 * factorial(n-1)

retorna 24
n=3

factorial(3)
nivel 2

n == 0?
Cierto
return 1

FT

retorna 120

Falso

return 3 * factorial(n-1)

retorna 6

n=2

DR
A

factorial(2)
nivel 3

n == 0?

Cierto

return 1

Falso

return 2 * factorial(n-1)

retorna 2

n=1

factorial(1)
nivel 4

n == 0?

Cierto

return 1

Falso

return 1 * factorial(n-1)

retorna 1

n=0
n == 0?

Cierto

return 1

factorial(0)
nivel 5

Falso
return n * factorial(n-1)

retorna 1

Figura 6.4: Flujo de ejecucion de la funcion factorial(5)

77

6 Noci
on de Repetici
on

FT

flujo de ejecuci
on cambia y la funcion, en el nivel 5 de recursion, retorna 1. Este cambio en
el flujo hace que se empiece a conocer el resultado de las aplicaciones de las funcion: en el
nivel 4, factorial(1-1) es igual a 1, de all que la funcion factorial en el nivel 4 retorne
1 1 = 1; este resultado hace que se conozca factorial(2-1) y se retorne 2 1 = 2 en el
nivel 3; y as sucesivamente hasta volver al nivel 0 donde se retornara el resultado final.
A continuaci
on se muestran otros ejemplos de algoritmos recursivos.

DR
A

Ejemplo 6.5
Cuenta la leyenda que en un templo de Hanoi, bajo la c
upula que se
nala el centro del mundo,
hay una bandeja de bronce con tres largas agujas. Al crear el mundo, Dios coloco en una
de ellas sesenta y cuatro discos de oro, cada uno de ellos mas peque
no que el anterior hasta
llegar al de la cima. Da y noche, incesantemente, los monjes transfieren discos de una
aguja a otra siguiendo las inmutables leyes de Dios, que dicen que debe moverse cada vez
el disco superior de los ensartados en una aguja a otra y que bajo el no puede haber un
disco de menor radio. Cuando los sesenta y cuatro discos pasen de la primera aguja a otra,
todos los creyentes se convertiran en polvo y el mundo desaparecera con un estallido.5
El objetivo es modelar computacionalmente este problema. La situacion inicial del problema para cuatro discos esta en la figura 6.5.

Figura 6.5: Torres de Hanoi - Configuracion inicial

Y se desea pasar a la situacion final de la figura 6.6.

Figura 6.6: Torres de Hanoi - Configuracion final

La leyenda fue inventada por De Parville en 1884, en Mathematical Recreations and Essays, un libro
de pasatiempos matem
aticos. La ambientaci
on era diferente: el templo estaba en Benares y el dios era
Brahma.

78

6.2 Recursion

FT

Aunque solo se puede tocar el disco superior de un monton, se debe pensar en el disco
del fondo. Ese disco debe pasar de la primera aguja a la tercera, y para que eso sea posible,
se debe alcanzar la configuraci
on de la figura 6.7.

Figura 6.7: Torres de Hanoi - Configuracion intermedia 1

DR
A

Solo en ese caso se puede pasar el disco mas grande a la tercera aguja, es decir, alcanzar
la configuracion de la figura 6.8.

Figura 6.8: Torres de Hanoi - Configuracion intermedia 2

Esta claro que el disco m

as grande no se va a mover ya de esa aguja, pues es su destino
final. La pregunta que surge entonces es: Como se han pasado los tres discos superiores
a la segunda aguja? Pues simple, pasar una pila de tres discos de una aguja a otra no es
mas que el problema de las torres de Hanoi para una torre de tres discos. De este punto lo
que falta por hacer es mover la pila de tres discos de la segunda aguja a la tercera, y eso,
nuevamente, es el problema de la torres de Hanoi para tres discos. Ah aparece la recursion.
Resolver el problema de las torres de Hanoi con n discos requiere entonces:
resolver el problema de las torres de Hanoi con n 1 discos, aunque pasandolos de
la aguja inicial a la aguja libre;
mover el u
ltimo disco de la aguja en que estaba inicialmente a la aguja de destino;
y resolver el problema de las torres de Hanoi con n 1 discos de la aguja libre a la
aguja final.

Hay un caso trivial o caso base: el problema de la torres de Hanoi para un solo disco
(basta con mover el disco de la aguja en la que este insertado a la aguja final).

79

6 Noci
on de Repetici
on

Los par
ametros que necesita el procedimiento son el n
umero de discos que vamos a
mover, la aguja origen y la aguja destino. Se identificara cada aguja con un n
umero. El
procedimiento se encuentra en el algoritmo 6.8.

FT

def torresHanoi(n, inicial, final):

"Procedimiento para resolver el problema de las torres de Haoi"
if n == 1:
print("Mover el disco superior de la aguja " + str(inicial))
print("a la aguja " + str(final))
else:
# Determinar cual es la aguja libre
if inicial != 1 and final != 1:
libre = 1
else:
if inicial != 2 and final != 2:
libre = 2
else:
libre = 3
# Primer subproblema: mover n-1 discos de inicial a libre
torresHanoi(n-1, inicial, libre)

DR
A

print("Mover el disco superior de la aguja " + str(inicial))

print("a la aguja " + str(final))
# Segundo subproblema: mover n-1 discos de libre a final
torresHanoi(n-1, libre, final)

Algoritmo 6.8: Imprime el proceso para solucionar las torres de hanoi de n discos

Ahora, para resolver el problema con n = 4 se hace el llamado al procedimiento torresHanoi(4,1,3). El programa imprimira las ordenes correspondientes a los
movimientos de la figura 6.9.

Interfaz Grafica

? ? ?

La soluci
on para el problema de las torres de Hanoi esta bien, pero no muestra gr
aficamente el proceso, es decir, solo describe textualmente los pasos para resolver el problema.
Para los siguientes problemas vamos a introducir un sistema para desarrollar interfaces
gr
aficas llamado Tkinter6 . Una interfaz gr
afica es un espacio de interaccion entre una persona y un programa con im
agenes en vez de comandos de texto. Algunas operaciones del
6

El sistema Tkinter (Tk Interface) es la interfaz est

andar de Python para el sistema gr
afico Tk GUI
toolkit.

80

6.2 Recursion

2)

3)

4)

5)

6)

7)

8)

9)

10)

11)

12)

13)

14)

15)

16)

FT

1)

Figura 6.9: Torres de Hanoi - Proceso completo para n = 4

sistema de interfaces gr
aficas Tkinter pueden verse en el cuadro 6.2.

Acci
on
Crea y retorna la ventana principal de un programa
Crea y retorna un nuevo boton en la ventana v con
texto t y que realiza la accion a cuando se oprime
Crea y retorna una nueva etiqueta en la ventana v
con texto t
Crea y retorna un nuevo campo de texto en la ventana v para un n
umero de caracteres c
Crea y retorna un nuevo campo de dibujo en la
ventana v de ancho w y alto h
Toma el widget y lo hace visible
Hace que la ventana se quede esperando los eventos
que puedan ocurrir hasta que se cierre la ventana

DR
A

Operaci
on
Tk()
Button(v,text=t,command=a)
Label(v,text=t)
Text(v,width=c)

Canvas(v,width=w,height=h)
pack()
mainloop()

Cuadro 6.2: Operaciones basicas del sistema Tkinter

Ejemplo 6.6
El Triangulo de Sierpinski es un fractal creado por Waclaw Sierpi
nski en 1915. El concepto
del Triangulo de Sierpinski es muy simple: Se toma un triangulo (usualmente, pero no
necesariamente, equil
atero) como la primera imagen de la figura 6.10; se conectan los
puntos medios de cada lado para formar cuatro triangulos separados y se corta el triangulo
del centro, como en la segunda imagen de la figura; para cada uno de los tres triangulos

81

6 Noci
on de Repetici
on

FT

restantes se realiza el mismo proceso como en la tercera imagen de la figura; y se repite el

proceso indefinidamente construyendo la imagen final de la figura.

...

Figura 6.10: Triangulo de Sierpinski

DR
A

La construcci
on de este fractal muestra claramente una recursion que puede ser implementada como la funci
on sierpinski() del algoritmo 6.9. La idea de este algoritmo se
centra en que el nivel de recursion en el que se encuentre el proceso determina el n
umero
de tri
angulos a dibujar: si estamos en un nivel inicial (cero) solo se dibuja un triangulo, en
el nivel uno se dibujan tres triangulos, en el nivel dos se dibuja nueve y as sucesivamente.
Lo importante a notar es que cada triangulo que se va a dibujar tiene una posicion particular y un tama
no especfico, y entre mas alto sea el nivel, la posicion cambiara de manera
mon
otona y dicho tama
no es mas peque
no (el tama
no de un lado de cualquiera de los tres
tri
angulos es la mitad del tama
no de un lado del triangulo superior).
Los par
ametros del procedimiento sierpinski() incluyen el canvas y las coordenadas
x y y donde ser
a dibujado el triangulo, el tama~
no del triangulo a dibujar y el nivel en el que
se encuentra la recursi
on. En el nivel cero simplemente se dibuja un triangulo usando el
procedimiento para crear polgonos (vease el cuadro 6.3); en cualquier otro nivel se realizan
tres llamados recursivos, correspondientes a los tres triangulos que se deben dibujar dentro
del tri
angulo superior.
El procedimiento gui-sierpinski() en el algoritmo 6.9 recibe como parametro el nivel
de profundidad del Tri
angulo de Sierpinski. Su proceso es simple: primero crea una ventana
y se la asigna a la variable v; entonces dentro de dicha ventana crea un canvas (asignado a
la variable miCanvas) de tama
no 500500 donde se dibujara el Triangulo de Sierpinski y se
hace visible con la operaci
on miCanvas.pack(); luego se hace el llamado al procedimiento
para construir y dibujar el triangulo enviando como argumento el canvas recien creado,
la posici
on dentro del canvas (100,400), el tama
no del triangulo mas grande y el nivel de
profundidad; finalmente se aplica la operacion para dejar a la ventana v lista para cualquier

82

6.3 Ejercicios

evento.

FT

def sierpinski(canvas, x, y, tamano, nivel):

"Procedimiento que dibuja el triangulo de sierpinski"
if (nivel == 0):
canvas.create_polygon(x, y,
x+tamano, y,
x+tamano/2, y-tamano*math.sqrt(3)/2,
outline="black",
fill="orange")
else:
sierpinski(canvas, x, y, tamano/2, nivel-1)
sierpinski(canvas, x+tamano/2, y, tamano/2, nivel-1)
sierpinski(canvas,
x+tamano/4, y-tamano*math.sqrt(3)/4,
tamano/2, nivel-1)

DR
A

def gui-sierpinski(nivel):
"Procedimiento que dibuja la ventana del triangulo de sierpinski"
v = Tkinter.Tk()
miCanvas = Tkinter.Canvas(v, width=500, height=500)
miCanvas.pack()
sierpinski(miCanvas, 100, 400, 300, nivel)
root.mainloop()

Algoritmo 6.9: Dibuja el triangulo de Sierpinski

Puede intuirse entonces que si se quisiera crear un Triangulo de Sierpinski con una
profundidad 4, se debera hacer la aplicacion del procedimiento gui-sierpinski(5).

6.3.

? ? ?

Ejercicios

6.1 Complete el juego de Triqui con las operaciones que no estan implementadas:
TriquiTerminado() recibe como parametros las nueve posiciones de un tablero
de Triqui y retorna True si alguno de los dos jugadores gano o si el tablero ya
esta completo y ninguno de los jugadores gano, de lo contrario retorna False.
ImprimirTriqui() recibe como parametros las nueve posiciones de un tablero
de Triqui e imprime el tablero de Triqui de una manera visualmente correcta
(i.e. como se ve normalmente el juego).

83

6 Noci
on de Repetici
on
Operaci
on
create arc(x0,y0,x1,y1)
create bitmap(x,y,bitmap=b)

create oval(x0,y0,x1,y1)

FT

create image(x,y,image=i)
create line(x0,y0,x1,y1,...,xn,yn)

create polygon(x0,y0,x1,y1,...,xn,yn)

create rectangle(x0,y0,x1,y1)

DR
A

create text(x,y,text=t)

Acci
on
Construye un arco desde el punto
(x0,y0) hasta el punto (x1,y1)
Muestra el mapa de bits b en el punto
(x,y)
Muestra la imagen i en el punto (x,y)
Construye una lnea que va por la serie de puntos (x0,y0), (x1,y1), . . . ,
(xn,yn)
Construye el ovalo que calza en el
rectangulo definido por los puntos
(x0,y0) y (x1,y1)
Construye un polgono cuya geometra
es especificada por los vertices definidos con los puntos (x0,y0), (x1,y1),
. . . , (xn,yn)
Construye el rectangulo definido por
los puntos (x0,y0) y (x1,y1)
Muestra el texto t en el punto (x,y)

Cuadro 6.3: Operaciones para dibujar en un Canvas de Tkinter

QuienGanoTriqui() recibe como parametros las nueve posiciones de un tablero

de Triqui y retorna una cadena de texto solo con el caracter correspondiente al
ganador del juego (X o O). Si no hubo ganador, la funcion debe retornar
un smbolo diferente.

6.2 El juego de Triqui del algoritmo 6.3 tiene algunos problemas, por ejemplo un jugador
puede seleccionar una posicion donde ya haba un smbolo, o si un jugador no ingresa
un n
umero entre 1 y 9 (las posiciones del tablero), pierde el turno. Corrija estos y
otros problemas que tiene el juego.
6.3 El algoritmo 6.4 tiene dos problemas, (1) si se paga con una cantidad menor al
costo del producto, no se da cambio, pero tampoco se especifica que le falta dinero
y (2) la funci
on siguienteDenominacion() no esta implementada. Solucione estos
problemas.
6.4 Asuma que en el problema del desglose de dinero se tiene una cantidad limitada de
billetes y monedas. Modifique el algoritmo 6.4 para que se tenga en cuenta el n
umero

84

6.3 Ejercicios

de billetes y monedas y, llegado el caso, imprima que no es posible dar el cambio

debido a que no se cuenta con las denominaciones necesarias.

FT

6.5 Asuma que el algoritmo soluci

on al problema del desglose va a ser usado en un
restaurante. Complete el algoritmo para que muestre un men
u de comida, le pida al
usuario seleccionar la comida que quiera (pueden ser varios platos), luego le pase la
cuenta y muestre el cambio dado lo que el cliente dio de dinero.
6.6 Mejore el algoritmo del punto anterior (6.5) haciendo que haya un n
umero n de
clientes, los cuales ven el men
u, escogen la comida y pagan. Este nuevo algoritmo
debe retornar la cantidad de dinero que pagaron todos los clientes del restaurante.
6.7 Muestre el flujo de ejecuci
on de la aplicacion del procedimiento torresHanoi(5,1,3).
6.8 Pruebe la funci
on torresHanoi() haciendo el llamado con los 64 discos de la leyenda,
es decir torresHanoi(64,1,3). Cuantos movimientos deben hacer los monjes?

DR
A

6.9 De manera general cu

antos movimientos son necesarios para resolver el problema con
n discos? Para responder esta pregunta escriba una funcion NumMovimientosHanoi()
que reciba un n
umero y devuelva el n
umero de movimientos necesarios para resolver
el problema de las torres de Hanoi con ese n
umero de discos (se debe utilizar la
funcion torresHanoi()).

6.10 Modifique el algoritmo 6.8 para mostrar graficamente el proceso de solucion de las
Torres de Hanoi. Puede usar el Mundo de la Tortuga o el sistema Tkinter.

85

DR
A

FT

6 Noci
on de Repetici
on

86

FT

7 Noci
on de Abstracci
on de Datos
En el captulo 4 se describi
o la abstraccion como el proceso en el que datos y algoritmos son agrupados dentro de una categora que los conecta. En este captulo veremos la
abstraccion que involucra datos.

7.1.

Listas

DR
A

La abstracci
on de datos, al igual que la abstraccion de control, permite ocultar informacion de manera que se presenten solo los datos relevantes a un contexto particular. De
esta forma se hace visible al usuario solo una interfaz de los datos mientras que los datos
como tal se vuelven privados y son accedidos solo a traves de dicha interfaz. Las interfaces, en general, son herramientas computacionales que sirven como punto de interaccion
entre componentes, los cuales pueden ser de bajo nivel como los sistemas operativos que
permiten interactuar piezas de hardware con programas, o de mas alto nivel como graficas (que brevemente se describieron en el captulo anterior) y estructuras de datos. Una
estructura de datos es un grupo de piezas de informacion reunidas bajo un mismo nombre. Su proposito es organizar eficientemente dicha informacion de manera que operaciones
como b
usqueda y ordenamiento se realicen de la mejor manera posible y se conserven las
propiedades matem
aticas que puedan existir en esas operaciones. Las estructuras de datos
comprenden, entre muchos otras, arreglos, registros, conjuntos, pilas, colas, arboles, grafos
y tablas hash, pero quiz
as las m
as usadas sean las listas.
Una lista es una secuencia de datos llamados elementos los cuales pueden ser accedidos
directamente por medio de un ndice. Para una lista X, el primer elemento tiene ndice
cero, es decir es el elemento X[0], el segundo elemento tiene ndice uno, o sea que es el
X[1], y as sucesivamente hasta el u
ltimo elemento cuyo ndice es igual al tama
no de la
lista menos uno, es decir que si n es el n
umero de elementos de la lista, el u
ltimo elemento
sera X[n 1].
Para ejemplificar la noci
on de lista y la necesidad de contar con ella, consideremos
un juego simple como el ahorcado. Este juego consiste en dos jugadores, uno de ellos
piensa en una palabra y dibuja lneas que representan las letras de dicha palabra, y el otro
jugador debe descifrar cu
al es esa palabra secreta. En cada turno el primer jugador dice
una letra y si esta letra pertenece a la palabra secreta el otro jugador escribira la letra
sobre la correspondiente lnea, pero si la letra no pertenece a la palabra el segundo jugador

87

Interfaz

Estructura de Datos

Lista

7 Noci
on de Abstracci
on de Datos

dibujar
a una parte de un hombre ahorcado. Si el primer jugador puede adivinar la palabra
secreta antes que se dibuje por completo el ahorcado, este gana, de lo contrario pierde. La
figura 7.1 muestra un juego de ahorcado: el primer jugador ha acertado 5 letras y fallado
igual n
umero de veces, por esto el dibujo del ahorcado esta muy cerca de terminarse.

FT

Letras Falladas:

U, S, E, T, L, B, V, K, Q

RA

DR
A

PRO

ON

Figura 7.1: Juego Ahorcado

Es de notar que ahorcado es posible convertirlo en un juego de un jugador contra el

computador ya que el segundo jugador que se nombro arriba solo se limita a interactuar
con las jugadas del primer jugador, es decir, solo selecciona una palabra y, cada vez que
el primer jugador dice una letra, verifica dicha letra y realiza la accion correspondiente:
escribir la letra en el espacio adecuado o dibujar una parte del cuerpo del ahorcado. La
palabra seleccionada por el segundo jugador debe ser parte de un conjunto de palabras
que conoce, lo suficientemente grande para que se pueda jugar una y otra vez cambiando
la palabra secreta y que as el primer jugador no sepa cual es de manera anticipada. Si
us
aramos una variable para cada palabra, se tendra una cantidad absurda e inmanejable
de variables, y si a eso le adicionamos las variables necesarias para conocer cuales son las
letras que ya se han probado, se complica a
un mas el algoritmo. Por esto son indispensables
unas estructuras de datos que re
unan y organicen las palabras y las letras sin necesidad de
crear dicha cantidad de variables.
El procedimiento para jugar ahorcado se encuentra en el algoritmo 7.1. Se cuenta con tres
listas listaPalabras, letrasAcertadas y letrasFalladas. El proposito de listaPalabras
es intuitivo (aunque debera tener muchos mas elementos para hacer el juego mas diver-

88

7.1 Listas

# Dibuja la ventana inicial

ventana = saludoInicial()

FT

def juegoAhorcado():
"Procedimiento para un juego de ahorcado"
listaPalabras = ["abstraccion", "ciclo", "declaracion", "estado",
"flujo", "implementacion", "grafica", "lista",
"modelo", "parametro", "recursion", "sistema"]
indice = random.randint(0, len(listaPalabras)-1)
palabraSecreta = listaPalabras[indice]
letrasAcertadas = []
letrasFalladas = []
juegoAcabado = False

# Ciclo del juego

while not juegoAcabado:
# Dibuja/Actualiza el tablero
dibujarTablero(ventana, palabraSecreta,
letrasAcertadas, letrasFalladas)

DR
A

# Pide una letra al jugador

letra = pedirLetra(ventana)

# Procede de acuerdo a la letra dada

letrasAcertadas.append(letra)
if letra in palabraSecreta:
# Chequea si encontro todas las letras
num = 0
completoPalabra = True
while num < len(palabraSecreta):
if not palabraSecreta[num] in letrasAcertadas:
completoPalabra = False
break
num = num + 1
if completoPalabra:
acabarJuego(ventana, True)
juegoAcabado = True
else:
# Chequea si se ha ahorcado
if len(letrasFalladas) == 10:
acabarJuego(ventana, False)
juegoAcabado = True

Algoritmo 7.1: Juego ahorcado

89

7 Noci
on de Abstracci
on de Datos

Acci
on
Agrega el elemento x al final de la lista
Inserta el elemento x en la posicion i de la lista
Borra el primer elemento de la lista que tenga valor x
Retorna y borra el elemento de la lista cuya posicion es i
Retorna el tama
no de la lista l
Retorna un booleano que indica si el elemento x se encuentra
en la lista l
Retorna una lista con los n
umeros del cero al n-1 como
elementos

DR
A

Operaci
on
append(x)
insert(i,x)
remove(x)
pop(i)
len(l)
x in l

FT

tido). Las otras dos listas sirven para llevar un registro de las letras que el jugador va
diciendo, en una van las letras que efectivamente se encuentran en la palabra secreta y en
la otra aquellas que no.
Al inicio del juego se toma una palabra de manera aleatoria de la lista listaPalabras
y se asigna a la variable palabraSecreta. Luego se da un saludo inicial (en teora se
debe mostrar una splash screen 1 ) con un procedimiento no implementado aqu llamado
saludoInicial(), y despues arranca el ciclo del juego: primero dibuja o actualiza el tablero
con el procedimiento dibujarTablero(), el cual debe mostrar una imagen como la figura
7.1 dada la palabra secreta y las listas de registro de letras; acto seguido le pide una letra
al jugador con la funci
on pedirLetra(); por u
ltimo, de acuerdo a la letra dada se realiza
el proceso correspondiente, es decir, agregar la letra a la lista letrasAcertadas o a la lista
letrasFalladas y, si es el caso, terminar el juego ya sea porque encontro todas las letras
de la palabra secreta o porque fallo diez letras y se termino de dibujar el ahorcado.
En el algoritmo 7.1 puede verse el uso de algunas operaciones para manejar listas como
append y in. Estas y otras operaciones basicas del sistema de listas se pueden ver en el
cuadro 7.1.

range(n)

Cuadro 7.1: Operaciones basicas del sistema de listas

Las operaciones saludoInicial(), dibujarTablero(), pedirLetra() y acabarJuego()

aplicadas en el algoritmo 7.1 realizan procesos graficos, por lo que pueden ser implementadas usando el sistema TkInter. Sin embargo, dado que ahorcado es un juego, podemos
usar un sistema especializado en la construccion de juegos. De all que vamos a introducir
pygame, un sistema para el desarrollo de juegos.
1

Una splash screen o pantalla de inicio, es una imagen que se muestra al inicio de un programa para presentar el logo y/o ttulo del programa, y adem
as para notificar al usuario que el programa se
est
a cargando.

90

7.1 Listas

FT

Pygame2 es una librera dise

nada para construir software multimedia. Cuenta
con operaciones para manejo de video y sonido que permiten desarrollar video
juegos. De igual manera, pygame tiene funciones para manejar graficos 2D,
m
usica, entradas, fuentes, detecci
on de colisiones, graficos 3D con OpenGL,
joysticks, pelculas, etc.
Las operaciones b
asicas y algunas constantes de pygame se pueden ver en el cuadro 7.2.
Operaci
on
init()
quit()
display.set mode(r)

display.update()
event.get()
mouse.get pos()

DR
A

font.SysFont(f,t)
draw.rect(s,c,r,w)

Acci
on
Inicializa todo el sistema pygame
Termina el sistema
Inicializa una ventana para trabajar y retorna un display
(dispositivo de salida). Su parametro r representa la resoluci
on de la ventana (una pareja (w, h) donde w es el ancho y
h es el alto de la ventana)
Actualiza la ventana
Retorna una lista con los eventos que recibe el sistema
Retorna una pareja, i.e. lista de dos elementos, con la posici
on (x, y) de la ventana donde se hizo clic con el mouse
Retorna la fuente con tipo f y tama
no t para ser usada
Dibuja un rectangulo en la superficie s con color c, anchura
del borde w (w=0 significa que el rectangulo estara lleno del
color c) y cuyos puntos se encuentran en las posiciones dadas
por los elementos de la lista r
Carga y retorna la imagen contenida en el archivo f
Toma la imagen i y la escala a las nuevas dimensiones (w,
h)
Carga el archivo de sonido w
Interpreta el archivo de sonido cargado previamente

image.load(f)
transform.scale(i,(w,h))
mixer.music.load(w)
mixer.music.play()

Constantes
QUIT
KEYUP
KEYDOWN

MOUSEMOTION
MOUSEBUTTONUP
MOUSEBUTTONDOWN

K RETURN
K SPACE
K A3

Cuadro 7.2: Operaciones b

asicas y algunas constantes del sistema Pygame

2
3

http://www.pygame.org/
Las constantes para todos los dem
as botones del teclado tienen la misma forma: K <tecla>.

91

7 Noci
on de Abstracci
on de Datos

A continuaci
on, en el ejemplo 7.1, se desarrollan las funciones y procedimientos no implementados del procedimiento juegoAhorcado() en el algoritmo 7.1, usando operaciones
del sistema pygame.

FT

Ejemplo 7.1

DR
A

La funci
on saludoInicial() (algoritmo 7.2) comienza inicializando el sistema pygame y
construyendo la ventana principal del programa (que puede verse en la figura 7.2). Despues
de esto selecciona la fuente con la que se escribira en esta funcion, que en este caso es
Arial de tama
no 30. Acto seguido asigna las variables que contienen las frases que se van
a imprimir en la pantalla. Dichas frases deben ser renderizadas, es decir, se deben generar
im
agenes a partir de unos modelos, que en este caso son texto. La renderizacion se produce
aplicando la operaci
on render() del modulo de fuentes del sistema (las operaciones de este
m
odulo pueden verse en el cuadro 7.3). Luego comienza un ciclo infinito en el cual primero
se borra completamente la pantalla, se se muestran las frases renderizadas y se espera a
que el usuario realice un evento. Si el evento resulta ser oprimir una tecla y esa tecla es
RETURN o ENTER, entonces el ciclo se rompe con la instruccion break y se termina la
funci
on retornando la ventana principal del programa.

Figura 7.2: Saludo Inicial en el juego Ahorcado

Una ventana en el sistema pygame es una superficie (surface en ingles) que sirve para
almacenar im
agenes. Dichas imagenes deben ser transferidas a la superficie como mapas
de bits (de all que el texto deba ser renderizado para poder ser mostrado, como se mencion
o anteriormente). La posicion donde se quiere transferir la imagen es una coordenada
(x, y) donde los valores de x y y van de (0, 0) (la esquina superior izquierda) a (w, h), la

92

7.1 Listas

esquina inferior derecha. En el cuadro 7.4 pueden detallarse dos operaciones de superficies
en pygame.

FT

def saludoInicial():
"Funcion que inicializa el sistema grafico"
"y muestra la ventana inicial"
# Inicializa el sistema
pygame.init()
ventana = pygame.display.set_mode((640, 480))
# Selecciona el tipo de fuente
fuente = pygame.font.SysFont("arial", 30)

# Construye las frases

titulo = fuente.render("JUEGO AHORCADO", True, (0,0,0))
subtitulo = fuente.render("Presione enter para empezar",
True,(0,0,0))

DR
A

# Ciclo para que el usuario lea el saludo de inicio

presionaEnter = False
while True:
# Muestra la informacion
ventana.fill((255,255,255))
ventana.blit(titulo,(180,180))
ventana.blit(subtitulo,(140,240))
# Maneja el evento de presionar una tecla
for e in pygame.event.get():
if e.type == pygame.KEYDOWN:
if e.key == pygame.K_RETURN:
presionaEnter = True
if presionaEnter:
break
# Actualiza el sistema
pygame.display.update()

return ventana

Algoritmo 7.2: Pantalla de inicio del juego ahorcado

Por otro lado, los eventos que ocurren en un programa de pygame tienen un tipo y
una llave (o nombre). El tipo de los eventos identifica la accion que el usuario realiza,
por ejemplo, el tipo QUIT para salir, KEYDOWN y KEYUP para presionar o soltar un boton
del teclado, y MOUSEMOTION, MOUSEBUTTONUP y MOUSEBUTTONDOWN para mover el mouse,

93

7 Noci
on de Abstracci
on de Datos

size(t)
set underline(b)
set bold(b)
set italic(b)

Acci
on
Crea una nueva superficie donde se imprime el texto t con
color c (una tipleta que representa el color en formato RGB).
El argumento a es un booleano que especifica si el texto
llevara antialias
Retorna las dimensiones necesarias (ancho,alto) para imprimir el texto t
De acuerdo al argumento booleano b, subraya el texto a
imprimir
De acuerdo al argumento booleano b, pone en negrilla el
texto a imprimir
De acuerdo al argumento booleano b, pone el texto a imprimir en italica

FT

Operaci
on
render(t,a,c)

Cuadro 7.3: Operaciones basicas del modulo de fuentes en el sistema Pygame

Acci
on
Dibuja la imagen s en la posicion d de la superficie
Llena la superficie con el color c

DR
A

Operaci
on
blit(s,d)
fill(c)

Cuadro 7.4: Operaciones basicas del modulo de superficies en el sistema Pygame

Ciclo for-each

presionar un bot
on o soltarlo. La llave del tipo determina exactamente la fuente del evento,
por ejemplo, K RETURN para la tecla RETURN o ENTER del teclado, K A para la tecla A,
y as sucesivamente.
Lo eventos que van sucediendo son almacenados temporalmente en una lista, la cual
es retornada por la funci
on pygame.event.get(). Esta lista puede recorrerse, es decir,
conocer sus elementos, usando un ciclo while, sin embargo, como se dijo en el captulo 6,
existe otro tipo de ciclo que realiza iteraciones sobre los elementos de una lista, llamado
ciclo for-each . Este tipo de ciclo tiene dos particularidades: (1) en cada iteraci
on una
variable definida en el ciclo toma el valor de un elemento de la lista en el orden en que
se encuentran los elementos en la lista, y (2) no se tienen que manejar los ndices de
los elementos de la lista. Estas caractersticas hacen valioso este tipo de ciclo ya que el
programador no se preocupa por los ndices de la lista los cuales pueden llevar facilmente
a un error en el programa (e.g. tratar de acceder un elemento inexistente).
El procedimiento dibujarTablero() que se muestra en el algoritmo 7.3, tiene como
par
ametros la ventana donde se dibujara, la palabra secreta y las listas de letras acertadas
y letras falladas. Como el tama
no de las letras que se van encontrando de la palabra secreta y el tama
no de las letras falladas son distintos, primero se crean dos fuentes. Luego se

94

7.1 Listas

FT

def dibujarTablero(ventana, palabraSecreta, letrasAcertadas,

letrasFalladas):
"Procedimiento que dibuja/actualiza el tablero del juego"
# Selecciona los tipos de fuente
fuente1 = pygame.font.SysFont("arial", 35)
fuente2 = pygame.font.SysFont("arial", 25)

# Crea la frase que va a mostrar dadas las letras acertadas

palabraAMostrar = ""
for letra in palabraSecreta:
if letra in letrasAcertadas:
palabraAMostrar = palabraAMostrar + \
string.capitalize(letra) + " "
else:
palabraAMostrar = palabraAMostrar + "_" + " "
# Borra completamente la ventana
ventana.fill((255,255,255))

DR
A

# Dibuja el estado del ahorcado dadas las letras falladas

if len(letrasFalladas) > 0:
ventana.blit(pygame.image.load(os.path.join("ahorcado" + \
str(len(letrasFalladas)) + \
".jpg")),(80,90))
# Muestra la frase "Letras Falladas"
ventana.blit(fuente2.render("Letras Falladas:",True,(0,0,0)), \
(330,100))
# Muestra las letras falladas
i=0
if letra in letrasFalladas:
ventana.blit(fuente2.render(string.capitalize(letra),True, \
(0,0,0)),(330+i,150))
i = i + 30
# Dibuja la frase actual
ventana.blit(fuente1.render(palabraAMostrar,True,(0,0,0)), \
(100,380))

# Actualiza el sistema
pygame.display.update()

Algoritmo 7.3: Dibuja/Actualiza la pantalla principal del juego ahorcado

95

7 Noci
on de Abstracci
on de Datos

(a)

(b)

(c)

(d)

FT

construye la palabra que se va a mostrar recorriendo cada una de las letras de la palabra
secreta y adicion
andolas (en may
uscula) a una cadena de caracteres si la letra se encuentra
en la lista de letras acertadas. Si la letra no se encuentra en la lista entonces se adiciona una lnea de subrayado. Acto seguido se limpia la pantalla y se dibuja el estado del
ahorcado. Este estado es dibujado cargando una imagen previamente hecha cuyo nombre
es ahorcadoX.jpg donde X es un n
umero entre 1 y 10 (estas imagenes, que pueden verse
en la figura 7.3, se encuentran como archivos en el sistema operativo y son cargadas en
el programa por medio del modulo de rutas de archivos del sistema os cuyas operaciones
b
asicas pueden verse en el cuadro 7.54 ). Despues se muestran las letras fallas y el estado
actual de la palabra secreta. Por u
ltimo se actualiza el sistema.

(e)

(f)

(g)

(h)

(i)

(j)

DR
A

Figura 7.3: Etapas del ahorcado

Operaci
on
path.exists(p)
path.basename(p)

path.dirname(p)

path.join(p1,p2,p3,...)

Acci
on
Retorna true si la ruta p existe, false de lo contrario
Retorna el nombre base de la ruta p (e.g. si
el sistema operativo actual es linux y p es
/usr/local/bin/programa entonces el resultado de
aplicar esta funcion es programa)
Retorna el nombre del directorio de la ruta p (e.g.
si el sistema operativo actual es windows y p es
C:\windows\temp\programa entonces el resultado de
aplicar esta funcion es C:\windows\temp)
Junta las rutas de archivos p1,p2,... de manera adecuada (e.g. si el sistema operativo actual es windows,
p1 es C: y p2 es temp, entonces el resultado de aplicar
esta funcion es C:\temp)

Cuadro 7.5: Operaciones basicas del modulo de rutas de archivos del sistema operativo

En el captulo ?? se profundizar
a un poco en el sistema os y se usar
a el m
odulo de manejo de archivos
y directorios del sistema operativo.

96

7.1 Listas

FT

Las letras que el jugador quiere probar en el juego las solicita simplemente presionando la
tecla correspondiente. En el algoritmo 7.4 se muestra el proceso para hacer esto. Se define
un ciclo infinito para esperar indefinidamente hasta que el usuario realice alg
un evento. Si
el evento realizado es presionar una tecla, se verifica si esa tecla corresponde a una letra y
si esto es cierto entonces se retorna la letra como una cadena de caracteres. De lo contrario,
es decir si la tecla no es una letra, hacemos la aplicacion de la operacion para interpretar
un sonido, que en este caso es un archivo de tipo wav que contiene un beep.

DR
A

def pedirLetra(ventana):
"Funcion que retorna la letra que el usuario ha ingresado"
# Ciclo para que el usuario ingrese la letra
while True:
for e in pygame.event.get():
if e.type == pygame.KEYDOWN:
# Si presiona una tecla que corresponde a una letra
if e.key == pygame.K_a:
return "a"
if e.key == pygame.K_b:
return "b"
if e.key == pygame.K_c:
return "c"

# ... aqui van los condicionales para las demas letras

if e.key == pygame.K_x:
return "x"
if e.key == pygame.K_y:
return "y"
if e.key == pygame.K_z:
return "z"
# Si presiona una tecla que no es una letra suena beep
else:
pygame.mixer.music.load("beep.wav")
pygame.mixer.music.play()

# Actualiza el sistema
pygame.display.update()

Algoritmo 7.4: Retorna la letra que el usuario presione en el juego ahorcado

Finalmente el algoritmo 7.5 para acabar el juego simplemente dibuja dos rectangulos
rellenos en la ventana y escribe en ellos las frases de ganador o perdedor. Mientras tanto
espera a que el jugador presione alguna tecla y cuando esto ocurre termina el sistema. Un

97

7 Noci
on de Abstracci
on de Datos

ejemplo del juego con los dos posibles finales puede verse en la figura 7.4.

FT

def acabarJuego(ventana, resultado):

"Procedimiento que termina el juego ahorcado"
# Selecciona la fuente y construye las frases finales
fuente = pygame.font.SysFont("arial", 40)
gano = fuente.render("Gano :-)", True, (255,0,0))
perdio = fuente.render("Perdio :-(", True, (255,0,0))

DR
A

# Ciclo para que el usuario vea el resultado y termine

acabo = False
while True:
# Si gano
if resultado == True:
pygame.draw.rect(ventana,(255,0,0),(335,240,215,85),5)
ventana.blit(gano,(355,260))
# Si perdio
else:
pygame.draw.rect(ventana,(255,0,0),(335,240,240,85),5)
ventana.blit(perdio,(355,260))
# Revisa los eventos que suceden
for e in pygame.event.get():
if e.type == KEYDOWN:
acabo = False
# Actualiza el sistema
pygame.display.update()
# Si presiono una tecla termina el sistema
if acabo:
pygame.quit()
break

Algoritmo 7.5: Termina el juego ahorcado

? ? ?

Ejemplo 7.2
Supongamos que queremos crear un juego que simule las elecciones para presidente. El
juego debe recibir el voto de cada uno de los n ciudadanos del pas y luego contar el
n
umero de votos para cada candidato de manera que se sepa quien es el presidente electo.
La tarjeta o tarjet
on electoral es un documento donde se encuentra la lista de candidatos
y el voto el blanco. Para votar, un ciudadano simplemente marca alguno de los candidatos
o la casilla del voto en blanco. Cuando se realiza el escrutinio, se cuentan cuantos votos se
marcaron para cada candidato y el que haya sacado la mayor cantidad es el ganador.
La informaci
on anterior provee los datos necesarios para construir el algoritmo 7.6 el

98

(a) Gan
o el juego ahorcado

FT

7.1 Listas

(b) Perdi
o el juego ahorcado

Figura 7.4: Estados finales del juego ahorcado

DR
A

cual simula las elecciones. Se tienen dos listas: la lista de los nombres de los candidatos y la
lista de los votos. En la lista de votos se iran contabilizando los votos que cada candidato
obtenga. Las listas listaNombres y listaVotos son correspondientes, es decir, el candidato
1, el cual es el elemento 1 de listaNombres, tiene el n
umero de votos del primer elemento
de listaVotos, el n
umero de votos del candidato 2 (elemento 2 de la lista) es el n
umero
que se encuentra en la segunda posici
on de la lista de votos, y as sucesivamente. Es de
notarse que en la lista de candidatos se tiene como u
ltimo elemento voto nulo, esto es
necesario para contabilizar este tipo de voto aunque no sea un candidato como tal. La
posicion donde se encuentra el voto nulo se almacena en la variable posVotoNulo para su
uso en la contabilidad de dicho voto.
La ventana se crea en la funci
on comienzoElecciones(), la cual se deja como ejercicio
para el lector.
El ciclo para hacer las votaciones hace n iteraciones, siendo n un parametro del procedimiento. En cada iteraci
on se obtiene el nombre del candidato por el que se vota mediante la
aplicacion de la funci
on sufragar(). Este nombre retornado por sufragar() se busca en
listaNombres y si existe se le agrega un voto a su elemento correspondiente. Si el nombre
no existe en la lista, entonces se contabiliza en el u
ltimo elemento de la lista de votos,
haciendo entender que fue un voto nulo.
Una vez termina el ciclo, se debe ordenar la lista de acuerdo a los votos que recibieron
cada uno de los candidatos. Esto se hace en la funcion ordenar(). Luego de esta aplicacion,
en la primera posici
on de listaNombres queda el nombre del ganador de las elecciones,
el cual es mostrado en el procedimiento mostrarGanador(), que tambien se deja como

99

7 Noci
on de Abstracci
on de Datos

ejercicio para el lector.

FT

def elecciones(n):
"Procedimiento para simular unas elecciones de presidente"
listaNombres = ["candidato1", "candidato2", "candidato3",
"candidato4", "candidato5", "en blanco",
"voto nulo"]
listaVotos = [0, 0, 0, 0, 0, 0, 0]
posVotoNulo = len(listaNombres) - 1
# Dibuja la tarjeta electoral
ventana = comienzoElecciones()

DR
A

# Comienzan las votaciones: Ciclo de n iteraciones

i = 1
while i < n:
# Se obtiene el nombre del candidato por el que se vota
voto = sufragar(ventana, listaNombres)
# Se busca el nombre dado en la lista de candidatos
# y se le agrega un voto
j = 0
while j < len(listaNombres) - 1:
if voto == listaNombres[j]:
listaVotos[j] = listaVotos[j] + 1
break
j = j + 1
# Si el nombre no esta en la lista es un voto nulo
if j == len(listaNombres):
listaVotos[posVotoNulo] = listaVotos[posVotoNulo] + 1
i = i + 1

# Escrutinio: se ordena la lista de candidatos por orden de votos

listaNombres = ordenar(listaNombres, listaVotos)
# Resultado
mostrarGanador(ventana, listaNombres, listaVotos)

Algoritmo 7.6: Simulador de elecciones

La funci
on sufragar() (algoritmo 7.7) recibe como parametros la ventana donde se
har
an las votaciones y la lista de candidatos. En ella se declara una variable donde se
almacenar
a el nombre del candidato elegido y luego, en un ciclo infinito, se maneja el
evento de presionar un bot
on del mouse. Cuando este evento sucede se obtiene la posici
on
donde se hizo clic y de acuerdo a ella se determina el candidato por el cual se quiere votar.
Una vez se haya hecho clic, el ciclo se interrumpe y se retorna el candidato elegido. Si

100

7.1 Listas

la accion de hacer clic se hace fuera de los rectangulos que limitan las imagenes de los
candidatos, se considera que el voto fue nulo y la variable elegido es retornada con su
valor por defecto, es decir, una cadena vaca.

FT

def sufragar(ventana, listaNombres):

"Funcion que retorna el candidato por el cual se ha votado"
# Declaracion de la variable que tendr el nombre del candidato
elegido = ""

DR
A

# Comienzan las votaciones: Ciclo de n iteraciones

haceClic = False
while True:
# Maneja el evento de hacer clic
for e in pygame.event.get():
if e.type == pygame.MOUSEBUTTONDOWN:
haceClic = True
pos = pygame.mouse.get_pos()
if pos[0] >= 22 and pos[0] <= 122 and \
pos[1] >= 80 and pos[1] <= 200:
elegido = listaNombres[0]
if pos[0] >= 142 and pos[0] <= 242 and \
pos[1] >= 80 and pos[1] <= 200:
elegido = listaNombres[1]
if pos[0] >= 262 and pos[0] <= 362 and \
pos[1] >= 80 and pos[1] <= 200:
elegido = listaNombres[2]
if pos[0] >= 382 and pos[0] <= 482 and \
pos[1] >= 80 and pos[1] <= 200:
elegido = listaNombres[3]
if pos[0] >= 502 and pos[0] <= 602 and \
pos[1] >= 80 and pos[1] <= 200:
elegido = listaNombres[4]
if pos[0] >= 622 and pos[0] <= 722 and \
pos[1] >= 80 and pos[1] <= 200:
elegido = listaNombres[5]
if haceClic:
break
# Actualiza el sistema
pygame.display.update()
return elegido

Algoritmo 7.7: Retorna un candidato en el juego de elecciones

El algoritmo 7.8 ordena las listas de candidatos y votos por n

umero de votos obtenidos.

101

7 Noci
on de Abstracci
on de Datos

FT

Esto lo logra realizando dos ciclos anidados. El ciclo externo recorre las listas desde el
primer elemento hasta el u
ltimo, encontrando el menor elemento y ubicandolo en la posici
on adecuada seg
un el orden que se desea. El menor elemento se encuentra realizando el
ciclo interno, desde la posicion donde se encuentra el recorrido de las listas hasta el final,
buscando saber cu
al es la posicion del elemento con menos valor.
def ordenar(listaNombres, listaVotos):
"Funcion que ordena las listas por numero de votos"
# Ciclo que recorre las listas
contador1 = 0
while contador1 < len(listaNombres):
contador2 = contador1
posMenor = contador1

# Ciclo que encuentra la posicion del elemento menor

while contador2 < len(listaNombres):
if listaVotos[posMenor] > listaVotos[contador2]:
posMenor = contador2
contador2 = contador2 + 1

DR
A

# Ubica el menor en la posicion adecuada segn el orden

nombreTemp = listaNombres.pop(posMenor)
listaNombres.insert(contador1, nombreTemp)
votoTemp = listaVotos.pop(posMenor)
listaVotos.insert(contador1, votoTemp)
contador1 = contador1 + 1

return listaNombres,listaVotos

Algoritmo 7.8: Ordena las listas de candidato y votos en el juego de elecciones

Ordenamiento

Matriz

? ? ?

Ordenar una lista es organizar cada elemento de ella en un orden particular. En el

algoritmo 7.8 se utiliz
o el metodo Selection Sort, el cual encuentra el mnimo valor en la
lista, lo intercambia por el valor de la primera posicion y repite este proceso en el resto
de la lista (empezando en la segunda posicion y avanzando una posicion cada iteraci
on).
Existen muchos otros algoritmos para ordenar una lista. Se deja como ejercicio para el
lector investigar e implementar algunos de esos algoritmos.
Los elementos que tienen las listas pueden ser de cualquier tipo de datos. Esto significa
que los elementos podran ser tambien listas. Cuando se tiene una lista de listas se dice
que se tiene una matriz . La cantidad de niveles de anidamiento de las listas determina el

102

7.1 Listas

n
umero de dimensiones que tiene la matriz. En el ejemplo 7.3 se trabajara con listas de
listas, es decir, matrices de dos dimensiones.

DR
A

FT

Ejemplo 7.3
Buscaminas es un juego muy popular cuyo objetivo es limpiar un campo minado sin
detonar ninguna mina. El campo minado es una grilla de n m ubicaciones, en las cuales
puede o no haber una mina.
Este es un juego de un solo jugador, quien debe explorar el campo minado haciendo
clic en las ubicaciones de manera estrategica para no detonar una mina. Cuando se limpia
(se hace clic en) una ubicaci
on que no tiene una mina, esta revela una pista acerca de las
ubicaciones adyacentes. La pista es un n
umero, el cual hace referencia a la cantidad de
minas que hay alrededor de dicha ubicacion.
El juego termina cuando se hace clic en una mina o cuando se ha limpiado la totalidad
de ubicaciones que no tienen mina. En la figura 7.5 puede verse un ejemplo del buscaminas
para Windows 7.

Figura 7.5: Buscaminas en Windows 7

El procedimiento para jugar buscaminas se encuentra en el algoritmo 7.9. La idea detras

de este procedimiento es contar con dos matrices, una (tableroOculto) en la que se encuentra el tablero completo, es decir, se conoce plenamente la ubicacion de las minas y,

103

7 Noci
on de Abstracci
on de Datos

por lo tanto, las pistas. La otra matriz (tableroVisible) representa el tablero tal y como
se ve en el juego, por lo que inicia vaca y a medida que se escoge una ubicacion, se va
revelando el contenido del tablero.

FT

def buscaminas(ancho, alto, numMinas):

"Procedimiento para jugar buscaminas"
tableroVisible = construirMatriz(ancho, alto)
tableroOculto = llenarTablero(ancho, alto, numMinas)
juegoAcabado = False
# Dibuja la ventana inicial
ventana = saludoInicial()

# Ciclo del juego

while not juegoAcabado:
# Dibuja/Actualiza el tablero
dibujarTablero(ventana, tableroVisible)
# Pide hacer clic en una posicion
x,y = obtenerUbicacion(ventana)

DR
A

# Procede de acuerdo a la ubicacion

tableroVisible[x][y] = tableroOculto[x][y]
# Si detono una mina (perdio)
if tableroOculto[x][y] == 'M':
acabarJuego(ventana, False)
juegoAcabado = True
else:
# Si no detono una mina pero completo el tablero (gano)
if tableroLleno(tableroVisible):
acabarJuego(ventana, True)
juegoAcabado = True

Algoritmo 7.9: Juego buscaminas

La parte gr
afica de este algoritmo se maneja de manera similar al algoritmo 7.1 del ejemplo del juego ahorcado, simplemente cambian algunos parametros e implementaciones de las
funciones y procedimientos saludoInicial(), dibujarTablero(), obtenerUbicacion()
(que en el ahorcado se llamaba pedirLetra()) y acabarJuego(). El proceso para obtener
el dato ingresado por el usuario es, quizas, el que mas cambia dado que ahora dicho dato es
una coordenada que representa la ubicacion que quiere explorar en el tablero. Todas estas
funciones se dejan como ejercicio para implementar.
Para trabajar con el tablero primero debe construirse la matriz. El proceso es bastante
simple y puede verse en el algoritmo 7.10. Se tienen dos ciclos anidados, el primero se

104

7.1 Listas

encarga de crear las sublistas y el segundo de ingresar la cantidad apropiada de elementos

a cada subsista. A medida que las sublistas van quedando construidas, se van adicionando
una lista inicialmente vaca, creando as la matriz, que es retornada al final.

for i in range(alto):
listatemp = []
for j in range(ancho):
listatemp.append(' ')
matriz.append(temp)
return matriz

FT

def construirMatriz(ancho, alto):

"Funcion que crea e inicializa con ' ' una matriz de anchoxalto"
matriz = []

Algoritmo 7.10: Crea y retorna una matriz de dimensiones ancho alto

DR
A

Una vez el tablero ha sido construido, se debe llenar con las minas y pistas. Este proceso
se realiza en el algoritmo 7.11. Primero se crea la matriz que representa el tablero. Luego
esta matriz se empieza a llenar con las minas (smbolo M). Las posiciones de las minas
son halladas de manera aleatoria y poniendo mucho cuidado de no repetir ninguna.

La forma de hallar y poner las pistas es relativamente simple: se recorre la matriz un

elemento a la vez y en cada ubicaci
on se pregunta si dicha ubicacion contiene una mina.
Si esto es cierto, entonces se continua con la siguiente ubicacion, pero si es falso entonces
se revisa cada uno de los ocho lugares adyacentes a la ubicacion actual preguntando por
una mina. Cada vez que una mina sea encontrada en una posicion adyacente, una variable
pista es aumentada una unidad en su valor, que inicialmente es cero. As, si se tienen tres
minas alrededor, por ejemplo, entonces el valor de la variable terminara siendo tres y ese
n
umero ira en la ubicaci
on correspondiente de la matriz.
Si el lector pone mucha atenci
on en la parte de las pistas del algoritmo 7.11 puede
darse cuenta que hay problemas en ella. Supongamos que estamos en la posicion (0,0)
de la matriz, es decir, recien iniciaron los dos ciclos, y en ella no hay una mina. Como
este lugar en la matriz es la esquina superior izquierda, esto quiere decir que hay que
revisar en las posiciones (0,1), (1,1) y (1,0), que son las u
nicas ubicaciones adyacentes a
(0,0). Sin embargo, n
otese que en el algoritmo la revision de minas se hace sobre ocho
ubicaciones adyacentes, luego que va a pasar en las cinco posiciones inexistentes que se
estan revisando? Sale un error porque efectivamente no existen. Entonces hay que modificar

105

7 Noci
on de Abstracci
on de Datos

el algoritmo para evitar estos problemas en los bordes de la matriz.

FT

def llenarTablero(ancho, alto, numMinas):

"Funcion que llena el tablero del buscaminas con minas y pistas"
# Primero se crea la matriz que servira de tablero
tableroOculto = construirMatriz(ancho, alto)
# Se llena el tablero con una cantidad numMinas de minas ('M')
i = 0
while i < numMinas:
dirx = random.randint(0, ancho - 1)
diry = random.randint(0, alto - 1)
if tableroOculto[dirx][diry] != 'M':
tableroOculto[dirx][diry] = 'M'
i = i + 1

DR
A

# Se recorre el tablero poniendo las pistas

for i in range(alto):
for j in range(ancho):
if tableroOculto[i][j] != 'M':
pista = 0
if tableroOculto[i+1][j] == 'M':
pista = pista + 1
if tableroOculto[i-1][j] == 'M':
pista = pista + 1
if tableroOculto[i][j+1] == 'M':
pista = pista + 1
if tableroOculto[i][j-1] == 'M':
pista = pista + 1
if tableroOculto[i+1][j+1] == 'M':
pista = pista + 1
if tableroOculto[i+1][j-1] == 'M':
pista = pista + 1
if tableroOculto[i-1][j+1] == 'M':
pista = pista + 1
if tableroOculto[i-1][j-1] == 'M':
pista = pista + 1
tableroOculto[i][j] = pista
return tableroOculto

Algoritmo 7.11: Llena el tablero del buscaminas con minas y pistas

El algoritmo 7.12 es una modificacion de la parte de las pistas del algoritmo 7.11. En el

106

7.1 Listas

antes de revisar la ubicaci

on se pregunta si dicha ubicacion existe en la matriz.

DR
A

FT

# Se recorre el tablero poniendo las pistas

for i in range(alto):
for j in range(ancho):
if tableroOculto[i][j] != 'M':
pista = 0
if i < alto - 1:
if tableroOculto[i+1][j] == 'M':
pista = pista + 1
if i > 0:
if tableroOculto[i-1][j] == 'M':
pista = pista + 1
if j < ancho - 1:
if tableroOculto[i][j+1] == 'M':
pista = pista + 1
if j > 0:
if tableroOculto[i][j-1] == 'M':
pista = pista + 1
if i < alto - 1 and j < ancho - 1:
if tableroOculto[i+1][j+1] == 'M':
pista = pista + 1
if i < alto - 1 and j > 0:
if tableroOculto[i+1][j-1] == 'M':
pista = pista + 1
if i > 0 and j < ancho - 1:
if tableroOculto[i-1][j+1] == 'M':
pista = pista + 1
if i > 0 and j > 0:
if tableroOculto[i-1][j-1] == 'M':
pista = pista + 1
tableroOculto[i][j] = pista

Algoritmo 7.12: Modificaci

on del algoritmo para llenar el tablero del buscaminas con
pistas

En el juego, para saber si el este acab

o se deben realizar dos tareas: preguntar si en la
ubicacion que el jugador escogi
o hay una mina y revisar si todo el tablero ha sido explorado. La primera tarea es muy sencilla de hacer, solo se pregunta si en la ubicacion actual
hay un caracter M. La segunda tarea requiere hacer un recorrido por todo la matriz
tableroVisible buscando una ubicaci
on que tenga el valor inicial y cuya ubicacion
correspondiente en tableroOculto no tenga una mina. Si no existe dicha ubicacion, entonces se hay llenado todo el tablero y el jugador gano. El algoritmo 7.13 muestra esta

107

7 Noci
on de Abstracci
on de Datos

segunda tarea.

FT

def tableroLleno(tableroVisible, tableroOculto):

"Funcion que revisa si se han descubierto todas las ubicaciones"
"sin mina"
lleno = True
for i in range(len(tableroVisible)):
for j in range(len(tableroVisible[0])):
if tableroVisible[i][j] == ' ' and \
tableroOculto[i][j] != 'M':
lleno = False
return lleno

Algoritmo 7.13: Funci

on que determina si se han descubierto todas las ubicaciones que
no tienen mina
? ? ?

Ejercicios

DR
A

7.2.

7.1 La operaci
on in para listas, revisa si un elemento se encuentra en una lista. As, si
escribimos if letra in letrasFalladas, lo que queremos saber es si el elemento
letra se encuentra en la lista letrasFalladas.
Desarrolle, sin usar dicha operacion in, la funcion buscarElemento() que tome como
argumentos una lista y un elemento, y retorne True si el elemento efectivamente se
encuentre en la lista, y False de lo contrario.

7.2 En el juego Ahorcado visto en este captulo se pueden repetir las letras falladas y
esto hace que se acumule la misma letra en la lista de letras falladas y, por lo tanto,
se dibuje un elemento mas del ahorcado. Corrija esto haciendo que el programa
muestre una aviso al jugador diciendo, cuando se repite una letra fallada, que ya se
escogi
o dicha letra y la pida de nuevo sin anexarla de nuevo a la lista y sin dibujar
un elemento m
as del ahorcado.
7.3 La u
ltima letra que se presiona y el dibujo completo en el juego ahorcado no se
alcanza a mostrar cuando termina el juego. Modifique los algoritmos necesarios para
que efectivamente se muestre la u
ltima letra presionada y se dibuje completamente
el ahorcado (cuando pierde).
7.4 Complete el ejemplo 7.2 de las elecciones desarrollando la funcion comienzoElecciones()
y el procedimiento mostrarGanador(). Para que los algoritmos aqu mostrados fun-

108

7.2 Ejercicios

FT

cionen correctamente, la ventana creada y retornada en comienzoElecciones() debe

tener unas dimensiones de 750 350 y verse como la figura 7.6.

DR
A

Figura 7.6: Ventana del juego de las elecciones

Es muy importante que en la ventana creada en comienzoElecciones() las fotos

de los candidatos esten en unos cuadros de tama
no 100 120 y las posiciones de
sus esquinas superior-izquierda sean: (22,80), (142,80), (262,80), (382,80), (502,80),
y (622,80).

7.5 La funci
on ordenamiento del ejemplo 7.2 retorna las listas en orden ascendente, es
decir, de menor a mayor, de acuerdo a los votos obtenidos. Desarrolle la funcion
invertirLista() para tomar estas listas y retornarlas en orden invertido (i.e. de
mayor a menor).
7.6 Investigue e implemente en el juego de las elecciones los siguientes metodos de ordenamiento: Bubble Sort, Insertion Sort y Shell Sort.
7.7 Desarrolle todas las funciones y procedimientos graficos del juego buscaminas.
7.8 El juego triqui del ejemplo 6.1 puede desarrollarse con una matriz y funciones de
pygame. Modifique las funciones necesarias para hacerlo.

109

DR
A

FT

7 Noci
on de Abstracci
on de Datos

110

FT

Bibliografa
[1] Jean-Raymond Abrial. Guidelines to formal system studies. MATISSE project, November 2000.
[2] Donald E. Knuth. Structured programming with go to statements. ACM Computing
Surveys, 6(4):261301, December 1974.

[3] Guido Van Rossum and Fred L Drake Jr. An Introduction to Python. Network Theory
Ltd, 2011.
[4] Guido Van Rossum and Fred L Drake Jr. The Python Language Reference Manual.
Network Theory Ltd, 2011.

DR
A

[5] Gerardo Sarria. Introduction to programming for engineers following the parachute
paradigm. In 39th ASEE/IEEE Frontiers in Education. IEEE, San Antonio, TX, USA,
1821 October 2009.
[6] G. Michael Schneider. The introductory programming course in computer science: ten
principles. In Papers of the SIGCSE/CSA technical symposium on Computer science
education, SIGCSE 78, pages 107114, New York, NY, USA, 1978. ACM.

111