Added solution for Perfect Rectangle and added a note about competitive programming in the README

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

Diff for: Hashing DS/perfect_rectangle.py

@@ -0,0 +1,124 @@
+'''
+Perfect Rectangle
+
+Given N axis-aligned rectangles where N > 0, determine if they all together form an exact cover of a rectangular region.
+Each rectangle is represented as a bottom-left point and a top-right point. For example, a unit square is represented as [1,1,2,2].
+(coordinate of bottom-left point is (1, 1) and top-right point is (2, 2)).
+
+Input: [
+        [1, 1, 3, 3],
+        [3, 1, 4, 2],
+        [3, 2, 4, 4],
+        [1, 3, 2, 4],
+        [2, 3, 3, 4]
+    ]
+Output: True
+Output explanation: All 5 rectangles together form an exact cover of a rectangular region.
+
+Input: [
+        [1, 1, 2, 3],
+        [1, 3, 2, 4],
+        [3, 1, 4, 2],
+        [3, 2, 4, 4]
+    ]
+Output: False
+Output explanation: Because there is a gap between the two rectangular regions.
+
+Input: [
+        [1, 1, 3, 3],
+        [3, 1, 4, 2],
+        [1, 3, 2, 4],
+        [3, 2, 4, 4]
+    ]
+Output: False
+Output explanation: Because there is a gap in the top center.
+
+Input: [
+        [1, 1, 3, 3],
+        [3, 1, 4, 2],
+        [1, 3, 2, 4],
+        [2, 2, 4, 4]
+    ]
+Output: False
+Output explanation: Because two of the rectangles overlap with each other.
+
+=========================================
+Check if 4 unique points exist. If 4 unique points exist, then
+check if the sum of all rectangles is equal to the final rectangle.
+    Time Complexity:    O(N)
+    Space Complexity:   O(N)
+'''
+
+
+############
+# Solution #
+############
+
+import math
+
+def is_perfect_rectangle(rectangles):
+    areas_sum = 0
+    all_points = set()
+
+    for rect in rectangles:
+        # sum the areas of all rectangles
+        areas_sum += (rect[2] - rect[0]) * (rect[3] - rect[1])
+
+        # find all points of the rectangle and check if they already exist
+        rect_points = [
+            (rect[0], rect[1]),   # left bottom
+            (rect[0], rect[3]),   # left top
+            (rect[2], rect[3]),   # right top
+            (rect[2], rect[1])    # right bottom
+        ]
+
+        for point in rect_points:
+            if point in all_points:
+                all_points.remove(point)
+            else:
+                all_points.add(point)
+
+    # if we want a perfect rectangle then the rectangle must have 4 unique points
+    if len(all_points) != 4:
+        return False
+
+    # find the bounding rectangle coordinates (minX, minY, maxX, maxY)
+    bounding_rectangle = [math.inf, math.inf, -math.inf, -math.inf]
+    for point in all_points:
+        bounding_rectangle = [
+            min(bounding_rectangle[0], point[0]),
+            min(bounding_rectangle[1], point[1]),
+            max(bounding_rectangle[2], point[0]),
+            max(bounding_rectangle[3], point[1])
+        ]
+
+    # calculate the area of bounding rectangle
+    bounding_rectangle_area = (bounding_rectangle[2] - bounding_rectangle[0]) * (bounding_rectangle[3] - bounding_rectangle[1])
+
+    # to see if there are overlapping, compare the sum of areas with the final rectangle area
+    return areas_sum == bounding_rectangle_area
+
+
+###########
+# Testing #
+###########
+
+# Test 1
+# Correct result => True
+rectangles = [[1, 1, 3, 3], [3, 1, 4, 2], [3, 2, 4, 4], [1, 3, 2, 4], [2, 3, 3, 4]]
+print(is_perfect_rectangle(rectangles))
+
+# Test 2
+# Correct result => False
+rectangles = [[1, 1, 2, 3], [1, 3, 2, 4], [3, 1, 4, 2], [3, 2, 4, 4]]
+print(is_perfect_rectangle(rectangles))
+
+# Test 3
+# Correct result => False
+rectangles = [[1, 1, 3, 3], [3, 1, 4, 2], [1, 3, 2, 4], [3, 2, 4, 4]]
+print(is_perfect_rectangle(rectangles))
+
+# Test 4
+# Correct result => False
+rectangles = [[1, 1, 3, 3], [3, 1, 4, 2], [1, 3, 2, 4], [2, 2, 4, 4]]
+print(is_perfect_rectangle(rectangles))

Diff for: README.md

@@ -144,7 +144,7 @@ Several books that have made an impression on me:
 3. [Algorithms by Robert Sedgewick & Kevin Wayne](https://www.goodreads.com/book/show/10803540-algorithms) - These authors are instructors of the previously mentioned coursera courses: [Algorithms Part 1](https://www.coursera.org/learn/algorithms-part1) and [Algorithms Part 2](https://www.coursera.org/learn/algorithms-part2). Also this book has excellent and free [site](http://algs4.cs.princeton.edu) with exercises, presentations, and examples.
 4. [The Algorithm Design Manual by Steven Skiena](https://www.goodreads.com/book/show/425208.The_Algorithm_Design_Manual) - The book describes many advanced topics and algorithms and it focuses on real life practical examples. This book has one of the best [site](http://www.algorist.com) with resources ([solutions](http://www.algorist.com/algowiki/index.php/The_Algorithms_Design_Manual_(Second_Edition)), [algorithms and data structures](http://www.algorist.com/algorist.html), [python implementations](http://www.algorist.com/languages/Python.html)).
 5. [Algorithms by S. Dasgupta, C. Papadimitriou, and U. Vazirani](https://www.goodreads.com/book/show/138563.Algorithms) - This book is an official book for algorithms and data structures classes in several famous universities.
-6. [Competitive Programming 3 by Steven Halim & Felix Halim](https://www.goodreads.com/book/show/22820968-competitive-programming-3) - A great book that prepares you for competitive programming (not for complete beginners). You can learn many things and tricks about competitive programming.
+6. [Competitive Programming 3 by Steven Halim & Felix Halim](https://www.goodreads.com/book/show/22820968-competitive-programming-3) - A great book that prepares you for competitive programming (not for complete beginners). You can learn many things and tricks about competitive programming. *But if your goal is to prepare for competitive programming then choose a faster language than Python, **C/C++** (or Java, it's faster than Python but not like C/C++).*
 
 
 ### Training Sites