I’m implementing a function apply_pattern_to_list() that applies a pattern to a list and removes inconsistent elements. However, I’m encountering issues with unexpected output and an IndexError. Here’s my current implementation:

def apply_pattern_to_list(L, pattern='+-', from_start=True):
    def is_consistent(a, b, p):
        return (p == '+' and a < b) or (p == '-' and a > b)

    result = {}
    pattern = pattern * (len(L) // len(pattern) + 1) 
    
    if from_start:
        i = 0
        while i < len(L) - 1:
            if not is_consistent(L[i], L[i+1], pattern[i % len(pattern)]):
                result[i+1] = L.pop(i+1)
            else:
                i += 1
    else:
        i = len(L) - 1
        while i > 0:
            if not is_consistent(L[i-1], L[i], pattern[(len(L)-i) % len(pattern)]):
                result[i-len(L)] = L.pop(i-1)
            else:
                i -= 1
    
    return result

Expected behavior

The function should remove elements that are inconsistent with the given pattern, either from the start or end of the list, and return a dictionary of removed elements with their positions.

Current issues

The output doesn’t match the expected result. An IndexError occurs in some cases, particularly when from_start=False.

Questions

• What modifications are needed to correct the output and match the expected behavior?

• How can I resolve the IndexError, especially for the from_start=False case?

• Are there any logical errors in my implementation of the pattern application?

Additional information

The function should work with various patterns and list inputs, as shown in the test cases.

Test cases:

# Test Case 1
L = []
assert apply_pattern_to_list(L) == {}, f"Test Case 1 Failed. Expected: {{}}, Got: {apply_pattern_to_list(L)}"

# Test Case 2
L = [1]
assert apply_pattern_to_list(L) == {}, f"Test Case 2 Failed. Expected: {{}}, Got: {apply_pattern_to_list(L)}"
assert L == [1], f"Test Case 2 Failed. Expected list: [1], Got: {L}"

# Test Case 3
L = [1, 2, 1, 2, 1, 2, 3]
assert apply_pattern_to_list(L) == {6: 3}, f"Test Case 3 Failed. Expected: {{6: 3}}, Got: {apply_pattern_to_list(L)}"
assert L == [1, 2, 1, 2, 1, 2], f"Test Case 3 Failed. Expected list: [1, 2, 1, 2, 1, 2], Got: {L}"

# Test Case 4
L = [1, 2, 1, 2, 1, 2, 3]
assert apply_pattern_to_list(L, from_start=False) == {-3: 1, -4: 2, -5: 1, -6: 2, -7: 1}, f"Test Case 4 Failed. Expected: {{-3: 1, -4: 2, -5: 1, -6: 2, -7: 1}}, Got: {apply_pattern_to_list(L, from_start=False)}"
assert L == [2, 3], f"Test Case 4 Failed. Expected list: [2, 3], Got: {L}"

# Test Case 5
L = [1, 3, 2, 0, 0, -2, -2, 1, 5, -4]
assert apply_pattern_to_list(L, '++-') == {2: 2, 3: 0, 4: 0, 5: -2, 6: -2, 7: 1}, f"Test Case 5 Failed. Expected: {{2: 2, 3: 0, 4: 0, 5: -2, 6: -2, 7: 1}}, Got: {apply_pattern_to_list(L, '++-')}"
assert L == [1, 3, 5, -4], f"Test Case 5 Failed. Expected list: [1, 3, 5, -4], Got: {L}"

# Test Case 6
L = [1, 3, 2, 0, 0, -2, -2, 1, 5, -4]
assert apply_pattern_to_list(L, '++-', False) == {-2: 5, -3: 1, -4: -2, -5: -2, -6: 0, -7: 0, -8: 2, -9: 3, -10: 1}, f"Test Case 6 Failed. Expected: {{-2: 5, -3: 1, -4: -2, -5: -2, -6: 0, -7: 0, -8: 2, -9: 3, -10: 1}}, Got: {apply_pattern_to_list(L, '++-', False)}"
assert L == [-4], f"Test Case 6 Failed. Expected list: [-4], Got: {L}"

# Test Case 7
L = [-11, -2, -3, 11, -11, -12, 12, -7, 14, -5, 15, -1, 11, -10, 11]
assert apply_pattern_to_list(L, '---+') == {1: -2, 2: -3, 3: 11, 4: -11, 6: 12, 7: -7, 8: 14, 9: -5, 10: 15, 11: -1}, f"Test Case 7 Failed. Expected: {{1: -2, 2: -3, 3: 11, 4: -11, 6: 12, 7: -7, 8: 14, 9: -5, 10: 15, 11: -1}}, Got: {apply_pattern_to_list(L, '---+')}"
assert L == [-11, -12], f"Test Case 7 Failed. Expected list: [-11, -12], Got: {L}"

# Test Case 8
L = [-11, -2, -3, 11, -11, -12, 12, -7, 14, -5, 15, -1, 11, -10, 11]
assert apply_pattern_to_list(L, '---+', False) == {-2: -10, -3: 11, -4: -1, -7: 14, -9: 12, -12: 11, -13: -3, -14: -2, -15: -11}, f"Test Case 8 Failed. Expected: {{-2: -10, -3: 11, -4: -1, -7: 14, -9: 12, -12: 11, -13: -3, -14: -2, -15: -11}}, Got: {apply_pattern_to_list(L, '---+', False)}"
assert L == [-11, -12, -7, -5, 15, 11], f"Test Case 8 Failed. Expected list: [-11, -12, -7, -5, 15, 11], Got: {L}"

• Expected along with my output