Adding solutions for Tasks Before Session 3

Author: tachyonlabs

README.md

@@ -98,3 +98,25 @@ And here's a GIF of my InterviewBit Hashing and Linked Lists topic pages:
 * [GIF of my InterviewBit Hashing and Linked Lists topic pages](https://github.com/tachyonlabs/CodePath-Alumni-Professional-Interview-Prep-Course/blob/master/interviewbit-hashing-and-linked-lists-topics.gif)
 
 When I went to take the HackerRank "CodePath Interview Prep - Unit 2 Test", once again I got a message about how I had already taken this test last summer and "can't login to a test that you have already completed" -- see the "My situation" description at the beginning of this README for an explanation of that -- so as directed by Patricia in Slack, I took the test as [email protected] instead of [email protected], and you should have the results.
+
+## Tasks Before Session 3
+
+As shown in this GIF, I've already completed most of the Trees problems, all but two of the Binary Search problems, and all but one of the Heaps and Maps problems, on InterviewBit (mostly in Python, but I've started doing Java versions of some of them as well):
+
+* GIF of my InterviewBit Trees, Binary Search, and Heaps and Maps topic pages
+
+#### My InterviewBit Trees solutions so far:
+
+* Java: Inorder Traversal (recursion version), Inorder Traversal (stack version), Preorder Traversal (recursion version), Preorder Traversal (stack version), Max Depth of Binary Tree, and Min Depth of Binary Tree.
+
+* Python: Next Greater Number BST, Valid Binary Search Tree, Vertical Order traversal of Binary Tree, Inorder Traversal, Postorder Traversal, Preorder Traversal, Identical Binary Trees, Symmetric Binary Tree, Sorted Array To Balanced BST, Binary Tree From Inorder And Postorder, Construct Binary Tree From Inorder And Preorder, Kth Smallest Element In Tree, Invert the Binary Tree, ZigZag Level Order Traversal BT, Populate Next Right Pointers Tree, Path Sum, Root to Leaf Paths With Sum, Max Depth of Binary Tree, Min Depth of Binary Tree, Sum Root to Leaf Numbers, and Flatten Binary Tree to Linked List.
+
+#### My InterviewBit Binary Search solutions so far:
+
+* Java: Square Root of Integer, Allocate Books, and Sorted Insert Position.
+
+* Python: Count Element Occurence, Rotated Array, Square Root of Integer, Painter's Partition Problem, Allocate Books, Matrix Search, Search for a Range, Sorted Insert Position, Implement Power Function, and Rotated Sorted Array Search.
+
+#### My InterviewBit Heaps and Maps solutions so far:
+
+* Python: N max pair combinations, Magician and Chocolates, Merge K Sorted Lists, Distinct Numbers in Window, and LRU Cache.

interviewbit-binary-search-allocate-books.java

@@ -0,0 +1,33 @@
+public class Solution {
+    public int books(ArrayList<Integer> a, int b) {
+        if (a.size() < b) {
+            return -1;
+        }
+        int longestBook = Collections.max(a);
+        if (a.size() == b) {
+            return longestBook;
+        }
+        int low = longestBook;
+        int high = a.stream().reduce(0, (x, y) -> x + y);
+        int mid, student, sumPer;
+        while (low <= high) {
+            mid = (low + high) / 2;
+            student = 1;
+            sumPer = 0;
+            for (int book : a) {
+                if (sumPer + book > mid) {
+                    student++;
+                    sumPer = book;
+                } else {
+                    sumPer += book;
+                }
+            }
+            if (student <= b) {
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+        return low;
+    }
+}

interviewbit-binary-search-allocate-books.py

@@ -0,0 +1,29 @@
+class Solution:
+    # @param A : list of integers
+    # @param B : integer
+    # @return an integer
+    def books(self, A, B):
+        if len(A) < B:
+            return -1
+        if len(A) == B:
+            return max(A)
+
+        low = max(A)
+        high = sum(A)
+        while low <= high:
+            mid = (low + high) / 2
+            students = 1
+            sump = 0
+            for book in A:
+                if sump + book > mid:
+                    students += 1
+                    sump = book
+                else:
+                    sump += book
+
+            if students <= B:
+                high = mid - 1
+            else:
+                low = mid + 1
+
+        return low

interviewbit-binary-search-count-element-occurence.py

@@ -0,0 +1,26 @@
+class Solution:
+    # @param A : tuple of integers
+    # @param B : integer
+    # @return an integer
+    def findCount(self, A, B):
+        start = 0
+        end = len(A) - 1
+        while start <= end:
+            mid = (start + end) / 2
+            if A[mid] == B:
+                count = 1
+                i = mid - 1
+                while i >= 0 and A[i] == B:
+                    count += 1
+                    i -= 1
+                i = mid + 1
+                while i < len(A) and A[i] == B:
+                    count += 1
+                    i += 1
+                return count
+            elif A[mid] < B:
+                start = mid + 1
+            elif A[mid] > B:
+                end = mid - 1
+
+        return 0

interviewbit-binary-search-implement-power-function.py

@@ -0,0 +1,16 @@
+class Solution:
+    # @param x : integer
+    # @param n : integer
+    # @param d : integer
+    # @return an integer
+    def pow(self, x, n, d):
+        if x == 0 or d == 1:
+            return 0
+
+        if n == 0:
+            return 1
+        elif n % 2:
+            return ((x % d) * self.pow(x, n - 1, d)) % d
+        else:
+            y = self.pow(x, n / 2, d)
+            return y ** 2 % d

interviewbit-binary-search-matrix-search.py

@@ -0,0 +1,21 @@
+class Solution:
+    # @param A : list of list of integers
+    # @param B : integer
+    # @return an integer
+    def searchMatrix(self, A, B):
+        rows = len(A)
+        cols = len(A[0])
+        start = 0
+        end = rows * cols - 1
+        while start <= end:
+            mid = (start + end) / 2
+            num = A[mid / rows][mid % rows]
+            if num == B:
+                return 1
+            elif num < B:
+                start = mid + 1
+            elif num > b:
+                end = mid - 1
+
+        return 0
+

interviewbit-binary-search-painters-partition-problem.py

@@ -0,0 +1,34 @@
+class Solution:
+    # @param A : integer
+    # @param B : integer
+    # @param C : list of integers
+    # @return an integer
+    def paint(self, A, B, C):
+        if not C:
+            return 0
+
+        low, high = max(C) * B, sum(C) * B
+
+        if len(C) <= A:
+            return low % 10000003
+
+        if A == 1:
+            return high % 10000003
+
+        while low <= high:
+            med = (low + high) / 2
+            painter = 1
+            boards = 0
+            for board in C:
+                if boards + board * B <= med:
+                    boards += board * B
+                else:
+                    painter += 1
+                    boards = board * B
+
+            if painter <= A:
+                high = med - 1
+            else:
+                low = med + 1
+
+        return low % 10000003

interviewbit-binary-search-rotated-array.py

@@ -0,0 +1,20 @@
+class Solution:
+    # @param A : tuple of integers
+    # @return an integer
+    def findMin(self, A):
+        if len(A) == 1:
+            return A[0]
+        if A[-1] > A[0]:
+            return A[0]
+
+        start = 0
+        end = len(A) - 2
+        while start <= end:
+            mid = (start + end) / 2
+            print A[mid:mid + 2]
+            if A[mid] > A[mid + 1]:
+                return A[mid + 1]
+            elif A[mid] > A[start]:
+                start = mid + 1
+            else:
+                end = mid

interviewbit-binary-search-rotated-sorted-array-search.py

@@ -0,0 +1,40 @@
+class Solution:
+    # @param A : tuple of integers
+    # @param B : integer
+    # @return an integer
+    def search(self, A, B):
+        def find_pivot():
+            low, high = 1, len(A) - 1
+            while low <= high:
+                mid = (low + high) / 2
+                if A[mid - 1] > A[mid]:
+                    return mid
+                if A[mid] > A[0]:
+                    low = mid + 1
+                else:
+                    high = mid - 1
+
+        if not A:
+            return -1
+
+        if len(A) == 1:
+            return 0 if A[0] == B else -1
+
+        low, high = 0, len(A) - 1
+        if A[0] > A[-1]:
+            pivot = find_pivot()
+            if B >= A[0]:
+                low, high = 0, pivot - 1
+            else:
+                low, high = pivot, len(A) - 1
+
+        while low <= high:
+            mid = (low + high) / 2
+            if A[mid] == B:
+                return mid
+            if A[mid] > B:
+                high = mid - 1
+            else:
+                low = mid + 1
+
+        return -1

interviewbit-binary-search-search-for-a-range.py

@@ -0,0 +1,31 @@
+class Solution:
+    # @param A : tuple of integers
+    # @param B : integer
+    # @return a list of integers
+    def searchRange(self, A, B):
+        def find_border(side, start, end):
+            while start <= end:
+                mid = (start + end) / 2
+                if (side == left and A[mid] == B and (mid == 0 or A[mid - 1] < B)) or (side == right and A[mid] == B and (mid == len(A) - 1 or A[mid + 1] > B)):
+                    return mid
+                elif side == left and A[mid] >= B:
+                    end = mid - 1
+                elif side == left and A[mid] < B:
+                    start = mid + 1
+                elif side == right and A[mid] > B:
+                    end = mid - 1
+                elif side == right and A[mid] <= B:
+                    start = mid + 1
+
+            return -1
+
+
+        left = True
+        right = False
+        left_border = find_border(left, 0, len(A) - 1)
+        if left_border == -1:
+            return [-1, -1]
+
+        right_border = find_border(right, left_border, len(A) - 1)
+
+        return [left_border, right_border]

interviewbit-binary-search-sorted-insert-position.java

@@ -0,0 +1,20 @@
+public class Solution {
+    public int searchInsert(ArrayList<Integer> a, int b) {
+        int start = 0;
+        int end = a.size() - 1;
+        int mid;
+        int val;
+        while (start <= end) {
+            mid = (start + end) / 2;
+            val = a.get(mid);
+            if (val == b) {
+                return mid;
+            } else if (val < b) {
+                start++;
+            } else {
+                end--;
+            }
+        }
+        return start;
+    }
+}

interviewbit-binary-search-sorted-insert-position.py

@@ -0,0 +1,17 @@
+class Solution:
+    # @param A : list of integers
+    # @param B : integer
+    # @return an integer
+    def searchInsert(self, A, B):
+        start = 0
+        end = len(A) - 1
+        while start <= end:
+            mid = (start + end) / 2
+            if A[mid] == B:
+                return mid
+            elif A[mid] < B:
+                start = mid + 1
+            else:
+                end = mid - 1
+
+        return start

interviewbit-binary-search-square-root-of-integer.java

@@ -0,0 +1,20 @@
+public class Solution {
+    public int sqrt(int a) {
+        int start = 0;
+        int end = a;
+        int mid;
+        long squared;
+        while (start <= end) {
+            mid = (start + end) / 2;
+            squared = mid * mid;
+            if (squared == a) {
+                return mid;
+            } else if (squared < a) {
+                start = mid + 1;
+            } else {
+                end = mid - 1;
+            }
+        }
+        return start - 1;
+    }
+}

interviewbit-binary-search-square-root-of-integer.py

@@ -0,0 +1,17 @@
+class Solution:
+    # @param A : integer
+    # @return an integer
+    def sqrt(self, A):
+        start = 0
+        end = A
+        while start <= end:
+            mid = (start + end) / 2
+            squared = mid ** 2
+            if squared == A:
+                return mid
+            elif squared < A:
+                start = mid + 1
+            elif squared > A:
+                end = mid - 1
+
+        return start - 1

interviewbit-heaps-and-maps-distinct-numbers-in-window.py

@@ -0,0 +1,25 @@
+class Solution:
+    # @param A : list of integers
+    # @param B : integer
+    # @return a list of integers
+    def dNums(self, A, B):
+        if B > len(A):
+            return []
+
+        window = {}
+        for num in A[:B]:
+            window[num] = window.get(num, 0) + 1
+
+        distinct = [len(window)]
+        for i in range(len(A) - B):
+            remkey = A[i]
+            if window[remkey] == 1:
+                del window[remkey]
+            else:
+                window[remkey] -= 1
+
+            addkey = A[i + B]
+            window[addkey] = window.get(addkey, 0) + 1
+            distinct.append(len(window))
+
+        return distinct