class MyQueue:
def __init__(self):
self.front = Stack()
self.end = Stack()
def size(self):
return self.front.size() + self.end.size()
def enqueue(self, val):
self.end.push(val)
def dequeue(self):
if self.front.is_empty() and not self.move():
raise Exception("queue is empty")
return self.front.pop()
def peek(self):
if self.front.is_empty() and not self.move():
raise Exception("queue is empty")
return self.front.peek()
# time: O(n), however, the average is O(1)
def move(self):
moved = False
while not self.end.is_empty():
moved = True
self.front.push(self.end.pop())
return moved
def print_q(self):
print self.front
print self.end
def version_2(test):
(given, expected) = test
original_stack = Stack()
sorted_stack = Stack()
for g in given:
original_stack.push(g)
# starts here
num_eltos = original_stack.size
for i in range(num_eltos):
pivot = original_stack.pop()
num_swaps = 0
while (not sorted_stack.is_empty()) and (pivot < sorted_stack.peek()):
original_stack.push(sorted_stack.pop())
num_swaps += 1
sorted_stack.push(pivot)
for _ in range(num_swaps):
sorted_stack.push(original_stack.pop())
# sorts in reverse order (smallest on top)
while not sorted_stack.is_empty():
original_stack.push(sorted_stack.pop())
given_str = ''.join(original_stack.to_array()) # doesn't count in the O(.) calculation
return given_str == expected
def sort_stack(stack):
buf = Stack()
while not stack.is_empty():
cur = stack.pop()
cnt = 0
while not buf.is_empty() and cur < buf.peek():
stack.push(buf.pop())
cnt += 1
buf.push(cur)
for i in xrange(cnt):
buf.push(stack.pop())
while not buf.is_empty():
stack.push(buf.pop())
class MyQueue:
def __init__(self):
self.s1 = Stack()
self.s2 = Stack()
def enqueue(self, item):
self.s1.push(item)
def dequeue(self):
if self.s2.top is None:
while self.s1.top is not None:
self.s2.push(self.s1.pop())
return self.s2.pop()
def dfs(self, starting_vertex, destination_vertex):
"""
Return a list containing a path from
starting_vertex to destination_vertex in
depth-first order.
"""
# make a stack
stack = Stack()
# make a visited set
visited = set()
# push the PATH to that node
stack.push([starting_vertex])
# while the stack isn't empty
while stack.size():
# pop the PATH
path = stack.pop()
# the last thing in the path is our current item
node = path[-1]
# if node is not visited:
if node not in visited:
# CHECK if it is the target
if node == destination_vertex:
return path
visited.add(node)
for neighbor in self.vertices[node]:
#copy the path
PATH_COPY = path.copy()
# add neighbor to the path
PATH_COPY.append(neighbor)
# enqueue the PATH_COPY
stack.push(PATH_COPY)
return None
class QueueViaStacks():
def __init__(self):
self.in_stack = Stack(5)
self.out_stack = Stack(5)
def enqueue(self, item):
self.in_stack.push(item)
def dequeue(self):
if self.out_stack.size == 0:
while self.in_stack.size:
self.out_stack.push(self.in_stack.pop())
if self.out_stack.is_empty is True:
raise IndexError("Can't dequeue from empty queue")
return self.out_stack.pop()
def dft(self, starting_vertex: T) -> None:
"""
Print each vertex in depth-first order
beginning from starting_vertex.
"""
# keep track of visited vertices
visited = set()
# create a stack class
stack = Stack()
# push the starting vertex onto the stack
stack.push(starting_vertex)
# while stack is not empty
while stack.size():
# pop from the stack
current_vertex = stack.pop()
# if current vertex has not been visited
if current_vertex not in visited:
# add it to visited
visited.add(current_vertex)
# print the current vertex
print(current_vertex)
# for every neighbors of current_vertex
for vertex in self.vertices[current_vertex]:
# push it onto the stack
stack.push(vertex)
def depth_first(self, xy1, xy2):
"""Execute a depth first search."""
tile_col1, tile_row1 = self.the_map.xy_to_cr(xy1[0], xy1[1])
tile_col2, tile_row2 = self.the_map.xy_to_cr(xy2[0], xy2[1])
successor_to_parent_map = {}
start_state = (tile_col1, tile_row1)
successor_to_parent_map[(
start_state,
None)] = None # (Successor, Action) -> (Parent, Action)
open_list = Stack()
open_list.push((start_state, None))
closed = []
while not open_list.isEmpty():
current_state, action_to_current_state = open_list.pop()
if current_state == (tile_col2, tile_row2):
return self.__get_action_path(
(current_state, action_to_current_state),
successor_to_parent_map)
if current_state not in closed:
for successor_state, action, step_cost in self.__get_successors(
current_state):
open_list.push((successor_state, action))
if successor_state not in closed:
successor_to_parent_map[(successor_state, action)] = (
current_state, action_to_current_state)
closed.append(current_state)
return []
def get_convex_hull_by_graham_scan(angle_sorted_list):
temp_stack = Stack()
temp_stack.push(angle_sorted_list[0])
temp_stack.push(angle_sorted_list[1])
for p in angle_sorted_list[2:] + angle_sorted_list[:1]:
while True:
top = temp_stack.peek()
second_top = temp_stack.peek_peek()
b = (p[0] - top[0], p[1] - top[1])
a = (top[0] - second_top[0], top[1] - second_top[1])
if a[0] * b[1] - a[1] * b[0] < 0:
temp_stack.pop()
else:
break
temp_stack.push(p)
temp_stack.pop()
return temp_stack.items
def evaluate(express):
ops = Stack()
vals = Stack()
for s in express.split():
if s in "+,-,*,/,sqrt".split(','):
ops.push(s)
elif s == '(':
pass
elif s == ')':
op = ops.pop()
v = vals.pop()
if op == '+':
v += vals.pop()
elif op == '-':
v -= vals.pop()
elif op == '*':
v *= vals.pop()
elif op == '/':
v /= vals.pop()
elif op == 'sqrt':
v = v**0.5
vals.push(v)
else:
vals.push(float(s))
return vals.pop()
def earliest_ancestor(ancestors, starting_node, visited=None, path=None):
# initialize path = [starting_node]
# path = [starting_node]
# get parents - only care about parent not starting node i.e: node[1]
# loop to check for number of connections
# if no connections return -1
print('ancestors:', ancestors)
print('starting_node:', starting_node)
graph = Graph()
stack = Stack()
path = [starting_node]
stack.push(path)
graph = {}
for key, value in ancestors:
# print('k,v:',key, value)
if value not in graph:
# print('aa',value)
graph[value] = set()
if key not in graph:
print('aa', value)
graph[key] = set()
graph[value].add(key)
print('graph:', graph)
if len(graph[starting_node]) == 0:
return -1
visited = set()
paths = list()
print('paths:', paths)
while stack.size() > 0:
current_path = stack.pop()
print('current_path:', current_path)
current_node = current_path[-1]
print('current_node:', current_node)
if current_node not in visited:
visited.add(current_node)
print('visited', visited)
for parent in graph[current_node]:
if parent not in visited:
new_path = list(current_path)
new_path.append(parent)
print('new_path:', new_path)
stack.push(new_path)
if len(graph[current_node]) == 0:
paths.append(current_path)
print('paths:', paths)
sorted_paths = sorted(paths, reverse=True) # key=lambda x: len(x))
print('*****', sorted_paths[-1][-1])
return sorted_paths[-1][-1]
def playing(player):
traversal_path = []
visited_dict = {}
visited_set = set()
path = Stack()
oposite_directions = {"s": "n", "n": "s", "e": "w", "w": "e"}
while len(visited_set) < len(room_graph):
current = player.current_room
visited_set.add(current)
# path.push(current.id)
# traversal_path.append(current)
# if current.id not in visited_set:
# print(current.id)
# visited_set.add(current.id)
visited_dict[current.id] = {}
# if len(current.get_exits()) == 1:
# direction = current.get_exits()
# path.pop()
# previous_room = path.stack[-1]
# visited_dict[current.id][direction] = previous_room
# player.travel(previous_room)
unvisited = Queue()
for direction in current.get_exits():
if current.get_room_in_direction(direction) not in visited_set:
# visited_dict[current.id][direction] = False
# unvisited.enqueue(direction)
unvisited.enqueue(direction)
if unvisited.size() > 0:
# direction = unvisited.dequeue()
direction = unvisited.dequeue()
path.push(direction)
traversal_path.append(direction)
player.travel(direction)
else:
# for direction in visited_dict[current.id]:
# if visited_dict[current.id][direction] == False:
# visited_dict[current.id][direction] = player.current_room.get_room_in_direction(direction)
# player.travel(direction)
previous_room = path.pop()
traversal_path.append(oposite_directions[previous_room])
player.travel(oposite_directions[previous_room])
return traversal_path
def sort_stack(stack):
s1 = stack
s2 = Stack(s1.size)
while(s1.is_empty() != True):
temp = s1.pop()
while(s2.is_empty() != True and s2.peek() > temp):
s1.push(s2.pop())
s2.push(temp)
return s2
class StackWithMin2(Stack):
def __init__(self):
super(StackWithMin2, self).__init__()
self.stack = Stack()
def pop(self):
item = super(StackWithMin2, self).pop()
if item == self.min():
self.stack.pop()
return item
def push(self, item):
if item <= self.min():
self.stack.push(item)
super(StackWithMin2, self).push(item)
def min(self):
if self.stack.top is not None:
return self.stack.top.val
else:
return 1e10
def parse_object(tokens):
s = Stack()
tokens_count = len(tokens)
n = 0
while n < tokens_count:
elem = tokens[n]
n += 1
if elem == ']':
l = []
while s.top() != '[':
top = s.pop()
l.insert(0, top)
s.pop()
s.push(l)
continue
if elem == '}':
l = []
while s.top() != '{':
top = s.pop()
l.insert(0, top)
s.pop()
if len(l) > 0 and not len(l) % 3 == 0 and not l.count(':') == len(l) / 3:
raise ValueError
d = {l[i]: l[i + 2] for i in range(0, len(l), 3)}
s.push(d)
continue
s.push(elem)
return s.top()
def version_1(test):
forward_stack = Stack()
backward_stack = Stack()
for t in test:
forward_stack.push(t)
while not forward_stack.is_empty():
backward_stack.push(forward_stack.pop())
result = ''.join(backward_stack.to_array())
return test == result
def path(starting_point):
graph = dft(player)
visited = {}
visits = {}
if graph:
s = Stack()
s.push([starting_point.current_room.id])
while s.size() > 0:
path = s.pop()
current_room = path[-1]
count = 0
random_direction = ''
if current_room in visited:
get_list = len(traversal_path)
print(get_list)
if len(visited) < 9:
visited[current_room] = path
randoms = []
for idx, val in graph[current_room].items():
if val is not '?':
randoms.append(idx)
random_direction = random.choice(randoms)
if len(random_direction) == 1:
if len(traversal_path) == 0:
traversal_path.append(random_direction)
get_new_room = graph[current_room][random_direction]
s.push([get_new_room])
random_direction = ''
else:
traversal_path.append(random_direction)
get_new_room = graph[current_room][random_direction]
s.push([get_new_room])
random_direction = ''
# for next_position in graph:
# s.push([next_position])
print(len(traversal_path), "TRAVERSAL PATH LENGTH")
print(len(visited), "LENGTH VISITED")
print(graph, "GRAPH")
return traversal_path
def version_1(test):
(given, expected) = test
original_stack = Stack()
sorted_stack = Stack()
for g in given:
original_stack.push(g)
# starts here
while not original_stack.is_empty():
pivot = original_stack.pop()
while (not sorted_stack.is_empty()) and (pivot < sorted_stack.peek()):
original_stack.push(sorted_stack.pop())
sorted_stack.push(pivot)
# sorts in reverse order (smallest on top)
while not sorted_stack.is_empty():
original_stack.push(sorted_stack.pop())
given_str = ''.join(original_stack.to_array()) # doesn't count in the O(.) calculation
return given_str == expected
def dft(self, starting_vertex):
"""
Print each vertex in depth-first order
beginning from starting_vertex.
"""
# make a stack
s = Stack()
# push on your starting node
s.push([starting_vertex])
# make a set to track if it was visited
visited = set()
# while stack not empty
while s.size() > 0:
# pop off what is on top.
current_node = s.pop()
# if we have no visited the vertex before
if current_node not in visited:
# run function/print
# print(current_node)
# mark as visited
# visited.add(current_node)
# get its neighbors
# neighbors = self.get_neighbors(current_node)
# for each of the neighbors
self.vertices[room.id] = {}
for neighbor in room.get_exits():
self.vertices[room.id][room.get_room_in_direction(
possible_direction).id] = neighbor
visited.add(room)
exits = room.get_exits()
while len(exits) > 0:
# select first neighbors on list
direct = exits[0]
# beej: create neighbor object
path = list(current_node)
# add possibles directions to move
path.append(room.get_room_in_direction(direct))
# add to stack
s.push(path)
# remove to contine
exits.remove(direct)
return self.vertices
def quick_sort_by_stack3(A, p, r):
stack = Stack()
q, t = random_partition3(A, p, r)
if q > p + 1:
stack.push(p)
stack.push(q - 1)
if t < r - 1:
stack.push(t + 1)
stack.push(r)
while not stack.is_empty():
r = stack.pop()
p = stack.pop()
q, t = random_partition3(A, p, r)
if q > p + 1:
stack.push(p)
stack.push(q - 1)
if t < r - 1:
stack.push(t + 1)
stack.push(r)
def find_group(self, positions, sort=True):
"""
dfs with node expansion based on the properties of the board,
as if a set of adjacent positions of same color in the same-game are each a connected graph
"""
frontier = Stack()
frontier.append(positions.pop(0))
frontier_register = set()
explored = set()
while frontier:
#print('frontier', frontier)
frontier_register.update(frontier)
position = frontier.pop()
explored.add(position)
for p in set(position.adjacent(self.dimensions)).intersection(positions):
if p not in explored and p not in frontier:
frontier.append(p)
return sorted(frontier_register) if sort else list(frontier_register)
def dfs(self, starting_vertex: T, destination_vertex: T) -> PathType:
"""
Return a list containing a path from
starting_vertex to destination_vertex in
depth-first order.
"""
# create the stack class
stack = Stack()
# would keep track of visited vertices
visited = set()
# push the starting vertex as a list of vert
stack.push([starting_vertex])
# while stack is not empty
while stack.size():
# pop a path from the stack
path = stack.pop()
# get the last vertex from the stack
current_vert = path[-1]
# if current_vert is the destination_vertex
if current_vert == destination_vertex:
# return path
return path
# if current_vert is not in visited:
if current_vert not in visited:
# add it to visited
visited.add(current_vert)
# for every neighbors of of current_vert
for vertex in self.vertices[current_vert]:
# create a copy of the path
new_path = list(path)
# append the current vertex
new_path.append(vertex)
# push the new path onto the stack
stack.push(new_path)
def depth_limited(problem, limit):
"""Depth Limited Search"""
frontier = Stack()
start_node = Node(problem['start'])
frontier.push(start_node)
closed_set = set()
while not frontier.isEmpty():
node = frontier.pop()
closed_set.add(node.value)
if goal_test(problem, node):
path = node.get_path()
cost = cal_path_cost(problem['graph'], path)
return path, cost, frontier.count
if node.depth == limit:
pass
else:
# Expansion
adj = problem['graph'].adj(node.value)
for child_value in quicksort(adj):
if push_or_not(problem, node, child_value, closed_set):
child_node = Node(child_value, node)
frontier.push(child_node)
return None
def dft(self, starting_vertex):
"""
Print each vertex in depth-first order
beginning from starting_vertex.
"""
# make a stack
stack = Stack()
# make a visited set
visited = set()
# put starting vertex in the stack
stack.push(starting_vertex)
# while the stack isn't empty
while stack.size():
# Pop off the top of the stack, it is current item
node = stack.pop()
# if node isn't visited
if node not in visited:
print(node)
# mark as visited
visited.add(node)
# for each of our current item's edges
for edge in self.vertices[node]:
stack.push(edge)
def dft(starting_position):
"""
Print each vertex in depth-first order
beginning from starting_vertex.
"""
# Create a queue/stack as appropriate
stack = Stack()
# Put the starting point in that
stack.push(starting_position.current_room)
# Make a set to keep track of where we've been
visited = {}
# While there is stuff in the queue/stack
while stack.size() > 0:
# Pop the first item
position = stack.pop()
# If not visited
if position.id not in visited:
# DO THE THING!
exits = position.get_exits()
visited[position.id] = {'n': '?', 's': '?', 'w': '?', 'e': '?'}
for exit in exits:
for idx, val in visited[position.id].items():
if idx == exit:
if idx == 'n':
visited[position.id][idx] = position.n_to.id
if idx == 's':
visited[position.id][idx] = position.s_to.id
if idx == 'e':
visited[position.id][idx] = position.e_to.id
if idx == 'w':
visited[position.id][idx] = position.w_to.id
for next_position in world.rooms:
stack.push(world.rooms[next_position])
return visited
def explore(player, db, db_id):
s = Stack()
local_visited = set()
visited_ids = set()
print(f'EXPLORING THE MAP')
init_room = player.initalize()
print(f'Initial room: {init_room}')
time.sleep(init_room["cooldown"])
# save room in db
db.insert_room(init_room)
for direction in init_room["exits"]:
s.push({str(init_room["room_id"]): direction})
db.update_stack(player, s.get_stack())
# STOP conditon == empty local stack and global que
while s.size() > 0:
current_room = s.pop()
current_room_id = list(current_room.keys())[0]
current_room_dir = current_room[current_room_id]
visited_ids.add(current_room_id)
print(f"Visited {len(visited_ids)} rooms")
print(
f'### Currently in room {current_room_id} moving to {current_room_dir} ###')
if str(current_room) not in local_visited:
local_visited.add(str(current_room))
# Make request for next movement
global_map = db.get_map(db_id)
if current_room_id not in global_map:
global_map[current_room_id] = {}
cur_room_dirs = global_map[current_room_id]
# check whether the next dir exists on the db map
if current_room_dir in cur_room_dirs:
next_room = player.wise_explore(
current_room_dir, cur_room_dirs[current_room_dir])
else:
# otherwise just use move
next_room = player.move(current_room_dir)
print(f'Next room: {next_room}')
# save next_room in DB
db.insert_room(next_room)
print('Going to sleep')
time.sleep(next_room["cooldown"])
# update map with newly discovered directions
update_map(current_room, next_room, db, db_id)
# check if next room is a shop and save it in DB if it is
shop_check(next_room, player, db, db_id)
# check for treasure
treasure_check(next_room, player, db, db_id)
# change name room
if next_room["room_id"] == 467:
print(f"Found Pirate Ry's name changer")
names = {"player55": "pavol", "player52": "diana", "player54": "markm", "player53": "talent antonio"}
if player["name"] in names:
res = player.change_name(names[player["name"]])
print(f"Changed name: {res}")
time.sleep(res["cooldown"])
# shrine room
if next_room["room_id"] == 22:
print("Found Shrine!")
i_pray = player.pray()
print(f"You prayed at the shrine: {i_pray}")
time.sleep(i_pray["cooldown"])
stack_before = s.size()
# add exits from next_room to stack and que
for direction in next_room["exits"]:
# check if the direction is the return direction
oposite_directions = {"n": "s", "s": "n", "e": "w", "w": "e"}
if oposite_directions[direction] != current_room_dir:
n_dict = {str(next_room["room_id"]): direction}
if str(n_dict) not in local_visited:
s.push(n_dict)
# update stack on db
db.update_stack(player, s.get_stack())
stack_after = s.size()
# if we dont push any rooms to the stack, we hit dead end => start BFT
if stack_before == stack_after:
# BFT will return shortest PATH to the next non-visited room
shortest_path = []
try:
# if current_room_id == s.stack[-1].id (you hit a dead end in looped nodes(cyclic graph))
# take s.stack[-2].id as TARGET if it exist
# if it doesnt (means the stack is empty) you are finished
if next_room["room_id"] == list(s.stack[-1].keys())[0]:
# BFS entry and target nodes:
# both have to be instances of room objects
# get rooms from DB by their ID
start = db.get_room_by_id(next_room["room_id"])
target = db.get_room_by_id(
list(s.stack[-2].keys())[0])
print(f'>>>> HIT A LOOPED NODE <<<<')
shortest_path = traverse(
start, target, db)
else:
# BFS entry and target nodes:
# get room from DB by its ID
start = db.get_room_by_id(next_room["room_id"])
target = db.get_room_by_id(
list(s.stack[-1].keys())[0])
shortest_path = traverse(
start, target, db)
traverse_path(shortest_path, player, db, db_id)
except IndexError:
print('We are done!')
else:
print(
f"{current_room} already visited")
class Program:
def __init__(self):
self.focus = Stack()
self.running = False
self.win = None
self.s = None
self.tabs = None
self.bomb = None
def init_state(self):
self.modules = [None, None, None, None, None, None, None, None]
self.tabs = Tabs(5, 0, *["Empty"] * 8)
self.focus = Stack()
self.slot = -1
bomb = self.bomb = Bomb(self)
bomb.notify_on_finish(self.bomb_info_finished)
self.update_bomb_info(bomb)
chooser = ModuleChooser(self)
self.focus.push(chooser)
self.focus.push(bomb)
def run(self, screen):
if self.running:
return
self.running = True
self.screen = screen
curses.noecho()
curses.curs_set(0)
curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_BLUE, curses.COLOR_BLACK)
curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_WHITE)
max_y, max_y = screen.getmaxyx()
self.win = win = curses.newwin(50, max_y, 7, 0)
win.keypad(1)
self.init_state()
self.add_decoration()
self.tabs.update(screen)
while True:
logging.debug("Program: Updating current object {:}".format(
self.focus.cur()))
self.focus.cur().update(win)
logging.debug("Program: Refreshing window")
screen.refresh()
win.refresh()
logging.debug("Program: Waiting for event")
ev = win.getch()
if ev == curses.KEY_F12:
return
elif ev == curses.KEY_F10:
if not type(self.focus.cur()) is Bomb:
self.slot = -1
win.erase()
self.focus.push(self.bomb)
elif ev == curses.KEY_F11:
self.init_state()
elif curses.KEY_F1 <= ev <= curses.KEY_F8:
curses.curs_set(0)
self.slot = ev - curses.KEY_F1
logging.debug("Program: Selected module {}".format(self.slot))
if not type(self.focus.cur()) is ModuleChooser:
self.focus.pop()
if self.modules[self.slot]:
logging.debug(
"Program: Current module active: {!s:}".format(
self.focus.cur()))
self.focus.push(self.modules[self.slot])
self.win.erase()
else:
self.focus.cur().event(ev, chr(ev))
self.tabs.set_active(self.slot)
self.tabs.update(screen)
if self.focus.cur() is None:
win.addstr(10, 50, "No module active")
def bomb_info_finished(self, bomb):
logging.debug("Program: Bomb info finished")
self.update_bomb_info(bomb)
if self.slot == -1:
self.slot = 0
self.focus.pop()
def update_bomb_info(self, bomb):
self.screen.move(1, 0)
self.screen.clrtoeol()
self.screen.addstr("batteries: {!s: <9} parallel: {}".format(
bomb.batteries, bomb.parallel))
self.screen.move(2, 0)
self.screen.clrtoeol()
self.screen.addstr("serial: {!s: <9} vowels: {}".format(
bomb.serial, bomb.vowels))
self.screen.move(3, 0)
self.screen.clrtoeol()
self.screen.addstr("FRK: {!s: <9} CAR: {}".format(
bomb.frk, bomb.car))
def set_module(self, module):
self.modules[self.slot] = module
self.tabs.set_tab(self.slot, module.title)
self.focus.push(module)
def add_decoration(self):
self.screen.addstr(
0, 0, " Keep talking and Nobody Explodes - Manual helper",
curses.A_REVERSE | curses.A_BOLD)
y, x = self.screen.getyx()
max_y, max_x = self.screen.getmaxyx()
length = max_x - x
self.screen.addstr(" " * length, curses.A_REVERSE | curses.A_BOLD)
self.screen.addstr(6, 0, "─" * max_x)
class DbSession(object):
"""Provides an API for users to make changes to an in-memory database with transactions.
Attributes:
database: An instance of an in-memory database.
transaction_stack: A stack of active transactions.
current_trans: The currently active transaction. Transactions are a set of keys which
represent keys in the database that have been edited during the current transaction.
"""
def __init__(self):
self.database = InMemoryDatabase()
self.transaction_stack = Stack()
self.current_trans = None
self.reset_transaction_state()
def reset_transaction_state(self):
self.current_trans = set() if self.transaction_stack.is_empty() else self.transaction_stack.current()
# Transaction stack should always have a 'base' transaction which can't be rolled back/commited
self.transaction_stack = Stack(self.current_trans)
def pop_transaction(self):
self.transaction_stack.pop()
self.current_trans = self.transaction_stack.current()
def has_open_transaction(self):
return self.transaction_stack.size() > 1
def begin(self):
self.current_trans = set()
self.transaction_stack.push(self.current_trans)
def rollback(self):
if not self.has_open_transaction():
print('NO TRANSACTION')
else:
map(self.database.remove, list(self.current_trans))
self.pop_transaction()
def commit(self):
if not self.has_open_transaction():
print('NO TRANSACTION')
else:
self.database.flatten()
self.reset_transaction_state()
def set_var(self, var, value):
if var in self.current_trans:
self.database.change(var, value)
else:
self.database.add(var, value)
self.current_trans.add(var)
def unset_var(self, var):
self.set_var(var, None)
def get_var(self, var):
print(self.database.get(var) or 'NULL')
def num_equal_to(self, value):
print(self.database.num_equal_to(value))
def __repr__(self):
return '{}\nTransaction Stack: {}'.format(self.database, self.transaction_stack)
class DbSession(object):
"""Provides an API for users to make changes to an in-memory database with transactions.
Attributes:
database: An instance of an in-memory database.
transaction_stack: A stack of active transactions.
current_trans: The currently active transaction. Transactions are a set of keys which
represent keys in the database that have been edited during the current transaction.
"""
def __init__(self):
self.database = InMemoryDatabase()
self.transaction_stack = Stack()
self.current_trans = None
self.reset_transaction_state()
def reset_transaction_state(self):
self.current_trans = set() if self.transaction_stack.is_empty(
) else self.transaction_stack.current()
# Transaction stack should always have a 'base' transaction which can't be rolled back/commited
self.transaction_stack = Stack(self.current_trans)
def pop_transaction(self):
self.transaction_stack.pop()
self.current_trans = self.transaction_stack.current()
def has_open_transaction(self):
return self.transaction_stack.size() > 1
def begin(self):
self.current_trans = set()
self.transaction_stack.push(self.current_trans)
def rollback(self):
if not self.has_open_transaction():
print('NO TRANSACTION')
else:
map(self.database.remove, list(self.current_trans))
self.pop_transaction()
def commit(self):
if not self.has_open_transaction():
print('NO TRANSACTION')
else:
self.database.flatten()
self.reset_transaction_state()
def set_var(self, var, value):
if var in self.current_trans:
self.database.change(var, value)
else:
self.database.add(var, value)
self.current_trans.add(var)
def unset_var(self, var):
self.set_var(var, None)
def get_var(self, var):
print(self.database.get(var) or 'NULL')
def num_equal_to(self, value):
print(self.database.num_equal_to(value))
def __repr__(self):
return '{}\nTransaction Stack: {}'.format(self.database,
self.transaction_stack)
class Program:
def __init__(self):
self.focus = Stack()
self.running = False
self.win = None
self.s = None
self.tabs = None
self.bomb = None
def init_state(self):
self.modules = [None, None, None, None, None, None, None, None]
self.tabs = Tabs(5, 0, *["Empty"] * 8)
self.focus = Stack()
self.slot = -1
bomb = self.bomb = Bomb(self)
bomb.notify_on_finish(self.bomb_info_finished)
self.update_bomb_info(bomb)
chooser = ModuleChooser(self)
self.focus.push(chooser)
self.focus.push(bomb)
def run(self, screen):
if self.running:
return
self.running = True
self.screen = screen
curses.noecho()
curses.curs_set(0)
curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_BLUE, curses.COLOR_BLACK)
curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_WHITE)
max_y, max_y = screen.getmaxyx()
self.win = win = curses.newwin(50, max_y, 7, 0)
win.keypad(1)
self.init_state()
self.add_decoration()
self.tabs.update(screen)
while True:
logging.debug("Program: Updating current object {:}".format(self.focus.cur()))
self.focus.cur().update(win)
logging.debug("Program: Refreshing window")
screen.refresh()
win.refresh()
logging.debug("Program: Waiting for event")
ev = win.getch()
if ev == curses.KEY_F12:
return
elif ev == curses.KEY_F10:
if not type(self.focus.cur()) is Bomb:
self.slot = -1
win.erase()
self.focus.push(self.bomb)
elif ev == curses.KEY_F11:
self.init_state()
elif curses.KEY_F1 <= ev <= curses.KEY_F8:
curses.curs_set(0)
self.slot = ev - curses.KEY_F1
logging.debug("Program: Selected module {}".format(self.slot))
if not type(self.focus.cur()) is ModuleChooser:
self.focus.pop()
if self.modules[self.slot]:
logging.debug("Program: Current module active: {!s:}".format(self.focus.cur()))
self.focus.push(self.modules[self.slot])
self.win.erase()
else:
self.focus.cur().event(ev, chr(ev))
self.tabs.set_active(self.slot)
self.tabs.update(screen)
if self.focus.cur() is None:
win.addstr(10, 50, "No module active")
def bomb_info_finished(self, bomb):
logging.debug("Program: Bomb info finished")
self.update_bomb_info(bomb)
if self.slot == -1:
self.slot = 0
self.focus.pop()
def update_bomb_info(self, bomb):
self.screen.move(1,0)
self.screen.clrtoeol()
self.screen.addstr("batteries: {!s: <9} parallel: {}".format(bomb.batteries, bomb.parallel))
self.screen.move(2,0)
self.screen.clrtoeol()
self.screen.addstr("serial: {!s: <9} vowels: {}".format(bomb.serial, bomb.vowels))
self.screen.move(3,0)
self.screen.clrtoeol()
self.screen.addstr("FRK: {!s: <9} CAR: {}".format(bomb.frk, bomb.car))
def set_module(self, module):
self.modules[self.slot] = module
self.tabs.set_tab(self.slot, module.title)
self.focus.push(module)
def add_decoration(self):
self.screen.addstr(0,0, " Keep talking and Nobody Explodes - Manual helper", curses.A_REVERSE | curses.A_BOLD)
y, x = self.screen.getyx()
max_y, max_x = self.screen.getmaxyx()
length = max_x - x
self.screen.addstr(" " * length, curses.A_REVERSE | curses.A_BOLD)
self.screen.addstr(6,0, "─" * max_x)
return None, None
def move_player(move):
player.travel(move.dir)
traversalPath.append(move.dir)
prevRoom = move.origin
currRoom = player.currentRoom.id
# if loop handle assiging exits
if currRoom in visited.keys() and visited[prevRoom][move.dir] == '?':
visited[currRoom][move.reverse()] = prevRoom
visited[prevRoom][move.dir] = currRoom
while stack.size() > 0:
move = stack.pop()
move.dir and move_player(move)
prevRoom = move.origin
currRoom = player.currentRoom.id
# new room found
if currRoom not in visited.keys():
visited[currRoom] = {}
visited[currRoom]['?'] = 0
exits = player.currentRoom.getExits()
for exit in exits:
if exit not in visited[currRoom]:
# If played moved and exit is where we entered the room from
if move.dir and exit == move.reverse():
visited[currRoom][exit] = prevRoom
def convert(self, verbose):
self.verbose = verbose
operators = "^*+-\/"
# operands = string.ascii_lowercase + string.digits
output = Queue()
stack = Stack()
for token in self.infix:
operands = re.match("^[a-z]$|^\d+\.\d+$|^\d+$", token)
operators = re.match("^[+-\/*^]$", token)
# if token is a number or variable add it to putput
if operands:
output.push(token)
if self.verbose == True:
print "1 token = %s, output = %s" % (token, output.list[::-1])
# if the token is variable add it mapVariable dictionary
if token in string.ascii_lowercase:
self.mapVariables[token] = ""
# if token is an operator
elif operators:
# while there is another operator on the stack
while not stack.isEmpty():
# if operator is lef-associative and its precedence is less than or equal to that on stack, or operator has precedence less than that on stack (is not left-associative)
if stack.lastOnStack() != "(" and (
(
self.precedence[token][0] <= self.precedence[stack.lastOnStack()][0]
and self.precedence[token][1] == "L"
)
or self.precedence[token][0] < self.precedence[stack.lastOnStack()][0]
):
# push operator to output from stack
output.push(stack.pop())
if self.verbose == True:
print "2 token = %s, output = %s" % (token, output.list[::-1])
else:
break
# push operator to stack
stack.push(token)
if self.verbose == True:
print "3 token = %s, stack = %s" % (token, stack.list[::-1])
# if token is left parenthesis push it to stack
elif token == "(":
stack.push(token)
if self.verbose == True:
print "4 token = %s, stack = %s" % (token, stack.list[::-1])
# if token is right parenthesis
elif token == ")":
# until token at the top of stack is not left parethesis
while stack.lastOnStack() != "(":
# push from stack to output
output.push(stack.pop())
if self.verbose == True:
print "5 token = %s, output = %s" % (token, output.list[::-1])
# and pop left parethesis from stack but not to output
stack.pop()
if self.verbose == True:
print "Left on stack " + str(stack.list[::-1])
print "Output " + str(output.list)
self._rpn = output.list[::-1]
while len(stack.list) > 0:
self._rpn.append(stack.pop())
if self.verbose == True:
print "RPN value = " + str(self._rpn)
return self._rpn
def __kruskal_optimized(graph):
"""
+ OPTIMAL
- UnionFind/Partition Dataset
+ used to check if if path is acyclic in optimal way
(just like 2 sets list in un-optimal way)
"""
class __UnionFind:
"""
Used for two set opns - (using just a list/hmap)
+ Set Membership
+ Union opn.
"""
def __init__(self, list_of_node_ids):
# note: can be a list as well where IDs are idxs
self.__partition = {}
for _id in list_of_node_ids:
# initially each node is root of it's own tree
self.__partition[_id] = _id
def find_root(self, x_id):
# if roots of two ids are same - same path i.e same path
# note: this is ammortized 1 - path depth is notably small
cur_node = self.__partition[x_id]
while self.__partition[cur_node] != cur_node:
# update
cur_node = self.__partition[cur_node]
return cur_node # ends at root
def union(self, u_id_root, v_id_root):
# point any one of roots to other
self.__partition[u_id_root] = v_id_root
def get_path(self, x_id):
path = []
cur_node = self.__partition[x_id]
while self.__partition[cur_node] != cur_node:
path = path.append(cur_node)
cur_node = self.__partition[cur_node]
return path
# ---------------------------------
# end class UnionFind / partition
# ----------------------------------
# kruskals algorithm:
# -------------------
# get sorted edges
list_of_all_edges = sorted(graph.edges, reverse=True) # |E| lg(|E|)
sorted_edges = Stack(list_of_all_edges)
n_vtxs = len(graph.vtx_map.keys())
# create patrition for faster union/set membership
partition = __UnionFind(graph.vtx_map.keys())
MST_edges = []
while len(MST_edges) != (n_vtxs - 1): # always n_vtxs-1 edges in MST
_cur_edge = sorted_edges.pop()
cur_u_id = _cur_edge.u_id
cur_v_id = _cur_edge.v_id
cur_wt = _cur_edge.wt
root_u_id = partition.find_root(cur_u_id)
root_v_id = partition.find_root(cur_v_id)
if root_u_id == root_v_id: # same path hence, ignore.
continue
#else append to accumulator and union the sets
MST_edges.append(Graph.__Edge(cur_u_id, cur_v_id, cur_wt))
partition.union(root_u_id, root_v_id)
# geting all nodes can be done from returned edges
return MST_edges
