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
