he-005

# HumanEval/5

Implement a file **`solution.py`** that completes the function below. Keep the given name and signature; your file must define it at module level.

```python
from typing import List


def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """
```

<!-- imported from OpenAI HumanEval (HumanEval/5) -->

# Auto-generated from OpenAI HumanEval HumanEval/5. Do not edit by hand.
from solution import *  # noqa: F401,F403 (prompt helpers may be referenced by tests)
from solution import intersperse as candidate

METADATA = {
    'author': 'jt',
    'dataset': 'test'
}


def check(candidate):
    assert candidate([], 7) == []
    assert candidate([5, 6, 3, 2], 8) == [5, 8, 6, 8, 3, 8, 2]
    assert candidate([2, 2, 2], 2) == [2, 2, 2, 2, 2]


def test_he_005():
    check(candidate)

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```python
from typing import List


def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """
    if not numbers:
        return []
    
    result = []
    for i, num in enumerate(numbers):
        result.append(num)
        if i < len(numbers) - 1:
            result.append(delimeter)
    
    return result
```

The task is to implement a function `intersperse` that takes a list of integers and a delimiter integer, and inserts the delimiter between every two consecutive elements of the input list.

Let me trace through the examples:
- `intersperse([], 4)` should return `[]` (empty list stays empty)
- `intersperse([1, 2, 3], 4)` should return `[1, 4, 2, 4, 3]`

So the pattern is: for each element except the last, append the element, then append the delimiter, then continue. Or alternatively, we can iterate through the list and add the delimiter after each element except the last one.

Here's my approach:
1. If the list is empty, return an empty list
2. Otherwise, iterate through the list and add each element
3. After each element (except the last one), add the delimiter

Let me write the code:

```python
from typing import List


def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """
    if not numbers:
        return []
    
    result = []
    for i, num in enumerate(numbers):
        result.append(num)
        if i < len(numbers) - 1:
            result.append(delimeter)
    
    return result
```

This should work correctly. Let me verify:
- `intersperse([], 4)`: returns `[]` ✓
- `intersperse([1, 2, 3], 4)`: 
  - i=0, num=1: append 1, i < 2 so append 4 → [1, 4]
  - i=1, num=2: append 2, i < 2 so append 4 → [1, 4, 2, 4]
  - i=2, num=3: append 3, i is not < 2 so don't append → [1, 4, 2, 4, 3] ✓

The implementation handles both edge cases correctly and produces the expected output.