左线性文法转化为有限自动机的代码

以下是将左线性文法转化为有限自动机的 Python 代码：

class LeftLinearGrammar:
    def __init__(self, productions, start_symbol):
        self.productions = productions
        self.start_symbol = start_symbol
        
    def to_finite_automaton(self):
        states = set()
        alphabet = set()
        transitions = {}
        start_state = self.start_symbol + "_0"
        final_states = set()
        
        # Create states for each non-terminal symbol
        for prod in self.productions:
            states.add(prod[0])
        
        # Create states for each production and add transitions
        for i, prod in enumerate(self.productions):
            prod_state = prod[0] + "_" + str(i)
            if i == 0:
                transitions[(start_state, prod[1][0])] = [prod_state]
            else:
                transitions[(prev_prod_state, prod[1][0])] = [prod_state]
                
            # Add transitions for the rest of the symbols
            for j in range(1, len(prod[1])):
                curr_state = prod[0] + "_" + str(i) 
                next_state = prod[0] + "_" + str(i+1) if j == len(prod[1])-1 else prod[0] + "_" + str(i) + "_" + str(j)
                transitions[(curr_state, prod[1][j])] = [next_state]
                states.add(curr_state)
                states.add(next_state)
                alphabet.add(prod[1][j])
                prev_prod_state = prod_state
                prod_state = next_state
            
            # Add final state to the final set
            if prod[1] == "":
                final_states.add(prod_state)
        
        # Add start state to the set of states
        states.add(start_state)
        
        return FiniteAutomaton(states, alphabet, transitions, start_state, final_states)

该代码中使用了一个 `LeftLinearGrammar` 类来表示左线性文法，并提供了一个 `to_finite_automaton()` 方法，该方法将左线性文法转换为等价的有限自动机。

具体来说，该方法会遍历每个产生式，并为每个非终端符号和每个产生式创建一个状态。然后，它会根据产生式的规则添加转移。最后，它会返回一个 `FiniteAutomaton` 类型的对象，该对象包含有限自动机的所有组件。