8/23/23

- delete_from_list.py
- is_string_palindromic_punctuation.py
- phone_number_mnemonic.py
- reverse_sublist.py
- reverse_words.py
- sorted_lists_merge.py
- is_list_cyclic.py

Author: jsgoller1

elements-of-programming-interviews/problem_mapping.js

@@ -546,7 +546,7 @@ problem_mapping = {
                 "total": 305
             },
             "Python: is_string_palindromic_punctuation.py": {
-                "passed": 0,
+                "passed": 305,
                 "total": 305
             }
         },
@@ -560,7 +560,7 @@ problem_mapping = {
                 "total": 103
             },
             "Python: reverse_words.py": {
-                "passed": 0,
+                "passed": 103,
                 "total": 103
             }
         },
@@ -676,7 +676,7 @@ problem_mapping = {
                 "total": 505
             },
             "Python: delete_from_list.py": {
-                "passed": 0,
+                "passed": 457,
                 "total": 457
             },
             "Python: insert_in_list.py": {
@@ -698,7 +698,7 @@ problem_mapping = {
                 "total": 501
             },
             "Python: sorted_lists_merge.py": {
-                "passed": 0,
+                "passed": 501,
                 "total": 501
             }
         },
@@ -712,7 +712,7 @@ problem_mapping = {
                 "total": 210
             },
             "Python: reverse_sublist.py": {
-                "passed": 0,
+                "passed": 210,
                 "total": 210
             }
         },
@@ -726,7 +726,7 @@ problem_mapping = {
                 "total": 102
             },
             "Python: is_list_cyclic.py": {
-                "passed": 0,
+                "passed": 102,
                 "total": 102
             }
         },
@@ -1548,7 +1548,7 @@ problem_mapping = {
                 "total": 629
             },
             "Python: smallest_subarray_covering_all_values.py": {
-                "passed": 0,
+                "passed": 13,
                 "total": 629
             }
         },
@@ -1988,7 +1988,7 @@ problem_mapping = {
                 "total": 102
             },
             "Python: phone_number_mnemonic.py": {
-                "passed": 0,
+                "passed": 102,
                 "total": 102
             }
         },

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

@@ -7,8 +7,8 @@
 
 # Delete the node past this one. Assume node is not a tail.
 def delete_after(node: ListNode) -> None:
-    # TODO - you fill in here.
-    return
+    if node and node.next:
+        node.next = node.next.next
 
 
 @enable_executor_hook

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

@@ -8,8 +8,23 @@
 
 
 def has_cycle(head: ListNode) -> Optional[ListNode]:
-    # TODO - you fill in here.
-    return None
+    if not head:
+        return head
+    slow = fast = head
+    while fast and fast.next:
+        fast = fast.next.next
+        slow = slow.next
+        if fast is slow:
+            break
+
+    if not fast or not fast.next:
+        return None
+
+    slow = head
+    while fast is not slow:
+        fast = fast.next
+        slow = slow.next
+    return fast
 
 
 @enable_executor_hook

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

@@ -1,12 +1,33 @@
 from test_framework import generic_test
 
+# empty is palindrome
+# " " is palindrome (it's also empty)
+
 
 def is_palindrome(s: str) -> bool:
-    # TODO - you fill in here.
+    l, r = 0, len(s)-1
+    while l <= r:
+        while l < len(s) and not s[l].isalnum():
+            l += 1
+        while r >= 0 and not s[r].isalnum():
+            r -= 1
+        if (0 <= l <= r < len(s)) and not s[l].lower() == s[r].lower():
+            return False
+        r -= 1
+        l += 1
     return True
 
 
 if __name__ == '__main__':
+    assert is_palindrome("")
+    assert is_palindrome(" ")
+    assert is_palindrome("a")
+    assert is_palindrome("aa")
+    assert is_palindrome(" a a ")
+    assert is_palindrome(" a     a ")
+    assert not is_palindrome("ab")
+    assert not is_palindrome("ab ")
+    assert not is_palindrome(" ab ")
     exit(
         generic_test.generic_test_main(
             'is_string_palindromic_punctuation.py',

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

@@ -3,9 +3,34 @@
 from test_framework import generic_test, test_utils
 
 
+KEYPAD = {
+    "2": "ABC",
+    "3": "DEF",
+    "4": "GHI",
+    "5": "JKL",
+    "6": "MNO",
+    "7": "PQRS",
+    "8": "TUV",
+    "9": "WXYZ",
+}
+
+
 def phone_mnemonic(phone_number: str) -> List[str]:
-    # TODO - you fill in here.
-    return []
+    solutions = []
+
+    def process_digit(phone_number, i, base):
+        if i == len(phone_number):
+            solutions.append("".join(base))
+            return
+        if phone_number[i] in ["0", "1"]:
+            process_digit(phone_number, i+1, base + [phone_number[i]])
+        else:
+            new_chars = KEYPAD[phone_number[i]]
+            for char in new_chars:
+                process_digit(phone_number, i+1, base + [char])
+
+    process_digit(phone_number, 0, [])
+    return solutions
 
 
 if __name__ == '__main__':

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

@@ -4,13 +4,67 @@
 from test_framework import generic_test
 
 
+def reverse_list(start: ListNode, end: ListNode) -> None:
+    if start == end:
+        return
+    prev = None
+    curr = start
+    while prev != end:
+        nextNext = curr.next
+        curr.next = prev
+        prev = curr
+        curr = nextNext
+
+
 def reverse_sublist(L: ListNode, start: int,
                     finish: int) -> Optional[ListNode]:
-    # TODO - you fill in here.
-    return None
+    if not start or start == finish:
+        return L
+    pre_start_node = start_node = end_node = post_end_node = None
+    curr = L
+    i = 1
+    while curr:
+        if i == start-1:
+            pre_start_node = curr
+        elif i == start:
+            start_node = curr
+        elif i == finish:
+            end_node = curr
+        elif i == finish+1:
+            post_end_node = curr
+        i += 1
+        curr = curr.next
+
+    reverse_list(start_node, end_node)
+    # if there was a pre-start node, it points now to end node
+    if pre_start_node:
+        pre_start_node.next = end_node
+    # if there was a post-end node, the old start node now points to it.
+    if post_end_node:
+        start_node.next = post_end_node
+    return L if pre_start_node else end_node
 
 
 if __name__ == '__main__':
+    """
+    start_i = 1
+    finish_i = 9
+    head = start = finish = end = ListNode(0, None)
+
+    for i in range(1, 10):
+        end.next = ListNode(i, None)
+        end = end.next
+        if i == start_i:
+            start = end
+        if i == finish_i:
+            finish = end
+    reverse_sublist(head, start_i, finish_i)
+
+    while (head):
+        print(f"Node: {head.data}")
+        head = head.next
+
+    """
     exit(
         generic_test.generic_test_main('reverse_sublist.py',
                                        'reverse_sublist.tsv', reverse_sublist))

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

@@ -6,8 +6,26 @@
 
 # Assume s is a list of strings, each of which is of length 1, e.g.,
 # ['r', 'a', 'm', ' ', 'i', 's', ' ', 'c', 'o', 's', 't', 'l', 'y'].
+
+def reverse_arr(arr, l, r):
+    while l <= r:
+        tmp = arr[l]
+        arr[l] = arr[r]
+        arr[r] = tmp
+        l += 1
+        r -= 1
+
+
 def reverse_words(s):
-    # TODO - you fill in here.
+    if not s:
+        return s
+    reverse_arr(s, 0, len(s)-1)
+    l = 0
+    for r, c in enumerate(s):
+        if c == " ":
+            reverse_arr(s, l, r-1)
+            l = r+1
+    reverse_arr(s, l, r)
     return
 
 
@@ -21,6 +39,7 @@ def reverse_words_wrapper(executor, s):
 
 
 if __name__ == '__main__':
+   # print(reverse_words("Alice likes Bob"))
     exit(
         generic_test.generic_test_main('reverse_words.py', 'reverse_words.tsv',
                                        reverse_words_wrapper))

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

@@ -6,8 +6,22 @@
 
 def merge_two_sorted_lists(L1: Optional[ListNode],
                            L2: Optional[ListNode]) -> Optional[ListNode]:
-    # TODO - you fill in here.
-    return None
+    head = ListNode(-1, None)
+    curr = head
+    while L1 and L2:
+        if L1.data <= L2.data:
+            curr.next = L1
+            L1 = L1.next
+        else:
+            curr.next = L2
+            L2 = L2.next
+        curr = curr.next
+
+    if L1:
+        curr.next = L1
+    if L2:
+        curr.next = L2
+    return head.next
 
 
 if __name__ == '__main__':