feat(algorithms, arrays): sorted squared array

Adds the algorithm for handling the sorted square array problem where an
input of integers is used as an input to the function and the output
result is the squares of each value in ascending order.

The assumption made here is that the input array is in ascending order
and that the integers can be negative, meaning that the order of the
squares will be the same as the input array elements that generated the
squares i.e. the positions might not match.

This uses a two pointer approach to ensure that the resultant array is
in order. The two pointer approach as the benefit of using less time to
handle sorting as sorting is not done in this approach. However a new
array is created which incurs a cost of O(n) where n is the size of the
input array.

Author: BrianLusina

algorithms/arrays/sorted_squared_array/README.md

@@ -0,0 +1,41 @@
+# Sorted Squared Array
+
+Write a function that takes in a non-empty array of integers that are sorted
+in ascending order and returns a new array of the same length with the squares
+of the original integers also sorted in ascending order
+
+```plain
+Sample Input
+
+array = [1, 2, 3, 5, 6, 8, 9]
+
+Sample Output
+
+[1, 4, 9, 25, 36, 64, 81]
+```
+
+## Hints
+
+1. While the integers in the input array are sorted in increasing order, their
+  squares won't necessarily be as well, because of the possible presence of
+  negative numbers
+2. Traverse the array value by value, square each value, and insert the squares
+  into an output array. Then, sort the output array before returning it. Is this
+  the optimal solution?
+3. To reduce the time complexity of the algorithm mentioned in Hint #2, you need
+  to avoid sorting the ouput array. To do this, as you square the values of the
+  input array, try to directly insert them into their correct position in the
+  output array.
+4. Use two pointers to keep track of the smallest and largest values in the input
+  array. Compare the absolute values of these smallest and largest values,
+  square the larger absolute value, and place the square at the end of the
+  output array, filling it up from right to left. Move the pointers accordingly,
+  and repeat this process until the output array is filled.
+
+## Optimal Space & Time Complexity
+
+- Time complexity: O(n)
+- Space complexity: O(n)
+
+Where n is the length of the input array
+

algorithms/arrays/sorted_squared_array/__init__.py

@@ -0,0 +1,71 @@
+from typing import List
+
+
+def sorted_squared_array(array: List[int]) -> List[int]:
+    """
+    Takes in a sorted array and returns a new array with the values squared and sorted in ascending order.
+    Args:
+        array (List[int]): A sorted array of integers.
+    Returns:
+        List[int]: A new array with the values squared and sorted in ascending order.
+    """
+    n = len(array)
+    if n == 0:
+        return []
+    # the result array must be the same length as the input array
+    result = [0] * n
+
+    # two pointers that point to the start and end of the input array to enable insertion of the squared values in
+    # ascending order
+    left, right = 0, n - 1
+
+    # file result array from right to left (largest to smallest squares
+    for i in range(n-1, -1, -1):
+        left_abs = abs(array[left])
+        right_abs = abs(array[right])
+
+        if left_abs > right_abs:
+            square = left_abs * left_abs
+            result[i] = square
+            left += 1
+        else:
+            square = right_abs * right_abs
+            result[i] = square
+            right -= 1
+
+    # Write your code here.
+    return result
+
+
+def sorted_squared_array_2(array: List[int]) -> List[int]:
+    """
+    Takes in a sorted array and returns a new array with the values squared and sorted in ascending order.
+    Args:
+        array (List[int]): A sorted array of integers.
+    Returns:
+        List[int]: A new array with the values squared and sorted in ascending order.
+    """
+    n = len(array)
+    if n == 0:
+        return []
+    # the result array must be the same length as the input array
+    result = [0] * n
+
+    # two pointers that point to the start and end of the input array to enable insertion of the squared values in
+    # ascending order
+    left, right = 0, n - 1
+
+    # file result array from right to left (largest to smallest squares
+    for i in range(n-1, -1, -1):
+        left_square = array[left] ** 2
+        right_square = array[right] ** 2
+
+        if left_square > right_square:
+            result[i] = left_square
+            left += 1
+        else:
+            result[i] = right_square
+            right -= 1
+
+    # Write your code here.
+    return result

algorithms/arrays/sorted_squared_array/test_sorted_squared_array.py

@@ -0,0 +1,38 @@
+import unittest
+from . import sorted_squared_array, sorted_squared_array_2
+
+
+class SortedSquaredArrayTestCases(unittest.TestCase):
+    def test_1(self):
+        """for an input of [1,2,3,5,6,8,9] it should return [1, 4, 9,25, 36, 64, 81]"""
+        input_array = [1, 2, 3, 5, 6, 8, 9]
+        expected = [1, 4, 9, 25, 36, 64, 81]
+        actual = sorted_squared_array(input_array)
+        self.assertEqual(expected, actual)
+
+    def test_2(self):
+        """for an input of [1] it should return [1]"""
+        input_array = [1]
+        expected = [1]
+        actual = sorted_squared_array(input_array)
+        self.assertEqual(expected, actual)
+
+
+class SortedSquaredArray2TestCases(unittest.TestCase):
+    def test_1(self):
+        """for an input of [1,2,3,5,6,8,9] it should return [1, 4, 9,25, 36, 64, 81]"""
+        input_array = [1, 2, 3, 5, 6, 8, 9]
+        expected = [1, 4, 9, 25, 36, 64, 81]
+        actual = sorted_squared_array_2(input_array)
+        self.assertEqual(expected, actual)
+
+    def test_2(self):
+        """for an input of [1] it should return [1]"""
+        input_array = [1]
+        expected = [1]
+        actual = sorted_squared_array_2(input_array)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == '__main__':
+    unittest.main()