def pointsInRange(analyzer, n, in_date, fi_date): arbol=analyzer["arbol_dates"] taxis = lt.newList("ARRAY_LIST",compare) lista=om.values(arbol, in_date, fi_date) if lt.isEmpty(lista): return None iterator=it.newIterator(lista) mapTaxis = m.newMap(100,maptype='CHAINING',loadfactor=5,comparefunction=compareMap) while it.hasNext(iterator): date=it.next(iterator) for i in range(1,lt.size(date)+1): element = lt.getElement(date,i) num,taxiId = element entry = m.get(mapTaxis,taxiId) if entry == None: lt.addLast(taxis, taxiId) m.put(mapTaxis,taxiId,num) else: num2 = entry["value"] numNew = num2 + num entry["value"] = numNew max_pq=hp.newHeap(compare) for j in range (1, lt.size(taxis)+1): taxiId = lt.getElement(taxis,j) points = me.getValue(m.get(mapTaxis,taxiId)) hp.insertMax(max_pq,points, taxiId) lst = max_pq['elements'] size = lt.size(lst) while size>1: lt.exchange(lst,1,size) size -=1 sinksort(lst,1,size) return (lst,lt.size(lst))
def fourthRequirement(analyzer, station, resistencia, resistenciamin): #Se recorren todos los nodos del grafo. grafo = analyzer['graph'] recorrido = m.keySet(dfs.DepthFirstSearch(grafo, station)['visited']) iterator = it.newIterator(recorrido) rutas = lt.newList() while it.hasNext(iterator): element = it.next(iterator) mpa = djk.Dijkstra(grafo, station) if djk.hasPathTo(mpa, element): distance = djk.distTo(mpa, element) if int(distance) <= int(resistencia) and int(distance) >= int( resistenciamin): lt.addLast(rutas, djk.pathTo(mpa, element)) else: a = 1 if lt.isEmpty(rutas): return None return rutas """ distancia=djk.distTo(station,station2) if distancia <= resistencia: add.... """ return None
def addCapitalLandingPoints(analyzer, country): """ Adiciona el punto de conexión de la capital de un país como vértice del grafo, adicionalmente crea un arco entre el vértice capital y los puntos de conexión de dicho país """ countries = analyzer['landingpointsbycountry'] coords = analyzer['landingpointscoords'] name = country['CountryName'] lstlandingpoints = me.getValue(mp.get(countries, str(name))) origin = str(country['CapitalName']) + '-' + name originlat = float(country['CapitalLatitude']) originlon = float(country['CapitalLongitude']) origincoords = originlat, originlon if lt.isEmpty(lstlandingpoints) == False: for landingpoint in lt.iterator(lstlandingpoints): cables = analyzer['cablesbylandingpoint'] lstcables = me.getValue(mp.get(cables, landingpoint)) for cable in lt.iterator(lstcables): destination = landingpoint + '-' + cable destlat = me.getValue(mp.get(coords, landingpoint))[0] destlon = me.getValue(mp.get(coords, landingpoint))[1] distance = hs.haversine((originlat, originlon), (destlat, destlon)) addLandingPoint(analyzer, origin) addCapitalVertexsCoords(analyzer, origin, origincoords) addConnection(analyzer, origin, destination, distance) else: closestlandingpoint = getClosestLandingPoint(analyzer, origincoords)[0] destination = getVertexByLandingPoint(analyzer, closestlandingpoint) distance = getClosestLandingPoint(analyzer, origincoords)[1] addLandingPoint(analyzer, origin) addCapitalVertexsCoords(analyzer, origin, origincoords) addConnection(analyzer, origin, destination, distance)
def connectCLP(catalog): i = 0 mapalp = catalog['info_lp'] grafo = catalog['connections'] listaCLP = catalog['nodos_capitales'] tamano = lt.size(listaCLP) mapa_paises = catalog['countries'] while i < tamano: nodo_capital = lt.getElement(listaCLP, i) pre = nodo_capital.split("*") pais = pre[(len(pre) - 1)] entry_pais = mp.get(mapa_paises, pais) if entry_pais == None: print(pais) minidic = me.getValue(entry_pais) loc_cap = ubicar_capital(minidic) lista = minidic['nodos_asoc'] lta_vacia = lt.isEmpty(lista) if lta_vacia == False: j = 0 tamano2 = lt.size(lista) while j < tamano2: nodo_pais = lt.getElement(lista, j) pre2 = nodo_pais.split("-") lp = pre2[0] loc2 = ubicarLp(lp, mapalp) dist = hs.haversine(loc_cap, loc2) addEdges(grafo, nodo_capital, nodo_pais, dist) j += 1 else: lista_vertices = gr.vertices(grafo) nodocercano = findNearest(lista_vertices, loc_cap, mapalp) if nodocercano[1] != None: addEdges(grafo, nodo_capital, nodocercano[0], nodocercano[1]) i += 1
def ruta_circula(graph, ref_table, tiempo, id_estacion): vertices = gr.vertices(graph) it_vertices = it.newIterator(vertices) list_station = [] while it.hasNext(it_vertices): actual_vertex = it.next(it_vertices) if id_estacion == actual_vertex: confirmador = gr.adjacents(graph, id_estacion) it_confirmador = it.newIterator(confirmador) while it.hasNext(it_confirmador): ad_vertex = it.next(it_confirmador) pt1 = Camino_corto(graph, ad_vertex, id_estacion) if pt1: if not lt.isEmpty(pt1): estacion_final = lt.firstElement(pt1) final = conversor_id_nombre(estacion_final["vertexA"], ref_table) final2 = conversor_id_nombre(estacion_final["vertexB"], ref_table) peso = estacion_final["weight"] list_station.append((final, final2, peso)) for i in list_station: if i[2] > tiempo: list_station.remove(i) return list_station
def getBestMTaxisByRange(analyzer, initDate, finalDate, M): dateslist = om.keys(analyzer['DateIndex'], initDate, finalDate) if lt.isEmpty(dateslist): return 0 iterator = it.newIterator(dateslist) pointdic = {} while it.hasNext(iterator): date = it.next(iterator) dictaxis = me.getValue(om.get(analyzer["DateIndex"], date)) for tid in dictaxis: if tid not in pointdic: pointdic[tid] = { "miles": 0, "total": 0, "services": 0, "points": 0 } pointdic[tid]["miles"] += dictaxis[tid]["miles"] pointdic[tid]["total"] += dictaxis[tid]["total"] pointdic[tid]["services"] += dictaxis[tid]["services"] if pointdic[tid]["total"] != 0: pointdic[tid]["points"] = pointdic[tid]["miles"] * pointdic[ tid]["services"] / pointdic[tid]["total"] qeue = pq.newMinPQ(cmpfunction=compareDegreeMax) for taxi in pointdic: points = pointdic[taxi]["points"] pq.insert(qeue, {"id": taxi, "points": points}) return qeue
def recomendarRutas(analyzer, agerange): ageGraph = crearGrafoEdad(analyzer, agerange) mayorsalida = majorStart(ageGraph["grafo"]) mayordestino = majorDestiny(ageGraph["grafo"]) if mayorsalida == None or mayordestino == None: return "No existen rutas para este rango de edad" else: pesos = lt.newList(datastructure="ARRAY_LIST") pathiterator = it.newIterator(ageGraph["lista"]) while it.hasNext(pathiterator): viaje = it.next(pathiterator) if viaje["start station id"] == mayorsalida and viaje["end station id"] == mayordestino: lt.addLast(pesos, viaje["tripduration"]) if lt.isEmpty(pesos): econ = None else: mrg.mergesort(pesos, lessfunction) econ = lt.firstElement(pesos) sal = m.get(analyzer["nameIndex"], mayorsalida) salnombre = me.getValue(sal) dest = m.get(analyzer["nameIndex"], mayordestino) destnombre = me.getValue(dest) W = {"salida":salnombre, "destino":destnombre, "tiempo":econ} return W
def optionFive(): """ Req C """ centiH = centiM = True while centiH: try: hhI = int(input('Ingrese la hora inferior en el rango\n>')) hhS = int(input('Ingrese la hora superior en el rango\n>')) except ValueError: print('Ingrese valores validos') else: hhI = hhI%24; hhS = hhS%24 hhI, hhS = min(hhI, hhS), max(hhI, hhS) centiH = False while centiM: try: mmI = int(input('Ingrese el minuto inferior en el rango\n>')) mmS = int(input('Ingrese el minuto superior en el rango\n>')) except ValueError: print('Ingrese valores validos') else: mmI = mmI%60; mmS = mmS%60 if hhI == hhS: mmI, mmS = min(mmI, mmS), max(mmI, mmS) centiM = False idCommunityAreaStart = str(float(input('Ingrese la id del area comun de origen\n>'))) idCommunityAreaEnd = str(float(input('Ingrese la id del area comun destino\n>'))) inferior = f'{hhI:02}:{mmI:02}'; superior = f'{hhS:02}:{mmI:02}' print(f'Consiguiendo el mejor horario entre el rango de horas [{inferior}>-<{superior}] para las estaciones [{idCommunityAreaStart}>-<{idCommunityAreaEnd}]') startTime, route, tripDuration = controller.mejorHorario(analyzer, inferior, superior, idCommunityAreaStart, idCommunityAreaEnd) print(f'Hora recomendada de inicio: {startTime}') print(f'Duracion estimada: {tripDuration}') print(f'Por la ruta: \n<') if not(route is None): if not (lt.isEmpty(route)): for i in range(1, lt.size(route)+1): commArea = lt.getElement(route, i) print(f'\t{i}) De {commArea["vertexA"]} a {commArea["vertexB"]}') else: print('\tNo hay estaciones de por medio(B)') else: print('\tNo hay estaciones de por medio(A)') print('>')
def requerimientoB(analyzer, FechaI, FechaF, FechaO): ListaR = op.keys(analyzer["MapaId"], FechaI, FechaF) ListaU = op.keys(analyzer["MapaId"], FechaO, FechaO) if lt.isEmpty(ListaR) == True: OrdenadaR = False else: PuntosR = Rango(ListaR, analyzer, False) OrdenadaR = DiciaLista(PuntosR) if lt.isEmpty(ListaU) == True: OrdenadaU = False else: PuntosU = Rango(ListaU, analyzer, FechaO) OrdenadaU = DiciaLista(PuntosU) ListaFinal = lt.newList("ARRAY_LIST") lt.addFirst(ListaFinal, OrdenadaU) lt.addLast(ListaFinal, OrdenadaR) return ListaFinal
def mvpDia(database, date, n): date = Date.newDate(date) wallets = Analysis.getPoints(database, date) values = [] while (n > len(values)) and (not lt.isEmpty(wallets)): wallet = lt.removeFirst(wallets) values.append((wallet.id, wallet.points)) return values
def mvpRango(database, date1, date2, m): date1 = Date.newDate(date1) date2 = Date.newDate(date2) wallets = Analysis.getPointsV2(database, date1, date2) values = [] while (m > len(values)) and (not lt.isEmpty(wallets)): wallet = lt.removeFirst(wallets) values.append((wallet['id'], wallet['points'])) return values
def parteA_services(DataBase, N): comp = DataBase.getCompanies() values = map.valueSet(comp) sort.mergesort(values, Comparation.compareServices) respuesta = [] while (N > len(respuesta)) and (not lt.isEmpty(values)): company = lt.removeFirst(values) respuesta.append((company.name, company.services)) return respuesta
def test_addFirst(lst, books): assert lt.isEmpty(lst) is True assert lt.size(lst) == 0 lt.addFirst(lst, books[1]) assert lt.size(lst) == 1 lt.addFirst(lst, books[2]) assert lt.size(lst) == 2 book = lt.firstElement(lst) assert book == books[2]
def test_addLast_array(alt, books): assert lt.isEmpty(alt) is True assert lt.size(alt) == 0 lt.addLast(alt, books[1]) assert lt.size(alt) == 1 lt.addLast(alt, books[2]) assert lt.size(alt) == 2 book = lt.firstElement(alt) assert book == books[1] book = lt.lastElement(alt) assert book == books[2]
def sortVideos(value_list, cmp): ''' Esta funcion organiza los videos por la cantidad de likes que tiene el video y retorna la lista ordenada ''' if lt.isEmpty(value_list): newlist = 1 else: newlist = qs.sort(value_list, cmp) return newlist
def GoodVideosByCategoryAndConuntry(compilation): """ busca videos por categoria y país""" for element in range(1, number + 1): video = lt.getElement(compilation, element) print(video["trending_date"] + " " + video["title"] + " " + video["channel_title"] + " " + video["publish_time"] + " " + video["views"] + " " + video["likes"] + " " + video["dislikes"]) if lt.isEmpty(compilation): print("No se encontraron videos")
def getMaxReps(sublista): if not lt.isEmpty(sublista): maximo_valor = 0 maximo_apuntador = lt.firstElement(sublista) for video in lt.iterator(sublista): if video['repeticiones'] >= maximo_valor: maximo_valor = video['repeticiones'] maximo_apuntador = video return maximo_apuntador else: return None
def if_add_video_req(video, top, k: int, n: int): min_top = None if not lt.isEmpty(top): min_top = lt.firstElement(top) if not min_top: lt.addFirst(top, video) # ... or likesVideo > likesMinTop: elif lt.size(top) < n or lt.getElement(video[0], k) > lt.getElement( min_top[0], k): add_to_top(video, top, k) if lt.size(top) > n: lt.removeFirst(top)
def isEmptyCatalog(lst): """ Indica si la lista está vacía Args: lst: La lista a examinar Raises: Exception """ try: return lt.isEmpty(lst) except Exception as exp: error.reraise(exp, 'TADList->isEmpty: ')
def test_insertElement_array(alt, books): assert lt.isEmpty(alt) is True assert lt.size(alt) == 0 lt.insertElement(alt, books[0], 1) assert lt.size(alt) == 1 lt.insertElement(alt, books[1], 2) assert lt.size(alt) == 2 lt.insertElement(alt, books[2], 1) assert lt.size(alt) == 3 book = lt.getElement(alt, 1) assert book == books[2] book = lt.getElement(alt, 2) assert book == books[0]
def getDateMoreAccidentsByRange(analyzer,initialDate, finalDate): keys=om.keys(analyzer['dateIndex'],initialDate, finalDate) value="" if not lt.isEmpty(keys): big=0 for i in range(1,lt.size(keys)+1): key=lt.getElement(keys, i) accidentdate=getaccident(analyzer['dateIndex'],key) size=lt.size(accidentdate) if size>big: big=size value=key return value
def Function2(controller, time1, time2, stationid): station2 = input("a que estación quiere dirigirse? ") #CICLO road = djk.Dijkstra(controller["graph"], stationid) caminoida = djk.pathTo(road, station2) retorno = djk.Dijkstra(controller["graph"], station2) caminovuelta = djk.pathTo(retorno, stationid) cam1 = djk.distTo(road, station2) cam2 = djk.distTo(retorno, stationid) if lt.isEmpty(caminovuelta) or lt.isEmpty(caminoida): print("no hay camino conectado de " + stationid + " a " + station2) return lt.newList(datastructure='SINGLE_LINKED', cmpfunction=None) else: if (cam1 + ((int(djk.pathTo(road, station2)['size']) * 20))) + (cam2 + ( (int(djk.pathTo(retorno, stationid)['size']) * 20))) in range( time1, time2): print(djk.pathTo(road, station2)) print(djk.pathTo(retorno, stationid)) return ("se encontró el siguiente camino de ida y vuelta") else: print( "se encontró un camino, pero esta fuera de los parametros establecidos." ) return lt.newList(datastructure='SINGLE_LINKED', cmpfunction=None) #CICLO tup = (caminoida, caminovuelta) return tup
def getMoviesByGenre(catalog, producername): lst = mp.keySet(catalog['genres']) iterator = li.newIterator(lst) lista_producers = lt.newList() while li.hasNext(iterator): element = li.next(iterator) if producername.lower() in element.lower(): producer = mp.get(catalog['genres'], element) if producer: #return me.getValue(producer) lt.addLast(lista_producers, me.getValue(producer)) if lt.isEmpty(lista_producers): return None return lista_producers
def isEmpty(queue): """Informa si la cola es vacía o no Args: queue: La cola a examinar Returns: True si la cola es vacia, False de lo contrario Raises: Exception """ try: return lt.isEmpty(queue) except Exception as exp: error.reraise(exp, 'TADQueue->isEmpty: ')
def f4(cont,s1,tMIN,tMAX): cola = qe.newQueue() qe.enqueue(cola,"Nota: se parte del supuesto de que un turista toma 20 minutos conociendo los alrededores en cada parada.") listaCand = model.CandidatasCirculares(cont,s1) if lt.isEmpty(listaCand): qe.enqueue(cola,"No se encontraron rutas.") return cola listaFinal = model.buscarEstaciónesFinales(cont,s1,listaCand) if lt.isEmpty(listaFinal): qe.enqueue(cola,"No se encontraron rutas.") return cola qe.enqueue(cola,"Se encontraron las siguientes rutas: ") iterador = it.newIterator(listaFinal) C = True while C: dixx = it.next(iterador) llave = list(dixx.keys())[0] valor = list(dixx.values())[0] tupla = model.CostoMinimoCircular(cont,s1,llave,valor) if (tMIN*60)<tupla[1]<(tMAX*60): qe.enqueue(cola,(tupla[0] + " , duración esperada en minutos: " + str(round(tupla[1]/60)) )) if not it.hasNext(iterador): C = False return cola
def addTrackHashtag(map, song): pista = song['track_id'] existpista = mp.contains(map, pista) if existpista: entry = mp.get(map, pista) ltpista = me.getValue(entry) else: ltpista = lt.newList('ARRAY_LIST') mp.put(map, pista, ltpista) if lt.isEmpty(ltpista): lt.addLast(ltpista, song['hashtag'].lower()) else: exist = lt.isPresent(ltpista, song['hashtag'].lower()) if exist == 0: lt.addLast(ltpista, song['hashtag'].lower())
def lporcategoria(ID, lista): """Crea una lista de videos de la categoría requerida ID(int): ID de la categoría de los videos a seleccionar lista: lista general retorna: lista: con sólo los elementos que cumplen con los parámetros""" final = lt.newList(datastructure='ARRAY_LIST') i = it.newIterator(lista) while it.hasNext(i): v = it.next(i) if v['category_id'] == ID: lt.addFirst(final, v) if lt.isEmpty(final) == True: return None else: return final
def isEmpty(stack): """Informa si la pila es vacía o no Args: stack: La pila a examinar Returns: True si la pila es vacia False de lo contrario Raises: Exception """ try: return lt.isEmpty(stack) except Exception as exp: error.reraise(exp, 'TADStack->isEmpty: ')
def requerimiento4(time, InitialS, citibike): time = int(time) #Cambio S-M listD = gr.vertices(citibike["graph"]) Recorrido = dfs.DepthFirstSearch(citibike["graph"], InitialS) ListaPilas = lt.newList('SINGLE_LINKED', compareIds) for i in range(1, lt.size(listD) + 1): vertice2 = lt.getElement(listD, i) if dfs.pathTo(Recorrido, vertice2) and InitialS != vertice2: Pila = dfs.pathTo(Recorrido, vertice2) lt.addLast(ListaPilas, Pila) ## Se buscan los Vertices que se conecten a Initial S listadeciclos = lt.newList('SINGLE_LINKED', compareIds) for r in range(1, lt.size(ListaPilas) + 1): listanueva = lt.newList('SINGLE_LINKED', compareIds) pila = lt.getElement(ListaPilas, r) for j in range(1, stack.size(pila) + 1): k = stack.pop(pila) lt.addLast(listanueva, k) lt.addLast(listadeciclos, listanueva) listaF = lt.newList('SINGLE_LINKED', compareIds) for i in range(1, lt.size(listadeciclos) + 1): EstacionesI = 0 Viaje = lt.newList('SINGLE_LINKED', compareIds) ciclo = lt.getElement(listadeciclos, i) peso = 0 for j in range(1, lt.size(ciclo)): verticeA = lt.getElement(ciclo, j) Ultimo = lt.lastElement(ciclo) verticeB = lt.getElement(ciclo, (j + 1)) arco = gr.getEdge(citibike["graph"], verticeA, verticeB) EstacionesI += 1 peso += int(arco["weight"]) lt.addLast(Viaje, EstacionesI) lt.addLast(Viaje, Ultimo) peso = peso / 60 lt.addLast(Viaje, peso) if peso <= time: lt.addLast(listaF, Viaje) if lt.isEmpty(listaF): return False else: return listaF
def lporcyp(ID, pais, lista): """Crea una lista de videos de la categoría y el país requeridos ID(int): ID de la categoría de los videos a seleccionar pais(str): país de los videos a seleccionar lista: lista general retorna: lista: con sólo los elementos que cumplen con los parámetros""" v = it.newIterator(lista) final = lt.newList(datastructure='ARRAY_LIST') while it.hasNext(v): x = it.next(v) if x['country'] == pais and x['category_id'] == ID: lt.addLast(final, x) if lt.isEmpty(final) == True: return None else: return final