Updated longest alternating subsequence to return actual subsequence

Author: FamALouiz

pydatastructs/linear_data_structures/algorithms.py

@@ -1881,11 +1881,11 @@ def longest_alternating_subsequence(array: OneDimensionalArray, **kwargs) -> int
     >>> arr = OneDimensionalArray(int, [1, 5, 4])
     >>> las = longest_alternating_subsequence(arr)
     >>> las
-    3
+    [1, 5, 4]
     >>> arr = OneDimensionalArray(int, [1, 5, 4, 3, 2, 6, 7])
     >>> las = longest_alternating_subsequence(arr)
     >>> las
-    4
+    [1, 5, 2, 7]
 
     References
     ==========
@@ -1900,20 +1900,27 @@ def longest_alternating_subsequence(array: OneDimensionalArray, **kwargs) -> int
     raise_if_backend_is_not_python(
         longest_alternating_subsequence, kwargs.get('backend', Backend.PYTHON))
 
-    increasing = 1
-    decreasing = 1
+    # Edge case
+    if len(array) == 0:
+        return OneDimensionalArray(int, [])
+
+    increasing = [array[0]]
+    decreasing = [array[0]]
     n = len(array)
 
     # Iterate from second element
     for i in range(1, n):
 
         # Increasing changes if decreasing changes
         if (array[i] > array[i-1]):
-            increasing = decreasing + 1
+            increasing = decreasing + [array[i]]
 
         # Decreasing changes if increasing changes
         elif (array[i] < array[i-1]):
-            decreasing = increasing + 1
+            decreasing = increasing + [array[i]]
 
     # Return the maximum length
-    return max(increasing, decreasing)
+    if len(increasing) > len(decreasing):
+        return OneDimensionalArray(int, increasing)
+    else:
+        return OneDimensionalArray(int, decreasing)

pydatastructs/linear_data_structures/tests/test_algorithms.py

@@ -420,26 +420,41 @@ def test_longest_alternating_subsequence():
     ODA = OneDimensionalArray
 
     arr1 = ODA(int, [-4, 3, -5, 9, 10, 12, 2, -1])
-    output: int = longest_alternating_subsequence(arr1)
-    expected_result = [3, -5, 9, 2, -1]
-    assert len(expected_result) == output
+    output: OneDimensionalArray = longest_alternating_subsequence(arr1)
+    expected_result = [-4, 3, -5, 12, -1]
+    assert str(expected_result) == str(output)
 
     arr2 = ODA(int, [10, 22, 9, 33, 49, 50, 31, 60])
-    output: int = longest_alternating_subsequence(arr2)
-    expected_result = [10, 22, 9, 33, 31, 60]
-    assert len(expected_result) == output
+    output: OneDimensionalArray = longest_alternating_subsequence(arr2)
+    expected_result = [10, 22, 9, 50, 31, 60]
+    assert str(expected_result) == str(output)
 
     arr3 = ODA(int, [1, 2, 3, 4, 5, 6, 7, 8, 9])
-    output: int = longest_alternating_subsequence(arr3)
-    expected_result = [1, 2]
-    assert len(expected_result) == output
+    output: OneDimensionalArray = longest_alternating_subsequence(arr3)
+    expected_result = [1, 9]
+    assert str(expected_result) == str(output)
 
     arr4 = ODA(int, [9, 8, 7, 6, 5, 4, 3, 2, 1])
-    output: int = longest_alternating_subsequence(arr4)
-    expected_result = [9, 8]
-    assert len(expected_result) == output
-
-    arr5 = ODA(int, [1, 5, 4, 3, 2, 1, 6, 7, 8, 9])
-    output: int = longest_alternating_subsequence(arr5)
-    expected_result = [1, 5, 4, 6]
-    assert len(expected_result) == output
+    output: OneDimensionalArray = longest_alternating_subsequence(arr4)
+    expected_result = [9, 1]
+    assert str(expected_result) == str(output)
+
+    arr5 = ODA(int, [1, 5, 4, 3, 2, 6, 7])
+    output: OneDimensionalArray = longest_alternating_subsequence(arr5)
+    expected_result = [1, 5, 2, 7]
+    assert str(expected_result) == str(output)
+
+    arr6 = ODA(int, [1, 5, 4])
+    output: OneDimensionalArray = longest_alternating_subsequence(arr6)
+    expected_result = [1, 5, 4]
+    assert str(expected_result) == str(output)
+
+    arr7 = ODA(int, [])
+    output: OneDimensionalArray = longest_alternating_subsequence(arr7)
+    expected_result = []
+    assert str(expected_result) == str(output)
+
+    arr8 = ODA(int, [1])
+    output: OneDimensionalArray = longest_alternating_subsequence(arr8)
+    expected_result = [1]
+    assert str(expected_result) == str(output)