如何替换数组中的元素？特定格式数组替换规则咨询

Alright, let's work through this array transformation problem. I'll start by clarifying the requirements as I understand them, then share a practical implementation and walk through how it works.

Clarified Requirements #

First, let's align on exactly what needs to happen with your array:

• When traversing the array, if we hit an element that starts with ( but doesn't end with ) (like '(DATE*'):
  • Extract the core tag from this element (e.g., DATE from '(DATE*')
  • Replace all subsequent elements with this tag until we encounter '*)'
  • Replace that final '*)' element with the same core tag
• For elements fully wrapped in () (like '(DATE)'), strip the parentheses to get the core content (e.g., DATE)
• Regular '*' elements stay as-is unless they fall within a replacement range

Python Implementation #

Here's a clean, commented implementation tailored to your input array:

def transform_array(arr):
    result = []
    in_replace_mode = False
    current_tag = ""
    
    for item in arr:
        if not in_replace_mode:
            # Detect start of a replacement block: e.g., '(DATE*'
            if item.startswith('(') and not item.endswith(')'):
                # Extract tag by stripping leading '(' and trailing '*'
                current_tag = item[1:-1]
                result.append(current_tag)
                in_replace_mode = True
            # Detect fully enclosed parenthetical element: e.g., '(DATE)'
            elif item.startswith('(') and item.endswith(')'):
                result.append(item[1:-1])
            # Add regular elements (like '*') as-is
            else:
                result.append(item)
        else:
            # We're in replacement mode until we hit '*)'
            if item == '*)':
                result.append(current_tag)
                in_replace_mode = False
                current_tag = ""
            else:
                # Replace all intermediate '*' with the active tag
                result.append(current_tag)
    
    return result

# Your input array
key = ['*', '(DATE*', '*', '*', '*)', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '(GPE*', '*)', '*', '*', '*', '(DATE)', '*']

# Generate and print the transformed array
transformed_key = transform_array(key)
print(transformed_key)

Output Result #

Running the code above will produce this transformed array:

['*', 'DATE', 'DATE', 'DATE', 'DATE', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', 'GPE', 'GPE', '*', '*', '*', 'DATE', '*']

Key Logic Breakdown #

• State Tracking: We use in_replace_mode to track if we're in the middle of replacing elements, and current_tag to store the active tag for replacements.
• Tag Extraction: For partial parenthetical elements like '(DATE*', we slice the string to remove the leading ( and trailing *. For fully enclosed elements like '(DATE)', we just remove the outer parentheses.
• Replacement Handling: Once in replacement mode, every element (until '*)') gets swapped with the active tag. The '*)' itself also becomes the tag, and we exit replacement mode.

Edge Case Note #

This implementation assumes no nested parentheses or overlapping replacement blocks. If your use case requires handling those, we'd need to adjust to stack-based tracking, but this works perfectly for the array you provided.

内容的提问来源于stack exchange，提问作者Harsh2093