Added 3 new geometry solutions and 1 DP

Author: Мето Трајковски

Diff for: Dynamic Programming/create_palindrom.py

@@ -0,0 +1,132 @@
+'''
+Create Palindrome (Minimum Insertions to Form a Palindrome)
+
+Given a string, find the palindrome that can be made by inserting the fewest number of characters as possible anywhere in the word.
+If there is more than one palindrome of minimum length that can be made, return the lexicographically earliest one (the first one alphabetically).
+
+Input: 'race'
+Output: 'ecarace'
+Output explanation: Since we can add three letters to it (which is the smallest amount to make a palindrome).
+                    There are seven other palindromes that can be made from "race" by adding three letters, but "ecarace" comes first alphabetically.
+
+Input: 'google'
+Output: 'elgoogle'
+
+Input: 'abcda'
+Output: 'adcbcda'
+Output explanation: Number of insertions required is 2 - aDCbcda (between the first and second character).
+
+Input: 'adefgfdcba'
+Output: 'abcdefgfedcba'
+Output explanation: Number of insertions required is 3 i.e. aBCdefgfEdcba.
+
+=========================================
+Recursive count how many insertions are needed, very slow and inefficient.
+    Time Complexity:    O(2^N)
+    Space Complexity:   O(N^2)  , for each function call a new string is created (and the recursion can have depth of max N calls)
+Dynamic programming. Count intersections looking in 3 direction in the dp table (diagonally left-up or min(left, up)).
+    Time Complexity:    O(N^2)
+    Space Complexity:   O(N^2)
+'''
+
+
+##############
+# Solution 1 #
+##############
+
+def create_palindrome_1(word):
+    n = len(word)
+
+    # base cases
+    if n == 1:
+        return word
+    if n == 2:
+        if word[0] != word[1]:
+            word += word[0] # make a palindrom
+        return word
+
+    # check if the first and last chars are same
+    if word[0] == word[-1]:
+        # add first and last chars
+        return word[0] + create_palindrome_1(word[1:-1]) + word[-1]
+
+    # if not remove the first and after that the last char
+    # and find which result has less chars
+    first = create_palindrome_1(word[1:])
+    first = word[0] + first + word[0] # add first char twice
+
+    last = create_palindrome_1(word[:-1])
+    last = word[-1] + last + word[-1] # add last char twice
+
+    if len(first) < len(last):
+        return first
+    return last
+
+
+##############
+# Solution 2 #
+##############
+
+import math
+
+def create_palindrome_2(word):
+    n = len(word)
+    dp = [[0 for j in range(n)] for i in range(n)]
+
+    # run dp
+    for gap in range(1, n):
+        left = 0
+        for right in range(gap, n):
+            if word[left] == word[right]:
+                dp[left][right] = dp[left + 1][right - 1]
+            else:
+                dp[left][right] = min(dp[left][right - 1], dp[left + 1][right]) + 1
+            left += 1
+
+    # build the palindrome using the dp table
+    return build_palindrome(word, dp, 0, n-1)
+
+def build_palindrome(word, dp, left, right):
+    # similar like the first solution, but without exponentialy branching
+    # this is linear time, we already know the inserting values
+    if left > right:
+        return ''
+    if left == right:
+        return word[left]
+
+    if word[left] == word[right]:
+        return word[left] + build_palindrome(word, dp, left + 1, right - 1) + word[left]
+
+    if dp[left + 1][right] < dp[left][right - 1]:
+        return word[left] + build_palindrome(word, dp, left + 1, right) + word[left]
+
+    return word[right] + build_palindrome(word, dp, left, right - 1) + word[right]
+
+
+###########
+# Testing #
+###########
+
+# Test 1
+# Correct result => 'ecarace'
+word = 'race'
+print(create_palindrome_1(word))
+print(create_palindrome_2(word))
+
+# Test 2
+# Correct result => 'elgoogle'
+word = 'google'
+print(create_palindrome_1(word))
+print(create_palindrome_2(word))
+
+# Test 3
+# Correct result => 'adcbcda'
+word = 'abcda'
+print(create_palindrome_1(word))
+print(create_palindrome_2(word))
+
+# Test 4
+# Correct result => 'abcdefgfedcba'
+word = 'adefgfdcba'
+print(create_palindrome_1(word))
+print(create_palindrome_2(word))

Diff for: Math/calculate_area_of_polygon.py

@@ -0,0 +1,41 @@
+'''
+Calculate Area of Polygon
+
+Given ordered coordinates of a polygon with n vertices. Find area of the polygon.
+Here ordered mean that the coordinates are given either in clockwise manner or anticlockwise from first vertex to last.
+
+Input: [(0, 0), (3, 0), (3, 2), (0, 2)]
+Output: 6.0
+Output explanation: The polygon is a 3x2 rectangle parallel with the X axis. The area is 6 (3*2).
+
+=========================================
+Use Shoelace formula (https://en.wikipedia.org/wiki/Shoelace_formula).
+abs( 1/2 ((X1Y2 + X2Y3 + ... + Xn-1Yn + XnY1) - (X2Y1 + X3Y2 + ... + XnYn-1 + X1Yn)) )
+    Time Complexity:    O(N)
+    Space Complexity:   O(1)
+'''
+
+
+############
+# Solution #
+############
+
+def calculate_area_of_polygon(polygon):
+    n = len(polygon)
+    prev = polygon[-1]
+    area = 0
+
+    for curr in polygon:
+        area += (prev[0] + curr[0]) * (prev[1] - curr[1])
+        prev = curr
+
+    return abs(area / 2) # return absolute value
+
+
+###########
+# Testing #
+###########
+
+# Test 1
+# Correct result => 6.0
+print(calculate_area_of_polygon([(0, 0), (3, 0), (3, 2), (0, 2)]))

Diff for: Math/check_if_point_inside_polygon.py

@@ -1,12 +1,12 @@
 '''
 Check if Point is Inside Polygon
 
-Given a polygon (created by counterclockwise ordered points, more than 2 points) and a point "p", find if "p" lies inside the polygon or not. 
+Given a polygon (created by counterclockwise ordered points, more than 2 points) and a point "p", find if "p" lies inside the polygon or not.
 The points lying on the border are considered inside.
 
 Input: [(0, 0), (3, 0), (3, 2), (0, 2)], (1, 1)
 Output: True
-Output explanation: In this example the polygon is a rectangle parallel with the X axis.
+Output explanation: The polygon is a 3x2 rectangle parallel with the X axis.
 
 =========================================
 To check if a point is inside a polygon you'll need to draw a straight line (in any of the 4 directions: up, right, down, left),
@@ -23,22 +23,22 @@
 
 def check_if_point_inside_polygon(polygon, p):
     n = len(polygon)
-    # add the first point as last to avoid checking, using modulo (polygon[(i + 1) % n]) or duplicate code for the last point
-    polygon.append(polygon[0])
+    prev = polygon[-1]
     is_inside = False   # or you can use counter and return (counter % 2) == 1
 
-    for i in range(n):
-        if intersect(polygon[i], polygon[i + 1], p):
+    for curr in polygon:
+        if intersect(prev, curr, p):
             is_inside = not is_inside
+        prev = curr
 
     return is_inside
 
 def intersect(a, b, p):
     # Y coordinate of p should be between Y coordinates
     # this can be written like (a[1] > p[1]) != (b[1] > p[1])
     if p[1] < max(a[1], b[1]) and p[1] >= min(a[1], b[1]):
-        ''' 
-        Equation of line:   
+        '''
+        Equation of line:
         y = (x - x0) * ((y1 - y0) / (x1 - x0)) + y0
         This formula is computed using the gradients (slopes, changes in the coordinates)
         Modify this formula to find X instead Y (because you already have Y)
@@ -65,6 +65,10 @@ def intersect(a, b, p):
 # Correct result => True
 print(check_if_point_inside_polygon([(0, 0), (3, 0), (3, 2), (0, 2)], (3, 1)))
 
+# Test 3
+# Correct result => True
+print(check_if_point_inside_polygon([(0, 0), (3, 0), (3, 2), (0, 2)], (3, 0)))
+
 # Test 3
 # Correct result => False
 print(check_if_point_inside_polygon([(0, 0), (3, 0), (3, 2), (0, 2)], (3, 3)))

Diff for: Math/check_if_two_rectangles_overlap.py

@@ -0,0 +1,62 @@
+'''
+Check if Two Rectangles Overlap
+
+Given two rectangles, find if the given two rectangles overlap or not.
+Note that a rectangle can be represented by two coordinates, top left and bottom right.
+So mainly we are given following four coordinates (min X and Y and max X and Y).
+    - l1: Bottom Left coordinate of first rectangle. (mins)
+    - r1: Top Right coordinate of first rectangle. (maxs)
+    - l2: Bottom Left coordinate of second rectangle. (mins)
+    - r2: Top Right coordinate of second rectangle. (maxs)
+It may be assumed that the rectangles are PARALLEL to the coordinate axis.
+
+Input: (0, 0), (3, 2), (1, 1), (5, 4)
+Output: True
+
+=========================================
+First check if rectangles are overlapping on X axis and
+after that if they are overlapping on Y axis.
+    Time Complexity:    O(1)
+    Space Complexity:   O(1)
+'''
+
+
+############
+# Solution #
+############
+
+def check_if_two_rectangles_overlap(l1, r1, l2, r2):
+    # first check by X coordinates, if rectangles can overlap on X axis
+    # longer form (l1[0] < l2[0] and r1[0] < l2[0]) or (l1[0] > r2[0] and r1[0] > r2[0])
+    # but we know that l1[0] is always smaller than r1[0]
+    if (r1[0] < l2[0]) or (l1[0] > r2[0]):
+        return False
+
+    # now we know that the rectangles are overlapping on X axis
+    # check if they are overlapping on Y axis
+    # (use the same logic from previous)
+    if (r1[1] < l2[1]) or (l1[1] > r2[1]):
+        return False
+
+    return True
+
+
+###########
+# Testing #
+###########
+
+# Test 1
+# Correct result => True
+print(check_if_two_rectangles_overlap((0, 0), (3, 2), (1, 1), (5, 4)))
+
+# Test 2
+# Correct result => True
+print(check_if_two_rectangles_overlap((0, 0), (3, 2), (3, 2), (5, 4)))
+
+# Test 3
+# Correct result => True
+print(check_if_two_rectangles_overlap((0, 0), (3, 2), (1, -1), (5, 4)))
+
+# Test 4
+# Correct result => False
+print(check_if_two_rectangles_overlap((0, 0), (3, 2), (2, 3), (5, 4)))

Diff for: README.md

@@ -89,7 +89,7 @@ Each solution/problem in this repo belongs to one of these categories:
 3. [Trees](https://github.com/MTrajK/coding-problems/tree/master/Trees) - Binary Search Trees, Tree Traversals: Breadth-First (Level Order) Traversal, Depth-First Traversal (Inorder, Preorder, Postorder), etc.
 4. [Dynamic Programming](https://github.com/MTrajK/coding-problems/tree/master/Dynamic%20Programming) - 2D and 1D Dynamic Programming, LCS, LIS, Knapsack, etc.
 5. [Strings](https://github.com/MTrajK/coding-problems/tree/master/Strings) - String Manipulations, Reversing, Encodings/Decodings, etc.
-6. [Math](https://github.com/MTrajK/coding-problems/tree/master/Math) - GCD, LCM, Prime Factors, Math Formulas, etc.
+6. [Math](https://github.com/MTrajK/coding-problems/tree/master/Math) - GCD, LCM, Factorization, Geometry, Math Formulas, etc.
 7. [Other](https://github.com/MTrajK/coding-problems/tree/master/Other) - Backtracking, BFS, DFS, Queues, Stacks, Matrices, etc.