he-014

# HumanEval/14

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 all_prefixes(string: str) -> List[str]:
    """ Return list of all prefixes from shortest to longest of the input string
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """
```

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

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

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


def check(candidate):
    assert candidate('') == []
    assert candidate('asdfgh') == ['a', 'as', 'asd', 'asdf', 'asdfg', 'asdfgh']
    assert candidate('WWW') == ['W', 'WW', 'WWW']


def test_he_014():
    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 all_prefixes(string: str) -> List[str]:
    """ Return list of all prefixes from shortest to longest of the input string
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """
    return [string[:i] for i in range(1, len(string) + 1)]
```

The user wants a Python function `all_prefixes(string: str) -> List[str]` that returns a list of all prefixes of the input string, ordered from shortest to longest.

Example: `all_prefixes('abc')` should return `['a', 'ab', 'abc']`.

Let's think about how to implement this.
A prefix of a string `s` of length `n` can be `s[0:i]` for `i` from 1 to `n`.
So we can use a list comprehension: `[string[:i] for i in range(1, len(string) + 1)]`.

Wait, what if the string is empty? The problem says "from shortest to longest". If `string` is `""`, `range(1, 1)` is empty, so it returns `[]`. That seems correct.

Let's test with `'abc'`:
`i=1` -> `'a'`
`i=2` -> `'ab'`
`i=3` -> `'abc'`
Result: `['a', 'ab', 'abc']`. Matches example.

Is there any edge case? Single character string `'a'` -> `['a']`. Correct.
The problem statement is straightforward.

I will write the solution in `solution.py`.

```python
from typing import List

def all_prefixes(string: str) -> List[str]:
    return [string[:i] for i in range(1, len(string) + 1)]
```

Check constraints or specific requirements: "Keep the given name and signature; your file must define it at module level."
The code matches.

One minor point: sometimes HumanEval problems expect exactly the docstring provided. I'll include it.

Let's verify the exact prompt:
```python
from typing import List


def all_prefixes(string: str) -> List[str]:
    """ Return list of all prefixes from shortest to longest of the input string
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """
```

I will output the complete code block.

Everything looks solid.
I will produce the solution.
No extra fluff.
Done. 
Let's double check logic.
`string[:i]` works correctly for strings.
`range(1, len(string) + 1)` covers lengths 1 to n.
List comprehension returns list of strings.
Type hints match.
Ready. 
Output matches request.✅
Proceeds. 
Output generation. 
```python
from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Return list of all prefixes from shortest to longest of the input string
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """
    return [string[:i] for i in range(1, len(string) + 1)]
```
All good. 
Self-Correction/Verification during thought: 
Could there be any issue with `string[:i]`? No.
Does it handle empty string? Returns `[]`, which is correct.
Does it handle spaces? `'a b'` -> `['a', 'a ', 'a b']`. Correct.
The problem is from HumanEval/14, which is exactly this.
I'm ready. 
Output matches. 
Proceeds. 
[Output Generation] -> *Proceeds*