Exemplo n.º 1
0
 def iter_deep(self):
     """ Iterative Deepening Search """
     for depth in range(1, DEPTH_LIMIT):
         solution = self.search(Stack(), False, depth)
         if solution.is_success():
             return solution
     return Solution()
Exemplo n.º 2
0
    def pressHotKeys(self, keys):
        #make a stack
        stack = Stack()
        temp = 0

        for key in keys:
            try:
                if key["type"] == 1:  # if is special type
                    if key["value"] in self.SpecialKeyCodes:
                        temp = self.SpecialKeyCodes[key["value"]]
                        gui.keyDown(temp)
                        stack.put(temp)
                else:
                    temp = key["value"]
                    if len(temp) == 1:
                        gui.keyDown(temp)
                        stack.put(temp)
            except:
                pass

        #empty the stack
        #unpress the key in the opposite order they were pressed
        while not stack.empty():
            temp = stack.get()
            gui.keyUp(temp)
 def scoreOfParentheses(self, S: str) -> int:
     # stack = Stack()
     # for ltr in S:
     #     if ltr == '(':
     #         stack.put(0)
     #     else:
     #         val = stack.get()
     #         if stack.qsize() > 0:
     #             if val == 0:
     #                 prev = stack.get()
     #                 prev += 1
     #                 stack.put(prev)
     #             else:
     #                 prev = stack.get()
     #                 prev += val*2
     #                 stack.put(prev)
     #         else:
     #             if val == 0:
     #                 stack.put(1)
     #             else:
     #                 stack.put(val*2)
     # return stack.get()
     cur_level = 0
     stack = Stack()
     for ltr in S:
         if ltr == '(':
             stack.put(cur_level)
             cur_level = 0
         else:
             maxx = max(1, cur_level)
             cur_level += stack.get() + maxx
             
     return(cur_level)
class Solution:
    def validTree(self, n, edges):
        """
        :type n: int
        :type edges: List[List[int]]
        :rtype: bool
        """
        if len(edges) != n-1:
            return False
        
        dic = defaultdict(list)
        for x, y in edges:
        	assert(isinstance(x, int) and isinstance(y, int))
            dic[x].append(y)
            dic[y].append(x)
        stack = Stack()
        stack.put(0)
        visited = set([0])
        while not stack.empty():
            node = stack.get()
            visited.add(node)
            for child in dic[node]:
                if child not in visited:
                    stack.put(child)
        return len(visited) == n
Exemplo n.º 5
0
    def DFS(self, initial_state):
        start_node = Node(initial_state, None, None, 0, initial_state.index(0))

        if start_node.goal_test().all():
            return start_node.find_solution()

        frontier = Stack()  ## List Stack
        frontier.put(start_node)
        explored = []  ## Needs changing, change to set().
        star = "**********************************"
        print("\nInitial State ---------- Depth: {0}".format(start_node.depth))
        while not (frontier.empty()):
            node = frontier.get()
            print("--------------------------------------------------")
            if node.goal_test().all():
                print("***************GOAL STATE FOUND*******************")
                print("\n")
                print(node.display())
                return node
            print("Depth = {0} \n".format(node.depth))
            print("{0}".format(node.display()))
            print(star)
            explored.append(node.state)
            children = node.generate_child()
            for child in children:
                if child.state not in explored:
                    frontier.put(child)

        return
Exemplo n.º 6
0
    def __init__(self):
        """Create the app."""

        super().__init__()

        self.configure_window()

        self.screen_stack = Stack(
        )  #Here the window will save a reference and order of the screens that it has packed
        #So that they can unpacked accordingly.
        self.pack_help_frame(
        )  #This frame provides help and a button to go to the previous window
        self.pack_initial_screen()  #Calling method to setup the initial screen
Exemplo n.º 7
0
def dfs(graph, start, goal):
    visited = set()
    stack = Stack()
    stack.put(start)

    while not stack.empty():
        node = stack.get()
        if node == goal:
            return True
        visited.add(node)
        for child in graph[node]:
            if child not in visited:
                stack.put(child)
    return False
Exemplo n.º 8
0
	def _display_dfs(self):
		if not self.root:
			return None
		container = Stack()
		container.put(self.root)
		while not container.empty():
			node = container.get()
			for i, child in enumerate(node.children):
				if child == None:
					continue
				if any(child.children):
					container.put(child)
				print(i, ":", child.key, end=", ")
			print('\n')
Exemplo n.º 9
0
class z9c(Serial):

    recv_buffer = Stack(maxsize=200)
    send_buffer = Stack(maxsize=200)
    dev = ""
    baud = ""

    def __init__(self, dev, baud=115200, async_mode=False):
        self.dev, self.baud = dev, baud
        super().__init__(port=self.dev, baudrate=self.baud)
        self.logger = logging.getLogger()
        self.logger.info(f"Initialized Device {dev} @Baudrate {baud}")
        self.connection = False
        self.try_timeout = 50
        self.id = str(uuid4())
        self.logger.info(
            f"Created Serial Device for resource {dev} as ID:{self.id}")
        self.establish_connection()
        self.async_mode = async_mode

    def clear_device_buffer(self):
        logging.debug("Clearing Device Buffer")
        while (out := self.recv())[1] == "ACK":
            continue
    def isValid(self, s):
        if not s:
            return True

        n = len(s)
        if n % 2 == 1:
            return False

        q = Stack(maxsize=n)
        for c in s:
            if isOpen(c):
                q.put(c)
            elif q.empty() or OP[c] != q.get():
                return False
        return q.empty()
Exemplo n.º 11
0
def lowestCommonAncestor(root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
    """
    Finds the lowest common ancestor of the given nodes in the tree.
    :param root: The root of the tree.
    :param p: TreeNode whose lowest common ancestor with q is to be found.
    :param q: TreeNode whose lowest common ancestor with p is to be found.
    :return: The lowest common ancestor of p and q if there is one.
    """

    # We use a stack to traverse the tree.
    stack = Stack()
    stack.put(root)

    # Dictionary to track the parents of each node.
    parents = {root: None}

    # We keep populating the parents dictionary till we haven't seen both
    # p and q.
    while p not in parents or q not in parents:

        # Get the node to be visited from the stack.
        node = stack.get()

        # Update the nodes children's parent and populate the stack
        if node.left:
            parents[node.left] = node
            stack.put(node.left)
        if node.right:
            parents[node.right] = node
            stack.put(node.right)

    # Set to hold unique ancestors as we traverse back along the parents
    # dictionary.
    ancestors = set()

    # Traverse upwards from p to the root of the tree and saving the path of
    # ancestors traversed along.
    while p:
        ancestors.add(p)
        p = parents[p]

    # Traverse upwards from q till we dont find a common ancestor in the path.
    while q not in ancestors:
        ancestors.add(q)
        q = parents[q]

    # return q if found else, q would be None.
    return q
Exemplo n.º 12
0
	def dfs(self, key):
		"""
		return node if found
		return None if not found
		"""
		if not self.root:
			return None
		stack = Stack()
		stack.put(self.root)
		while not stack.empty():
			node = stack.get()
			if key == node.key:
				return node
			for child in node.children[::-1]:
				stack.put(child)
		return None
Exemplo n.º 13
0
def check_balance(word):
    stack_validator = Stack()
    for i in word:
        if i == '(' or i == '[' or i == '{':
            stack_validator.put(i)
        else:
            if i == ')':
                if stack_validator.get() != '(':
                    return False
            elif i == ']':
                if stack_validator.get() != '[':
                    return False
            elif i == '}':
                if stack_validator.get() != '{':
                    return False
    if stack_validator.empty():
        return True
    else:
        return False
Exemplo n.º 14
0
 def hasCycle(self,
              graph):  # return True if graph has cycle, else return False
     visited = set()
     for node in graph.keys():
         if node not in visited:
             stack = Stack()
             stack.put(node)
             path = set([node])
             while not stack.emtpy():
                 node = stack.pop()
                 visited.add(node)
                 for child in graph[node]:
                     if child in path:
                         return True
                     if child not in visited and child in graph:
                         stack.append(child)
                         path.add(child)
         if len(visited) == len(graph): break
     return False
Exemplo n.º 15
0
 def countComponents(self, n, edges):
     """
     :type n: int
     :type edges: List[List[int]]
     :rtype: int
     """
     """
     Time: O(n)
     Space: O(n)
     """
     # input validation
     if n == 0 and len(edges) == 0:
         return 0
     if n != 0 and len(edges) == 0:
         return n
     assert(isinstance(n, int) and 0 < n)
     
     # initialization
     dic = defaultdict(list)
     for vi, vj in edges:
         dic[vi].append(vj)
         dic[vj].append(vi)
     visited = set()
     count = 0
     
     # process
     for i in range(n):
         if i in dic and i not in visited:
             stack = Stack()
             stack.put(i)
             while not stack.empty():
                 node = stack.get()
                 visited.add(node)
                 for child in dic[node]:
                     if child not in visited:
                         stack.put(child)
             count += 1
     return count + (n - len(visited))
     
     
             
             
Exemplo n.º 16
0
def up_link_down(sibling):
    letters = Stack()
    while sibling and not sibling.link:
        letters.put(sibling.parent_letter)
        sibling = sibling.parent

    if not sibling:
        return None, None

    node = sibling.link
    while not letters.empty():
        curr_letter = letters.get()
        if curr_letter in node.children:
            node = node.children[curr_letter]
            sibling = sibling.children[curr_letter]
            sibling.link = node
        else:
            break

    return node, sibling
Exemplo n.º 17
0
def dfs(problem):
    open_set = Stack() # LIFO open_set
    closed_set = set() # visited nodes set
    meta = dict() # meat information, meta[key] = (parent_state, action to reach child)

    # Initialize
    root = problem.get_root()
    meta[root] = (None, None)
    open_set.put(root)

    while not open_set.empty():
        node = open_set.get()
        if problem.isGoal(node):
            return construc_path(node, meta)
        for (child, action) in problem.getSuccessors(node):
            if child in closed_set:
                continue
            if child not in open_set:
                meta[child] = (node, action)
                open_set.put(child)
        closed_set.add(node)
Exemplo n.º 18
0
    def DLFS(self, initial_state, Depth):
        start_node = Node(initial_state, None, None, 0)
        start = time.time()  ##
        if start_node.goal_test().all():
            return start_node.find_solution()

        frontier = Stack()  ## List Stack
        frontier.put(start_node)
        explored = set()
        print("\nInitial State ---------- Depth: {0}".format(start_node.depth))
        while not (frontier.empty()):
            if DLFS.searchCanceled:
                print("canceled!")
                return
            self.max_stored = max(self.max_stored,
                                  frontier.qsize() + len(explored))
            node = frontier.get()

            if node.goal_test().all():
                print("***************GOAL STATE FOUND*******************")
                print("\n")
                print(node.display())
                DLFS.pathCost = node.depth  ##
                DLFS.maxStoredNodes = self.max_stored  ##
                DLFS.numProcessedNodes = node.num_processed  ##
                DLFS.timeTaken = time.time() - start  ##
                return node.find_solution()
            if (node.depth < Depth and tuple(node.state) not in explored):
                explored.add(tuple(node.state))
                children = node.generate_child()
                for child in children:
                    if DLFS.searchCanceled:
                        print("canceled!")
                        return
                    if tuple(child.state) not in explored:
                        frontier.put(child)

        return None
Exemplo n.º 19
0
def make_dfs(g: Graph):
    stack = Stack()
    visited = set()
    for v_idx in g.get_vertexes():
        if v_idx in visited:
            continue
        stack.put(v_idx)
        while (not stack.empty()):
            curr_v = stack.get()
            stack.put(curr_v)  # just peek, not pop
            has_unvisited_neighbor = False
            if curr_v not in visited:
                yield curr_v
                visited.add(curr_v)
            for neighbor_idx in g.get_neighbors(curr_v):
                if neighbor_idx in visited:
                    continue
                stack.put(neighbor_idx)
                has_unvisited_neighbor = True
                break
            if has_unvisited_neighbor:
                continue
            stack.get()  # pop
Exemplo n.º 20
0
 def calPoints(self, ops: List[str]) -> int:
     stack = Stack()
     accum = 0
     for op in ops:
         try:
             stack.put(int(op))
             accum += int(op)
         except:
             if op == 'C':
                 last_valid = stack.get()
                 accum -= last_valid
             elif op == 'D':
                 last_valid = stack.get()
                 accum += last_valid * 2
                 stack.put(last_valid)
                 stack.put(last_valid * 2)
             elif op == "+":
                 last_valid = stack.get()
                 before_last = stack.get()
                 accum += (last_valid + before_last)
                 stack.put(before_last)
                 stack.put(last_valid)
                 stack.put(before_last + last_valid)
     return accum
Exemplo n.º 21
0
 def __init__(self):
     LOGGER.debug(f"{self}")
     super(GPIOHypervisor, self).__init__()
     self.cmd = Stack(maxsize=4)
     self.logger = logging.getLogger("GPIO Hypervisor")
Exemplo n.º 22
0
 def __init__(self):
     LOGGER.debug(f"{self}")
     self.SEND = Stack(maxsize=256)
     self.CMD = Stack(maxsize=256)
Exemplo n.º 23
0
 def __init__(self, target):
     self.target = target
     self.RECV = Stack(maxsize=256)
     self.SEND = Stack(maxsize=256)
Exemplo n.º 24
0
 def __init__(self):
     self.stak = Stack()
     self.q = Queue()
Exemplo n.º 25
0
 def dfs(self):
     """ Depth-First Search """
     return self.search(Stack())
 def __init__(self):
     self.q = Stack()
Exemplo n.º 27
0
 def __init__(self):
     self.stack = Stack()
     self.top = None
Exemplo n.º 28
0
 def partition(self, s: str):
     path = Stack()
     result = []
     self.recursion(s, 0, len(s), path, result)
     return result