feat(algorithms, array): is valid subsequence

Adds the validate subsequence algorithm solution to check if an array
is a valid subsequence of another input array. Here integers are used.
However, this can be modified to take in generics to where the types are
comparable to check if one is a valid subsequence of another input list.

This provides two approaches to the problem. One iterates through the
main array checking if the first element in the subsequence equals to
the first element in the array and if true, moves the `seek` pointer up
by 1.

If not, the `seek` pointer is checked against the length of the
subsequence to check if it has reached the end and if so, then the
sequence is a valid subsequence of the input array.

Similar approach is applied to the second alternative solution. However,
two pointers are used, were `i` is the pointer that will be used on the
subsequence and `j` is the pointer that will be used on the main input
array. The `while` loop condition is used to ensure that both `i` and
`j` do not go over the bounds and checks if the value at pointer `i` on
the sequence is equal to the value at pointer `j` on the input array. If
so, then the `i` pointer is moved up by one. Either way, the `j` pointer
is moved up by one along the main input array.
After the loop complets, the `i` pointer is checked against the length
of the sequence to verify that it reached the end. if not, then the
sequence is not a valid subsequence otherwise it is regarded as a valid
subsequence.

Author: BrianLusina

algorithms/arrays/subsequence/README.md

@@ -0,0 +1,35 @@
+# Validate Subsequence
+
+Given two non-empty arrays of integers, write a function that determines whether the second array is a subsequence of
+the first one.
+
+A subsequence of an array is a set of numbers that aren't necessarily adjacent in the array but that are in the same
+order as they appear in the array. For instance, the numbers [1, 3, 4] form a subsequence of the array
+[1, 2, 3, 4], and so do the numbers [2, 4]. Note that a single number in an array and the array itself are both valid
+subsequences of the array.
+
+``` plain
+Example 1:
+
+Input: array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [1, 6, -1, 10]
+Output: true
+
+Example 2:
+
+Input: array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [5, 1, 22, 6, -1, 8, 10]
+Output: true
+Example 3:
+
+Input: array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [5, 6, 1, 10, 22, 8, -1, 25]
+Output: false
+```
+
+## Related Topics
+
+- Array
+- Hash Table
+- Two Pointers
+- Binary Search
+- Greedy
+- Sorting
+

algorithms/arrays/subsequence/__init__.py

@@ -0,0 +1,71 @@
+from typing import List
+
+
+def is_valid_subsequence(array: List[int], sequence: List[int]) -> bool:
+    """
+    Returns true if a sequence is a subsequence of the provided array
+
+    A subsequence of an array is a set of numbers that aren't necessarily adjacent in the array but that are in the same
+    order as they appear in the array. For instance, the numbers [1, 3, 4] form a subsequence of the array
+    [1, 2, 3, 4], and so do the numbers [2, 4]. Note that a single number in an array and the array itself are both valid
+    subsequences of the array.
+
+    Time complexity: O(n) - where n is the length of the array. We iterate through the array once to find the first
+    element in the sequence. Then, we iterate through the sequence once to check if the current element in the array is
+
+    Space complexity: O(1) - we only use a constant amount of extra space to store variables and do not depend on the
+    input size.
+
+    Args:
+        array (list): A non-empty array of integers.
+        sequence (list): A non-empty array of integers.
+
+    Returns:
+        A boolean that indicates whether the second array is a subsequence of the first one.
+    """
+    # a sequence that is longer than the array is not a valid subsequence
+    if len(sequence) > len(array) or len(array) == 0 or len(sequence) == 0:
+        return False
+
+    seek = 0
+
+    for i in range(len(array)):
+        if sequence[seek] == array[i]:
+            seek += 1
+        if seek == len(sequence):
+            return True
+
+    return False
+
+def is_valid_subsequence_v2(array: List[int], sequence: List[int]) -> bool:
+    """
+    Returns true if a sequence is a subsequence of the provided array
+
+    A subsequence of an array is a set of numbers that aren't necessarily adjacent in the array but that are in the same
+    order as they appear in the array. For instance, the numbers [1, 3, 4] form a subsequence of the array
+    [1, 2, 3, 4], and so do the numbers [2, 4]. Note that a single number in an array and the array itself are both valid
+    subsequences of the array.
+
+    Time complexity: O(n) - where n is the length of the array. We iterate through the array once to find the first
+    element in the sequence. Then, we iterate through the sequence once to check if the current element in the array is
+
+    Space complexity: O(1) - we only use a constant amount of extra space to store variables and do not depend on the
+    input size.
+
+    Args:
+        array (list): A non-empty array of integers.
+        sequence (list): A non-empty array of integers.
+
+    Returns:
+        A boolean that indicates whether the second array is a subsequence of the first one.
+    """
+    i, j = 0, 0
+
+    while i < len(sequence) and j < len(array):
+        if sequence[i] == array[j]:
+            i += 1
+        j += 1
+
+    if i == len(sequence):
+        return True
+    return False

algorithms/arrays/subsequence/test_is_valid_subsequence.py

@@ -0,0 +1,79 @@
+import unittest
+from . import is_valid_subsequence, is_valid_subsequence_v2
+
+
+class IsValidSubsequenceTestCase(unittest.TestCase):
+    def test_1(self):
+        """array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [1, 6, -1, 10]"""
+        array = [5, 1, 22, 25, 6, -1, 8, 10]
+        sequence = [1, 6, -1, 10]
+        actual = is_valid_subsequence(array, sequence)
+        self.assertTrue(actual)
+
+    def test_2(self):
+        """should return True for array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [5, 1, 22, 6, -1, 8, 10]"""
+        array =  [5, 1, 22, 25, 6, -1, 8, 10]
+        sequence = [5, 1, 22, 6, -1, 8, 10]
+        actual = is_valid_subsequence(array, sequence)
+        self.assertTrue(actual)
+
+    def test_3(self):
+        """should return False for array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [5, 6, 1, 10, 22, 8, -1, 25]"""
+        array =  [5, 1, 22, 25, 6, -1, 8, 10]
+        sequence = [5, 6, 1, 10, 22, 8, -1, 25]
+        actual = is_valid_subsequence(array, sequence)
+        self.assertFalse(actual)
+
+    def test_4(self):
+        """should return True for array = [1,2,3,4], sequence = [1,3,4]"""
+        array =  [1,2,3,4]
+        sequence = [1,3,4]
+        actual = is_valid_subsequence(array, sequence)
+        self.assertTrue(actual)
+
+    def test_5(self):
+        """should return True for array = [1,2,3,4], sequence = [2,4]"""
+        array =  [1,2,3,4]
+        sequence = [2,4]
+        actual = is_valid_subsequence(array, sequence)
+        self.assertTrue(actual)
+
+class IsValidSubsequenceV2TestCase(unittest.TestCase):
+    def test_1(self):
+        """array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [1, 6, -1, 10]"""
+        array = [5, 1, 22, 25, 6, -1, 8, 10]
+        sequence = [1, 6, -1, 10]
+        actual = is_valid_subsequence_v2(array, sequence)
+        self.assertTrue(actual)
+
+    def test_2(self):
+        """should return True for array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [5, 1, 22, 6, -1, 8, 10]"""
+        array =  [5, 1, 22, 25, 6, -1, 8, 10]
+        sequence = [5, 1, 22, 6, -1, 8, 10]
+        actual = is_valid_subsequence_v2(array, sequence)
+        self.assertTrue(actual)
+
+    def test_3(self):
+        """should return False for array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [5, 6, 1, 10, 22, 8, -1, 25]"""
+        array =  [5, 1, 22, 25, 6, -1, 8, 10]
+        sequence = [5, 6, 1, 10, 22, 8, -1, 25]
+        actual = is_valid_subsequence_v2(array, sequence)
+        self.assertFalse(actual)
+
+    def test_4(self):
+        """should return True for array = [1,2,3,4], sequence = [1,3,4]"""
+        array =  [1,2,3,4]
+        sequence = [1,3,4]
+        actual = is_valid_subsequence_v2(array, sequence)
+        self.assertTrue(actual)
+
+    def test_5(self):
+        """should return True for array = [1,2,3,4], sequence = [2,4]"""
+        array =  [1,2,3,4]
+        sequence = [2,4]
+        actual = is_valid_subsequence_v2(array, sequence)
+        self.assertTrue(actual)
+
+
+if __name__ == '__main__':
+    unittest.main()