def getSeverityByDate(catalog, date):
Año = tree.get(catalog["AccidentsTree"], date, greater)
res = ""
if Año:
Severidades = map.keySet(Año["Severity"])
iterator = it.newIterator(Severidades)
res += "El total de accidentes la fecha " + str(date) + " fue " + str(
lt.size(Año["id"])) + "\n"
while it.hasNext(iterator):
SevKey = it.next(iterator)
res += 'Severidad ' + str(SevKey) + ' : ' + str(
map.get(Año["Severity"], SevKey, compareByKey)) + '\n'
return res
return None
def dfs(self, graph, vert, marked, pre, post, reversepost):
"""
Implementación del recorrido Depth First Search
"""
q.enqueue(pre, vert)
m.put(marked, vert, True)
lstadjacents = g.adjacents(graph, vert)
adjiterator = it.newIterator(lstadjacents)
while it.hasNext(adjiterator):
adjvert = it.next(adjiterator)
if not m.contains(marked, adjvert):
self.dfs(graph, adjvert, marked, pre, post, reversepost)
q.enqueue(post, vert)
s.push(reversepost, vert)
def test_kosaraju(self):
graph = g.newGraph(12, self.comparenames, directed=True)
idscc = m.newMap(12,
maptype='PROBING',
comparefunction=self.comparenames)
pre = q.newQueue()
post = q.newQueue()
reversepost = s.newStack()
marked = m.newMap(12, comparefunction=self.comparenames)
grmarked = m.newMap(12,
maptype='PROBING',
comparefunction=self.comparenames)
grpre = q.newQueue()
grpost = q.newQueue()
grreversepost = s.newStack()
# se inicializa el grafo
self.loadgraph(graph)
self.assertEqual(g.numVertex(graph), 12)
self.assertEqual(g.numEdges(graph), 14)
# Se calcula el grafo reverso de G
greverse = self.reverse(graph)
self.assertEqual(g.numVertex(greverse), 12)
self.assertEqual(g.numEdges(greverse), 14)
# Se recorre el grafor reverso de G, utilizando DepthFirstOrder.
self.dfo(greverse, grmarked, grpre, grpost, grreversepost)
lst = self.lstReversePost(grreversepost)
#lst contiene los vertices retornados por reversepost (G-reverso)
#Se recorre el grafo en el orden dado por reverspost (G-reverso)
iterlst = it.newIterator(lst)
scc = 1
while (it.hasNext(iterlst)):
vert = it.next(iterlst)
if not m.contains(marked, vert):
self.sccCount(graph, vert, marked, idscc, scc)
scc += 1
self.assertTrue(self.stronglyConnected(idscc, 'Pedro', 'Maria'))
self.assertTrue(self.stronglyConnected(idscc, 'Martin', 'Gloria'))
self.assertTrue(self.stronglyConnected(idscc, 'Susana', 'Tere'))
self.assertFalse(self.stronglyConnected(idscc, 'Pedro', 'Gloria'))
self.assertFalse(self.stronglyConnected(idscc, 'Camila', 'Jose'))
self.assertFalse(self.stronglyConnected(idscc, 'Gloria', 'Luz'))
def printTable(self, table):
print('TABLE:')
print('Capacity: ' + str(table['capacity']))
print('Scale: ' + str(table['scale']))
print('Shift: ' + str(table['shift']))
print('Prime: ' + str(table['prime']))
print('Size: ' + str(table['size']))
iterator = it.newIterator(table['table'])
pos = 1
while it.hasNext(iterator):
print("[ " + str(pos) + " ]-->", end="")
entry = it.next(iterator)
print(entry)
pos += 1
def probarOrden(lst):
"""
Revisa que la lista que se pasa por parametro esté en el orden correcto en el cual los libros deberian estar
"""
iterator = it.newIterator(lst)
indice = 0
while it.hasNext(iterator):
element = it.next(iterator)
assert element == lista_ordenada_correcta[indice]
indice += 1
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
def printTitlesDirector(movies):
size = lt.size(movies)
if size:
print('El director tiene las siguientes películas: ')
iterator = it.newIterator(movies)
while it.hasNext(iterator):
movie = it.next(iterator)
print('Titulo: ' + movie['title'] + ' Rating: ' +
movie['vote_average'] + ' (' + movie['vote_count'] +
' votos)')
else:
print('No se encontraron peliculas')
print('\n')
def componentes_conectados(grafo):
counter = 0
vertices = g.vertices(grafo)
graph_iter = it.newIterator(vertices)
m = map.newMap(capacity=10,
maptype='CHAINING',
comparefunction=grafo['comparefunction'])
while (it.hasNext(graph_iter)):
n = it.next(graph_iter)
visited_w = map.get(m, n)
if visited_w == None:
newDFS_2(grafo, n, m)
counter += 1
return counter
def verifySorting(self, lista, compFunction):
iterator = it.newIterator(lista)
count=0
prev_element=None
while it.hasNext(iterator):
element = it.next(iterator)
#result = "".join(str(key) + ": " + str(value) + ", " for key, value in element.items())
#print (result)
if count > 0:
if compFunction(element, prev_element):
return False
count+=1
prev_element=copy.copy(element)
return True
def get_actor_director(search, result, actor):
iterator = it.newIterator(search)
while it.hasNext(iterator):
element = it.next(iterator)
if actor.lower() in element['actor1_name'].lower():
lt.addLast(result, element['director_name'])
elif actor.lower() in element['actor2_name'].lower():
lt.addLast(result, element['director_name'])
elif actor.lower() in element['actor3_name'].lower():
lt.addLast(result, element['director_name'])
elif actor.lower() in element['actor4_name'].lower():
lt.addLast(result, element['director_name'])
elif actor.lower() in element['actor5_name'].lower():
lt.addLast(result, element['director_name'])
def addDirector (catalog, row):
"""
Adiciona un director a la lista de directores
"""
name=row["director_name"]
id_m=row['id']
movie= None
average_vote= None
peliculas= catalog['peliculas_prom']
size = lt.size(peliculas)
iterator = it.newIterator(peliculas)
#encuentra el nombre de la pelicula en la lista de películas a partir de su id
while it.hasNext(iterator) and movie==None:
pelicula = it.next(iterator)
if pelicula['id']==id_m:
movie=pelicula['title']
average_vote=pelicula['vote_average']
#adiciona un director nuevo si no está en la lista de directores o lo actualiza si a está
size = lt.size(catalog['directores'])
repetido= 0
if size:
iterator = it.newIterator(catalog['directores'])
while it.hasNext(iterator):
director = it.next(iterator)
if name == director["name"]:
updateDirector(director, movie, average_vote)
repetido=1
if not(size) or repetido==0:
if float(average_vote)>=6:
positives=1
else:
positives=0
d = newDirector (name, movie, average_vote, positives)
lt.addLast (catalog['directores'], d)
def know_director(director, lst_d, lst_c):
if len(lst_d) == 0:
print('Las listas están vacías')
return 0, 0
else:
t1_start = process_time() # Start time.
all_director_movies, movies_data = (lt.newList('ARRAY_LIST') for _ in range(2))
# Search all director movie ids and add them to a list.
get_director_movie_ids(lst_c, all_director_movies, director)
# Search movies and add vote points to list.
iterator_ids = it.newIterator(all_director_movies)
while it.hasNext(iterator_ids):
movie_id = it.next(iterator_ids)
iterator_movies = it.newIterator(lst_d)
while it.hasNext(iterator_movies):
movie = it.next(iterator_movies)
if movie_id == movie['id']:
lt.addLast(movies_data, movie)
show_movies(movies_data, director)
# Calculate number of movies and total vote average of director.
total_vote_average = movies_total_average(movies_data)
t1_stop = process_time() # Final time.
print('Tiempo de ejecución ', t1_stop - t1_start, ' segundos')
return movies_data['size'], total_vote_average
def componentes_conectados(catalog):
counter = 0
grafo = catalog['non_directed_Graph']
vertices = g.vertices(grafo)
graph_iter = it.newIterator(vertices)
m = map.newMap(capacity=55681,
maptype='CHAINING',
comparefunction=grafo['comparefunction'])
while (it.hasNext(graph_iter)):
n = it.next(graph_iter)
visited_w = map.get(m, n)
if visited_w == None:
dfs.newDFS_2(grafo, n, m)
counter += 1
return counter
def getEdge(graph, vertexa, vertexb):
"""
Retorna el arco asociado a los vertices vertexa ---- vertexb
"""
element = map.get(graph['vertices'], vertexa)
lst = element['value']
itvertex = it.newIterator(lst)
while (it.hasNext(itvertex)):
edge = it.next(itvertex)
if (e.either(edge) == vertexa
or (e.other(edge, e.either(edge)) == vertexa)):
if (e.either(edge) == vertexb
or (e.other(edge, e.either(edge)) == vertexb)):
return edge
return None
def test_randomElements(self):
"""
Lista con elementos en orden aleatorio
"""
self.lst = slt.newList(self.list_type)
slt.addFirst(self.lst, self.book5)
slt.addFirst(self.lst, self.book6)
slt.addFirst(self.lst, self.book3)
slt.addFirst(self.lst, self.book10)
slt.addFirst(self.lst, self.book1)
slt.addFirst(self.lst, self.book2)
slt.addFirst(self.lst, self.book8)
slt.addFirst(self.lst, self.book4)
slt.addFirst(self.lst, self.book7)
slt.addFirst(self.lst, self.book9)
print(
"Testing Random list:----------------------------------------------------"
)
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
print("sorting ....")
sort.selectionSort(self.lst, self.less)
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
def getAccidentByDateSeverity (catalog, date):
"""
Retorna la cantidad de libros para un año y con un rating dado
"""
dateElement = tree.get(catalog['dateTree'], strToDate(date,'%Y-%m-%d') , greater)
response=''
if dateElement:
ratingList = map.keySet(dateElement['severityMap'])
iteraRating=it.newIterator(ratingList)
while it.hasNext(iteraRating):
ratingKey = it.next(iteraRating)
response += ''+str(ratingKey) + ':' + str(map.get(dateElement['severityMap'],ratingKey,compareByKey)) + '\n'
return response
return None
def bfs (search, source):
queue = q.newQueue()
q.enqueue(queue, source)
while not (q.isEmpty(queue)):
v = q.dequeue (queue)
visited_v = map.get(search['visitedMap'], v)['value']
adjs = g.adjacents(search['graph'], v)
adjs_iter = it.newIterator (adjs)
while (it.hasNext(adjs_iter)):
w = it.next (adjs_iter)
print(w)
visited_w = map.get(search['visitedMap'], w)
if visited_w == None:
map.put(search['visitedMap'], w, {'marked':True, 'edgeTo':v})
q.enqueue(queue, w)
def countCC (graph):
counter = 0
listVert = gs.vertices(graph)
if not lt.isEmpty(listVert):
counter = 1
source = lt.firstElement(listVert)
search = newDFS(graph, source)
vert_iter = it.newIterator(listVert)
while (it.hasNext(vert_iter)):
v = it.next (vert_iter)
if not map.get(search['visitedMap'], v):
map.put(search['visitedMap'], v, {'marked':True,'edgeTo':None})
dfs(search, v)
counter+=1
return counter
def countConnectedComponents(catalog):
"""
Retorna la cantidad de componentes conectados de un grafo.
Aquí en necesario usar DFS para saber cuántos están conectados y luego interar sobre este DFS para contarlos¿?
"""
grafo = catalog["flightGraph"]
vertices = g.vertices(grafo)
componentes_conectados = 0
iterator = it.newIterator(vertices)
while it.hasNext(iterator):
element = it.next(iterator)
if g.degree(grafo, element) > 0:
componentes_conectados += 1
return componentes_conectados
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 printBestMoviesDirector(movies, criteria):
size = lt.size(movies)
if size:
print('El director tiene ' + str(size) +
' películas con puntaje promedio igual o mayor a ' +
str(criteria) + ": ")
iterator = it.newIterator(movies)
while it.hasNext(iterator):
movie = it.next(iterator)
print('Titulo: ' + movie['title'] + ' Rating: ' +
movie['vote_average'] + ' (' + movie['vote_count'] +
' votos)')
else:
print('No se encontraron peliculas')
print('\n')
def printProbingTable(self, map):
print('TABLE:')
print('Capacity: ' + str(map['capacity']))
print('Scale: ' + str(map['scale']))
print('Shift: ' + str(map['shift']))
print('Prime: ' + str(map['prime']))
print('size: ' + str(map['size']))
iterator = it.newIterator(map['table'])
pos = 1
while it.hasNext(iterator):
print("[ " + str(pos) + " ]-->", end="")
entry = it.next(iterator)
print(entry, end="")
print("-->", end="")
print("None")
pos += 1
def peliculasPorGenero(lst, criteria):
t1_start = process_time()
votos = 0
cantidad = 0
peliculas = []
i_file = it.newIterator(lst)
while it.hasNext(i_file):
movie = it.next(i_file)
if criteria.lower() in movie["genres"].lower():
votos += int(movie["vote_count"])
cantidad += 1
peliculas.append(movie["original_title"])
promedio = round(votos / cantidad, 2)
t1_stop = process_time()
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
return (peliculas, cantidad, promedio)
def countElementsFilteredByColumn(criteria, column, lst):
if lst['size'] == 0:
print("La lista esta vacía")
return 0
else:
t1_start = process_time() #tiempo inicial
counter = 0
iterator = it.newIterator(lst)
while it.hasNext(iterator):
element = it.next(iterator)
if criteria.lower() in element[column].lower(
): #filtrar por palabra clave
counter += 1
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
return counter
def test_ManyElements():
"""
Con muchos elementos en la lista, en donde identificadores se repiten
Deben aparecer consecutivos aquellos con id igual
"""
lst = slt.newList(list_type)
slt.addFirst(lst, book5)
slt.addFirst(lst, book6)
slt.addFirst(lst, book14)
slt.addFirst(lst, book3)
slt.addFirst(lst, book13)
slt.addFirst(lst, book10)
slt.addFirst(lst, book1)
slt.addFirst(lst, book12)
slt.addFirst(lst, book2)
slt.addFirst(lst, book8)
slt.addFirst(lst, book4)
slt.addFirst(lst, book11)
slt.addFirst(lst, book7)
slt.addFirst(lst, book9)
print(
"Repeated elements:----------------------------------------------------"
)
iterator = it.newIterator(lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
print("sorting ....")
sort.shellSort(lst, less)
assert slt.removeFirst(lst) == book1
assert slt.removeFirst(lst) == book2
assert slt.removeFirst(lst) == book3
assert slt.removeFirst(lst) == book4
assert slt.removeFirst(lst) == book5
assert slt.removeFirst(lst) == book6
assert slt.removeFirst(lst) == book7
assert slt.removeFirst(lst) == book11
assert slt.removeFirst(lst) == book8
assert slt.removeFirst(lst) == book12
assert slt.removeFirst(lst) == book13
assert slt.removeFirst(lst) == book9
assert slt.removeFirst(lst) == book10
assert slt.removeFirst(lst) != book14
def peliculas_por_genero(listagenero, criterio):
pos = lt.isPresent(listagenero, criterio)
if pos == 0:
print(" No se necontro este genero")
return
else:
generos = lt.getElement(listagenero, pos)
lista_peliculas = generos["peliculas"]
itera = it.newIterator(lista_peliculas)
print("Las Peliculas del genero ", criterio, " son:")
while it.hasNext(itera):
pelicula = it.next(itera)
print(pelicula)
print("Numero de peliculas por genero: ", criterio, " es:",
lista_peliculas['size'])
print("El promedio en votos por genero: ", criterio, " es:",
generos['sum_Votos'] / lista_peliculas['size'])
def ranking_peliculas_por_genero(listagenero, columna, orden, cantidad):
columna = int(columna)
orden = int(orden)
cantidad = int(cantidad)
if columna == 1:
colum = "sum_Votos"
lacolumna = "vote_count"
else:
colum = "sum_average"
lacolumna = "vote_averange"
if orden == 1: # de mayor a menor
shell.shellSort1(listagenero, greater, colum)
elgenero = "mejor"
else:
shell.shellSort1(listagenero, less, colum)
elgenero = "peor"
generos = lt.getElement(listagenero, 1)
lista_peliculas = generos["peliculas"]
if len(generos['genero']) == 0:
generos['genero'] = "Sin definir"
print("El genero con ", elgenero, "ranking por ", lacolumna, " es :",
generos['genero'], "\n")
print("las ", cantidad, "primeras peliculas son:")
itera = it.newIterator(lista_peliculas)
i = 1
while it.hasNext(itera):
peli = it.next(itera)
print(peli)
if i >= cantidad:
break
i = i + 1
print("Numero de peliculas por genero ", generos['genero'], " es:",
lista_peliculas['size'])
print("Cantida de votos: ", generos['sum_Votos'])
print("El promedio en votos por genero: ", generos['genero'], " es:",
generos['sum_Votos'] / lista_peliculas['size'])
print("El promedio en ranking por genero: ", generos['genero'], " es:",
generos['sum_average'] / lista_peliculas['size'])
def getBookByYearRating(catalog, year):
"""
Retorna la cantidad de libros por rating para un año
"""
yearElement = tree.get(catalog['yearsTree'], strToDate(year, '%Y'),
greater)
response = ''
if yearElement:
ratingList = map.keySet(yearElement['ratingMap'])
iteraRating = it.newIterator(ratingList)
while it.hasNext(iteraRating):
ratingKey = it.next(iteraRating)
response += 'Rating ' + str(ratingKey) + ':' + str(
map.get(yearElement['ratingMap'], ratingKey,
compareByKey)) + '\n'
return response
return None
def Ranking(column, details, compfunction, elements):
"""
Retorna una lista con cierta cantidad de elementos ordenados por el criterio
"""
t1_start = process_time() #tiempo inicial
copia = lt.subList(details, 1, details["size"])
lt.shellSort(copia, compfunction, column)
iterator = it.newIterator(copia)
ranking = {}
x = 1
while it.hasNext(iterator) and x <= elements:
element = it.next(iterator)
ranking[element.get("original_title")] = element.get(column)
x += 1
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
return ranking
def getPositiveVotes(catalog, directorName):
director = getDirectorInfo(catalog, directorName)
if director:
movies = director['directorMovies']
positivos = 0
size = lt.size(movies)
if size:
iterator = it.newIterator(movies)
while it.hasNext(iterator):
movieTitle = it.next(iterator)
movie = map.get(catalog['moviesMap'], movieTitle, compareByKey)
#print(movie)
if float(movie['vote_average']) >= 6:
positivos += 1
return positivos
return None
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
