Add files via upload

Author: ADITYADAS1999

10_length_of_last_word_of_sentence.py

@@ -0,0 +1,10 @@
+def length_of_last_word(s):
+        words = s.split()
+        if len(words) == 0:
+            return 0
+        return len(words[-1])
+
+print(length_of_last_word("i love you"))
+print(length_of_last_word("Python"))
+print(length_of_last_word(""))
+print(length_of_last_word("  "))

11_sum_binary_number.py

@@ -0,0 +1,12 @@
+# Python program to add two binary numbers.
+
+# Driver code
+# Declaring the variables
+a = "1101"
+b = "100"
+
+# Calculating binary value using function
+sum = bin(int(a, 2) + int(b, 2))
+
+# Printing result
+print(sum[2:])

12_nth_stears_condition_either_one_or_two_stears_at_a_time.py

@@ -0,0 +1,21 @@
+# Python program to count
+# ways to reach nth stair
+
+# Recursive function to find
+# Nth fibonacci number
+def fib(n):
+	if n <= 1:
+		return n
+	return fib(n-1) + fib(n-2)
+
+# Returns no. of ways to
+# reach sth stair
+def countWays(s):
+	return fib(s + 1)
+
+# Driver program
+s = 4
+print("Number of ways = ")
+print(countWays(s))
+
+# Contributed by Harshit Agrawal

13_remove_duplicate_element_in_lined_list_and_sort_the_list.py

@@ -0,0 +1,87 @@
+    #Represent a node of the singly linked list  
+class Node:
+    def __init__(self,data):  
+    self.data = data
+    self.next = None  
+              
+class RemoveDuplicate:  
+#Represent the head and tail of the singly linked list  
+    def __init__(self):
+        self.head = None;  
+        self.tail = None;  
+#addNode() will add a new node to the list  
+    def addNode(self, data):  
+#Create a new node  
+        newNode = Node(data);  
+              
+            #Checks if the list is empty  
+            if(self.head == None):  
+                #If list is empty, both head and tail will point to new node  
+                self.head = newNode;  
+                self.tail = newNode;  
+            else:  
+                #newNode will be added after tail such that tail's next will point to newNode  
+                self.tail.next = newNode;  
+                #newNode will become new tail of the list  
+                self.tail = newNode;  
+                  
+        #removeDuplicate() will remove duplicate nodes from the list  
+        def removeDuplicate(self):  
+            #Node current will point to head  
+            current = self.head;  
+            index = None;  
+            temp = None;  
+              
+            if(self.head == None):  
+                return;  
+            else:  
+                while(current != None):  
+                    #Node temp will point to previous node to index.  
+                    temp = current;  
+                    #Index will point to node next to current  
+                    index = current.next;  
+                      
+                    while(index != None):  
+                        #If current node's data is equal to index node's data  
+                        if(current.data == index.data):  
+                            #Here, index node is pointing to the node which is duplicate of current node  
+                            #Skips the duplicate node by pointing to next node  
+                            temp.next = index.next;  
+                        else:  
+                            #Temp will point to previous node of index.  
+                            temp = index;  
+                        index = index.next;  
+                    current = current.next;  
+                      
+        #display() will display all the nodes present in the list  
+        def display(self):  
+            #Node current will point to head  
+            current = self.head;  
+            if(self.head == None):  
+                print("List is empty");  
+                return;  
+            while(current != None):  
+                #Prints each node by incrementing pointer  
+                print(current.data);  
+                current = current.next;  
+              
+       
+    sList = RemoveDuplicate();  
+              
+    #Adds data to the list  
+    sList.addNode(1);  
+    sList.addNode(2);  
+    sList.addNode(3);  
+    sList.addNode(2);  
+    sList.addNode(2);  
+    sList.addNode(4);  
+    sList.addNode(1);  
+       
+    print("Originals list: ");  
+    sList.display();  
+       
+    #Removes duplicate nodes  
+    sList.removeDuplicate();  
+       
+    print("List after removing duplicates: ");  
+    sList.display();  

14_delete_duplicate_element_in_sorted_inkedlist.py

@@ -0,0 +1,85 @@
+#Represent a node of the singly linked list  
+class Node:  
+    def __init__(self,data):  
+        self.data = data;  
+        self.next = None;  
+          
+class RemoveDuplicate:  
+    #Represent the head and tail of the singly linked list  
+    def __init__(self):  
+        self.head = None;  
+        self.tail = None;
+            #addNode() will add a new node to the list  
+    def addNode(self, data):  
+        #Create a new node  
+        newNode = Node(data);  
+          
+        #Checks if the list is empty  
+        if(self.head == None):  
+            #If list is empty, both head and tail will point to new node  
+            self.head = newNode;  
+            self.tail = newNode;  
+        else:  
+            #newNode will be added after tail such that tail's next will point to newNode  
+            self.tail.next = newNode;  
+            #newNode will become new tail of the list  
+            self.tail = newNode;
+             #removeDuplicate() will remove duplicate nodes from the list  
+    def removeDuplicate(self):  
+        #Node current will point to head  
+        current = self.head;  
+        index = None;  
+        temp = None;  
+          
+        if(self.head == None):  
+            return;  
+        else:  
+            while(current != None):  
+                #Node temp will point to previous node to index.  
+                temp = current;  
+                #Index will point to node next to current  
+                index = current.next;  
+                  
+                while(index != None):  
+                    #If current node's data is equal to index node's data  
+                    if(current.data == index.data):  
+                        #Here, index node is pointing to the node which is duplicate of current node  
+                        #Skips the duplicate node by pointing to next node  
+                        temp.next = index.next;  
+                    else:  
+                        #Temp will point to previous node of index.  
+                        temp = index;  
+                    index = index.next;  
+                current = current.next;
+                #display() will display all the nodes present in the list  
+    def display(self):  
+        #Node current will point to head  
+        current = self.head;  
+        if(self.head == None):  
+            print("List is empty");  
+            return;  
+        while(current != None):  
+            #Prints each node by incrementing pointer  
+            print(current.data);  
+            current = current.next;  
+          
+   
+sList = RemoveDuplicate();  
+          
+#Adds data to the list  
+sList.addNode(1);  
+sList.addNode(2);  
+sList.addNode(3);  
+sList.addNode(2);  
+sList.addNode(2);  
+sList.addNode(4);  
+sList.addNode(1);  
+   
+print("Originals list: ");  
+sList.display();  
+   
+#Removes duplicate nodes  
+sList.removeDuplicate();  
+   
+print("List after removing duplicates: ");  
+sList.display();  

15_merge_two_array_and_sort.py

@@ -0,0 +1,47 @@
+# Python program to merge two unsorted lists 
+# in sorted order
+# Function to merge array in sorted order
+def unsortedarray (a, b, res, n, m):
+   # Sorting a[] and b[]
+   a.sort()
+   b.sort()
+   # Merge two sorted arrays into res[]
+   i, j, k = 0, 0, 0
+   while (i < n and j < m):
+      if (a[i] <= b[j]):
+         res[k] = a[i]
+         i += 1
+         k += 1
+      else:
+         res[k] = b[j]
+         j += 1
+         k += 1
+   while (i < n):  # Merging remaining
+      # elements of a[] (if any)
+      res[k] = a[i]
+      i += 1
+      k += 1
+   while (j < m):  # Merging remaining
+      # elements of b[] (if any)
+      res[k] = b[j]
+      j += 1
+      k += 1
+# Driver code
+A=list()
+n=int(input("Enter the size of the First List ::"))
+print("Enter the Element of First List ::")
+for i in range(int(n)):
+   k=int(input(""))
+   A.append(k)
+B=list()
+m=int(input("Enter the size of the Second List ::"))
+print("Enter the Element of Second List ::")
+for i in range(int(n)):
+   k=int(input(""))
+   B.append(k)
+# Final merge list
+res = [0 for i in range(n + m)]
+unsortedarray(A, B, res, n, m)
+print ("Sorted merged list :")
+for i in range(n + m):
+   print (res[i],)

18_given_tree_is_binary_tree_weather_itself_mirror_or_not.py

@@ -0,0 +1,51 @@
+# Python program to check if a given Binary Tree is  
+# symmetric or not 
+  
+# Node structure 
+class Node: 
+  
+    # Utility function to create new node 
+    def __init__(self, key): 
+        self.key = key 
+        self.left = None
+        self.right = None
+  
+# Returns True if trees with roots as root1 and root 2  
+# are mirror 
+def isMirror(root1 , root2): 
+    # If both trees are empty, then they are mirror images 
+    if root1 is None and root2 is None: 
+        return True 
+      
+    """ For two trees to be mirror images, the following three 
+        conditions must be true 
+        1 - Their root node's key must be same 
+        2 - left subtree of left tree and right subtree 
+          of the right tree have to be mirror images 
+        3 - right subtree of left tree and left subtree 
+           of right tree have to be mirror images 
+    """
+    if (root1 is not None and root2 is not None): 
+            if  root1.key == root2.key: 
+                return (isMirror(root1.left, root2.right)and
+                isMirror(root1.right, root2.left)) 
+  
+    # If neither of the above conditions is true then root1 
+    # and root2 are not mirror images 
+    return False
+  
+def isSymmetric(root): 
+  
+    # Check if tree is mirror of itself 
+    return isMirror(root, root) 
+  
+# Driver Program  
+# Let's construct the tree show in the above figure 
+root = Node(1) 
+root.left = Node(2) 
+root.right = Node(2) 
+root.left.left = Node(3) 
+root.left.right = Node(4) 
+root.right.left = Node(4) 
+root.right.right = Node(3) 
+print("1" if isSymmetric(root) == True else "0") 

25 print_a_specific_row_of_pascal_triangle.py

@@ -0,0 +1,17 @@
+# Print Pascal's Triangle in Python
+from math import factorial
+ 
+# input n
+n = 5
+for i in range(n):
+    for j in range(n-i+1):
+ 
+        # for left spacing
+        print(end=" ")
+ 
+    for j in range(i+1):
+ 
+        # nCr = n!/((n-r)!*r!)
+        print([factorial(i)//(factorial(j)*factorial(i-j))],end=" ")
+ 
+   

26_print_a_particular_index_of_pascal_triangle.py

@@ -0,0 +1,44 @@
+# index row in Pascal's triangle
+ 
+# Function to find the elements
+# of rowIndex in Pascal's Triangle
+def getRow(rowIndex) :
+ 
+    currow = []
+     
+    # 1st element of every row is 1
+    currow.append(1)
+     
+    # Check if the row that has to
+    # be returned is the first row
+    if (rowIndex == 0) :
+     
+        return currow
+     
+    # Generate the previous row
+    prev = getRow(rowIndex - 1)
+ 
+    for i in range(1, len(prev)) :
+         
+        # Generate the elements
+        # of the current row
+        # by the help of the
+        # previous row
+        curr = prev[i - 1] + prev[i]
+        currow.append(curr)
+ 
+    currow.append(1)
+     
+    # Return the row
+    return currow
+ 
+n = 0
+arr = getRow(n)
+ 
+for i in range(len(arr)) :
+ 
+    if (i == (len(arr) - 1)) :
+        print(arr[i])
+    else :
+        print(arr[i] , end = ", ")
+ 

30_31_inorder_preorder_postorder.py

@@ -0,0 +1,129 @@
+class BinaryTree:
+    def __init__(self):
+        self.root = None
+        self.size = 0
+
+    # Return True if the element is in the tree
+    def search(self, e):
+        current = self.root # Start from the root
+
+        while current != None:
+            if e < current.element:
+                current = current.left
+            elif e > current.element:
+                current = current.right
+            else: # element matches current.element
+                return True # Element is found
+
+        return False
+
+    # Insert element e into the binary search tree
+    # Return True if the element is inserted successfully
+    def insert(self, e):
+        if self.root == None:
+          self.root = self.createNewNode(e) # Create a new root
+        else:
+          # Locate the parent node
+          parent = None
+          current = self.root
+          while current != None:
+            if e < current.element:
+              parent = current
+              current = current.left
+            elif e > current.element:
+              parent = current
+              current = current.right
+            else:
+              return False # Duplicate node not inserted
+
+          # Create the new node and attach it to the parent node
+          if e < parent.element:
+            parent.left = self.createNewNode(e)
+          else:
+            parent.right = self.createNewNode(e)
+
+        self.size += 1 # Increase tree size
+        return True # Element inserted
+
+    # Create a new TreeNode for element e
+    def createNewNode(self, e):
+      return TreeNode(e)
+    """
+    # Return the size of the tree
+    def getSize(self):
+      return self.size"""
+
+    # Inorder traversal from the root
+    def inorder(self):
+      self.inorderHelper(self.root)
+
+    # Inorder traversal from a subtree
+    def inorderHelper(self, r):
+      if r != None:
+        self.inorderHelper(r.left)
+        print(r.element, end = " ")
+        self.inorderHelper(r.right)
+
+    # Postorder traversal from the root
+    def postorder(self):
+      self.postorderHelper(self.root)
+
+    # Postorder traversal from a subtree
+    def postorderHelper(self, root):
+      if root != None:
+        self.postorderHelper(root.left)
+        self.postorderHelper(root.right)
+        print(root.element, end = " ")
+
+    # Preorder traversal from the root
+    def preorder(self):
+      self.preorderHelper(self.root)
+
+    # Preorder traversal from a subtree
+    def preorderHelper(self, root):
+      if root != None:
+        print(root.element, end = " ")
+        self.preorderHelper(root.left)
+        self.preorderHelper(root.right)
+
+
+    # Return true if the tree is empty
+    def isEmpty(self):
+      return self.size == 0
+
+    # Remove all elements from the tree
+    def clear(self):
+      self.root == None
+      self.size == 0
+
+    # Return the root of the tree
+    def getRoot(self):
+      return self.root
+
+class TreeNode:
+    def __init__(self, e):
+      self.element = e
+      self.left = None # Point to the left node, default None
+      self.right = None # Point to the right node, default None
+
+    ####################### Main test binary tree
+
+def main(size = 7):
+    int_list=input('Enter a list of integers seperated by spaces: ')
+
+    numbers =[int_list] 
+
+    print ("\n\nInserting the following values:")  
+    intTree = BinaryTree()
+    for e in numbers:
+      intTree.insert(e)
+    print("\nPreorder traversal:")
+    intTree.preorder()
+    print("\n\nInorder traversal:")
+    intTree.inorder()
+    print("\n\nPostorder traversal:")
+    intTree.postorder()
+
+
+if __name__ == "__main__":
+    main()

9 sum_of_sub_array.py

@@ -0,0 +1,15 @@
+class Solution(object):
+   def maxSubArray(self, nums):
+      """
+      :type nums: List[int]
+      :rtype: int
+      """
+      dp = [0 for i in range(len(nums))]
+      dp[0] = nums[0]
+      for i in range(1,len(nums)):
+         dp[i] = max(dp[i-1]+nums[i],nums[i])
+      #print(dp)
+      return max(dp)
+nums = [-2,1,-3,7,-2,2,1,-5,4]
+ob1 = Solution()
+print(ob1.maxSubArray(nums))