new

Author: harishpuvvada

Dynamic Programming/0-KnapSack-Weight,Value.py

@@ -1,5 +1,4 @@
 #A naive recursive implementation of 0-1 Knapsack Problem
-
 # Returns the maximum value that can be put in a knapsack of capacity W
 def knapSack(W , wt , val , n):   #Time Complexity is O(2^n)
 
@@ -17,6 +16,7 @@ def knapSack(W , wt , val , n):   #Time Complexity is O(2^n)
         #      max(---- eq for including nth wt-------------------,---- for not including------)
 
 
+#Using Dynamic programming
 def dynamicProg_KP(W, wt, val, n): #Time Complexity is O(nW)
     #creating a table using list comprehensions
     K = [[0 for x in range(W+1)] for x in range(n+1)] #here "+1" cuz we go from 0 to W,0 to n
@@ -34,6 +34,8 @@ def dynamicProg_KP(W, wt, val, n): #Time Complexity is O(nW)
     return K[n][W]
 
 
+
+
 # To test above functions
 val = [60, 100, 120]
 wt = [10, 20, 30]

Dynamic Programming/Longest Common SubSequence.py

@@ -0,0 +1,38 @@
+
+#Using recursion - Time Complexity => O(2^n)
+def lcs(X, Y, m, n):
+
+    if m == 0 or n == 0:
+       return 0;
+    elif X[m-1] == Y[n-1]:
+       return 1 + lcs(X, Y, m-1, n-1);
+    else:
+       return max(lcs(X, Y, m, n-1), lcs(X, Y, m-1, n));
+
+
+#Using tabulation method of dynamic programming - Time Complexity => O(mn)
+def lcs(X , Y):
+    m = len(X)
+    n = len(Y)
+
+    L = [[None for _ in range(n+1)] for _ in range(m+1)]
+
+    """Following steps build L[m+1][n+1] in bottom up fashion
+    Note: L[i][j] contains length of LCS of X[0..i-1]
+    and Y[0..j-1]"""
+    for i in range(m+1):
+        for j in range(n+1):
+            if i == 0 or j == 0 :
+                L[i][j] = 0
+            elif X[i-1] == Y[j-1]:
+                L[i][j] = L[i-1][j-1]+1
+            else:
+                L[i][j] = max(L[i-1][j] , L[i][j-1])
+
+    return L[m][n]
+
+
+
+X = "AGGTAB"
+Y = "GXTXAYB"
+print "Length of LCS is ", lcs(X , Y, len(X), len(Y))

Dynamic Programming/wordbreak.py

@@ -0,0 +1,9 @@
+dictionary = ["i","am","awesome"]
+
+s = "iamaweso"
+
+l = len(s)
+
+K = [[0 for _in range(l)] for _ in range(l)]
+
+for i 

Lists/listFlatten.py

@@ -0,0 +1,35 @@
+"""
+Implement Flatten Arrays.
+Given an array that may contain nested arrays,
+give a single resultant array.
+
+function flatten(input){
+}
+
+Example:
+
+Input: var input = [2, 1, [3, [4, 5], 6], 7, [8]];
+flatten(input);
+Output: [2, 1, 3, 4, 5, 6, 7, 8]
+"""
+
+
+def flatten_rec(input):
+
+    flatList = []
+
+    def makelist(lis):
+        for el in lis:
+            if type(el) == list:
+                makelist(el)
+            else:
+                flatList.append(el)
+
+    makelist(input)
+
+    return flatList
+
+
+
+input = [2, 1, [3, [4, 5], 6], 7, [8]]
+print(flatten_rec(input))

Lists/max 3 num prod.py

@@ -1,31 +1,21 @@
 import sys
 
 def solution(lis):
-
     first = second = third = -sys.maxsize
 
     for num in lis:
 
         if num > first:
-
             second = first
-
             third = second
-
             first = num
 
         elif num > second :
-
             third = second
-
             second = num
 
-
         elif num > third :
-
             third = num
 
     print(first, second, third)
-
-
     return first * second * third

Lists/product of ints.py

@@ -15,14 +15,12 @@ def index_prod(lst):
 
     while i < len(lst):
 
-
         # Set index as cumulative product
         output[i] = product
 
         # Cumulative product
         product *= lst[i]
 
-        # Move forward
         i +=1
 
         print("output", output)

Lists/remove duplicates.py

@@ -0,0 +1,11 @@
+
+'''remove duplicates from a given list'''
+
+def remove_duplicates(lst):
+    seen = set()
+    res = []
+    for x in lst:
+        if x not in seen:
+            res.append(x)
+            seen.add(x)
+    return res

Misc/Matrix Multiplication.py

@@ -0,0 +1,23 @@
+
+
+
+def matrixmult (A, B):
+    rows_A = len(A)
+    cols_A = len(A[0])
+    rows_B = len(B)
+    cols_B = len(B[0])
+
+    if cols_A != rows_B:
+      print "Cannot multiply the two matrices. Incorrect dimensions."
+      return
+
+    # Create the result matrix
+    # Dimensions would be rows_A x cols_B
+    C = [[0 for row in range(cols_B)] for col in range(rows_A)]
+    #print C
+
+    for i in range(rows_A):
+        for j in range(cols_B):
+            for k in range(cols_A):
+                C[i][j] += A[i][k] * B[k][j]
+    return C

Misc/Simple Order Book.py

@@ -0,0 +1,54 @@
+''' This question from AKuna Capital'''
+
+
+# a simple orderbook class    
+import operator
+class OrderBook:
+    def __init__(self):
+        self.order_book = {}
+
+    def buy(self, order_id, price):
+        self.order_book[order_id] = price
+        
+    def sell(self, order_id):
+        if order_id in self.order_book:
+            del self.order_book[order_id]
+
+    def get_high_price(self):
+        if not self.order_book:
+            return -1
+        sorted_prices = sorted(self.order_book.items(),key=operator.itemgetter(1))
+        ret_val = "%g" % float(sorted_prices[-1][1])  #This line is to drop trailing ".0" from floats
+        return ret_val
+
+
+book = OrderBook()
+for line in sys.stdin:
+    elements = line.split(' ')
+    time_order = int(elements[0])
+    type_order = elements[1]
+    id_order = int(elements[2])
+    price_order = None
+    if len(elements) == 4:
+        price_order = float(elements[3])
+        
+    if type_order == 'B':
+        book.buy(id_order,price_order)
+        
+    elif type_order == 'S':
+        book.sell(id_order)
+        
+    print(time_order, book.get_high_price())
+
+
+
+
+#Sample Input
+# 0 B 1 10.0
+# 10 B 2 20.5
+# 30 B 3 15.0
+# 60 S 2
+# 100 S 1
+# 200 S 3
+# 250 B 4 10.5
+# 300 S 4

Trees/print all nth level nodes.py

@@ -0,0 +1,32 @@
+
+'''
+
+Print nodes at k distance from root
+Given a root of a tree, and an integer k. Print all the nodes which are at k distance from root.
+
+For example, in the below tree, 4, 5 & 8 are at distance 2 from root.
+            1
+          /   \
+        2      3
+      /   \   /
+    4     5  8 
+
+
+    '''
+
+
+def printNodeFunc(root,n,store = []):
+
+	if not root:
+		return
+
+	if n==0:
+		print(root.data)
+
+	else:
+		printNodeFunc(root.left,n-1)
+		printNodeFunc(root.right,n-1)
+
+
+
+#Ans : 4,5,8