def ranking_peliculas2(num_peliculas: int, lst1: list, lst2: list,
criterio2: int):
t1_start = process_time() #tiempo inicial
movies_lt = lt.newList(datastructure='ARRAY_LIST', cmpfunction=None)
i = 1
filas = len(lst1)
while i < filas:
movie_name = lst1[i]["original_title"]
movie_vote_average = float(lst1[i]["vote_average"])
movie_vote_count = float(lst1[i]["vote_count"])
movie = {
'movie_name': movie_name,
'vote_average': movie_vote_average,
'vote_count': movie_vote_count
}
lt.addLast(movies_lt, movie)
i = i + 1
if criterio2 == 1:
mg.mergesort(movies_lt, mejor_calificada)
if criterio2 == 2:
mg.mergesort(movies_lt, peor_calificada)
conjunto_mejores_calificadas = lt.subList(movies_lt, 1, num_peliculas)
pos_inicial_peores_calificadas = lt.size(movies_lt) - num_peliculas
conjunto_peores_calificadas = lt.subList(movies_lt,
pos_inicial_peores_calificadas,
num_peliculas)
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
return conjunto_mejores_calificadas[
"elements"], conjunto_peores_calificadas["elements"]
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 addEdge(graph, vertexa, vertexb, weight=0):
"""
Agrega un arco entre los vertices vertexa ---- vertexb, con peso weight.
Si el grafo es no dirigido se adiciona dos veces el mismo arco, en el mismo orden
Si el grafo es dirigido se adiciona solo el arco vertexa --> vertexb
"""
try:
# Se crea el arco
edge = e.newEdge(vertexa, vertexb, weight)
#Se obtienen las listas de adyacencias de cada vertice
#Se anexa a cada lista el arco correspondiente
entrya = map.get(graph['vertices'], vertexa)
lt.addLast(entrya['value'], edge)
if (not graph['directed']):
entryb = map.get(graph['vertices'], vertexb)
lt.addLast(entryb['value'], edge)
else:
degree = map.get(graph['indegree'], vertexb)
map.put(graph['indegree'], vertexb, degree['value'] + 1)
graph['edges'] += 1
return graph
except:
return None
def ranking_genero(genero: str, num_peliculas: int, lst1: list, lst2: list,
criterio: int):
t1_start = process_time() #tiempo inicial
movies_lt = lt.newList(datastructure='ARRAY_LIST', cmpfunction=None)
j = 1
filas = len(lst1)
while j < filas:
elemento = lst1[j]["genres"]
if genero in elemento:
movie_name = lst1[j]["original_title"]
movie_vote_average = float(lst1[j]["vote_average"])
movie_vote_count = float(lst1[j]["vote_count"])
movie = {
'movie_name': movie_name,
'vote_average': movie_vote_average,
'vote_count': movie_vote_count
}
lt.addLast(movies_lt, movie)
j = j + 1
if criterio == 1:
mg.mergesort(movies_lt, greater_num)
if criterio == 2:
mg.mergesort(movies_lt, greater_rating)
pedazo_mejores = lt.subList(movies_lt, 1, num_peliculas)
pos_inicial_peores = lt.size(movies_lt) - num_peliculas
pedazo_peores = lt.subList(movies_lt, pos_inicial_peores, num_peliculas)
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
return pedazo_mejores["elements"], pedazo_peores["elements"]
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 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 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 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 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 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 test_addLast(self):
self.lst = slt.newList()
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.firstElement(self.lst)
self.assertDictEqual(book, self.book1)
book = slt.lastElement(self.lst)
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()
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_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 loadCSVFile(file, cmpfunction):
lst = lt.newList("ARRAY_LIST", cmpfunction)
dialect = csv.excel()
dialect.delimiter = ";"
try:
with open(file, encoding="utf-8") as csvfile:
row = csv.DictReader(csvfile, dialect=dialect)
for elemento in row:
lt.addLast(lst, elemento)
except:
print("Hubo un error con la carga del archivo")
return lst
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 test_addLast (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.book1)
self.assertEqual (slt.size(self.lst), 1)
slt.addLast (self.lst, self.book2)
self.assertEqual (slt.size(self.lst), 2)
book = slt.firstElement(self.lst)
self.assertDictEqual (book, self.book1)
book = slt.lastElement(self.lst)
self.assertDictEqual (book, self.book2)
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 edges(graph):
"""
Retorna una lista con todos los arcos del grafo graph
"""
lstmap = map.valueSet(graph['vertices'])
lstresp = lt.newList()
itervertex = it.newIterator(lstmap)
while it.hasNext(itervertex):
lstedge = it.next(itervertex)
iteredge = it.newIterator(lstedge)
while (it.hasNext(iteredge)):
edge = it.next(iteredge)
if not (lt.isPresent(lstresp, edge, e.compareedges)):
lt.addLast(lstresp, edge)
return lstresp
def addEdge(graph, vertexa, vertexb, weight=0):
"""
Agrega un arco entre los vertices vertexa ---- vertexb, con peso weight
"""
# Se crea el arco
edge = e.newEdge(vertexa, vertexb, weight)
#Se obtienen las listas de adyacencias de cada vertice
entrya = map.get(graph['vertices'], vertexa)
entryb = map.get(graph['vertices'], vertexb)
#Se anexa a cada lista el arco correspondiente
lt.addLast(entrya['value'], edge)
lt.addLast(entryb['value'], edge)
graph['edges'] += 1
def adjacents(graph, vertex):
"""
Retorna una lista con todos los vertices adyacentes al vertice vertex
"""
element = map.get(graph['vertices'], vertex)
lst = element['value']
lstresp = lt.newList()
iter = it.newIterator(lst)
while (it.hasNext(iter)):
edge = it.next(iter)
v = e.either(edge)
if (v == vertex):
lt.addLast(lstresp, e.other(edge, v))
else:
lt.addLast(lstresp, v)
return lstresp
def enqueue (queue, element):
"""Agrega el elemento element en el tope de la pila
Args:
queue: La cola donde se insertará el elemento
element: El elemento a insertar
Returns:
La cola modificada
Raises:
Exception
"""
try:
lt.addLast (queue, element)
return queue
except Exception as ex:
err.reraise(ex, 'enqueue ')
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
def addLast(lst, element):
""" Agrega un elemento en la última posición de la lista.
Se adiciona un elemento en la última posición de la lista y se actualiza el apuntador a la útima posición.
Se incrementa el tamaño de la lista en 1
Args:
lst: La lista en la que se inserta el elemento
element: El elemento a insertar
Raises:
Exception
"""
try:
lt.addLast(lst, element)
except Exception as exp:
error.reraise(exp, 'TADList->addLast: ')
def adjacentEdges(graph, vertex):
"""
Retorna una lista con todos los enlaces adyacentes al vertice vertex
"""
try:
element = map.get(graph['vertices'], vertex)
lst = element['value']
lstresp = lt.newList()
iter = it.newIterator(lst)
while (it.hasNext(iter)):
edge = it.next(iter)
v = e.either(edge)
if (v == vertex):
lt.addLast(lstresp, edge)
return lstresp
except:
return None
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 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 newMap( capacity, prime, comparefunction):
"""
Crea una tabla de hash con capacidad igual a capacity (idealment un numero primo). prime es un número primo utilizado para
el cálculo de los codigos de hash, si no es provisto se utiliza el primo 109345121.
"""
scale = rd.randint(1, prime-1) + 1
shift = rd.randint(1, prime)
table = lt.newList('ARRAY_LIST')
for _ in range(capacity):
entry = me.newMapEntry(None, None)
lt.addLast (table, entry)
hashtable = { 'prime': prime,
'capacity': capacity,
'scale':scale,
'shift':shift,
'table':table,
'comparefunction':comparefunction,
'size':0,
'type':'PROBING'}
return hashtable
def newMap(capacity, prime):
"""
Crea una tabla de hash con capacidad igual a capacity (idealmente un numero primo). prime es un número primo utilizado para
el calculo de los codigos de hash, si no es provisto se utiliza el primo 109345121. Bucket representa
la lista de parejas llave,valor a guardar en cada posición de la tabla de hash.
"""
scale = rd.randint(1, prime - 1) + 1
shift = rd.randint(1, prime)
table = lt.newList('ARRAY_LIST')
for _ in range(capacity):
bucket = lt.newList()
lt.addLast(table, bucket)
hashtable = {
'prime': prime,
'capacity': capacity,
'scale': scale,
'shift': shift,
'table': table,
'size': 0,
'type': 'CHAINING'
}
return hashtable
