New IB Sol

Author: rahulcode22

Backtracking/generate-all-parenthesis.py

@@ -0,0 +1,13 @@
+def generateParenthesis(n):
+    ans = []
+    def backtrack(S = '', left = 0, right = 0):
+        if len(S) == 2*n:
+            ans.append(S)
+            return
+        if left < n:
+            backtrack(S + '(',left+1, right)
+        if right < left:
+            backtrack(S + ')',left,right+1)
+    backtrack()
+    return ans
+print generateParenthesis(3)

Graph/BFS.py renamed to Graph/DirectedBFS.py

@@ -0,0 +1,55 @@
+from collections import defaultdict
+
+# This class represents a directed graph using
+# adjacency list representation
+class Graph:
+
+    # Constructor
+    def __init__(self):
+
+        # default dictionary to store graph
+        self.graph = defaultdict(list)
+
+    # function to add an edge to graph
+    def addEdge(self,u,v):
+        self.graph[u].append(v)
+
+    # A function used by DFS
+    def DFSUtil(self,v,visited):
+
+        # Mark the current node as visited and print it
+        visited[v]= True
+        print v,
+
+        # Recur for all the vertices adjacent to this vertex
+        for i in self.graph[v]:
+            if visited[i] == False:
+                self.DFSUtil(i, visited)
+
+
+    # The function to do DFS traversal. It uses
+    # recursive DFSUtil()
+    def DFS(self,v):
+
+        # Mark all the vertices as not visited
+        visited = [False]*(len(self.graph))
+
+        # Call the recursive helper function to print
+        # DFS traversal starting from all vertices one by one
+        for i in range(len(self.graph)):
+            if visited[i] == False:
+                self.DFSUtil(i,visited)
+
+
+# Driver code
+# Create a graph given in the above diagram
+g = Graph()
+g.addEdge(0, 1)
+g.addEdge(0, 2)
+g.addEdge(1, 2)
+g.addEdge(2, 0)
+g.addEdge(2, 3)
+g.addEdge(3, 3)
+
+print "Following is DFS from (starting from vertex 2)"
+g.DFS(2)

Graph/UndirectedDFS.py

@@ -0,0 +1,19 @@
+'''Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.'''
+def numIslands(self,grid):
+    if not grid:
+        return 0
+    count = 0
+    for i in range(len(grid)):
+        for j in range(len(grid[0])):
+            if grid[i][j] == '1':
+                self.dfs(grid,i,j)
+                count += 1
+    return count
+def dfs(self,grid,i,j):
+    if i < 0 or j<0 or i >= len(grid) or j >= len(grid[0]) or grid[i][j] != '1':
+        return
+    grid[i][j] = '#'
+    self.dfs(grid,i+1,j)
+    self.dfs(grid,i-1,j)
+    self.dfs(grid,i,j+1)
+    self.dfs(grid,i,j-1)

Graph/number-of-islands.py

@@ -0,0 +1,36 @@
+def lengthOfLongestSubstring(arr):
+    max_length = 0
+    i = 0
+    j = i+1
+    n = len(arr)
+    ans = arr[0]
+    while j < n:
+        if arr[j] not in arr[i:j]:
+            len_ = len(arr[i:j+1])
+            if len_ > max_length:
+                max_length = len_
+                ans = arr[i:j+1]
+            j += 1
+        else:
+            i += 1
+            j = i+1
+    return ans
+
+
+s = raw_input()
+print lengthOfLongestSubstring(s)
+
+
+#Approach 2
+class Solution:
+    # @param A : string
+    # @return an integer
+    def lengthOfLongestSubstring(self, A):
+        prev = {c:-1 for c in A}
+        best, prev_best = 1, 1
+        for i in range(1, len(A)):
+            prev[A[i-1]] = i-1
+            prev_best = min(i-prev[A[i]], prev_best+1)
+            best = max(best, prev_best)
+        return best
+Close

Hashing/longest-substring-without-repeat.py

@@ -24,6 +24,6 @@ def SumLinkedList(first,second):
         if second:
             second = second.next
 
-    if carry > 0
-    temp.next = Node(carry)
+    if carry > 0:
+        temp.next = Node(carry)
     return head

LinkedList/Add-LinkedList-as-no.py

@@ -0,0 +1,14 @@
+def maxArea(height):
+    i = 0
+    j = len(height)-1
+    max_water = 0
+    while i < j:
+        max_water = max(max_water,(j-i)*min(height[j],height[i]))
+        if height[i] < height[j]:
+            i += 1
+        else:
+            j -= 1
+    return max_water
+
+arr = [1,1]
+print maxArea(arr)