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 getDirector(catalog, director):
"""
Retorna a un director con su informacion.
"""
value= getElementCriteria(catalog, 'director_name', director)
try:
movies=value['movies']
info=value['details']
lst=lt.newList(datastructure='SINGLE_LINKED')
iterator=it.newIterator(info)
while it.hasNext(iterator):
movie=it.next(iterator)
title=movie['title']
lt.addLast(lst, title)
avg=value['vote_avg']
size=lt.size(movies)
return (lst, size, avg)
except:
return None
def TaxisPorCompania(analyzer):
taxisXCompania = om.newMap(omaptype='RBT', comparefunction=compareIds)
total_taxis = 0
nombres = om.keySet(analyzer['companias'])
iter = it.newIterator(nombres)
while it.hasNext(iter):
cada_compania = it.next(iter)
nombre_compania = om.get(analyzer['companias'], cada_compania)
if nombre_compania['key'] is not None:
taxis = me.getValue(nombre_compania)['taxis_afiliados']
# print(taxis)
if taxis is not None:
num_taxis = m.size(taxis)
total_taxis += num_taxis
om.put(taxisXCompania, num_taxis, cada_compania)
# print(om.valueSet(taxisXCompania))
# print(om.keySet(taxisXCompania))
return (taxisXCompania)
def LikesPais(catalogo, pais, numero, tag):
#sacar paises, sacar videos del pais
paises = catalogo['paises']
videos = me.getValue(mp.get(paises, pais))['videos']
#iteracion, obitine diccionario con las views de los videos con el tag y el pais
iterator = it.newIterator(videos)
final = {}
lista = lt.newList()
while it.hasNext(iterator):
x = it.next(iterator)
answer = (mp.get(catalogo['videosID'], x))
tags = answer['value']['tags']
if tag in tags:
likes = answer['value']['likes']
if x in final and likes > final[x]:
final[x] = likes
else:
final[x] = likes
#recorre el diccionario y devuelve la lista con el numero de videos pedidos
lista = recorrerDic(final, numero)
print(lista)
for i in lista:
video = mp.get(catalogo['videosID'], i)
titulo = video['value']['title']
canal = video['value']['channel_title']
tiempo = video['value']['publish_time']
views = video['value']['views']
likes = video['value']['likes']
dislikes = video['value']['dislikes']
tags = video['value']['tags']
print(text.BOLD + 'Title: ' + text.END, titulo, '\n',
text.BOLD + 'Channel_title: ' + text.END, canal, text.BOLD, '\n',
'Publish_time: ' + text.END, tiempo, '\n',
text.BOLD + 'Views: ' + text.END, views, '\n',
text.BOLD + text.YELLOW + 'Likes: ' + text.END, likes, '\n',
text.BOLD + 'Dislikes: ' + text.END, dislikes, '\n',
text.BOLD + 'Tags: ' + text.END, tags)
def getAccidentsByRange(analyzer, initialDate, endDate):
"""
Para un rango de fechas retorna la cantidad de accidentes
sucedidos junto con la categoría más reportada
"""
lst = om.values(analyzer['dateIndex'], initialDate,
endDate) #Hacemos una lista con los valores
lstiterator = it.newIterator(lst)
totalaccidentes = 0
most = (0, None)
while (it.hasNext(lstiterator)):
lstdate = it.next(lstiterator)
z = lt.size(lstdate['lstaccident'])
par = ((lt.getElement(lstdate['lstaccident'],
1))['Start_Time']).split()
fecha = par[0]
if z > most[0]:
most = (z, fecha)
totalaccidentes += z
return totalaccidentes, most
def addPais(diccio):
iterador = it.newIterator(diccio["videos"])
while it.hasNext(iterador):
actual = it.next(iterador)
if mp.contains(diccio["trending"], actual["country"]) == True:
par = mp.get(diccio['trending'], actual["country"])
lis = me.getValue(par)
lt.addLast(lis, actual)
else:
lis = lt.newList()
mp.put(diccio['trending'], actual["country"], lis)
lt.addLast(lis, actual)
return diccio
def Suma_de_los_valores(citiTaxi, initialDate, finalDate):
"""
Retorna el numero de crimenes en un rago de fechas.
"""
dic={}
cont=0
lst = om.keys(citiTaxi['fecha'], initialDate, finalDate)
iterator = it.newIterator(lst)
while it.hasNext(iterator):
llave = it.next(iterator)
llave2 = om.get(citiTaxi['fecha'], llave)
entry = me.getValue(llave2)
for i in entry:
if i not in dic:
dic[i] = {'dinero': entry[i]['dinero'], 'millas': entry[i]['millas'], 'servicios': entry[i]['servicios']}
else:
dic[i]['dinero'] += entry[i]['dinero']
dic[i]['millas'] += entry[i]['millas']
dic[i]['servicios'] += entry[i]['servicios']
return dic
def getAccidentsByHours2(analyzer, initialDate, endDate):
"""
Para un rango de fechas retorna la cantidad de accidentes
sucedidos junto con la categoría más reportada
"""
lst = om.values(analyzer['hourIndex'], initialDate,
endDate) #Hacemos una lista con los valores
lstiterator = it.newIterator(lst)
totalaccidentes = 0
conteo = {}
while (it.hasNext(lstiterator)):
lstdate = it.next(lstiterator)
z = lt.size(lstdate['lstaccident'])
par = ((lt.getElement(lstdate['lstaccident'], 1))['Severity'])
if par in conteo:
conteo[par] += z
else:
conteo[par] = z
totalaccidentes += z
return totalaccidentes, conteo
def getAccidentsByDate(analyzer, day):
"""
Para una fecha determinada, retorna el numero de accidentes
por severidad.
"""
aDate = om.get(analyzer['date'], day)
if aDate['key'] is not None:
Accismap = me.getValue(aDate)['severities']
sev=m.keySet(Accismap)
iterator= it.newIterator(sev)
totales=0
while(it.hasNext(iterator)):
severity1= it.next(iterator)
numaccis = m.get(Accismap,severity1)
lista= numaccis['value']
cuantas = lt.size(lista['listBySeverity'])
totales+=cuantas
if lista is not None:
print("severidad: "+ str(severity1) + " tiene : " +str(cuantas) +" accidentes")
print("accidentes totales: "+str(totales))
def totalTaxis(analyzer):
cont=0
lista=[]
lista2=[]
valores=m.valueSet(analyzer["TaxiNum"])
iterator_valores= it.newIterator(valores)
while it.hasNext(iterator_valores):
elemento=it.next(iterator_valores)
lista.append(elemento)
for i in lista:
valor=i
for k in valor:
numeros=valor[k]
lista2.append(numeros)
for z in lista2:
cont+=z
return cont
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 fifthRequirement(analyzer, edad):
grafo1 = analyzer['ages1']
grafo2 = analyzer['ages2']
mpa1 = djk.Dijkstra(grafo1, str(edad))
mpa2 = djk.Dijkstra(grafo2, str(edad))
res1 = lt.firstElement(djk.pathTo(mpa1, "salida"))['vertexB']
res2 = lt.firstElement(djk.pathTo(mpa2, "salida"))['vertexB']
mpa1 = djk.Dijkstra(analyzer['graph'], res1)
ruta = djk.pathTo(mpa1, res2)
iterator = it.newIterator(ruta)
ruta = res1
while it.hasNext(iterator):
element = it.next(iterator)
estacion = element['vertexB']
ruta += "-" + estacion
print(
"Los usuarios con edad en los {}'s les gusta iniciar en la estación {} y terminar en la estación {}. Se recomienda la ruta siguiente: {}"
.format(int(edad) * 10, res1, res2, ruta))
return None
def rutas(analyzer, id, res):
lista = lt.newList()
vert = gr.adjacents(analyzer["trips"], id)
iterator = it.newIterator(vert)
while it.hasNext(iterator):
element = it.next(iterator)
edge = gr.getEdge(analyzer["trips"], id, element)
time = edge["weight"]
if (float(time) <= float(res)) and (element != id):
route = newRoute()
route["path"] = id + "-" + edge["vertexB"]
route["time"] = time
route["startName"] = nameStation(analyzer, id)
route["endName"] = nameStation(analyzer, edge["vertexB"])
lstTimes = route["Seg"]
lt.addLast(lstTimes, (id + "-" + edge["vertexB"], time))
lt.addLast(lista, route)
vertB = edge["vertexB"]
ruta(analyzer, lista, route, vertB, res)
return lista
def DiasPais(catalogo, pais):
pais = pais.lower().strip()
paises = catalogo['paises']
vidP = me.getValue(mp.get(paises, pais))['videos']
iterator = it.newIterator(vidP)
maxdict = {}
while it.hasNext(iterator):
x = it.next(iterator)
if x in maxdict:
maxdict[x] += 1
else:
maxdict[x] = 1
keys = list(maxdict.keys())
values = list(maxdict.values())
maxV = values.index(max(values))
topD = keys[maxV]
dTop = values[maxV]
video = me.getValue(mp.get(catalogo['videosID'], topD))
return video, dTop
def optionSix():
rango = input("ingrese el rango de edad: ")
path_, estacion_salida, estacion_llegada, costo = controller.recomendar_rutas(
cont, rango)
if path_ is None:
print("No hay estaciones de salida ni llegada para ese rango de edad")
elif path_ == 0:
print("La estacion de salida recomendada es: ", estacion_salida)
print("La estacion de llegada recomendada es: ", estacion_llegada)
print("El tiempo estimado de viaje es:", costo)
else:
print("La estacion de salida recomendada es: ", estacion_salida)
print("La estacion de llegada recomendada es: ", estacion_llegada)
print("El tiempo estimado de viaje es:", costo)
print("***************************************")
print("Las estaciones en la ruta son: ")
iterador = it.newIterator(path_)
while it.hasNext(iterador):
element = it.next(iterador)
print(element)
def getTrendVidByCountry(catalog, country_name):
countries = catalog['countries']
posCountry = lt.isPresent(countries, country_name)
if posCountry > 0:
country = lt.getElement(countries, posCountry)
mg.sort(country['videos'], cmpVideosByTitle)
iteratorVid = lti.newIterator(country['videos'])
trendVids = lt.newList("ARRAY_LIST", cmpfunction=compareVideoName)
while lti.hasNext(iteratorVid):
video = lti.next(iteratorVid)
vidName = video['title']
posVid = lt.isPresent(trendVids, vidName)
if posVid > 0:
el = lt.getElement(trendVids, posVid)
el['cuenta'] += 1
else:
lt.addLast(trendVids, {"info": video, "cuenta": 1})
sortedTrendVids = mg.sort(trendVids, cmpVideosByDays)
firstTrendVid = lt.firstElement(sortedTrendVids)
return firstTrendVid
def numhts(tracks, catalog):
mapafinal = mp.newMap(maptype="PROBING", loadfactor=0.5)
tracksmap = mp.newMap(maptype="PROBING", loadfactor=0.5)
d = it.newIterator(tracks)
while it.hasNext(d):
track = it.next(d)
mp.put(tracksmap, track)
x = promedio(catalog, track)
if x != None:
numht = x[0]
prom = x[1]
par = mp.get(mapafinal, numht)
if par != None:
lista = me.getValue(par)
lt.addLast(lista, (track, prom))
else:
lista = lt.newList(datastructure="ARRAY_LIST")
lt.addLast(lista, (track, prom))
mp.put(mapafinal, numht, lista)
return mapafinal, tracksmap
def optionNine():
try:
if (cat.isdigit()) and (int(cat) > 0) and (int(cat) < 8):
catLst, size = controller.getPublicityRoute(analyzer, int(cat))
routeIterator = it.newIterator(catLst)
ite = 1
if size > 2:
print(
"Las rutas que son las más adecuadas para publicidad dentro del rango de edad ingresado son:\n"
)
else:
print(
"La ruta que es la más adecuada para publicidad dentro del rango de edad ingresado es:\n"
)
while it.hasNext(routeIterator) and (ite < size):
routeTup = it.next(routeIterator)
num, route = routeTup
if num == 0:
print(
"No hay viajes registrados que cumplan con los requisitos en ese grupo de edad"
)
else:
statLst = route.split("-")
routeAns = ""
for i in range(0, len(statLst)):
routeAns = routeAns + "-" + controller.getStationName(
analyzer, statLst[i]) + "(id- " + statLst[i] + ")"
print("La ruta " + routeAns[1:] + " con " + str(num) +
" veces realizada.")
ite += 1
total = it.next(routeIterator)
print(
"\nHubo " + str(total) +
" viajes hechos por personas del rango de edad ingresado que tienen suscripción de 3 días"
)
else:
print(
"La categoria ingresada debe ser un numero natural entre 1 y 7"
)
except:
print("Hubo un error en la busqueda")
def video_trending_categoria(category_name, lista, categorias) -> dict:
for i in categorias:
if categorias[i] == category_name:
numero_categoria = int(i)
mayor = 0
aux = []
dict_final = {}
iterador = it.newIterator(lista)
contador2 = 0
while it.hasNext(iterador):
elemento = it.next(iterador)
centinela = True
contador = 0
if numero_categoria == int(elemento['category_id']):
while contador < len(aux):
if (elemento['title'] == aux[contador]["title"]):
aux[contador]["numero de dias"] += 1
centinela = False
contador += 1
if centinela == True:
aux.append({
"title": elemento["title"],
"channel_title": elemento["channel_title"],
"category_id": elemento["category_id"],
"numero de dias": 1,
"dates": str(elemento["trending_date"])
})
while contador2 < len(aux):
if int(aux[contador2]["numero de dias"]) > mayor:
dict_final["title"] = aux[contador2]["title"]
dict_final["channel_title"] = aux[contador2]["channel_title"]
dict_final["category_id"] = numero_categoria
dict_final["numero de dias"] = aux[contador2]["numero de dias"]
mayor = int(aux[contador2]["numero de dias"])
contador2 += 1
return dict_final
def initSearch(graph, source):
"""
Inicializa la estructura de busqueda y deja
todos los arcos en infinito.
Se inserta en la cola indexada el vertice source
Args:
graph: El grafo a examinar
source: El vertice fuente
Returns:
Estructura de busqueda inicializada
Raises:
Exception
"""
try:
search = {'source': source, 'visited': None, 'iminpq': None}
search['visited'] = map.newMap(
numelements=g.numVertex(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
vertices = g.vertices(graph)
itvertices = it.newIterator(vertices)
while (it.hasNext(itvertices)):
vert = it.next(itvertices)
map.put(search['visited'], vert, {
'marked': False,
'edgeTo': None,
'distTo': math.inf
})
map.put(search['visited'], source, {
'marked': True,
'edgeTo': None,
'distTo': 0
})
pq = iminpq.newIndexMinPQ(cmpfunction=graph['comparefunction'])
search['iminpq'] = pq
iminpq.insert(search['iminpq'], source, 0)
return search
except Exception as exp:
error.reraise(exp, 'dks:init')
def findStations(citibike, lat1, lon1, lat2, lon2):
iterator = it.newIterator(
citibike['stations']
) #Lugar donde se encuentra la información de todas las estaicones
while it.hasNext(iterator):
info = it.next(iterator)
lat_s = info['start station latitude']
lon_s = info['start station longitude']
short_st_distance = 2000
short_fn_distance = 2000
start_name = ''
finish_name = ''
startPoint = distance(lat1, lat_s, lon1, lon_s)
finishPoint = distance(lat2, lat_s, lon2, lon_s)
if startPoint < short_st_distance:
short_st_distance = startPoint
start_name = info['start station id']
if finishPoint < short_fn_distance:
short_fn_distance = finishPoint
finish_name = info['start station id']
return [start_name, finish_name]
def top_companies_by_services(catalog, top_number):
companies_per_services = catalog["companies"]["companies_per_services"]
key_lst = m.keySet(companies_per_services)
greater = 0
counter = 0
lst = lt.newList(cmpfunction=compare_companies)
while counter < top_number:
iterator = it.newIterator(key_lst)
while it.hasNext(iterator):
company = it.next(iterator)
entry = m.get(companies_per_services, company)
services_number = me.getValue(entry)
if services_number > greater:
greater = services_number
greater_company = company
lt.addLast(lst, (greater_company, greater))
pos = lt.isPresent(key_lst, greater_company)
lt.deleteElement(key_lst, pos)
greater = 0
counter += 1
return lst
def getCloserStation(analyzer, latitud, longitud):
grafo = analyzer['graph']
vertice = str(72)
recorrido = m.keySet(dfs.DepthFirstSearch(grafo, vertice)['visited'])
iterator = it.newIterator(recorrido)
distance = float('inf')
closer = 0
while it.hasNext(iterator):
element = it.next(iterator)
coordinates = m.get(analyzer['distance'], element)['value']
if coordinates == None:
a = 1
else:
distancia = dinstancefunction(
np.radians(float(coordinates['latitud'])),
np.radians(float(coordinates['longitud'])), float(latitud),
float(longitud))
if distance >= distancia:
distance = distancia
closer = element
return closer
def hayarMinCiclos(cont, initialStation, estaciones):
listaCiclos=[]
for a in range(0,len(estaciones)):
lista=[]
cont = minimumCostPaths(cont, initialStation)
tiempo1 = djk.distTo(cont["paths"],estaciones[a]) #tiempo de Inicio a V1
lista=["Hay un camino que empieza en "+str(initialStation)+" y va a " +str(estaciones[a]) +" en un tiempo de "+str(round(tiempo1))+" segundos que se conecta asi:"]
cont = minimumCostPaths(cont, estaciones[a])
tiempo2 = djk.distTo(cont["paths"],initialStation)
minimumCostPaths(cont, estaciones[a])
path2 = minimumCostPath(cont, initialStation)
iterator = it.newIterator(path2)
tiempo_visita=0
while it.hasNext(iterator):
element=it.next(iterator)
lista.append(element)
tiempo_visita+=20
tiempo_total= tiempo1/60+tiempo2/60+tiempo_visita
tupla=(lista,round(tiempo_total))
listaCiclos.append(tupla)
return listaCiclos
def Req4(catalog,country,tag):
videosCountry= getVideosByCountry(catalog, country)
result=lt.newList('ARRAY_LIST',compareLikes)
b=lit.newIterator(videosCountry['videos'])
while lit.hasNext(b):
e=lit.next(b)
if tag in e['tags']:
dic={}
r= lt.isPresent(result,e)
if r==0:
dic['title']=e['title']
dic['channel_title']=e['channel_title']
dic['publish_time']=e['publish_time']
dic['views']=e['views']
dic['likes']=e['likes']
dic['dislikes']=e['dislikes']
dic['tags']=e['tags']
lt.addLast(result,dic)
sort=sortLikes(result)
#print(lt.getElement(dic_sort,1))
return sort
def TiempoNecesariomod(analyzer, GPCC, limites):
if GPCC == False:
return False
else:
Ideal = {}
Pesos = {}
for A in GPCC:
Pesos[A] = 0
n = it.newIterator(gr.edges(GPCC[A]))
if it.hasNext(n):
d = it.next(n)
Pesos[A] += ed.weight(d)
LimiteInferior = 0*60
LimiteSuperior = limites*60
for B in Pesos:
if Pesos[B] >= LimiteInferior and Pesos[B] <= LimiteSuperior:
Ideal[B] = GPCC[B]
if len(Ideal) == 0:
return "Vacio"
else:
return Ideal
def test_pushElements():
"""
Se prueba la creacion de una nueva pila, se agregan todos los datos
creados por sistema y se imprime su valor
"""
stack = st.newStack(list_type)
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
iterator = it.newIterator(stack)
while it.hasNext(iterator):
element = it.next(iterator)
print(element)
def P_Q(analyzer):
TopS = pq.newMinPQ(cmpfunction= comparefunction)
TopT = pq.newMinPQ(cmpfunction= comparefunction)
lstcompany = m.keySet(analyzer["Company"])
iterator = it.newIterator(lstcompany)
while it.hasNext(iterator):
i = it.next(iterator)
consulta = m.get(analyzer["Company"], i)['value']
numtaxis = len(consulta["Taxis"])
numservices = (consulta["Services"])
taxisE = {"key": numtaxis, "company": i}
servicesE = {"key": numservices, "company": i}
pq.insert(TopT, taxisE)
pq.insert(TopS, servicesE)
return {"T_taxis": TopT, "T_services": TopS}
def accidentesPorFecha(cont):
t1_start = process_time() #tiempo inicial
year = input('Digite el año YYYY: ')
month = input('Digite el mes MM: ')
day = input('Digite el día DD: ')
date = year.strip() + '-' + month.strip() + '-' + day.strip()
lst = ctrl.accidentesPorFecha(cont, date)
print('Los tipos de accidentes acontecidos en la fecha', date, 'fueron: ')
iterator = it.newIterator(lst[1])
i = 1
while it.hasNext(iterator):
print(i, '- ', it.next(iterator))
i += 1
print('Para un total de ', lst[0]['total'], ' accidentes')
print('Total según severidad: ')
print('Severidad 1: ', lst[0]['1'])
print('Severidad 2: ', lst[0]['2'])
print('Severidad 3: ', lst[0]['3'])
print('Severidad 4: ', lst[0]['4'])
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos ")
def imprimir_recomendador(cont, ref, rango):
recomendador = controller.recomendador_de_rutas(cont, ref, rango)
inicio = recomendador["inicio"]
llegada = recomendador["llegada"]
print(
f"La estación en la que inician más viajes personas en su rango de edad es la estación {inicio}\n"
)
print(
f"La estación en la que terminan más viajes personas en su rango de edad es la estación {llegada}\n"
)
print("El camino más corto entre el par de estaciones es el siguiente:")
camino = recomendador["camino"]
if camino == None:
print("No existe camino entre esas estaciones")
else:
ite = it.newIterator(camino)
while it.hasNext(ite):
ruta = it.next(ite)
ruta_ini = ruta['vertexA']
ruta_fin = ruta['vertexB']
print(f"De la estación {ruta_ini} a la estación {ruta_fin}")
