feat(dsa): find duplicate using fast and slow pointers

Author: BrianLusina

algorithms/fast_and_slow/__init__.py

@@ -35,3 +35,5 @@ No number repeats itself in the array [1, 2, 3]
 Explanation 3:
 1 and 4 repeats itself in the array [3, 4, 1, 4, 1], we can return 1 or 4
 ```
+
+> Note: You cannot modify the given array nums. You have to solve the problem using only constant extra space.

puzzles/find_duplicate/README.md …s/fast_and_slow/find_duplicate/README.mdpuzzles/find_duplicate/README.md renamed to algorithms/fast_and_slow/find_duplicate/README.md puzzles/find_duplicate/README.md renamed to algorithms/fast_and_slow/find_duplicate/README.md

@@ -0,0 +1,70 @@
+from typing import List
+
+
+def find_duplicate_floyd_algo(numbers: List[int]) -> int:
+    """
+    Finds the duplicate number in a list of integers.
+
+    This code implements Floyd's Tortoise and Hare algorithm to find the duplicate number in a list of integers. It
+    uses two pointers, slow and fast, that move at different speeds through the list, eventually meeting at the
+    duplicate number. The algorithm assumes that the list contains a duplicate number and that the numbers in the list
+    are indices that point to other numbers in the list.
+
+    Args:
+        numbers (list): list of integers
+    Returns:
+        int: duplicated integer
+    """
+    if not numbers:
+        raise ValueError("List is empty")
+
+    if not all(isinstance(num, int) for num in numbers):
+        raise ValueError("List contains non-integer values")
+
+    if len(numbers) == len(set(numbers)):
+        return -1
+
+    if len(numbers) <= 1:
+        return -1
+
+    slow = numbers[0]
+    fast = numbers[numbers[0]]
+
+    while slow != fast:
+        slow = numbers[slow]
+        fast = numbers[numbers[fast]]
+
+    fast = 0
+    while fast != slow:
+        slow = numbers[slow]
+        fast = numbers[fast]
+
+    return slow
+
+
+def find_duplicate(numbers: List[int]) -> int:
+    """
+    Finds the duplicate number in a list of integers.
+    @param numbers: List of integers
+    @return: duplicated integer
+    """
+    if not numbers:
+        raise ValueError("List is empty")
+
+    if not all(isinstance(num, int) for num in numbers):
+        raise ValueError("List contains non-integer values")
+
+    if len(numbers) == len(set(numbers)):
+        return -1
+
+    if len(numbers) <= 1:
+        return -1
+
+    for i in range(len(numbers)):
+        idx = abs(numbers[i])
+        if numbers[idx] < 0:
+            return abs(numbers[i])
+        else:
+            numbers[idx] = -numbers[idx]
+
+    return -1

algorithms/fast_and_slow/find_duplicate/__init__.py

@@ -0,0 +1,154 @@
+import unittest
+
+from . import find_duplicate, find_duplicate_floyd_algo
+
+
+class FindDuplicateTestCases(unittest.TestCase):
+    def test_1(self):
+        """nums = [3, 4, 1, 4, 2] should return 4"""
+        nums = [3, 4, 1, 4, 2]
+        expected = 4
+        actual = find_duplicate(nums)
+
+        self.assertEqual(expected, actual)
+
+    def test_2(self):
+        """nums = [1, 2, 3] should return -1"""
+        nums = [1, 2, 3]
+        expected = -1
+        actual = find_duplicate(nums)
+
+        self.assertEqual(expected, actual)
+
+    def test_3(self):
+        """nums = [3, 4, 1, 4, 1] should return 1 or 4"""
+        nums = [3, 4, 1, 4, 1]
+        expected_1 = 1
+        expected_4 = 4
+
+        actual = find_duplicate(nums)
+
+        self.assertIn(actual, [expected_1, expected_4])
+
+
+class FindDuplicateWithFastAndSlowPointersTestCases(unittest.TestCase):
+    def test_1(self):
+        """nums = [3, 4, 1, 4, 2] should return 4"""
+        nums = [3, 4, 1, 4, 2]
+        expected = 4
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(expected, actual)
+
+    # @unittest.skip("Failing due to IndexError. Needs further investigation")
+    def test_2(self):
+        """nums = [1, 2, 3] should return -1"""
+        nums = [1, 2, 3]
+        expected = -1
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(expected, actual)
+
+    def test_3(self):
+        """nums = [3, 4, 1, 4, 1] should return 1 or 4"""
+        nums = [3, 4, 1, 4, 1]
+        expected_1 = 1
+        expected_4 = 4
+
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertIn(actual, [expected_1, expected_4])
+
+    def test_4(self):
+        """nums = [1, 3, 3, 4, 2, 5] should return 3"""
+        nums = [1, 3, 3, 4, 2, 5]
+        expected = 3
+
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(actual, expected)
+
+    def test_5(self):
+        """nums = [1, 5, 3, 4, 2, 5] should return 5"""
+        nums = [1, 5, 3, 4, 2, 5]
+        expected = 5
+
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(actual, expected)
+
+    def test_6(self):
+        """nums = [1, 2, 3, 4, 5, 6, 6, 7] should return 6"""
+        nums = [1, 2, 3, 4, 5, 6, 6, 7]
+        expected = 6
+
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(actual, expected)
+
+    def test_7(self):
+        """nums = [4, 6, 7, 7, 3, 5, 2, 8, 1] should return 7"""
+        nums = [4, 6, 7, 7, 3, 5, 2, 8, 1]
+        expected = 7
+
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(actual, expected)
+
+    def test_8(self):
+        """nums = [9, 8, 7, 6, 2, 3, 5, 4, 1, 9] should return 9"""
+        nums = [9, 8, 7, 6, 2, 3, 5, 4, 1, 9]
+        expected = 9
+
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(actual, expected)
+
+    def test_9(self):
+        """nums = [3, 4, 4, 4, 2] should return 4"""
+        nums = [3, 4, 4, 4, 2]
+        expected = 4
+
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(actual, expected)
+
+    def test_10(self):
+        """nums = [1, 1] should return 1"""
+        nums = [1, 1]
+        expected = 1
+
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(actual, expected)
+
+    def test_11(self):
+        """nums = [1,3,4,2,2] should return 2"""
+        nums = [1,3,4,2,2]
+        expected = 2
+
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(actual, expected)
+
+    def test_12(self):
+        """nums = [1,3,6,2,7,3,5,4] should return 3"""
+        nums = [1,3,6,2,7,3,5,4]
+        expected = 3
+
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(actual, expected)
+
+    def test_13(self):
+        """nums = [1,2,2] should return 2"""
+        nums = [1,2,2]
+        expected = 2
+
+        actual = find_duplicate_floyd_algo(nums)
+
+        self.assertEqual(actual, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()