def findPopularsAdd(analyzer): """ Compara los vertices para buscar los más populares segun su categoria en edad que cumplen los requerimientos para tener publicidad """ mayLst = analyzer["publicity"]["BestPublicity"] catLst = analyzer["publicity"]["ByAges"] for pos in range(1, 8): total = 0 mayCatLst = lt.getElement(mayLst, pos) mayTup = lt.firstElement(mayCatLst) routesMap = lt.getElement(catLst, pos) routesLst = m.keySet(routesMap) routeIterator = it.newIterator(routesLst) while it.hasNext(routeIterator): vert = it.next(routeIterator) routeEntry = m.get(routesMap, vert) timesRoute = me.getValue(routeEntry) total += timesRoute routeTuple = (timesRoute, vert) mayTimes, name = mayTup if mayTimes < timesRoute: size = lt.size(mayCatLst) if size > 1: for i in range(0, size - 1): lt.deleteElement(mayCatLst, 1) lt.changeInfo(mayCatLst, 1, routeTuple) mayTup = routeTuple elif timesRoute == mayTimes: lt.addLast(mayCatLst, routeTuple) lt.addLast(mayCatLst, total) return analyzer
def delMin(heap): """ Retorna el menor elemento del heap y lo elimina. Se reemplaza con el último elemento y se hace sink. Args: heap: El arreglo con la informacion Returns: El menor elemento eliminado Raises: Exception """ try: if (heap['size'] > 0): min = lt.getElement(heap['elements'], 1) last = lt.getElement(heap['elements'], heap['size']) lt.changeInfo(heap['elements'], 1, last) lt.changeInfo(heap['elements'], heap['size'], None) heap['size'] -= 1 sink(heap, 1) return min return None except Exception as exp: error.reraise(exp, 'heap:delMin')
def rehash(map): """ Se aumenta la capacidad de la tabla al doble y se hace rehash de todos los elementos de la tabla. """ try: newtable = lt.newList('ARRAY_LIST', map['comparefunction']) capacity = nextPrime(map['capacity']*2) for _ in range(capacity): entry = me.newMapEntry(None, None) lt.addLast(newtable, entry) oldtable = map['table'] map['size'] = 0 map['currentfactor'] = 0 map['table'] = newtable map['capacity'] = capacity for pos in range(lt.size(oldtable)): entry = lt.getElement(oldtable, pos+1) if (entry['key'] is not None and entry['key'] != '__EMPTY__'): hash = hashValue(map, entry['key']) pos = findSlot(map, entry['key'], hash, map['comparefunction']) lt.changeInfo(map['table'], abs(pos), entry) if (pos < 0): map['size'] += 1 map['currentfactor'] = map['size'] / map['capacity'] return map except Exception as exp: error.reraise(exp, 'Probe:rehash')
def put(map, key, value): """ Ingresa una pareja llave,valor a la tabla de hash. Si la llave ya existe en la tabla, se reemplaza el valor Args: map: El map a donde se guarda la pareja key: la llave asociada a la pareja value: el valor asociado a la pareja Returns: El map Raises: Exception """ try: hash = hashValue(map, key) # Se obtiene el hashcode de la llave entry = me.newMapEntry(key, value) pos = findSlot(map, key, hash, map['comparefunction']) lt.changeInfo(map['table'], abs(pos), entry) if (pos < 0): # Se reemplaza el valor con el nuevo valor map['size'] += 1 map['currentfactor'] = map['size'] / map['capacity'] if (map['currentfactor'] >= map['limitfactor']): rehash(map) return map except Exception as exp: error.reraise(exp, 'Probe:put')
def put(map, key, value): """ Ingresa una pareja llave,valor a la tabla de hash. Si la llave ya existe en la tabla, se reemplaza el valor Args: map: El map a donde se guarda la pareja key: la llave asociada a la pareja value: el valor asociado a la pareja Returns: El map Raises: Exception """ try: hash = hashValue(map, key) bucket = lt.getElement(map['table'], hash) entry = me.newMapEntry(key, value) pos = lt.isPresent(bucket, key) if pos > 0: # La pareja ya exista, se reemplaza el valor lt.changeInfo(bucket, pos, entry) else: lt.addLast(bucket, entry) # La llave no existia map['size'] += 1 map['currentfactor'] = map['size'] / map['capacity'] if (map['currentfactor'] >= map['limitfactor']): rehash(map) return map except Exception as exp: error.reraise(exp, 'Chain:put')
def heapsort(array): size = lt.size(array) for root in range(size // 2 - 1, 0, -1): heapify(array, size, root) for subsize in range(size, 1, -1): oldlast = lt.getElement(array, subsize) newlast = lt.getElement(array, 1) lt.changeInfo(array, 1, oldlast) lt.changeInfo(array, subsize, newlast) heapify(array, subsize, 1)
def addTrending(trending_lista, video): video posvideo = lt.isPresent(trending_lista, video) if posvideo > 0: vid = lt.getElement(trending_lista, posvideo) dias = vid['trending'] dias += 1 vid['trending'] = dias lt.changeInfo(trending_lista, posvideo, vid) else: trending = newTrending(video, trending_lista) lt.addLast(trending_lista, trending)
def exchange(iheap, i, j): """ Intercambia los elementos en las posiciones i y j del heap """ try: element_i = lt.getElement(iheap['elements'], i) element_j = lt.getElement(iheap['elements'], j) lt.changeInfo(iheap['elements'], i, element_j) map.put(iheap['qpMap'], element_i['key'], j) lt.changeInfo(iheap['elements'], j, element_i) map.put(iheap['qpMap'], element_j['key'], i) except Exception as exp: error.reraise(exp, 'indexheap:exchange')
def getMoviesByCountry(catalog, country_name): country = mp.get(catalog['countries'], country_name) if country: result = me.getValue(country) for i in range(1, lt.size(result['movies']) + 1): info = lt.getElement(result['movies'], i) mapKey = mp.get(catalog['directorsIds'], info['elements'][2]) if mapKey: mapValue = me.getValue(mapKey) lt.changeInfo(info, 3, mapValue['director_name']) return result else: return 0
def heapsort(array): #Función que realiza el ordenamiento size = lt.size(array) #Se hace heapify por cada una de las raices que tengan al menos un hijo #Esto nos dará un maxPQ de todo el arreglo for root in range(size // 2, 0, -1): heapify(array, size, root) #Se hace el proceso de reemplazar la raiz del heap por el elemento más a la derecha y luego se asume que el tamaño del heap es 1 elemento más pequeño para que no se tenga en cuenta el elemento ordenado #Nuevamente hace heapify con la nueva raiz para garantizar que sigamos teniendo un maxPQ #Se hace este proceso hasta que quede un heap de tamaño 1, ordenandolo for subsize in range(size, 1, -1): oldlast = lt.getElement(array, subsize) newlast = lt.getElement(array, 1) lt.changeInfo(array, 1, oldlast) lt.changeInfo(array, subsize, newlast) heapify(array, subsize, 1)
def addActor(catalog, pelicula, n): actores = catalog['actores'] if n == 1: actor = pelicula['actor1_name'] elif n == 2: actor = pelicula['actor2_name'] elif n == 3: actor = pelicula['actor3_name'] elif n == 4: actor = pelicula['actor4_name'] else: actor = pelicula['actor5_name'] actor = actor.lower() existeActor = mp.contains(actores, actor) if existeActor: entry = mp.get(actores, actor) act = me.getValue(entry) else: act = newActor(actor) mp.put(actores, actor, act) peliData = me.getValue(mp.get(catalog['id'], pelicula['id'])) lt.addLast(act['peliculas'], peliData['title']) act["calificacion"] += float(peliData['vote_average']) act["size"] += 1 act["promedio"] = round(act["calificacion"] / act["size"], 2) if pelicula['director_name'] == 'none': pass elif lt.size(act['directores']) == 0: lt.addLast(act['directores'], [pelicula['director_name'], 1]) act['mayor director'] = lt.getElement(act['directores'], 1) else: bo = False for i in range(1, lt.size(act['directores']) + 1): if pelicula['director_name'] == lt.getElement( act['directores'], i)[0]: a = lt.getElement(act['directores'], i) lt.changeInfo(act['directores'], i, [a[0], a[1] + 1]) bo = True if lt.getElement(act['directores'], i)[1] > \ act['mayor director'][1]: act['mayor director'] = lt.getElement(act['directores'], i) if not bo: lt.addLast(act['directores'], [pelicula['director_name'], 1])
def getMoviesByDirector(catalog, director_name): director = mp.get(catalog['directors'], director_name) movieavg = 0 if director: result = me.getValue(director) for i in range(1, lt.size(result['movies']) + 1): index = lt.getElement(result['movies'], i) mapKey = mp.get(catalog['moviesIds'], index) if mapKey: mapValue = me.getValue(mapKey) movieavg += float(mapValue['vote_average']) lt.changeInfo(result['movies'], i, mapValue['title']) totalMovies = lt.size(result['movies']) result['vote_average'] = round((movieavg / totalMovies), 5) return (result['movies']['elements'], result['vote_average'], totalMovies) else: return 0
def changeInfo(citibike,lst,pos): """ Intercambia el ID de la estación por su nombre correspondiente """ lstCitibike = citibike['stations'] iterator = it.newIterator(lstCitibike) stationId = lt.getElement(lst,pos) while it.hasNext(iterator): info = it.next(iterator) startStation = info['start station id'] endStation = info['end station id'] if stationId == startStation: stationId = info['start station name'] lt.changeInfo(lst,pos,stationId) break elif stationId == endStation: stationId = info['end station name'] lt.changeInfo(lst,pos,stationId) break
def cluster_mas_grande(self): tamaños = lt.newList(datastructure="ARRAY_LIST") ref = lt.newList(datastructure='ARRAY_LIST') for i in range(self.cluster_number): lt.addLast(tamaños, 0) lt.addLast(ref, 0) vertices = gp.vertices(self.connections_map) vertex_it = ll_it.newIterator(vertices) while ll_it.hasNext(vertex_it): vertex = ll_it.next(vertex_it) cluster = self.vertex_cluster(vertex) new_value = lt.getElement(tamaños, cluster) + 1 lt.changeInfo(tamaños, cluster, new_value) if not lt.getElement(ref, cluster): lt.changeInfo(ref, cluster, vertex) maximo = 0, 0 for i in range(1, self.cluster_number + 1): if maximo[1] < lt.getElement(tamaños, i): maximo = i, lt.getElement(tamaños, i) self.mas_grande = *maximo, lt.getElement(ref, maximo[0])
def heapify(array, size, root): largest = root left = (largest * 2) + 1 right = (largest * 2) + 2 if left < size and lt.getElement(array, largest) < lt.getElement( array, left): largest = left if right < size and lt.getElement(array, largest) < lt.getElement( array, right): largest = right if largest != root: oldroot = lt.getElement(array, root) newroot = lt.getElement(array, largest) lt.changeInfo(array, largest, oldroot) lt.changeInfo(array, root, newroot) heapify(array, size, largest)
def remove(map, key): """ Elimina la pareja llave,valor, donde llave == key. Args: map: El map a donde se guarda la pareja key: la llave asociada a la pareja Returns: El map Raises: Exception """ try: hash = hashValue(map, key) pos = findSlot(map, key, hash, map['comparefunction']) if pos > 0: entry = me.newMapEntry('__EMPTY__', '__EMPTY__') lt.changeInfo(map['table'], pos, entry) map['size'] -= 1 return map except Exception as exp: error.reraise(exp, 'Probe:remove')
def getMoviesByActor(catalog, actor_name): actor = mp.get(catalog['actors'], actor_name) promedio = 0 if actor: r = me.getValue(actor) for i in range(1, lt.size(r['movies']) + 1): index = lt.getElement(r['movies'], i) mapKey = mp.get(catalog['moviesIds'], index) if mapKey: mapValue = me.getValue(mapKey) promedio += float(mapValue['vote_average']) lt.changeInfo(r['movies'], i, mapValue['title']) totalMovies = lt.size(r['movies']) print(promedio) r['vote_average'] = (promedio / totalMovies) return r['movies']['elements'], r['vote_average'], totalMovies else: return -1
def heapify(array, size, root): #Función que se encarga de revisar si los hijos tanto izquierdo como derecho de la raiz son mayores, y en caso de serlo los sube y revisa nuevamente largest = root left = (largest * 2) right = (largest * 2) + 1 #Compara los valored de los hijos con la raiz y asigna el hijo como valor mayor en caso de que se cumpla if left < size and lt.getElement(array, largest) < lt.getElement( array, left): largest = left if right < size and lt.getElement(array, largest) < lt.getElement( array, right): largest = right #Realiza el intercambio del mayor con la raiz en caso de que se necesite y nuevamente realiza la función recursivamente pero con el hijo que reemplazó. if largest != root: oldroot = lt.getElement(array, root) newroot = lt.getElement(array, largest) lt.changeInfo(array, largest, oldroot) lt.changeInfo(array, root, newroot) heapify(array, size, largest)
def increaseKey(iheap, key, newindex): """ Incrementa el indice de un llave Args: iheap: El heap a revisar key: la llave a incrementar newindex: El nuevo indice de la llave Returns: El numero de elementos Raises: Exception """ try: val = map.get(iheap['qpMap'], key) elem = lt.getElement(iheap['elements'], val['value']) elem['index'] = newindex lt.changeInfo(iheap['elements'], val['value'], elem) sink(iheap, val['value']) return iheap except Exception as exp: error.reraise(exp, 'indexheap:increaseKey')
def put(map, key, value): """ Ingresa una pareja llave,valor a la tabla de hash. Si la llave ya existe en la tabla, se reemplaza el valor Args: map: El map a donde se guarda la pareja key: la llave asociada a la pareja value: el valor asociado a la pareja Returns: El map Raises: Exception """ hash = hashValue(map, key) bucket = lt.getElement(map['table'], hash) entry = me.newMapEntry(key, value) pos = lt.isPresent(bucket, key) if pos > 0: # La pareja ya exista, se reemplaza el valor lt.changeInfo(bucket, pos, entry) else: lt.addLast(bucket, entry) # La llave no existia map['size'] += 1 return map
def def_generos(contador, generos, elemento): """ Función que, en el requerimiento 4, determina los rangos de los géneros dados. """ if elemento.lower() == "reggae": nuevo = ["reggae", 60.0, 90.0] elif elemento.lower() == "down-tempo": nuevo = ["down-tempo", 70.0, 100.0] elif elemento.lower() == "chill-out": nuevo = ["chill-out", 90.0, 120.0] elif elemento.lower() == "hip-hop": nuevo = ["hip-hop", 85.0, 115.0] elif elemento.lower() == "jazz and funk": nuevo = ["jazz and funk", 120.0, 125.0] elif elemento.lower() == "pop": nuevo = ["pop", 100.0, 130.0] elif elemento.lower() == "r&b": nuevo = ["r&b", 60.0, 80.0] elif elemento.lower() == "rock": nuevo = ["rock", 110.0, 140.0] elif elemento.lower() == "metal": nuevo = ["metal", 100.0, 160.0] lt.changeInfo(generos, contador, nuevo)
def newUniqueCatalog(catalog): """Genera un nuevo catálogo en el que cada video (por título invidual) solo se incluye una vez.""" unique_dict = {"videos": None} unique_dict["videos"] = {} unique_catalog = lt.newList("ARRAY_LIST") pos = 0 for video in lt.iterator(catalog): pos += 1 try: video_info = unique_dict["videos"][video["title"]] new_day = lt.getElement(video_info, 1) + 1 lt.changeInfo(video_info, 1, new_day) except Exception: unique_dict["videos"][video["title"]] = lt.newList("ARRAY_LIST") lt.addLast(unique_dict["videos"][video["title"]], 1) lt.addLast(unique_dict["videos"][video["title"]], pos) lt.addLast(unique_dict["videos"][video["title"]], video) for i in unique_dict["videos"]: lt.addLast(unique_catalog, unique_dict["videos"][i]["elements"]) return unique_catalog
def mergesort(lst, lessfunction): size = lt.size(lst) if size > 1: mid = (size // 2) """se divide la lista original, en dos partes, izquierda y derecha, desde el punto mid.""" leftlist = lt.subList(lst, 1, mid) rightlist = lt.subList(lst, mid+1, size - mid) """se hace el llamado recursivo con la lista izquierda y derecha""" mergesort(leftlist, lessfunction) mergesort(rightlist, lessfunction) """i recorre la lista izquierda, j la derecha y k la lista original""" i = j = k = 1 leftelements = lt.size(leftlist) rightelements = lt.size(rightlist) while (i <= leftelements) and (j <= rightelements): elemi = lt.getElement(leftlist, i) elemj = lt.getElement(rightlist, j) """compara y ordena los elementos""" if lessfunction(elemj, elemi): # caso estricto elemj < elemi lt.changeInfo(lst, k, elemj) j += 1 else: # caso elemi <= elemj lt.changeInfo(lst, k, elemi) i += 1 k += 1 """Agrega los elementos que no se comprararon y estan ordenados""" while i <= leftelements: lt.changeInfo(lst, k, lt.getElement(leftlist, i)) i += 1 k += 1 while j <= rightelements: lt.changeInfo(lst, k, lt.getElement(rightlist, j)) j += 1 k += 1 return lst
def open_connections(self, filepath: str): self.connections_list = lt.newList(datastructure='ARRAY_LIST') file = open(filepath, 'r') file.readline() line = file.readline() types = line_types(line) lt.changeInfo(types, 5, 'f') lt.changeInfo(types, 6, 's') lt.changeInfo(types, 8, 'f') while line: self.add_connection(line, types) line = file.readline() file.close()
def test_changeInfo_array(altbooks): book10 = {'book_id': '10', 'book_title': 'Title 10', 'author': 'author 10'} lt.changeInfo(altbooks, 1, book10) book = lt.getElement(altbooks, 1) assert book10 == book