Added AhoCorasick - Python (#886)

* Create AhoCorasick.py * Update README.md * Update CONTRIBUTING.md * Update README.md Co-authored-by: Thuvarakan Tharmarajasingam <17289840+Thuva4@users.noreply.github.com>

Author: azhar1038

CONTRIBUTING.md

@@ -186,3 +186,4 @@ Unfortunately, sometimes the bug can be only reproduced in your project or in yo
 - [Esci92](https://github.com/Esci92)
 - [ir2010](https://github.com/ir2010)
 - [Cc618](https://github.com/Cc618)
+- [Md Azharuddin](https://github.com/azhar1038)

README.md

@@ -117,4 +117,4 @@ Folder structure should be like this
 
 ## License
 
-[Apache License 2.0](LICENSE)
+[Apache License 2.0](LICENSE)

algorithms/Python/AhoCorasick/AhoCorasick.py

@@ -0,0 +1,196 @@
+# Python program for implementation of
+# Aho-Corasick algorithm for string matching
+
+# defaultdict is used only for creating dictionary
+# which is the final output
+from collections import defaultdict
+
+# For simplicity, Arrays and Queues have been implemented using lists. 
+# If you want to improve performace try using them instead
+class AhoCorasick:
+ def __init__(self, words):
+
+ # Max number of states in the matching machine.
+ # Should be equal to the sum of the length of all keywords.
+ self.max_states = sum([len(word) for word in words])
+
+ # Maximum number of characters.
+ # Currently supports only alphabets [a,z]
+ self.max_characters = 26
+
+ # All the words in dictionary which will be used to create Trie
+ self.words = words
+
+ # OUTPUT FUNCTION IS IMPLEMENTED USING out []
+ # Bit i in this mask is one if the word with
+ # index i appears when the machine enters this state.
+ # Lets say, a state outputs two words "he" and "she" and
+ # in our provided words list, he has index 0 and she has index 3
+ # so value of out[state] for this state will be 1001
+ # It has been initialized to all 0.
+ # We have taken one extra state for the root.
+ self.out = [0]*(self.max_states+1)
+
+ # FAILURE FUNCTION IS IMPLEMENTED USING fail []
+ # There is one value for each state + 1 for the root
+ # It has been initialized to all -1
+ # This will contain the fail state value for each state
+ self.fail = [-1]*(self.max_states+1)
+
+ # GOTO FUNCTION (OR TRIE) IS IMPLEMENTED USING goto [[]]
+ # Number of rows = max_states + 1
+ # Number of columns = max_characters i.e 26 in our case
+ # It has been initialized to all -1.
+ self.goto = [[-1]*self.max_characters for _ in range(self.max_states+1)]
+
+ # Once the Trie has been built, it will contain the number
+ # of nodes in Trie which is total number of states required <= max_states
+ self.states_count = self.__build_matching_machine()
+
+
+ # Builds the String matching machine.
+ # Returns the number of states that the built machine has.
+ # States are numbered 0 up to the return value - 1, inclusive.
+ def __build_matching_machine(self):
+ k = len(self.words)
+
+ # Initially, we just have the 0 state
+ states = 1
+
+ # Convalues for goto function, i.e., fill goto
+ # This is same as building a Trie for words[]
+ for i in range(k):
+ word = self.words[i]
+ current_state = 0
+
+ # Process all the characters of the current word
+ for character in word:
+ ch = ord(character) - 97 # Ascii valaue of 'a' = 97
+
+ # Allocate a new node (create a new state)
+ # if a node for ch doesn't exist.
+ if self.goto[current_state][ch] == -1:
+ self.goto[current_state][ch] = states
+ states += 1
+
+ current_state = self.goto[current_state][ch]
+
+ # Add current word in output function
+ self.out[current_state] |= (1<<i)
+
+ # For all characters which don't have
+ # an edge from root (or state 0) in Trie,
+ # add a goto edge to state 0 itself
+ for ch in range(self.max_characters):
+ if self.goto[0][ch] == -1:
+ self.goto[0][ch] = 0
+ 
+ # Failure function is computed in 
+ # breadth first order using a queue
+ queue = []
+
+ # Iterate over every possible input
+ for ch in range(self.max_characters):
+
+ # All nodes of depth 1 have failure function value as 0.
+ if self.goto[0][ch] != 0:
+ self.fail[self.goto[0][ch]] = 0
+ queue.append(self.goto[0][ch])
+
+ # Now queue has states 1 and 3
+ while queue:
+
+ # Remove the front state from queue
+ state = queue.pop(0)
+
+ # For the removed state, find failure
+ # function for all those characters
+ # for which goto function is not defined.
+ for ch in range(self.max_characters):
+
+ # If goto function is defined for
+ # character 'ch' and 'state'
+ if self.goto[state][ch] != -1:
+
+ # Find failure state of removed state
+ failure = self.fail[state]
+
+ # Find the deepest node labeled by proper
+ # suffix of String from root to current state.
+ while self.goto[failure][ch] == -1:
+ failure = self.fail[failure]
+ 
+ failure = self.goto[failure][ch]
+ self.fail[self.goto[state][ch]] = failure
+
+ # Merge output values
+ self.out[self.goto[state][ch]] |= self.out[failure]
+
+ # Insert the next level node (of Trie) in Queue
+ queue.append(self.goto[state][ch])
+ 
+ return states
+
+
+ # Returns the next state the machine will transition to using goto
+ # and failure functions.
+ # current_state - The current state of the machine. Must be between
+ # 0 and the number of states - 1, inclusive.
+ # next_input - The next character that enters into the machine.
+ def __find_next_state(self, current_state, next_input):
+ answer = current_state
+ ch = ord(next_input) - 97 # Ascii value of 'a' is 97
+
+ # If goto is not defined, use
+ # failure function
+ while self.goto[answer][ch] == -1:
+ answer = self.fail[answer]
+
+ return self.goto[answer][ch]
+
+
+ # This function finds all occurrences of all words in text.
+ def search_words(self, text):
+
+ # Initialize current_state to 0 
+ current_state = 0
+
+ # A dictionary to store the result.
+ # Key here is the found word
+ # Value is a list of all occurances start index
+ result = defaultdict(list)
+
+ # Traverse the text through the built machine
+ # to find all occurrences of words
+ for i in range(len(text)):
+ current_state = self.__find_next_state(current_state, text[i])
+
+ # If match not found, move to next state
+ if self.out[current_state] == 0: continue
+
+ # Match found, store the word in result dictionary
+ for j in range(len(self.words)):
+ if (self.out[current_state] & (1<<j)) > 0:
+ word = self.words[j]
+
+ # Start index of word is (i-len(word)+1)
+ result[word].append(i-len(word)+1)
+
+ # Return the final result dictionary
+ return result
+
+# Driver code
+if __name__ == "__main__":
+ words = ["he", "she", "hers", "his"]
+ text = "ahishers"
+
+ # Create an Object to initialize the Trie
+ aho_chorasick = AhoCorasick(words)
+
+ # Get the result
+ result = aho_chorasick.search_words(text)
+
+ # Print the result
+ for word in result:
+ for i in result[word]:
+ print("Word", word, "appears from", i, "to", i+len(word)-1)