2. Data Processing

---
title: Data Processing with Basic Patterns
---

# Problem Statement

Given a list of integers `data` and a string `operation`, implement the function `process_data(data: List[int], operation: str) -> Any`. The function should perform the following operations based on the input:

1. **Mapping**: If the operation is `"double"`, return a list where each element is doubled.
2. **Filtering**: If the operation is `"even"`, return a list containing only the even numbers.
3. **Aggregation**: If the operation is `"sum"`, return the sum of all elements.
4. **Sorting**: If the operation is `"sort"`, return the list sorted in ascending order.
5. **Grouping**: If the operation is `"group"`, return a dictionary where the keys are the elements, and the values are the counts of their occurrences.
6. **Uniques**: If the operation is `"unique"`, return a sorted list of unique elements.

**Examples**
```py3
process_data([1, 2, 3, 4, 5], "double") # [2, 4, 6, 8, 10]
process_data([1, 2, 3, 4, 5], "even")   # [2, 4]
process_data([1, 2, 3, 4, 5], "sum")    # 15
process_data([5, 3, 1, 4, 2], "sort")  # [1, 2, 3, 4, 5]
process_data([1, 1, 2, 3, 2], "group") # {1: 2, 2: 2, 3: 1}
process_data([1, 2, 3, 2, 1], "unique")# [1, 2, 3]
```

# Solution

```py3
def process_data(data: list[int], operation: str) -> any:
    """
    Perform basic data processing operations on a list of integers.

    Arguments:
    data: list[int] - The list of integers.
    operation: str - The operation to perform ("double", "even", "sum", "sort", "group", "unique").

    Returns:
    any - The result of the operation.
    """
    if operation == "double":
        return [x * 2 for x in data]
    elif operation == "even":
        return [x for x in data if x % 2 == 0]
    elif operation == "sum":
        return sum(data)
    elif operation == "sort":
        return sorted(data)
    elif operation == "group":
        from collections import Counter
        return dict(Counter(data))
    elif operation == "unique":
        return sorted(set(data))
    else:
        raise ValueError("Invalid operation")
```

# Public Test Cases

## Input 1
```
is_equal(
    process_data([1, 2, 3, 4, 5], "double"),
    [2, 4, 6, 8, 10]
)
```

## Output 1
```
True
```

## Input 2
```
is_equal(
    process_data([1, 2, 3, 4, 5], "even"),
    [2, 4]
)
```

## Output 2
```
True
```

## Input 3
```
is_equal(
    process_data([1, 2, 3, 4, 5], "sum"),
    15
)
```

## Output 3
```
True
```

## Input 4
```
is_equal(
    process_data([5, 3, 1, 4, 2], "sort"),
    [1, 2, 3, 4, 5]
)
```

## Output 4
```
True
```

# Private Test Cases

## Input 1
```
data = [3, 3, 2, 1, 1, 1]
operation = "group"
is_equal(
    process_data(data, operation),
    {3: 2, 2: 1, 1: 3}
)
```

## Output 1
```
True
```

## Input 2
```
data = [8, 5, 7, 3, 3, 5, 8]
operation = "unique"
is_equal(
    process_data(data, operation),
    [3, 5, 7, 8]
)
```

## Output 2
```
True
```

## Input 3
```
data = [6, 7, 8, 9]
operation = "even"
is_equal(
    process_data(data, operation),
    [6, 8]
)
```

## Output 3
```
True
```

# Notes
- The function should handle invalid operations by raising a `ValueError`.
- Input validation is not required for this problem.