😓 some pending problems that require updates...

Author: Srinivas11789

ProblemSolving/bulbSwitch/bulb.py

@@ -0,0 +1,26 @@
+# Pending...
+
+class Solution(object):
+    def bulbSwitch(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        
+	# Time Limit Exceeded Solution
+        import collections
+        
+        # Lets assume 1 in ON and 0 is OFF
+        # * First steps (1st iteration) also includes constructing the dictionary
+        # * So, all are ON
+        switches = collections.Counter(range(1,n+1))
+        
+        for i in range(2, n+1):
+            if i == 2:
+                for k in range(i, n+1, i):
+                    switches[k] = 0
+            else:
+                for k in range(i, n+1, i):
+                    switches[k] = switches[k]^1
+
+        return sum(switches.values())

ProblemSolving/serializeAndDeserializeBST/serial.py

@@ -0,0 +1,93 @@
+# Pending...
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+# Logic:
+# * Given a root,Lets use any one traversal technique (pre, post or in order) or level order and obtain a string (or any technique to traverse)
+# * Given a string, Lets reverse the corresponding order we select and reconstruct the tree
+# * Remember we do it state less so we dont store any variables
+
+class Codec:
+
+    def serialize(self, root):
+        """Encodes a tree to a single string.
+        
+        :type root: TreeNode
+        :rtype: str
+        """
+        
+        def pre_order_traverse(node, encode):
+            
+            if not node:
+                return
+        
+            if node.left and node.right:
+                encode += "/"+ str(node.val) +  "L" + str(node.left.val) +  "R" + str(node.right.val)
+            elif node.left:
+                encode += "/"+ str(node.val) + "L" + str(node.left.val)
+            elif node.right:
+                encode += "/"+ str(node.val) + "R" + str(node.right.val)
+            elif node:
+                encode += "/"+str(node.val) 
+                
+            pre_order_traverse(node.left, encode)
+            pre_order_traverse(node.right, encode)
+            
+            return encode
+            
+        return pre_order_traverse(root, "")
+        
+
+    def deserialize(self, data):
+        """Decodes your encoded data to tree.
+        
+        :type data: str
+        :rtype: TreeNode
+        """
+        
+        def reverse_traversal_to_bst(node, sequence, root):
+            
+            if sequence and node == "":
+                subtree = list(sequence.pop(0))
+                root = node = TreeNode(int(subtree.pop(0)))
+                if subtree and subtree[0] == "L":
+                    subtree.pop(0)
+                    node.left = TreeNode(int(subtree.pop(0)))
+                if subtree and subtree[0] == "R":
+                    subtree.pop(0)
+                    node.right= TreeNode(int(subtree.pop(0)))
+            
+            elif sequence and node.val == sequence[0]:
+                subtree = list(sequence.pop(0))
+                subtree.pop(0)
+                if subtree and subtree[0] == "L":
+                    subtree.pop(0)
+                    node.left = TreeNode(int(subtree.pop(0)))
+                if subtree and subtree[0] == "R":
+                    subtree.pop(0)
+                    node.right= TreeNode(int(subtree.pop(0)))
+            
+            if node.left:
+                reverse_traversal_to_bst(node.left, sequence, root)
+            if node.right:
+                reverse_traversal_to_bst(node.right, sequence, root)
+            
+            return root
+            
+        if not data:
+            return []
+        print data
+        return reverse_traversal_to_bst("", data.split("/")[1:], "")
+        
+        
+        
+
+# Your Codec object will be instantiated and called as such:
+# codec = Codec()
+# print codec.serialize(root)
+# codec.deserialize(codec.serialize(root))

ProblemSolving/targetSum/target.py

@@ -0,0 +1,40 @@
+# Pending...
+
+class Solution(object):
+    def findTargetSumWays(self, nums, S):
+        """
+        :type nums: List[int]
+        :type S: int
+        :rtype: int
+        """
+        
+        # Logic 1: Bruteforce with itertools...
+        
+        # BruteForce with all the combinations for the target sum
+        # * Use itertools
+        # * add symbols to each integer and then eval() to check for target sum
+        
+        import itertools
+        
+        count = 0
+        
+        if 0 in nums:
+            i = 0
+            while nums and i < len(nums):
+                if nums[i] == 0:
+                    del nums[i]
+                else:
+                    i += 1
+        
+        if not nums:
+            return 0
+        
+        n = len(nums)    
+        
+        for combination in itertools.product(["+","-"], repeat=n):
+            expression = ""
+            for i in range(n):
+                expression += combination[i]+str(nums[i])
+            if eval(expression) == S:
+                count += 1
+        return count