CTCI 3.2/3.3

Python solutions

Author: kyle8998

CTCI/Chapter3/3.1-Three_In_One.py

@@ -29,6 +29,43 @@ def pop(self, stack_number):
 #-------------------------------------------------------------------------------
 # CTCI Solution 
 
+class MultiStack:
+
+    def __init__(self, stacksize):
+        self.numstacks = 3
+        self.array = [0] * (stacksize * self.numstacks)
+        self.sizes = [0] * self.numstacks
+        self.stacksize = stacksize
+
+    def Push(self, item, stacknum):
+        if self.IsFull(stacknum):
+            raise Exception('Stack is full')
+        self.sizes[stacknum] += 1
+        self.array[self.IndexOfTop(stacknum)] = item
+
+    def Pop(self, stacknum):
+        if self.IsEmpty(stacknum):
+            raise Exception('Stack is empty')
+        value = self.array[self.IndexOfTop(stacknum)]
+        self.array[self.IndexOfTop(stacknum)] = 0
+        self.sizes[stacknum] -= 1
+        return value
+
+    def Peek(self, stacknum):
+        if self.IsEmpty(stacknum):
+            raise Exception('Stack is empty')
+        return self.array[self.IndexOfTop(stacknum)]
+
+    def IsEmpty(self, stacknum):
+        return self.sizes[stacknum] == 0
+
+    def IsFull(self, stacknum):
+        return self.sizes[stacknum] == self.stacksize
+
+    def IndexOfTop(self, stacknum):
+        offset = stacknum * self.stacksize
+        return offset + self.sizes[stacknum] - 1
+
 #-------------------------------------------------------------------------------
 #Testing
 

CTCI/Chapter3/3.2-Stack_Min.py

@@ -0,0 +1,115 @@
+# CTCI 3.1
+# Three in One
+
+import unittest
+
+class MinStack():
+  def __init__(self):
+    self.top, self._min = None, None
+    
+  def min(self):
+    if self._min:
+        return self._min.data
+    else:
+        return None
+ 
+  def push(self, item):
+    if self._min and item >= self._min.data:
+        self._min = Node(data=self._min.data, next=self._min)
+    else:
+        self._min = Node(data=item, next=self.top)
+    self.top = Node(data=item, next=self.top)
+
+  def pop(self):
+    if not self.top:
+        return None
+    else:
+        self._min = self._min.next
+        item = self.top.data
+        self.top = self.top.next
+        return item
+    
+    
+
+#-------------------------------------------------------------------------------
+# CTCI Solution 
+
+class MultiStack:
+
+    def __init__(self, stacksize):
+        self.numstacks = 1
+        self.array = [0] * (stacksize * self.numstacks)
+        self.sizes = [0] * self.numstacks
+        self.stacksize = stacksize
+        self.minvals = [sys.maxint] * (stacksize * self.numstacks)
+
+    def Push(self, item, stacknum):
+        if self.IsFull(stacknum):
+            raise Exception('Stack is full')
+        self.sizes[stacknum] += 1
+        if self.IsEmpty(stacknum):
+            self.minvals[self.IndexOfTop(stacknum)] = item
+        else:
+            self.minvals[self.IndexOfTop(stacknum)] = min(
+                item, self.minvals[self.IndexOfTop(stacknum) - 1])
+        self.array[self.IndexOfTop(stacknum)] = item
+
+    def Pop(self, stacknum):
+        if self.IsEmpty(stacknum):
+            raise Exception('Stack is empty')
+        value = self.array[self.IndexOfTop(stacknum)]
+        self.array[self.IndexOfTop(stacknum)] = 0
+        self.sizes[stacknum] -= 1
+        return value
+
+    def Peek(self, stacknum):
+        if self.IsEmpty(stacknum):
+            raise Exception('Stack is empty')
+        return self.array[self.IndexOfTop(stacknum)]
+
+    def Min(self, stacknum):
+        return self.minvals[self.IndexOfTop(stacknum)]
+
+    def IsEmpty(self, stacknum):
+        return self.sizes[stacknum] == 0
+
+    def IsFull(self, stacknum):
+        return self.sizes[stacknum] == self.stacksize
+
+    def IndexOfTop(self, stacknum):
+        offset = stacknum * self.stacksize
+        return offset + self.sizes[stacknum] - 1
+
+#-------------------------------------------------------------------------------
+#Testing
+
+class Node():
+  def __init__(self, data=None, next=None):
+    self.data, self.next = data, next
+  
+  def __str__(self):
+    string = str(self.data)
+    if self.next:
+      string += ',' + str(self.next)
+    return string
+
+class Test(unittest.TestCase):
+  def test_min_stack(self):
+    min_stack = MinStack()
+    self.assertEqual(min_stack.min(), None)
+    min_stack.push(7)
+    self.assertEqual(min_stack.min(), 7)
+    min_stack.push(6)
+    min_stack.push(5)
+    self.assertEqual(min_stack.min(), 5)
+    min_stack.push(10)
+    self.assertEqual(min_stack.min(), 5)
+    self.assertEqual(min_stack.pop(), 10)
+    self.assertEqual(min_stack.pop(), 5)
+    self.assertEqual(min_stack.min(), 6)
+    self.assertEqual(min_stack.pop(), 6)
+    self.assertEqual(min_stack.pop(), 7)
+    self.assertEqual(min_stack.min(), None)
+
+if __name__ == "__main__":
+  unittest.main()

CTCI/Chapter3/3.3-Stack_Of_Plates.py

@@ -0,0 +1,67 @@
+# CTCI 3.1
+# Three in One
+
+import unittest
+
+class MultiStack():
+    def __init__(self, capacity):
+        self.capacity = capacity
+        self.stacks = []
+
+    def push(self, item):
+        if len(self.stacks) and (len(self.stacks[-1]) < self.capacity):
+            self.stacks[-1].append(item)
+        else:
+            self.stacks.append([item])
+
+    def pop(self):
+        while len(self.stacks) and (len(self.stacks[-1]) == 0):
+            self.stacks.pop()
+        if len(self.stacks) == 0:
+            return None
+        item = self.stacks[-1].pop()
+        if len(self.stacks[-1]) == 0:
+            self.stacks.pop()
+        return item
+
+    def pop_at(self, stack_number):
+        if (stack_number < 0) or (len(self.stacks) <= stack_number):
+            return None
+        if len(self.stacks[stack_number]) == 0:
+            return None
+        return self.stacks[stack_number].pop()
+    
+
+#-------------------------------------------------------------------------------
+# CTCI Solution 
+
+
+#-------------------------------------------------------------------------------
+#Testing
+
+class Test(unittest.TestCase):
+  def test_multi_stack(self):
+    stack = MultiStack(3)
+    stack.push(11)
+    stack.push(22)
+    stack.push(33)
+    stack.push(44)
+    stack.push(55)
+    stack.push(66)
+    stack.push(77)
+    stack.push(88)
+    self.assertEqual(stack.pop(), 88)
+    self.assertEqual(stack.pop_at(1), 66)
+    self.assertEqual(stack.pop_at(0), 33)
+    self.assertEqual(stack.pop_at(1), 55)
+    self.assertEqual(stack.pop_at(1), 44)
+    self.assertEqual(stack.pop_at(1), None)
+    stack.push(99)
+    self.assertEqual(stack.pop(), 99)
+    self.assertEqual(stack.pop(), 77)
+    self.assertEqual(stack.pop(), 22)
+    self.assertEqual(stack.pop(), 11)
+    self.assertEqual(stack.pop(), None)
+
+if __name__ == "__main__":
+  unittest.main()

README.md

@@ -119,7 +119,9 @@ Cracking the Coding Interview 6th Edition Python Solutions
 | 2.7|            | Intersection                                                                                 | [Python](CTCI/Chapter2/2.7-Intersection.py)                     |
 | 2.8|            | Loop Detection                                                                               | [Python](CTCI/Chapter2/2.8-Loop_Detection.py)                   |
 |    |            |                                                                                              |                                                                 |
-| 3.1|            | Three in One                                                                                 | [Python](CTCI/Chapter2/3.1-Three_In_One.py)                     |
+| 3.1|            | Three in One                                                                                 | [Python](CTCI/Chapter3/3.1-Three_In_One.py)                     |
+| 3.2|            | Stack Min                                                                                    | [Python](CTCI/Chapter3/3.2-Stack_Min.py)                        |
+| 3.3|            | Stack of Plates                                                                              | [Python](CTCI/Chapter3/3.3-Stack_Of_Plates.py)                  |
 
 ---