he-012

# HumanEval/12

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, Optional


def longest(strings: List[str]) -> Optional[str]:
    """ Out of list of strings, return the longest one. Return the first one in case of multiple
    strings of the same length. Return None in case the input list is empty.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """
```

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

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

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


def check(candidate):
    assert candidate([]) == None
    assert candidate(['x', 'y', 'z']) == 'x'
    assert candidate(['x', 'yyy', 'zzzz', 'www', 'kkkk', 'abc']) == 'zzzz'


def test_he_012():
    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, Optional


def longest(strings: List[str]) -> Optional[str]:
    """ Out of list of strings, return the longest one. Return the first one in case of multiple
    strings of the same length. Return None in case the input list is empty.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """
    if not strings:
        return None
    
    return max(strings, key=len)
```

The task is to implement a function `longest` that takes a list of strings and returns the longest string. If there are multiple strings of the same maximum length, it should return the first one. If the list is empty, it should return `None`.

Let me trace through the examples:
1. `longest([])` should return `None` (empty list)
2. `longest(['a', 'b', 'c'])` should return `'a'` (all have length 1, return first)
3. `longest(['a', 'bb', 'ccc'])` should return `'ccc'` (lengths are 1, 2, 3, so 'ccc' is longest)

The implementation should:
1. Check if the list is empty, return `None` if so
2. Find the maximum length among all strings
3. Return the first string that has that maximum length

Here's my approach:
```python
def longest(strings: List[str]) -> Optional[str]:
    if not strings:
        return None
    
    max_len = max(len(s) for s in strings)
    for s in strings:
        if len(s) == max_len:
            return s
```

Or more concisely:
```python
def longest(strings: List[str]) -> Optional[str]:
    if not strings:
        return None
    
    return max(strings, key=len)
```

The `max()` function with `key=len` will return the first element with the maximum length, which is exactly what we need.

Let me verify with the examples:
1. `longest([])` - empty list, returns `None` ✓
2. `longest(['a', 'b', 'c'])` - all length 1, `max` returns first one 'a' ✓
3. `longest(['a', 'bb', 'ccc'])` - lengths 1, 2, 3, `max` returns 'ccc' ✓

This solution is clean and correct.