def CompaniesInfo(catalog, criteria1, criteria2):
"""
Proyecto Final | Req 1
Retorna:
Número total de taxis reportados.
Número total de compañías.
TOP X compañías con más taxis afiliados.
TOP Y compañías con más servicios prestados.
"""
companies_lt = m.keySet(catalog['Companies_Map'])
num_companies = lt.size(companies_lt)
moreCabs = lt.newList(datastructure='ARRAY_LIST', cmpfunction=None)
moreServices = lt.newList(datastructure='ARRAY_LIST', cmpfunction=None)
iterator = it.newIterator(companies_lt)
while it.hasNext(iterator):
company_name = it.next(iterator)
company = m.get(catalog['Companies_Map'], company_name)
lt.addLast(moreCabs, company)
lt.addLast(moreServices, company)
mg.mergesort(moreCabs, greaterNumCabs)
mg.mergesort(moreServices, greaterNumServices)
TOPNumCabs = lt.subList(moreCabs, 1, criteria1)
TOPNumServices = lt.subList(moreServices, 1, criteria2)
return catalog['Num_Total_Cabs'], num_companies, TOPNumCabs, TOPNumServices
def reportegeneral(analyzer, parametrom, parametron):
listaviajes = analyzer["lista"]
lista = []
companias = []
for i in range(lt.size(listaviajes) + 1):
taxiid = lt.getElement(listaviajes, i)["taxi_id"]
compania = lt.getElement(listaviajes, i)["company"]
if compania == "":
compania = "independent owner"
if compania not in companias:
companias.append(compania)
if taxiid not in lista:
lista.append(taxiid)
addCompany(analyzer, compania, taxiid, lt.getElement(listaviajes, i))
addtaxid(analyzer, taxiid)
rankingm = lt.newList("ARRAY_LIST")
rankingn = lt.newList("ARRAY_LIST")
for i in companias:
compania = m.get(analyzer["mapcompany"], i)
lt.addLast(rankingm, compania)
lt.addLast(rankingn, compania)
mg.mergesort(rankingm, greater_company)
mg.mergesort(rankingn, greater_company_taxis)
rankingm = lt.subList(rankingm, 1, parametrom + 1)
rankingn = lt.subList(rankingn, 1, parametron + 1)
return len(lista), len(companias), rankingm, rankingn
def consulta2(Inite, fecha_ini, fecha_fin, top2):
fecha_fin = transformador_fecha(fecha_fin)
fecha_ini = transformador_fecha(fecha_ini)
datos_entre_medio = om.values(Inite["mapa_fecha"], fecha_ini, fecha_fin)
mapa_intermedio = m.newMap(maptype="PROBING",
comparefunction=compareStationsv2)
for i in range(1, lt.size(datos_entre_medio) + 1):
lista = lt.getElement(datos_entre_medio, i)
lista = m.valueSet(lista)
for e in range(1, lt.size(lista) + 1):
elemento = lt.getElement(lista, e)
existe = m.get(mapa_intermedio, elemento["taxi"])
if existe is None:
m.put(mapa_intermedio, elemento["taxi"], elemento)
else:
nodo_new = incrementalV3(me.getValue(existe), elemento)
m.put(mapa_intermedio, nodo_new["taxi"], nodo_new)
top_2 = lt.newList("ARRAY_LIST")
mapa_intermedio_ordenado = m.valueSet(mapa_intermedio)
mergesort.mergesort(mapa_intermedio_ordenado,
comparador_ascendente) # SHELLSORT
for i in range(1, lt.size(mapa_intermedio_ordenado) + 1):
elemento = lt.getElement(mapa_intermedio_ordenado, i)
lt.addLast(top_2, elemento)
if i == top2:
break
return top_2
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 Req1RepInfo(chicagoAnalyzer, mTop, nTop):
if 0 in {mTop, nTop}: return 0
totalTaxi = m.size(chicagoAnalyzer['taxi'])
totalCompany = m.size(chicagoAnalyzer['company'])
topMCompanyTaxi = lt.newList(datastructure='ARRAY_LIST')
topNCompanyService = lt.newList(datastructure='ARRAY_LIST')
#Obtener taxis por compania
ltCompany = m.keySet(chicagoAnalyzer['company'])
for company in range(lt.size(ltCompany)):
size = m.get(chicagoAnalyzer['company'],
lt.getElement(ltCompany, company))['value']
lt.addLast(topMCompanyTaxi,
(lt.getElement(ltCompany, company), lt.size(size)))
count = 0
for idTaxi in range(lt.size(size)):
infoT = m.get(chicagoAnalyzer['taxi'],
lt.getElement(size, idTaxi))['value']
count += m.get(infoT, 'numServices')['value']
lt.addLast(topNCompanyService,
(lt.getElement(ltCompany, company), count))
ms.mergesort(topMCompanyTaxi, comparePoints)
ms.mergesort(topNCompanyService, comparePoints)
return totalTaxi, totalCompany, lt.subList(topMCompanyTaxi, 1,
mTop)['elements'], lt.subList(
topNCompanyService, 1,
nTop)['elements']
def getBestTime(database: DataBase, area1: str, area2: str, time1,
time2) -> dict:
route = database.getRoute(area1, area2).getRoute()
route = orderedmap.values(route, time1, time2)
sort.mergesort(route, cmp.trip)
trip = list.removeFirst(route)
return (trip.seconds, trip.time)
def req1_return(Inite, ranking1, ranking2):
companies_orden = m.valueSet(Inite["mapa_companies"])
services_orden = m.valueSet(Inite["mapa_companies"])
mergesort.mergesort(services_orden,
comparador_ascendente_services) # SHELLSORT
mergesort.mergesort(companies_orden,
comparador_ascendente_taxis) # SHELLSORT
cantidad_compañias_taxi = m.size(Inite["mapa_companies"])
top1 = lt.newList("ARRAY_LIST")
top2 = lt.newList("ARRAY_LIST")
for i in range(1, lt.size(companies_orden) + 1):
elemento = lt.getElement(companies_orden, i)
lt.addLast(top1, elemento)
if i == ranking1:
break
for i in range(1, lt.size(services_orden) + 1):
elemento = lt.getElement(services_orden, i)
lt.addLast(top2, elemento)
if i == ranking2:
break
return {
"ranking1": top1,
"ranking2": top2,
"compañias taxi": cantidad_compañias_taxi,
"total taxis": len(Inite["Taxis sin repetir"]),
}
def parteA_consulta(inicial, rankingM, rankingN):
orden_compañias = m.valueSet(inicial["compañias"])
compañias_servicios_ordenados = m.valueSet(inicial["compañias"])
mergesort.mergesort(orden_compañias, comparador_de_taxis)
mergesort.mergesort(compañias_servicios_ordenados, comparador_de_servicios)
numero_compañias = m.size(inicial["compañias"])
topM = lt.newList("ARRAY_LIST")
topN = lt.newList("ARRAY_LIST")
cuantas_tengoM = 1
while cuantas_tengoM <= rankingM:
elemento_agregar = lt.getElement(orden_compañias, cuantas_tengoM)
lt.addLast(topM, elemento_agregar)
cuantas_tengoM += 1
cuantas_tengoN = 1
while cuantas_tengoN <= rankingN:
elemento_agregar = lt.getElement(compañias_servicios_ordenados,
cuantas_tengoN)
lt.addLast(topN, elemento_agregar)
cuantas_tengoN += 1
return (topM, topN, numero_compañias, len(inicial["taxis"]))
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 criticStations(citibike):
"""
Top 3 Llegada, Top 3 Salida y Top 3 menos usadas
Req 3
"""
#Listas respuesta
topLlegada = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareroutes)
topSalida = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareroutes)
intopUsadas = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareroutes)
#Listas temporales para obtener el top 3
top3LS = lt.newList(datastructure='ARRAY_LIST', cmpfunction=compareroutes)
inTop3 = lt.newList(datastructure='ARRAY_LIST', cmpfunction=compareroutes)
tempLT = lt.newList(cmpfunction=compareroutes)
ltKeys = gr.edges(citibike['connections'])
for arc in range(1, lt.size(ltKeys) + 1):
lt.addLast(tempLT, lt.getElement(ltKeys, arc)['count'])
ms.mergesort(tempLT, greatequal)
for i in range(1, 10):
lt.addLast(top3LS, lt.getElement(tempLT, i))
for i in range(3):
lt.addLast(inTop3, lt.getElement(tempLT, lt.size(tempLT) - i))
vxl = 1
while vxl <= lt.size(tempLT) and lt.size(topLlegada) <= 3:
if lt.isPresent(top3LS, lt.getElement(ltKeys, vxl)['count']):
vxA = getStation(citibike,
lt.getElement(ltKeys, vxl)['vertexA'])[1]
if not lt.isPresent(topLlegada, vxA):
lt.addLast(topLlegada, vxA)
vxl += 1
vxs = 1
while vxs <= lt.size(tempLT) and lt.size(topSalida) <= 3:
if lt.isPresent(top3LS, lt.getElement(ltKeys, vxs)['count']):
vxB = getStation(citibike,
lt.getElement(ltKeys, vxs)['vertexB'])[1]
if not lt.isPresent(topLlegada, vxB):
lt.addLast(topSalida, vxB)
vxs += 1
vxin = 1
while vxin <= lt.size(tempLT) and lt.size(intopUsadas) <= 3:
if lt.isPresent(inTop3, lt.getElement(ltKeys, vxin)['count']):
vxA = getStation(citibike,
lt.getElement(ltKeys, vxin)['vertexA'])[1]
if not lt.isPresent(intopUsadas, vxA):
lt.addLast(intopUsadas, vxA)
vxin += 1
return topLlegada, topSalida, intopUsadas
def top_servcios(catalogo):
llaves=m.keySet(catalogo["lista_compañias"])
ite=it.newIterator(llaves)
lista=lt.newList(datastructure='SINGLE_LINKED', cmpfunction=None)
while it.hasNext(ite):
llave=it.next(ite)
pareja=m.get(catalogo["lista_compañias"],llave)
lt.addLast(lista,pareja)
mer.mergesort(lista,comparar_data_servicios)
return lista
def DiciaLista(PuntosR):
ListaStr = lt.newList("ARRAY_LIST")
ListaL = m.keySet(PuntosR)
for i in range(1 + lt.size(ListaL)):
Llave = lt.getElement(ListaL, i)
Valor = m.get(PuntosR, Llave)
Valor = Valor["value"]
Str = str(Llave) + str("_: ") + str(Valor)
lt.addLast(ListaStr, Str)
mg.mergesort(ListaStr, GreaterTaxis)
return ListaStr
def topTarget(dataBase: dict, target: int) -> list:
targetGraph = dataBase['target']
targetList = list.newList()
if map.contains(targetGraph, target):
targetGraph = map.get(targetGraph, target)
targetGraph = mapentry.getValue(targetGraph)
targetList = graph.edges(targetGraph)
mergesort.mergesort(targetList, Comparation.targetVal)
return targetList
def parteA4(analyzer):
lista = lt.newList()
companies = m.keySet(analyzer['companyByTrips'])
iterator = it.newIterator(companies)
while it.hasNext(iterator):
company = it.next(iterator)
value = m.get(analyzer['companyByTrips'], company)['value']
size = m.size(value)
data = {'key': company, 'value': size}
lt.addLast(lista, data)
ms.mergesort(lista, compareTripsValues)
return lista
def consulta_parteBA(inicial, fecha, top):
fecha = datetime.datetime.strptime(fecha, "%Y-%m-%d")
fecha = fecha.date()
mapa_taxi = me.getValue(om.get(inicial["fechas"], fecha))
final = lt.newList("ARRAY_LIST")
lst = m.valueSet(mapa_taxi)
mergesort.mergesort(lst, comparador_puntos)
cuantas_tengo = 1
while cuantas_tengo <= top:
elemento_agregar = lt.getElement(lst, cuantas_tengo)
lt.addLast(final, elemento_agregar)
cuantas_tengo += 1
return final
def consulta_puntos_PROV(Inite, fecha, top):
fecha = transformador_fecha(fecha)
mapa = me.getValue(om.get(Inite["mapa_fecha"], fecha))
top_final = lt.newList("ARRAY_LIST")
lista_ordenada = m.valueSet(mapa)
mergesort.mergesort(lista_ordenada, comparador_ascendente) # SHELLSORT
for i in range(1, lt.size(lista_ordenada) + 1):
a_ver = lt.getElement(lista_ordenada, i)
lt.addLast(top_final, a_ver)
if i == top:
break
return top_final
def getToStationFromCoordinates(citibike, Lat1, Lon1, Lat2, Lon2):
"""
RETO4 | REQ 6
Dada una latitud y longitud inicial,
se halla la estación de Citibike más cercana.
Dada una coordenada de destino, se halla
la estación de Citibike más cercana.
Se calcula la ruta de menor tiempo entre estas
dos estaciones.
"""
stations_keys = m.keySet(citibike['Edges_Map'])
initialStationSortedByDistance = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareValues)
finalStationSortedByDistance = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareValues)
iterator = it.newIterator(stations_keys)
while it.hasNext(iterator):
station = it.next(iterator)
sta = m.get(citibike['Edges_Map'], station)
staLat = float(sta['value']['Latitude'])
staLon = float(sta['value']['Longitude'])
distance_from_initial_point = distanceFromTo(Lat1, staLat, Lon1,
staLon)
distance_from_final_point = distanceFromTo(Lat2, staLat, Lon2, staLon)
sta['value']['Distance_From_Initial_Point'] = round(
distance_from_initial_point, 5)
sta['value']['Distance_From_Final_Point'] = round(
distance_from_final_point, 5)
lt.addLast(initialStationSortedByDistance, sta)
lt.addLast(finalStationSortedByDistance, sta)
mg.mergesort(initialStationSortedByDistance, closerInitialStation)
mg.mergesort(finalStationSortedByDistance, closerFinalStation)
CloserStation1 = lt.lastElement(initialStationSortedByDistance)
CloserStation2 = lt.lastElement(finalStationSortedByDistance)
paths = djk.Dijkstra(citibike['graph'], CloserStation1['key'])
pathTo = djk.pathTo(paths, CloserStation2['key'])
cost = djk.distTo(paths, CloserStation2['key'])
return CloserStation1, CloserStation2, pathTo, cost
def puntosPorRangoFecha(analyzer, fecha1, fecha2, numero):
fecha1 = datetime.datetime.strptime(fecha1, '%Y-%m-%d').date()
fecha2 = datetime.datetime.strptime(fecha2, '%Y-%m-%d').date()
lstValores = om.values(analyzer['mapaTaxi'], fecha1, fecha2)
nueva_lista = lt.newList('SINGLE_LINKED', compararTaxi)
itera = it.newIterator(lstValores)
while (it.hasNext(itera)):
elemto = it.next(itera)
lista = elemto['lstidtaxi']
itera2 = it.newIterator(lista)
while (it.hasNext(itera2)):
valor = it.next(itera2)
id_taxi = valor['idtaxi']
puntos = valor["puntos"]
pos = lt.isPresent(nueva_lista, id_taxi)
if pos == 0:
salida = {"idtaxi": None, "puntos": None}
salida["idtaxi"] = id_taxi
salida["puntos"] = puntos
lt.addLast(nueva_lista, salida)
else:
salida = lt.getElement(nueva_lista, pos)
salida["puntos"] = salida["puntos"] + puntos
#ordenar lista de salida
merSort.mergesort(nueva_lista, compararvalores)
itera = it.newIterator(nueva_lista)
i = 1
resultado = []
while (it.hasNext(itera)):
valor = it.next(itera)
salida = {}
salida['Taxi'] = valor['idtaxi']
salida['puntos'] = valor['puntos']
resultado.append(salida)
if i >= numero:
break
i = i + 1
return resultado
def para_mantenimiento(citibike, fecha, ide):
fecha = str_to_python_time(fecha)
arbol = om.get(citibike["mapa_fecha"], fecha)
arbol = me.getValue(arbol)
mapa = m.get(arbol, ide)
grafo = me.getValue(mapa)
arcos = gr.edges(grafo)
horas_organizadas = lt.newList("ARRAY_LIST")
camino_organizado = lt.newList("ARRAY_LIST")
for i in range(1, lt.size(arcos) + 1):
elemento = lt.getElement(arcos, i)
corre_hora = str(elemento["inicio"])
corre_hora = datetime.datetime.strptime(corre_hora, "%H:%M:%S.%f")
corre_hora = datetime.datetime.time(corre_hora)
lt.addLast(horas_organizadas, corre_hora)
mge.mergesort(horas_organizadas, comparador_horas)
for i in range(1, lt.size(horas_organizadas) + 1):
hora = lt.getElement(horas_organizadas, i)
for e in range(1, lt.size(arcos) + 1):
arco = lt.getElement(arcos, e)
corre_hora = str(arco["inicio"])
corre_hora = datetime.datetime.strptime(corre_hora, "%H:%M:%S.%f")
corre_hora = datetime.datetime.time(corre_hora)
arco["inicio"] = corre_hora
if corre_hora == hora:
lt.addLast(camino_organizado, arco)
for i in range(1, lt.size(camino_organizado) + 1):
elemento = lt.getElement(camino_organizado, i)
if i == 1:
parqueada = conver_to_seconds(elemento["inicio"])
usada = conver_to_seconds(elemento["final"]) - conver_to_seconds(
elemento["inicio"])
else:
usada += conver_to_seconds(elemento["final"]) - conver_to_seconds(
elemento["inicio"])
parqueada += conver_to_seconds(
elemento["inicio"]) - conver_to_seconds(
(lt.getElement(camino_organizado, i - 1))["final"])
if i == lt.size(camino_organizado):
resta = conver_to_seconds("23:59:59")
parqueada += resta - conver_to_seconds(elemento["final"])
return (usada, parqueada, camino_organizado)
def buscar_estaciones_top_ingreso(graph, reference_table):
""""Funcion para hallar los viajes que llegan a una estacion!"""
estaciones = lt.newList()
vertices = gr.vertices(graph)
it_vertice = it.newIterator(vertices)
while it.hasNext(it_vertice):
vert = it.next(it_vertice)
estacion = gr.indegree(graph, vert)
nombre = conversor_id_nombre(vert, reference_table)
lt.addLast(estaciones, (estacion, nombre))
merge.mergesort(estaciones, lessFunction)
final_top = []
for i in range(3):
top = lt.lastElement(estaciones)
final_top.append(top)
lt.removeLast(estaciones)
return final_top
def buscar_estaciones_peor_top(graph, reference_table):
""""Funcion para hallar los viajes que llegan a una estacion!"""
estaciones = lt.newList()
vertices = gr.vertices(graph)
it_vertice = it.newIterator(vertices)
while it.hasNext(it_vertice):
vert = it.next(it_vertice)
estacion = gr.indegree(graph, vert)
estacion += gr.outdegree(graph, vert)
lt.addLast(estaciones, (estacion, vert))
merge.mergesort(estaciones, lessFunction)
final_top = []
for i in range(3):
top = lt.firstElement(estaciones)
nombre = conversor_id_nombre(top[1], reference_table,
"end station name")
final_top.append((top[0], nombre))
lt.removeFirst(estaciones)
return final_top
def EstaciónMasProxima(latO, lonO, analyzer):
idynombre = []
prox = lt.newList(datastructure="ARRAY_LIST", cmpfunction=comparador)
Index = analyzer["index"]
A = m.keySet(Index)
a = it.newIterator(A)
while it.hasNext(a):
B = it.next(a)
C = m.get(Index, B)
B = me.getValue(C)
latitud = B["start station latitude"]
longitud = B["start station longitude"]
distancia = ha.haversine(float(lonO), float(latO), float(longitud), float(latitud))
B["Distancia al punto"] = distancia
lt.addLast(prox, B)
merge.mergesort(prox, MasProximo)
resultado = lt.firstElement(prox)
idynombre.append(resultado["start station name"])
idynombre.append(resultado["start station id"])
return idynombre
def topViajes(dataBase) -> tuple:
stations = dataBase['station']
topIn = list.newList()
topOut = list.newList()
topTrips = list.newList()
keys = map.keySet(stations)
keys = listiterator.newIterator(keys)
while listiterator.hasNext(keys):
key = listiterator.next(keys)
station = map.get(stations, key)
station = mapentry.getValue(station)
list.addFirst(topIn, {
'station': station['name'],
'value': station['tripsIn']
})
list.addFirst(topOut, {
'station': station['name'],
'value': station['tripsOut']
})
list.addFirst(topTrips, {
'station': station['name'],
'value': station['trips']
})
mergesort.mergesort(topIn, Comparation.tripsVal)
mergesort.mergesort(topOut, Comparation.tripsVal)
mergesort.mergesort(topTrips, Comparation.tripsVal)
return (topIn, topOut, topTrips)
def parteB_consultaB(inicial, fecha_ini, fecha_fin, topN):
fecha_fin = datetime.datetime.strptime(fecha_fin, "%Y-%m-%d")
fecha_fin = fecha_fin.date()
fecha_ini = datetime.datetime.strptime(fecha_ini, "%Y-%m-%d")
fecha_ini = fecha_ini.date()
datos_mitad = om.values(inicial["fechas"], fecha_ini, fecha_fin)
datos = m.newMap(maptype="PROBING", comparefunction=compararEstacions2)
for dic in range(1, lt.size(datos_mitad) + 1):
lista = lt.getElement(datos_mitad, dic)
lista = m.valueSet(lista)
for ele in range(1, lt.size(lista) + 1):
dato = lt.getElement(lista, ele)
obtenido = m.get(datos, dato["taxi"])
if obtenido == None:
m.put(datos, dato["taxi"], dato)
else:
obtenido = me.getValue(obtenido)
nodo_antes_servicio = obtenido["puntos"] / obtenido["servicios"]
nodo_ahora_servicio = dato["puntos"] / dato["servicios"]
nuevo = nodo_ahora_servicio + nodo_antes_servicio
nuevo *= (obtenido["servicios"] + dato["servicios"])
nuevo_nodo = {
"taxi": obtenido["taxi"],
"puntos": nuevo,
"servicios": obtenido["servicios"] + dato["servicios"]
}
m.put(datos, nuevo_nodo["taxi"], nuevo_nodo)
list_final = lt.newList("ARRAY_LIST")
ordenado = m.valueSet(datos)
mergesort.mergesort(ordenado, comparador_puntos)
for dato_ in range(1, lt.size(ordenado) + 1):
candidato = lt.getElement(ordenado, dato_)
lt.addLast(list_final, candidato)
if dato_ == topN:
break
return list_final
def hallarTop(tabla, numero):
taxis = m.keySet(tabla)
puntos = m.valueSet(tabla)
mrg.mergesort(puntos, lessfunction)
listaOrd = lt.newList(datastructure="ARRAY_LIST")
i = 0
while i < numero:
F = lt.lastElement(puntos)
lt.addLast(listaOrd, F)
lt.removeLast(puntos)
i += 1
listaTaxis = lt.newList(datastructure="ARRAY_LIST")
itelistapuntos = it.newIterator(listaOrd)
while it.hasNext(itelistapuntos):
G = it.next(itelistapuntos)
itetop = it.newIterator(taxis)
while it.hasNext(itetop):
H = it.next(itetop)
I = m.get(tabla, H)
J = me.getValue(I)
if J == G:
lt.addLast(listaTaxis, H)
return listaTaxis
def getPointsV2(database: DataBase, date1, date2) -> dict:
days = database.getDays()
days = orderedmap.values(days, date1, date2)
days = lti.newIterator(days)
top = map.newMap(comparefunction=cmp.compareId)
while lti.hasNext(days):
day = lti.next(days).points
day = map.valueSet(day)
day = lti.newIterator(day)
while lti.hasNext(day):
wallet = lti.next(day)
if map.contains(top, wallet.id):
node = map.get(top, wallet.id)
value = mapentry.getValue(node)
value['points'] += wallet.points
else:
value = {'id': wallet.id, 'points': wallet.points}
map.put(top, wallet.id, value)
top = map.valueSet(top)
sort.mergesort(top, cmp.points)
return top
def puntosPorFecha(analyzer, fecha, numero):
fecha = datetime.datetime.strptime(fecha, '%Y-%m-%d').date()
entry = om.get(analyzer['mapaTaxi'], fecha)
valor = me.getValue(entry)
lsttaxis = valor['lstidtaxi']
merSort.mergesort(lsttaxis, compararvalores)
itera = it.newIterator(lsttaxis)
i = 1
resultado = []
while (it.hasNext(itera)):
valor = it.next(itera)
salida = {}
salida['Taxi'] = valor['idtaxi']
salida['puntos'] = valor['puntos']
resultado.append(salida)
if i >= numero:
break
i = i + 1
return resultado
def sortVideos(catalog, size, tipo, cmpfunction):
if size != "None":
sub_list = lt.subList(catalog['videos'], 0, size)
else:
sub_list = catalog
sub_list = sub_list.copy()
if tipo == 1:
sorted_list = se.selection_sort(sub_list, cmpfunction)
elif tipo == 2:
sorted_list = it.insertion_sort(sub_list, cmpfunction)
elif tipo == 3:
sorted_list = sa.shell_sort(sub_list, cmpfunction)
elif tipo == 4:
sorted_list = qu.sort(sub_list, cmpfunction)
elif tipo == 5:
sorted_list = me.mergesort(sub_list, cmpfunction)
return sorted_list
def getBestVideos(catalog, num, opcionsort):
"""
Retorna los mejores videos
"""
sub_list = lt.subList(catalog['videos'], 1, num)
sub_list = sub_list.copy()
start_time = time.process_time()
if opcionsort == 4:
nsblista = ms.mergesort(sub_list, cmpVideosByViews)
elif opcionsort == 5:
nsblista = qs.quicksortf(sub_list, cmpVideosByViews)
elif opcionsort == 1:
nsblista = sortselect(sub_list, cmpVideosByViews)
elif opcionsort == 2:
nsblista = sortinsert(sub_list, cmpVideosByViews)
elif opcionsort == 3:
nsblista = sortshell(sub_list, cmpVideosByViews)
stop_time = time.process_time()
elapsed_time_mseg = (stop_time - start_time) * 1000
return elapsed_time_mseg, nsblista
def criticalStations(citibike):
"""
RETO 4 | REQ 3
Retorna:
Las tres estaciones de donde salen más viajes.
La tres estaciones de donde llegan más viajes.
La tres estaciones menos usadas.
"""
top_arrival = []
top_departure = []
least_used = []
arrival_lt_sorted = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareValues)
departure_lt_sorted = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareValues)
total_trips_sorted = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareValues)
stations_keys = m.keySet(citibike['Edges_Map'])
iterator = it.newIterator(stations_keys)
while it.hasNext(iterator):
station = it.next(iterator)
sta = m.get(citibike['Edges_Map'], station)
lt.addLast(arrival_lt_sorted, sta)
lt.addLast(departure_lt_sorted, sta)
lt.addLast(total_trips_sorted, sta)
mg.mergesort(arrival_lt_sorted, greaterValueArrival)
mg.mergesort(departure_lt_sorted, greaterValueDeparture)
mg.mergesort(total_trips_sorted, greaterTotalTrips)
i = 0
while i < 3:
top_arr = lt.removeFirst(arrival_lt_sorted)
top_arrival.append(top_arr)
top_dep = lt.removeFirst(departure_lt_sorted)
top_departure.append(top_dep)
least = lt.removeLast(total_trips_sorted)
least_used.append(least)
i += 1
return top_arrival, top_departure, least_used
