FACULTAD DE INGENIERA

FUNDAMENTOS DE COMPUTACION Y PROGRAMACION

PEP N2

ASPECTOS GENERALES DE LA PRUEBA

Lea atentamente la prueba y las instrucciones antes de comenzar a desarrollarla.

Queda prohibido hablar con los compaeros(as) durante el desarrollo de la PEP.
La PEP contiene 2 preguntas de desarrollo, con un total de 45 puntos y una exigencia del 60%
Tiene un lmite de tiempo de 90 minutos para responder.
El equipo docente tiene la prohibicin de responder consultas.
El/La estudiante que se sorprenda en actos deshonestos ser calificado con la nota mnima.
Los elementos tecnolgicos deben permanecer apagados y guardados. Queda absolutamente
prohibido el uso todo elemento tecnolgico. Su uso puede significar la nota mnima o sanciones
mayores.
El alumno deber identificarse con su Cdula de Identidad.
Sobre el escritorio slo podr existir lpiz (obligatorio) y goma/lpiz corrector (opcional).
Complete sus datos personales antes de comenzar la evaluacin.
Considere que la evaluacin contempla el cdigo, los comentarios y el seguimiento de las buenas
prcticas de programacin.
Responda cada pregunta, a continuacin de su enunciado, en el espacio que se le entrega para
ello.

NOMBRE RUT SECCIN

1. (30 puntos) Un ndice invertido es una estructura utilizada en la informtica para optimizar el
funcionamiento de los motores de bsqueda como google, bing o yahoo , el objetivo de estas
estructuras es permitir que el buscador conozca en qu documentos se encuentran las
palabras que usualmente buscamos. Normalmente se construyen a partir de un ndice en el
cul se indican las palabras que se encuentran en el documento.

Suponiendo que tenemos un archivo indice.txt el cul tiene los documentos con sus
respectivas palabras, se desea construir un archivo indiceInvertido.txt que contenga el
resultado de la construccin del ndice invertido a partir de los datos del ndice.

Un ejemplo de un ndice normal y uno invertido puede verse a continuacin:

indice.txt
Documento 1; el perro no come chocolate
Documento 2; la vaca come pasto
Documento 3; el perro come carne
Documento 4; la vaca no come carne

indiceInvertido.txt
carne; Documento 3, Documento 4
chocolate; Documento 1
come; Documento 1, Documento 2, Documento 3, Documento 4
el; Documento 1, Documento 3
la; Documento 2, Documento 4
 3 de diciembre de 2016

no; Documento 1, Documento 4

perro; Documento 1, Documento 3
vaca; Documento 2, Documento 4

En orden de construir el ndice invertido, se ha decidido utilizar la estrategia de solucin

enunciada en el siguiente diagrama de abstraccin:

El que puede leerse como:

La funcin leerArchivo() recibe como entrada el nombre del ndice a leer y entrega
como salida una lista de strings dnde cada elemento de la lista es una lnea del
archivo (con salto de lnea incluido), por ejemplo:
'Documento 1; el perro no come chocolate\n'
La funcin procesarContenido()recibe el contenido y los ordena como una lista de
listas dnde cada elemento ser de la forma:
['Documento 1', ['el', 'perro', 'no', 'come', 'chocolate']]
A partir de dicha salida la funcin crearIndiceInvertido() construye el ndice
nuevo, indicando, para cada palabra los documentos en los que esta se encuentra,
utilizando una estructura similar a la funcin procesarContenido().
La funcin prepararEscritura(), transforma el ndice invertido a un string para
asegurar que el proceso siguiente realice la escritura.
Finalmente la funcin escribirArchivo(), recibe como entrada los datos a escribir
y el nombre del archivo, para construir el archivo de salida y entrega un True, para
que el programa informe cuando el proceso termina exitosamente.

A partir de este diseo de solucin, se le solicita a usted que, a partir de la abstraccin

generada, construya:
A. (9 puntos) Las funciones leerArchivo() y procesarContenido(),
B. (15 puntos) La funcin crearIndiceInvertido(),
2
 3 de diciembre de 2016

C. (6 puntos) El bloque principal del programa

Considere que:
Las funciones prepararEscritura() y escribirArchivo() existen y funcionan
correctamente.
Las listas anteriores representan ejemplos y que el programa debe funcionar para
todos los casos que respondan a las reglas anteriores.
Es posible definir funciones auxiliares siempre y cuando stas no alteren la
abstraccin dada.

#############################################################
#
# ITEM A
#
#############################################################

# Funcin que lee un archivo de texto

# ENTRADA: nombre del archivo (string)
# SALIDA: contenido del archivo (lista de strings)
def leerArchivo(nombreArchivo):
# Se abre el archivo en modo de lectura
archivo = open(nombreArchivo, 'r')
# Se obtiene el contenido del archivo en una lista de strings
contenidoArchivo = archivo.readlines()
# Se cierra el archivo
archivo.close()
# Se retorna el contenido
return contenidoArchivo

# Funcin que entrega una lista de listas con el ndice de archivos

# ENTRADA: contenido del archivo (lista de strings)
# SALIDA: contenido procesado (lista de listas)
def procesarContenido(contenido):
# Declaro una lista llamada ndice para almacenar el contenido
indice = []
# Para cada lnea en el contenido del archivo
for linea in contenido :
# Elimino el salto de lnea al final de esta y utilizo split
# para separar el nombre del documento de las palabras que contiene
lista = linea.strip('\n').lstrip(" ").split(';')
# Transformo el string con las palabras que el documento contiene a una
# lista, separando las palabras por el caracter espacio
lista[1] = lista[1].split(" ")
#Agrego la lista al ndice
indice.append(lista)
# Se entrega el ndice
return indice

3
 3 de diciembre de 2016

#############################################################
#
# ITEM B
#
#############################################################

# Funcin que encuentra los documentos en los que se encuentra una palabra
# ENTRADAS: palabra a buscar (string), indice (lista de strings)
# SALIDA: lista de documentos (lista de strings)
def encontrarDocumentos(palabra, indice):
# Se crea una lista vaca para almacenar los documentos
documentos = []
# Para cada elemento en el ndice
for elemento in indice :
# Si la palabra est en la lista de palabras
if palabra in elemento[1]:
# Se aade el nombre del documento a la lista de documentos
documentos.append(elemento[0])
# Se retorna la lista de documentos
return documentos

# Funcin que construye un ndice invertido

# ENTRADA: ndice (lista de listas)
# SALIDA: ndice invertido (lista de listas)
def contruirIndiceInvertido(indice):
# Se declara una lista vaca para ir almacenando las palabras
palabras = []
# Para cada elemento en el ndice
for elemento in indice :
# Para cada palabra en la lista de palabras
for palabra in elemento[1] :
# Si la palabra a revisar an no se ha agregado a la lista de
palabras
if not (palabra in palabras) :
# Se agrega la palabra a la lista
palabras.append(palabra)
# OPCIONAL: Se ordena la lista para que el ndice invertido quede ordenado
alfabticamente
palabras.sort()
# Se declara una lista vaca para almacenar el ndice invertido
indiceInvertido = []
# Para cada palabra en la lista de palabras
for palabra in palabras :
# Se obtiene la lista de documentos en los cules la palabra aparece,
invocando la funcin
# auxiliar "encontrarDocumentos"
documentosConPalabra = encontrarDocumentos(palabra, indice)
4
 3 de diciembre de 2016

# Se genera la estructura de lista para agregar el elemento al ndice

invertido
lista = [palabra, documentosConPalabra]
# Se agrega el elemento al indiceInvertido
indiceInvertido.append(lista)
# Se entrega el ndice invertido
return indiceInvertido

#############################################################
#
# ITEM C
#
#############################################################

# BLOQUE PRINCIPAL

# ENTRADA
# Se invoca a la funcin leerArchivo
contenidoEntrada = leerArchivo("ndice.txt")
# PROCESAMIENTO
# Se procesa el contenido para obtener la lista de listas
contenidoProcesado = procesarContenido(contenidoEntrada)
# Se genera el indice invertido
indiceInvertido = contruirIndiceInvertido(contenidoProcesado)
# Se genera el string de salida
contenidoSalida = prepararEscritura(indiceInvertido)
# SALIDA
# Se escribe el contenido en el archivo
exito = escribirArchivo("indiceInvertido.txt", contenidoSalida)
# Si el contenido se escribe
if exito :
print "El archivo fue escrito exitosamente"

2. (15 puntos) Para dibujar una circunferencia de radio r, podemos expresar sus coordenadas
cartesianas mediante la ecuacin:
( )2 + ( )2 = 2
Dnde las coordenadas a, b representan el centro de la circunferencia y el radio consiste en
todos los puntos x, y que satisfacen la ecuacin.

Adems, sabemos que podemos obtener el dominio de x debido a que:

x alcanza su valor mximo y mnimo cuando (y b)2 = 0, con valores r + a y a r
respectivamente.
Del mismo modo, si despejamos y en la ecuacin, podemos obtener que los valores
que tomar y estarn dados por la siguiente expresin:

5
 3 de diciembre de 2016

= ( | 2 ( )2 | +
A partir de esta informacin, construya un programa en Python que dibuje el grfico de una
circunferencia (en color azul) para valores de r, a y b dados por teclado. Considere que numpy
posee la funcin abs(array) para el clculo del valor absoluto y sqrt(array) para el clculo
de la raz cuadrada.

# BLOQUE DE DEFINICIONES

# IMPORTACIN DE MDULOS
import matplotlib.pyplot as graficador
import numpy as numpy

# BLOQUE PRINCIPAL

# ENTRADA

# Se solicita como entrada el valor del radio

r = input("Ingrese el radio: ")

# Se solicita la coordenada x del centro de la circunferencia

a = input("Ingrese la coordenada x del centro : ")

# Se solicita la coordenada y del centro de la circunferencia

b = input("Ingrese la coordenada y del centro:")

# PROCESAMIENTO

# Se declara un vector desde el valor mnimo de x, hasta el

# valor mximo
x = numpy.arange(-r, r+ 0.01, 0.01) + a

# Se calculan las coordenadas positivas del vector del eje y

y1 = numpy.sqrt(numpy.abs(r**2 - (x - a) ** 2)) + b
# Se calculan las coordenadas negativas del vector del eje y
y2 = - numpy.sqrt(numpy.abs(r**2 - (x - a) ** 2)) + b

# SALIDA

# Se grafica la parte positiva de la circunferencia

recta = graficador.plot(x, y1 )
# Se grafica la parte negativa de la circunferencia
recta2 = graficador.plot(x, y2)

# Se iguala la representacin, para que la circunferencia se vea como una sola

graficador.setp(recta ,'color', 'b', 'linestyle', '-', "linewidth", 1.0)
graficador.setp(recta2 ,'color','b', 'linestyle', '-', "linewidth", 1.0)

# Se etiquetan los ejes X e Y del grfico

6
 3 de diciembre de 2016

graficador.xlabel("EJE X")
graficador.ylabel("EJE Y")
# Se le determina un ttulo al grfico
titulo = "Circunferencia de radio " + str(r) + " con centro en (" +str(a) \
+", " +str(b) +")"
# Se identifica el ttulo del grfico
graficador.title(titulo)
# Se muestra el grfico
graficador.show()