from OrderedList import OrderedList import random o_list = OrderedList() for i in range(10): rand_num = random.randrange(0, 10) while o_list.search(rand_num): rand_num = random.randrange(0, 10) o_list.add(rand_num) print("After insertion:") for item in o_list: print(item, end=" ") print() for i in range(10): rand_num = random.randrange(0, 10) while not (o_list.search(rand_num)): rand_num = random.randrange(0, 10) o_list.remove(rand_num) print("After deletion:") for item in o_list: print(item, end=" ") print()
from OrderedList import OrderedList def print_list(ol): current = ol.head while current != None: print(current.get_data(), end=" ") current = current.get_next() print() ol = OrderedList() for i in range(10, 0, -1): ol.add(i) ol.add(0) print_list(ol) print('Size of the list: %d' % ol.size()) print('Removing 5 from the list: %s' % ol.remove(5)) print_list(ol) for i in range(-1, 12): print('Is %d in the list? %s' % (i, ol.search(i))) print('Is 300 in the list? %s' % ol.search(300))
class SearchStrategies: """ Provides a way to run various search strategies. AStar usage: create instance: search = SearchStrategies() set the costs matrix: search.setCosts() set the euristics matrix: search.setHeuristic() (optional) set the ignore value: search.setIgnore(value) run algorithm: search.run(from, where) BFS usage: create instance: search = SearchStrategies() set cost matrix: search.setCosts (optional) set the ignore value: search.setIgnore(value) run algorithm: search.BFS(from, where) """ def __init__(self): self.costs = None self.heuristic = None self.ignore = None self.way_list = OrderedList() self.parcial_cost_table = {} def setCosts(self, costs): """ @costs: 2x2 matrix consisting in a list of lists """ self.costs = costs def setHeuristic(self, heuristic): """ @heuristic: 2x2 matrix consisting in a list of lists """ self.heuristic = heuristic def setIgnore(self, value): """ Value which represents 'unpassable' or 'invalid' ways. Will be compared against each value in the cost matrix and if the comparison is True, that cost will be ignored. """ self.ignore = value def aStar(self, from_, where, start_at=1): """ Executes the aStar algorithm. Fins a way from 'from_' to 'where' and returns it or raises NotFoundException if no way has been found. @from_: index of the item we are going from @where: index of the item we desire to get as destination @start_at: which is the first number in the enumeration? """ # fer funció que from i where existeixi (fora d'aquesta classe) # Move from and where values to start from zero from_, where = from_ - start_at, where - start_at self.parcial_cost_table = {} self.way_list = OrderedList() self.way_list.add([from_], 0) # n = 1 while self.way_list[0][0] != where and self.way_list: # print(n) # n+=1 head = self.way_list[0] expanded = self.expand(head) expanded = self.cleanCycles(expanded) father_cost = self.way_list.get(0)[1] # get cost # Remove head as we already explored it self.way_list.remove(head) # Remove all the ways that aren't optimized self.removeRedundantWays(expanded, father_cost) # Add all the ways that we found out in this iteration for way in expanded: cost = self.findCost(way, father_cost) self.way_list.add(way, cost) if self.way_list: return self.way_list[0] else: raise NotFoundException() def BFS(self, from_, where, start_at=1): """ Executes the Breath First Search algorithm. Fins a way from 'from_' to 'where' and returns it or raises NotFoundException if no way has been found. @from_: index of the item we are going from @where: index of the item we desire to get as destination @start_at: which is the first number in the enumeration? """ from_, where = from_ - start_at, where - start_at self.way_list = [] self.way_list.append([from_]) while self.way_list[0][0] != where and self.way_list: head = self.way_list[0] expanded = self.expand(head) expanded = self.cleanCycles(expanded) # Remove head as we already explored it self.way_list.remove(head) # Add all the ways that we found out in this iteration for way in expanded: self.way_list.append(way) if self.way_list: return self.way_list[0] else: raise NotFoundException() def expand(self, way): """ Returns a list of all the possible ways that we can produce from the given way. @way: list containing a way (list of nodes). """ head = way[0] # CARE return_list = [] # Traverse the matrix by row for i, cost in enumerate(self.costs[head]): if cost != self.ignore: copied_list = copy.copy(way) copied_list.insert(0, i) return_list.append(copied_list) return_list.append(copied_list) # Traverse the matrix by column (this way we can give only half the table # when we make the costs). i, j = head, head length = len(self.costs) while j < length: cost = self.costs[j][i] assert isinstance(cost, int) or isinstance(cost, float) if cost != self.ignore: copied_list = copy.copy(way) copied_list.insert(0, j) return_list.append(copied_list) j += 1 return return_list def cleanCycles(self, ways): """ Checks the given ways and returns a list of those ways that have no cycles. @ways: list of lists consisting of ways. """ return_list = [] for way in ways: if way[0] in way[1:]: continue return_list.append(way) return return_list def findCost(self, way, father_cost): """ Returns the cost of the given way. @way: list containing a way (list of nodes). @father_cost: acumulated cost in previous steps. Example: [10,9,7,6,4] cost [9,7,6,4] = father_cost return cost[9->10] + father_cost """ # Get indexes which will be used for searching the cost i = way[0] j = way[1] # If j is bigger than i, we just invert them, that way we can make sure # that the program will work even if we just provide half the # cost table (which can save a lot of space). if i > j: i, j = j, i cost = self.costs[j][i] return cost + father_cost def removeRedundantWays(self, expanded, father_cost): """ Checks every way in the expanded list against the value in the parcial cost table. If that way isn't optimum, we remove it in order to make the algorithm faster. @expanded: 2x2 matrix of possible ways we can go from the actual head. @father_cost: cost of the way from origin to the previous father node. """ # Traverse list from last to first as we may need to remove items # as we are iterating through it. for i in range(len(expanded) - 1, -1, -1): way = expanded[i] head = way[0] parcial_cost = self.parcial_cost_table.get(way[0], "NotFound") way_cost = self.findCost(way, father_cost) if way_cost < parcial_cost or parcial_cost == "NotFound": # Update the table with the new cost self.parcial_cost_table[head] = way_cost # Remove ways in the way_list that have the same cost as the parcial cost to_remove = [] for item, cost in self.way_list.iterWithValues(): if cost == parcial_cost and item[0] == head: to_remove.append(item) for removable in to_remove: self.way_list.remove(removable) else: expanded.pop(i)
from OrderedList import OrderedList import random o_list = OrderedList() for i in range(10): rand_num = random.randrange(0,10) while o_list.search(rand_num): rand_num = random.randrange(0,10) o_list.add(rand_num) print("After insertion:") for item in o_list: print(item,end=" ") print() for i in range(10): rand_num = random.randrange(0,10) while not(o_list.search(rand_num)): rand_num = random.randrange(0,10) o_list.remove(rand_num) print("After deletion:") for item in o_list: print(item,end=" ") print()