diff --git a/ContainsX.py b/ContainsX.py
new file mode 100644
index 0000000..c643e2d
--- /dev/null
+++ b/ContainsX.py
@@ -0,0 +1,47 @@
+from sys import stdin,setrecursionlimit
+setrecursionlimit(10**6)
+class treeNode:
+    def __init__(self, data):
+        self.data = data
+        self.children = []
+    def __str__(self):
+        return str(self.data)
+
+def containsX(tree, x):
+    #############################
+    # PLEASE ADD YOUR CODE HERE #
+    #############################
+    if tree is None:
+        return False
+    if tree.data == x:
+        return True
+    childCount = len(tree.children)
+    for i in range(childCount):
+        if (containsX(tree.children[i], x)):
+            return True
+    return False
+def createLevelWiseTree(arr):
+    root = treeNode(int(arr[0]))
+    q = [root]
+    size = len(arr)
+    i = 1
+    while i<size:
+        parent = q.pop(0)
+        childCount = int(arr[i])
+        i += 1
+        for j in range(0,childCount):
+            temp = treeNode(int(arr[i+j]))
+            parent.children.append(temp)
+            q.append(temp)
+        i += childCount
+    return root
+
+# Main
+
+arr = list(int(x) for x in stdin.readline().strip().split())
+x=int(stdin.readline().strip())
+tree = createLevelWiseTree(arr)
+if containsX(tree,x):
+    print('true')
+else:
+    print('false')
diff --git a/CountLeafNodes.py b/CountLeafNodes.py
new file mode 100644
index 0000000..0871c72
--- /dev/null
+++ b/CountLeafNodes.py
@@ -0,0 +1,42 @@
+import sys
+class treeNode:
+    def __init__(self, data):
+        self.data = data
+        self.children = []
+    def __str__(self):
+        return str(self.data)
+
+def leafNodeCount(tree):
+    #############################
+    # PLEASE ADD YOUR CODE HERE #
+    #############################
+    if tree is None:
+        return 0
+    childCount = len(tree.children)
+    if childCount == 0:
+        return 1
+    res = 0
+    for i in range(childCount):
+        res += leafNodeCount(tree.children[i])
+    return res
+def createLevelWiseTree(arr):
+    root = treeNode(int(arr[0]))
+    q = [root]
+    size = len(arr)
+    i = 1
+    while i<size:
+        parent = q.pop(0)
+        childCount = int(arr[i])
+        i += 1
+        for j in range(0,childCount):
+            temp = treeNode(int(arr[i+j]))
+            parent.children.append(temp)
+            q.append(temp)
+        i += childCount
+    return root
+
+# Main
+sys.setrecursionlimit(10**6)
+arr = list(int(x) for x in input().strip().split(' '))
+tree = createLevelWiseTree(arr)
+print(leafNodeCount(tree))
diff --git a/Data Structures and Algorithms/BellmanFord.py b/Data Structures and Algorithms/BellmanFord.py
new file mode 100644
index 0000000..327fd43
--- /dev/null
+++ b/Data Structures and Algorithms/BellmanFord.py	
@@ -0,0 +1,61 @@
+from Graph import *
+
+def relaxEdge(G, edge):
+    
+    u,v,w = edge
+    u = G.getVertexById(u.getId())
+    v = G.getVertexById(v.getId())
+    
+    distanceU = u.getDistance()
+    distanceV = v.getDistance()
+    
+    if (distanceU + w < distanceV):
+        v.setDistance(distanceU + w)
+
+def printSolution(S):
+    for v in S.vert_dict:
+        i = S.getVertexById(v)
+        print('----------------------------------------------')
+        print(f' Vertex: |{i.getId()}| - Distance from source: |{i.getDistance()}|') 
+    print('----------------------------------------------')
+
+def bellmanFord(G, s):
+    print("Bellman-Ford's shortest path")
+    s.setDistance(0)
+    i = 0
+    while(i < (G.num_vertices)):
+        for edge in G.edges_list:
+            relaxEdge(G, edge)
+        i = i + 1
+    
+    for edge in G.edges_list:
+        u,v,w = edge
+        if (v.getDistance() > u.getDistance() + w):
+            print("NEGATIVE CYCLE")
+            return False
+
+    printSolution(G)
+    return True
+
+if __name__ == '__main__':
+
+    g = Graph()
+
+    a = g.addVertex('a')
+    b = g.addVertex('b')
+    c = g.addVertex('c')
+    d = g.addVertex('d')
+    e = g.addVertex('e')
+    f = g.addVertex('f')
+
+    g.addEdge(a, b, 6) 
+    g.addEdge(a, b, 7)  
+    g.addEdge(a, f, 14)
+    g.addEdge(b, c, 10)
+    g.addEdge(b, d, 15)
+    g.addEdge(c, d, 11)
+    g.addEdge(c, f, 2)
+    g.addEdge(d, e, 6)
+    g.addEdge(e, f, 9)
+
+    bellmanFord(g, a)
\ No newline at end of file
diff --git a/Data Structures and Algorithms/binary_tree.py b/Data Structures and Algorithms/binary_tree.py
new file mode 100644
index 0000000..91ec60b
--- /dev/null
+++ b/Data Structures and Algorithms/binary_tree.py	
@@ -0,0 +1,44 @@
+class Node:
+    def __init__(self, key):
+        self.left = None
+        self.right = None
+        self.val = key
+
+    # Traverse preorder
+    def traversePreOrder(self):
+        print(self.val, end=' ')
+        if self.left:
+            self.left.traversePreOrder()
+        if self.right:
+            self.right.traversePreOrder()
+
+    # Traverse inorder
+    def traverseInOrder(self):
+        if self.left:
+            self.left.traverseInOrder()
+        print(self.val, end=' ')
+        if self.right:
+            self.right.traverseInOrder()
+
+    # Traverse postorder
+    def traversePostOrder(self):
+        if self.left:
+            self.left.traversePostOrder()
+        if self.right:
+            self.right.traversePostOrder()
+        print(self.val, end=' ')
+
+
+root = Node(1)
+
+root.left = Node(2)
+root.right = Node(3)
+
+root.left.left = Node(4)
+
+print("Pre order Traversal: ", end="")
+root.traversePreOrder()
+print("\nIn order Traversal: ", end="")
+root.traverseInOrder()
+print("\nPost order Traversal: ", end="")
+root.traversePostOrder()
diff --git a/Data Structures and Algorithms/heapsort.py b/Data Structures and Algorithms/heapsort.py
new file mode 100644
index 0000000..82100dd
--- /dev/null
+++ b/Data Structures and Algorithms/heapsort.py	
@@ -0,0 +1,39 @@
+def heapify(arr, n, i):
+      # Find largest among root and children
+      largest = i
+      l = 2 * i + 1
+      r = 2 * i + 2
+  
+      if l < n and arr[i] < arr[l]:
+          largest = l
+  
+      if r < n and arr[largest] < arr[r]:
+          largest = r
+  
+      # If root is not largest, swap with largest and continue heapifying
+      if largest != i:
+          arr[i], arr[largest] = arr[largest], arr[i]
+          heapify(arr, n, largest)
+  
+  
+  def heapSort(arr):
+      n = len(arr)
+  
+      # Build max heap
+      for i in range(n//2, -1, -1):
+          heapify(arr, n, i)
+  
+      for i in range(n-1, 0, -1):
+          # Swap
+          arr[i], arr[0] = arr[0], arr[i]
+  
+          # Heapify root element
+          heapify(arr, i, 0)
+  
+  
+  arr = [1, 12, 9, 5, 6, 10]
+  heapSort(arr)
+  n = len(arr)
+  print("Sorted array is")
+  for i in range(n):
+      print("%d " % arr[i], end='')
diff --git a/Factor of a Number b/Factor of a Number
new file mode 100644
index 0000000..78f28f7
--- /dev/null
+++ b/Factor of a Number	
@@ -0,0 +1,11 @@
+# method to print the divisors
+def printDivisors(n) :
+    i = 1
+    while i <= n :
+        if (n % i==0) :
+            print (i,end=" ")
+        i = i + 1
+         
+# Driver method
+print ("The divisors of 100 are: ")
+printDivisors(100)
diff --git a/HeightOfTree.py b/HeightOfTree.py
new file mode 100644
index 0000000..fef95f9
--- /dev/null
+++ b/HeightOfTree.py
@@ -0,0 +1,37 @@
+import sys
+sys.setrecursionlimit(10**6)
+class treeNode:
+    def __init__(self, data):
+        self.data = data
+        self.children = []
+    def __str__(self):
+        return str(self.data)
+
+#main
+def heightOfTree(root):
+    height = 0
+    for child in root.children:
+        ch = heightOfTree(child)
+        height = max(ch, height)
+    height += 1
+    return height
+## Read input as specified in the question.
+def createLevelWiseTree(arr):
+    root = treeNode(int(arr[0]))
+    q = [root]
+    size = len(arr)
+    i = 1
+    while i<size:
+        parent = q.pop(0)
+        childCount = int(arr[i])
+        i += 1
+        for j in range(0,childCount):
+            temp = treeNode(int(arr[i+j]))
+            parent.children.append(temp)
+            q.append(temp)
+        i += childCount
+    return root
+## Print output as specified in the question.
+arr = list(int(x) for x in sys.stdin.readline().rstrip().rsplit())
+root = createLevelWiseTree(arr)
+print(heightOfTree(root))
diff --git a/LevelOrderTraversal.py b/LevelOrderTraversal.py
new file mode 100644
index 0000000..bcd7d67
--- /dev/null
+++ b/LevelOrderTraversal.py
@@ -0,0 +1,125 @@
+"""
+Level order traversal
+Send Feedback
+For a given a Binary Tree of type integer, print it in a level order fashion where each level will be printed on a new line. 
+Elements on every level will be printed in a linear fashion and a single space will separate them.
+"""
+from sys import stdin, setrecursionlimit
+import queue
+
+setrecursionlimit(10 ** 6)
+
+
+#Following is the structure used to represent the Binary Tree Node
+class BinaryTreeNode:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+def printLevelWise(root):
+    #Your code goes here
+    if root is None :
+        return
+
+    pendingNodes = queue.Queue()
+    pendingNodes.put(root)
+    pendingNodes.put(None)
+
+    while not pendingNodes.empty(): 
+        frontNode = pendingNodes.get()
+    
+        if frontNode is None :
+            print()
+            
+            if not pendingNodes.empty() :
+                pendingNodes.put(None)
+                
+        else :
+            print(frontNode.data, end = " ")
+            
+            if frontNode.left is not None :
+                pendingNodes.put(frontNode.left)
+                
+                
+            if frontNode.right is not None :
+                pendingNodes.put(frontNode.right)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+                
+
+#Taking level-order input using fast I/O method
+def takeInput():
+    levelOrder = list(map(int, stdin.readline().strip().split(" ")))
+    start = 0
+    
+    length = len(levelOrder)
+
+    if length == 1 :
+        return None
+    
+    root = BinaryTreeNode(levelOrder[start])
+    start += 1
+
+    q = queue.Queue()
+    q.put(root)
+
+    while not q.empty():
+        currentNode = q.get()
+
+        leftChild = levelOrder[start]
+        start += 1
+
+        if leftChild != -1:
+            leftNode = BinaryTreeNode(leftChild)
+            currentNode.left =leftNode
+            q.put(leftNode)
+
+        rightChild = levelOrder[start]
+        start += 1
+
+        if rightChild != -1:
+            rightNode = BinaryTreeNode(rightChild)
+            currentNode.right =rightNode
+            q.put(rightNode)
+
+    return root
+
+
+# Main
+root = takeInput()
+printLevelWise(root)
diff --git a/Missing Number b/Missing Number
new file mode 100644
index 0000000..f6363f9
--- /dev/null
+++ b/Missing Number	
@@ -0,0 +1,11 @@
+def findMissingNumbers(n):
+    numbers = set(n)
+    length = len(n)
+    output = []
+    for i in range(1, n[-1]):
+        if i not in numbers:
+            output.append(i)
+    return output
+    
+listOfNumbers = [1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 13, 14, 16]
+print(findMissingNumbers(listOfNumbers))
diff --git a/NextLargestNodeInAGenericTree.py b/NextLargestNodeInAGenericTree.py
new file mode 100644
index 0000000..e5ef11b
--- /dev/null
+++ b/NextLargestNodeInAGenericTree.py
@@ -0,0 +1,51 @@
+from sys import stdin,setrecursionlimit
+setrecursionlimit(10**6)
+class treeNode:
+    def __init__(self, data):
+        self.data = data
+        self.children = []
+
+def nextLargestUtil(root, x):
+    global res
+    if root is None:
+        return
+    if root.data > x:
+        if ((res == None or res.data > root.data)):
+            res = root
+    countChildren = len(root.children)
+    for i in range(countChildren):
+        nextLargestUtil(root.children[i], x)
+    return
+def nextLargest(root, n):
+    #############################
+    # PLEASE ADD YOUR CODE HERE #
+    #############################
+    global res
+    res = None
+    nextLargestUtil(root, n)
+    return res
+
+
+
+def createLevelWiseTree(arr):
+    root = treeNode(int(arr[0]))
+    q = [root]
+    size = len(arr)
+    i = 1
+    while i<size:
+        parent = q.pop(0)
+        childCount = int(arr[i])
+        i += 1
+        for j in range(0,childCount):
+            temp = treeNode(int(arr[i+j]))
+            parent.children.append(temp)
+            q.append(temp)
+        i += childCount
+    return root
+
+# Main
+arr = list(int(x) for x in stdin.readline().strip().split())
+n = int(input())
+tree = createLevelWiseTree(arr)
+if nextLargest(tree, n):
+    print(nextLargest(tree, n).data)
diff --git a/NodeWithMaximumChildSum.py b/NodeWithMaximumChildSum.py
new file mode 100644
index 0000000..83eb141
--- /dev/null
+++ b/NodeWithMaximumChildSum.py
@@ -0,0 +1,51 @@
+from sys import stdin,setrecursionlimit
+setrecursionlimit(10**6)
+class treeNode:
+    def __init__(self, data):
+        self.data = data
+        self.children = []
+    def sum(self):
+        ans = self.data
+        for child in self.children:
+            ans += child.data
+        return ans
+def maxSumUtil(root, resNode, maxsum):
+    if root is None:
+        return
+    cur_sum = root.data
+    count = len(root.children)
+    for i in range(count):
+        cur_sum += root.children[i].data
+        resNode, maxsum = maxSumUtil(root.children[i], resNode, maxsum)
+    if cur_sum > maxsum:
+        resNode = root
+        maxsum = cur_sum
+    return resNode, maxsum
+def maxSumNode(tree):
+    #############################
+    # PLEASE ADD YOUR CODE HERE #
+    #############################
+    resNode, maxsum = treeNode(None), 0
+    resNode, maxsum = maxSumUtil(tree, resNode, maxsum)
+    return resNode.data
+
+def createLevelWiseTree(arr):
+    root = treeNode(int(arr[0]))
+    q = [root]
+    size = len(arr)
+    i = 1
+    while i<size:
+        parent = q.pop(0)
+        childCount = int(arr[i])
+        i += 1
+        for j in range(0,childCount):
+            temp = treeNode(int(arr[i+j]))
+            parent.children.append(temp)
+            q.append(temp)
+        i += childCount
+    return root
+
+# Main
+arr = list(int(x) for x in stdin.readline().strip().split())
+tree = createLevelWiseTree(arr)
+print(maxSumNode(tree))
diff --git a/NodesAtDepthK.py b/NodesAtDepthK.py
new file mode 100644
index 0000000..187221d
--- /dev/null
+++ b/NodesAtDepthK.py
@@ -0,0 +1,49 @@
+class BinaryTreeNode:
+    def __init__(self,data):
+        self.data = data
+        self.left = None
+        self.right = None
+def treeInput():
+    rootData = int(input())
+    if rootData == -1:
+        return None
+    root = BinaryTreeNode(rootData)
+    leftTree = treeInput()
+    rightTree = treeInput()
+    root.left = leftTree
+    root.right = rightTree
+    return root
+
+def PrintTree(root):
+    if root == None:
+        return
+    print(root.data,end= ":")
+    if root.left is not None:
+        print("L", root.left.data, end = ",")
+    if root.right is not None:
+        print("R", root.right.data, end = "")
+    print()
+    PrintTree(root.left)
+    PrintTree(root.right)
+#Approach 1
+def PrintDepthK(root,k):
+    if root is None:
+        return
+    if k == 0:
+        print(root.data)
+        return
+    PrintDepthK(root.left,k-1)
+    PrintDepthK(root.right,k-1)
+#Approach 2
+def PrintDepthKv2(root,k,d = 0):
+    if root is None:
+        return
+    if k == d:
+        print(root.data)
+        return
+    PrintDepthKv2(root.left,k,d+1)
+    PrintDepthKv2(root.right,k,d+1)
+
+root = treeInput()
+PrintTree(root)
+PrintDepthKv2(root,2)
diff --git a/Python_Script/password_generator.py b/Python_Script/password_generator.py
new file mode 100644
index 0000000..ac73caa
--- /dev/null
+++ b/Python_Script/password_generator.py
@@ -0,0 +1,29 @@
+import string, random
+
+if __name__ == '__main__':
+    s1 = string.ascii_lowercase
+    s2 = string.ascii_uppercase
+    s3 = string.digits
+    s4 = string.punctuation
+
+    while True:
+        a = input("Enter password length\n") # handle gibberish(anything is entered except int)
+        b = a.isdigit()
+        if b==True:
+            plen= int(a)
+            break
+        else:
+            print("Invalid value! Please enter the valid value")
+
+    s = []
+    s.extend(list(s1))
+    s.extend(list(s2))
+    s.extend(list(s3))
+    s.extend(list(s4))
+    
+    random.shuffle(s)
+
+    print("".join(s[0:plen])) 
+    # The string whose method is called is inserted in between each given string. 
+    # The result is returned as a new string.
+    # Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
diff --git a/Simple Linear Regression.ipynb b/Simple Linear Regression.ipynb
new file mode 100644
index 0000000..6f7f68d
--- /dev/null
+++ b/Simple Linear Regression.ipynb	
@@ -0,0 +1,605 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7e890180",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "42312531",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.model_selection import train_test_split "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f7fec88",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "6d497591",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>age</th>\n",
+       "      <th>distance</th>\n",
+       "      <th>YearsExperience</th>\n",
+       "      <th>Salary</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>31.1</td>\n",
+       "      <td>77.75</td>\n",
+       "      <td>1.1</td>\n",
+       "      <td>39343</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>31.3</td>\n",
+       "      <td>78.25</td>\n",
+       "      <td>1.3</td>\n",
+       "      <td>46205</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>31.5</td>\n",
+       "      <td>78.75</td>\n",
+       "      <td>1.5</td>\n",
+       "      <td>37731</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>32.0</td>\n",
+       "      <td>80.00</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>43525</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>32.2</td>\n",
+       "      <td>80.50</td>\n",
+       "      <td>2.2</td>\n",
+       "      <td>39891</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    age  distance  YearsExperience  Salary\n",
+       "0  31.1     77.75              1.1   39343\n",
+       "1  31.3     78.25              1.3   46205\n",
+       "2  31.5     78.75              1.5   37731\n",
+       "3  32.0     80.00              2.0   43525\n",
+       "4  32.2     80.50              2.2   39891"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# load dataset\n",
+    "df = pd.read_csv(\"ml_data_salary.csv\")\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "c01ec834",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = df.drop(['age'], axis = 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "7687b1eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>YearsExperience</th>\n",
+       "      <th>Salary</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.1</td>\n",
+       "      <td>39343</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1.3</td>\n",
+       "      <td>46205</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.5</td>\n",
+       "      <td>37731</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2.0</td>\n",
+       "      <td>43525</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2.2</td>\n",
+       "      <td>39891</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   YearsExperience  Salary\n",
+       "0              1.1   39343\n",
+       "1              1.3   46205\n",
+       "2              1.5   37731\n",
+       "3              2.0   43525\n",
+       "4              2.2   39891"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = df.drop(['distance'], axis = 1)\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "5c6b8109",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = df[['YearsExperience']];\n",
+    "y = df['Salary']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "595ce83e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>YearsExperience</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1.3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2.2</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   YearsExperience\n",
+       "0              1.1\n",
+       "1              1.3\n",
+       "2              1.5\n",
+       "3              2.0\n",
+       "4              2.2"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "80fc04f4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0    39343\n",
+       "1    46205\n",
+       "2    37731\n",
+       "3    43525\n",
+       "4    39891\n",
+       "Name: Salary, dtype: int64"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "d8d9eb64",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=1/5, random_state=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "0bd39c96",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "LinearRegression()"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from sklearn.linear_model import LinearRegression\n",
+    "reg = LinearRegression().fit(X_train,y_train)\n",
+    "reg"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "1a8f2414",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred = reg.predict(X_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "dc45b5c5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 40748.96184072, 122699.62295594,  64961.65717022,  63099.14214487,\n",
+       "       115249.56285456, 107799.50275317])"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y_pred"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "1903fff8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x13811d81a90>]"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAD4CAYAAADy46FuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAhQUlEQVR4nO3deXhV5bn38e/NaNBiVNQDQd+gIjigohG1TjiCYivHoy2dpJbW6qXVWqWC1WptlfjaqrWt9qVOaHsUSj1oi4gUVKpFNBRHBOWFiAkoKINoAQnc54+9Evba2dkZ9rD28PtcV67sde+1Vp7kUn77Wc96nmXujoiISEs6Rd0AERHJbwoKERFJSUEhIiIpKShERCQlBYWIiKTUJeoGZFqvXr28srIy6maIiBSUBQsWfOTueyZ7r+iCorKykpqamqibISJSUMzsvZbe06UnERFJSUEhIiIpKShERCQlBYWIiKSkoBARkZQUFCIikpKCQkREUlJQiIgUgQdfXM7CFeuycu6im3AnIlJKFn/wCcPv+gcAh/XdlScvPyHjP0NBISJSgNyd0Q++wtx31gCwU9dOTL74uKz8LAWFiEiBqaldy/m/n9e0/ftvHsnwQ3tn7ecpKERECkTDtu2MuPsFlny4EYB+vXbmmatOYvrrqzi+eg4r12+iT3kZY4cNYOTgioz9XAWFiEgBmP32h4yZtGPB00e/dyzH7b8H0xbWM/7xN9i0dRsA9es3Mf7xNwAyFhYKChGRPLZ56zaOuXU2GzZtBeCYfrvz6PeOpVMnA+D2mUuaQqLRpq3buH3mEgWFiEix+8uCOq7+82tN23/7wQkcWrFraJ+V6zclPbaleke0Oo/CzB4ws9Vm9mZc7XYzW2xmr5vZ/5hZedx7481sqZktMbNhcfWjzOyN4L27zcyCenczmxzU55tZZdwxo83s3eBrdKZ+aRGRfPbJ5q1UjpveFBJfPrwPtdUjmoUEQJ/ysqTnaKneEW2ZcPcQMDyhNgs41N0PA94BxgOY2cHAKOCQ4Jh7zKxzcMy9wMVA/+Cr8ZxjgHXufgBwJ3BbcK7dgRuBY4AhwI1mtlv7f0URkcLxh7nLOOymZ5q2n7tmKHd/bXCL+48dNoCyrp1DtbKunRk7bEDG2tTqpSd3nxv/KT+oPRO3+RJwfvD6XOAxd98CLDezpcAQM6sFerr7PAAzexgYCcwIjrkpOH4q8NugtzEMmOXua4NjZhELl0fb/VuKiOS51Rs3M+SW2U3bY07oxw3nHNzqcY3jELfPXJLXdz19B5gcvK4gFhyN6oLa1uB1Yr3xmPcB3L3BzDYAe8TXkxwjIlI0bn3qbSbOXda0/fJ1p7FXz53afPzIwRUZDYZEaQWFmf0EaAD+1FhKspunqHf0mMR2XEzsshb77rtvihaLiOSPFR//m5Nuf7Zp+9rhA7l06P4Rtii5DgdFMLh8DnCauzf+A14H7BO3W19gZVDvm6Qef0ydmXUBdgXWBvWhCcc8l6wt7j4RmAhQVVWVNExERPLJDx9byLRXVzZtv3bjmexa1jXCFrWsQ6vHmtlw4Frgy+7+77i3ngRGBXcy9SM2aP2yu68CNprZscH4w4XAE3HHNN7RdD4wJwiemcCZZrZbMIh9ZlATESlYi1Z+QuW46U0h8X//6zBqq0fkbUhAG3oUZvYosU/2vcysjtidSOOB7sCs4C7Xl9z9End/y8ymAIuIXZK6zN0bZ4JcSuwOqjJig9gzgvr9wCPBwPdaYndN4e5rzeznwCvBfjc3DmyLiBQad+frf5jPvGUfA/CFnbrwyk9OZ6eEO5byke24alQcqqqqvKampvUdRURy5KVlHzNq4o77fP5wYRVnHLx3hC1qzswWuHtVsvc0M1tEJEsatm3nzDvnsuyjzwA4YK9dePrKE+nSubCeGaegEBHJgplvfcD3H1nQtD3l+8cxpN/uEbao4xQUIiIZ9OmWBg69ccd9N8cfsAd/HHMMwXhuQVJQiIhkyI1PvMmkee81bc+48kQO6t0zwhZlhoJCRCRNqz/ZzJBbdyy/sUv3Lrz5s2EpjigsCgoRkTR856FXmLN4ddN2sqXAC52CQkTy1rSF9Vld7C4dy9Z8yqm/er5p+9CKnvztBydG2KLsUVCISF7KxSM+O+r0O55n6epPm7bnjj2FfffoEWGLsktBISJ5KReP+GyvhSvW8Z/3/LNp++xB/8E93zgqtE8+94I6SkEhInkpF4/4bCt354CfzGDb9h0rWSy4/nT22KV7aL987gWlo7CmB4pIycjFIz7bYs7iD+k3/qmmkPjeif2orR7RLCQgdS+okKlHISJ5aeywAaFP55D5R3ymsn27s991T4Vqi24eRo9uLf+zmU+9oExSUIhIXsrFIz5bMuWV9/nxX15v2r7hnIMZc0K/Vo/rU15GfZJQyHUvKNMUFCKSt7L9iM9EWxq2MeD6p0O1d285i65tXMQv6l5QtigoRESA38x+l1/NemfH9tcG86XD+7TrHFH2grJJQSEiJS1x+Q2A5RPO7vAifrnuBeWCgkJESlbluOmh7T999xiOP6BXRK3JXwoKESk5Sz7YyLC75oZqtdUjImpN/lNQiEhJSexF5ONjSfONgkJESsI/3l3Dt+5/OVRTL6JtFBQiUvQSexFPXn48h/Utj6YxBUhBISJFa0rN+/x46uuhmnoR7aegEJGi4+70Gx9efuOFa0+h727FuxR4NikoRKSo3D5zMb979v83bffdrYwXrj01whYVPgWFiBSFrdu20/8nM0K11248k13LuqY8rhifH5FpCgoRKXiXPLKAp9/6oGn79IP24r7RR7d6XLE+PyLTFBQiUrA2bt7KoJueCdXe+cVZdOvStkX88vEpevlIQSEiBemUXz7H8o8+a9q+5OT9GXfWwHado1ifH5FpCgoRKSgr12/ii9VzQrWOLuJXrM+PyDQFhYgUjMSJcxPOG8TXhuzb4fMV6/MjMk1BISJ57836DZzzmxdCtUxMnCvW50dkmoJCRPJaYi/ioYuOZuiAvTJ2/mJ8fkSmKShEJC/98aX3uH7am6Galt+IhoJCRPJOYi/ir5efwKC+u0bUGlFQiEjOtTQb+sYn3mTSvPdC+6oXET1z96jbkFFVVVVeU1MTdTNEpAWJs6EBdurSic0N20P7zbn6ZPbbc5dcN69kmdkCd69K9p56FCKSU8lmQyeGhHoR+aXVee5m9oCZrTazN+Nqu5vZLDN7N/i+W9x7481sqZktMbNhcfWjzOyN4L27LZgdY2bdzWxyUJ9vZpVxx4wOfsa7ZjY6Y7+1iEQm1aznV396hkIiD7VlQZSHgOEJtXHAbHfvD8wOtjGzg4FRwCHBMfeYWefgmHuBi4H+wVfjOccA69z9AOBO4LbgXLsDNwLHAEOAG+MDSUQKU0uznivKyyjv0S3HrZG2aDUo3H0usDahfC4wKXg9CRgZV3/M3be4+3JgKTDEzHoDPd19nscGRR5OOKbxXFOB04LexjBglruvdfd1wCyaB5aIFJC6df9OumSGZkPnt46OUezt7qsA3H2VmTXOfqkAXorbry6obQ1eJ9Ybj3k/OFeDmW0A9oivJzkmxMwuJtZbYd99Oz6dX0SyJ/GW104G7mg2dAHI9GB2slW5PEW9o8eEi+4TgYkQu+up9WaKSDLZeIhPTe1azv/9vFCto4v4STQ6GhQfmlnvoDfRG1gd1OuAfeL26wusDOp9k9Tjj6kzsy7ArsQuddUBQxOOea6D7RWRVmTjIT6JvYgRg3rzu28cmV5DJefa9nSP5p4EGu9CGg08EVcfFdzJ1I/YoPXLwWWqjWZ2bDD+cGHCMY3nOh+YE4xjzATONLPdgkHsM4OaiGRBqof4tNeUmvebhURt9QiFRIFqtUdhZo8S+2Tfy8zqiN2JVA1MMbMxwArgAgB3f8vMpgCLgAbgMndv/C/vUmJ3UJUBM4IvgPuBR8xsKbGexKjgXGvN7OfAK8F+N7t74qC6iGRIph7ikxgQ484ayCUn79/hdkn0Wg0Kd/9aC2+d1sL+twC3JKnXAIcmqW8mCJok7z0APNBaG0Ukfek+xOdnf32LB1+sDdU0J6I4aGa2iADpPcQnsRfxwLerOHXg3hlvo0RDQSEiQMce4nPu717ktffXh2rqRRQfBYWINGnrQ3y2bXf2v+6pUO2Zq07iwL2/kK2mSYQUFCLSLomXmUC9iGKnoBCJUDYmuGXLxs1bGXTTM6HawhvOYLedtT5TsVNQiEQkGxPcskW9iNKmoBCJSKoJbvkSFO99/Bkn3/5cqPbuLWfRtXNH5+pKIVJQiEQkUxPcsiWxF9Gv1848e83QaBojkVJQiEQk3Qlu2fLPpR/x9fvmh2q6zFTaFBQiEUlnglt7tXXQPLEXccFRfbn9gsMz3h4pLAoKkYh0ZIJbR7Rl0PyOWe9w9+x3Q8epFyGNFBQiEWrrBLd0tDZontiLuPyUA7hGT5uTOAoKkSLX0uB4/fpNSZcCF0mkoBApci0Nmse79xtHctag3jlqkRQa3QwtUuTGDhtAWdfOLb5fWz1CISEpqUchUuRGDq5g23bn6j+/Fqo//cMTGfgfPSNqlRQSBYVIkdPyG5IuBYVIkfro0y1U/eLvoZoW8ZOOUFCIFCH1IiSTFBQiReTN+g2c85sXQrWlt5xFFy3iJ2lQUIgUicReRJdOxtJbz46oNVJMFBQiBe6JV+u58rFXQzVdZpJMUlCIFLDEXsSpA/figW8fHVFrpFgpKEQK0C3TF/GHfywP1dSLkGxRUIgUmMRexNhhA7jslAMiao2UAgWFSIH48m9f4PW6DaGaehGSCwoKkTzn7vQb/1So9uC3j+aUgXtF1CIpNQoKkTymiXOSDxQUInlo89ZtDLzh6VBtztUns9+eu0TUIillCgqRNmjrM6czQb0IyTcKCpFWtOWZ05nwwYbNHDthdqj2+k1n0nOnrhn7GSIdoaAQaUVrz5zOBPUiJJ8pKERa0dIzp1uqt8eLSz/iG/fND9WW3Xo2nTpZ2ucWyRQFhUgrWnrmdJ/ysg6dr3G8I/Gce+zcjQU3nNGhc4pkk9YeFmlFsmdOl3XtzNhhA9p9rmkL67nmz681C4m7vnqEQkLyloJCpBUjB1cw4bxBVJSXYUBFeRkTzhvUofGJH05+lYbt3qx++8wlGWipSHakdenJzK4Cvgs48AZwEdADmAxUArXAV9x9XbD/eGAMsA24wt1nBvWjgIeAMuAp4Ep3dzPrDjwMHAV8DHzV3WvTabNIR4wcXJHWwPV3HnqFOYtXt/h+JsY7RLKlwz0KM6sArgCq3P1QoDMwChgHzHb3/sDsYBszOzh4/xBgOHCPmTX25+8FLgb6B1/Dg/oYYJ27HwDcCdzW0faKRKVy3PSUIQEdH+8QyYV0Lz11AcrMrAuxnsRK4FxgUvD+JGBk8Ppc4DF33+Luy4GlwBAz6w30dPd57u7EehDxxzSeaypwmpnpdhApCJXjpje77fWurx6RsfEOkVzp8KUnd683s18CK4BNwDPu/oyZ7e3uq4J9VplZ48plFcBLcaeoC2pbg9eJ9cZj3g/O1WBmG4A9gI/i22JmFxPrkbDvvvt29FcSyYhki/jdd2EVpx+8d9N2rmZ5i2RCh4PCzHYj9om/H7Ae+LOZfTPVIUlqnqKe6phwwX0iMBGgqqqq+UihSI60ZeJcuuMdIrmWzmD26cByd18DYGaPA18EPjSz3kFvojfQeHG2Dtgn7vi+xC5V1QWvE+vxx9QFl7d2Bdam0WaRrPh0SwOH3jgzVJt99cnsr0X8pAikExQrgGPNrAexS0+nATXAZ8BooDr4/kSw/5PAf5vZHUAfYoPWL7v7NjPbaGbHAvOBC4HfxB0zGpgHnA/MCcYxRPKGlt+QYpfOGMV8M5sK/AtoABYSu/yzCzDFzMYQC5MLgv3fMrMpwKJg/8vcvXEBnUvZcXvsjOAL4H7gETNbSqwnMaqj7RXJtGVrPuXUXz0fqr35s2Hs0l0LHkhxsWL7gF5VVeU1NTVRN0OKnHoRUmzMbIG7VyV7Tx99RNrh74s+5LsPhz+ILJ9wNrprW4qZgkKkjdSLkFKloBBpxR2z3uHu2e+GagoIKSUKCpEUEnsRQwfsyUMXDYmoNSLRUFCIJHHB7//JK7XrQjX1IqRUKShEEiT2Iq4dPpBLh+4fUWtEoqegEAlosFokOQWFlLxt2539rwsv4vfImCGc2H/PiFokkl8UFFLS1IsQaZ2CQkrSus8+Z/DPZ4Vqz14zlH69do6oRSL5S0EhJUe9CJH2UVBIyXijbgNf+u0Lodqim4fRo5v+NxBJRf+HSElQL0Kk4xQUUtQmv7KCa//yRqimRfxE2kdBIUVLvQiRzFBQSNH50eRXeXxhfaimgBDpOAWFFJXEXsSQfrsz5fvHRdQakeKgoJCiMOjGmWzc0hCqqRchkhkKCil4ib2Ia848kMtP7d/i/tMW1nP7zCWsXL+JPuVljB02gJGDK7LdTJGCpaCQgtWRweppC+sZ//gbbNq6DYD69ZsY/3jsriiFhUhynaJugEh7bd22vVlI/HHMMW261HT7zCVNIdFo09Zt3D5zSUbbKFJM1KOQgpLuLa8r129qV11EFBRSIFZv3MyQW2aHai+OO5WK8rJ2nadPeRn1SUKhT3mZxi5EWqCgkLyXyYlzY4cNCI1RAJR17cwpA/fU2IVICzRGIXnrldq1zUJiyS+Gp3Xb68jBFUw4bxAV5WUYUFFexoTzBvHs4jUauxBpgXoUkpeyufzGyMEVzXoJV01+Nem+GrsQUVBIC6K6Xv/AC8u5+W+LQrVcTJxLNXYhUuoUFNJMVHMNolzEr6Wxi7HDBuTk54vkMwWFNJNqrkE2guK7k17h72+vDtVyvfxG4++lu55EmlNQSDO5nGuQ2Is4/aC9uG/00Rn/OW2RbOxCRBQUkkQurtcPv2suiz/YGKppET+R/KTbY6WZscMGUNa1c6iWyev1leOmh0Li7q8NVkiI5DH1KKSZbF2v1xPnRAqTgkKSyuT1+s8btnPg9TNCtelXnMAhfXbNyPlFJLsUFJJV2e5FaH0mkexTUEhWrP5kM0NuDS/it/CGM9ht524Z+xl6toRIbqQ1mG1m5WY21cwWm9nbZnacme1uZrPM7N3g+25x+483s6VmtsTMhsXVjzKzN4L37jYzC+rdzWxyUJ9vZpXptFfCpi2s5/jqOfQbN53jq+cwbWF9Rs5bOW56s5CorR6R0ZAAPVtCJFfSvevp18DT7j4QOBx4GxgHzHb3/sDsYBszOxgYBRwCDAfuMbPGW2vuBS4G+gdfw4P6GGCdux8A3AnclmZ7JdD4abx+/SacHZ/G0wmLf61Y1+xS09JbzsragLWeLSGSGx0OCjPrCZwE3A/g7p+7+3rgXGBSsNskYGTw+lzgMXff4u7LgaXAEDPrDfR093nu7sDDCcc0nmsqcFpjb0PSk+lP45XjpnPePf8M1WqrR9Clc/buwG5pXofWZxLJrHT+L94PWAM8aGYLzew+M9sZ2NvdVwEE3/cK9q8A3o87vi6oVQSvE+uhY9y9AdgA7JHYEDO72MxqzKxmzZo1afxKpSNTn8Ynv7KiWS+itnpETm57zfZ8DxGJSWcwuwtwJPADd59vZr8muMzUgmQ9AU9RT3VMuOA+EZgIUFVV1ex9aS4Ts68TA2JIv92Z8v3j0m5bW2l9JpHcSCco6oA6d58fbE8lFhQfmllvd18VXFZaHbf/PnHH9wVWBvW+Serxx9SZWRdgV2BtGm2WQDqrpV479XUm17wfqkU1cU7rM4lkX4eDwt0/MLP3zWyAuy8BTgMWBV+jgerg+xPBIU8C/21mdwB9iA1av+zu28xso5kdC8wHLgR+E3fMaGAecD4wJxjHkDR19NN4Yi/iitP686MzDmy2n+Y3iBSPdOdR/AD4k5l1A5YBFxEb95hiZmOAFcAFAO7+lplNIRYkDcBl7t74cfZS4CGgDJgRfEFsoPwRM1tKrCcxKs32Spz2fBr/4oTZrNywOVRrqRfRnvkNChSR/GfF9gG9qqrKa2pqom5G3mrvP8zuTr/xT4VqE791FGce8h8tHnN89Zyk4x8V5WW8OO7UUFuSXf6acN4ghYVIjpnZAnevSvaeZmaXkPbOZO7o8httvaMq1w9IEpGO0TLjJaStcyc+b9jeLCT+/qOT2jxg3db5DZowJ1IY1KMoIW35hzkTi/i19Y6q8h5dWffvrc2OL+/RtV0/T0SyS0FRQlLNnVj72ecc+fNZofrbNw+nrFvnZvu3pq13VLU0PFZkw2YiBU9BUUJa+qRfv35TKCQqgn/YT7/j+Q7fjdSWO6o2bGrem0hVF5FoKChKSOIn/T2/0J3VG7eE9ll269k8+drKnCzfnYtnc4tI+jSYXWJGDq7gxXGn4hAKiXMO601t9Qg6dbKcLd+ttZpECoN6FCVm4Yp1/GeSVV7j5epuJK3VJFIYFBQlJPGOpmuHD+TSofs32y+Xl4S0VpNI/tOlpxIw/fVVSZcCTxYSoEtCIhKmHkWRSwyIP19yHEdX7p7yGF0SEpF4Cooi9btnlzYbfG7PxDldEhKRRgqKIpNsEb/nrhlKZa+dI2qRiBQ6BUURuWryq/zPwvpQLaoHColI8VBQFIEtDdsYcP3TodqrPz2D8h7dImqRiBQTBUWBG3bnXJZ8uLFp+6DePZlx5YkRtkhEio2CokCt//fnHHFzeBG/d35xFt266I5nEcksBUUBSrzl9bwjK7jjK0dE0xgRKXoKigJS+9FnDP3lc6Ha8glnY2bRNEhESoKCokAk9iLGnTWQS05OPrNaRCSTFBR57uXla/nK/5sXqumWVxHJJQVFHkvsRdz7jSM5a1DviFojIqVKQdGKaQvrc77mkXoRIpJPFBQpTFtYn5MnvcVL7EVMu+x4jtinPCs/S0SkLXTTfQq5etIbwN9eXxkKiYN796S2eoRCQkQipx5FCrl40luyRfwWXH86e+zSPWM/Q0QkHepRpNDSE90y9aS3P8xdFgqJLx3eh9rqEQoJEckr6lGkMHbYgNAYBWTmSW+fN2znwOtnhGpv3zycsm6dWzhCRCQ66lGkMHJwBRPOG0RFeRkGVJSXMeG8QWkNZP/0iTdDIfGF7l0w4PQ7nmdawhLhIiL5QD2KVmTqSW8bN29l0E3PhGo7denExi0NQG7uqBIR6Qj1KHLgW/fPD4VEYy9lc8P20H7ZuqNKRCQd6lFk0aoNmzhuwpxQrXERv+uC3kOiTN5RJSKSCQqKLDluwmxWbdjctP3gRUdzyoC9mrb7lJdRnyQUMnVHlYhIpujSU4Yt/uATKsdND4VEbfWIUEhA7I6qsq7hu5wycUeViEimqUeRQYnLb/z18hMY1HfXpPs2Dljneh0pEZH2UlBkwD+XfsTX75vftP2F7l1442fDWj0uU3dUiYhkU9pBYWadgRqg3t3PMbPdgclAJVALfMXd1wX7jgfGANuAK9x9ZlA/CngIKAOeAq50dzez7sDDwFHAx8BX3b023TZnUmIv4h8/PoV9du+R1jmjWLFWRKQlmRijuBJ4O257HDDb3fsDs4NtzOxgYBRwCDAcuCcIGYB7gYuB/sHX8KA+Bljn7gcAdwK3ZaC9GTFtYX0oJI7ct5za6hEZCYnxj79B/fpNODvmV2gynohEJa0ehZn1BUYAtwA/CsrnAkOD15OA54Brg/pj7r4FWG5mS4EhZlYL9HT3ecE5HwZGAjOCY24KzjUV+K2Zmbt7Ou1Opq2f4rdvd/a7LryI36s/PYPyHt0y0o5UK9aqVyEiUUi3R3EX8GMgfubY3u6+CiD43ni7TwXwftx+dUGtInidWA8d4+4NwAZgj8RGmNnFZlZjZjVr1qxp9y/R1k/xv3t2aSgk/uvIvtRWj8hYSEBuVqwVEWmPDvcozOwcYLW7LzCzoW05JEnNU9RTHRMuuE8EJgJUVVW1u7fR2qf4LQ3bGHD906H3F/98ODt1zfwifppfISL5Jp0exfHAl4NLR48Bp5rZH4EPzaw3QPB9dbB/HbBP3PF9gZVBvW+SeugYM+sC7AqsTaPNSaX6FD9r0YehkPjRGQdSWz0iKyEBml8hIvmnw0Hh7uPdva+7VxIbpJ7j7t8EngRGB7uNBp4IXj8JjDKz7mbWj9ig9cvB5amNZnasmRlwYcIxjec6P/gZGR+fSPVp/XsP1zS9Xnbr2VxxWv9M//iQbKxYKyKSjmzMo6gGppjZGGAFcAGAu79lZlOARUADcJm7N17vuZQdt8fOCL4A7gceCQa+1xILpIxL9twJ2HGNa/oVJ3BIn+QT57JB8ytEJJ9YFj6gR6qqqsprampa3zHBtIX13DZjMas+2bH0xrlH9OHXowZnsnkiInnJzBa4e1Wy97TWU+BLh/cJhcTzY4cqJERE0BIeTToZfPeEfnTuZIw/+6ComyMikjcUFHGuP+fgqJsgIpJ3dOkpELvhSkREEikoREQkJQWFiIikpKAQEZGUFBQiIpKSgkJERFJSUIiISEoKChERSano1noyszXAe1G3o516AR9F3YiIlfrfoNR/f9DfAKL9G/wfd98z2RtFFxSFyMxqWlqMq1SU+t+g1H9/0N8A8vdvoEtPIiKSkoJCRERSUlDkh4lRNyAPlPrfoNR/f9DfAPL0b6AxChERSUk9ChERSUlBISIiKSkoImJm+5jZs2b2tpm9ZWZXRt2mqJhZZzNbaGZ/i7otUTCzcjObamaLg/8ejou6TblmZlcF/x+8aWaPmtlOUbcp28zsATNbbWZvxtV2N7NZZvZu8H23KNvYSEERnQbganc/CDgWuMzMSvURe1cCb0fdiAj9Gnja3QcCh1NifwszqwCuAKrc/VCgMzAq2lblxEPA8ITaOGC2u/cHZgfbkVNQRMTdV7n7v4LXG4n941ARbatyz8z6AiOA+6JuSxTMrCdwEnA/gLt/7u7rI21UNLoAZWbWBegBrIy4PVnn7nOBtQnlc4FJwetJwMhctqklCoo8YGaVwGBgfsRNicJdwI+B7RG3Iyr7AWuAB4PLb/eZ2c5RNyqX3L0e+CWwAlgFbHD3Z6JtVWT2dvdVEPswCewVcXsABUXkzGwX4C/AD939k6jbk0tmdg6w2t0XRN2WCHUBjgTudffBwGfkyeWGXAmuw58L9AP6ADub2TejbZXEU1BEyMy6EguJP7n741G3JwLHA182s1rgMeBUM/tjtE3KuTqgzt0be5NTiQVHKTkdWO7ua9x9K/A48MWI2xSVD82sN0DwfXXE7QEUFJExMyN2Xfptd78j6vZEwd3Hu3tfd68kNng5x91L6pOku38AvG9mA4LSacCiCJsUhRXAsWbWI/j/4jRKbEA/zpPA6OD1aOCJCNvSpEvUDShhxwPfAt4ws1eD2nXu/lR0TZKI/AD4k5l1A5YBF0Xcnpxy9/lmNhX4F7G7AReSp0tZZJKZPQoMBXqZWR1wI1ANTDGzMcQC9ILoWriDlvAQEZGUdOlJRERSUlCIiEhKCgoREUlJQSEiIikpKEREJCUFhYiIpKSgEBGRlP4XGt33odji7XsAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.scatter(X_train, y_train)\n",
+    "plt.plot(X_train, reg.predict(X_train))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "ff2c4095",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x13811dd7bb0>]"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.scatter(X_test, y_test)\n",
+    "plt.plot(X_test, reg.predict(X_test))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f036c516",
+   "metadata": {},
+   "source": [
+    "We checl both tesmt and train both are linear so these are hwai baty now we will chek this by a score\n",
+    "m"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c6f53219",
+   "metadata": {},
+   "source": [
+    "# Testing and evaluation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b429237",
+   "metadata": {},
+   "source": [
+    "Model Fitness"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "bb885ed9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.988169515729126"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "reg.score(X_test, y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "f932693e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9411949620562126"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "reg.score(X_train, y_train)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "382eb6c8",
+   "metadata": {},
+   "source": [
+    "# Prediction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "f12db637",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([73342.97478427])"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "reg.predict([[5]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "667d62e6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 73342.97478427, 119905.85041792, 166468.72605157])"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "reg.predict([[5],[10],[15]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "04fe24c8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/python/BMI_Calculator.py b/python/BMI_Calculator.py
new file mode 100644
index 0000000..67c337a
--- /dev/null
+++ b/python/BMI_Calculator.py
@@ -0,0 +1,19 @@
+h=float(input("Enter your height in meters: "))
+w=float(input("Enter your Weight in Kg: "))
+
+BMI=w/(h*h)
+print("BMI Calculated is:  ",BMI)
+
+if(BMI>0):
+	if(BMI<=16):
+		print("You are very underweight")
+	elif(BMI<=18.5):
+		print("You are underweight")
+	elif(BMI<=25):
+		print("Congrats! You are Healthy")
+	elif(BMI<=30):
+		print("You are overweight")
+	else: 
+        print("You are very overweight")
+else:
+    print("enter valid details")
diff --git a/python/floppybird.py b/python/floppybird.py
new file mode 100644
index 0000000..895207e
--- /dev/null
+++ b/python/floppybird.py
@@ -0,0 +1,222 @@
+import random # For generating random numbers
+import sys # We will use sys.exit to exit the program
+import pygame
+from pygame.locals import * # Basic pygame imports
+
+# Global Variables for the game
+FPS = 32
+SCREENWIDTH = 289
+SCREENHEIGHT = 511
+SCREEN = pygame.display.set_mode((SCREENWIDTH, SCREENHEIGHT))
+GROUNDY = SCREENHEIGHT * 0.8
+GAME_SPRITES = {}
+GAME_SOUNDS = {}
+PLAYER = 'gallery/sprites/bird.png'
+BACKGROUND = 'gallery/sprites/background.png'
+PIPE = 'gallery/sprites/pipe.png'
+
+def welcomeScreen():
+    """
+    Shows welcome images on the screen
+    """
+
+    playerx = int(SCREENWIDTH/5)
+    playery = int((SCREENHEIGHT - GAME_SPRITES['player'].get_height())/2)
+    messagex = int((SCREENWIDTH - GAME_SPRITES['message'].get_width())/2)
+    messagey = int(SCREENHEIGHT*0.13)
+    basex = 0
+    while True:
+        for event in pygame.event.get():
+            # if user clicks on cross button, close the game
+            if event.type == QUIT or (event.type==KEYDOWN and event.key == K_ESCAPE):
+                pygame.quit()
+                sys.exit()
+
+            # If the user presses space or up key, start the game for them
+            elif event.type==KEYDOWN and (event.key==K_SPACE or event.key == K_UP):
+                return
+            else:
+                SCREEN.blit(GAME_SPRITES['background'], (0, 0))    
+                SCREEN.blit(GAME_SPRITES['player'], (playerx, playery))    
+                SCREEN.blit(GAME_SPRITES['message'], (messagex,messagey ))    
+                SCREEN.blit(GAME_SPRITES['base'], (basex, GROUNDY))    
+                pygame.display.update()
+                FPSCLOCK.tick(FPS)
+
+def mainGame():
+    score = 0
+    playerx = int(SCREENWIDTH/5)
+    playery = int(SCREENWIDTH/2)
+    basex = 0
+
+    # Create 2 pipes for blitting on the screen
+    newPipe1 = getRandomPipe()
+    newPipe2 = getRandomPipe()
+
+    # my List of upper pipes
+    upperPipes = [
+        {'x': SCREENWIDTH+200, 'y':newPipe1[0]['y']},
+        {'x': SCREENWIDTH+200+(SCREENWIDTH/2), 'y':newPipe2[0]['y']},
+    ]
+    # my List of lower pipes
+    lowerPipes = [
+        {'x': SCREENWIDTH+200, 'y':newPipe1[1]['y']},
+        {'x': SCREENWIDTH+200+(SCREENWIDTH/2), 'y':newPipe2[1]['y']},
+    ]
+
+    pipeVelX = -4
+
+    playerVelY = -9
+    playerMaxVelY = 10
+    playerMinVelY = -8
+    playerAccY = 1
+
+    playerFlapAccv = -8 # velocity while flapping
+    playerFlapped = False # It is true only when the bird is flapping
+
+
+    while True:
+        for event in pygame.event.get():
+            if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
+                pygame.quit()
+                sys.exit()
+            if event.type == KEYDOWN and (event.key == K_SPACE or event.key == K_UP):
+                if playery > 0:
+                    playerVelY = playerFlapAccv
+                    playerFlapped = True
+                    GAME_SOUNDS['wing'].play()
+
+
+        crashTest = isCollide(playerx, playery, upperPipes, lowerPipes) # This function will return true if the player is crashed
+        if crashTest:
+            return     
+
+        #check for score
+        playerMidPos = playerx + GAME_SPRITES['player'].get_width()/2
+        for pipe in upperPipes:
+            pipeMidPos = pipe['x'] + GAME_SPRITES['pipe'][0].get_width()/2
+            if pipeMidPos<= playerMidPos < pipeMidPos +4:
+                score +=1
+                print(f"Your score is {score}") 
+                GAME_SOUNDS['point'].play()
+
+
+        if playerVelY <playerMaxVelY and not playerFlapped:
+            playerVelY += playerAccY
+
+        if playerFlapped:
+            playerFlapped = False            
+        playerHeight = GAME_SPRITES['player'].get_height()
+        playery = playery + min(playerVelY, GROUNDY - playery - playerHeight)
+
+        # move pipes to the left
+        for upperPipe , lowerPipe in zip(upperPipes, lowerPipes):
+            upperPipe['x'] += pipeVelX
+            lowerPipe['x'] += pipeVelX
+
+        # Add a new pipe when the first is about to cross the leftmost part of the screen
+        if 0<upperPipes[0]['x']<5:
+            newpipe = getRandomPipe()
+            upperPipes.append(newpipe[0])
+            lowerPipes.append(newpipe[1])
+
+        # if the pipe is out of the screen, remove it
+        if upperPipes[0]['x'] < -GAME_SPRITES['pipe'][0].get_width():
+            upperPipes.pop(0)
+            lowerPipes.pop(0)
+        
+        # Lets blit our sprites now
+        SCREEN.blit(GAME_SPRITES['background'], (0, 0))
+        for upperPipe, lowerPipe in zip(upperPipes, lowerPipes):
+            SCREEN.blit(GAME_SPRITES['pipe'][0], (upperPipe['x'], upperPipe['y']))
+            SCREEN.blit(GAME_SPRITES['pipe'][1], (lowerPipe['x'], lowerPipe['y']))
+
+        SCREEN.blit(GAME_SPRITES['base'], (basex, GROUNDY))
+        SCREEN.blit(GAME_SPRITES['player'], (playerx, playery))
+        myDigits = [int(x) for x in list(str(score))]
+        width = 0
+        for digit in myDigits:
+            width += GAME_SPRITES['numbers'][digit].get_width()
+        Xoffset = (SCREENWIDTH - width)/2
+
+        for digit in myDigits:
+            SCREEN.blit(GAME_SPRITES['numbers'][digit], (Xoffset, SCREENHEIGHT*0.12))
+            Xoffset += GAME_SPRITES['numbers'][digit].get_width()
+        pygame.display.update()
+        FPSCLOCK.tick(FPS)
+
+def isCollide(playerx, playery, upperPipes, lowerPipes):
+    if playery> GROUNDY - 25  or playery<0:
+        GAME_SOUNDS['hit'].play()
+        return True
+    
+    for pipe in upperPipes:
+        pipeHeight = GAME_SPRITES['pipe'][0].get_height()
+        if(playery < pipeHeight + pipe['y'] and abs(playerx - pipe['x']) < GAME_SPRITES['pipe'][0].get_width()):
+            GAME_SOUNDS['hit'].play()
+            return True
+
+    for pipe in lowerPipes:
+        if (playery + GAME_SPRITES['player'].get_height() > pipe['y']) and abs(playerx - pipe['x']) < GAME_SPRITES['pipe'][0].get_width():
+            GAME_SOUNDS['hit'].play()
+            return True
+
+    return False
+
+def getRandomPipe():
+    """
+    Generate positions of two pipes(one bottom straight and one top rotated ) for blitting on the screen
+    """
+    pipeHeight = GAME_SPRITES['pipe'][0].get_height()
+    offset = SCREENHEIGHT/3
+    y2 = offset + random.randrange(0, int(SCREENHEIGHT - GAME_SPRITES['base'].get_height()  - 1.2 *offset))
+    pipeX = SCREENWIDTH + 10
+    y1 = pipeHeight - y2 + offset
+    pipe = [
+        {'x': pipeX, 'y': -y1}, #upper Pipe
+        {'x': pipeX, 'y': y2} #lower Pipe
+    ]
+    return pipe
+
+
+
+
+
+
+if __name__ == "__main__":
+    # This will be the main point from where our game will start
+    pygame.init() # Initialize all pygame's modules
+    FPSCLOCK = pygame.time.Clock()
+    pygame.display.set_caption('Flappy Bird by CodeWithHarry')
+    GAME_SPRITES['numbers'] = ( 
+        pygame.image.load('gallery/sprites/0.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/1.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/2.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/3.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/4.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/5.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/6.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/7.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/8.png').convert_alpha(),
+        pygame.image.load('gallery/sprites/9.png').convert_alpha(),
+    )
+
+    GAME_SPRITES['message'] =pygame.image.load('gallery/sprites/message.png').convert_alpha()
+    GAME_SPRITES['base'] =pygame.image.load('gallery/sprites/base.png').convert_alpha()
+    GAME_SPRITES['pipe'] =(pygame.transform.rotate(pygame.image.load( PIPE).convert_alpha(), 180), 
+    pygame.image.load(PIPE).convert_alpha()
+    )
+
+    # Game sounds
+    GAME_SOUNDS['die'] = pygame.mixer.Sound('gallery/audio/die.wav')
+    GAME_SOUNDS['hit'] = pygame.mixer.Sound('gallery/audio/hit.wav')
+    GAME_SOUNDS['point'] = pygame.mixer.Sound('gallery/audio/point.wav')
+    GAME_SOUNDS['swoosh'] = pygame.mixer.Sound('gallery/audio/swoosh.wav')
+    GAME_SOUNDS['wing'] = pygame.mixer.Sound('gallery/audio/wing.wav')
+
+    GAME_SPRITES['background'] = pygame.image.load(BACKGROUND).convert()
+    GAME_SPRITES['player'] = pygame.image.load(PLAYER).convert_alpha()
+
+    while True:
+        welcomeScreen() # Shows welcome screen to the user until he presses a button
+        mainGame() # This is the main game function 
diff --git a/saam.c b/saam.c
new file mode 100644
index 0000000..4ff2033
--- /dev/null
+++ b/saam.c
@@ -0,0 +1,135 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#define SIZE 20
+
+struct DataItem {
+   int data;   
+   int key;
+};
+
+struct DataItem* hashArray[SIZE]; 
+struct DataItem* dummyItem;
+struct DataItem* item;
+
+int hashCode(int key) {
+   return key % SIZE;
+}
+
+struct DataItem *search(int key) {
+   //get the hash 
+   int hashIndex = hashCode(key);  
+	
+   //move in array until an empty 
+   while(hashArray[hashIndex] != NULL) {
+	
+      if(hashArray[hashIndex]->key == key)
+         return hashArray[hashIndex]; 
+			
+      //go to next cell
+      ++hashIndex;
+		
+      //wrap around the table
+      hashIndex %= SIZE;
+   }        
+	
+   return NULL;        
+}
+
+void insert(int key,int data) {
+
+   struct DataItem *item = (struct DataItem*) malloc(sizeof(struct DataItem));
+   item->data = data;  
+   item->key = key;
+
+   //get the hash 
+   int hashIndex = hashCode(key);
+
+   //move in array until an empty or deleted cell
+   while(hashArray[hashIndex] != NULL && hashArray[hashIndex]->key != -1) {
+      //go to next cell
+      ++hashIndex;
+		
+      //wrap around the table
+      hashIndex %= SIZE;
+   }
+	
+   hashArray[hashIndex] = item;
+}
+
+struct DataItem* delete(struct DataItem* item) {
+   int key = item->key;
+
+   //get the hash 
+   int hashIndex = hashCode(key);
+
+   //move in array until an empty
+   while(hashArray[hashIndex] != NULL) {
+	
+      if(hashArray[hashIndex]->key == key) {
+         struct DataItem* temp = hashArray[hashIndex]; 
+			
+         //assign a dummy item at deleted position
+         hashArray[hashIndex] = dummyItem; 
+         return temp;
+      }
+		
+      //go to next cell
+      ++hashIndex;
+		
+      //wrap around the table
+      hashIndex %= SIZE;
+   }      
+	
+   return NULL;        
+}
+
+void display() {
+   int i = 0;
+	
+   for(i = 0; i<SIZE; i++) {
+	
+      if(hashArray[i] != NULL)
+         printf(" (%d,%d)",hashArray[i]->key,hashArray[i]->data);
+      else
+         printf(" ~~ ");
+   }
+	
+   printf("\n");
+}
+
+int main() {
+   dummyItem = (struct DataItem*) malloc(sizeof(struct DataItem));
+   dummyItem->data = -1;  
+   dummyItem->key = -1; 
+
+   insert(1, 20);
+   insert(2, 70);
+   insert(42, 80);
+   insert(4, 25);
+   insert(12, 44);
+   insert(14, 32);
+   insert(17, 11);
+   insert(13, 78);
+   insert(37, 97);
+
+   display();
+   item = search(37);
+
+   if(item != NULL) {
+      printf("Element found: %d\n", item->data);
+   } else {
+      printf("Element not found\n");
+   }
+
+   delete(item);
+   item = search(37);
+
+   if(item != NULL) {
+      printf("Element found: %d\n", item->data);
+   } else {
+      printf("Element not found\n");
+   }
+}
diff --git a/space_game.py b/space_game.py
new file mode 100644
index 0000000..41d063e
--- /dev/null
+++ b/space_game.py
@@ -0,0 +1,180 @@
+import pygame
+import os
+pygame.init()
+pygame.font.init()
+pygame.mixer.init()
+
+WIDTH, HEIGHT = 900, 500
+
+WIN = pygame.display.set_mode((WIDTH, HEIGHT))
+pygame.display.set_caption("First Game!!!")
+
+WHITE = (255, 255, 255)
+BLACK = (0, 0, 0)
+YELLOW = (255, 255, 0)
+RED = (255, 0, 0)
+
+VEL = 5
+
+BULLET_VEL = 7
+MAX_BULLETS = 10
+
+BULLET_HIT_SOUND = pygame.mixer.Sound(os.path.join('Assets', 'Grenade+1.mp3'))
+BULLET_FIRE_SOUND = pygame.mixer.Sound(os.path.join('Assets', 'Gun+Silencer.mp3'))
+
+YELLOW_HIT = pygame.USEREVENT + 1
+RED_HIT = pygame.USEREVENT + 2
+
+FPS = 60
+
+BORDER = pygame.Rect(WIDTH/2 - 5, 0, 10, HEIGHT)
+
+HEALTH_FONT = pygame.font.SysFont('century gothic', 40)
+WINNER_FONT = pygame.font.SysFont('century gothic', 40)
+
+SPACESHIP_WIDTH, SPACESHIP_HEIGHT = 55, 40
+
+YELLOW_SPACESHIP_IMAGE = pygame.image.load(os.path.join('Assets', 'spaceship_yellow.png'))
+YELLOW_SPACESHIP = pygame.transform.rotate(pygame.transform.scale(YELLOW_SPACESHIP_IMAGE, (SPACESHIP_WIDTH, SPACESHIP_HEIGHT)), 90)
+
+RED_SPACESHIP_IMAGE = pygame.image.load(os.path.join('Assets', 'spaceship_red.png'))
+RED_SPACESHIP = pygame.transform.rotate(pygame.transform.scale(RED_SPACESHIP_IMAGE, (SPACESHIP_WIDTH, SPACESHIP_HEIGHT)), 270)
+
+SPACE = pygame.transform.scale(pygame.image.load(os.path.join('Assets', 'space.png')), (WIDTH, HEIGHT))
+
+def yellow_handle_movement(keys_pressed, yellow):
+    if keys_pressed[pygame.K_a] and yellow.x - VEL > 0:
+        yellow.x -= VEL
+    if keys_pressed[pygame.K_d] and yellow.x + VEL + yellow.width - 10 < BORDER.x:
+        yellow.x += VEL
+    if keys_pressed[pygame.K_w] and yellow.y - VEL > 0:
+        yellow.y -= VEL
+    if keys_pressed[pygame.K_s] and yellow.y + yellow.height + VEL < HEIGHT - 15:
+        yellow.y += VEL
+
+def red_handle_movement(keys_pressed, red):
+    if keys_pressed[pygame.K_LEFT] and red.x - VEL > BORDER.x + BORDER.width:
+        red.x -= VEL
+    if keys_pressed[pygame.K_RIGHT] and red.x + VEL + red.width < WIDTH + 10:
+        red.x += VEL
+    if keys_pressed[pygame.K_UP] and red.y - VEL > 0:
+        red.y -= VEL
+    if keys_pressed[pygame.K_DOWN] and red.y + red.height + VEL < HEIGHT - 15:
+        red.y += VEL 
+
+def handle_bullets(yellow_bullets, red_bullets, yellow, red):
+    for bullet in yellow_bullets:
+        bullet.x += BULLET_VEL
+        if red.colliderect(bullet):
+            pygame.event.post(pygame.event.Event(RED_HIT))
+            yellow_bullets.remove(bullet)
+        elif bullet.x > WIDTH:
+            yellow_bullets.remove(bullet)
+
+    for bullet in red_bullets:
+        bullet.x -= BULLET_VEL
+        if yellow.colliderect(bullet):
+            pygame.event.post(pygame.event.Event(YELLOW_HIT))
+            red_bullets.remove(bullet)
+        elif bullet.x < 0:
+            red_bullets.remove(bullet)
+
+
+
+def draw_window(yellow, red, yellow_bullets, red_bullets, red_health, yellow_health):
+    WIN.blit(SPACE, (0, 0))
+    pygame.draw.rect(WIN, BLACK, BORDER)
+
+    WIN.blit(YELLOW_SPACESHIP, (yellow.x, yellow.y))
+    WIN.blit(RED_SPACESHIP, (red.x, red.y))
+
+    red_health_text = HEALTH_FONT.render("Health: " + str(red_health), 1, WHITE)
+    yellow_health_text = HEALTH_FONT.render('Health: ' + str(yellow_health), 1, WHITE)
+
+    WIN.blit(yellow_health_text, (WIDTH - red_health_text.get_width() - 10,10))
+    WIN.blit(red_health_text, (10, 10))
+
+    for bullet in yellow_bullets:
+        pygame.draw.rect(WIN, YELLOW, bullet)
+    for bullet in red_bullets:
+        pygame.draw.rect(WIN, RED, bullet)
+
+    pygame.display.update()
+
+
+
+def draw_winner(text):
+    draw_text = WINNER_FONT.render(text, 1, WHITE)
+    WIN.blit(draw_text, (WIDTH//2 - draw_text.get_width()//2, HEIGHT//2 - draw_text.get_height()//2))
+    pygame.display.update()
+    pygame.time.delay(5000)
+    
+
+
+def main():
+    
+    yellow = pygame.Rect(100, 300, SPACESHIP_WIDTH, SPACESHIP_HEIGHT)
+    red = pygame.Rect(700, 300, SPACESHIP_WIDTH, SPACESHIP_HEIGHT)
+
+    yellow_bullets = []
+    red_bullets = []
+
+    red_health = 3
+    yellow_health = 3
+    
+    clock = pygame.time.Clock()
+    
+    run = True
+
+    while run:
+
+        clock.tick(FPS)
+
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                run = False
+                pygame.quit()
+                
+            if event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_LCTRL and len(yellow_bullets) < MAX_BULLETS:
+                    bullet = pygame.Rect(yellow.x + yellow.width, yellow.y + yellow.height//2 - 2, 10, 5)
+                    yellow_bullets.append(bullet)
+                    BULLET_FIRE_SOUND.play()
+
+                if event.key == pygame.K_RCTRL and len(red_bullets) <= MAX_BULLETS:
+                    bullet = pygame.Rect(red.x, red.y + red.height//2 - 2, 10, 5)
+                    red_bullets.append(bullet)
+                    BULLET_FIRE_SOUND.play()
+
+            if event.type == RED_HIT:
+                red_health -= 1
+                BULLET_HIT_SOUND.play()
+            if event.type == YELLOW_HIT:
+                yellow_health -= 1
+                BULLET_HIT_SOUND.play()
+
+        winner_text = ''
+        if red_health <= 0:
+            winner_text = 'YELLOW WINS !!!'
+        
+        if yellow_health <= 0:
+            winner_text = 'RED WINS !!!'
+
+        if winner_text != '':
+            draw_winner(winner_text)
+            break
+
+        keys_pressed = pygame.key.get_pressed()
+        yellow_handle_movement(keys_pressed,yellow)
+        red_handle_movement(keys_pressed, red)
+        
+        
+        handle_bullets(yellow_bullets, red_bullets, yellow, red)
+        draw_window(yellow, red, yellow_bullets, red_bullets, yellow_health, red_health)
+
+    
+    main()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/stack.ipynb b/stack.ipynb
new file mode 100644
index 0000000..f1d4f6f
--- /dev/null
+++ b/stack.ipynb
@@ -0,0 +1,271 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "88b9bbda",
+   "metadata": {},
+   "source": [
+    "# Q1. Create a class Stack Contains\n",
+    "\n",
+    "a. Items\n",
+    "2. Functions\n",
+    "a. push\n",
+    "i. insert the item at start of the stack\n",
+    "b. pop\n",
+    "i. Pop first element from the stack\n",
+    "c. peak\n",
+    "i. Returns top element of the stack\n",
+    "d. print_stack\n",
+    "i. Display the entire\n",
+    "e. size\n",
+    "i. Return total number of items in the stack\n",
+    "f. push_without_using_insert\n",
+    "i. Insert the item at start of the stack without using .insert method of\n",
+    "string\n",
+    "\n",
+    "Note: Not a single function should crash on an empty stack"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "971650a5",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "16306651",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#stack class\n",
+    "\n",
+    "class Stack:\n",
+    "#constructors\n",
+    "    def __init__(self,items = 0):\n",
+    "        self.items = []\n",
+    "\n",
+    "#function to push data   \n",
+    "    def push(self,data):\n",
+    "        return self.items.insert(0,data)\n",
+    "    \n",
+    "#function to pop(delete) data from top   \n",
+    "    def pop(self, x=0):\n",
+    "        if self.isEmpty():\n",
+    "            pass        \n",
+    "        else:\n",
+    "            return self.items.pop(x)\n",
+    "    \n",
+    "# function to return element from peak    \n",
+    "    def peak(self):\n",
+    "        if self.isEmpty():\n",
+    "            pass\n",
+    "        else:\n",
+    "            return self.items[0]\n",
+    "        \n",
+    "# function to print entire stack\n",
+    "    def print_stack(self):\n",
+    "        if self.isEmpty():\n",
+    "            pass\n",
+    "        else:\n",
+    "            return self.items\n",
+    "\n",
+    "# function to print stack size    \n",
+    "    def size(self):\n",
+    "        if self.isEmpty():\n",
+    "            pass\n",
+    "        else:\n",
+    "            return len(self.items)\n",
+    "\n",
+    "# function to print without using insert       \n",
+    "    def push_without_using_insert(self, data ):\n",
+    "        x = data + self.items\n",
+    "        return x\n",
+    "\n",
+    "    \n",
+    "# function to check either stack is empty or not   \n",
+    "    def isEmpty(self):\n",
+    "        if len(self.items) == 0:\n",
+    "            return (\"Empty stack\")\n",
+    "    \n",
+    "         "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "df54d3f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s = Stack()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "66be8562",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s.push(1)\n",
+    "s.push(2)\n",
+    "s.push(3)\n",
+    "s.push(4)\n",
+    "s.push(5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "10a11c7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "5"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s.pop()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "e07d9952",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[4, 3, 2, 1]"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s.print_stack()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "7d913f8d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s.peak()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "42a0ef70",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s.size()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "5d3c6e95",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[9, 4, 3, 2, 1]"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s.push_without_using_insert([9])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a67101b0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a23edfd0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "state": {},
+    "version_major": 2,
+    "version_minor": 0
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/suhasini_modi.c b/suhasini_modi.c
new file mode 100644
index 0000000..4ff2033
--- /dev/null
+++ b/suhasini_modi.c
@@ -0,0 +1,135 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#define SIZE 20
+
+struct DataItem {
+   int data;   
+   int key;
+};
+
+struct DataItem* hashArray[SIZE]; 
+struct DataItem* dummyItem;
+struct DataItem* item;
+
+int hashCode(int key) {
+   return key % SIZE;
+}
+
+struct DataItem *search(int key) {
+   //get the hash 
+   int hashIndex = hashCode(key);  
+	
+   //move in array until an empty 
+   while(hashArray[hashIndex] != NULL) {
+	
+      if(hashArray[hashIndex]->key == key)
+         return hashArray[hashIndex]; 
+			
+      //go to next cell
+      ++hashIndex;
+		
+      //wrap around the table
+      hashIndex %= SIZE;
+   }        
+	
+   return NULL;        
+}
+
+void insert(int key,int data) {
+
+   struct DataItem *item = (struct DataItem*) malloc(sizeof(struct DataItem));
+   item->data = data;  
+   item->key = key;
+
+   //get the hash 
+   int hashIndex = hashCode(key);
+
+   //move in array until an empty or deleted cell
+   while(hashArray[hashIndex] != NULL && hashArray[hashIndex]->key != -1) {
+      //go to next cell
+      ++hashIndex;
+		
+      //wrap around the table
+      hashIndex %= SIZE;
+   }
+	
+   hashArray[hashIndex] = item;
+}
+
+struct DataItem* delete(struct DataItem* item) {
+   int key = item->key;
+
+   //get the hash 
+   int hashIndex = hashCode(key);
+
+   //move in array until an empty
+   while(hashArray[hashIndex] != NULL) {
+	
+      if(hashArray[hashIndex]->key == key) {
+         struct DataItem* temp = hashArray[hashIndex]; 
+			
+         //assign a dummy item at deleted position
+         hashArray[hashIndex] = dummyItem; 
+         return temp;
+      }
+		
+      //go to next cell
+      ++hashIndex;
+		
+      //wrap around the table
+      hashIndex %= SIZE;
+   }      
+	
+   return NULL;        
+}
+
+void display() {
+   int i = 0;
+	
+   for(i = 0; i<SIZE; i++) {
+	
+      if(hashArray[i] != NULL)
+         printf(" (%d,%d)",hashArray[i]->key,hashArray[i]->data);
+      else
+         printf(" ~~ ");
+   }
+	
+   printf("\n");
+}
+
+int main() {
+   dummyItem = (struct DataItem*) malloc(sizeof(struct DataItem));
+   dummyItem->data = -1;  
+   dummyItem->key = -1; 
+
+   insert(1, 20);
+   insert(2, 70);
+   insert(42, 80);
+   insert(4, 25);
+   insert(12, 44);
+   insert(14, 32);
+   insert(17, 11);
+   insert(13, 78);
+   insert(37, 97);
+
+   display();
+   item = search(37);
+
+   if(item != NULL) {
+      printf("Element found: %d\n", item->data);
+   } else {
+      printf("Element not found\n");
+   }
+
+   delete(item);
+   item = search(37);
+
+   if(item != NULL) {
+      printf("Element found: %d\n", item->data);
+   } else {
+      printf("Element not found\n");
+   }
+}
diff --git a/tic_tac_toe.py b/tic_tac_toe.py
new file mode 100644
index 0000000..3c91f4b
--- /dev/null
+++ b/tic_tac_toe.py
@@ -0,0 +1,123 @@
+board = [' ' for x in range(10)]
+
+def insertLetter(letter, pos):
+    board[pos] = letter
+
+def spaceIsFree(pos):
+    return board[pos] == ' '
+
+def printBoard(board):
+    print('   |   |')
+    print(' ' + board[1] + ' | ' + board[2] + ' | ' + board[3])
+    print('   |   |')
+    print('-----------')
+    print('   |   |')
+    print(' ' + board[4] + ' | ' + board[5] + ' | ' + board[6])
+    print('   |   |')
+    print('-----------')
+    print('   |   |')
+    print(' ' + board[7] + ' | ' + board[8] + ' | ' + board[9])
+    print('   |   |')
+
+def isWinner(bo, le):
+    return (bo[7] == le and bo[8] == le and bo[9] == le) or (bo[4] == le and bo[5] == le and bo[6] == le) or(bo[1] == le and bo[2] == le and bo[3] == le) or(bo[1] == le and bo[4] == le and bo[7] == le) or(bo[2] == le and bo[5] == le and bo[8] == le) or(bo[3] == le and bo[6] == le and bo[9] == le) or(bo[1] == le and bo[5] == le and bo[9] == le) or(bo[3] == le and bo[5] == le and bo[7] == le)
+
+def playerMove():
+    run = True
+    while run:
+        move = input("Please select a postion to place an \'X\', (1-9)")
+        try:
+            move = int(move)
+            if move > 0 and move < 10:
+                if spaceIsFree(move):
+                    run = False
+                    insertLetter('X', move)
+                else:
+                    print('Sorry, the space is occupied!')
+            else:
+                print('Please type a number within the range!')
+        except:
+            print('Please type a number.')
+
+def compMove():
+    possibleMoves = [x for x, letter in enumerate(board) if letter == ' ' and x != 0]
+    move = 0
+
+    for let in ["O", 'X']:
+        for i in possibleMoves:
+            boardCopy = board[:]
+            boardCopy[i] = let
+            if isWinner(boardCopy, let):
+                move = i
+                return move
+
+    cornersOpen = []
+    for i in possibleMoves:
+        if i in [1,3,7,9]:
+            cornersOpen.append(i)
+
+    if len(cornersOpen) > 0:
+        move = selectRandom(cornersOpen)
+        return move
+
+    if 5 in possibleMoves:
+        move = 5
+        return move
+
+    edgesOpen = []
+    for i in possibleMoves:
+        if i in [2,4,6,8]:
+            edgesOpen.append(i)
+
+    if len(edgesOpen) > 0:
+        move = selectRandom(edgesOpen)
+        
+    return move
+
+def selectRandom(li):
+    import random
+    ln = len(li)
+    r = random.randrange(0,ln)
+    return li[r]
+
+def isBoardFull(board):
+    if board.count(' ') > 1:
+        return False
+    else:
+        return True
+
+def main():
+    print('WELCOME TO TIC-TAC-TOE !!!')
+    printBoard(board)
+
+    while not(isBoardFull(board)):
+        if not(isWinner(board, 'O')):
+            playerMove()
+            printBoard(board)
+        else:
+            print("Sorry, O\'s win this time!")
+            break
+
+        if not(isWinner(board, 'X')):
+            move = compMove()
+            if move == 0:
+                print('Tie Game!')
+            else:
+                insertLetter('O', move)
+                print("Computer placed an \'O\' in position", move, ":")
+                printBoard(board)
+        else:
+            print("You have won this time, Good Job!")
+            break
+
+    if isBoardFull(board):
+        print('Tie Game!')
+
+while True:
+    answer = input('Do you want to play again? (Y/N)')
+    if answer.lower() == 'y' or answer.lower == 'yes':
+        board = [' ' for x in range(10)]
+        print('-----------------------------------')
+        main()
+    else:
+        break