Here I present a recursive solution for NFA. Node = self.get_next_node(node, character)Īutomata = 'Initial node: %s Terminal node: %s ' % (self.initial_node.val, self.terminal_node.val) Return (om_node = om_node) and (self.etiquette = link.etiquette) and (self.to_node = link.to_node)ĭef _init_(self, initial_node, nodes, terminal_node):ĭef get_next_node(self, current_node, etiquette): Return '(%s -%s-> %s)' % (om_node.val, self.etiquette, self.to_node.val) Ok = ok and (self.links = node.links)ĭef _init_(self, from_node, etiquette, to_node): I was however ever so slightly inspired by John Coleman's answer. Here is my version of a dfa implementation if you're looking for a more object-oriented one. For example, the following DFA from the Wikipedia article on DFAsĬan be represented by a dictionary like this: dfa = ,'1011101')įor NFAs you could store sets of possible states rather than individual states in the transition dictionaries and use the random module to pick the next state from the set of possible states. For each state create a dictionary which is keyed by the letters of the alphabet and then a global dictionary which is keyed by the states. A straightforward way to represent a DFA is as a dictionary of dictionaries.

Sign up icq with email