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())
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
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 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 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)
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)
def build(self, tree, X, y): init_capacity = 0 if tree.max_depth <= 10: init_capacity = (2**(tree.max_depth + 1)) - 1 else: init_capacity = 2047 tree._resize(init_capacity) splitter = self.splitter max_depth = self.max_depth min_samples_leaf = self.min_samples_leaf min_samples_split = self.min_samples_split min_impurity_decrease = self.min_impurity_decrease min_impurity_split = self.min_impurity_split splitter.init(X, y) n_node_samples = splitter.n_samples # SplitRecord split impurity = np.inf first = 1 max_depth_seen = -1 rc = 0 stack = Stack() # stack_record # node = StackRecord() # node.start = 0 # node.end = n_node_samples # node.depth = 0 # node.parent = _TREE_UNDEFINED # node.is_left = 0 # node.impurity = np.inf # node.n_constant_features = 0 stack.push(0, n_node_samples, 0, _TREE_UNDEFINED, 0, np.inf, 0) while not stack.is_empty() > 0: node = stack.pop() start = node.start end = node.end is_left = node.is_left is_leaf = node.is_leaf depth = node.depth n_node_samples = node.end - node.start splitter.node_reset(node.start, node.end) is_leaf = (node.depth >= max_depth or n_node_samples < min_samples_split or n_node_samples < 2 * min_samples_leaf) if first: impurity = splitter.node_impurity() first = 0 is_leaf = (is_leaf or (impurity <= min_impurity_split)) if not is_leaf: split, n_constant_features = splitter.node_split(impurity) is_leaf = ( is_leaf or split.pos >= node.end or (split.improvement + EPSILON < min_impurity_decrease)) node_id = tree._add_node(node.parent, node.is_left, is_leaf, split.feature, split.threshold, node.impurity, n_node_samples) splitter.node_value(tree.value + node_id * tree.value_stride) if not is_leaf: stack.push(split.pos, end, depth + 1, node_id, 0, split.impurity_right, n_constant_features) stack.push(start, split.pos, depth + 1, node_id, 1, split.impurity_left, n_constant_features) if depth > max_depth_seen: max_depth_seen = depth tree.max_depth = max_depth_seen