bcb-0002

# BigCodeBench/2

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

Allowed libraries: `statistics`, `random`.

```python
import random
import statistics

def task_func(LETTERS):
    """
    Create a dictionary in which keys are random letters and values are lists of random integers.
    The dictionary is then sorted by the mean of the values in descending order, demonstrating the use of the statistics library.
    
    Parameters:
        LETTERS (list of str): A list of characters used as keys for the dictionary.
    
    Returns:
    dict: The sorted dictionary with letters as keys and lists of integers as values, sorted by their mean values.
    
    Requirements:
    - random
    - statistics
    
    Example:
    >>> import random
    >>> random.seed(42)
    >>> sorted_dict = task_func(['a', 'b', 'c'])
    >>> list(sorted_dict.keys())
    ['a', 'b', 'c']
    >>> isinstance(sorted_dict['a'], list)
    True
    >>> type(sorted_dict['a'])  # Check type of values
    <class 'list'>
    """
```

<!-- imported from BigCodeBench (BigCodeBench/2) -->

# Auto-generated from BigCodeBench BigCodeBench/2. Do not edit by hand.
import pathlib as _pathlib
exec(_pathlib.Path(__file__).with_name("solution.py").read_text(), globals())

import unittest
class TestCases(unittest.TestCase):
    
    def setUp(self):
        # Setting up a common letters array and sorted dictionary for use in all tests
        self.letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
        self.sorted_dict = task_func(self.letters)
    def test_case_1(self):
        # Check if the function returns a dictionary
        self.assertIsInstance(self.sorted_dict, dict, "The function should return a dictionary.")
    def test_case_2(self):
        # Ensure all keys in the sorted dictionary are within the provided letters
        all_letters = all([key in self.letters for key in self.sorted_dict.keys()])
        self.assertTrue(all_letters, "All keys of the dictionary should be letters.")
        
    def test_case_3(self):
        # Ensure all values are lists of integers
        all_lists = all([isinstance(val, list) and all(isinstance(i, int) for i in val) for val in self.sorted_dict.values()])
        self.assertTrue(all_lists, "All values of the dictionary should be lists of integers.")
        
    def test_case_4(self):
        # Check if the dictionary is sorted by the mean values in descending order
        means = [statistics.mean(val) for val in self.sorted_dict.values()]
        self.assertTrue(all(means[i] >= means[i + 1] for i in range(len(means) - 1)), "The dictionary should be sorted in descending order based on the mean of its values.")
    
    def test_case_5(self):
        # Check if the dictionary includes all provided letters as keys
        self.assertEqual(set(self.sorted_dict.keys()), set(self.letters), "The dictionary should have all provided letters as keys.")

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
import random
import statistics

def task_func(LETTERS):
    """
    Create a dictionary in which keys are random letters and values are lists of random integers.
    The dictionary is then sorted by the mean of the values in descending order, demonstrating the use of the statistics library.
    
    Parameters:
        LETTERS (list of str): A list of characters used as keys for the dictionary.
    
    Returns:
    dict: The sorted dictionary with letters as keys and lists of integers as values, sorted by their mean values.
    
    Requirements:
    - random
    - statistics
    
    Example:
    >>> import random
    >>> random.seed(42)
    >>> sorted_dict = task_func(['a', 'b', 'c'])
    >>> list(sorted_dict.keys())
    ['a', 'b', 'c']
    >>> isinstance(sorted_dict['a'], list)
    True
    >>> type(sorted_dict['a'])  # Check type of values
    <class 'list'>
    """
    # Create a dictionary with random letters as keys and lists of random integers as values
    result_dict = {}
    
    for letter in LETTERS:
        # Generate a random list of integers (between 1 and 10 elements, each between 1 and 100)
        random_list = [random.randint(1, 100) for _ in range(random.randint(1, 10))]
        result_dict[letter] = random_list
    
    # Sort the dictionary by the mean of the values in descending order
    sorted_items = sorted(result_dict.items(), key=lambda item: statistics.mean(item[1]), reverse=True)
    
    # Convert back to a dictionary (Python 3.7+ maintains insertion order)
    sorted_dict = dict(sorted_items)
    
    return sorted_dict
```