8/21/23

- anagrams.py
- is_string_permutable_to_palindrome.py
- is_anonymous_letter_constructible.py
- lru_cache_hard_way.py
- lru_cache.py

Author: jsgoller1

elements-of-programming-interviews/problem_mapping.js

@@ -1450,7 +1450,7 @@ problem_mapping = {
                 "total": 9
             },
             "Python: anagrams.py": {
-                "passed": 0,
+                "passed": 9,
                 "total": 9
             }
         },
@@ -1464,7 +1464,7 @@ problem_mapping = {
                 "total": 305
             },
             "Python: is_string_permutable_to_palindrome.py": {
-                "passed": 0,
+                "passed": 305,
                 "total": 305
             }
         },
@@ -1478,7 +1478,7 @@ problem_mapping = {
                 "total": 212
             },
             "Python: is_anonymous_letter_constructible.py": {
-                "passed": 0,
+                "passed": 212,
                 "total": 212
             }
         },
@@ -1492,7 +1492,7 @@ problem_mapping = {
                 "total": 101
             },
             "Python: lru_cache.py": {
-                "passed": 0,
+                "passed": 101,
                 "total": 101
             }
         },

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

@@ -2,10 +2,24 @@
 
 from test_framework import generic_test, test_utils
 
+"""
+In: list of strings; strings fit in mem
+Out: list of list of strings, grouped by anagrams, must have at least 2
+
+edges:
+- empty list, no anagrams, all anagrams
+
+- sort lowercased strings, use as keys 
+"""
+
+import collections
+
 
 def find_anagrams(dictionary: List[str]) -> List[List[str]]:
-    # TODO - you fill in here.
-    return []
+    dd = collections.defaultdict(list)
+    for word in dictionary:
+        dd["".join(sorted(word.lower()))].append(word)
+    return [v for v in dd.values() if len(v) > 1]
 
 
 if __name__ == '__main__':

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

@@ -1,10 +1,13 @@
 from test_framework import generic_test
+import collections
+import string
 
 
 def is_letter_constructible_from_magazine(letter_text: str,
                                           magazine_text: str) -> bool:
-    # TODO - you fill in here.
-    return True
+    letter = collections.Counter(letter_text)
+    magazine = collections.Counter(magazine_text)
+    return all(letter[k] <= magazine[k] for k in letter if k not in string.whitespace)
 
 
 if __name__ == '__main__':

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

@@ -1,12 +1,33 @@
 from test_framework import generic_test
 
 
+"""
+in: string
+out: bool
+
+edges: 
+    - empty (assume yes)
+    - case? assuming it matters, "Aba" not palindrome
+    - whitespace? assume words won't have whitespace, can handle if so
+
+count letters?
+"""
+from collections import Counter
+
+
 def can_form_palindrome(s: str) -> bool:
-    # TODO - you fill in here.
-    return True
+    return len([v for v in Counter(s).values() if v % 2]) < 2
 
 
 if __name__ == '__main__':
+    assert can_form_palindrome("")
+    assert can_form_palindrome("aa")
+    assert can_form_palindrome("Aaa")
+    assert not can_form_palindrome("ba")
+    assert not can_form_palindrome("john says no")
+    assert not can_form_palindrome("sit on a potato pan otis")
+    assert can_form_palindrome("sitonapotatopanotis")
+
     exit(
         generic_test.generic_test_main(
             'is_string_permutable_to_palindrome.py',

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

@@ -1,22 +1,57 @@
 from test_framework import generic_test
 from test_framework.test_failure import TestFailure
 
+"""
+- isbns are positive ints 
+- LRU can be implemented with a queue
+- hashing done with dict
+- naive approach:
+    - use queue and dict
+    - whenever lookup/insert occurs, find item in queue, remove, and re-insert
+    - if an item is ever outside the valid length of the queue, dequeue it and erase from dict
+    - lookup, insert, and erase are O(n) where n is cache capacity. Can we achieve better? O(1)?
+- If we keep an op counter, our "queue" could be implemented as a bst or sorted array? (no, we'd still
+  have to shift)
+- Could we use a doubly linked list? each dict entry has value and dll node pointer
+    - have pointers newest and oldest, both start null
+    - anytime something is updated, if other nodes were pointing to it, we clip it out and connect them
+    - we then make it the newest
+    - if we have to evict, we knock out the oldest and make its follower the new oldest
+"""
+
+from collections import OrderedDict
+
 
 class LruCache:
     def __init__(self, capacity: int) -> None:
-        # TODO - you fill in here.
-        return
+        self.data = OrderedDict()
+        self.capacity = capacity
+
+    def _update_isbn(self, isbn):
+        if isbn not in self.data:
+            return
+        price = self.data[isbn]
+        del self.data[isbn]
+        self.data[isbn] = price
 
     def lookup(self, isbn: int) -> int:
-        # TODO - you fill in here.
-        return 0
+        if isbn not in self.data:
+            return -1
+        self._update_isbn(isbn)
+        return self.data[isbn]
 
     def insert(self, isbn: int, price: int) -> None:
-        # TODO - you fill in here.
-        return
+        if isbn in self.data:
+            self._update_isbn(isbn)
+            return
+        self.data[isbn] = price
+        if len(self.data) > self.capacity:
+            self.data.popitem(last=False)  # FIFO order
 
     def erase(self, isbn: int) -> bool:
-        # TODO - you fill in here.
+        if isbn not in self.data:
+            return False
+        del self.data[isbn]
         return True
 
 

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

@@ -0,0 +1,170 @@
+from test_framework import generic_test
+from test_framework.test_failure import TestFailure
+
+"""
+- isbns are positive ints 
+- LRU can be implemented with a queue
+- hashing done with dict
+- naive approach:
+    - use queue and dict
+    - whenever lookup/insert occurs, find item in queue, remove, and re-insert
+    - if an item is ever outside the valid length of the queue, dequeue it and erase from dict
+    - lookup, insert, and erase are O(n) where n is cache capacity. Can we achieve better? O(1)?
+- If we keep an op counter, our "queue" could be implemented as a bst or sorted array? (no, we'd still
+  have to shift)
+- Could we use a doubly linked list? each dict entry has value and dll node pointer
+    - have pointers newest and oldest, both start null
+    - anytime something is updated, if other nodes were pointing to it, we clip it out and connect them
+    - we then make it the newest
+    - if we have to evict, we knock out the oldest and make its follower the new oldest
+"""
+
+
+class QueueNode:
+    def __init__(self, isbn, price):
+        self.isbn = isbn
+        self.price = price
+        self.more = None
+        self.less = None
+
+    def __repr__(self):
+        more = self.more.isbn if self.more else None
+        less = self.less.isbn if self.less else None
+        return f"QueueNode(isbn: {self.isbn}, price: {self.price}, more: {more}, less: {less})"
+
+
+class LruCache:
+    def __init__(self, capacity: int) -> None:
+        self.head = None
+        self.tail = None
+        self.capacity = capacity
+        self.data = {}
+
+    def __repr__(self):
+        nodes = []
+        node = self.head
+        while node:
+            nodes.append(repr(node))
+            nodes.append("\n")
+            node = node.less
+            # print(f"repring node: {repr(node)}")
+        return "".join(nodes)
+
+    def _eviction_policy(self):
+        if len(self.data) <= self.capacity:
+            return
+        if self.capacity == 0:
+            self.head = None
+            self.tail = None
+            self.data = {}
+        else:
+            to_delete = self.tail
+            self.tail = to_delete.more
+            self.tail.less = None
+            del self.data[to_delete.isbn]
+
+    def _update_recency(self, node):
+        if self.head == self.tail == None:
+            # first node inserted
+            self.head = node
+            self.tail = node
+            return
+
+        if node == self.head:
+            # Node is already most recent, nothing to do here
+            return
+
+        if node == self.tail:
+            # If there's a node more recent than this one,
+            # it becomes the new tail
+            if node.more:
+                self.tail = node.more
+                self.tail.less = None
+
+        if node != self.head and node != self.tail:
+            # Ensure old more/less point to each other, if they exist
+            if node.more:
+                node.more.less = node.less
+            if node.less:
+                node.less.more = node.more
+
+            # Bump previous head down if it existed and we weren't it.
+            self.head.more = node
+            node.less = self.head
+            self.head = node
+            node.more = None
+
+    def lookup(self, isbn: int) -> int:
+        if isbn not in self.data:
+            # print(f"Lookup {isbn} (not found)")
+            # print(f"{self.__repr__()}")
+            return -1
+        node = self.data[isbn]
+        price = node.price
+        self._update_recency(node)
+        # print(f"Lookup {isbn}")
+        # print(f"{self.__repr__()}")
+        return price
+
+    def insert(self, isbn: int, price: int) -> None:
+        if isbn in self.data:
+            node = self.data[isbn]
+        else:
+            node = QueueNode(isbn, price)
+            self.data[isbn] = node
+        self._update_recency(node)
+        self._eviction_policy()
+        # print(f"Insert ({isbn},{price})")
+        # print(f"{self.__repr__()}")
+
+    def erase(self, isbn: int) -> bool:
+        if isbn not in self.data:
+            # print(f"Erase {isbn} (not found)")
+            # print(f"{self.__repr__()}")
+
+            return False
+
+        node = self.data[isbn]
+        if node.more:
+            node.more.less = node.less
+        if node.less:
+            node.less.more = node.more
+
+        if node == self.head:
+            self.head = node.less
+        if node == self.tail:
+            self.tail = node.more
+
+        del self.data[isbn]
+        # print(f"Erase {isbn}")
+        # print(f"{self.__repr__()}")
+        return True
+
+
+def lru_cache_tester(commands):
+    if len(commands) < 1 or commands[0][0] != 'LruCache':
+        raise RuntimeError('Expected LruCache as first command')
+
+    cache = LruCache(commands[0][1])
+
+    for cmd in commands[1:]:
+        if cmd[0] == 'lookup':
+            result = cache.lookup(cmd[1])
+            if result != cmd[2]:
+                raise TestFailure('Lookup: expected ' + str(cmd[2]) +
+                                  ', got ' + str(result))
+        elif cmd[0] == 'insert':
+            cache.insert(cmd[1], cmd[2])
+        elif cmd[0] == 'erase':
+            result = 1 if cache.erase(cmd[1]) else 0
+            if result != cmd[2]:
+                raise TestFailure('Erase: expected ' + str(cmd[2]) + ', got ' +
+                                  str(result))
+        else:
+            raise RuntimeError('Unexpected command ' + cmd[0])
+
+
+if __name__ == '__main__':
+    exit(
+        generic_test.generic_test_main('lru_cache.py', 'lru_cache.tsv',
+                                       lru_cache_tester))