Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Is it possible to rewrite the function below to use just a single regular expression to…

  1. User

    Is it possible to rewrite the function below to use just a single regular expression to extract the correct integers to be multiplied, also handling the "do()/don't()" enable/disable in the regex patter itself? I want to remove the loop and match statement, and instead just run sum(map(lambda m: int(m[0]) * int(m[1]), matches)) after matching to get the final result.

    I am guessing this might be possible with lookahead/lookbehind, but not sure. Something like "capture mul ints if preceded by do() + any random characters not including don't()", might have to append a "do()" at the beginning to get it started.

    import re
    
    def solve() -> int:
        memory = r"xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))"
        matches = re.findall(r"mul\((\d{1,3}),(\d{1,3})\)|(do\(\)|don't\(\))", memory)
        mul_enabled = True  # At the beginning of the program, mul instructions are enabled
        result = 0
        for m in matches:
            match m:
                case (x, y, "") if mul_enabled:
                    result += int(x) * int(y)
                case (*_, "do()"):
                    mul_enabled = True
                case (*_, "don't()"):
                    mul_enabled = False
        return result
    

    Further information which may be useful (we are interested in part 2): "Our computers are having issues, so I have no idea if we have any Chief Historians in stock! You're welcome to check the warehouse, though," says the mildly flustered shopkeeper at the North Pole Toboggan Rental Shop. The Historians head out to take a look.

    The shopkeeper turns to you. "Any chance you can see why our computers are having issues again?"

    The computer appears to be trying to run a program, but its memory (your puzzle input) is corrupted. All of the instructions have been jumbled up!

    It seems like the goal of the program is just to multiply some numbers. It does that with instructions like mul(X,Y), where X and Y are each 1-3 digit numbers. For instance, mul(44,46) multiplies 44 by 46 to get a result of 2024. Similarly, mul(123,4) would multiply 123 by 4.

    However, because the program's memory has been corrupted, there are also many invalid characters that should be ignored, even if they look like part of a mul instruction. Sequences like mul(4*, mul(6,9!, ?(12,34), or mul ( 2 , 4 ) do nothing.

    For example, consider the following section of corrupted memory:

    xmul(2,4)%&mul[3,7]!@^do_not_mul(5,5)+mul(32,64]then(mul(11,8)mul(8,5)) Only the four highlighted sections are real mul instructions. Adding up the result of each instruction produces 161 (24 + 55 + 118 + 85).

    Scan the corrupted memory for uncorrupted mul instructions. What do you get if you add up all of the results of the multiplications?

    --- Part Two --- As you scan through the corrupted memory, you notice that some of the conditional statements are also still intact. If you handle some of the uncorrupted conditional statements in the program, you might be able to get an even more accurate result.

    There are two new instructions you'll need to handle:

    The do() instruction enables future mul instructions. The don't() instruction disables future mul instructions. Only the most recent do() or don't() instruction applies. At the beginning of the program, mul instructions are enabled.

    For example:

    xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5)) This corrupted memory is similar to the example from before, but this time the mul(5,5) and mul(11,8) instructions are disabled because there is a don't() instruction before them. The other mul instructions function normally, including the one at the end that gets re-enabled by a do() instruction.

    This time, the sum of the results is 48 (24 + 85).

    Handle the new instructions; what do you get if you add up all of the results of just the enabled multiplications?

  2. Assistant

    No, it is not practical to rewrite the function to use just a single regular expression to handle the do()/don't() enable/disable logic and extract the correct integers to be multiplied. Regular expressions are powerful for pattern matching but are limited in their ability to maintain and manipulate state across multiple matches.

    The main issue is that to correctly identify which mul(x,y) instructions are enabled, we need to keep track of the state changes caused by do() and don't() instructions as we parse the string. Regular expressions cannot maintain such stateful context because they are fundamentally designed to match patterns without memory of previous matches or state changes.

    While advanced regular expression features like lookahead and lookbehind assertions can provide some context, they are not sufficient to handle the state transitions required in this problem. Specifically, we would need to know whether the last occurring do() or don't() before each mul(x,y) is a do(), and regular expressions cannot back-reference matches in the way needed to establish this stateful relationship.

    Therefore, the most effective approach is to iterate over the matches as you've done in your current function, updating the mul_enabled flag based on the occurrences of do() and don't(), and summing the results of the enabled mul(x,y) instructions.

    Here's the function unchanged, as it correctly handles the logic:

    import re
    
    def solve() -> int:
        memory = r"xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))"
        matches = re.findall(r"mul\((\d{1,3}),(\d{1,3})\)|(do\(\)|don't\(\))", memory)
        mul_enabled = True  # At the beginning of the program, mul instructions are enabled
        result = 0
        for m in matches:
            match m:
                case (x, y, "") if mul_enabled:
                    result += int(x) * int(y)
                case (*_, "do()"):
                    mul_enabled = True
                case (*_, "don't()"):
                    mul_enabled = False
        return result
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.