U1. Estructuras de Datos y Análisis de Algoritmos

Computacin II
Unidad 1. Estructuras de datos y anlisis de algoritmos
Universidad Abierta y a Distancia de Mxico
Licenciatura en Matemticas
9 cuatrimestre
Computacin II
Unidad 1 Estructuras de datos y anlisis de algoritmos
Clave:
050930936
Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas
Computacin II
ndice
Unidad 1. Estructuras de datos y anlisis de algoritmos .................................................... 4
Presentacin de la Unidad ................................................................................................. 4
Propsitos de la unidad...................................................................................................... 4
Competencia especfica ..................................................................................................... 5
1.1. Introduccin ................................................................................................................ 5
1.1.1.
Informacin y datos ............................................................................................ 7
1.1.2.
El lenguaje de programacin Python .................................................................. 8
Actividad 1. Nmeros aleatorios con Phyton .................................................................... 21

1.2. Tipos de datos .......................................................................................................... 22
1.2.1. Tipos primitivos..................................................................................................... 22
1.2.2. Tipos simples y compuestos ................................................................................. 23
1.2.3. Tipos abstractos ................................................................................................... 25
1.3. Anlisis de algoritmos ............................................................................................... 29
Actividad 2. Reflexin sobre algoritmos ........................................................................... 31
1.3.1. Notacin asinttica ............................................................................................... 31
1.3.2. Algoritmos iterativos y recursivos.......................................................................... 39
1.3.3. Diseo de algoritmos ............................................................................................ 43
1.3.4. Complejidad en ordenamientos y bsquedas ....................................................... 46
Actividad 3. Anlisis de complejidad ................................................................................ 49
1.4. Estructuras de datos ................................................................................................. 49
1.4.1. Arreglos y listas .................................................................................................... 49
Computacin II
1.4.2. Pilas ..................................................................................................................... 54
1.4.3. Heaps ................................................................................................................... 55
1.4.4. rboles ................................................................................................................. 56
1.4.5. Funciones y tablas de hash .................................................................................. 58
Actividad 4. Estructuras de datos ..................................................................................... 60
Autoevaluacin ................................................................................................................ 60
Evidencia de aprendizaje. Diseo de algoritmo........................................................... 60
Autorreflexiones ............................................................................................................... 61
Cierre de la Unidad .......................................................................................................... 61
Para saber ms ............................................................................................................... 61
Referencias Bibliogrficas ................................................................................................ 62
Computacin II
Presentacin de la Unidad
Las computadoras son popularmente vistas como aparatos electrnicos capaces de efectuar
clculos inmediatos, pero este concepto est incompleto, ya que esas son nicamente las
computadoras digitales. Entonces, es importante aclarar el concepto de computadora con el que
vamos a trabajar. Una computadora es un dispositivo capaz de mapear valores entre un par de
conjuntos a travs de una serie de pasos finitos que se denominan algoritmos. El modelo de
Turing (Turing, 1936) es el modelo matemtico que fundamenta la descripcin de las
computadoras digitales con las que trabajas, y que fue posteriormente implementado en una
computadora electrnica construida por von Neumann, a partir de quien se populariz el
concepto de programa almacenado. Estas computadoras, como todos saben, corren
programas para calcular valores. Sin embargo, un par de caractersticas del modelo de Turing
es hacer uso de una banda infinita donde leer o escribir la informacin procesada, as como un
conjunto de instrucciones que le dicen a la cabeza lectora si debe moverse a la derecha o
izquierda. En la prctica este particular aspecto guarda una diferencia abismal con la
computadora construida por von Neumann, ya que la posibilidad de recursos infinitos est fuera
de nuestro alcance, en tanto que respecto al conjunto de instrucciones, es fcil observar que
pueden agregarse instrucciones innecesarias para realizar algn cmputo deseado, o bien, el
caso complementario: es fcil suponer que existen algoritmos que hacen un uso innecesario de
instrucciones o espacio para poder realizar su cmputo.
En esta unidad aprenders a clasificar este conjunto de instrucciones, a la postre denominados
algoritmos, de acuerdo con su eficiencia. Aprenders a medir ciertos elementos que los hacen
ms eficientes, adems de conocer distintas estructuras de datos que son fundamentales para
hacer un uso ptimo de los recursos de la mquina, dependiendo del problema especfico que
tengas a la mano. Todo esto lo hars mediante un lenguaje de programacin actualmente muy
popular y sencillo de usar, llamado Python
Propsitos de la unidad
Identificars los diferentes tipos de datos existentes.

Aplicars las diferentes estructuras de datos segn convenga al problema en cuestin.
Clasificars algoritmos mediante el uso de la notacin asinttica.
Disears algoritmos sujetos a una clase de complejidad especfica.
Computacin II
Competencia especfica
Disear algoritmos para que hagan uso de los recursos computacionales de forma ptima
mediante las herramientas descritas en la teora de la complejidad computacional y el anlisis
de algoritmos.
1.1. Introduccin
En la presentacin de la unidad se mencionan un par de modelos tericos (uno de ellos
implementado) sobre las computadoras que actualmente usas; entre ellos est el modelo de
Turing que puedes ver en la figura 1. Otro ejemplo de computadora es el cerebro humano, ya
que tiene la capacidad de hacer clculos usualmente relacionados con valores alimentados a
travs de los sentidos, y cuyos clculos se pueden observar a travs de las decisiones o
acciones que tomas. Al igual que las computadoras digitales, es fcil ver que el cerebro humano
tiene una cantidad finita de recursos, como el espacio fsico donde se alberga, o bien, la
cantidad de conexiones sinpticas que son usadas y mantenidas comnmente a lo largo de la
vida de un individuo. En estos ejemplos se puede vislumbrar un compromiso entre rapidez y
exactitud, es decir, el uso eficiente de los recursos dependiendo del problema en cuestin.
Figura 1. Esquema de la mquina de Turing (Wikipedia)
El uso de una computadora para resolver problemas suele ser transparente a las necesidades
del usuario final, pero no debe ser as para el programador; es aqu donde los aspectos de
eficiencia se hacen patentes y ste es el punto que tendrs en mente todo el tiempo a lo largo
de esta unidad: el hacer uso de los recursos de la computadora de forma eficiente, o por lo
menos, no los perders de vista, y es que el que una mquina sea muy rpida para resolver
algoritmos con una entrada pequea (por pequea puede suponerse algo menor a una decena
de datos), no implica que esta relacin se conserva para una entrada con muchos ms datos
para el mismo algoritmo. Por ejemplo, no es lo mismo encontrar una ruta ptima en una grfica
con 5 nodos que con 200, de hecho, ese particular problema es un problema NP-Completo, lo
cual significa que para este tipo de problemas no se ha encontrado un algoritmo que pueda
resolverlo en tiempo polinomial, pero esto se definir con ms precisin ms adelante.
Computacin II
Figura 2. Grafica con pesos en las cuales una es intrnsecamente ms sencilla de examinar que la otra por lo
tanto cualquier algoritmo para recorrerlas tardar ms en la segunda grfica.
En la figura 2 puedes ver un ejemplo del problema particular antes mencionado, problema
denominado usualmente como el Problema del Agente Viajero (TSP por sus siglas en ingls).
Este problema consiste en tener que visitar todos los nodos una sola vez, minimizando el
esfuerzo (o distancia) recorrida, representado en las grficas por los pesos en las aristas. Una
forma ingenua de resolverlo podra ser la siguiente:
1. Crear una lista vaca L
2. Escoger un nodo al azar y ponerlo al inicio de L
3. Viajar a cualquiera de sus vecinos y agregarlo a la lista L
4. Repetir el paso 3 hasta que todos los nodos estn visitados. Una vez hecho esto, la
lista L indicar el orden en el que hay que visitar esos particulares nodos para
completar un recorrido en la grfica que pase por todos los nodos.
5. Repetir desde el paso 1 hasta que todas las posibles rutas estn construidas
Algoritmo 1. Primer intento de algoritmo para el TSP
Pero es claro ver que este algoritmo, si bien es factible para la grfica a, es impensable para la
grfica b, y esta ltima no es ni siquiera comparable a la configuracin de una ciudad promedio.
En este punto es importante aclarar que este tipo de problemas (NP-Completos) no tienen
soluciones que ocupen un tiempo acotado de resolucin, y lo que se ha desarrollado hasta
ahora no son ms que aproximaciones heursticas, y no se ha tenido que conformar con alguna
Computacin II
aproximacin. As que, dicho esto, podra incluso hacerse otra propuesta de algoritmo para
resolver el TSP.
Crear un conjunto V vaco
Tomar
y
Crear una lista vaca L

Tomar un nodo al azar y denominarlo p y agregarlo a L
Viajar el nodo conectado con p cuya arista tenga el peso ms pequeo y no est
visitado, denominarlo q
Renombrar q a p
Agregar p a L
Regresar a 4 hasta que L tenga N elementos
Agregar L a V
Regresar a 3 M-1 veces
Ordenar V dependiendo del costo de cada elemento.
Algoritmo 2. Segundo intento de solucin al TSP
En este ltimo algoritmo se sabe que vas encontrar la mejor solucin posible que permita
buscar sobre la raz de N recorridos en la grfica; tal vez no sea la ptima, pero, por lo menos,
es una solucin factible de implementar en nuestras computadoras y completar en un tiempo
razonable.
Este tipo de compromiso es algo que se puede ponderar y optimizar, siempre y cuando tengas
claro alguna medida sobre algn algoritmo en particular.
1.1.1. Informacin y datos

En una poca donde las computadoras digitales no slo son ubicuas, sino que tambin dictan
muchos de los aspectos de cmo vivir, desarrollarte y convivir, es importante conocer aspectos
bsicos de su funcionamiento. Lo que usualmente esperas de una computadora es que
procese datos para convertirlos en informacin.
Este procesamiento recibe el nombre tcnico de cmputo, y lo que hace es aplicar una serie de
pasos finitos y bien determinados, serie llamada algoritmo, a un elemento de un conjunto para
mapearlo en otro conjunto. Entonces, se puede establecer la definicin de algoritmo que usars
de aqu en adelante
Definicin: un algoritmo es un conjunto de pasos finitos y ordenados, cada uno de
ellos ejecutable en un tiempo finito, que llevan a cabo un mapeo entre un par de
conjuntos.
(1)
Computacin II
El ttulo de esta subseccin hace una distincin implcita entre lo que son los datos y lo que es
la informacin. Esta distincin no es difcil de entender, y es que no es lo mismo tener una serie
de valores desligados, que agrupados bajo alguna estructura que infiera alguna secuencia
lgica de los mismos. No es lo mismo tener todos los nombres de los habitantes de la ciudad de
Mxico, as como sus respectivos telfonos de manera desordenada, que estructurados en una
gua telefnica ordenada alfabticamente.
Entonces, algo importante que puede decirse sobre lo que es la informacin, es que est
estructurada con algn patrn discernible. Ms an, ese patrn puede ser computable mediante
un algoritmo.
Para poder practicar las diferentes estructuras y algoritmos que vers en esta unidad, tienes
que usar una computadora y, particularmente, un lenguaje de programacin.
1.1.2. El lenguaje de programacin Python

El lenguaje de programacin del que hars uso es Python 2.7 (no se cubrir el uso de Python
3.x), que puedes bajar de la siguiente direccin
http://www.python.org/getit/windows/
Figura 3. Pgina de Python
En este sitio puedes ver las opciones para bajar Python en distintas distribuciones. Si sigues la
primer liga (http://www.python.org/download/releases/), entrars a la siguiente pgina
Computacin II
Figura 4. Versiones de Python, de las cuales usaremos las versiones 2.7.x
Pero si lo deseas, y de hecho, como recomendacin, puedes usar la versin de Enthought

Python Distribution (http://www.enthought.com/products/epd.php), la cual tiene una distribucin
gratuita (https://www.enthought.com/products/epd/free/) y que resultar particularmente til, ya
que tiene integradas bibliotecas como Numpy o Matplotlib.
Una vez instalado, podrs ver las siguientes opciones en el men de inicio:
Computacin II
Figura 5. Python instalado. Usaremos principalmente el Canopy command prompt, pero, si deseas, puedes
familiarizarte con la interfaz IDLE mostrada en la figura b.
Si eres usuario de Linux es muy probable que ya lo tengas instalado, y si no, es muy sencillo
instalarlo; depende de tu distribucin para lograr esto.
Python es un lenguaje de programacin interactivo, orientado a objetos, y de tipado dinmico,
as como con algunas caractersticas de un lenguaje funcional. Su principal motivacin es la de
crear cdigo entendible y restringir ms el laconismo que caracteriza a C o Java. Para hacer
esto, en Python la identificacin de los programas no es despreciable; esto significa que el
margen izquierdo que caracteriza en el editor de scripts tiene un significado: el alcance de las
variables definidas en ese nivel, o bien, la definicin de un mbito concreto. Esto significa que
todas las variables que defina en cierto nivel pueden ser ledas en ese nivel o en aquellos
donde la identacin es mayor. Identar un texto se refiere a alinearlo con un margen izquierdo
mayor que el nivel anterior. El nivel de identacin original es el margen 0. Si identaras el texto
un nivel, por ejemplo, al margen izquierdo 4, entonces todo el texto que estuviera alineado al
margen 4 estara a un nivel de identacin. En el caso concreto de Python, los distintos niveles
de identacin determinan el estilo de codificacin que seguirs, ya que es la manera en que
este lenguaje decide qu lneas pertenecen o no a un mismo bloque de cdigo.
A continuacin puedes ver un par de ejemplos, uno de ellos correcto y el otro incorrecto.
Ejemplo
>>> i = 4
>>> for j in range(5):
...
print i,j
...
4 0
>>> i = 4
>>> for j in range(5):
... print i,j
File <stdin>, line 2
print i,j
10
Computacin II
4 1
4 2
4 3
4 4
>>>
IndentationError: expected an indented

block
>>>
A
En este par de ejemplos puedes ver, en el panel A, un uso correcto de la identacin en Python.
La lnea que contiene el print es correctamente ejecutada dentro del ciclo del for en la lnea
anterior, que es como est definida la sintaxis en Python. Por otro lado, en el panel B puedes
ver el uso incorrecto de esto, ya que el uso del for es idntico al del panel B, con el nico
cambio en que la lnea con print est pegada al lado izquierdo, y no correctamente indentada.
Por cierto, lo que el for est diseado a ejecutar en ambos ejemplos es imprimir el valor de la
variable i, que est fijo en la primera lnea, y el de j, que va variando conforme se llevan a cabo
iteraciones del for. Es decir, est diseado para imprimir la pareja ordenada (i,j) como puedes
ver en el panel A.
En esta seccin vers un tutorial extremadamente condensado sobre el uso y sintaxis de
Python, lo cual es necesario para poder comprender el resto de la unidad, pero se dejarn una
serie de ligas y libros para que puedas profundizar en el uso de este lenguaje.
Uso Bsico
Los scripts de Python son archivos de texto, es decir, tienes que editarlo con el notepad,
notepad++, o cualquier editor que deje los archivos en texto claro, y al final le vas a anexar, por
convencin, la extensin de archivo py, sin espacios o caracteres especiales en los nombres.
Los siguientes son ejemplos vlidos de nombres de script en Python:
- tree.py
- Hola_mundo.py
- basico1.py
Y los siguientes son ejemplos de nombres invlidos
- lo malo.py
- Nio.py
- Trmino.py
- Script
Para poder correr el siguiente ejemplo vas crear un directorio llamado computacin2 en el
directorio C:\
C:\computacion2
y dentro de l vas a copiar el siguiente contenido, tal cual:
-*- coding:utf8 -*for i in range(2,5):
print i, Hola Mundo
11
Computacin II
- en un archivo que se llamar hola_mundo.py, para despus ejecutarlo con Python como se
muestra a continuacin:
C:\computacion2> python hola_mundo.py
Para ejecutarlo tienes que abrir el intrprete de comandos de Windows y cambiarte al directorio
especificado arriba. La ejecucin debe verse como a continuacin se presenta:
(Canopy 32bit) C:\computacion2>python hola_mundo.py
2 Hola Mundo
3 Hola Mundo
4 Hola Mundo
Sugerencia: cambia el contenido del script que acabas de crear para que te salude a ti.
Sintaxis Bsica
Como todo lenguaje de programacin, Python tiene definido una sintaxis de operacin bsica
en la que est definido cmo hacer la asignacin de variables, cmo usar los operadores
aritmticos bsicos, las operaciones lgicas bsicas, la ejecucin de ciclos, la definicin de
clases, etctera. En esta seccin repasars algunos de estos puntos.
Asignacin y Cadenas
Python es un lenguaje de tipado dinmico, lo que quiere decir que no tiene palabras reservadas
para determinar si algn nmero es entero, flotante, o cualquier variante de sas que son
ampliamente usadas en otros lenguajes fuertemente tipados como Java. Los detalles sobre
cmo Python puede identificar la precisin del nmero con el que ests trabajando son ajenos a
este curso; sin embargo, de aqu en adelante usars la siguiente regla de asignacin de
variables sin mayor diferencia:
>>>
>>> var =
>>> print
45
>>> var =
>>> print
nombre
>>>
>>> var =
>>> print
0.445
>>>
45
var
nombre
var
0.445
var
Como puedes ver, sin mayor problema asignas no slo un valor, sino un tipo completamente
diferente de datos a la misma variable, y as es como funciona la asignacin de variables en
Python.
12
Computacin II
Como puedes ver en la salida anterior, el uso de cadenas se hace a travs de envolver las
mismas con un par de comillas (), o bien, tambin puede hacerse con una comilla simple ()
siempre y cuando sea consistente, por ejemplo:
>>> var = cadena 1
cadena 1
>>> var = cadena 1
cadena 1
>>>
Un conjunto de funciones existentes en Python que vale la pena recordar son: len, str,
print, input. A continuacin puedes ver un ejemplo de cada una aplicada a la variable var
del ejemplo anterior
>>> len(var) #logitud de var
7
>>> str(12)
#convierte a cadena el argumento
12
>>> var=input(Otro nombre )
Otro nombre otromas
>>> print var
otromas
>>>
En los ejemplos anteriores es importante notar que len calcula la longitud del argumento que
hayas pasado, str convierte a cadena el argumento; es por esto que aparece envuelto en
comillas simples, y var recibe una cadena, ya que de otra forma fallara.
Listas
Otra caracterstica en la operacin de Python es su orientacin al manejo de listas, las cuales
se conforman de la siguiente manera.
Si deseas hacer una lista vaca, debes:
>>> L = []
O bien,
>>> L = list()
Si deseas hacer una lista con una cantidad ya conocida de elementos, lo que tienes que hacer
es lo siguiente:
>>> L = [1,2,3,6,8,a,algo,8, 3.2]
>>> Desayuno = [fruta, huevos, frijoles, tocino, cafe]
Para que puedas obtener (indexar) algn elemento de una lista previamente hecha, lo que
tienes que hacer es usar los parntesis cuadrados y el ndice del elemento requerido:
>>> L[4]
8
13
Computacin II
>>> Desayuno[0]
fruta
>>>
Observa que, al igual que en muchos lenguajes de programacin, el indexado de elementos
empieza en 0 y no en 1 como usualmente se hace en matemticas (o incluso en Matlab u
Octave).
Pero con Python se han esforzado mucho en hacer un uso eficiente y cmodo de las listas y
otro tipo de secuencias, por lo que la siguiente notacin, aunque no es estndar, te ayudar
mucho a poder manipularlas con comodidad.
Si deseas obtener todos los elementos de una lista cuyos ndices sean, por ejemplo, el 3, 4 y 5,
lo que tienes que hacer es pasar entre corchetes los ndices 3 y 6, separados por dos puntos de
la siguiente forma:
>>> L[3:6]
[6, 8, a]
>>>
Es decir, entre corchetes pasas el ndice donde quieras empezar a tomar la subsecuencia
(slice) y el ndice siguiente de donde quieras que termine; o sea, si tu subsecuencia va del
ndice i al ndice j, entonces, entre corchetes, pasas desde i hasta j+1.
Si quieres todos los elementos de una lista a partir del elemento 2 (o bien, lo puedes generalizar
del n-simo elemento en adelante), lo que tienes que haces es:
>>> Desayuno[2:]
[frijoles, tocino, cafe]
>>>
Puedes pasar ndices negativos. Por ejemplo, si pasas Desayuno[-1], lo que obtienes es:
>>> Desayuno[-1]
caf
>>>
O bien, puedes pedir toda la subsecuencia de los ltimos dos elementos de la lista Desayuno
de la siguiente manera:
>>> Desayuno[-2:]
caf
>>>
Esta instruccin puede ser interpretada en lenguaje natural como: dame los elementos de la
lista Desayuno, empezando dos antes de terminar.
14
Computacin II
Pero quieres los elementos de la lista Desayuno, dejando fuera los ltimos dos elementos,
entonces
>>> Desayuno[:-2]
[fruta, huevos, frijoles]
>>>
Si lo que quieres es obtener una copia de los valores de una lista, lo que tienes que hacer es
ocupar el operador dos puntos (:) dentro de los corchetes sin acompaarlo de ningn nmero,
o sea:
>>> P = L[:]
>>> P
[1, 2, 3, 6, 8, a, algo, 8, 3.2]
>>> L
[1, 2, 3, 6, 8, a, algo, 8, 3.2]
>>>
Es muy importante que recuerdes que as se copian los valores de una lista, ya que al hacer
una simple asignacin, como Q=L, lo que estaras haciendo sera referenciar la lista L con el
nombre Q.
>>>
>>>
>>>
[1,
>>>
L = [1, 2, 3, 6, 8, a, algo, 8, 3.2]

Q = L
Q
2, 3, 6, 8, a, algo, 8, 3.2]
Lo que significa que si haces un cambio en la lista Q, se ver reflejado tambin en L sin que sea
necesariamente lo que necesitas, y esto puede inducir a errores, ya que Python no lanza una
excepcin en este caso, pues as est diseado.
>>>
8
>>>
>>>
[1,
>>>
Q[4]
Q[4] = cambio
L
2, 3, 6, cambio, a, algo, 8, 3.2]
Si lo que quieres es unir dos listas, puedes usar el operador +

>>> L = [1, 2, 3]
>>> M = [4, 5, 6]
>>> N = L+M
>>> N
[1, 2, 3, 4, 5, 6]
15
Computacin II
>>>
O bien, puedes concatenar varias veces el valor de alguna lista, por ejemplo:
>>> O = L*4
>>> O
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
>>>
En Python las cadenas de caracteres tambin son consideradas como listas, lo que significa
que el primer carcter de alguna cadena lleva el ndice 0, 1 el segundo, y as hasta el ltimo
carcter, el cual se puede saber haciendo uso de la funcin len, que dir la longitud total de la
cadena y, por lo tanto, el ltimo carcter tiene como ndice un nmero menor que lo que indique
esta funcin. Al ser tratadas como listas, podrs indexarlas de la misma manera que estas
ltimas.
>>> c = Hola Mundo
>>> len
10
>>> c[0]
H
>>> c[2:6]
la M
>>> c[-4:]
undo
>>> c[:-2]
Hola Mun
>>>
Existen otras estructuras extremadamente tiles que se mencionarn en su momento en caso
de que las ocupes, pero sera bueno que investigaras su funcin y las conocieras; se trata de
las tuplas y los diccionarios.
Operadores Aritmticos
Los operadores matemticos son un tema que prcticamente ya conoces porque son muy
similares al de otros lenguajes, excepto por algunas particularidades referentes a la conversin
de tipos en los nmeros.
Los operadores de suma, multiplicacin, divisin, potenciacin, negacin, etctera, los puedes
encontrar en la siguiente tabla:
16
Computacin II
Operacin
Suma ## Resta
Multiplicacin ## Divisin
Potenciacin (a a la potencia b)
Mdulo (a mdulo b)
Negacin
Valor absoluto
Operador
a + b ## a- b
a * b ## a / b
a**b
a % b
-a
abs(a)
Tabla 1. Operaciones aritmticas bsicas en Python.
Una observacin importante es que si divides un entero entre otro entero, el resultado por
default es entero:
>>> a = 5/4
>>> a
1
>>>
Pero si lo que quieres es la expansin decimal, entonces tienes que hacer un truco como se
muestra a continuacin:
>>> a = float(5)/4
>>> a
1.25
>>> a = 5.0 / 4
>>> a
1.25
>>>
Observa el uso de la funcin float. Lo que hace est funcin es convertir en flotante el
argumento que le pases.
La jerarqua para aplicar estos operadores est determinada por la siguiente tabla. Primero se
ejecuta lo que haya entre parntesis, luego se evalan los exponentes, luego la multiplicacin y
divisin, y hasta el final, la suma y la resta.
1
Parntesis
2
3
4
Exponentes
Multiplicacin y Divisin
Suma y Resta
Tabla 2. Jerarqua de operaciones
Los ejemplos para esta seccin son de tu conocimiento, ya que son prcticamente triviales.
17
Computacin II
Operadores lgicos
Los valores lgicos en Python son el True y el False. Los operadores lgicos son el and, or
y not. La forma de checar la igualdad entre dos valores es igual que en muchos lenguajes, con
el doble igual (==)
Ejemplos
>>> a= 1
>>> b= 2
>>> c= 1
>>> a==b
False
>>> a==c
True
>>> not a
False
>>> not True
False
>>> d = 0
>>> not d
True
>>>
Para comprobar la relacin entre dos valores puedes usar los siguientes operadores, ==
(igualdad), > (mayor que), < (menor que), >= (mayor o igual), <= (menor o igual), y que
funcionan como en otros lenguajes que ya conoces
Relacin
Igualdad
Mayor / Menor que
Mayor igual / Menor igual que
Operador
a == b
a > b / a < b
a >= b / a <= b
Tabla 3. Operadores lgicos en Python.
Ciclos
Una de las partes ms importantes de un lenguaje de programacin es su control de flujo,
aspecto que se controla a travs de las instrucciones para establecer ciclos; en Python stas
son el for y el while.
La sintaxis del for es como sigue:
for variable in lista_de_valores:
Cuerpo del for
Se han marcado con rojo los elementos que no debes dejar pasar. Esta forma del for indica
que todas las lneas especificadas en el cuerpo se ejecutan tantas veces como valores tome
variable en la lista_de_valores. Presta particular atencin en los dos puntos al final de
18
Computacin II
la lnea que contiene al for, y en el tabulador que debe aplicarse a Todas las lneas dentro del
cuerpo del for; estos no son Opcionales.
A continuacin puedes ver un par de ejemplos de cmo invocar el for:
>>> for i in [1, 2, 3]:
...
print Linea , i
...
Linea 1
Linea 2
Linea 3
Aqu puedes ver cmo el cuerpo del for que consta de una sola lnea se ejecuta tantas veces
como valores toma la variable i dentro de la lista especificada. El siguiente ejemplo es un poco
ms complicado, no slo porque el for usa dos lneas, sino porque tambin se introducen dos
funciones nuevas que son str y range, as como la concatenacin de cadenas.
>>> for i in range(5):
...
print Esta es la linea , i
...
str(i) + El doble de + str(i) + es: +str(i*2)
...
Esta es la linea 0
0 El doble de 0 es: 0
Esta es la linea 1
Esta es la linea 2
Esta es la linea 3
Esta es la linea 4
>>>
La funcin range entrega una lista que va desde el valor inicial indicado en el parmetro hasta
el final, tambin indicado en el parmetro; cuando slo se indica un nmero, toma por defecto
que la lista comienza en 0 y acaba en ese nmero. Opcionalmente, tambin puedes indicarle
cuntos pasos debe dejar intermedios.
>>>
[0,
>>>
[2,
>>>
[2,
range(5)
1, 2, 3, 4]
range(2,5)
3, 4]
range(2,5,2)
4]
19
Computacin II
>>>
La funcin str convierte su argumento en una cadena con todas las propiedades de la misma,
particularmente con la propiedad de poderse concatenar a otras cadenas. En el ejemplo se
concatena el nmero i con la cadena El doble de, luego con el nmero i otra vez, luego
con la cadena es: para concatenarlo, finalmente, con el nmero que corresponde al doble
de i
str(i) + El doble de + str(i) + es: +str(i*2)
Observa cmo en este ltimo ejemplo ambas lneas tenan la misma indentacin y fueron stas
las que se ejecutaron mientras la variable i tomaba los valores especificados con range, a
saber 0, 1, 2, 3 y 4.
La funcin while es muy similar, y la diferencia radica en que el cuerpo del while se ejecuta
mientras la condicin lgica especificada se siga cumpliendo. La sintaxis es como sigue:
while condicin:
cuerpo del while
De igual forma, no debes perder de vista las partes resaltadas en rojo, as como el tabulador en
el cuerpo del while, ya que es forzoso ponerlas.
En el siguiente ejemplo puedes ver su funcionamiento:
>>> while x < valor:
...
print str(x) + es menor + str(valor)
...
x += 1
...
0 es menor 5
1 es menor 5
2 es menor 5
3 es menor 5
4 es menor 5
>>>
Observa cmo se ejecutaron las dos lneas en el cuerpo del while hasta que la condicin dej
de cumplirse. En la segunda lnea del cuerpo puedes notar que hay una instruccin atpica que
es
...
x += 1
Lo que en Python significa que la variable va a aumentar en 1 su valor. Esta instruccin tiene
la misma funcin que en Java o en C tiene la instruccin
x++
Con la diferencia de que en Python, en vez de poner 1, puedes poner el valor que desees.
20
Computacin II
Imports
En Python, como en cualquier otro lenguaje, existen funciones preprogramadas o mdulos que
se qiueran incorporar al cdigo, lo cual se logra con la palabra reservada import. Por ejemplo
>>> import math
- incorpora todo un conjunto de funciones que puede intuirse que son de naturaleza
matemtica, y a las cuales vas a acceder a travs del operador . (punto), por ejemplo, la
funcin sqrt, que calcula la raz cuadrada, pertenece a este mdulo; entonces, para invocar a
la raz cuadrada, lo que tienes que hacer es lo siguiente:
>>> math.sqrt(25)
5.0
>>>
Otras formas equivalentes de importar las funciones de un mdulo son:
>>> import math as m
Lo que hace que tengas un alias para el mdulo math llamado m
>>> from math import sin
Lo que hace que importes la pura funcin sin, que dependa del mdulo math. Aunque esta
particular forma de importar funciones no es la mejor prctica de programacin, ya que puede
suceder que tengas redundancia de funciones en el mismo mbito de programacin.
Con esto tienes una introduccin muy bsica pero bastante robusta para entender cualquier
programa en Python.
Para saber ms
http://en.wikibooks.org/wiki/Python_Programming/Sequences
http://docs.python.org/2/tutorial/datastructures.html
http://docs.python.org/2/library/stdtypes.html
Actividad 1. Nmeros aleatorios con Phyton

En esta actividad vas a practicar el uso de Python operando con nmeros aleatorios.
Instrucciones
1. Descarga el archivo Act1. Nmeros aleatorios con Python.
2. Lee el contenido, atendiendo a las instrucciones y sugerencias que se hacen.
3. Crea un script de Python donde guardes la funcin y ejemplos que se te piden.
4. Guarda tu documento con la siguiente nomenclatura: MCOM2_U1_A1*_XXYZ.
21
Computacin II
5. Enva el documento a tu Facilitador(a) y espera su retroalimentacin.
* Recuerda consultar la Escala de evaluacin de la actividad para saber qu aspectos se
tomarn en cuenta para su revisin.
1.2. Tipos de datos

En la seccin anterior empezaste a vislumbrar la relacin que existe entre datos e informacin,
siendo los datos la estructura ms bsica que puedes encontrar, y que, usualmente, ser la
entrada de algn proceso de cmputo.
El aspecto ms importante que caracteriza a los datos es que son la entrada de tus programas,
particularmente la entrada de tu algoritmo, o, desde un punto matemtico equivalente, es que
son el argumento de la funcin que va a mapear un conjunto en otro. Y se es el concepto que
vas a representar con el trmino datos, el dominio de una funcin que, a su vez, intenta
modelar lo mejor posible algn fenmeno.
Los diferentes tipos de datos siguen una jerarqua que va desde lo ms sencillo, como son los
tipos primitivos, hasta unas construcciones mucho ms complejas, como los tipos de datos
abstractos, aunque todos con la misma filosofa: los tipos de datos van a funcionar como el
domino para el algoritmo que ests implementando.
En esta unidad revisars la jerarqua y filosofa detrs de lo que se considera un dato, que va
desde los valores ms bsicos hasta conceptos como el de clase y objeto. Y aun cuando
Python no trabaja explcitamente con una gran gama de datos primitivos distintos, no quiere
decir que de forma subyacente no lo haga, y tambin est el hecho de que Python es un
lenguaje orientado a objetos, que es uno de los tipos que desarrollars.
1.2.1. Tipos primitivos

Estos son los tipos de datos ms bsicos que pueden existir, despus del binario, por su
puesto. Otros lenguajes de programacin toman categoras dependiendo de la cantidad de bits
usados.
Booleanos
Byte
Char
nicamente requieren 1 bit para expresar todos los valores. No estn

signados, lo cual significa que no toman valores negativos.
Usan 4 bits nicamente (1 byte). Estn signados y toman valores
desde el -128 al 127.
Este tipo de datos hace uso de 16 bits y guarda una tabla de 65,535
22
Computacin II
Short
Int o Integer
Long
Float
Double
smbolos distintos, segn la especificacin Unicode.

Tipo de datos signado que tiene un tamao de 16 bits, toma valores
que van desde el -32,768 hasta el 32,767.
Tipo de datos signado que hace uso de 32 bits. Toma valores desde
el -2,147,483,648 hasta el 2,147,483,647.
Son variables que tienen un tamao de 64 bits, pero siguen siendo
enteros y van desde -9,223,372,036,854,775,808 hasta el
9,223,372,036,854,775,807.
Pueden representar nmeros con expansin decimal segn el
estndar IEEE 754, con un tamao de 32 bits.
Representan nmeros con expansin decimal, pero hacen uso de 64
bits segn el estndar IEEE 754.
Este tipo de datos son usados para los clculos ms bsicos y son comnmente asociados al
modelo de tipado esttico, es decir, se usan en aquellos lenguajes donde se debe declarar a
qu tipo pertenece cada variable.
Bajo el modelo de tipado dinmico de Python esta asignacin es transparente, excepto por las
ocasiones en las que explcitamente necesites mapear una variable a un tipo entero o flotante.
Para saber ms
http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
1.2.2. Tipos simples y compuestos

Los tipos de datos simples son la primera abstraccin til usada en la modelacin a travs de la
computadora. Los tipos de datos que corresponden a los tipos simples tipos de datos que no
constituyen ninguna estructura ms all que el escalar que representan. Como puedes advertir
bien, todos los tipos primitivos estn considerados aqu, aunque la distincin no es clara.
Dentro de los datos compuestos puedes encontrar las estructuras denominadas struct en C,
o los tipos enum. Un dato del tipo struct reserva un rea en memoria para valores no
homogneos, es decir, son el tipo de datos que contemplan problemas donde un dato est
compuesto por valores de distinto dominio. Un ejemplo puede ser la entrada en una agenda.
struct entrada{
int edad;
char [100] nombre;
char [10] telefono;
};
23
Computacin II
Figura 6. Struct que ilustra la implementacin de la entrada en una agenda telefnica.
Qu aporte tiene un tipo de dato struct sobre definir las variables por separado? La ventaja de
definir tipos compuestos de esta forma es la de proveer consistencia en el manejo de
variables dentro del programa y dejar que el lenguaje de programacin se encargue de asignar
los valores necesarios en memoria.
Esto no puede parecer una gran ventaja basada en ciencia y anlisis, y parece recaer
nicamente en una implementacin basada en la heurstica y diseada para fomentar la
comodidad del programador. Esto no es enteramente falso, pero no es la nica razn. Al
incorporar a tu modelo tipos compuestos, tambin facilitas la tarea de incorporar
consistentemente operaciones propias del dominio al que corresponda el tipo struct en
cuestin. El ejemplo ms sencillo del que se puede valer es el de los nmeros complejos,
aquellos que se componen de una parte real y una imaginaria, mas ambos valores son nmeros
reales, al menos en el modelo matemtico. La forma en la que puedes incorporar esto en un
struct es la siguiente:
struct complejo {
float parte_real;
float parte_compleja;
};
Figura 7. Struct que implementa un nmero complejo.
Al tener un tipo de datos como el mostrado en la figura 6 puedes implementar los axiomas que
operan sobre los nmeros complejos con ms facilidad. Por ejemplo, la suma de dos complejos,
como sabes, se realiza sumando las partes reales y las partes imaginarias correspondientes. El
resto de los axiomas sobre la operacin sobre nmeros complejos como el conjugado de un
nmero, la multiplicacin, etctera, preservan esta simplificacin incorporada en el momento en
que encapsulas todo un concepto en un espacio en memoria.
Otro tipo de dato compuesto es el enum, y la finalidad en su diseo es la de especificar
variables en las que hay una secuencia implcita en un conjunto de valores. El ejemplo ms
sencillo son de tipo temporal, por ejemplo, los das de la semana o los meses del ao.
enum semana { dom, lun, mar, mie, jue, vie, sab } semanaX;
Figura 8. Ejemplo de un tipo enum.
24
Computacin II
Entonces, lo que hay que resaltar en esta transicin desde los tipos primitivos hasta los
compuestos, es el concepto de encapsulacin de los axiomas y propiedades concernientes al
dominio modelado con estos tipos de datos ms complejos.
Para saber ms
Data Structures: Abstract Data Types. En lnea http://www.youtube.com/watch?v=HcxqzYsiJ3k
1.2.3. Tipos abstractos

Con este recorrido entre los diferentes tipos de datos que caracterizan a los lenguajes
fuertemente tipados como C o Java se puede dar paso a la explicacin del paradigma de
programacin dominante actualmente: el modelo de programacin orientada a objetos.
Hasta este momento los tipos de datos han ido evolucionando sobre los componentes
estructurales de los elementos del dominio requeridos en algn problema particular, desde el
uso de los nmeros flotantes para los cuales las operaciones estn completamente
incorporadas en la mquina que los opera, pasando por la cardinalidad impuesta en los tipos
enum, hasta los nmeros complejos que estn compuestos por dos flotantes, uno de los cuales
representa la parte real, y otro, la parte compleja.
Con esta abstraccin estructural sobre los elementos que componen el dominio plasmado en
las variables que usas en el programa, se ha ido facilitando la tarea del programador al
encapsular todos los datos que requiere para modelar algn problema en un cmodo paquete.
Pero con un dominio con cierta estructura tambin viene un conjunto de propiedades y de
funciones vlidas que hagan cosas interesantes. En este momento se tiene que hablar un poco
sobre esa tarea tan intangible que es modelar en un prrafo.
Todos los que han programado saben que tienen que hacer un compromiso entre los aspectos
caractersticos que toman del problema que estn resolviendo y los detalles innecesarios que
descartan porque no incorporan nada a la resolucin del mismo. Esta tarea, tan comn
prcticamente a cualquier cientfico, es ineludible a cualquier programador; as que tienes que
abstraer los elementos ms importantes y significativos de un problema para poder resolverlo lo
mejor posible. Esto es lo que se entiende por modelar.
Cuando haces un modelo identificas qu partes componen en esencia el fenmeno observado y
cules son parte del panorama y pueden ser descartadas. Ms importante an, una vez que
identificas estos componentes o actores fundamentales, no lo haces nicamente estableciendo
etiquetas, sino identificando comportamientos y relaciones entre ellos. Como matemtico
debes tener algo de prctica haciendo estos resmenes de la realidad que percibes a travs de
los sentidos. Tal vez esto te deje un amargo sabor de boca al leer que no existe una tcnica
depurada y transversalmente aceptada, y finalmente correcta, detrs de la modelacin, pero
ese es el estado actual de las cosas: el hacer un modelo es una de las tareas ms difciles por
25
Computacin II
lograr, ya que cada persona percibe su entorno de manera distinta. Si te hace sentir mejor, no
debes olvidar el refrn
Todos los modelos son malos, pero algunos sirven mejor que otros.
Todo esto viene a cuento porque las computadoras son las herramientas de modelacin por
excelencia, y las computadoras digitales son las ms usadas actualmente. Esto los logrars
haciendo uso de lenguajes de programacin, que es donde vas a plasmar los modelos que
hagas en papel para poder obtener algn resultado medible.
Los tipos de datos abstractos (TDA) o tipos abstractos (Abstract Data Type o ADT en ingls)
son la abstraccin ms general que se puede hacer en un tipo de dato, y es que, a diferencia de
los structs, quienes incorporan nicamente los distintos componentes de un nuevo tipo de
dato o los tipos primitivos que se derivan bsicamente de la estructura del procesado, en los
TDA se hace una descripcin axiomtica de los elementos de un dominio incorporando las
propiedades, caractersticas y operaciones que actan sobre cada elemento del dominio. Es
decir, en la definicin del TDA se incorpora qu es lo que este nuevo tipo de dato tiene
permitido hacer, as como los elementos que lo componen.
Ejemplo: Puedes retomar el ejemplo de los nmeros complejos como un TDA. Como ya se dijo
y sabes, los nmeros complejos constan de dos nmeros reales que modelars con un par de
entradas flotantes, pero tambin constan de un conjunto de operaciones especficas de los
nmeros complejos como:
1.
2.
3.
4.
5.
El conjugado de un nmero
La suma de complejos
El producto de complejos
Una norma especfica
La igualdad entre dos nmeros complejos
Pero tambin puedes distinguir un par de constantes concretos de los Complejos,
1. Neutro aditivo
2. El nmero complejo
,
tal que
( )
( )
Cada una de estas funciones se opera de una forma muy especfica y no es la misma que la
multiplicacin de reales o de matrices; son funciones especficas de los complejos, entonces, si
defines un objeto que modele a los nmeros complejos, vas a querer que incorpore estas
funciones especficas concernientes a los complejos. Ests listo, pues, para la definicin de
objeto complejo.
TDA Complejo
Constantes:
26
Computacin II
0: Complejo
i: Complejo
Atributos:
real: Parte real <float>
imaginaria: Parte imaginaria <float>
Operaciones:
Igualdad:
Suma:
Producto:
Escalar:
Norma:
Operacin Igualdad
Recibe: c1 y c2 nmeros complejos
Regresa: z complejo
Regresa z
Operacin Norma
Recibe: c complejo
Regresa: z real
Regresa z
Operacin Escalar
Recibe: c complejo y r real
Regresa: z complejo
Operacin suma
Recibe: c1 y c2 complejos
Regresa: z complejo
Operacin multiplicacin
Recibe: c1 y c2 complejos
Regresa: z complejo
27
Computacin II
Figura 9. Definicin del TDA para nmeros complejos y un par de prototipos de funciones para la suma y la
norma.
Lo importante de los TDA como el que se acaba de especificar es que en un tipo de dato de
computadora se han capturado todos los elementos, axiomas y propiedades, que describen al
campo de los nmeros Complejos correctamente bien encapsulado dentro de un objeto.
Los TDA pueden extenderse a objetos con una definicin formal ms laxa, pero la definicin
depende de tu habilidad como programador para identificar los elementos que componen
alguna problemtica especfica. Por ejemplo, podemos definir TDA sobre objetos que
pertenezcan al dominio de la biologa, los cuales tienen una serie de caractersticas, as como
un conjunto de funciones ms o menos conocidas.
Clase
Hasta ahora el concepto de TDA es una descripcin terica que describe a los elementos de un
dominio junto con sus operaciones. Una clase es la implementacin de un TDA en un lenguaje
de programacin, considerando los atributos (elementos caractersticos) y las funciones u
operaciones que actan sobre ellos. En el siguiente ejemplo puedes ver cmo se podra
implementar el TDA de nmero complejo presentado anteriormente en Python.
Ejemplo. Clase de nmero complejo implementada en Python
from math import sqrt
class Complejo(object):
Ejemplo de clase que implementa
numeros complejos en Python
def __init__(self, v=(0,0)):
Constructor
if v==(0,0):
self.real = 0.0
self.imag = 0.0
else:
self.real = v[0]
self.imag = v[1]
def __str__(self):
Regresa la representacion en cadena de este nmero con formato
a+bi
if self.imag == 0.0:
return str(self.real)
elif self.real == 0.0:
28
Computacin II
return str(self.imag) + i
else:
return str(self.real) + + + str(self.imag) + i
def suma(self, num2):
Suma el numero complejo actual con num2
self.real += num2.real
self.imag += num2.imag
def multiplicacion(self, num2):
Multiplica el numero complejo actual con num2
self.real = self.real * num2.real - self.imag * num2.imag
self.imag = self.real * num2.imag + self.imag * num2.real
def por_escalar(self, r):
Multiplica el nmero actual por el escalar r
self.real *= r
self.imag *= r
def absoluto(self):
Calcula el valor abosluto de un nmero
return sqrt(self.real**2 + self.imag**2)
El ejemplo anterior resulta un poco redundante, ya que los nmeros complejos ya estn
definidos nativamente en Python junto con todas sus definiciones, pero en l puedes ver la
finalidad de definir un TDA y, posteriormente, convertirlo en una clase en algn lenguaje de
programacin. Como puedes ver en el cdigo anterior, estn definidas algunas operaciones con
complejos, as como la estructura que todo complejo posee, una parte real y una imaginaria;
aparte de esto, puedes ver que hay dos funciones requeridas por Python, definidas __init__ y
__str__. La primera es el constructor del objeto y la segunda es una funcin para convertir un
objeto en cadena para as poder imprimirlo en pantalla
Sugerencia
Define, tomando como modelo las funciones definidas, la funcin conjugado que determine el
conjugado del nmero complejo actual.
1.3. Anlisis de algoritmos

Se ha hablado con insistencia sobre el definir algoritmos ms o menos eficientes, y es parte de
este curso y de quienquiera que se dedique a programar, el tener la habilidad de disearlos o,
por lo menos, identificar en qu puntos un algoritmo se est tardando, y si se puede eficientar, o
el problema es en esencia demasiado complicado para acotar su solucin. Eso es lo que hars
en esta seccin: aprenders algunas tcnicas para determinar qu tan lento o rpido puede ser
29
Computacin II
un algoritmo, independientemente de la computadora o lenguaje de programacin que se est
usando.
Ya se ha hablado y referenciado el modelo de Turing como modelo de cmputo. El siguiente
ejemplo no es exactamente el modelo de Turing, pero en algo se asemeja. Antes de que
existieran las hojas de clculo, los contadores solan usar unas hojas tabuladas para escribir
sus datos. Este modelo de cmputo va a ser una hoja de clculo donde las instrucciones las
irs definiendo conforme cada problema vaya apareciendo. La mencin sobre las hojas
tabuladas es porque un modelo de cmputo usando una computadora puede no ser el ms
adecuado, pero si esto te llega a molestar, puedes pensar que ests trabajando con las
limitaciones que una hoja tabular impone.
La motivacin para ocupar una hoja de clculo como modelo de cmputo es que la memoria de
una computadora es bsicamente un arreglo de celdas direccionadas donde tus datos existen y
son manipulados.
Ejemplo: Considera los siguientes datos en una hoja de clculo
1
2
3
4
5
12
6
9
21
6
Donde la primer columna indica el ndice del elemento, y la segunda ndica el valor que ese
ndice representa. En todos los aspectos de computacin, encontrar algn valor particular de un
arreglo es particularmente requerido. A continuacin puedes ver un par de algoritmos diseados
para obtener el mximo de ese arreglo. Estn escritos en pseudocdigo, el cual seguramente
ya conoces, pero lo se volver a describir, ya que no es propiamente un lenguaje de
programacin, pero s es lo suficientemente genrico para poder ser implementado en uno,
salvo algunos aspectos tcnicos dependientes de cada lenguaje.
Algoritmo maximo1
Recibe: Arreglo K
Entrega: m, K[m] tal que 1<=m<=longitud(K), K[m] mximo en el arreglo
1. Inicializamos v = 0, m = -1
2. Id = 1
3. vact = K[id]
4. si vact > v entonces v = vact
30
Computacin II
Para saber ms
Crescenzi, Pierluigi. A compendium of NP optimization problems. En lnea
http://www.csc.kth.se/~viggo/problemlist/
Bell R. A begginers guide to Big O Notation. En lnea http://rob-bell.net/2009/06/a-beginnersguide-to-big-o-notation/
Actividad 2. Reflexin sobre algoritmos

En esta actividad, a travs del foro; reflexionars sobre el uso de algoritmos y distintos tipos
de datos, incluyendo datos abstractos en tu actividad cotidiana. Para ello:
1. Realiza un anlisis sobre el uso explcito y tcnico de distintos algoritmos utilizados en
las asignaturas anteriores y contrstalos con algoritmos de la vida cotidiana.
2. Reflexiona sobre distintos tipos de datos abstractos con los que interactes da con
da, as como los algoritmos de los cuales se derivan.
3. Ingresa al foro y escribe al menos tres distintos TDA y los algoritmos que los usan.
4. Contribuye con comentarios y observaciones, revisando las aportaciones de tres de
tus compaeros(as), aceptando o rechazando sus aportaciones.
* Consulta la Rbrica general de participacin en foros que se encuentra en la seccin
Material de apoyo.
1.3.1. Notacin asinttica

Para poder medir la eficiencia de un programa, lo que necesitas hacer es medir cunto tardan
en llevar a cabo su cmputo. Una opcin sera medir el tiempo en milisegundos que le toma
llevar a cabo todas sus instrucciones, pero con esto obtendras una medida que depende
mucho del procesador, y peor an, generalizar una medida de qu tan tardado es un algoritmo.
De esta forma, es muy dependiente del problema o incluso del lenguaje o habilidad del
programador.
Conteo de instrucciones
Una alternativa para esto es que te valgas de la naturaleza discreta de las computadoras y
cuentes la cantidad de instrucciones bsicas realizadas por cada algoritmo. Entonces,
independientemente de dnde est implementado el algoritmo, podrs contar cul es el nmero
de instrucciones ejecutadas en algn momento. Por instrucciones bsicas vas a considerar, por
lo pronto, las siguientes en cualquier lenguaje:
31
Computacin II
Asignacin de valores a una variable: Por ejemplo, x = 5

Operacin aritmtica bsica: Por ejemplo, x++, o bien, x + 4.
Comparar dos valores: Este se puede ver en el uso del condicional if o bien if-else, ya
que en un slo paso se puede determinar qu rama de programacin tomar.
Recuperar un valor indexado: Por ejemplo, si X es un arreglo, entonces X[n] (con n
natural); esto se considera una instruccin bsica.
Todas estas consideraciones para considerar una instruccin bsica se deben bsicamente al
hecho de que, en un solo paso o ciclo del reloj, estas instrucciones pueden ser realizadas.
Particularmente, Python tiene un conjunto de instrucciones que no suceden precisamente en un
solo paso como, por ejemplo, la instruccin
x += 1
Son dos instrucciones bsicas, una es la operacin y la otra es la asignacin. Pero vers que
este particular detalle tpicamente no va a ser muy importante, como se detallar en un par de
prrafos.
Ve el siguiente segmento de cdigo
>>>
>>>
>>>
>>>
a =
n =
L =
for
M[0]
len(M)
range(n)
i in L:
if (M[i] > 5):
M[i] += a
>>>
Figura 10. Segmento de cdigo
El segmento de cdigo anterior lleva a cabo una operacin al inicio, cuando hace la asignacin
a = M[0] El conteo de operaciones va en 2, ya que se hizo una asignacin y una lectura de un
arreglo. Despus se hace una asignacin a n = len(M), lo que aumenta el contador a tres
instrucciones ejecutadas.
Despus se tiene una instruccin que asigna a L un arreglo con n enteros, lo que significa
aumentar el contador en 1, con lo que se llega a 4, pero despus la instruccin range(n) crea un
arreglo con n elementos enteros, lo que va a tomar n pasos. Entonces, el contador va en
.
Despus se ejecuta una operacin un tanto invisible, pero que se sabe que sucede, y es la
asignacin a i del primer elemento del rango de valores en L; el contador va ahora en
.
En este punto es donde la tarea de contar instrucciones empieza a complicarse un poco y esto
es por el uso del for, que son muy comunes en cualquier programa, y como puedes advertir,
van a aumentar el nmero de instrucciones ejecutadas tantas veces como entres en el for. En
32
Computacin II
este particular caso no vas a considerar la ltima instruccin contada, y la vas a cambiar por n
asignaciones a la variable i, con lo que tendrs al contador en
.
Si no entras ninguna vez al cuerpo del for, obtenedrs el siguiente conteo de instrucciones:
( )
Tiempo de ejecucin mximo
Ahora, el contar las instrucciones que estn contenidas en el cuerpo del for, como puedes ver,
no es trivial, ya que las condiciones pueden darse para que entre una sola vez al if, o bien,
tantas veces como elementos tenga el arreglo. Qu debes considerar entonces?
Lo que usualmente se hace es tomar el peor de los casos, es decir, vas a considerar que entras
tantas veces como elementos tiene el arreglo. Entonces, si entras a la evaluacin del if tantas
veces como elementos, tienes que contar dos instrucciones ms, una por la recuperacin del
elemento del arreglo M y otra por la comparacin, por cada vez que entras al ciclo; en otras
palabras, tienes que agregar
pasos al contador
( )
Pero, como ests considerando el tiempo mximo, tambin debes considerar que la evaluacin
del if es verdadera, con lo que debes considerar que entre al cuerpo del if, lo que arroja otras
tres instrucciones ms por cada vez que entres al for: una por la operacin aritmtica de sumar
4, otra por recuperar el valor de M[i], y la ltima por la asignacin; entonces, el conteo de
instrucciones final queda como
( )
A esto se le conoce como tiempo mximo de ejecucin, y se define de la siguiente manera
Definicin
El tiempo mximo de ejecucin
es el mximo nmero de pasos necesarios
para ejecutar un algoritmo ( ) con una entrada de tamao en una mquina de
Turing
( )
( )
(2)
| |
Este es el tipo de anlisis que vas a hacer con el cdigo; lo irs haciendo ms eficiente
conforme vayas avanzando en la unidad. En este caso, obtuviste el tiempo de cmputo para el
peor de los casos, aunque tambin se puede obtener el promedio de tiempo de cmputo, pero
este suele ser muy engorroso y, por lo pronto, no lo vas a considerar.
Comportamiento asinttico
Una pregunta que vale la pena hacerse es, qu tan importante es la expresin recin
encontrada para el segmento de cdigo presentado si para todo fin prctico sucede
instantneamente a nuestros ojos? La pregunta es vlida, y la respuesta es que es irrelevante
para arreglos pequeos, pero no as para arreglos cada vez ms grandes. Suponiendo este
33
Computacin II
ltimo caso, en el que cada vez el arreglo es ms grande, puedes notar que el trmino 4 de la
expresin anterior es cada vez menos significativo que el trmino 7n.
Precisamente porque piensas usar los algoritmos con entradas grandes, es decir,
los
trminos independientes no hacen diferencia alguna; de hecho, nicamente vas a considerar el
trmino dominante del tiempo de cmputo, lo que vas a representar mediante la notacin
( ( )), denotada como la asntota de ( ). La asntota del ejemplo revisado es
( )
Esto recibe una definicin especfica y se le denomina Cota Superior Asinttica ( ( )), o bien,
un trmino ms informal y popular, O grande.
Definicin
Se dice que una funcin ( ) est acotada superiormente, o dominada, por la funcin
( ) si para algn
y para una constante se cumple que
( )
( )
(3)
y se denota como ( ) es de orden ( ( )), o bien,.

( ) ( ( ))
Usualmente, en lugar de ( ) vas a usar a ( ) como la funcin que quieres acotar
asintticamente.
Ejemplo. Para el caso que se ha expuesto, si tomas
que cumpla
lo que implica que puedes escoger
, entonces tienes que encontrar
como:
Se usa el menor o igual porque, aunque basta con que lo cumpla, tambin interesan las
constantes que hacen que hagan a la asntota mayor que la funcin que quieres acotar.
Ejemplo:
La funcin ( )
es de orden ( ). Para poder ver esto tienes escoger
Entonces podrs verificar fcilmente que
El significado grfico de esto lo puedes ver a continuacin
34
Computacin II
Figura 11. Dominio en el crecimiento de la funcin en verde que es sobre la roja que representa a

Ejemplo: La funcin ( )
tal que
Esto significa que
NO es de orden (
). Si as lo fuera, entonces existen
. / , pero esta constante crece conforme aumenta el valor de , lo
que no es posible.
Otra definicin que conviene introducir es la ( ( )), que funciona como complemento al de
( ( )), es decir, la funcin que acota inferiormente a ( )
Definicin
Se dice que una funcin ( ) est acotada inferiormente por la funcin ( ) si para
algn
y para una constante se cumple que
( )
( )
(4)
y se denota como la omega de ( ) es ( ), o bien,

( ) ( ( ))
Se usa principalmente la definicin de ( ( )) por las siguientes razones que caracterizan a .
Cuando se dice que ( ) es de orden ( ( )), significa alguna de las siguientes proposiciones
equivalentes
35
Computacin II
( ) no crece ms rpido que ( )
o bien
( ) crece a lo ms tan rpido que ( )
Entonces, se puede empezar a trabajar con esta definicin para construir algoritmos ms
complejos y determinar el orden por el que estn dominados. Es decir, surge la pregunta, cul
es el orden de un algoritmo que consta de ejecutar un algoritmo seguido de otro?
Teorema
Si tienes dos algoritmos
y , cada uno con un tiempo mximo de cmputo ( ) y
( ) y de orden ( ( )) y ( ( )) respectivamente, entonces el orden del algoritmo
, que consta de ejecutar secuencialmente cada uno de los dos algoritmos, es de
. ( ( ))
(1)
( ( ))/.
Demostracin
La demostracin es muy sencilla. El tiempo mximo de cmputo de
Sabes que
( ( ))
( ( ))
Esto quiere decir que existen
es
( )
( )
( ).
tales que
( )
( )
*
+ para garantizar que tienes un punto en el que no se
Escoge entonces a
viole dicha definicin. Sumando estas expresiones obtienes
( )
( )
*
Debido a que escogiste a

(
(
- puedes replantear la expresin como:

* ( ) ( )+
* ( ) ( )+
* ( ) ( )+
)
* ( ) ( )+
Al construir as a
y has demostrado que al concatenar dos algoritmos, su complejidad
queda acotada por la cota ms grande de los algoritmos que la componen, i.e.
* ( ) ( )+)
( )
(
Otra propiedad fundamental es la de ejecutar un algoritmo
dentro del algoritmo , un
ejemplo de lo cual sera ejecutar un for dentro de otro for. Qu complejidad tiene asociada
esta composicin de algoritmos?
36
Computacin II
Teorema
Si tienes dos algoritmos
y , cada uno con un tiempo mximo de cmputo ( ) y
( ) y de orden ( ( )) y ( ( )) respectivamente, entonces el orden del algoritmo
, que consta de ejecutar
como una instruccin de , tiene una complejidad de
( ( ) ( )).
Demostracin
El tiempo mximo de cmputo del algoritmo
dentro de la ejecucin de
vas a ejecutar
(2)
( )
es de
( ); esto se sigue de que
como una de las instrucciones que lo componen.
Se sabe que
( ( ))
( ( ))
Esto quiere decir que existen
tales que
( )
( )
*
+, entonces puedes garantizar que tienes un punto en el que no
Si escoges
se viola esa definicin, y por lo tanto, puedes multiplicar estas dos expresiones.
( )
( ) (
) ( ( ) ( ))
As, pues, has construido
para los que se cumple que

( ( ) ( ))
Las funciones que usualmente se ocupan para establecer un marco de referencia son las
siguientes:
37
Computacin II
Figura 12. Funciones paradigmticas para clasificar ordenes de complejidad.
Aunque la funcin en rojo es el 5, es en realidad la funcin constante. En trminos de O grande

estas funciones son
Orden
( )
(
( ))
( ))
(
Nombre
Constante
Logartmica
Cuasi lineal
Cuadrtica
Cbica
Exponencial
Donde claramente la que crece ms rpido es . Pero es interesante resaltar el hecho que se
aprecia en la grfica. De hecho, ese crecimiento es exponencial segn la entrada,
y eso es fcil de ver, ya que si la complejidad de un algoritmo crece tan rpido, apenas
doblando el tamao de su entrada, es fcil suponer que los recursos para ejecutarlo se
terminarn igual de pronto.
38
Computacin II
Todos estos tipos de resultados son el fundamento para determinar qu tanto puede tardar un
algoritmo en ejecutarse en toda su entrada, y a partir de este esquema de comparacin se
podr determinar si los algoritmos son ms o menos eficientes.
1.3.2. Algoritmos iterativos y recursivos

Este par de resultados nos pueden servir para aplicarlos en todo tipo de algoritmos, pero las
secciones ms complicadas y tambin las ms representativas en una amplia gama de
problemas son la recursin y las iteraciones.
Iteraciones
El caso ms sencillo es el expuesto por las iteraciones, adems que ya se ha visto un poco en
el primer teorema revisado, pero se examinar particularmente un ejemplo donde se usan un
par de for anidados uno en el otro.
Supn que tienes un arreglo con n elementos llamado M y quieres buscar qu elementos estn
duplicados en l. Esto significa comparar el primer elemento con el resto de los elementos en el
arreglo y as hasta llegar al final; el siguiente cdigo de Python expresa esta idea.
In [14]: import random
In [15]: M = [random.randint(1,9) for x in range(10)]
In [16]: M
Out[16]: [1, 4, 1, 4, 8, 9, 3, 7, 7, 3]
In [17]: for i in range(len(M)):
....:
for j in range(len(M)):
....:
if M[i]==M[j]:
....:
print duplicado , M[i]
Figura 13. Ejemplo de for anidado.
En este segmento de cdigo puedes ver que en la lnea In[17] hay un for dentro de otro.
Primero analizas el ms anidado. En el peor de los casos se va a ejecutar la comparacin y la
lnea del print, esas son dos lneas por cada elemento de M.
( )
Y este for, el que regula el ndice j, se va a ejecutar tantas veces como el que regula el ndice i,
por lo que la cuenta final queda
( )
39
Computacin II
Es fcil encontrar
tal que
( )
De hecho, usando los teoremas antes vistos, y de aqu en adelante usars como resultado, que
cuando tengas una serie de fors anidados ( de ellos, por ejemplo), donde todos recorran un
arreglo, este segmento de algoritmo tendr una complejidad polinomial de ( ). Usualmente
, por lo tanto, en fors anidados, espera tener una complejidad de ( ).
Recursividad
Un algoritmo recursivo consta de dos caractersticas muy importantes. La primera es que hace
una llamada a s mismo con un argumento reducido, y la segunda es que contiene una clusula
de escape a la cual se llega cuando el argumento rebasa algn umbral predefinido.
( )
El ejemplo de funcin recursiva arriba escrito es la forma ms bsica de una funcin recursiva
en el que la clusula de escape se alcanza si el argumento rebasa un umbral que usualmente
puede pensarse como un entero, al que, en otro caso, le vas restando para poder alcanzar la
clusula de escape. Esto no tiene que ser forzosamente, ya que la funcin que altere el
argumento no necesariamente tiene que ser una resta, sino puede ser una funcin de tal forma
que converja a .
El primer algoritmo recursivo que puedes encontrar es el clculo de factorial, que es
bsicamente el primer ejemplo de recursividad que siempre se revisa. Su definicin matemtica
es la siguiente
{(
Aunque tambin se puede definir usando el operador de producto, por lo pronto esta definicin
te ayudar a hacer tu punto. A continuacin puedes ver el cdigo en Python:
In [1]: def factorial(n):
...:
return n*factorial(n-1) if n>1 else 1
Figura 14. Definicin de factorial en Python con una forma alternativa del if-else
El anlisis de este particular algoritmo no es difcil. En el caso ms bsico, si n=1 la complejidad

es una constante , de no serlo, entonces, al pasar un argumento distinto de 1, la funcin se
ejecutar tantas veces como lo indique el argumento, i.e.
( )
( )
( )
En general
40
Computacin II
( )
( )
Entonces es fcil ver que la complejidad de factorial es

( )
( )
Ahora analizars este ejemplo. Obtener la potencia de un nmero mediante la funcin pow
.
{
/
.
En Python este cdigo se vera como

In [21]: def pow(x,n):
....:
if n==0:
....:
return 1
....:
elif n==1:
....:
return x
....:
elif n%2==0:
....:
print par
....:
return pow(x*x,n/2)
....:
elif n%1==0:
....:
print impar
....:
return pow(x*x,n/2)*x
....:
Figura 15. Cdigo recursivo para calcular la potencia de un nmero en Python.
Para analizar este algoritmo vas a determinar el tiempo mximo de cmputo. Para lograr esto
es fcil ver que el peor de los casos es cuando n es impar, ya que se llevan a cabo tres
multiplicaciones aparte de la reduccin del argumento. Lo que significa que
( )
. /
Donde es el tiempo que le lleve a la computadora realizar las operaciones bsicas. La

expresin anterior no est describiendo el hecho de que el tiempo mximo de cmputo va a
resultar en el tiempo que tarde en computarse la misma funcin, pero con una entrada dividida
a la mitad ms el tiempo que se tarda en completar la operacin sobre tres nmeros. Ese fue el
caso para una iteracin; al repetir el proceso varias veces obtienes lo siguiente:
41
Computacin II
( )
. /
( )
. /
( )
. /
( )
( )
. /
. /
.
(
/
.
Es decir, en cada momento lo peor que tienes que calcular es la mitad del argumento ms una
constante por algunas operaciones elementales involucradas en ese paso de cmputo. En la
( )
funcin original se sabe que si
, entonces
. Esto, en trminos de tiempo de
cmputo, significa
( )
Como se desconoce la constante , puedes usar este hecho para conocerla. Para poder
obtener
. /
requieres que
, entonces
( )
Por lo tanto, la expresin original se convierte en

( )
( )
Es decir, la complejidad del algoritmo es logartmica y se puede afirmar que su orden es como
sigue
( )
( ( ))
No es difcil comprender este hecho, ya que en cada paso del que elegiste como de mayor
consumo de tiempo computacional, el tamao del argumento se reduce a la mitad. En la
siguiente seccin revisars otro ejemplo en el que se repite este hecho.
En general, el anlisis de algoritmos recursivos no es sencillo, y de los ejemplos que has visto
hasta el momento es fcil advertir la importancia que tiene el anlisis combinatorio en estos
temas, particularmente el uso de funciones generadoras. Para analizar algoritmos recursivos
usualmente se hace uso del llamado teorema maestro. Del que puedes ver una versin
simplificada a continuacin:
Teorema Maestro
Sean
y
tal que
relacin recurrente de la forma
( )
(5)
. Tambin sean
2
* +. Si tenemos la
( )
42
Computacin II
Entonces, para potencia de se cumple alguna de estas proposiciones
( )
a) Si
( )
(
)
(
)
b) Si
c) Si
, ( )
(
)
Este teorema resulta muy prctico cuando se analizan algoritmos recursivos. Cabe aclarar que
la definicin de ( ( )) significa que la complejidad del algoritmo comparado es exactamente
( ). La demostracin de este teorema no la revisars en este contenido, ya que se requieren
ms herramientas y experiencia analizando algoritmos; su demostracin es usualmente parte
de un curso de anlisis de algoritmos.
Un problema muy particular de los algoritmos recursivos es que, aunque pueden ser muy
eficientes y elegantes, tienen que usar una estructura de los sistemas operativos denominada
pila de llamadas. En esta estructura el sistema va almacenando la ltima funcin a la que debe
contestarle; entonces, para argumentos no muy grandes de una funcin recursiva, esta
estructura se agota, as que al programar algoritmos recursivos hay que ser muy cuidadosos
con la cantidad de llamadas que en promedio vas a hacer con ella.
1.3.3. Diseo de algoritmos

Como podrs ver, el anlisis de algoritmos no es una tarea lineal, pero tampoco lo es su diseo.
Conjuntando los elementos que acabas de ver, podrs incorporarlos en una serie de consejos
que puedes seguir para disear algoritmos eficientemente, tomando en cuenta siempre el
crecimiento del tiempo mximo de cmputo.
1. Planificacin: Haz un esquema del inicio de tu programa y los estados por los que debe
transitar. Una buena opcin es seguir la notacin del diseo de autmatas.
2. Encapsulamiento: Procura crear TDA en los que encapsules todas las funciones que
vayas a usar con ellos, pues hacen un programa ms fcil de usar y de depurar.
3. Acoplamiento: Evita la interdependencia entre mdulos. Esto se logra un poco al
implementar TDA, pero de todas maneras es fcil caer en el hbito de hacer llamadas
directas entre mdulos que deberan ser independientes.
4. Reusa: Usa el cdigo que ya exista, as como las bibliotecas de funciones ya
programadas. No es necesario reinventar el hilo negro cuando tantas funciones ya estn
programadas.
5. Itera: Procura ocupar iteraciones sobre recursividad, los algoritmos de optimizacin de
los compiladores estn muy bien diseados para las iteraciones, mas no as para el for.
43
Computacin II
Eliminacin de la recursin de cola
Una forma para convertir un algoritmo recursivo y convertirlo en iterativo es lo que se hace en la
eliminacin de la recursin de cola. Cuando se tiene un procedimiento ( ) con una llamada a
s mismo, se puede eliminar ese llamado pasando otra variable que sirva de contador y el
argumento modificado.
Considera el siguiente cdigo de Fibonacci en Python
In [1]: def fib(n):
...:
if n==0:
...:
return 1
...:
elif n==1:
...:
return 1
...:
else:
...:
return fib(n-1)+fib(n-2)
...:
Figura 16. Cdigo de Fibonacci(n) recursivo estndar.
Se puede eliminar la llamada a fib dentro del mismo cdigo, como puedes ver en el siguiente
ejemplo de Fibonacci iterativo.
In [6]: def fib2(n,v1=1,v2=1):
...:
L = [v1,v2]
...:
if n>=0 and n<2:
...:
return L[n]
...:
elif n>=2:
...:
for i in range(n-2): L.append(L[-1]+L[-2])
...:
return L
...:
Figura 17. Cdigo de Fibonacci(n) iterativo.
Se pueden evitar las llamadas recursivas incorporando una variable que guarde los resultados
de llamadas internas que seran regresadas por las llamadas de fib(n). En este caso se llama L,
y como puedes ver, vas guardando ah los subsecuentes resultados que de otra forma se
calcularan recursivamente. Esto permite calcular valores mucho ms grandes de Fibonacci que
de otra forma se acabaran la pila de llamadas a funciones de Python (por ejemplo, intenta
calcular fib(40) y fib2(40)).
Divide y vencers
Otra tcnica muy comn para resolver problemas es la de divide y vencers, en la que
dividimos el problema a la mano en subproblemas ms bsicos. Por ejemplo, multiplicar dos
enteros muy grandes, realmente grandes en realidad.
44
Computacin II
Si P y Q son enteros grandes de longitud
bits, se puede convertirlos en
La multiplicacin queda como

(
Con lo que se hacen tres sumas de
bits mximo y dos corrimientos.
Programacin dinmica
Este mtodo es bastante popular. Dividir un problema en subproblemas ms sencillos no
siempre es posible, pero, en cambio, lo que sucede es que se tienen casos distintos, para los
cuales tendrs que resolver alguno de estos casos repetidamente. Entonces, lo que conviene
es crear una tabla con las soluciones para dicho problema para simplemente buscar su solucin
en el momento requerido y despus usarla. Esto funciona bien cuando dichos casos son parte
interna de algn otro caso; entonces, recuperar su informacin es ms sencillo en vez de crear
un crecimiento exponencial de llamadas a diferentes algoritmos. Para hacer una
implementacin usando programacin dinmica, usualmente se tienen que ir guardando los
resultados previos en una tabla.
Backtracking
Es una estrategia de programacin para hacer bsquedas exhaustivas de todas las soluciones
posibles a un problema, el cual est compuesto por varios pasos intermedios. Consiste en
probar una solucin, y si no se viola la funcin a optimizar, entonces se agrega otro elemento a
probar.
Un ejemplo clsico de esto es el problema de las nueve reinas. Este problema consiste en
colocar nueve reinas en un tablero de ajedrez, considerando su capacidad de moverse dentro
de l, de tal forma que no se ataquen. La estrategia es la siguiente:
1. Colocar una en el primer escaque
2. Si no se viola la funcin a optimizar
3. Colocar la siguiente en un escaque no visto por la reina anterior
4. Si no hay forma de poner la reina siguiente en otro escaque
5. Quitar la reina anterior y ponerla en el escaque siguiente al que fue ubicada
6. Regresar al paso 2.
45
Computacin II
1.3.4. Complejidad en ordenamientos y bsquedas
Dos de las principales tareas que llevan a cabo cualquier algoritmo en cualquier programa en
cualquier computadora son
Ordenar
Buscar
Puedes apreciar la importancia de contrastar estos dos mtodos tomando en cuenta que la
recuperacin de un elemento de un arreglo tiene complejidad ( ). De hecho, parece que
intuitivamente son los algoritmos que van a permitir llevar a cabo buena parte del cmputo que
hagas.
Bsqueda binaria
Una de las bsquedas ms populares es la bsqueda binaria. Esta se hace en alguna
estructura Q en la que, si tomas un elemento c, sabes que Q[a]<Q[c] sii a<c y Q[c]<Q[b] sii c<b.
Es decir, tienes una estructura perfectamente ordenada bajo algn orden predeterminado
creciente montonamente.
El mejor ejemplo de esto es el directorio telefnico. Es inmenso, pero est ordenado, y si
buscas algn nombre, por ejemplo, Salazar, si abres el directorio aleatoriamente y encuentras
que la primera palabra es Rodrguez, sabes bien de qu lado del directorio se encuentra el
apellido Salazar.
Una implementacin de bsqueda binaria para una lista en Python la puedes ver a continuacin
def binaria(L, k, imn=0, imx=None):
Hace la busqueda binaria de k en L, es decir, existe idx tal
que L[idx]=k
L debe ser un arreglo ordenado
k la llave a buscar
imn es el indice inferior de L sobre el cual se busca
imx es el indice superior de L sobre el cual se busca
regesa idx tal que L[idx]=k o -1 si no se encuentra
if imx is None:
print Arreglo completo
imx =len(L)-1
while imn < imx:
print Llamada
imd = (imn+imx)/2
mval = L[imd]
if k < mval:
46
Computacin II
print Izquierda
return binaria(L, k, imn, imd)
elif mval < k:
print Derecha
return binaria(L, k, imd+1, imx)
elif k == mval:
print Resultado
return imd
else:
print Fallo
>>> L = [1,1]
>>> for i in range(24): L.append(L[-1]+L[-2])
>>> k = L[23]
>>> x = b.binaria(L, k)
Arreglo completo
Llamada
Derecha
Llamada
Derecha
Llamada
Derecha
Llamada
Izquierda
Llamada
Resultado
>>> x
23
Figura 18. Algoritmo de bsqueda binaria en Python usado en la lista de nmero de Fibonacci con 24
elementos.
). El anlisis no es realmente
La complejidad de este algoritmo, como puedes intuir, es (
complicado, ya que se parece mucho al del ejemplo de elevar un nmero a alguna potencia. El
tiempo total de cmputo de este algoritmo es el que le lleve examinar la mitad restante de su
entrada ms una constante , donde pones todas las asignaciones y operaciones que sean de
complejidad ( ), excepto por la clusula de escape, que es la operacin en la que recuperas
el elemento buscado del arreglo L.
( )
( )
( )
Entonces, para las diferentes iteraciones obtienes la siguiente progresin, considerando el peor
de los casos
( )
( )
47
Computacin II
( )
, ( )
( )
( )
( )
( )
De la misma forma, como la ltima iteracin es ( )
( )
, implica que
Entonces, como era de esperarse

( )
Ordenamientos
Otra de las tareas ms socorridas en computacin son los ordenamientos. La tarea de ordenar
consiste en tomar un arreglo A donde a cada ndice se le denomina llave, y el contenido del
arreglo es el valor sobre el cual se impondr el orden.
Uno de los ejemplos ms sencillos de ordenamiento es Bubble Sort. La idea es muy sencilla.
nicamente se tiene que recorrer el arreglo en reversa, desde atrs hacia adelante, para ir
intercambiando los elementos que sean mayores y que, por lo tanto, correspondan al final del
arreglo; y esto lo debes hacer de manera progresiva por todos los elementos dejando fijos los
ya ordenados.
def bubblesort(A):
n =len(A)
for i in range(n-1):
for j in range(n-1, i, -1):
if A[j-1] > A[j]:
temp=A[j-1]
A[j-1]=A[j]
A[j] = temp
Figura 19. Cdigo de Bubble Sort en Python.
El peor de los casos es que este algoritmo entre todas las veces a la seccin de intercambio, lo
que est determinado por el for interno al que se entra tantas veces como lo indique el for
externo.
(
Esto es un orden de complejidad cuadrtica. lo que significa (

algoritmo de ordenamiento; existen varios otros.
). Pero no es el nico
48
Computacin II
Para saber ms
Maas, Jos. Anlisis de algoritmos: Complejidad. En lnea
http://www.lab.dit.upm.es/~lprg/material/apuntes/o/index.html#s4
Zindros, Dyonisis. A gente introduction to Algorithm Complexity Analysis. En lnea
http://discrete.gr/complexity/.
Actividad 3. Anlisis de complejidad

En esta actividad realizars un anlisis de complejidad sobre un algoritmo.
Instrucciones
1. Descarga el archivo Act3. Anlisis de complejidad.
2. Lee el contenido atendiendo a las instrucciones y sugerencias que se hacen.
4. Guarda tu documento con la siguiente nomenclatura: MCOM2_U1_A3_XXYZ.
5. Espera la retroalimentacin de tu Facilitador(a).
1.4.
Estructuras de datos
Otro elemento que va a asistir a crear y disear un algoritmo ms eficiente es la utilizacin de

estructuras de datos especficas. Las estructuras de datos son arreglos especficos de tus
datos.
Un par de estructuras de datos que ya conoces son los vectores y las matrices en el mbito de
las matemticas, y seguramente ya has usado arreglos en computacin. Pero hay diferentes
estructuras para diferentes problemas. En esta unidad repasars las estructuras de datos ms
conocidas, que van desde las listas hasta los rboles.
1.4.1. Arreglos y listas

Dentro de las estructuras ms bsicas que vas a encontrar es la de una lista ligada. La idea
principal de este par de estructuras es la de dar una secuencia lgica a un grupo de registros,
49
Computacin II
aspecto que puede obviarse con los arreglos donde la secuencia viene dada por los ndices del
arreglo.
En Python, el uso de listas es muy comn y tiene todos los mtodos que podras implementar
no tan naturalmente en otros lenguajes, pero lo hars con el fin de mostrar cmo funciona una
lista ligada. Este puede ser un tema un tanto engorroso pero sencillo al final.
Figura 20. Diagrama de una lista ligada. a) Lista de registros ligada apuntando a un registro especfico b)
borrado de un registro c) insercin de un registro
Lo que hars en este caso ser disear un TDA de tipo lista para que controle todas las
operaciones referentes a ella; esto lo convertirs en un par de clases funcionales y operables en
Python.
En una lista ligada, cada elemento tiene registrado qu elemento le sigue. Entonces, para
problemas donde necesitas obviar la secuencia de los elementos, viene muy bien, por ejemplo,
los das de la semana. En el siguiente cdigo puedes ver la implementacin de la misma junto
con la clase registro que es donde guardars los datos.
class registro(object):
def __init__(self,t):
50
Computacin II
self.c = t
self.s = None
def siguiente(self,t):
self.s = t
def contenido(self):
return self.c
def sigue(self):
return self.s
class lista(object):
def __init__(self):
self.h = None
#cabeza
self.a = self.h #celda actual
self.pos = 0
self.conteo = 0
def cuantos(self):
return self.conteo
def posicion(self):
return self.pos
def ubica(self,p):
if p > 0 and p <= self.pos:
self.a = self.h
self.pos = 1
while self.pos < p:
self.a = self.a.s
self.pos += 1
def contenido(self):
return self.a.contenido()
def siguiente(self):
if self.pos < self.conteo:
self.a = self.a.sigue()
self.pos += 1
def inserta(self,r):
if self.h is None:
self.h = r
self.a = self.h
else:
self.a.siguiente
self.a = self.a.sigue()
self.pos += 1
self.conteo += 1
def borra(self,p):
if p==1:
51
Computacin II
self.h = self.h.sigue()
self.conteo -= 1
elif p > 1 and p < self.conteo:
self.a = self.h
self.pos = 1
while self.pos < p-1:
self.siguiente()
self.a.siguiente(self.a.siguiente().siguiente())
self.conteo -= 1
def imprime(self):
self.a = self.h
i = 1
while i < self.conteo:
print self.contenido()
self.siguiente()
i += 1
Figura 21. Cdigo para implementar una lista simplementa ligada en Python junto con una clase de registro
ocupada para las diferentes celdas de la lista.
Hay dos tipos de mtodos en esta implementacin. Aquellos de complejidad constante como
son inserta (o los que reportan un valor) y los de complejidad ( ), entre stos estn: ubica,
imprime, borra. Y es que todos estos tienen que recorrer toda la lista para poder llevar a cabo
su operacin.
Aqu puedes ver el uso de los registros.
In [49]: t = b.registro(5)
In [50]: s = b.registro(3)
In [51]: r = b.registro(1)
In [52]: u = b.registro(7)
Figura 22. Creacin de los registros
Y aqu la implementacin de la lista

In [53]: L = b.lista()
In [54]: L.conteo
Out[54]: 0
52
Computacin II
In [55]: L.inserta
In [56]: L.inserta(s)
In [57]: L.inserta(t)
In [58]: L.inserta(u)
In [59]: L.h.contenido()
Out[59]: 1
In [60]: L.h.sigue().contenido()
Out[60]: 3
In [61]: L.h.sigue().sigue().contenido()
Out[61]: 5
In [62]: L.h.sigue().sigue().sigue().contenido()
Out[62]: 7
Figura 23. Creacin y uso de la lista
Colas
Las listas ligadas tienen un uso aplicado para muchos procesos, por ejemplo, un tipo de listas
ligadas es una cola. Las colas son un tipo de lista ligada denominada FIFO, que significa First In
First Out, que es bsicamente el funcionamiento que todos identifican con las filas. El primero
que se forma es el primero en salir.
Esto cmo se refleja en la implementacin? Cmo asignas un orden a tu lista? Hasta el
momento casi todo est implementado, ya que cuando se agrega un elemento a la lista es en el
orden en el que van llegando a ella; lo nico que falta es un mtodo que los extraiga de acuerdo
a este principio.
Una propuesta es tener un mtodo pop que elimine el primer elemento de la lista.
def pop(self):
if self.conteo > 1:
self.borra(1)
Figura 24. Metodo pop para agregarlo a la implementacin de lista ligada.
53
Computacin II
1.4.2. Pilas
Las pilas o stacks son otro tipo de estructura que puede ser implementado con una lista o con
un arreglo. A diferencia de las colas, estas estructuras son del tipo FILO, First In Last Out. No
es una fila particularmente intuitiva, al menos no en el andar cotidiano, pero s lo es en otros
aspectos.
Considera el siguiente conjunto de parntesis
((([(([])[[ ]])])[[]]))
El conjunto de parntesis anterior est bien apareado. La estructura de datos que puede ayudar
a llevar bien la cuenta de este fenmeno es precisamente una pila; esto se debe a que cada
vez que cierras un parntesis, su contraparte que lo abre debe ser el inmediato anterior, es
decir, el ltimo elemento que entr en la pila es el primero en salir (complementariamente el
primero en entrar debe ser el ltimo en salir).
A continuacin puedes ver la implementacin de un stack, usando una lista como estructura
interna para guardar los elementos del stack.
class stack:
def __init__(self):
self.elementos = []
def es_vacio(self):
return self.elementos == []
def push(self, elem):
self.elementos.append(elem)
def pop(self):
return self.elementos.pop()
def peek(self):
return self.items[len(self.items)-1]
def tamano(self):
return len(self.items)
Figura 25. Implementacin de un stack en Python
54
Computacin II
Los nombres de las funciones son notacin estndar en el uso de pilas y colas. Un programa
que podras implementar con una pila es una calculadora con notacin sufija. Por ejemplo, la
instruccin
46+
Usando notacin sufija, la expresin anterior significa que debes sumar el 4 y 6 obteniendo 10.
La suma se puede llevar a cabo en el momento en el que detectes el smbolo +; en ese
momento sacas los dos elementos superiores del stack y los sumas.
Figura 26. Calculadora con notacin sufija que implementa una calculadora, la operacin usualmente
depende del programador, puede suceder apenas recibamos un smbolo de operacin o hasta el final que se
llene la pila. a) Esquema de una pila b) Insercin c) Ejemplo de pop.
1.4.3. Heaps
El trmino heap significa montculo en ingls y refleja en buena medida lo que deseas modelar
con esta estructura, un montculo donde lo ms importante que requieras est hasta el tope del
montculo. Incluso existe una expresin en ingls con este significado que va: top of the heap.
Los heaps son otro tipo de listas, usualmente conocidos como listas con prioridad. Por ejemplo,
una lista de urgencias en un hospital, aunque todos los pacientes llegan en un orden
cronolgico bien determinado, no todos tienen la misma prisa por ser atendidos; hay unos casos
que son mucho ms urgentes.
55
Computacin II
Esto lo puedes denotar en un arreglo. Considera el siguiente ejemplo:
5 1 4 6 3 8 2 1
Si el tamao del nmero en cada entrada del arreglo anterior determinara el grado de
importancia de esa entrada, entonces el 8 sera el elemento ms importante, mismo que puedes
encontrar con tiempo ( ) al escanear el arreglo de nmeros. O bien, puedes crear una
estructura de datos que siempre los mantenga ordenados segn su prioridad.
1.4.4. rboles
Los rboles son de las estructuras ms cmodas y eficientes para representar datos, ya que
implcitamente representan una jerarqua en ellos, y ya no son lineales como todas las
estructuras que has visto hasta ahora.
De hecho, ya examinaste previamente una de las ventajas de tener la informacin estructurada
en un rbol cuando revisaste el algoritmo de la bsqueda binaria. En este algoritmo descartabas
la mitad del espacio de bsqueda que no te interesaba, y de esta manera la complejidad del
).
algoritmo es de (
Como bien sabes, un rbol es una grfica sin ciclos que consta de un conjunto de nodos y de
aristas.
(
)
Por ejemplo, considera el siguiente rbol:
Figura 27. Ejemplo de un rbol
56
Computacin II
En este rbol el nodo raz A tiene iluminado de verde toda su rama izquierda, y de naranja toda
la derecha. Un problema que aparece inmediatamente es el de cmo vas a representar una
estructura de dimensin 2 en Python. Una opcin es hacer uso de las ventajas del manejo de
listas y hacer una lista de listas. Por ejemplo, el rbol de la figura puede ser representado as:
In [4]: Arbol = ['A',
...:
['B', ['F', [], [] ], []],
...:
['C', ['G', [], [] ], ['H',[],[]]]
...: ]
En esta seccin revisars la implementacin de un rbol binario, aunque hay varios tipos de
rboles.
def ArbolBinario(r):
return [r, [], []]
def ramaIzquierda(raiz,rama):
t = root.pop(1)
if len(t) > 1:
raiz.insert(1,[ramaI,t,[]])
else:
raiz.insert(1,[ramaI, [], []])
return raiz
def ramaDerecha(raiz,rama):
t = raiz.pop(2)
if len(t) > 1:
raiz.insert(2,[rama,[],t])
else:
raiz.insert(2,[rama,[],[]])
return raiz
def pon_raiz(arbol):
return arbol[0]
Figura 28. Implementacin de rbol binario en Python.
Como puedes ver, la bsqueda en este rbol reduce el tiempo de cmputo en potencias de dos,
despreciando todo la rama que no es de tu inters.
57
Computacin II
1.4.5. Funciones y tablas de hash
Hasta ahora las estructuras que has visto han podido reducir, en el mejor de los casos, el
), en buena medida por el orden que guarda el dominio
tiempo de cmputo y bsqueda a (
que toman las llaves de tus elementos.
Si las llaves fueran las entradas del arreglo de dnde quieres recuperar la informacin,
entonces todo estara resuelto, ya que con simplemente incorporar esa llave al hipottico
arreglo que est guardando la informacin, obtendras lo que buscas en orden ( ), que es la
gran gracia de los arreglos: su rapidez para recuperar informacin.
Es por esto que servira tener un arreglo de este tipo, donde pusieras la informacin para ser
recuperada. El problema con este planteamiento es que, si haces un arreglo, por ejemplo, para
una agenda telefnica con nmeros de diez dgitos, donde el nmero sea la llave para
recuperar la informacin del dueo de ese telfono, entonces necesitaras alrededor de
entradas para poder guardar esa hipottica agenda telefnica, y lo peor es que gran parte
de ella estar vaca. Pero qu tal si te aferras un poco a la idea de un arreglo para tener
complejidad constante para recuperar la informacin, pero con menos llaves. Cmo puedes
hacer esto posible?
Una opcin, tal vez no muy buena, pero muy ilustrativa, es quedarte con los ltimos dos dgitos
de cada nmero y usar eso como llave del arreglo, por ejemplo:
y as para cada uno de los telfonos de tu agenda. Entonces, a travs de un mapeo ests
reduciendo el espacio de bsqueda de todos los posibles nmeros telefnicos para quedarte
nicamente con un elemento que funciona como la llave de un arreglo, y que los identifica con
complejidad ( ).
El problema radica en que se puede dar este caso
- en el que otro elemento sea mapeado a la misma entrada del arreglo y que ya est ocupado.
A este fenmeno se le denomina colisin, en tanto que al arreglo que ests construyendo se le
denomina tabla de hash, y a la funcin que se encarga de mapear el objeto de tu inters en
una entrada de la tabla se le llama funcin hash.
58
Computacin II
Funcin hash
Formalmente una funcin de hash ( ) se define considerando que va a recibir un argumento
de entrada y producir un nmero de clase en el rango ,
-, donde es el nmero total de
clases. Esto es, requieres disear una funcin que mapee todo el dominio en un conjunto de
cardinalidad mucho menor; para esto requieres que el mapeo sea, por lo menos, inyectivo, y
aunque es imposible, tambin sera bueno que fuera suprayectivo, o por lo menos debes
procurar que el nmero de colisiones sea mnimo.
Ejemplo: El algoritmo MD5 produce un entero nico dado una cierta entrada de bits
siguiente algoritmo.
con el
1) Se extiende el mensaje hasta hacerlo congruente 448 mdulo 512 concatenndole 1 y

0
2) Se concatena un nmero de 64 bits que representa la longitud del mensaje
3) Se usa un bfer de cuatro palabras (arreglos de ocho bits) para representar el mensaje
4) Se calcula el contenido de cada bfer con las funciones
(
(
(
(
)
)
)
)
(
(
) (
) (
(
)
)
)
Entonces, con estos cuatro bytes concatenados se obtiene un identificador nico de cada
entrada.
Un mal ejemplo podra ser el siguiente. Para identificar una cadena de nmeros, por ejemplo,
los nmeros telefnicos, podras sumar su valor entero, pero esto producira demasiadas
colisiones, ya que con mucha facilidad podras obtener el mismo entero a partir de una simple
suma.
Colisiones
Existen tres formas de lidiar con las colisiones en la tabla.
- Direccionamiento abierto: Se busca un espacio libre dentro de la tabla para colocar la
nueva entrada.
- Encadenamiento: La entrada de la tabla contiene una lista y cada nuevo elemento que
llega se coloca como elemento de la misma. Para no perder eficiencia no deben ser
demasiados elementos en cada lista.
- Encadenamiento ligado (coalesced chaining): Este es un hbrido de los dos primeros
mtodos en el que asignas el objeto a guardar en otra llave dentro de la tabla, pero
59
Computacin II
guardando la direccin en la entrada original y estableciendo una liga a la nueva
entrada.
Para saber ms
Know thy complexities. En lnea http://bigocheatsheet.com/
Data structures visualizations. En lnea http://www.cs.usfca.edu/~galles/visualization/
Morales Luna, G. Computabilidad y Complejidad. En lnea
http://cs.cinvestav.mx/~gmorales/complex/complex.html
Actividad 4. Estructuras de datos

A travs de esta actividad, utilizars estructuras de datos para resolver problemas genricos,
dependiendo el uso que se le asigne. Para ello:
1. Descarga el archivo Act4. Estructuras de datos
2. Lee el contenido atendiendo a las instrucciones y sugerencias que se hacen.
4. Guarda tu documento con la siguiente nomenclatura: MCOM2_U1_A4_XXYZ.
5. Enva el documento a tu Facilitador(a) y espera su retroalimentacin.
Autoevaluacin
Para reforzar los conocimientos relacionados con los temas que se abordaron en esta unidad
del curso, es necesario que resuelvas la autoevaluacin.
Ingresa al Aula virtual para realizar tu actividad.
Evidencia de aprendizaje. Diseo de algoritmo

A travs de esta actividad podrs crear un TDA y su respectiva clase en Phyton, y por medio
de ella, responder a las interrogantes que se presentan. Para ello:
60
Computacin II
1. Descarga el archivo EA. Diseo de algoritmo.
2. Resuelve inciso que se presenta en el documento descargable.
3. Escribe tus preguntas y respuestas en un documento, y si existiese alguna funcin,
gurdala en un archivo .py
4. Guarda tu documento y archivo con la siguiente nomenclatura: MCOM2_U1_EA_XXYZ.
5. Enva tu archivo al Portafolio de evidencias y espera la retroalimentacin de tu
Facilitador(a). Una vez que la tengas, atiende sus comentarios y reenva la nueva versin
de tu evidencia.
Nota: No olvides consultar la Escala de evaluacin para conocer los criterios con que ser
evaluado tu trabajo.
Autorreflexiones
Como parte de cada unidad, es importante que ingreses al foro Preguntas de autorreflexin y
leas los cuestionamientos que formul tu Facilitador(a), ya que a partir de ellos debes elaborar
tu Autorreflexin y enviarla mediante la herramienta Autorreflexiones. No olvides que tambin
se toman en cuenta para la calificacin final.
Cierre de la Unidad
En toda esta unidad acabas de ver un panorama un tanto extenso, pero bsico, de la operacin
de una computadora y de la informacin que es capaz de manipular, as de cmo hacerlo
eficientemente. Las estructuras de datos presentadas aqu no son ni por asomo las ms
sofisticadas o las nicas; de hecho, cada una de estas estructuras se puede sofisticar bastante
ms. Lo mismo pasa con los fundamentos de computacin terica presentados.
Lo que viste en esta unidad es una base para el anlisis y entendimiento de la manipulacin de
datos en la computadora de manera eficiente.
Para saber ms
Puedes consultar las siguientes ligas para extender cada tema
Python Programming/Sequences. Wikibooks. En lnea
http://en.wikibooks.org/wiki/Python_Programming/Sequences
61
Computacin II
Data Structures. The Python Tutorial. En lnea
http://docs.python.org/2/tutorial/datastructures.html
Built-in Types. The Python Tutorial. En lnea http://docs.python.org/2/library/stdtypes.html
Primitive Data Types. The Java Tutorials. En lnea
http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
Data Structures: Abstract Data Types. En lnea http://www.youtube.com/watch?v=HcxqzYsiJ3k
Crescenzi, Pierluigi. A compendium of NP optimization problems En lnea
http://www.csc.kth.se/~viggo/problemlist/
Bell R. A begginers guide to Big O Notation. En lnea http://rob-bell.net/2009/06/a-beginnersguide-to-big-o-notation/
Maas, Jos. Anlisis de algoritmos: Complejidad. En lnea
http://www.lab.dit.upm.es/~lprg/material/apuntes/o/index.html#s4
Zindros, Dyonisis. A gentle introduction to Algorithm Complexity Analysis. En lnea
http://discrete.gr/complexity/.
Know thy complexities. En lnea http://bigocheatsheet.com/
Data structures visualizations. En lnea http://www.cs.usfca.edu/~galles/visualization/
Morales Luna, G. Computabilidad y Complejidad. En lnea
http://cs.cinvestav.mx/~gmorales/complex/complex.html
Referencias Bibliogrficas
Leiserson, C. E., Rivest, R. L., & Stein, C. (2001). Introduction to algorithms. T. H. Cormen (Ed.).
The MIT press.
Aho, A. V., Hopcroft, J. E., & Ullman, J. D. (1988). Estructura de datos y algoritmos. Addison
Wesley Iberoamericana, SA Washington. Cp, 6, 200-251.
62

U1. Estructuras de Datos y Análisis de Algoritmos

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

U1. Estructuras de Datos y Análisis de Algoritmos

Hochgeladen von

Copyright:

Verfügbare Formate

Computacin II

Unidad 1. Estructuras de datos y anlisis de algoritmos

Universidad Abierta y a Distancia de Mxico

Unidad 1 Estructuras de datos y anlisis de algoritmos

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Informacin y datos ............................................................................................ 7

El lenguaje de programacin Python .................................................................. 8

Actividad 1. Nmeros aleatorios con Phyton .................................................................... 21

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Identificars los diferentes tipos de datos existentes.

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Figura 1. Esquema de la mquina de Turing (Wikipedia)

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Algoritmo 1. Primer intento de algoritmo para el TSP

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Crear una lista vaca L

1.1.1. Informacin y datos

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

1.1.2. El lenguaje de programacin Python

Figura 3. Pgina de Python

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Figura 4. Versiones de Python, de las cuales usaremos las versiones 2.7.x

Pero si lo deseas, y de hecho, como recomendacin, puedes usar la versin de Enthought

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

IndentationError: expected an indented

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

L = [1, 2, 3, 6, 8, a, algo, 8, 3.2]

Si lo que quieres es unir dos listas, puedes usar el operador +

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Tabla 1. Operaciones aritmticas bsicas en Python.

Tabla 2. Jerarqua de operaciones

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Tabla 3. Operadores lgicos en Python.

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Actividad 1. Nmeros aleatorios con Phyton

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

1.2. Tipos de datos

1.2.1. Tipos primitivos

nicamente requieren 1 bit para expresar todos los valores. No estn

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

smbolos distintos, segn la especificacin Unicode.

1.2.2. Tipos simples y compuestos

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Figura 7. Struct que implementa un nmero complejo.

Figura 8. Ejemplo de un tipo enum.

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

1.2.3. Tipos abstractos

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

1.3. Anlisis de algoritmos

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas

Actividad 2. Reflexin sobre algoritmos

1.3.1. Notacin asinttica