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

Author: jsgoller1

Diff for: 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
             }
         },

Diff for: 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',

Diff for: 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))

Diff for: 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',

Diff for: 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):

Diff for: elements-of-programming-interviews/python/sunset_view.py

@@ -2,10 +2,22 @@
 
 from test_framework import generic_test
 
+"""
+- Input is a list of height
+- Output is list of indices
+
+[6,5,4,3,2,1]
+[1,2,3,4]
+"""
+
 
 def examine_buildings_with_sunset(sequence: Iterator[int]) -> List[int]:
-    # TODO - you fill in here.
-    return []
+    stack = []
+    for i, height in enumerate(sequence):
+        while stack and stack[-1][1] <= height:
+            stack.pop()
+        stack.append((i, height))
+    return [item[0] for item in reversed(stack)]
 
 
 def examine_buildings_with_sunset_wrapper(sequence):