def findSlot(map, key, hashvalue, comparefunction):
"""
Encuentra una posición libre en la tabla de hash.
map: la tabla de hash
key: la llave
hashvalue: La posición inicial de la llave
comparefunction: funcion de comparación para la búsqueda de la llave
"""
avail = -1 # no se ha encontrado una posición aun
searchpos = 0 #
table = map['table']
while (searchpos != hashvalue
): # Se busca una posición hasta llegar al punto de partida
if (searchpos == 0):
searchpos = hashvalue # searchpos comienza la búsqueda en la posición hashvalue
if isAvailable(table, searchpos): # La posición esta disponible
element = lt.getElement(table, searchpos)
if (avail == -1):
avail = searchpos # avail tiene la primera posición disponible encontrada
if element[
'key'] == None: # La posición nunca ha sido utilizada, luego el elemento no existe
break
else: # la posicion no estaba disponible
element = lt.getElement(table, searchpos)
if comparefunction(
key, element): # La llave es exactamente la que se busca
return searchpos # Se termina la busqueda y se retorna la posicion
searchpos = (((searchpos) % map['capacity']) + 1)
# Se pasa a la siguiente posición de la tabla
return -(avail) # Se retorna la primera posicion disponible, se indica
def test_insertElement(self):
self.lst = slt.newList()
slt.insertElement(self.lst, self.book1, 1)
self.assertEqual(slt.size(self.lst), 1)
slt.insertElement(self.lst, self.book2, 1)
self.assertEqual(slt.size(self.lst), 2)
book = slt.getElement(self.lst, 1)
self.assertDictEqual(book, self.book2)
book = slt.getElement(self.lst, 2)
self.assertDictEqual(book, self.book1)
def test_getElement(self):
self.lst = slt.newList('ARRAY_LIST')
slt.addLast(self.lst, self.book1)
self.assertEqual(slt.size(self.lst), 1)
slt.addLast(self.lst, self.book2)
self.assertEqual(slt.size(self.lst), 2)
book = slt.getElement(self.lst, 1)
self.assertDictEqual(book, self.book1)
book = slt.getElement(self.lst, 2)
self.assertDictEqual(book, self.book2)
def keySet(map):
"""
Retorna una lista con todas las llaves de la tabla de hash
"""
ltset = lt.newList()
for pos in range(lt.size(map['table'])):
bucket = lt.getElement(map['table'], pos + 1)
for element in range(lt.size(bucket)):
entry = lt.getElement(bucket, element + 1)
lt.addLast(ltset, entry['key'])
return ltset
def valueSet(map):
"""
Retornar una lista con todos los valores de la tabla de hash
"""
ltset = lt.newList()
for pos in range(lt.size(map['table'])):
bucket = lt.getElement(map['table'], pos + 1)
for element in range(lt.size(bucket)):
entry = lt.getElement(bucket, element + 1)
lt.addLast(ltset, entry['value'])
return ltset
def test_getElement(self):
self.lst = slt.newList('ARRAY_LIST')
self.assertEqual(slt.isEmpty(self.lst), True)
self.assertEqual(slt.size(self.lst), 0)
slt.addLast(self.lst, self.movie1)
self.assertEqual(slt.size(self.lst), 1)
slt.addLast(self.lst, self.movie2)
self.assertEqual(slt.size(self.lst), 2)
movie = slt.getElement(self.lst, 1)
self.assertDictEqual(movie, self.movie1)
movie = slt.getElement(self.lst, 2)
self.assertDictEqual(movie, self.movie2)
def test_getElement (self):
self.lst = slt.newList()
self.assertEqual (slt.isEmpty(self.lst), True)
self.assertEqual (slt.size(self.lst), 0)
slt.addLast (self.lst, self.book1)
self.assertEqual (slt.size(self.lst), 1)
slt.addLast (self.lst, self.book2)
self.assertEqual (slt.size(self.lst), 2)
book = slt.getElement(self.lst, 1)
self.assertDictEqual (book, self.book1)
book = slt.getElement(self.lst, 2)
self.assertDictEqual (book, self.book2)
def test_insertElement (self):
self.lst = slt.newList('ARRAY_LIST')
self.assertEqual (slt.isEmpty(self.lst), True)
self.assertEqual (slt.size(self.lst), 0)
slt.insertElement (self.lst, self.book1, 1)
self.assertEqual (slt.size(self.lst), 1)
slt.insertElement (self.lst, self.book2, 1)
self.assertEqual (slt.size(self.lst), 2)
book = slt.getElement(self.lst, 1)
self.assertDictEqual (book, self.book2)
book = slt.getElement(self.lst, 2)
self.assertDictEqual (book, self.book1)
def shellSort(lst, lessfunction, column):
n = lt.size(lst)
h = 1
while h < n / 3: # Se calcula el tamaño del primer gap. La lista se h-ordena con este tamaño
h = 3 * h + 1 # por ejemplo para n = 100, h toma un valor inical de 13 , 4, 1
while (h >= 1):
for i in range(h, n):
j = i
while (j >= h) and lessfunction(lt.getElement(
lst, j + 1), lt.getElement(lst, j - h + 1), column):
lt.exchange(lst, j + 1, j - h + 1)
j -= h
h //= 3 # h se decrementa en un tercio. cuando h es igual a 1, se comporta como insertionsort
def get(map, key, comparefunction):
"""
Retorna la pareja llave, valor, cuya llave sea igual a key.
Es necesario proveer una función de comparación para las llaves.
Si la llave no esta presente se retorna None
"""
hash = hashValue(map, key)
bucket = lt.getElement(map['table'], hash)
pos = lt.isPresent(bucket, key, comparefunction)
if pos > 0:
return lt.getElement(bucket, pos)
else:
return None
def req4(criteria, lstCast, lstMov):
"""
Retorna la cantidad de elementos que cumplen con un criterio para una columna dada
"""
# Guardar los id de las peliculas del actor
idMov = lt.newList("ARRAY_LIST", compFunc)
# Guardar el nombre del director y el numero de las colaboraciones
myDirectorDic = {}
for i in range(lt.size(lstCast)):
director = lt.getElement(lstCast, i)
if criteria == director['actor1_name'] or criteria == director['actor2_name'] or criteria == director['actor3_name'] or criteria == director['actor4_name'] or criteria == director['actor5_name']:
lt.addLast(idMov, director['id'])
dir_name = director['director_name']
# revisa si la llave existe
if dir_name in myDirectorDic:
myDirectorDic[dir_name] = int(myDirectorDic[dir_name]) + 1
else:
myDirectorDic[dir_name] = 1
pelicula = lt.newList("ARRAY_LIST", compFunc)
numPel = 0
calProm = 0.0
for i in range(lt.size(lstMov)):
id = lt.getElement(lstMov, i)['id']
if lt.isPresent(idMov, id) > 0:
lt.addLast(pelicula, lt.getElement(lstMov, i)['title'])
numPel += 1
calProm += float(lt.getElement(lstMov, i)['vote_average'])
if numPel == lt.size(idMov):
break
prom = 0.0
if numPel != 0:
prom = calProm / numPel
# Busca el director con mayores colaboraciones
actual = 0
name = ""
for k, v in myDirectorDic.items():
if actual < int(v):
actual = int(v)
name = str(k)
res = "Para el actor " + str(criteria) + "\nEl director con el cual más a trabajado es: " + str(
name) + "\nSu peliculas tienen un calficación promedio de: " + str(prom) + "\nEl numero de peliculas del actor es: " + str(numPel) + "\n"
return pelicula, res
def test_carga():
lista = []
lst = lt.newList()
file = "Data\theMoviesdb\MoviesCastingRaw-small.csv"
sep = ";"
dialect = csv.excel()
dialect.delimiter = sep
assert (lt.size(lst) == 0), "la lista no empieza en cero"
try:
with open(file, enconding='utf-8') as csvfile:
reader = csv.DictReader(csvfile, dialect=dialect)
for row in reader:
lista.append(row)
lt.addLast(lst, row)
except:
assert False, "Se presento un error al cargar el archivo"
assert len(lista) == lt.size(lst), "son diferentes tamaños"
for i in range(len(lista)):
assert lt.getElement(
lst, i + 1) == lista[i], "las listas no estan en el mismo orden"
def new_copy(lst, datastructure="SINGLE_LINKED", cmpfunction=None):
copia = lt.newList(datastructure, cmpfunction)
for i in range(1, lt.size(lst) + 1):
a = lt.getElement(lst, i)
lt.addLast(copia, a)
return copia
def test_carga():
lst = []
lst = lt.newList()
file = "Data/GoodReads/books.csv"
sep = ','
dialect = csv.excel()
dialect.delimiter = sep
assert (lt.size(lst) == 0), "la lista no empieza en cero"
try:
with open(file, encoding='utf-8') as csvfile:
reader = csv.DictReader(csvfile, dialect=dialect)
for row in reader:
lst.append(row)
lt.addLast(lst, row)
except:
assert False, "Se presento un error al cargar el archivo"
assert len(lst) == lt.size(lst), "Son diferentes tamaños"
for i in range(len(lst)):
assert lt.getElement(
lst, i + 1) == lst[i], "Las listas no estan en el mismo orden"
def test_carga():
lista = []
lst = lt.newList('ARRAY_LIST', cmpfunction)
file = config.data_dir + 'MoviesCastingRaw-small.csv'
sep = ';'
dialect = csv.excel()
dialect.delimiter = sep
assert (lt.size(lst) == 0), "La lista no empieza en cero."
try:
with open(file, encoding='utf-8') as csvfile:
reader = csv.DictReader(csvfile, dialect=dialect)
for row in reader:
lista.append(row)
lt.addLast(lst, row)
except:
assert False, "Se presento un error al cargar el archivo."
assert len(lista) == lt.size(lst), "Son diferentes tamaños."
for i in range(len(lista)):
assert lt.getElement(
lst, i + 1) == lista[i], "Las listas no estan en el mismo orden."
def getElement(lst, pos):
"""
Retorna el elemento en la posición pos de la lista.
pos debe ser mayor que cero y menor o igual al tamaño de la lista
la lista no esta vacia
"""
return lt.getElement(lst, pos)
def isAvailable(table, pos):
"""
Informa si la posición pos esta disponible en la tabla de hash. Se entiende que una posición está disponible
si su contenido es igual a None (no se ha usado esa posicion) o a __EMPTY__ (la posición fue liberada)
"""
entry = lt.getElement(table, pos)
if (entry['key'] == None or entry['key'] == '__EMPTY__'):
return True
return False
def valueSet(map):
"""
Retornar una lista con todos los valores de la tabla de hash
"""
ltset = lt.newList()
for pos in range(lt.size(map['table'])):
entry = lt.getElement(map['table'], pos + 1)
if (entry['value'] != None and entry['value'] != '__EMPTY__'):
lt.addLast(ltset, entry['value'])
return ltset
def keySet(map):
"""
Retorna una lista con todas las llaves de la tabla de hash
"""
ltset = lt.newList()
for pos in range(lt.size(map['table'])):
entry = lt.getElement(map['table'], pos + 1)
if (entry['key'] != None and entry['key'] != '__EMPTY__'):
lt.addLast(ltset, entry['key'])
return ltset
def req6(x, criteria, sentido, lstMov, genre):
pelicula = lt.newList("ARRAY_LIST")
numPel = 0
voteProm = 0.0
voteAverage = 0.0
for i in range(lt.size(lstMov)):
if lt.getElement(lstMov, i)['genres'].find(genre) != -1:
lt.addLast(pelicula, lt.getElement(lstMov, i))
res = "THE " + str(x) + " "
if criteria == 0 and sentido == 0:
sort.mergesort(pelicula, lessV)
res = res + "WORST VOTE "
elif criteria == 0 and sentido == 1:
sort.mergesort(pelicula, greaterV)
res = res + "BEST VOTE "
elif criteria == 1 and sentido == 0:
sort.mergesort(pelicula, lessA)
res = res + "WORST AVERAGE "
else:
sort.mergesort(pelicula, greaterA)
res = res + "BEST AVERAGE "
sub = lt.subList(pelicula, 1, x)
for i in range(lt.size(sub)):
numPel += 1
voteProm += float(lt.getElement(sub, i)['vote_count'])
voteAverage += float(lt.getElement(sub, i)['vote_average'])
prom1 = 0.0
prom2 = 0.0
if numPel != 0:
prom1 = voteProm/numPel
prom2 = voteAverage/numPel
res = res + genre + " Movies\n Promedio de votos: " + \
str(prom1) + " Votación promedio: " + str(prom2) + "\n"
return sub, res
def isEmpty(map):
"""
Informa si la tabla de hash se encuentra vacia
"""
empty = True
for pos in range(lt.size(map['table'])):
entry = lt.getElement(map['table'], pos + 1)
if (entry['key'] != None and entry['key'] != '__EMPTY__'):
empty = False
break
return empty
def req5(criteria, lstMov):
pelicula = lt.newList("ARRAY_LIST")
numPel = 0
voteProm = 0.0
for i in range(lt.size(lstMov)):
if lt.getElement(lstMov, i)['genres'].find(criteria) != -1:
lt.addLast(pelicula, lt.getElement(lstMov, i)['title'])
numPel += 1
voteProm += float(lt.getElement(lstMov, i)['vote_count'])
prom = 0.0
if numPel != 0:
prom = voteProm/numPel
res = "La cantidad de peliculas del genero " + \
str(criteria) + " es de: " + str(numPel) + \
" con un promedio de cantidad de votos de: " + str(prom) + "\n"
return pelicula, res
def test_removeFirst(self):
self.lst = slt.newList('ARRAY_LIST')
slt.addLast(self.lst, self.book1)
slt.addLast(self.lst, self.book2)
slt.removeFirst(self.lst)
book = slt.getElement(self.lst, 1)
self.assertEqual(slt.isEmpty(self.lst), False)
self.assertEqual(slt.size(self.lst), 1)
self.assertDictEqual(book, self.book2)
slt.removeFirst(self.lst)
self.assertEqual(slt.isEmpty(self.lst), True)
self.assertEqual(slt.size(self.lst), 0)
def contains(map, key, comparefunction):
"""
Retorna True si la llave key se encuentra en la tabla de hash o False en caso contrario.
Es necesario proveer la función de comparación entre llaves.
"""
hash = hashValue(map, key)
bucket = lt.getElement(map['table'], hash)
pos = lt.isPresent(bucket, key, comparefunction)
if pos > 0:
return True
else:
return False
def isEmpty(map):
"""
Informa si la tabla de hash se encuentra vacia
"""
bucket = lt.newList()
empty = True
for pos in range(lt.size(map['table'])):
bucket = lt.getElement(map['table'], pos + 1)
if lt.isEmpty(bucket) == False:
empty = False
break
return empty
def get(map, key, comparefunction):
"""
Retorna la pareja llave, valor, cuya llave sea igual a key.
Es necesario proveer una función de comparación para las llaves.
"""
hash = hashValue(map, key)
pos = findSlot(map, key, hash, comparefunction)
if pos > 0:
element = lt.getElement(map['table'], pos)
return element['value']
else:
return None
def remove(map, key, comparefunction):
"""
Elimina la pareja llave,valor, donde llave == key.
Es necesario proveer la función de comparación entre llaves
"""
hash = hashValue(map, key)
bucket = lt.getElement(map['table'], hash)
pos = lt.isPresent(bucket, key, comparefunction)
if pos > 0:
lt.deleteElement(bucket, pos)
map['size'] -= 1
else:
return None
def conocer_un_director(criteria, lst1, lst2):
if len(lst1) == 0 or len(lst2) == 0:
print("Alguna de las listas está vacía.")
else:
t2_start = process_time() #tiempo inicial
pelis_director = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=None)
info = {}
tit = lt.newList(datastructure='ARRAY_LIST', cmpfunction=None)
vote_av = lt.newList(datastructure='ARRAY_LIST', cmpfunction=None)
num_pelis = 0
filas = len(lst1)
i = 1
while i < filas:
director_name = lst2[i]['director_name']
if director_name == criteria:
lt.addLast(tit, lst1[i]['title'])
info['Titulos peliculas'] = tit
num_pelis += 1
lt.addLast(vote_av, float(lst1[i]['vote_average']))
i += 1
if lt.size(vote_av) == 1:
info['Promedio votos peliculas'] = lt.getElement(vote_av, 1)
else:
suma = 0
for j in range(0, lt.size(vote_av)):
suma = suma + lt.getElement(vote_av, j)
info['Promedio votos peliculas'] = round(suma / lt.size(vote_av), 2)
info['Total peliculas'] = num_pelis
lt.addLast(pelis_director, info)
t2_stop = process_time() #tiempo final
print("Tiempo de ejecucion", t2_stop - t2_start)
return pelis_director
def req3(criteria, lstCast, lstMov):
"""
Retorna la cantidad de elementos que cumplen con un criterio para una columna dada
"""
# Guardar los id de las peliculas del director
idMov = lt.newList("ARRAY_LIST", compFunc)
for i in range(lt.size(lstCast)):
director = lt.getElement(lstCast, i)
if criteria == director['director_name']:
lt.addLast(idMov, director['id'])
pelicula = lt.newList("ARRAY_LIST", compFunc)
numPel = 0
calProm = 0.0
for i in range(lt.size(lstMov)):
id = lt.getElement(lstMov, i)['id']
# Revisamos si el id de la pelicula actual está en el id de peliculas de nuestro director
if lt.isPresent(idMov, id) > 0:
lt.addLast(pelicula, lt.getElement(lstMov, i)['title'])
numPel += 1
calProm += float(lt.getElement(lstMov, i)['vote_average'])
if numPel == lt.size(idMov):
break
prom = 0.0
if numPel != 0:
prom = calProm/numPel
res = "El director " + str(criteria) + " posee un total de: " + str(numPel) + \
" peliculas, las cuales tienen una calificación promedio de: " + \
str(prom) + "\n"
return pelicula, res
def put(map, key, value, comparefunction):
"""
Ingresa una pareja llave,valor a la tabla de hash. Si la llave ya existe en la tabla, se reemplaza el valor.
Es necesario proveer una función de comparación para las llaves.
"""
hash = hashValue(map, key)
bucket = lt.getElement(
map['table'], hash
) #Se obtiene la lista de elementos en la posicion hash de la tabla
entry = me.newMapEntry(key, value)
pos = lt.isPresent(bucket, key, comparefunction)
if pos > 0: #La pareja ya exista, se reemplaza el valor con la nueva información
lt.changeInfo(bucket, pos, entry)
else:
lt.addLast(bucket,
entry) #La llave no existia, se crea una nueva entrada
map['size'] += 1
