domingo, 13 de julio de 2014

Trabajos finales


Llegamos al final de la cursada. Los trabajos finales de los alumnos son todos muy buenos, demuestran el trabajo realizado aplicando conceptos estudiados en la materia.

 

Árboles Binarios Aritméticos

 

Damián Ledesma y Diego Tapia construyeron un analizador sintáctico de expresiones aritméticas de números y operaciones suma, resta, multiplicación y división. El análisis se realiza construyendo un árbol binario y finalmente resuelve la expresión podando el árbol a medida que lo recorre. De esta manera demuestran sin tener conocimientos de teoría de compiladores, la construcción, recorrido y modificación dinámicos de árboles con estructura semántica, reutilizando código desarrollado en los trabajos prácticos. Este es el informe.

 

Código de Huffman

 

Bruno Vitucci trabajó con árboles de Huffman, vistos como un caso de aplicación de árboles binarios. En una primera etapa desarrolló un traductor de texto a código de unos y ceros y otro traductor en sentido inverso, ambos para un código de Huffman fijo de ejemplo. En una segunda etapa logró la construcción del árbol a partir de una tabla de frecuencias de ejemplo. De esta manera trabajó en la construcción y recorrido dinámicos de árboles binarios, en el uso de diccionarios y la lectura y escritura de archivos. Este es el informe.

 

Algoritmo de Manejo de Grafos

 

Maive Acevedo trabajó con algoritmos sobre grafos. Construyó un grafo mediante listas de adyacencias cuyos nodos son las provincias argentinas y cuyas aristas representan adyacencia entre ellas. Implementó el algoritmo de Dijkstra para determinar cuántas provincias es necesario cruzar para llegar de una inicial a otra final. Finalmente añadió la medición de un indicador del tiempo de ejecución del algoritmo, que se informa al final de cada ejecución. De esta manera logró implementar un grafo, trabajar sobre la estructura, implementar el algoritmo de Dijkstra, elaborar un indicador del tiempo de ejecución e implementarlo. Este es el informe.

martes, 24 de junio de 2014

Agenda últimas fechas


Quedan dos fechas para el cierre de la cursada. Nos organizaremos de la siguiente manera:


29/6: Última fecha para la entrega del informe del trabajo final (ver más abajo detalles del formato y contenido).

30/6: Clase obligatoria. Las actividades serán las siguientes:

  • Devolución del segundo parcial (notas, errores comunes, etc.)
  • Entrega y defensa de trabajo final: entregan lo que tengan hecho. Implica una reunión con cada grupo para que me muestren el trabajo y problemas que tuvieron.
  • Puesta en conocimiento de los trabajos al curso. No es necesario que se preparen para esta actividad.
  • Últimas consultas sobre trabajos prácticos.

6/7: Última fecha para entrega de trabajos prácticos.

7/7: Recuperatorio del segundo parcial y en casos puntuales previamente acordados recuperatorio del primer parcial.

Informe del trabajo final

El informe del trabajo final forma el 25% de la nota del mismo.

Tiene una longitud de entre 1 y 3 páginas y no debe incluir el código, salvo fragmentos puntuales para hacer algún comentario. Entregar preferentemente en un formato libre (por ejemplo PDF). Esos son los únicos requisitos de formato, aunque sugiero incluir las siguientes secciones:

  • Alumno/s
  • Título del trabajo
  • Resultados logrados y ejemplos de uso
  • Problemas encontrados
  • Estructura del código
Para los trabajos de extensión de un TP el informe deberá estar orientado a lectores que no conozcan los enunciados, es decir, explicando el objetivo de cada ejercicio, cada clase y cada método y si se aplica, ejemplos de uso.

Salvo que me soliciten lo contrario publicaré todos o los mejores trabajos en el blog.

miércoles, 18 de junio de 2014

Segundo parcial

El examen será a partir de las 15:30 (puntual) y antes de esa hora estaré respondiendo consultas del contenido del parcial y probablemente mostraré más ejemplos prácticos. No veremos contenidos nuevos. Después del examen (de 17:30 a 18) podrán hacer consultas del TF y TPs.

La clase del 30 de junio es obligatoria (se toma asistencia). Luego les comento los detalles.


No habrán ejercicios de programación. Como siempre, no es necesario saber el seudocódigo de los algoritmos "de memoria", pero sí entender qué hacen y cómo, entender la estrategia. La mitad de las preguntas será de ejercicios prácticos y la otra mitad de teoría y de aplicar conceptos teóricos. La cantidad de preguntas será mucho mayor que en el primer parcial pero cada una abarcará menos conceptos y tendrá menos opciones.

Los temas son heaps, dispersión y las dos clases sobre grafos, es decir los temas correspondientes a las presentaciones 9, 10, 11 y 12. Por si necesitan complementar con los libros: los capítulos son los siguientes:
  • Aho: capítulos 6 y 7.
  • Basee:  secciones 4.8, 6.5, 6.6, 7.1 a 7.6 y capítulo 8
No se evaluarán temas teóricos no vistos en clase.

sábado, 14 de junio de 2014

Recuperatorio: modalidad y horario

El lunes próximo haremos el recuperatorio del primer parcial. El horario será a partir de las 15:30 (puntual) y antes de esa hora estaré respondiendo las consultas que tengan.

No habrá clase (contenidos nuevos). No es necesario que vayan quienes no recuperan. Sin embarbo por consultas sobre otros temas pueden presentarse a las 17:25.

Tanto el temario como la proporción de teoría/práctica serán iguales que en el parcial. No habrán ejercicios de programación pero sí de interpretar código, formular ecuaciones de T(n) (iterativo y recursivo) y resolver ecuaciones de recurrencia. La cantidad de preguntas será mucho mayor pero cada una abarcará menos conceptos.

miércoles, 11 de junio de 2014

Material trabajos prácticos

Lo siguiente es un resumen del material que tienen disponible para completar los trabajos prácticos. Si encuentran algo incorrecto o tienen algo para comentar, por favor avisen por mail o dejen un comentario.

Como verán, hemos desarrollado gran parte de los TP en clase. No hay problema en que compartan dicho material.

Algo que ya comenté anteriormente: si van a editar código publicado por mí, tengan presente que acostumbro a usar tabuladores para la indentación, por lo que quizás necesiten hacer el reemplazo correspondiente.


TP1: Sugiero a quienes ya lo entregaron que no continúen completandolo sino que inviertan sus esfuerzos en los otros TP y el TF. Quienes entregaron el TP1 lo tienen aprobado.


TP2: Sugiero aprovechar que todavía es posible entregarlo no totalmente completo. Resumo el material que tienen disponible para completarlo:

Ejercicio 1: El 3 de mayo publiqué una versión corregida de la resolución que hicimos en clase (http://unajct.blogspot.com.ar/2014/05/clase-284-y-recursos-tp2.html).

Ejercicio 2: Sugiero que lo resuelvan solo si tienen todos los otros ejercicios completos.

Ejercicio 3: Lo declaramos opcional a cambio de la opcionalidad del Ejercicio 4.

Ejercicio 4: Lo resolvimos en clase, si no me equivoco el 2 de junio.

Ejercicio 5: Publiqué una "ayudita" con todo el ejercicio casi resuelto (http://unajct.blogspot.com.ar/2014/06/ayudita-tp2.html).

Ejercicio 6: Es bastante sencillo. Intenten por lo menos responder la primera parte de la pregunta.

Ejercicio 7: Creo que resolvimos por lo menos uno en clase.

Ejercicio 8: Los puntos a y c quedan anulados por estar mal planteados. El punto b lo resolvimos en clase el 9 de junio.

Ejercicio 9: Lo mostré resuelto rápidamente el 9 de junio.

Ejercicio 10: Es muy sencillo.


TP3: Resumo el material que tienen disponible para completarlo:

Ejercicio 1: Si no me equivoco, en clase lo resolvimos casi por completo. Si hace falta también pueden basarse en el ejercicio 1 del TP2.

Ejercicio 2: Los puntos a y b los trabajamos en clase. Los puntos c y d son simplemente ejecutar el código del enunciado y pegar el resultado.

Ejercicio 3: Para los puntos a y b tienen el seudocódigo en la teoría. El punto c es sencillo: un bloque iterativo que va buscando el padre de nodo hasta llegar a la raíz, invocando al método que se menciona.

Ejercicio 4: Es opcional.


TP4: Resumo el material que tienen disponible para completarlo:

Ejercicio 1: publiqué la resolución de los puntos a, b y c (http://unajct.blogspot.com.ar/2014/05/tp4-rev2.html). El punto d consiste en hacer cambios muy puntuales sobre minHeap.

Ejercicio 2: Consiste en hacer una ejecución del método construir del punto 1.

Ejercicio 3: El punto a es simplemente ejecutar y explicar las líneas del enunciado. El punto c lo mostré detenidamente resuelto en clase. Quedaría el punto b, que es similar al c.

Ejercicio 4: Los puntos a y b son simplemente ejecutar y copiar la salida. El punto c pide una breve opinión, que no requiere fundamentación.


TP5: Está preaprobado, es decir que no es obligatorio entregarlo. Solo quienes hayan entregado todos los anteriores, pueden realizarlo para mejorar el promedio. El enunciado no está listo, pero sugiero que quien esté interesado me avise y comience con la implementación de una clase grafo y el algoritmo DFS. Comparto el código de la clase auxiliar desarrollada en clase.

Clase 9/6

El 9/6 vimos la segunda clase teórica sobre grafos, que comienza con una revisión de los algoritmos de recorridos.

También avanzamos un poco con lo que será el Trabajo Práctico 5. Recuerden que dicho TP se da por preaprobado. El post siguiente habla más sobre el tema.

jueves, 5 de junio de 2014

Ayudita TP2

Les dejo una ayuda para el punto 5 del TP2, además de los datos de prueba de biblioteca que les dejé la otra vez. Si encuentran errores pueden dejar comentarios o avisarme por mail.


a) Recuerden que nbiblioteca (definido en biblioteca_borrador.py) es un nodo de árbol. En el punto 1a se define la función dato. Usándola obtenemos el dato relacionado al nodo, que es un objeto de tipo elementoBiblioteca. La clase elementoBiblioteca es muy sencilla, se puede consultar directamente su método texto.

b) Se puede usar la siguiente función. ¿Qué parámetro le pasaría?

def contarLibros(nodo):
        if(nodo.dato().tipo()=='L'):
                c = 1
        else:
                c = 0
        p = nodo.hijoMI()
        while(p):
                c = c + contarLibros(p)
                p = nodo.hermanoDerecho(p)
        return c

c) Dado que no contamos con un método de eliminación simple (que elimine todo el subárbol), limítese a mencionar las dos operaciones que debería realizar una función mover(libro, origen, destino).

d) Podemos contar la cantidad total de capítulos con una función muy parecida a la del punto b y luego dividirla por la cantidad de libros.

e) Se puede usar la siguiente función:

def medirTextoYTitulos(nodo, enLibro=False):
        """
        Mide la longitud del texto de los parrafos y los
        titulos. El parametro enLibro debe ser True solo
        si el nodo esta dentro de un libro
        """
        if(nodo.dato().tipo()=='L'):
                enLibro = True
        if enLibro:
                c = len(nodo.dato().texto())
        else:
                c = 0
        p = nodo.hijoMI()
        while(p):
                c = c + medirTextoYTitulos(p, enLibro)
                p = nodo.hermanoDerecho(p)
        return c


y una variante de la siguiente:

def medirLibros(nodo):
        if(nodo.dato().tipo()=='L'):
                print " ", nodo.dato().texto(), medirTextoYTitulos(nodo)
        p = nodo.hijoMI()
        while(p):
                medirLibros(p)
                p = nodo.hermanoDerecho(p)
        return c


f) Intente con lo siguiente.

def buscarLibro(buscarDesde, libro, camino=''):
        nodo = buscarDesde
        if(nodo.dato().tipo()=='L'):
                if nodo.dato().texto() == libro.texto():
                        return camino
                else:
                        return None
        p = nodo.hijoMI()
        while(p):
                c = camino + '.' + buscarDesde.dato().texto()
                c = buscarLibro(p, libro, c)
                if c:
                        return c
                p = nodo.hermanoDerecho(p)
        return None


g) medirTextoYTitulos puede contar la cantidad de texto de un subárbol. Debería hacer una variante para que cuente solo los párrafos.

h) Es casi igual al punto g.

i) Usamos una estrategia similar a los anteriores, solo que no continuamos la recursión una vez encontrada una sección.

def seccionesPrimerNivel(nodo):
        if(nodo.dato().tipo()=='S'):
                return 1
        p = nodo.hijoMI()
        c = 0
        while(p):
                c = c + seccionesPrimerNivel(p)
                p = nodo.hermanoDerecho(p)
        return c

Clase 2/6

El 2 de junio vimos la primera parte de grafos y entre todos implementamos un grafo con realización de matriz de adyacencia, con un método para hacer el recorrido DFS. Les dejo la presentación.

martes, 27 de mayo de 2014

Resultados del primer parcial

Ya tengo algunas conclusiones sobre los resultados del parcial. Charlaremos la próxima clase sobre el tema.

Antes quisiera conocer la impresión de ustedes, para lo cual preparé una breve encuesta anónima.

domingo, 25 de mayo de 2014

TP4 rev2

Hice unos cambios a los puntos 1 y 2 del TP4. Pueden verlo en http://unajct.blogspot.com/2014/05/tp4.html.

Dudo que sean muchos los que estén trabajando con el TP4, sin embargo, para no perjudicar a nadie, les dejo la clase minHeap, es decir, la resolución de los puntos 1a, 1b y 1c. Si editan el archivo .py no olviden tomar precauciones con el estilo de indentación (yo generalmente uso tabulador).

sábado, 24 de mayo de 2014

Clase 19 de mayo y parcial

Les dejo la presentación de la clase del 19 de mayo. Vimos dispersión (hashing) y comenzamos con el trabajo práctico 4 sobre el mismo tema.

Les resumo lo que hablamos sobre el parcial:
  • Será de opción múltiple.
  • El contenido es todo hasta árboles binarios, binarios de búsqueda y autobalanceados.
  • No habrá ejercicios de programación.
  • Un tercio del parcial (también con opción múltiple) será de resolución de ejercicios prácticos (cálculo de T(n), O(n), insertar gráficamente datos en alguna de las estructuras vistas, etc.).
  • El resto será evaluación de la teoría, en forma directa o aplicada. En forma aplicada significa con ejemplos o relacionando conceptos.
  • De 14 a 15:10 haremos clase, para responder dudas puntuales que tengan y para avanzar con el TP4. A las 15:30 comenzará la evaluación. Traten de llegar temprano.
También señalé dos errores conceptuales que más de un alumno cometió en los prácticos.
Algunos de ustedes no tienen tema de trabajo final o tienen pendiente confirmar. Pueden hacerlo por mail o podemos hablar personalmente. Se aplica la política de que un tema queda asignado al primero que lo elige si lo confirma.

domingo, 18 de mayo de 2014

TP4

Les voy dejando la guía del Trabajo Práctico 4. Tiene dos adjuntos: listaClaveValor.py y autos.py. Como estoy teniendo problemas técnicos con los adjuntos, a continuación les pego el código de ambos archivos:


ListaClaveValor.py

class listaClaveValor:
    def __init__(self, clave=None, valor=None):
        self.__clave = clave
        self.__valor = valor
        self.__siguiente = None
    def buscarClave(self, c):
        e = self
        while e!=None and e.__clave!=c:
            e = e.__siguiente
        return e
    def buscarValor(self, v):
        e = self
        while e!=None and e.__valor!=v:
            e = e.__siguiente
        return e
    def insertar(self, c, v):
        e = self
        while e!=None and e.__clave!=c:
            ea = e
            e = e.__siguiente
        if e:
            e.__valor = v
            return e
        if ea.__clave == None:
            ea.__clave = c
            ea.__valor = v
            return ea
        e = listaClaveValor(c,v)
        ea.__siguiente = e
        return e
    def longitud(self):
        e = self
        n = 0
        while e!=None:
            n = n + 1
            e = e.__siguiente
        return n
    def valor(self):
        return self.__valor
    def clave(self):
        return self.__clave
    def siguiente(self):
        return self.__siguiente
    def __str__(self):
        e = self
        s = '['
        if self.__clave == None:
            return '[]'
        while e!=None:
            s = s + str(e.__clave) + ','
            e = e.__siguiente
        return s[:-1] + ']'



autos.py


from dispersion import *

class auto:
    def __init__(self, patente, marca, fabricacion, propietario):
        self._patente = patente
        self._marca = marca
        self._fabricacion = fabricacion
        self._propietario = propietario
    def marca(self):
        return self._marca
    def propietario(self):
        return self._propietario
    def fabricacion(self):
        return self._fabricacion

def hashPatente(p):
    b = 13
    h = 0
    for i in range(0,6):
        h = h + b**i * ord(p[i])
    return h

mapa = hashTableXXX(h=11, hash=hashPatente)
pa1 = 'ADF565'
pa2 = 'RUY276'
pa3 = 'ETI127'
pa4 = 'AE5328'
pa5 = 'BRY070'
pa6 = 'WER808'
pa7 = 'WGJ756'
pa8 = 'YEW423'
pa9 = 'VFU112'
a1 = auto(pa1, 'Toyota', 1990, 'Juan')
a2 = auto(pa2, 'Volkswagen', 1993, 'Antonio')
a3 = auto(pa3, 'Fiat', 1997, 'Adriana')
a4 = auto(pa4, 'Toyota', 2001, 'Lucia')
a5 = auto(pa5, 'Peugeot', 2003, 'Maria')
a6 = auto(pa6, 'Fiat', 2006, 'Jose')
a7 = auto(pa7, 'Toyota', 2007, 'Mariano')
a8 = auto(pa8, 'Volkswagen', 2008, 'Hernan')
a9 = auto(pa9, 'Peugeot', 2009, 'Pedro')
mapa.insertar(pa1, a1)
print "insertando", pa1, mapa.estado(), "carga:", mapa.factorCarga()
mapa.insertar(pa2, a2)
print "insertando", pa2, mapa.estado(), "carga:", mapa.factorCarga()
mapa.insertar(pa3, a3)
print "insertando", pa3, mapa.estado(), "carga:", mapa.factorCarga()
mapa.insertar(pa4, a4)
print "insertando", pa4, mapa.estado(), "carga:", mapa.factorCarga()
mapa.insertar(pa5, a5)
print "insertando", pa5, mapa.estado(), "carga:", mapa.factorCarga()
mapa.insertar(pa6, a6)
print "insertando", pa6, mapa.estado(), "carga:", mapa.factorCarga()
mapa.insertar(pa7, a7)
print "insertando", pa7, mapa.estado(), "carga:", mapa.factorCarga()
mapa.insertar(pa8, a8)
print "insertando", pa8, mapa.estado(), "carga:", mapa.factorCarga()
mapa.insertar(pa9, a9)
print "insertando", pa9, mapa.estado(), "carga:", mapa.factorCarga()

print "buscando..."
for p in [pa1,pa2,pa3,pa4,pa5,pa6,pa7,pa8,pa9]:
    a = mapa.buscar(p)
    print p,a.marca(),a.propietario()

miércoles, 14 de mayo de 2014

Tema de trabajo final

La última clase hablamos sobre el trabajo final. Les resumo la cuestión de los grupos y la definición de tema.

El trabajo se hace en grupos de 1 a 3 personas, el tema es a elegir y acordar conmigo. A medida que vayan teniendo una idea del tema vayan comentándome muy brevemente por mail. Tengan en cuenta que cada grupo deberá trabajar sobre un tema distinto. La próxima clase me gustaría hablar con cada grupo y tratar de definir los temas.

Hay dos posibles tipos de trabajo:
  1. Extensión de un trabajo práctico de los que hicimos, profundizando el estudio teórico del tema, implementando y analizando los algoritmos y realizando mediciones con datos aleatorios.
  2. Construir un módulo de python con las estructuras y algoritmos vistos para alguno de los temas e implementar una pequeña aplicación que la utilice. Ejemplos:
    • Sectorización de redes de suministro de agua potable.
    • Compresor/descompresor de texto basado en códigos de Huffman.
Quienes ya tengan conocimientos sobre grafos tendrán la posibilidad de trabajar con el tema. El resto tenga presente que es el último tema que se ve. Los temas teóricos con los que pueden trabajar son:

  • Estructuras fundamentales y algoritmos de ordenamiento y búsqueda
  • Árboles (generales)
  • Árboles binarios, de búsqueda y autobalanceados
  • Heap y hashing
  • Grafos
  • Problemas NP

Clases del 5 y 12 de mayo

El 5 de mayo vimos árboles binarios, les dejo la presentación. También empezamos con el Trabajo Práctico 3, sobre árboles binarios, árboles binarios de búsqueda y árboles autobalanceados. Perdón por la demora en publicarlo.

A pedido de ustedes, el 12 de mayo hicimos un refuerzo de cálculo de T(n) tanto para algoritmos no recursivos como para recursivos. Introdujimos una variante en una de las técnicas vistas. También vimos las estructuras heap (a veces llamadas montón o montículo) con sus algoritmos correspondientes. Además hablamos un poco sobre el trabajo final. Publicaré otro post sobre eso.

sábado, 3 de mayo de 2014

Clase 28/4 y recursos TP2

La clase del 28/4 vimos dos ejemplos de ecuaciones de recurrencia y comenzamos con el TP2. Algunos comentarios respecto del TP2:

  • Les comparto una versión corregida de los ejercicios que resolvimos en clase.
  • Les comparto código con datos para quien quiera usarlo para hacer pruebas con el ejercicio 5. Dos aclaraciones:
    • Dicho ejercicio no pide las respuestas a las preguntas sino las líneas de código necesarias para obtenerlas (es suficiente con las líneas sin estructurarlas en clases ni en funciones).
    • No es necesario entregar código con pruebas como el que les comparto.
  • Si están todos de acuerdo, intercambiaremos la opcionalidad entre los ejercicios 3 y 4. Lo discutiremos la próxima clase.
  • Espero que todo esto sirva de ayuda pero tengan en cuenta que el TP sigue siendo largo.

La próxima clase veremos un tema teórico y comenzaremos con el TP3.

sábado, 26 de abril de 2014

TP2

Está subido acá el práctico 2 para que lo vayan mirando. Trabajaremos en él la próxima clase.

martes, 22 de abril de 2014

Clase 21/4

La clase del 21/4 vimos algoritmos recursivos, incluyendo el cálculo del costo, y luego árboles en general. Les dejo las presentaciones respectivamente acá y acá.

miércoles, 16 de abril de 2014

Clase 14/4 y comentarios sobre el TP1

La clase pasada hicimos un repaso rápido de estructuras fundamentales y vimos 3 de los algoritmos clásicos de búsqueda más los 2 de ordenamiento. Las presentaciones son esta y esta respectivamente.

Además trabajamos con el TP1. Dado que cometí errores en la resolución en clase con el ejercicio 3b, les dejo un documento con resoluciones y comentarios. Además me parece justo retrasar 3 días la fecha de entrega. En la línea 8 del seudocódigo del enunciado del mismo ejercicio, usé paréntesis cuando debían ser corchetes.


Como los noté preocupados acerca de la implementación en python de los algoritmos, les hago algunos comentarios que pueden ayudar:

  • Para el ejercicio 7 les van a venir bien los métodos split y strip de String y readline de File.
  • Cuando el ejercicio pide graficar, no se espera que lo hagan desde python sino a partir de los resultados usando por ejemplo una planilla de cálculo.
  • Todo el seudocódigo usado en clase tiene 0 como primer elemento de las listas, lo cual es natural en python. Por el contrario, los bloques "para", a menos que digan lo contrario, incluyen los dos extremos del rango. Por ejemplo si dice "para x de 0 a n-1:", repetirá n veces.

sábado, 12 de abril de 2014

TP1

Les dejo acá la guía del trabajo práctico 1 sobre análisis de algoritmos y estructuras fundamentales. Necesitarán este adjunto.

 La próxima clase luego de un poco de teoría avanzaremos en la resolución tanto como podamos.

jueves, 10 de abril de 2014

Clase 7/4

En la clase del 7/4 hicimos un primer abordaje al análisis de algoritmos. Aplicaremos estos conocimientos y ampliaremos el alcance con otros algoritmos y estructuras de datos. Puden descargar la presentación acá.

viernes, 4 de abril de 2014

Clase 31/3

Pueden ver la presentación del 31/3 acá. Pueden hacer un repaso de Python más extensivo con la documentación del sitio oficial. La documentación es amplia. Para no perderse recuerden que hay un tutorial por un lado y documentación exhaustiva por otro.

lunes, 3 de marzo de 2014

Bibliografía recomendada

Usaremos en clase material de las siguientes fuentes.


  • Tutorial del sitio oficial de Python versión 2 (http://docs.python.org/2.7/tutorial/index.html), principalmente capítulos 3, 4, 5, 8 y 10.
  • Documentación de referencia del sitio oficial de Python versión 2 (http://docs.python.org/2.7/library/index.html), hasta el capítulo 10 inclusive.
  • Aho, A.; Hopcroft, J.; Ullman, J. Estructuras de datos y algoritmos. Editorial Addison Wesley (ISBN 9789684443457). Año 1999.
  • Sara Baase, Allen Van Gelder. Algoritmos Computacionales: Introducción al análisis y diseño, Tercera Edición.
  • Allen Weiss, M. Estructuras de datos en Java. Editorial Addison Wesley (ISBN 9788478290352). Año 2000.
  • Downey, A. y otros. Aprenda a pensar como un programador con Python. Editorial Green Tea Press (ISBN 0-9716775-0-6). 1º Ed. Año 2002.
  • Martelli, A. Python Guía de Referencia. Editorial Anaya Multimedia (ISBN 9788441523173). 1º Ed. Año 2008.
  • Booch, G. Anállsis y diseño orientado a objetos con aplicaciones. Editorial Addison–Wesley Iberoa (ISBN 9684443528). Ed. 2. Año 1996.
  • Rumbaugh, J.; Blaha, M.; Eddy, F.; Lorensen, W.; Premerlani, W. Modelado y diseño orientado objetos. Editorial Prentice-Hall (ISBN 0132406985). 1º Ed. Año 1996.
  • Pilgrim, M. Inmersión en Python. Año 2009.
  • González Duque, R. Python para todos. Creative Commons Reconocimiento 2.5. Año 2010.
  • Waite, M.; Lafore, R. Data structures and algorithms in Java. Editorial Kindle (ISBN 978-0672324536). Ed. 2°. Año 2002.

Si tienen material para sugerir podremos agregarlo a la lista.

Bienvenidos

Este es el blog de la materia Complejidad Temporal, Algoritmos y Estructuras de Datos, de la carrera de Ingeniería en Informática de la Universidad Nacional Arturo Jauretche.

En este blog está destinado a publicar enunciados, material y referencias, respuestas a preguntas frecuentes, datos de fechas, avisos de cambios de planes, etc. Espero que sea de utilidad a los alumnos.

Durante el cursado los alumnos deberán entregar trabajos prácticos, rendir exámenes parciales y hacer dos entregas de un trabajo final. Se informarán los detalles oportunamente.

Para comenzar les solicito que completen la encuesta inicial. Bienvenidos al primer cuatrimestre de 2014.