Merge branch 'smv1999:master' into circular-queue

RC2208 · web-flow · commit 98bf74bfb50b · 2021-07-20T20:09:42.000+05:30
diff --git a/Arrays/triplet_sum.cpp b/Arrays/triplet_sum.cpp
@@ -0,0 +1,61 @@
+/******************************************************************************
+
+Given an array arr of size n and an integer X.
+Find if there's a triplet in the array which sums up to the given integer X.
+
+*******************************************************************************/
+
+//SOLUTION (in C++)
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+void findTripletSum(int A[], int n, int X)
+{
+    sort(A, A+n);   //sort the array, it becomes easy to take the sum.
+    int i, j, k, count = 0;
+    for(i = 0;i<=n-3;i++)   //i should only run till n-3 as we need three numbers for a triplet.
+    {
+        j = i+1;
+        k = n-1;
+        while(j<k)    //two-pointer appraoch is used.
+        {
+            if(A[i] + A[j] + A[k] < X)   //since the array is sorted, if the sum if less than X, the we need to increment j.
+            {
+                j++;
+            }
+            else if(A[i] + A[j] + A[k] > X)  //If the sum is greater than X, we need to decrement k.
+            {
+                k--;
+            }
+            else if(A[i] + A[j] + A[k] == X) //If the sum is equal to X we need to increement j and decrement k, so that we may find other combinations of the given sum.
+            {
+                j++;
+                k--;
+                count++;
+            }
+        }
+    }
+    if(count == 0)
+      cout<<"The triplet doesn't exists"<<endl;
+    else
+      cout<<"The triplet exists"<<endl;
+}
+
+int main()
+{
+    int n, X;
+    cout<<"Enter n"<<endl;
+    cin>>n;
+    cout<<"Enter the sum you want to find"<<endl;
+    cin>>X;
+    cout<<"Enter the array elements"<<endl;
+    int A[n];
+    for(int i = 0;i<n;i++)
+    {
+        cin>>A[i];
+    }
+    findTripletSum(A, n, X);
+    return 0;
+}
diff --git a/Bit Manipulation/rotate_bits.cpp b/Bit Manipulation/rotate_bits.cpp
@@ -0,0 +1,76 @@
+/*A rotation (or circular shift) is an operation similar to shift except that the
+bits that fall off at one end are put back to the other end. 
+In left rotation, the bits that fall off at left end are put back at right end. 
+In right rotation, the bits that fall off at right end are put back at left end.
+*/
+
+#include <bits/stdc++.h> 
+using namespace std; 
+
+// Left Rotate 'cnt' number of bits of the given number 'n'
+int left_rotate_bits(int n, int cnt)
+{
+    int msb;
+    
+    // 32 is the total number of bits used to store an INT variable in C++
+    for(cnt = cnt % 31;cnt>0;cnt--)
+    {
+        //Store the current MSB in a temporary variable
+        msb = (n >> 31) & 1;
+        //Left rotate the given number by one bit
+        n = (n<<1);
+        //Set the dropped MSB as the new LSB
+        n = n | msb;
+    }
+    return n;
+}
+
+// Right Rotate 'cnt' number of bits of the given number 'n'
+int right_rotate_bits(int n, int cnt)
+{
+    int lsb;
+    
+    // 32 is the total number of bits used to store an INT variable in C++
+    for(cnt = cnt % 31;cnt>0;cnt--)
+    {
+        //Store the current LSB in a temporary variable
+        lsb = n & 1;
+        //Right rotate the given number by one bit and drop its LSB
+        n = (n >> 1) & (~(1 << 31));
+        //Set the dropped LSB as the new MSB
+        n = n | (lsb << 31);
+    }
+    return n;
+}
+
+
+int main()
+{
+    int n,cnt,left,right;
+    cout<<"\nEnter the number : ";
+    cin>>n;
+
+    cout<<"How many bits do you want to rotate : ";
+    cin>>cnt;
+  
+    //Call the sort function 
+    left = left_rotate_bits(n, cnt);  
+    right = right_rotate_bits(n,cnt);
+
+    cout<<"The Left-rotated number is : "<<left<<endl;
+    cout<<"The Right-rotated number is : "<<right<<endl;
+
+    return 0;
+}
+
+/*
+INPUT 
+Enter the number : 39
+How many bits do you want to rotate : 17
+OUTPUT
+The Left-rotated number is : 5111808 
+The Right-rotated number is : 1277952
+
+Time Complexity: O(n)
+Space Complexity: O(1)
+*/
diff --git a/Data Structures/Trees/lowest_common_ancestor_binary_tree.py b/Data Structures/Trees/lowest_common_ancestor_binary_tree.py
@@ -0,0 +1,141 @@
+# Lowest Common Ancestor in Binary Tree
+# Time Complexity : O(n) , Space Complexity : O(1)
+
+"""
+Binary trees are trees where any node can have only 0, 1 or 2 children, which are sorted in any order.
+Lowest Common Ancestor (LCA) of two given nodes is the shared ancestor of n1 and n2 that is located farthest from the root
+or the last common node that occurs on the paths from root node to those nodes.
+
+Here, we first check if both numbers exist in tree or not, with exists_in_tree() function by recursively traversing the trees.
+If yes then we find the LCA of both the elements with find_lca() function, which follows as :
+    if LCA isnt found yet, but current node is one of the elements, then current node is the LCA
+    else look for LCA in left and right subtree
+        if both elements are found in different subtrees, make current node as LCA
+        else if they are in same sub tree, return the LCA of that subtree
+
+"""
+
+
+class Node :
+    """Class to define nodes of binary tree, with attributes data to store values, and left and right pointers"""
+    def __init__(self, value) :
+        self.data = value
+        self.left = None
+        self.right = None
+
+def find_lca(node, n1, n2):    
+    """Finds LCA of 2 numbers by recursively searching in left and right subtree
+    input args : current node, the numbers whose lca is to be found, isFound list telling if the particular element is found
+    returns : lca if found else None    
+    Time complexity : O(n), Space complexity : O(1)
+    """
+    if node==None:
+        return None
+
+    # if one element is found in current node, we return it 
+    # in normal case, both elements are found in different subtrees, called recursively, which is handeled later in this function
+    # there may also be the case when one element is ancestor of another, which is handeled here, as this node is tha lca
+    if node.data == n1:
+        return node
+    elif node.data == n2:
+        return node
+
+    # Recursive calls
+    lca_left = find_lca(node.left, n1, n2)
+    lca_right = find_lca(node.right, n1, n2)
+    
+    if lca_left and lca_right:      # if both are not none, that is 1 element is found in each subtree
+        return node                 # that means, current node is the lca
+    else:                           # both numbers in same sub tree
+        return lca_left if lca_left!=None else lca_right    # return lca whichever is not none
+
+
+def exists_in_tree(node, n):
+    """This function finds if an element exists in a tree or not by recursively traversing the tree
+        input : current node and the element to be found
+        output : returns True if it exists, False if not
+        Time complexity : O(n), Space complexity : O(1)
+    """
+    if node == None:
+        return False
+    if node.data == n:
+        return True
+    
+    if exists_in_tree(node.left, n) or exists_in_tree(node.right, n):
+        return True
+    else:
+        return False
+
+
+
+def lowest_common_ancestor_binary_tree(root, n1, n2):
+    """This function checks if both elements are present in binary tree or not, and depending upon that returns proper value
+        input : root node of the tree, numbers whose lca is to be found
+        output : returns calculated LCA, if both exist, else None
+        Both Time and Space complexity are : O(1)        
+    """
+    if exists_in_tree(root,n1) and exists_in_tree(root,n2):     # if both the elements exist in the tree
+        return find_lca(root, n1, n2)                           # then we calculate its LCA
+    else :
+        return None                 # otherwise we give answer None
+
+
+
+def print_output(lca, n1, n2):
+    """Prints LCA of two numbers with a proper message if it exists"""
+    if lca == None:
+        print("\nElement does not exist in tree.\n")
+    else:
+        print(f"\nlca({n1}, {n2}) = {lca.data}\n")
+
+
+#============================= DRIVER CODE =============================
+if __name__ == "__main__":
+
+    root = Node(1)
+    root.left = Node(2)
+    root.right = Node(3)
+    root.left.left = Node(4)
+    root.left.right = Node(5)
+    root.right.left = Node(6)
+    root.right.right = Node(7)
+
+    """
+            1
+           / \ 
+          2   3
+         / \  /\
+        4  5 6  7
+    """
+
+      
+    lca = lowest_common_ancestor_binary_tree(root, 4, 5)
+    print_output(lca, 4, 5)
+    lca = lowest_common_ancestor_binary_tree(root, 2, 5)
+    print_output(lca, 2, 5)
+    lca = lowest_common_ancestor_binary_tree(root, 4, 2)
+    print_output(lca, 4, 2)
+    
+
+# OTHER EXAMPLES
+    
+    """lca = lowest_common_ancestor_binary_tree(root, 4, 7)
+    print_output(lca, 4, 7)
+    lca = lowest_common_ancestor_binary_tree(root, 2, 3)
+    print_output(lca, 2, 3)
+    lca = lowest_common_ancestor_binary_tree(root, 2, 1)
+    print_output(lca, 2, 1)"""
+
+    """lca = lowest_common_ancestor_binary_tree(root, 1, 8)
+    print_output(lca, 1, 8)
+    lca = lowest_common_ancestor_binary_tree(root, 1, 1)
+    print_output(lca, 1, 1)
+    lca = lowest_common_ancestor_binary_tree(root, 2, 6)
+    print_output(lca, 2, 6)"""
+    
+    """lca = lowest_common_ancestor_binary_tree(root, 9, 8)
+    print_output(lca, 9, 8)
+    lca = lowest_common_ancestor_binary_tree(root, -1, 1)
+    print_output(lca, -1, 1)
+    lca = lowest_common_ancestor_binary_tree(root, -5, -6)
+    print_output(lca, -5, -6)"""
diff --git a/Dynamic Programming/Floyed- Warshall.c b/Dynamic Programming/Floyed- Warshall.c
@@ -0,0 +1,89 @@
+/* Write a program to implement all pair of Shortest path for
+a given graph (Floyed- Warshall Algorithm) using
+Dynamic Programing approach. 
+
+            1  2  3  4  5
+        __  _  _  _  _  _
+        |
+    1   |   0  3  8  X  -4
+    2   |   X  0  X  1   7
+    3   |   X  4  0  X   X      ==> D[0]
+    4   |   2  X  -5 0   X
+    5   |   X  X  X  6   0
+
+
+            1  2  3  4  5
+        __  _  _  _  _  _
+        |
+    1   |   X  1  1  X   1
+    2   |   X  X  X  2   2
+    3   |   X  3  X  3   X      ==> pi[0]
+    4   |   X  X  4  X   X
+    5   |   X  X  X  5   X
+
+*/
+
+#include<stdio.h>
+#define infinity 1000000
+int D[100][100],PI[100][100],i,j,n,k;
+int main(){
+	printf("Enter no. of nodes:	");
+	scanf("%d",&n);
+	for(i=1;i<=n;i++){
+		for(j=1;j<=n;j++){
+			if (i==j){
+				D[i][j] = 0;
+			}
+			if (i!=j){			
+				printf("Enter cost of D[%d][%d]	", i,j);
+				scanf("%d", &D[i][j]);
+			}
+		}
+		printf("\n");
+	}
+	for(i=1;i<=n;i++){
+		for(j=1;j<=n;j++){
+			printf("Enter value of PI[%d][%d]	", i,j);
+			scanf("%d", &PI[i][j]);	
+		}
+		printf("\n");
+	}
+	printf("\n\nMatrix D\n\n");
+	for(i=1;i<=n;i++){
+		for(j=1;j<=n;j++){
+			printf("%d	",D[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n\nMatrix PI\n\n");
+	for(i=1;i<=n;i++){
+		for(j=1;j<=n;j++){
+			printf("%d	",PI[i][j]);
+		}
+		printf("\n");
+	}
+	for(k=1;k<=n;k++){
+		for(i=1;i<=n;i++){
+			for(j=1;j<=n;j++){
+				if(D[i][j] > (D[i][k] + D[k][j])){
+					D[i][j] = (D[i][k] + D[k][j]);
+					PI[i][j] = PI[k][j];
+				}
+			}
+		}
+	}
+	printf("\n\nFinal D Matrix\n\n");
+	for(i=1;i<=n;i++){
+		for(j=1;j<=n;j++){
+			printf("%d	",D[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n\nFinal PI Matrix\n\n");
+	for(i=1;i<=n;i++){
+		for(j=1;j<=n;j++){
+			printf("%d	",PI[i][j]);
+		}
+		printf("\n");
+	}
+}
diff --git a/SilverAndGold.java b/SilverAndGold.java
