8/25/23

Shooting for 10:

1) evaluate_rpn.py
2) is_valid_parenthsization.py
3) directory_path_normalization.py
4) sunset_view.py
5) queue_from_stacks.py
6) queue_with_max.py
7) circular_queue.py

Author: jsgoller1

elements-of-programming-interviews/problem_mapping.js

@@ -896,7 +896,7 @@ problem_mapping = {
                 "total": 108
             },
             "Python: evaluate_rpn.py": {
-                "passed": 0,
+                "passed": 108,
                 "total": 108
             }
         },
@@ -910,7 +910,7 @@ problem_mapping = {
                 "total": 78
             },
             "Python: is_valid_parenthesization.py": {
-                "passed": 0,
+                "passed": 78,
                 "total": 78
             }
         },
@@ -924,7 +924,7 @@ problem_mapping = {
                 "total": 255
             },
             "Python: directory_path_normalization.py": {
-                "passed": 0,
+                "passed": 255,
                 "total": 255
             }
         },
@@ -938,7 +938,7 @@ problem_mapping = {
                 "total": 101
             },
             "Python: sunset_view.py": {
-                "passed": 0,
+                "passed": 101,
                 "total": 101
             }
         },
@@ -966,7 +966,7 @@ problem_mapping = {
                 "total": 65
             },
             "Python: circular_queue.py": {
-                "passed": 0,
+                "passed": 65,
                 "total": 65
             }
         },
@@ -980,7 +980,7 @@ problem_mapping = {
                 "total": 65
             },
             "Python: queue_from_stacks.py": {
-                "passed": 0,
+                "passed": 65,
                 "total": 65
             }
         },
@@ -994,7 +994,7 @@ problem_mapping = {
                 "total": 201
             },
             "Python: queue_with_max.py": {
-                "passed": 0,
+                "passed": 201,
                 "total": 201
             }
         }

elements-of-programming-interviews/python/circular_queue.py

@@ -4,20 +4,57 @@
 
 class Queue:
     def __init__(self, capacity: int) -> None:
-        # TODO - you fill in here.
+        if capacity < 1:
+            raise RuntimeError(f"Queue must have at positive capacity (cannot use {capacity}).")
+        self.capacity = capacity
+        self.data = [""] * capacity
+        self._size = 0
+        self.tail = None
+        self.head = None
         return
 
+    def _resize(self, new_capacity):
+        new_data = [""] * new_capacity
+        head = self.head
+        for i in range(self._size):
+            new_data[i] = self.data[head]
+            head = (head + 1) % self.capacity
+        self.data = new_data
+        self.capacity = new_capacity
+        self.head = 0
+        self.tail = self._size - 1
+
     def enqueue(self, x: int) -> None:
-        # TODO - you fill in here.
+        if self._size == self.capacity:
+            self._resize(self.capacity * 2)
+
+        if self.tail == self.head == None:
+            self.head = self.tail = 0
+        else:
+            self.tail = (self.tail + 1) % self.capacity
+
+        self.data[self.tail] = x
+        self._size += 1
         return
 
     def dequeue(self) -> int:
-        # TODO - you fill in here.
-        return 0
+        if self._size == 0:
+            raise RuntimeError("Cannot dequeue from empty queue.")
+        val = self.data[self.head]
+        self.data[self.head] = ""
+
+        self._size -= 1
+        if self._size == 0:
+            self.tail = self.head = None
+        else:
+            self.head = (self.head + 1) % self.capacity
+        return val
 
     def size(self) -> int:
-        # TODO - you fill in here.
-        return 0
+        return self._size
+
+    def __repr__(self):
+        return f"Queue(capacity: {self.capacity}, size: {self._size}, tail: {self.tail}, head: {self.head}, {self.data})"
 
 
 def queue_tester(ops):

elements-of-programming-interviews/python/directory_path_normalization.py

@@ -1,12 +1,101 @@
 from test_framework import generic_test
 
 
+"""
+Allowed chars:
+- . (current path)
+- .. (parent dir)
+- / (subdir)
+- alphanum (dir name)
+- empty (same as .)
+
+cases:
+    - empty
+    - /////// -> / 
+    - / -> / 
+    - /../.. -> /
+    - ../.. -> ../..
+    - derp -> derp
+    - /derp -> /derp
+    - /derp/.. -> /
+    - derp/.. -> empty? 
+    - derp/../.. -> ..
+
+- Paths can be absolute (begin at '/') or relative (begin at current dir)
+- for abspaths, / is highest parent; any '..' from '/' yields '/'
+- for relpaths, each '..' either pops the last known dir, or appends '..' 
+"""
+
+
+def shortest_equivalent_path_first(path: str) -> str:
+    """
+    - is absolute? (first char)
+    - split path on '/' 
+    - keep stack
+    - for each item in path list:
+        - if char is ., skip it
+        - if item is alphanum, push it
+        - if item is ..:
+            - if dir is absolute, pop if stack is nonempty, else skip
+            - if dir is rel, pop if stack is nonempty and stack top not .., else push  
+    - return joined stack; prepend '/' is absolute path
+    """
+    if not path:
+        return path
+    absolute = path[0] == '/'
+
+    stack = []
+    dirs = [item for item in path.split('/') if item]
+    for item in dirs:
+        if item == "..":
+            if absolute and stack:
+                stack.pop()
+            elif not absolute and (not stack or stack[-1] == ".."):
+                stack.append(item)
+            elif not absolute and stack and stack[-1] != "..":
+                stack.pop()
+        elif item == ".":
+            continue
+        else:
+            stack.append(item)
+
+    return ("/" if absolute else "") + "/".join(stack)
+
+
 def shortest_equivalent_path(path: str) -> str:
-    # TODO - you fill in here.
-    return ''
+    if not path:
+        return path
+
+    stack = []
+    for item in (item for item in path.split('/') if (item and item != ".")):
+        if item == "..":
+            if stack and (path[0] == '/' or stack[-1] != ".."):
+                stack.pop()
+            else:
+                stack.append(item)
+        else:
+            stack.append(item)
+
+    return ("/" if path.startswith('/') else "") + "/".join(stack)
 
 
 if __name__ == '__main__':
+    cases = [
+        ("", ""),
+        ("///////", "/"),
+        ("/", "/"),
+        ("/../..", "/"),
+        ("../..", "../.."),
+        ("derp", "derp"),
+        ("/derp", "/derp"),
+        ("/derp/..", "/"),
+        ("derp/..", ""),
+        ("derp/../..", "..")
+    ]
+    for path, expected in cases:
+        actual = shortest_equivalent_path(path)
+        assert actual == expected, f"{path}: {actual} != {expected}"
+
     exit(
         generic_test.generic_test_main('directory_path_normalization.py',
                                        'directory_path_normalization.tsv',

elements-of-programming-interviews/python/evaluate_rpn.py

@@ -1,12 +1,50 @@
 from test_framework import generic_test
 
 
+OPERATIONS = ["*", "+", "/", "-"]
+
+
+def apply(operation, op1, op2):
+    if operation == "*":
+        return op1 * op2
+    elif operation == "+":
+        return op1+op2
+    elif operation == "/":
+        return op1 // op2
+    else:
+        return op1 - op2
+
+
 def evaluate(expression: str) -> int:
-    # TODO - you fill in here.
-    return 0
+    # NOTE: assuming valid expression
+    if not expression:
+        return 0
+    stack = []
+    expr = expression.split(",")
+    for val in expr:
+        if val not in OPERATIONS:
+            stack.append(int(val))
+        else:
+            op2 = stack.pop()
+            op1 = stack.pop()
+            stack.append(apply(val, op1, op2))
+    return stack.pop()
 
 
 if __name__ == '__main__':
+    """
+    cases = [
+        ("0", 0),
+        ("", 0),
+        ("4", 4),
+        ("-4", -4),
+        ("4,4,+", 8),
+        ("10,10,X,4,4,+,+,2,/", 54)
+
+    ]
+    for expression, expected in cases:
+        assert evaluate(expression) == expected, f"{evaluate(expression)} != {expected}"
+    """
     exit(
         generic_test.generic_test_main('evaluate_rpn.py', 'evaluate_rpn.tsv',
                                        evaluate))

elements-of-programming-interviews/python/is_valid_parenthesization.py

@@ -2,11 +2,22 @@
 
 
 def is_well_formed(s: str) -> bool:
-    # TODO - you fill in here.
-    return True
+    BRACES = {
+        '{': '}',
+        '(': ')',
+        '[': ']'
+    }
+    stack = []
+    for c in s:
+        if c in BRACES:
+            stack.append(c)
+        elif not stack or not (c == BRACES[stack.pop()]):
+            return False
+    return len(stack) == 0
 
 
 if __name__ == '__main__':
+    # is_well_formed("()")
     exit(
         generic_test.generic_test_main('is_valid_parenthesization.py',
                                        'is_valid_parenthesization.tsv',

elements-of-programming-interviews/python/queue_from_stacks.py

@@ -3,13 +3,18 @@
 
 
 class Queue:
+    def __init__(self):
+        self.in_stack = []
+        self.out_stack = []
+
     def enqueue(self, x: int) -> None:
-        # TODO - you fill in here.
-        return
+        self.in_stack.append(x)
 
     def dequeue(self) -> int:
-        # TODO - you fill in here.
-        return 0
+        if not self.out_stack:
+            while self.in_stack:
+                self.out_stack.append(self.in_stack.pop())
+        return self.out_stack.pop()
 
 
 def queue_tester(ops):

elements-of-programming-interviews/python/queue_with_max.py

@@ -1,19 +1,51 @@
 from test_framework import generic_test
 from test_framework.test_failure import TestFailure
 
+"""
+- max stack uses separate stack
+- queue adds to end, releases from front. 
+- any time we add to the end, the max can change; 
+  any time we release from front, too
+- likely not viable in O(c) time and space
+
+- use a deque
+- each time we find a new max, dump the old deque, start with 
+  just current element
+- if we enqueue something less than current max, enqueue to deque
+- if the dequeued item matches current max, pop from deque
+"""
+
+import collections
+
 
 class QueueWithMax:
+    def __init__(self):
+        self.data = collections.deque()
+        self.max_vals = collections.deque()
+
     def enqueue(self, x: int) -> None:
-        # TODO - you fill in here.
-        return
+        self.data.appendleft(x)
+        if not self.max_vals:
+            self.max_vals.append(x)
+            return
+
+        if x > self.max_vals[-1]:
+            self.max_vals = collections.deque([x])
+        else:
+            while self.max_vals[0] < x:
+                self.max_vals.popleft()
+            self.max_vals.appendleft(x)
 
     def dequeue(self) -> int:
-        # TODO - you fill in here.
-        return 0
+        if self.data[-1] == self.max_vals[-1]:
+            self.max_vals.pop()
+        return self.data.pop()
 
     def max(self) -> int:
-        # TODO - you fill in here.
-        return 0
+        return self.max_vals[-1]
+
+    def __repr__(self):
+        return f"QueueWithMax(data: {self.data}, maxes: {self.max_vals})"
 
 
 def queue_tester(ops):