Add lessons

Add lessons #1 #2 and #3

Author: subsr97

README.md

@@ -1,6 +1,8 @@
 # Daily Coding Problem
-A repository of my own solutions as well as optimal solutions for [Daily Coding Problem](https://www.dailycodingproblem.com/).
+A repository of my solutions for [Daily Coding Problem](https://www.dailycodingproblem.com/).
 
-[Index](./index.md) contains the list of programs.
+[Index](./index.md) contains the list Daily Coding Problems and lessons.
 
-The programs are located in the [solutions](./solutions) folder.
+Daily Coding Problem solutions are in [challenges](./challenges).
+
+Lessons and guides by DCP are in [lessons](./lessons).

index.md

@@ -7,3 +7,8 @@
 6. [XOR Linked List](./challenges/xor-linked-list.py)
 7. [Decode Ways](./challenges/decode-ways.py)
 8. [Count Unival Subtrees](./challenges/count-unival-subtrees.py)
+
+# Lessons
+1. [Merge Sort](./lessons/merge-sort.py)
+2. [Count Nodes in Binary Tree](./lessons/count-nodes-in-binary-tree.py)
+3. [Deepest Node in Binary Tree](./lessons/deepest-node-in-binary-tree.py)

lessons/count-nodes-in-binary-tree.py

@@ -0,0 +1,25 @@
+"""
+Given the root to a binary tree, count the total number of nodes there are.
+
+"""
+
+class Node:
+	def __init__(self, val, left=None, right=None):
+		self.val = val
+		self.left = left
+		self.right = right
+
+def count(node):
+	return count(node.left) + count(node.right) + 1 if node else 0
+
+if __name__ == "__main__":
+	tree = Node(4, Node(2, Node(1), Node(3)), Node(5))
+	"""
+	    4
+	   / \
+	  2   5
+	 / \  
+	1   3
+	  
+	"""
+	print(count(tree))

lessons/deepest-node-in-binary-tree.py

@@ -0,0 +1,44 @@
+"""
+Given the root to a binary tree, return the deepest node.
+
+"""
+
+class Node:
+	def __init__(self, val, left=None, right=None):
+		self.val = val
+		self.left = left
+		self.right = right
+
+	def __str__(self):
+		return "<" + str(self.val) + ">"
+
+def deepest(node):
+	if node and not node.left and not node.right:
+		return (node, 1) # Leaf and its depth
+
+	if not node.left: # Then the deepest node is on the right subtree
+		return increment_depth(deepest(node.right))
+	elif not node.right: # Then the deepest node is on the left subtree
+		return increment_depth(deepest(node.left))
+
+	return increment_depth(
+			max(deepest(node.left), deepest(node.right),
+					key=lambda x: x[1]))
+
+def increment_depth(node_depth_tuple):
+	node, depth = node_depth_tuple
+	return (node, depth + 1)
+
+if __name__ == "__main__":
+	tree = Node(4, Node(2, Node(1, Node(0)), Node(3)), Node(5))
+	"""
+			4
+		   / \
+		  2   5
+		 / \  
+		1   3
+	   /
+	  0
+	"""
+	node_depth_tuple = deepest(tree)
+	print(node_depth_tuple[0], " of depth ", node_depth_tuple[1])

lessons/merge-sort.py

@@ -0,0 +1,27 @@
+"""
+Return a new sorted merged list from K sorted lists, each with size N.
+
+"""
+
+import heapq
+
+def merge(lists):
+    merged_list = []
+
+    heap = [(lst[0], i, 0) for i, lst in enumerate(lists) if lst]
+    heapq.heapify(heap)
+
+    while heap:
+        val, list_ind, element_ind = heapq.heappop(heap)
+
+        merged_list.append(val)
+
+        if element_ind + 1 < len(lists[list_ind]):
+            next_tuple = (lists[list_ind][element_ind + 1],
+                          list_ind,
+                          element_ind + 1)
+            heapq.heappush(heap, next_tuple)
+    return merged_list
+
+if __name__ == "__main__":
+    print(merge([[1], [1, 3, 5], [1, 10, 20, 30, 40]]))