Updated two_num.py

### Summary
Refactored the `two_sum` function to enhance clarity, improve structure, and ensure compliance with Python best practices (PEP 8). This version prioritizes intuitive logic, robust error handling, and clear documentation.

### Key Changes
- **Function Renaming:** Renamed `twoSum` to `two_sum` to adhere to PEP 8 standards for function naming.
- **Improved Variable Naming:** Replaced ambiguous names (`chk_map`, `compl`) with more intuitive identifiers (`seen_values`, `complement`).
- **Added Type Hints:** Introduced `from typing import List, Union` to improve code clarity and provide IDE/linter support.
- **Enhanced Docstring:** Expanded the docstring to include detailed function descriptions, argument explanations, and return behavior.
- **Robust Return Handling:** Ensured the function explicitly returns `False` if no valid pair is found, improving clarity in edge cases.
- **Improved Output Structure:** Added a `__main__` block with structured output for cleaner and more informative result display.

### Rationale
These changes improve:
- **Readability:** Clearer variable names and enhanced documentation make the code easier to understand for future developers (and my future self).
- **Maintainability:** Improved structure provides a stronger foundation for future feature enhancements or modifications.
- **Compliance:** Aligns with Python's official best practices for formatting and style (PEP 8).

Author: dnoice

two_num.py

@@ -1,26 +1,57 @@
-"""Author Anurag Kumar (mailto:[email protected])
+"""
+Author: Anurag Kumar (mailto:[email protected])
 
-Given an array of integers, return indices of the two numbers
-such that they add up to a specific target.
-You may assume that each input would have exactly one solution,
-and you may not use the same element twice.
+Description:
+    This function finds two numbers in a given list that add up to a specified target. 
+    It returns the indices of those two numbers.
 
-Example:
-Given nums = [2, 7, 11, 15], target = 9,
-Because nums[0] + nums[1] = 2 + 7 = 9,
-return [0, 1].
+Constraints:
+    - Each input will have exactly one solution.
+    - The same element cannot be used twice.
 
+Example:
+    >>> two_sum([2, 7, 11, 15], 9)
+    [0, 1]
 """
 
+from typing import List, Union
+
+def two_sum(nums: List[int], target: int) -> Union[List[int], bool]:
+    """
+    Finds indices of two numbers in 'nums' that add up to 'target'.
+
+    Args:
+        nums (List[int]): List of integers.
+        target (int): Target sum.
 
-def twoSum(nums, target):
-    chk_map = {}
-    for index, val in enumerate(nums):
-        compl = target - val
-        if compl in chk_map:
-            indices = [chk_map[compl], index]
-            print(indices)
-            return [indices]
-        else:
-            chk_map[val] = index
+    Returns:
+        List[int]: Indices of the two numbers that add up to the target.
+        False: If no such pair is found.
+    """
+    # Dictionary to track seen values and their indices
+    seen_values = {}
+
+    for index, value in enumerate(nums):
+        complement = target - value
+        
+        # Check if the complement exists in the dictionary
+        if complement in seen_values:
+            return [seen_values[complement], index]
+
+        # Add current value to dictionary for future reference
+        seen_values[value] = index
+
+    # Return False if no pair is found (explicit is better than implicit)
     return False
+
+# Example usage
+if __name__ == "__main__":
+    example_nums = [2, 7, 11, 15]
+    example_target = 9
+    result = two_sum(example_nums, example_target)
+    
+    # Clean, professional result display
+    if result:
+        print(f"Indices that add up to {example_target}: {result}")
+    else:
+        print(f"No combination found that adds up to {example_target}.")