Add sandbox

epi_judge_python/lru_cache.py

@@ -1,22 +1,87 @@
 from test_framework import generic_test
 from test_framework.test_failure import TestFailure
 
+class Node:
+    def __init__(self, value, prev=None, next=None):
+        self.value = value
+        self.prev = prev
+        self.next = next
+
+class DoublyLinkedList:
+    def __init__(self, capacity):
+        self.head = None
+        self.tail = None
+        self.capacity = capacity
+        self.size = 0
+
+    def appendleft(self, value):
+        if self.size == self.capacity:
+            raise IndexError('Cannot add node. List at capacity.')
+        if self.size == 0:
+            self.head = Node(value)
+            self.tail = self.head
+        else:
+            temp = self.head
+            self.head = Node(value)
+            self.head.next = temp
+            temp.prev = self.head
+        self.size += 1
+
+    def append(self, value):
+        if self.size == self.capacity:
+            raise IndexError('Cannot add node. List at capacity.')
+        if self.size == 0:
+            self.head = Node(value)
+            self.tail = self.head
+        else:
+            temp = self.tail
+            self.tail.next = Node(value)
+            self.tail = self.tail.next
+            self.tail.prev = temp
+        self.size += 1
+
+    def remove(self, value):
+
+
+
+    def popleft(self):
+        if self.size == 0:
+            raise IndexError('Cannot pop from an empty list')
+        self.size -= 1
+        val = self.head.value
+        if self.head.next:
+            self.head = self.head.next
+        self.head.prev = None
+        return val
+
+    def pop(self):
+        if self.size == 0:
+            raise IndexError('Cannot pop from an empty list')
+        self.size -= 1
+        val = self.tail.value
+        if self.tail.prev:
+            self.tail = self.tail.prev
+        self.tail.next = None
+        return val
 
 class LruCache:
     def __init__(self, capacity):
-        # TODO - you fill in here.
-        return
+        self.queue = DoublyLinkedList(capacity)
+        self.map = {}
+        self.size = 0
+        self.capacity = capacity
 
     def lookup(self, isbn):
-        # TODO - you fill in here.
         return 0
 
     def insert(self, isbn, price):
-        # TODO - you fill in here.
-        return
+        if self.size == capacity:
+            if isbn in self.map:
+
+
+        self.size -= 1
 
     def erase(self, isbn):
-        # TODO - you fill in here.
         return True
 
 
@@ -44,6 +109,4 @@ def run_test(commands):
 
 
 if __name__ == '__main__':
-    exit(
-        generic_test.generic_test_main("lru_cache.py", 'lru_cache.tsv',
-                                       run_test))
+    exit(generic_test.generic_test_main("lru_cache.py", 'lru_cache.tsv', run_test))

sandbox/BST.py

@@ -0,0 +1,135 @@
+import collections
+class BSTNode:
+    def __init__(self, data=None, left=None, right=None):
+        self.data, self.left, self.right = data, left, right
+
+class TreeNode:
+    def __init__(self, label=None, edges=None):
+        self.label = label
+        self.edges = edges
+
+def is_bst(tree, min_val=float('-inf'), max_val=float('inf')):
+    if not tree:
+        return True
+    elif not min_val <= tree.data <= max_val:
+        return False
+    return is_bst(tree.left, min_val, tree.data) and is_bst(tree.right, tree.data, max_val)
+
+
+def find_k_largest_elements(tree, k):
+    def find_k_largest_elements_helper(tree):
+        if tree and len(k_largest) < k:
+            find_k_largest_elements_helper(tree.right)
+            if len(k_largest) < k:
+                k_largest.append(tree.data)
+                find_k_largest_elements_helper(tree.left)
+
+    k_largest = []
+    find_k_largest_elements_helper(tree)
+    return k_largest
+
+
+def lca_recursive(tree, s, b):
+    if s.data == tree.data or b.data == tree.data:
+        return tree.data
+    if s.data < tree.data < b.data:
+        return tree.data
+    if s.data < tree.data and b.data < tree.data:
+        return lca_recursive(tree.left, s, b)
+    if s.data > tree.data and b.data > tree.data:
+        return lca_recursive(tree.right, s, b)
+
+def lca_iterative(tree, s, b):
+    while tree.data < s.data or tree.data > b.data:
+        while tree.data < s.data:
+            tree = tree.right
+        while tree.data > b.data:
+            tree = tree.left
+
+    return tree.data
+
+def lca_postorder(tree, s, b):
+    pass
+
+class Edge:
+    def __init__(self, root=None, length=None):
+        self.root = root
+        self.length = length
+
+def diameter(tree):
+    class HeightAndDiameter:
+        def __init__(self, height=None, diameter=None):
+            self.height = height
+            self.diameter = diameter
+
+    def compute(t):
+        diameter = float('-inf')
+        heights = [0.0, 0.0]
+        for e in t.edges:
+            h_d = compute(e.root)
+            if h_d.height + e.length > heights[0]:
+                heights = [h_d.height + e.length, heights[0]]
+            elif h_d.height + e.length > heights[1]:
+                heights[1] = h_d.height + e.length
+            diameter = max(diameter, h_d.diameter)
+
+        return HeightAndDiameter(heights[0], max(diameter, heights[0], + heights[1]))
+
+    return compute(tree).diameter if tree else 0
+
+def invertTree(root):
+    """
+    :type root: TreeNode
+    :rtype: TreeNode
+    """
+    if not root or not root.left and not root.right:
+        return root
+
+    stack = [root]
+    while stack:
+        node = stack.pop()
+        node.left, node.right = node.right, node.left
+        if node.left:
+            stack.append(node.left)
+        if node.right:
+            stack.append(node.right)
+
+    return root
+
+def create_bstree():
+    n = BSTNode(19)
+    n.left = BSTNode(7)
+    n.left.left = BSTNode(3)
+    n.left.left.left = BSTNode(2)
+    n.left.left.right = BSTNode(5)
+    n.left.right = BSTNode(11)
+    n.left.right.right = BSTNode(17)
+    n.left.right.right.left = BSTNode(13)
+    n.right = BSTNode(43)
+    n.right.left = BSTNode(23)
+    n.right.left.right = BSTNode(37)
+    n.right.left.right.left = BSTNode(29)
+    n.right.left.right.left.right = BSTNode(31)
+    n.right.left.right.right = BSTNode(41)
+    n.right.right = BSTNode(47)
+    n.right.right.right = BSTNode(53)
+    return n
+def create_btree():
+    tb = TreeNode('B')
+    tb.edges = [Edge(tb, 7),Edge(tb, 14),Edge(tb, 73)]
+    tc = TreeNode('C')
+    return tb
+
+if __name__ == '__main__':
+    bstree = create_bstree()
+    btree = create_btree
+    #print is_bst(tree)
+    #print find_k_largest_elements(tree, 3)
+    #smaller = tree.left.right.right.left
+    #larger = tree.left.right.right
+    #print lca_iterative(tree, smaller, larger)
+    #print lca_recursive(tree, smaller, larger)
+    #print diameter(tree)
+
+    tree = invertTree(bstree)
+    print tree.data, tree.left.data, tree.right.data

sandbox/DFS.py

@@ -0,0 +1,22 @@
+class Trie:
+    class TrieNode:
+        def __init__(self, label=None, data=None):
+            self.label = label
+            self.data = data
+            self.children = []
+
+        def __getitem__(self, key):
+            return self.children[key]
+
+        def add_child(self, key, data):
+            if self.children:
+                self.children.append()
+
+    def __init__(self):
+        pass
+
+    def insert(self, word):
+        pass
+
+    def search(self, word):
+        pass

sandbox/Trees.py

@@ -0,0 +1,63 @@
+class TreeNode:
+    def __init__(self, val, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+    def __repr__(self):
+        return 'TreeNode({})'.format(self.val)
+
+def is_bst(tree, min_val=float('-inf'), max_val=float('inf')):
+    if not tree:
+        return True
+    elif not min_val <= tree.val <= max_val:
+        return False
+    return is_bst(tree.left, min_val, tree.val) and is_bst(tree.right, tree.val, max_val)
+
+
+def deserialize(string):
+    if string == '{}':
+        return None
+    nodes = [None if val == 'null' else TreeNode(int(val))
+             for val in string.strip('[]{}').split(',')]
+    kids = nodes[::-1]
+    root = kids.pop()
+    for node in nodes:
+        if node:
+            if kids: node.left = kids.pop()
+            if kids: node.right = kids.pop()
+    return root
+
+
+def drawtree(root):
+    def height(root):
+        return 1 + max(height(root.left), height(root.right)) if root else -1
+
+    def jumpto(x, y):
+        t.penup()
+        t.goto(x, y)
+        t.pendown()
+
+    def draw(node, x, y, dx):
+        if node:
+            t.goto(x, y)
+            jumpto(x, y - 20)
+            t.write(node.val, align='center', font=('Arial', 12, 'normal'))
+            draw(node.left, x - dx, y - 60, dx / 2)
+            jumpto(x, y - 20)
+            draw(node.right, x + dx, y - 60, dx / 2)
+
+    import turtle
+    t = turtle.Turtle()
+    t.speed(0);
+    turtle.delay(0)
+    h = height(root)
+    jumpto(0, 30 * h)
+    draw(root, 0, 30 * h, 40 * h)
+    t.hideturtle()
+    turtle.mainloop()
+
+
+if __name__ == '__main__':
+   # drawtree(deserialize('[1,2,3,null,null,4,null,null,5]'))
+    drawtree(deserialize('[2,1,3,0,7,9,1,2,null,1,0,null,null,8,8,null,null,null,null,7]'))

sandbox/allocate_books.py

@@ -0,0 +1,37 @@
+def books(book_list, people):
+    def is_possible(arr, readers, curr_min):
+        students_required = 1
+        curr_sum = 0
+        for i in range(len(arr)):
+            if arr[i] > curr_min:
+                return False
+            if curr_sum + arr[i] > curr_min:
+                students_required += 1
+                curr_sum = arr[i]
+                if students_required > readers:
+                    return False
+            else:
+                curr_sum += arr[i]
+
+        return True
+
+    if len(book_list) < people:
+        raise ValueError('Num people exceed num books')
+
+    n = sum(book_list)
+    lo, hi = 0, n
+    res = float('inf')
+    while lo <= hi:
+        m = (lo + hi) // 2
+        if is_possible(book_list, people, m):
+            res = min(res, m)
+            hi = m - 1  # check smaller
+        else:
+            lo = m + 1
+
+    return res
+
+if __name__ == '__main__':
+    arr = [12, 34, 67, 90]
+    m = 2
+    print(books(arr, m))