# Problem Description
The problem involves transforming an array of integers over a series of time steps, T. At each time step, the array undergoes a specific transformation where certain elements are removed. The goal is to determine the state of the array at a given time point, T.

# Visual Facts
1. **Initial State (T=0)**:
   - Example 1: `[3, -1, 0, 2, -9, -7]`
   - Example 2: `[3, -4, -2, 4, -6, -5, 3, -2]`

2. **Transformation Steps**:
   - At each time step, the array is transformed by removing elements.
   - Example 1:
     - T=1: `[3, -1, -9, -7]` (elements `0` and `2` removed)
     - T=2: `[3, -7]` (elements `-1` and `-9` removed)
     - T=3: `[]` (elements `3` and `-7` removed)
   - Example 2:
     - T=1: `[3, -4, -2, -5, 3, -2]` (elements `4` and `-6` removed)
     - T=2: `[3, -4, 3, -2]` (elements `-2` and `-5` removed)
     - T=3: `[3, -2]` (elements `-4` and `3` removed)
     - T=4: `[]` (elements `3` and `-2` removed)

3. **Time Steps**:
   - The transformation continues until the array is empty.
   - The number of elements removed at each step appears to be two.

# Visual Patterns
1. **Element Removal**:
   - At each time step, two elements are removed from the array.
   - The elements removed are from the center of the array.
   - If the array has an even number of elements, the two central elements are removed. N//2 and N//2-1

2. **Termination**:
   - The process continues until the array becomes empty.
   - The number of time steps required to empty the array depends on the initial length of the array.

3. **Array Length**:
   - The length of the array decreases by 2 at each time step.

# Solution
from typing import List

def solution(nums: List[int], T: int) -> List[int]:
    """
    Returns the array at a specified time point T.

    Parameters:
        nums (List[int]): The initial array of integers        
        T (int): The target time point

    Returns:
        List[int]: The array at time T
    """
    new_nums = [_ for _ in nums]
    for _ in range(T):
        new_nums.pop(len(new_nums)//2)
        new_nums.pop(len(new_nums)//2)
    return new_nums


# Test Script
def test():
    test_cases = [
        ([3,-1, 0, 2, -9, -7], 1, [3,-1, -9, -7]),
        ([3, -4, -2, 4, -6, -5, 3, -2], 2, [3, -4, 3, -2]),
        ([3, -4, -2, 4, -6, -5, 3, -2], 3, [3, -2]),
        ([3,-4,-2,4,-6,-5,3,-2,7, 8], 1, [3, -4, -2, 4, 3, -2, 7, 8]),
        ([3,-4,-2,4,-6,-5,3,-2,7, 8], 2,[3, -4, -2, -2, 7, 8]),
        ([59,65,21,87,37,99],2,[59,99]),
        ([136, 839, 614, 172, 834, 661, 751, 474, 352, 161], 4, [136, 161]),
        ([125, 132, 147, 725, 597, 492, 258, 11], 3, [125, 11]),
        ([103, 706, 283, 830, 358, 528, 67, 587, 940,100], 1, [103, 706, 283, 830, 67, 587, 940, 100]),
        ([821, 287, 970, 212], 1,[821, 212]),
    ]
    def equal_arr(arr1, arr2):
        return arr1 == arr2

    for nums, T, expected_output in test_cases:
        try:
            nums_copy = nums.copy()
            output = solution(nums_copy, T)
        except Exception as e:
            error_message = (
                f"An exception occurred while running the test case:\n"
                f"`nums`: {nums}\n"
                f"`T`: {T}\n\n"
                f"Exception: '{str(e)}'"
            )
            assert False, error_message

        if not equal_arr(output, expected_output):
            error_message = (
                f"The following Test Case failed:\n"
                f"`nums`: {nums}\n"
                f"`T`: {T}\n\n"
                f"Actual Output: {output}\n"
                f"Expected Output: {expected_output}"
            )
            assert False, error_message

test()