KMP algorithm

Author: Partho Biswas

README.md

@@ -809,6 +809,7 @@ BFS, DFS, Dijkstra, Floyd–Warshall, Bellman-Ford, Kruskal, Prim's, Minimum Spa
 | --- | --- | --- | --- | --- | --- |
 |01| [Kadane's_Algorithm](algoexpert.io/questions/Kadane's_Algorithm.md) | [Python](algoexpert.io/python/Kadane's_Algorithm.py)|
 |02| [Topological_Sort](algoexpert.io/questions/Topological_Sort.md) | [Python](algoexpert.io/python/Topological_Sort.py) |
+|03| [KMP_Algorithm](algoexpert.io/questions/KMP_Algorithm.md) | [Python](algoexpert.io/python/KMP_Algorithm.py) |
 
 </p>
 </details>
@@ -942,7 +943,7 @@ BFS, DFS, Dijkstra, Floyd–Warshall, Bellman-Ford, Kruskal, Prim's, Minimum Spa
 |02| [Longest_Palindromic_Substring](algoexpert.io/questions/Longest_Palindromic_Substring.md) | [Python](algoexpert.io/python/Longest_Palindromic_Substring.py)|
 |03| [Caesar_Cipher_Encryptor](algoexpert.io/questions/Caesar_Cipher_Encryptor.md) | [Python](algoexpert.io/python/Caesar_Cipher_Encryptor.py)|
 |04| [Longest_Substring_Without_Duplication](algoexpert.io/questions/Longest_Substring_Without_Duplication.md) | [Python](algoexpert.io/python/Longest_Substring_Without_Duplication.py)|
-|05| [Underscorify_Substring](algoexpert.io/questions/Underscorify_Substring.md) | [Python](algoexpert.io/python/Underscorify_Substring.py)|
+|05| [Underscorify_Substring](algoexpert.io/questions/Underscorify_Substring.md) | [Python](algoexpert.io/python/Underscorify_Substring.py)| --- | Hard | TODO: Check again. Difficult to analyse the space ad time complexity |
 |06| [Pattern_Matcher](algoexpert.io/questions/Pattern_Matcher.md) | [Python](algoexpert.io/python/Pattern_Matcher.py)|
 
 </p>

algoexpert.io/python/Breadth_First_Search.py

@@ -1,23 +1,20 @@
 # https://www.algoexpert.io/questions/Breadth-first%20Search
-
-
 class Node:
-
     def __init__(self, name):
+        self.children = []
         self.name = name
-        self.childern = []
 
-    def add_children(self, name):
-        self.childern.append(Node(name))
+    def addChild(self, name):
+        self.children.append(Node(name))
         return self
 
-    # O(v + e) time | O(v) space
-    def breadth_first_search(self, array):
+    def breadthFirstSearch(self, array):
         queue = [self] # step 1 > add root node to the queue, the node on which we are calling BFS
         while len(queue) > 0:
             current = queue.pop(0) # step 2 > pop the root/current node
             array.append(current.name) # step 3 > add the current node to the final array
-            for child in current.childern: # step 4 > add the children of the current node to the queue
+            for child in current.children: # step 4 > add the children of the current node to the queue
                 queue.append(child)
         return array
 
+

algoexpert.io/python/Find_Closest_Value_in_BST.py

@@ -1,5 +1,3 @@
-
-
 class BST:
     def __init__(self, value):
         self.value = value
@@ -23,7 +21,7 @@ def insert(self, value):
 def findClosestValueInBst(tree, target):
     return findClosestValueInBstHelper(tree, target, float("inf"))
 
-# Solution 1 starts here
+# Solution 1
 # Avarage: O(log(n)) time | O(log(n)) space
 # Worst: O(n) time | O(n) space
 def findClosestValueInBstHelper(tree, target, closest):
@@ -37,9 +35,8 @@ def findClosestValueInBstHelper(tree, target, closest):
         return findClosestValueInBstHelper(tree.right, target, closest)
     else:
         return closest
-# Solution 1 ends here
 
-# Solution 2 starts here
+# Solution 2
 # Avarage: O(log(n)) time | O(1) space
 # Worst: O(n) time | O() space
 def findClosestValueInBstHelper_2(tree, target, closest):
@@ -54,7 +51,6 @@ def findClosestValueInBstHelper_2(tree, target, closest):
         else:
             break
     return closest
-# Solution 2 ends here
 
 
 test_tree = BST(100).insert(5).insert(15).insert(5).insert(2).insert(1).insert(22) \

algoexpert.io/python/KMP_Algorithm.py

@@ -0,0 +1,31 @@
+def knuthMorrisPrattAlgorithm(string, substring):
+    pattern = buildPattern(substring)
+	return doesMatch(string, substring, pattern)
+
+def buildPattern(substring):
+	pattern = [-1 for _ in substring]
+	j, i = 0, 1
+	while i < len(substring):
+		if substring[i] == substring[j]:
+			pattern[i] = j
+			i += 1
+			j += 1
+		elif j > 0:
+			j = pattern[j - 1] + 1
+		else:
+			i += 1
+	return pattern
+
+def doesMatch(string, substring, pattern):
+	i, j = 0, 0
+	while i + len(substring) - j <= len(string):
+		if string[i] == substring[j]:
+			if j == len(substring) - 1:
+				return True
+			i += 1
+			j += 1
+		elif j > 0:
+			j = pattern[j - 1] + 1
+		else:
+			i += 1
+	return False

algoexpert.io/python/Right_Sibling_Tree.py

@@ -5,7 +5,6 @@ def __init__(self, value, left=None, right=None):
         self.left = left
         self.right = right
 
-
 def rightSiblingTree(root):
     mutate(root, None, None)
 	return root

algoexpert.io/python/Search_For_Range.py

@@ -1,6 +1,3 @@
-
-
-
 # Solution #1   -   Recursive SOlution
 # O(logn) time  |  O(logn) space
 def searchForRange(array,  target):
@@ -9,7 +6,6 @@ def searchForRange(array,  target):
     alteredBinarySearch(array, target, 0, len(array) - 1, finalRange, False)
     return finalRange
 
-
 def alteredBinarySearch(array, target, left, right, finalRange, goLeft):
     if left > right:
         return
@@ -31,9 +27,6 @@ def alteredBinarySearch(array, target, left, right, finalRange, goLeft):
                 alteredBinarySearch(array, target, mid + 1, right, finalRange, goLeft)
 
 
-
-
-
 # Solution #2   -   Iterative SOlution
 # O(logn) time  |  O(1) space
 def searchForRange(array,  target):
@@ -42,7 +35,6 @@ def searchForRange(array,  target):
     alteredBinarySearch(array, target, 0, len(array) - 1, finalRange, False)
     return finalRange
 
-
 def alteredBinarySearch(array, target, left, right, finalRange, goLeft):
     while left <= right:
         mid = (left + right) // 2
@@ -64,5 +56,10 @@ def alteredBinarySearch(array, target, left, right, finalRange, goLeft):
 
 
 
-
-
+# Solution 3  - using python bisect library
+import bisect
+def searchForRange(array, target):
+    # Write your code here.
+    left = bisect.bisect_left(array, target)
+	right = bisect.bisect_right(array, target)
+	return [left, right - 1] if left < right else [-1, -1]

algoexpert.io/python/Topological_Sort.py

@@ -1,53 +1,43 @@
-
 # SOLUTION #1
-
 class JobNode:
     def __init__(self, job):
         self.job = job
         self.prereqs = []
         self.visited = False
         self.visiting = False
 
-
 class JobGraph:
     def __init__(self, jobs):
         self.nodes = []
         self.graph = {}
         for job in jobs:
-            self.addNodes(job)
-
+            self.addNode(job)
 
     def addPrereq(self, job, prereq):
         jobNode = self.getNode(job)
         prereqNode = self.getNode(prereq)
         jobNode.prereqs.append(prereqNode)
 
-
     def addNode(self, job):
         self.graph[job] = JobNode(job)
         self.nodes.append(self.graph[job])
 
-
     def getNode(self, job):
         if job not in self.graph:
             self.addNode(job)
         return self.graph[job]
 
-
-
 #   O(v + e) time | O(v + e) space
 def topologicalSort(jobs, deps):
     jobGraph = createJobGraph(jobs, deps)
     return getOrderedJobs(jobGraph)
 
-
 def createJobGraph(jobs, deps):
     graph = JobGraph(jobs)
     for prereq, job in deps:
         graph.addPrereq(job, prereq)
     return graph
 
-
 def getOrderedJobs(graph):
     orderedJobs = []
     nodes = graph.nodes
@@ -58,7 +48,6 @@ def getOrderedJobs(graph):
             return []
     return orderedJobs
 
-
 def depthFirstTraverse(node, orderedJobs):
     if node.visited:
         return False
@@ -75,60 +64,46 @@ def depthFirstTraverse(node, orderedJobs):
     return False
 
 
-
-
-
-
-
 # SOLUTION #2
-
 class JobNode:
     def __init__(self, job):
         self.job = job
         self.deps = []
         self.numOfPrereqs = 0
 
-
 class JobGraph:
     def __init__(self, jobs):
         self.nodes = []
         self.graph = {}
         for job in jobs:
-            self.addNodes(job)
-
+            self.addNode(job)
 
     def addDep(self, job, dep):
         jobNode = self.getNode(job)
         depNode = self.getNode(dep)
         jobNode.dep.append(depNode)
         depNode.numOfPrereqs += 1
 
-
     def addNode(self, job):
         self.graph[job] = JobNode(job)
         self.nodes.append(self.graph[job])
 
-
     def getNode(self, job):
         if job not in self.graph:
             self.addNode(job)
         return self.graph[job]
 
-
-
 #   O(v + e) time | O(v + e) space
 def topologicalSort(jobs, deps):
     jobGraph = createJobGraph(jobs, deps)
     return getOrderedJobs(jobGraph)
 
-
 def createJobGraph(jobs, deps):
     graph = JobGraph(jobs)
     for job, dep in deps:
         graph.addDep(job, dep)
     return graph
 
-
 def getOrderedJobs(graph):
     orderedJobs = []
     nodesWithNoPrereqs = list(filter(lambda node: node.numOfPrereqs == 0, graph.nodes))
@@ -139,7 +114,6 @@ def getOrderedJobs(graph):
     graphHasEdges = any(node.numOfPrereqs for node in graph.nodes)
     return [] if graphHasEdges else orderedJobs
 
-
 def removeDeps(node, nodesWithNoPrereqs):
     while len(node.deps):
         dep = node.deps.pop()

algoexpert.io/python/Underscorify_Substring.py

@@ -1,4 +1,3 @@
-
 # O(n*m) time |  O(n) space
 def underscorifySubstring(string, substring):
     locations = collapse(getLocations(string, substring))
@@ -39,7 +38,7 @@ def underscorify(string, locations):
     inBetweenUnderscores = False
     finalChars = []
     i = 0
-    while stringIdx < len(string) and locationsIdx < len(locationsIdx):
+    while stringIdx < len(string) and locationsIdx < len(locations):
         if stringIdx ==  locations[locationsIdx][i]:
             finalChars.append("_")
             inBetweenUnderscores = not inBetweenUnderscores
@@ -60,3 +59,4 @@ def underscorify(string, locations):
 
 
 
+