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'
    """
    return max(strings, key=len, default=None)
```

The user wants me to implement a function `longest` that:
1. Takes a list of strings
2. Returns the longest string
3. If there are multiple strings with the same longest length, return the first one
4. Return None if the list is empty

This is straightforward. I can use Python's built-in `max` function with a key, or iterate manually.

Using `max` with `default=None` handles the empty list case:
```python
def longest(strings: List[str]) -> Optional[str]:
    if not strings:
        return None
    return max(strings, key=len)
```

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

The `max` function with `default` parameter will return `None` if the iterable is empty, and `max` is stable in the sense that it returns the first maximum element encountered when there are ties (actually, Python's `max` returns the first one it encounters with the maximum value).

Let me verify: `max(['a', 'b', 'c'], key=len)` - all have length 1, so it should return 'a' (the first one). Yes, that's correct.

Let me write the solution.