def bracket_validation(input):
    letters= []
    s = Stack()
    for x in input:
        if x is '{' or x is '(' or x is '[':
            s.push(x)
        if x is '}':
            temp=s.peek()
            if temp is '{':
                s.pop()
            else:
                return False    
        if x is ']':
            # return True
            temp=s.peek()
            if temp is '[':
                s.pop()
            else:
                return False
        if x is ')':
            temp=s.peek()
            if temp is '(':
                s.pop()
            else:
                return False
    if s.peek() is None:
        return True
    else:
        return False
예제 #2
0
def test_stack_peek():
    letters = Stack()
    assert not letters.peek()

    letters.push('A')
    assert letters.peek() == 'A'

    letters.push('B')
    assert letters.peek() == 'B'
예제 #3
0
class PseudoQueue(object):
    def __init__(self):
        self._stack1 = Stack()
        self._stack2 = Stack()

    def enqueue(self, val):
        self._stack1.push(val)

    def dequeue(self):
        if not self._stack2.peek():
            while self._stack1.peek():
                self._stack2.push(self._stack1.pop())
        return self._stack2.pop()
def multi_bracket_validation(input):
    stack = Stack()
    b = {')': '(', ']': '[', '}': '{'}
    for i in range(len(input) - 1):
        if input[i] in b.values():
            stack.push(input[i])
        if input[i] in b.keys():
            if stack.peek() == b[input[i]]:
                stack.pop()
            else:
                return False
    if stack.peek() == None:
        return True
    else:
        return False
class PseudoQueue:
    '''
    This PseudoQueue class definition can be used to create an instance of a queue data strucsture.  It will be composed of nodes and has the methods of enqueue, dequeue, is_empty, and peek.  It has attritubes of rear and front.  As an additional challenge... this class of PseudoQueues uses two stacks at its implementation layer.
    '''
    def __init__(self):
        self.front_stack = Stack()
        self.rear_stack = Stack()
        self.front = self.rear = None

    def enqueue(self, value=None):
        node = Node(value)
        if self.rear_stack.top:
            self.rear_stack.top.next_node = node
        self.rear_stack.top = node
        if not self.front_stack.top:
            self.front_stack.top = node
            self.front = self.front_stack.top

    def is_empty(self):
        return self.front_stack.is_empty()

    def dequeue(self, ):
        if self.front_stack.top == self.rear_stack.top:
            self.rear_stack.top = None
        value = self.front_stack.pop()
        print("front stack top is:")
        return value

    def peek(self):
        return self.front_stack.peek()
예제 #6
0
class Queue():
    def __init__(self):
        self.input_stack = Stack()
        self.output = Stack()

    def enqueue(self, value):
        self.input_stack.push(value)

    def dequeue(self):
        if self.output.peek() is not None:
            return output.pop()
        if self.input_stack.peek() is not None:
            while self.input_stack.peek() is not None:
                self.output.push(self.input_stack.pop())
            return self.output.pop()
        return None
예제 #7
0
def test_peek():
    s = Stack()
    s.push("apple")
    s.push("banana")
    actual = s.peek()
    expected = "banana"
    assert actual == expected
예제 #8
0
def test_can_successfully_peek_the_stack():
    new_stack = Stack()
    new_stack.push('green')
    new_stack.push('blue')

    expected = 'blue'
    actual = new_stack.peek()
    assert expected == actual
예제 #9
0
def test_stacks_and_queues_5 ():
    stack = Stack()
    stack.push('a')
    stack.push('b')
    stack.push('c')
    actual = stack.peek()
    expected = 'c'
    assert actual == expected
예제 #10
0
def test_can_successfully_push_multiple_values_onto_a_stack():
    new_stack = Stack()
    new_stack.push('blue')
    new_stack.push('red')
    new_stack.push('orange')
    new_stack.push('green')

    expected = 'green'
    actual = new_stack.peek()
    assert expected == actual
예제 #11
0
def test_can_successfully_pop_from_a_stack():
    new_stack = Stack()
    new_stack.push('red')
    new_stack.push('orange')
    new_stack.push('green')
    new_stack.push('blue')

    new_stack.pop()

    expected = 'green'
    actual = new_stack.peek()
    assert expected == actual
 def depth_first(self, start):
     visited = []
     s = Stack()
     s.push(start)
     visited.append(start)
     while s.is_empty() == False:
         curr = s.peek()
         flag = False
         for neighbor in self.get_neighbors(curr):
             if neighbor[0] not in visited and flag == False:
                 s.push(neighbor[0])
                 visited.append(neighbor[0])
                 flag = True
         if flag == False:
             s.pop()
     return visited
class PseudoQueue():
  def __init__(self):
    self.stack1 = Stack()
    self.stack2 = Stack()

  def enqueue(self, value):
    self.stack1.push(value)

  def dequeue(self):
    while self.stack1.peek():
      if self.stack1.top.next == None:
        return self.stack1.top.value
      
      else:
        temp = self.stack1.pop()
        self.stack2.push(temp)
        continue
def test_empty_stack_peek():
    s = Stack()
    assert s.peek() == 'this stack is empty buddy'
def test_stack_peek():
    s = Stack()
    s.push('hello world')
    s.push('quit peeking')
    assert s.peek() == 'quit peeking'
예제 #16
0
def test_peek_empty():
    s = Stack()
    with pytest.raises(InvalidOperationError) as e:
        s.peek()

    assert str(e.value) == "Not allowed on empty structure"
def test_peek_stack():
    stck2 = Stack()
    stck2.push(9)
    stck2.push(8)
    stck2.push(10)
    assert stck2.peek() == 10
def test_pop_from_empty():
    stck = Stack()
    assert stck.is_empty() == True
    with pytest.raises(AttributeError):
        stck.peek()
def test_stack_peek():
    stack5 = Stack()
    stack5.push(5)
    assert stack5.peek() == 5
    assert stack5.top.val == 5
def test_pop_or_peek_empty_stack():
    stack = Stack()
    with pytest.raises(EmptyStackException):
        stack.peek()
    with pytest.raises(EmptyStackException):
        stack.pop()
def test_peek_empty():
    s = Stack()
    with pytest.raises(InvalidOperationError) as e:
        s.peek()

    assert str(e.value) == "Method not allowed on empty collection"
예제 #22
0
def test_peek_on_empty_raises_exception():
    new_stack = Stack()
    expected = 'Exception'
    actual = new_stack.peek()
    assert expected == actual
예제 #23
0
def test_can_successfully_push_to_a_stack():
    new_stack = Stack()
    new_stack.push('blue')
    expected = 'blue'
    actual = new_stack.peek()
    assert expected == actual