feat(icake): add code for problems 5-7

Author: Jessica Yung

.gitignore

@@ -0,0 +1 @@
+.idea

interview-cake/p1_to_p5.py

@@ -16,7 +16,6 @@
 
 
 """
-import unittest
 
 
 def condense_meeting_times_alt(meeting_times):
@@ -64,6 +63,3 @@ def action_two_tuples(first_index, second_index, tuples_list):
         if second[1] >= first[0]:
             # TODO: list append merged, delete prev
             merge(second_index, first_index)
-
-if __name__ == '__main__':
-    unittest.main()

interview-cake/p4.py

@@ -0,0 +1,41 @@
+import unittest
+
+
+class Fibonacci:
+
+    def __init__(self):
+        self.memo = {}
+
+    def fib(self, n):
+        """Computes the nth Fibonacci number."""
+        if n < 0:
+            raise Exception("Index was negative. There are no negative-index Fibonacci numbers.")
+
+        # Base cases
+        elif n == 0 or n == 1:
+            return 1
+        # Non-base cases
+        elif n in self.memo:
+            print("Fetch fib for %i" % n)
+            return self.memo[n]
+
+        print("Compute fib %i" % n)
+        result = self.fib(n-1) + self.fib(n-2)
+
+        # Memo-ize result
+        self.memo[n] = result
+
+        return result
+
+
+class Tests(unittest.TestCase):
+
+    def test_fibonacci(self):
+        self.assertEqual(Fibonacci().fib(10), 89)
+        self.assertEqual(Fibonacci().fib(1), 1)
+        self.assertEqual(Fibonacci().fib(0), 1)
+        self.assertEqual(Fibonacci().fib(5), 8)
+
+
+if __name__ == '__main__':
+    unittest.main()

interview-cake/p5-memoization.py

@@ -0,0 +1,63 @@
+"""
+Problem 5
+
+Also covers:
+- Memo-ization (Fibonacci numbers example)
+
+
+"""
+
+
+def combinations(amount, denominations):
+    sorted_denoms = sorted(denominations)
+    combos = 0
+    if sorted_denoms[0] > amount:
+        return combos
+    if divmod(amount, denominations[0])[1] == 0:
+        pass
+    """
+    for multiples in range(divmod(amount, min)[0])
+    Try divmod(amount, min)[0] min.
+
+    if divmod(amount, min)[1] == 0:
+        combos += 1
+        # Then Try divmod(amount, min)[0] -2
+
+    Try (#smallest you can fit - 2) smallest + 1 second smallest
+        if too small, try + 1 third smallest... until greater than or equal to
+        if equal,
+    Try (#smallest
+    """
+
+
+number_of_ways = 0
+
+
+def num_ways_top_down(amount, denominations, current_index=0,):
+
+    # Previously got to exact amount
+    if amount == 0:
+        return 1
+    # Overshot: Used too many coins
+    if amount < 0:
+        return 0
+    # Used all denominations, so no remaining ways to resolve
+    if current_index == len(denominations):
+        return 0
+
+    # Choose a current denomination (using current_index)
+    current_denomination = denominations[current_index]
+
+    num_possibilities = 0
+    while amount >= 0:
+        num_possibilities += num_ways_top_down(amount, denominations, current_index+1)
+        amount -= current_denomination
+
+    for denomination in denominations:
+        # for each number_of_times_to_use_denomination in possible_number_of_times_to_use_denom_without_overshooting_amount:
+        for times_to_use in range(divmod(amount, denomination)[0]):
+            number_of_ways += num_ways(remaining_amount, denominations)
+
+    # Might there not be double counting?
+
+

interview-cake/p5.py

@@ -0,0 +1,51 @@
+def rectangular_intersection(rect1, rect2):
+    """rect1 and rect2 are dictionaries."""
+
+    # Initialise rectangle
+    rect_intersection = {}
+
+    # Put x coordinates into an array
+    x_coordinates = [rect1['left_x'], rect1['left_x'] + rect1['width'], rect2['left_x'], rect2['left_x'] + rect2['width']]
+
+    # Check two rectangles intersect in x
+    if x_coordinates[1] < x_coordinates[2] and x_coordinates[3] < x_coordinates[1]:
+        return False
+
+    # Add rectangular intersection x values to rect_intersection dictionary
+    x_coordinates = sorted(x_coordinates)
+    rect_intersection['left_x'] = x_coordinates[1]
+    rect_intersection['width'] = x_coordinates[2] - x_coordinates[1]
+
+    # Put y coordinates into an array
+    y_coordinates = [rect1['bottom_y'], rect1['bottom_y'] + rect1['height'], rect2['bottom_y'], rect2['bottom_y'] + rect2['height']]
+
+    # Check two rectangles intersect in y
+    if y_coordinates[1] < y_coordinates[2] and y_coordinates[3] < y_coordinates[0]:
+        return False
+
+    # Add rectangular intersection y values to rect_intersection dictionary
+    y_coordinates = sorted(y_coordinates)
+    rect_intersection['bottom_y'] = y_coordinates[1]
+    rect_intersection['height'] = y_coordinates[2] - y_coordinates[1]
+
+"""
+Dumb way of doing it:
+
+if rect1['left_x'] < rect2['left_x']:
+    left_rect = rect1
+    right_rect = rect2
+elif rect1['left_x'] == rect2['left_x']:
+    if rect1['width'] <= rect2['width']:
+        left_rect = rect1
+        right_rect = rect2
+    else:
+        left_rect = rect2
+        right_rect = rect1
+else:
+    left_rect = rect2
+    right_rect = rect1
+
+# Find x intersection
+if left_rect['left_x'] + left_rect['width'] < right_rect['left_x']:
+    return False
+"""

interview-cake/p6.py

@@ -0,0 +1,50 @@
+class TempTracker:
+
+    def __init__(self):
+
+        # For mean
+        self.temp_count = 0
+        self.mean = None
+        self.sum = 0.0
+
+        # For max
+        self.max = None
+
+        # For min
+        self.min = None
+
+        # For mode
+        self.mode = None
+        self.occurrences = [0] * 111
+        self.max_occurrences = 0
+
+    def insert(self, temp):
+
+        # Update mean
+        self.temp_count += 1
+        self.sum += temp
+        self.mean = self.sum / self.temp_count
+
+        # Update max and min
+        if (self.max is None) or (temp > self.max):
+            self.max = temp
+        if (self.min is None) or (temp < self.min):
+            self.min = temp
+
+        # Update mode
+        self.occurrences[temp] += 1
+        if self.occurrences[temp] > self.max_occurrences:
+            self.max_occurrences = self.occurrences[temp]
+            self.mode = temp
+
+    def get_max(self):
+        return self.max
+
+    def get_min(self):
+        return self.min
+
+    def get_mean(self):
+        return self.mean
+
+    def get_mode(self):
+        return self.mode

interview-cake/p7.py

@@ -0,0 +1,30 @@
+def find_linear_regression_line(points):
+    # Separate points into X and y to fit LinearRegression model
+    points_x = [[point[0]] for point in points]
+    points_y = [point[1] for point in points]
+    print("X points: ", points_x, "Length: ", len(points_x))
+    print("Y points: ", points_y, "Length: ", len(points_y))
+
+    # Fit points to LinearRegression line
+    clf = LinearRegression().fit(points_x, points_y)
+
+    # Get parameters from line
+    coef = clf.coef_[0]
+    intercept = clf.intercept_
+    print("Coefficients: ", coef, "Intercept: ", intercept)
+    return coef, intercept
+
+def intersection_x(coef1, intercept1, coef2, intercept2):
+    """Returns x-coordinate of intersection of two lines."""
+    x = (intercept2-intercept1)/(coef1-coef2)
+    return x
+
+def draw_linear_regression_line(coef1, intercept1, intersection_x, imshape=[540,960]):
+
+    # Get starting and ending points of regression line, ints.
+    point_one = (int(intersection_x), int(intersection_x * coef1 + intercept1))
+    print("Point one: ", point_one)
+    point_two = (imshape[1], int(imshape[1] * coef1 + intercept1))
+    print("Point one: ", point_one, "Point two: ", point_two)
+    # Draw line using cv2.line
+    cv2.line(img, point_one, point_two, color, thickness)

interview-cake/rough.py

@@ -0,0 +1 @@
+Sorting takes O(?) time; O(nlogn)