Peephole Optimization for Simple Arithmetic Expressions

Peephole optimization is a simple yet effective technique in compiler design where the compiler analyzes a small "window" (the peephole) of instructions and replaces them with a more efficient sequence. This challenge asks you to implement a basic peephole optimizer for a simplified arithmetic expression language. The goal is to identify and replace common, inefficient instruction sequences with more optimized equivalents.

Problem Description

You are tasked with implementing a peephole optimizer for a sequence of arithmetic instructions. The instructions are represented as strings, and the optimizer should identify and replace specific patterns with more efficient alternatives. The supported instructions are:

ADD x y: Adds the values of variables x and y and stores the result in x.
SUB x y: Subtracts the value of y from x and stores the result in x.
MUL x y: Multiplies the values of x and y and stores the result in x.
MOV x y: Copies the value of y to x.

The peephole optimizer should focus on the following two patterns:

MOV x y; ADD x z: This can be optimized to ADD y z (where x is overwritten).
MOV x y; SUB x z: This can be optimized to SUB y z (where x is overwritten).

The optimizer should take a slice of strings representing the instruction sequence as input and return a new slice of strings with the optimized instructions. The order of instructions not matching the patterns should remain unchanged. Variable names are assumed to be single characters.

Key Requirements:

The optimizer must correctly identify and replace the specified patterns.
The optimizer should not modify instructions that do not match the patterns.
The optimizer should preserve the order of instructions that are not part of a pattern.
The optimizer should handle cases where the input slice is empty or contains only one instruction.

Expected Behavior:

The function should return a new slice of strings representing the optimized instruction sequence. The original slice should not be modified.

Edge Cases to Consider:

Empty input slice.
Input slice with only one instruction.
Patterns appearing consecutively.
Variable names that are not single characters (assume single character for this challenge).
Instructions other than the supported ones.

Examples

Example 1:

Input: ["MOV a b", "ADD a c"]
Output: ["ADD b c"]
Explanation: The "MOV a b; ADD a c" pattern is recognized and replaced with "ADD b c".

Example 2:

Input: ["MOV a b", "SUB a c"]
Output: ["SUB b c"]
Explanation: The "MOV a b; SUB a c" pattern is recognized and replaced with "SUB b c".

Example 3:

Input: ["ADD a b", "MUL a c", "MOV a d", "ADD a e"]
Output: ["ADD a b", "MUL a c", "ADD d e"]
Explanation: Only the "MOV a d; ADD a e" pattern is recognized and replaced.

Example 4:

Input: ["MOV a b", "ADD a c", "MOV a d", "SUB a e"]
Output: ["ADD b c", "ADD d e"]
Explanation: Two patterns are recognized and replaced sequentially.

Example 5:

Input: []
Output: []
Explanation: Empty input, empty output.

Example 6:

Input: ["ADD a b"]
Output: ["ADD a b"]
Explanation: No patterns to optimize.

Constraints

The input slice will contain strings representing valid instructions (as defined above).
Variable names will be single characters (a-z).
The length of the input slice will be between 0 and 100 (inclusive).
The performance of the optimizer should be reasonable for the given input size. Avoid excessively complex algorithms.

Notes

Consider using string manipulation techniques to parse and compare instructions.
Think about how to efficiently iterate through the instruction sequence and identify patterns.
The optimizer should be stateless; it should not maintain any internal state between calls.
Focus on the two specified patterns for this challenge. More complex optimizations are not required.
The returned slice should contain only the optimized instructions, not the original instructions that were replaced.
Error handling for invalid instructions is not required; assume the input is always valid.