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
