he-017

# HumanEval/17

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 parse_music(music_string: str) -> List[int]:
    """ Input to this function is a string representing musical notes in a special ASCII format.
    Your task is to parse this string and return list of integers corresponding to how many beats does each
    not last.

    Here is a legend:
    'o' - whole note, lasts four beats
    'o|' - half note, lasts two beats
    '.|' - quater note, lasts one beat

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """
```

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

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

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


def check(candidate):
    assert candidate('') == []
    assert candidate('o o o o') == [4, 4, 4, 4]
    assert candidate('.| .| .| .|') == [1, 1, 1, 1]
    assert candidate('o| o| .| .| o o o o') == [2, 2, 1, 1, 4, 4, 4, 4]
    assert candidate('o| .| o| .| o o| o o|') == [2, 1, 2, 1, 4, 2, 4, 2]


def test_he_017():
    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 parse_music(music_string: str) -> List[int]:
    mapping = {'o': 4, 'o|': 2, '.|': 1}
    return [mapping[note] for note in music_string.split()]
```

The user wants me to implement a function `parse_music` that takes a string of musical notes in a special ASCII format and returns a list of integers representing the duration of each note in beats.

The legend is:
- 'o' -> 4 beats
- 'o|' -> 2 beats
- '.|' -> 1 beat

The input string contains these notes separated by spaces.
Example: `'o o| .| o| o| .| .| .| .| o o'`
Output: `[4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]`

I need to split the string by spaces, then map each token to its corresponding beat value.

Let's write a simple mapping:
```python
mapping = {
    'o': 4,
    'o|': 2,
    '.|': 1
}
```

Then split the string and map:
```python
return [mapping[note] for note in music_string.split()]
```

Wait, what if the string is empty? `music_string.split()` returns `[]`, and the list comprehension returns `[]`, which is correct.

Let's test with the example:
`'o o| .| o| o| .| .| .| .| o o'.split()` -> `['o', 'o|', '.|', 'o|', 'o|', '.|', '.|', '.|', '.|', 'o', 'o']`
Mapping gives `[4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]`. Matches example.

Is there any edge case? The problem statement says "Input to this function is a string representing musical notes in a special ASCII format." It implies valid input.
The function signature is given.

I will implement it exactly as described.

Code structure:
```python
from typing import List

def parse_music(music_string: str) -> List[int]:
    mapping = {'o': 4, 'o|': 2, '.|': 1}
    return [mapping[note] for note in music_string.split()]
```

Wait, should I handle cases where `music_string` might be empty or contain only spaces? `split()` handles multiple spaces and empty strings correctly by returning an empty list.

Let's double check the exact prompt.
"Keep the given name and signature; your file must define it at module level."

The code looks solid.

One minor point: sometimes in these problems, the input might not have spaces? But the example has spaces. The problem says "separated by spaces" implicitly by the example. `split()` is safe.

I'll produce the solution.
No extra fluff.
Ready. 
Let's verify one more time.
`'o'` -> 4
`'o|'` -> 2
`'.|'` -> 1
All match.
The function name is `parse_music`.
Type hints are `List[int]`.
Imports: `from typing import List` is already in the prompt, but I'll include it in the solution file as requested.

Final code:
```python
from typing import List

def parse_music(music_string: str) -> List[int]:
    mapping = {'o': 4, 'o|': 2, '.|': 1}
    return [mapping[note] for note in music_string.split()]
```

That's it.
I will output this inside a code block.
Check if any other considerations: The problem is from HumanEval/17. The standard solution is exactly this.
All good. 
Proceeding. 
Output matches request.
Done. 
Self-Correction/Verification during thought: 
Could there be trailing/leading spaces? `split()` handles them.
Could the input be `""`? `split()` returns `[]`, returns `[]`. Correct.
Is `typing.List` needed? The prompt includes it, I'll keep it.
Everything is fine.
Output matches. 
Proceeds. 
[Output Generation] -> code block. 
Done. 
```python
from typing import List

def parse_music(music_string: str) -> List[int]:
    mapping = {'o': 4, 'o|': 2, '.|': 1}
    return [mapping[note] for note in music_string.split()]
```
Matches exactly.
Done. 
I will produce the response now. 
All steps verified. No extra text. Fenced code block. Correct filename `solution.py` implied by prompt but I'll just give the code. The prompt says "Implement a file **`solution.py`** that completes the function below." I will provide the full code for `solution.py`.
Done. 
Output Generation. 
[Done]