feat(algorithms, two-pointers): triangle numbers

Author: BrianLusina

algorithms/two_pointers/triangle_numbers/README.md

@@ -0,0 +1,83 @@
+# Triangle Numbers
+
+Write a function to count the number of triplets in an integer array nums that could form the sides of a triangle. For
+three sides to form a valid triangle, the sum of any two sides must be greater than the third side. The triplets do not
+need to be unique.
+
+## Examples
+
+```text
+Input:
+nums = [11,4,9,6,15,18]
+
+Output:
+10
+
+Explanation: Valid combinations are...
+
+4, 15, 18
+6, 15, 18
+9, 15, 18
+11, 15, 18
+9, 11, 18
+6, 11, 15
+9, 11, 15
+4, 6, 9     
+```
+
+## Solution
+
+In order for a triplet to be valid lengths of a triangle, the sum of any two sides must be greater than the third side. 
+By sorting the array, we can leverage the two-pointer technique to count all valid triplets in O(n2) time and O(1) space.
+The key to this question is realizing that if we sort three numbers from smallest to largest (say a ≤ b ≤ c), we only
+need to check if a + b > c. If this condition holds, the other two conditions (a + c > b and b + c > a) are automatically
+satisfied because c ≥ b and b ≥ a. For example, with 4, 8, 9, if 4 + 8 > 9 is true, then we have a valid triplet.
+
+![Solution 1](./images/solutions/triangle_numbers_solution_1.png)
+
+But not only that, triplets where the smallest number is between 4 and 8 are also valid triplets.
+
+![Solution 2](./images/solutions/triangle_numbers_solution_2.png)
+
+This means that if we sort the input array, and then iterate from the end of the array to the beginning, we can use the
+two-pointer technique to efficiently count all valid triplets.
+
+![Solution 3](./images/solutions/triangle_numbers_solution_3.png)
+
+The pointers i, left, and right represent the current triplet we are considering. If nums[left] + nums[right] > nums[i]
+then we know there are a total of right - left valid triplets, since all triplets between left and right are also valid
+triplets. We can then decrement right to check for the valid triplets that can be made by decreasing the middle value.
+
+![Solution 4](./images/solutions/triangle_numbers_solution_4.png)
+![Solution 5](./images/solutions/triangle_numbers_solution_5.png)
+![Solution 6](./images/solutions/triangle_numbers_solution_6.png)
+![Solution 7](./images/solutions/triangle_numbers_solution_7.png)
+
+When nums[left] + nums[right] < nums[i], we know that all triplets between left and right are also invalid, so we
+increment left to look for a larger smallest value.
+
+![Solution 8](./images/solutions/triangle_numbers_solution_8.png)
+
+Each time left and right cross, we decrement i and reset left and right to their positions at opposite ends of the array.
+This happens until i is less than 2, at which point we have counted all valid triplets.
+
+![Solution 9](./images/solutions/triangle_numbers_solution_9.png)
+![Solution 10](./images/solutions/triangle_numbers_solution_10.png)
+![Solution 11](./images/solutions/triangle_numbers_solution_11.png)
+![Solution 12](./images/solutions/triangle_numbers_solution_12.png)
+![Solution 13](./images/solutions/triangle_numbers_solution_13.png)
+![Solution 14](./images/solutions/triangle_numbers_solution_14.png)
+![Solution 15](./images/solutions/triangle_numbers_solution_15.png)
+![Solution 16](./images/solutions/triangle_numbers_solution_16.png)
+![Solution 17](./images/solutions/triangle_numbers_solution_17.png)
+![Solution 18](./images/solutions/triangle_numbers_solution_18.png)
+![Solution 19](./images/solutions/triangle_numbers_solution_19.png)
+![Solution 20](./images/solutions/triangle_numbers_solution_20.png)
+![Solution 21](./images/solutions/triangle_numbers_solution_21.png)
+![Solution 22](./images/solutions/triangle_numbers_solution_22.png)
+![Solution 23](./images/solutions/triangle_numbers_solution_23.png)
+![Solution 24](./images/solutions/triangle_numbers_solution_24.png)
+![Solution 25](./images/solutions/triangle_numbers_solution_25.png)
+![Solution 26](./images/solutions/triangle_numbers_solution_26.png)
+![Solution 27](./images/solutions/triangle_numbers_solution_27.png)
+![Solution 28](./images/solutions/triangle_numbers_solution_28.png)

algorithms/two_pointers/triangle_numbers/__init__.py

@@ -0,0 +1,51 @@
+from typing import List
+
+
+def triangle_number(heights: List[int]) -> int:
+    """
+    Finds the count of valid triangles that can be formed from the given input of numbers. A valid triangle is a triangle
+    which has any two sides whose sum is greater than the third side. This assumes that it is okay to manipulate the
+    input list. Therefore callers of this function should be aware that the input list is manipulated in place.
+
+    Args:
+        heights (list): list of integers that represent sides of a triangle
+    Returns:
+        int: number of valid triangles that can be formed
+    """
+    # If there are no heights, or we have an empty list, return 0 early as no valid triangles can be formed here.
+    if not heights:
+        return 0
+
+    # Sorts the heights in place. This incurs a time complexity cost of O(n log(n)) and space cost of O(n) as this sorting
+    # requires temporary storage using Python's timsort
+    heights.sort()
+
+    # Keeps track of number of valid triangles that can be formed
+    count = 0
+
+    # Iterate through the list starting from the back, idx will be at the last position, this will be the third pointer
+    for idx in range(len(heights) - 1, 1, -1):
+        # Initialize the two pointers to keep track of the other two indices that will point to the two other numbers that
+        # can form a valid triangle.
+        left = 0
+        right = idx - 1
+
+        # This is a micro-optimization to get the largest side and use it in the loop below
+        largest_side = heights[idx]
+
+        while left < right:
+            # A valid triplet is found by satisfying the condition a + b > c. If this condition holds, then the other
+            # two conditions hold as well, a + c > b and b + c > a.
+            is_valid_triplet = heights[left] + heights[right] > largest_side
+            if is_valid_triplet:
+                # The numbers between the right and left pointers form valid triplets with the number at the idx position
+                # we find all the possible triplets(triangles) that can be formed by finding the difference.
+                count += right - left
+                # we decrement right to check if there are valid triplets that can be formed by decreasing the middle valid
+                right -= 1
+            else:
+                # Increase the left to find the next maximum minimum number that can form a valid triplet
+                left += 1
+
+    # return the count of the triangles that can be formed
+    return count