x

Author: semioz

Easy/Balanced-binary-tree/solution.java

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean isBalanced(TreeNode root) {
+        return dfs(root)[0] == 1;
+    }
+
+    public int[] dfs(TreeNode root) {
+        if (root == null) {
+            return new int[]{1, 0};
+        }
+
+        int[] left = dfs(root.left);
+        int[] right = dfs(root.right);
+
+        boolean balanced = (left[0] == 1) && (right[0] == 1) && (Math.abs(left[1] - right[1]) <= 1);
+        int height = 1 + Math.max(left[1], right[1]);
+
+        return new int[]{balanced ? 1 : 0, height};
+    }
+}

Easy/Middle-of-linked-list/solution.java

@@ -0,0 +1,21 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode middleNode(ListNode head) {
+        ListNode slow = head, fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        return slow;
+    }
+}

Medium/Design-Browser-History/solution.py

@@ -0,0 +1,26 @@
+class LlNode:
+    def __init__(self, data, prev=None, next=None):
+        self.data = data
+        self.prev = prev
+        self.next = next
+
+class BrowserHistory:
+
+    def __init__(self, homepage: str):
+        self.current = LlNode(homepage)        
+
+    def visit(self, url: str) -> None:
+        self.current.next = LlNode(url, self.current)
+        self.current = self.current.next
+
+    def back(self, steps: int) -> str:
+        while self.current.prev and steps > 0:
+            self.current = self.current.prev
+            steps -= 1
+        return self.current.data
+
+    def forward(self, steps: int) -> str:
+        while self.current.next and steps > 0:
+            self.current = self.current.next
+            steps -= 1
+        return self.current.data

Medium/LRU-Cache/solution.go

@@ -0,0 +1,28 @@
+class LRUCache(object):
+
+    def __init__(self, capacity):
+        """
+        :type capacity: int
+        """
+        
+
+    def get(self, key):
+        """
+        :type key: int
+        :rtype: int
+        """
+        
+
+    def put(self, key, value):
+        """
+        :type key: int
+        :type value: int
+        :rtype: None
+        """
+        
+
+
+# Your LRUCache object will be instantiated and called as such:
+# obj = LRUCache(capacity)
+# param_1 = obj.get(key)
+# obj.put(key,value)