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