Merge pull request #15 from nickolasteixeira/chapter3

Chapter3

Author: fvntr

Python/chapter03/3.4 - Queue via Stacks/Nick.py

@@ -0,0 +1,123 @@
+#!/usr/bin/python3
+'''Queue via Stacks: Implement a MyQueue class
+which implements a queue using two stacks.'''
+import unittest
+
+
+class Stack:
+    def __init__(self):
+        self.stack = []
+        self.min = None
+
+    def getMin(self):
+        return self.min
+
+    def pop(self):
+        if not self.length:
+            print('No stack to pop')
+            return
+
+        item = self.stack.pop()
+
+        if item == self.min:
+            if self.length() > 0:
+                self.findMin()
+            else:
+                self.min = None
+        return item
+
+    def findMin(self):
+        self.min = self.stack[0]
+        for x in self.stack:
+            if x < self.min:
+                self.min = x
+
+    def length(self):
+        return len(self.stack)
+
+    def push(self, value):
+        if not self.min:
+            self.min = value
+        elif value < self.min:
+            self.min = value
+
+        self.stack.append(value)
+
+    def peek(self):
+        if not self.length:
+            print('No stack to peek')
+            return
+        return self.stack[-1]
+
+    def printStack(self):
+        if not self.length:
+            print('No stack to peeek')
+            return
+
+        print("Top of stack\n _ ")
+        for x in self.stack[::-1]:
+            print('|', x, '|')
+            print('|', '_', '|')
+
+
+class MyQueue:
+    def __init__(self):
+        self.newStack = Stack()
+        self.oldStack = Stack()
+
+    def push(self, value):
+        self.newStack.push(value)
+
+    def pop(self):
+        self.rotate()
+        if self.oldStack.length() == 0:
+            print('Nothing to pop in this queue')
+            return
+        return self.oldStack.pop()
+
+    def peek(self):
+        self.rotate()
+        if self.oldStack.length() == 0:
+            print('Nothing to peek in this queue')
+            return
+        return self.oldStack.peek()
+
+    def rotate(self):
+        if (self.oldStack.length() == 0):
+            while not self.newStack.length() == 0:
+                self.oldStack.push(self.newStack.pop())
+
+    def printQueue(self):
+        self.rotate()
+        for x in self.oldStack.stack[::-1]:
+            print('Item in Queue -->', x)
+
+        for x in self.newStack.stack:
+            print('Item in Queue -->', x)
+
+
+class Test(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        pass
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def test1(self):
+        arr = [2, 5, 7, 10, 3, 10, -1, -100]
+        print(arr)
+        q = MyQueue()
+        for x in arr:
+            q.push(x)
+
+        q.printQueue()
+        print('First in Queue --> Popped', q.pop())
+        print('Second in Queue --> Popped', q.pop())
+        q.printQueue()
+        print('Let\'s take a peek -->', q.peek())
+
+
+if __name__ == '__main__':
+    unittest.main()

Python/chapter03/3.5 - Sort Stack/Nick.py

@@ -0,0 +1,77 @@
+#!/usr/bin/python3
+'''Queue via Stacks: Implement a MyQueue class
+which implements a queue using two stacks.'''
+import unittest
+
+
+class Stack:
+    def __init__(self):
+        self.stack = []
+
+    def pop(self):
+        if self.isEmpty():
+            print('No stack to pop')
+            return
+
+        return self.stack.pop()
+
+    def isEmpty(self):
+        return len(self.stack) == 0
+
+    def push(self, value):
+        self.stack.append(value)
+
+    def peek(self):
+        if self.isEmpty():
+            print('No stack to peek')
+            return
+        return self.stack[-1]
+
+    def printStack(self):
+        if self.isEmpty():
+            print('No stack to peeek')
+            return
+
+        print("Top of stack\n _ ")
+        for x in self.stack[::-1]:
+            print('|', x, '|')
+            print('|', '_', '|')
+
+    def sort(self):
+        r = Stack()
+        while not self.isEmpty():
+            temp = self.pop()
+            print('Temp ->', temp)
+            while not r.isEmpty() and r.peek() > temp:
+                self.push(r.pop())
+            r.push(temp)
+            print('self stack', self.stack)
+            print(r.stack, end='\n\n')
+
+        while not r.isEmpty():
+            self.push(r.pop())
+
+
+class Test(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        pass
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def test1(self):
+        arr = [2, 5, 7, 10, 3, 10, -1, -100]
+        print(arr)
+        q = Stack()
+        for x in arr:
+            q.push(x)
+
+        q.printStack()
+        q.sort()
+        q.printStack()
+
+
+if __name__ == '__main__':
+    unittest.main()

Python/chapter03/3.6 - Animal Shelter/Nick.py

@@ -0,0 +1,88 @@
+#!/usr/bin/python3
+'''Animal Shelter: An animal shelter, which holds only
+dogs and cats, operates on a strictly"first in, first
+out" basis. People must adopt either the "oldest"
+(based on arrival time) of all animals at the shelter,
+or they can select whether they would prefer a dog or
+a cat (and will receive the oldest animal of that type).
+They cannot select which specific animal they would
+like. Create the data structures to maintain this
+system and implement operations such as enqueue,
+dequeueAny, dequeueDog, and dequeueCat. You may use
+the built-in Linked list data structure.
+Hints: #22, #56, #63'''
+import unittest
+
+
+class ShelterQueue:
+    def __init__(self):
+        self.queue = []
+
+    def enqueue(self, animal):
+        if len(self.queue) == 0:
+            self.queue.append(animal)
+        else:
+            self.queue.insert(0, animal)
+
+    def printQueue(self):
+        print('----- Beginning of Queue ------')
+        for x in self.queue[::-1]:
+            print(x)
+        print('------ End of Queue ------')
+
+    def dequeueAnimal(self, animal):
+        if len(self.queue) == 0:
+            return
+        temp = False
+        for x in self.queue[::-1]:
+            if animal in x:
+                temp = x
+                break
+        if temp:
+            pet = temp
+            self.queue.remove(temp)
+            return pet
+
+    def dequeueDog(self):
+        return self.dequeueAnimal('D')
+
+    def dequeueCat(self):
+        return self.dequeueAnimal('C')
+
+    def dequeueAny(self):
+        if len(self.queue) == 0:
+            return
+        return self.queue.pop()
+
+
+class Test(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        q = ShelterQueue()
+        animals = ['D1', 'D2', 'C1', 'D3', 'C2', 'C3', 'C4']
+        for x in animals:
+            q.enqueue(x)
+
+        q.printQueue()
+        print('{}  got adopted!'.format(q.dequeueDog()))  # D1
+        print('{}  got adopted!'.format(q.dequeueCat()))  # C1
+        q.printQueue()
+
+        print('{}  got adopted!'.format(q.dequeueAny()))  # D2
+        print('{}  got adopted!'.format(q.dequeueCat()))  # C2
+        print('{}  got adopted!'.format(q.dequeueAny()))  # D3
+        print('{}  got adopted!'.format(q.dequeueDog()))  # No Dogs
+        print('{}  got adopted!'.format(q.dequeueAny()))  # C3
+        print('{}  got adopted!'.format(q.dequeueCat()))  # C4
+        print('{}  got adopted!'.format(q.dequeueCat()))  # No Cats
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def test1(self):
+        pass
+
+
+if __name__ == '__main__':
+    unittest.main()