# Problem Description
This appears to be an array processing problem where we need to transform an input array L into a new array based on certain grouping and length value rules. The function takes a list of integers and returns a new list containing length values based on specific partitioning patterns.

# Visual Facts
1. Two examples are shown in the image:
   - Example 1: Input array [0,0,4,12,7,0,5,0,2,9,0,...]
   - Example 2: Input array [0,0,1,5,0,0,4,3,0,...]

2. The output arrays are shown:
   - Example 1 output: [3,1,2,...]
   - Example 2 output: [2,2,...]

3. Blue brackets in the image indicate grouping of numbers
   - Groups are marked with "len" labels
   - Multiple numbers are grouped together
   - Groups appear to be separated by zeros

# Visual Patterns
1. Grouping Pattern:
   - Numbers are grouped between zeros
   - Consecutive non-zero numbers form a group
   - Zeros act as separators/delimiters
   
2. Calculation Pattern:
   - For each group, return the length value of that group
   - The length values are collected in order of appearance
   
3. Processing Rules:
   - Multiple consecutive zeros are treated as a single separator
   - Each group must contain at least one non-zero number
   - The output array contains only the length values from each group
   - The order of length values in the output preserves the original sequence


# Solution
from typing import List

def solution(L: List[int]) -> List[int]:
    """
    Processes the input array according to a specific pattern.

    Parameters:
        L (List[int]): The source array to be processed       

    Returns:
        List[int]: The processed array
    """
    result = []
    temp = []
    
    for num in L:
        if num != 0:
            temp.append(num)
        else:
            if temp:
                result.append(len(temp))
                temp = []
    
    if temp:
        result.append(len(temp))
    
    return result


# Test Script
def test():
    test_cases = [
        ([0, 0, 4, 12, 7, 0, 5, 0, 2, 9, 0], [3, 1, 2]),
        ([2, 0, 1, 5, 0, 0, 5, 0, 4, 0, 0], [1, 2, 1, 1]),
        ([0, 0, 0, 0, 0], []),
        ([1], [1]),
        ([0, 1, 2, 0, 0, 1, 1, 2], [2, 3]),
        ([1, 0, 1, 0, 0, 9, 1, 2, 0, 0, 0, 2], [1, 1, 3, 1]),
        ([1, 100, 0, 0, 101, 12, 131, 0, 0], [2, 3]),
        ([0, 0, 0, 1, 1, 0, 0, 88, 12, 0], [2, 2]),
        ([0, 2, 1, 1, 6, 0, 0, 0, 1, 1, 2, 2], [4, 4]),
        ([4, 4, 3, 3, 6], [5])
    ]

    for L, expected_output in test_cases:
        try:
            output = solution(L)
        except Exception as e:
            error_message = (
                f"An exception occurred while running the test case:\n"
                f"`L`: {L}\n\n"
                f"Exception: '{str(e)}'"
            )
            assert False, error_message
            
        if output != expected_output:
            error_message = (
                f"The following Test Case failed:\n"
                f"`L`: {L}\n\n"
                f"Actual Output: {output}\n"
                f"Expected Output: {expected_output}"
            )
            assert False, error_message

test()