Solve LeetCode and Algorithm Problems in Python with AI

## Problem Restatement & Approach

Given an array `nums` and a `target`, find two distinct indices `i` and `j` such that `nums[i] + nums[j] == target`.

**Approach:** Use a hash map (dictionary) to store each number's index as we iterate. For each number `x`, check if its complement `target - x` has already been seen. If yes, we've found the pair; otherwise, record `x`'s index and continue.

*Brute-force alternative:* Check every pair with two nested loops in O(n²) time.

## Complexity Analysis

- **Time:** O(n) — single pass through the array, with O(1) average-case dictionary lookups/insertions.
- **Space:** O(n) — the hash map may store up to n entries in the worst case.

## Code

```python
from typing import List

def two_sum(nums: List[int], target: int) -> List[int]:
    """
    Returns indices of the two numbers in `nums` that add up to `target`.
    Assumes exactly one valid solution exists.
    """
    # Maps a previously seen number -> its index in nums
    seen_index_of = {}

    for current_index, current_value in enumerate(nums):
        complement = target - current_value

        # If complement was seen earlier, we've found the pair
        if complement in seen_index_of:
            return [seen_index_of[complement], current_index]

        # Record current value's index for future complement checks
        seen_index_of[current_value] = current_index

    # Per problem constraints, this line should never execute
    return []


# Example usage
if __name__ == "__main__":
    print(two_sum([2, 7, 11, 15], 9))  # Expected: [0, 1]
```

## Walkthrough on `nums = [2, 7, 11, 15]`, `target = 9`

1. **Index 0, value 2:** complement = 9 − 2 = 7. `seen_index_of` is empty, so 7 not found. Store `{2: 0}`.
2. **Index 1, value 7:** complement = 9 − 7 = 2. `2` is in `seen_index_of` at index 0. Return `[0, 1]`. ✅

The algorithm returns on the first hit, so it never examines indices 2 or 3. This single-pass hash-map technique is the standard optimal solution for the Two Sum problem.

# Two Sum Problem Solution

## Problem Restatement & Approach

We need to find two distinct indices in an array where the values sum to a target. The optimal approach uses a **hash map** to store values we've seen along with their indices. As we iterate through the array, for each number, we check if `target - current_number` exists in our map. This gives us O(n) time complexity instead of the brute-force O(n²) nested loop approach.

## Complexity Analysis

- **Time Complexity:** O(n) — single pass through the array with O(1) hash map lookups
- **Space Complexity:** O(n) — hash map stores up to n elements

## Solution

```python
def twoSum(nums: list[int], target: int) -> list[int]:
    """
    Find two indices in nums that sum to target.
    
    Args:
        nums: List of integers
        target: Target sum value
    
    Returns:
        List of two indices [i, j] where nums[i] + nums[j] == target
    """
    # Dictionary to store value -> index mapping
    seen = {}
    
    for current_index, current_num in enumerate(nums):
        # Calculate what number we need to reach the target
        complement = target - current_num
        
        # Check if we've already seen the complement
        if complement in seen:
            # Return indices: complement's index first, current index second
            return [seen[complement], current_index]
        
        # Store current number and its index for future lookups
        seen[current_num] = current_index
    
    # No solution found (shouldn't happen per problem statement)
    return []
```

## Walkthrough with Example

**Input:** `nums = [2,7,11,15]`, `target = 9`

| Iteration | current_index | current_num | complement | seen dict | Action |
|-----------|---|---|---|---|---|
| 0 | 0 | 2 | 7 | {} | 7 not in seen; store {2: 0} |
| 1 | 1 | 7 | 2 | {2: 0} | 2 is in seen! Return [0, 1] ✓ |

**Output:** `[0, 1]` (because `nums[0] + nums[1] = 2 + 7 = 9`)

The algorithm finds that when we reach index 1 (value 7), we need 2 to sum to 9, and we've already seen 2 at index 0, so we immediately return the answer.

### 1) Problem restatement and approach summary

We need to find **two different indices** in `nums` such that their values add up to `target`. The problem guarantees **exactly one valid answer**.

#### Optimal approach: hash map
We scan the array once and store numbers we have already seen in a dictionary:

- For each number `value` at index `i`, compute its needed partner:
  `complement = target - value`
- If `complement` was seen earlier, we immediately return its index and `i`
- Otherwise, store `value -> i` in the dictionary

This gives a fast **one-pass** solution.

> Brute-force alternative: check every pair with two nested loops, which takes `O(n^2)` time.

---

### 2) Time and space complexity

- **Time complexity:** `O(n)`  
  Each element is processed once, and dictionary lookups are average `O(1)`.

- **Space complexity:** `O(n)`  
  In the worst case, we store up to all elements in the hash map.

---

### 3) Python 3 code

```python
from typing import List

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        # Maps a number to the index where it was first seen
        seen_indices = {}

        for current_index, current_value in enumerate(nums):
            complement = target - current_value

            # If we've already seen the needed complement,
            # we have found the two indices
            if complement in seen_indices:
                return [seen_indices[complement], current_index]

            # Otherwise, store the current value and its index
            seen_indices[current_value] = current_index

        # Problem guarantees exactly one solution, so this line is never reached
        return []
```

---

### 4) Short walkthrough with example

Input:
`nums = [2, 7, 11, 15]`, `target = 9`

Step-by-step:

- Start with empty map: `seen_indices = {}`
- Index `0`, value `2`
  - complement = `9 - 2 = 7`
  - `7` not in map
  - store `2: 0`
- Index `1`, value `7`
  - complement = `9 - 7 = 2`
  - `2` is in map at index `0`
  - return `[0, 1]`

So the answer is:

`[0, 1]`

### 1. Problem Restatement and Approach Summary

The goal is to find the indices of two distinct numbers in an array that sum to a given target. The problem guarantees a unique solution exists.

A simple brute-force approach would be to check every pair of numbers, which takes O(n²) time. However, a more optimal solution uses a hash map (a Python dictionary) to achieve linear time complexity. We can iterate through the array once. For each element, we calculate its "complement" (i.e., `target - current_number`). If this complement is already in our hash map, we have found our pair and can return their indices. If not, we add the current number and its index to the map for future lookups.

### 2. Time and Space Complexity Analysis

*   **Time Complexity: O(n)**
    We traverse the list containing `n` elements only once. Each lookup and insertion in the hash map takes, on average, O(1) time.

*   **Space Complexity: O(n)**
    In the worst-case scenario, we might store all `n` elements in the hash map before finding the solution (e.g., if the two numbers that sum to the target are the last two elements in the array).

### 3. Python 3 Code

```python
from typing import List

def two_sum(nums: List[int], target: int) -> List[int]:
    """
    Finds two numbers in a list that sum up to a specific target.

    This function uses a one-pass hash map approach for optimal performance.
    
    Args:
        nums: A list of integers.
        target: The target integer sum.

    Returns:
        A list containing the indices of the two numbers.
    """
    # Dictionary to store numbers we've seen and their indices.
    # Key: number, Value: index
    num_to_index_map = {}

    # Enumerate through the list to get both index and value.
    for current_index, current_num in enumerate(nums):
        # Calculate the complement needed to reach the target.
        complement = target - current_num

        # Check if the complement exists in our map.
        if complement in num_to_index_map:
            # If it exists, we found our solution.
            # Return the index of the complement and the current number's index.
            return [num_to_index_map[complement], current_index]
        
        # If the complement is not found, add the current number and its index to the map.
        # We do this after the check to avoid using the same element twice.
        num_to_index_map[current_num] = current_index
        
    # The problem statement guarantees a solution exists, so this part is unreachable.
    # Included for completeness in a general case.
    return []

```

### 4. Code Walkthrough

Let's trace the execution with the example `nums = [2, 7, 11, 15]` and `target = 9`.

1.  **Initialization:**
    *   `num_to_index_map` is an empty dictionary: `{}`.

2.  **First Iteration (index = 0):**
    *   `current_index` is `0`, `current_num` is `2`.
    *   `complement` is `9 - 2 = 7`.
    *   Is `7` in `num_to_index_map`? No, the map is empty.
    *   Add `current_num` and `current_index` to the map: `num_to_index_map` becomes `{2: 0}`.

3.  **Second Iteration (index = 1):**
    *   `current_index` is `1`, `current_num` is `7`.
    *   `complement` is `9 - 7 = 2`.
    *   Is `2` in `num_to_index_map`? Yes, it is! The key `2` exists.
    *   We have found the solution. We return the index of the complement from the map, which is `num_to_index_map[2]` (value `0`), and the `current_index` (`1`).
    *   The function returns `[0, 1]`. The loop terminates.

### 1. Problem Restatement and Approach Summary
Given an array `nums` and `target`, find and return the indices of exactly two distinct elements that sum to `target`. Use a single-pass hash map (dictionary) to store seen numbers and their indices: for each `num` at index `i`, check if `(target - num)` is in the map; if yes, return the indices; else, store `num` at `i`. (Brute-force alternative: O(n²) nested loops checking every pair.)

### 2. Time and Space Complexity Analysis
- **Time**: O(n), single pass through the array.
- **Space**: O(n), worst case stores all elements in the hash map.

### 3. Clean, Commented Python 3 Code
```python
from typing import List

def twoSum(nums: List[int], target: int) -> List[int]:
    """
    Finds two indices in nums that sum to target using a hash map.
    Assumes exactly one solution exists.
    """
    seen = {}  # Dictionary to store number -> index mappings
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]  # Found the pair
        seen[num] = i  # Store current num's index
    return []  # No solution (though problem guarantees one)
```

### 4. Walkthrough with Example
For `nums = [2,7,11,15]`, `target = 9`:
- i=0, num=2: complement=7 not in {}, store {2:0}
- i=1, num=7: complement=2 in {}, return [0,1]
Matches expected output `[0,1]`.