Merge branch 'smv1999:master' into master

Author: paurush11

.vscode/settings.json

@@ -0,0 +1,64 @@
+// Given an array of N positive integers. Find an integer denoting the maximum XOR subset value in the given array.
+// Time complexity: O(n)
+
+
+#include<bits/stdc++.h>
+#define fl(i,a,b) for(i=a;i<b;i++)
+#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
+using namespace std;
+typedef long long int ll;
+
+ll maxSubsetXOR(ll set[], ll n)
+{
+    ll index=0, max_pos, max;
+    for (ll i = 31; i >= 0; i--)
+    {
+        max= LONG_MIN;
+        max_pos= index;
+         for (ll j = index; j < n; j++)
+        {
+            if ( (arr[j] & (1 << i)) != 0 && arr[j] > max )
+                     {
+                         max= arr[j];
+                         max_pos= j;
+                     }
+               
+        }
+        if (max == LONG_MIN)
+            continue;
+
+        swap(arr[index], arr[max_pos]);
+        max_pos = index;
+
+        for (ll j=0; j<n; j++)
+        {
+            if (j != max_pos &&  (arr[j] & (1 << i)) != 0)
+                arr[j] = arr[j] ^ arr[max_pos];
+        }
+        index++;
+    }
+    ll ans = 0;
+    for (ll i = 0; i < n; i++)
+        ans ^= arr[i];
+    return ans;
+}
+
+int main()
+{ 
+   fast;
+
+    #ifndef ONLINE_JUDGE
+    freopen("input.txt","r",stdin);
+    freopen("output.txt","w",stdout);
+    #endif
+
+    ll n; cin>>n;
+    ll arr[n];
+    for(auto &x: arr)
+        cin>>x;
+     
+    cout << maxSubsetXOR(arr, n);
+    
+    return 0;
+
+}

Bit Manipulation/max_subset_XOR.cpp

@@ -0,0 +1,52 @@
+/*
+Src : LeetCode
+--------------
+
+Given the root of a binary tree, flatten the tree into a "linked list":
+
+1) The "linked list" should use the same TreeNode class where the right child pointer points to the next node in the list and the left child pointer is always null.
+2) The "linked list" should be in the same order as a pre-order traversal of the binary tree.
+
+Input: root = [1,2,5,3,4,null,6]
+Output: [1,null,2,null,3,null,4,null,5,null,6]
+*/
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* flattenSubtrees(TreeNode* root){
+        if(!root->left && !root->right) return root;
+        if(root->left==NULL)
+            return fun(root->right);
+        TreeNode* last=fun(root->left);
+        last->right=root->right;
+        root->right=root->left;
+        root->left=NULL;
+        return fun(last);
+    }
+    
+    void flatten(TreeNode* root) {
+        if(!root) return;
+        flatten(root->left);
+        flatten(root->right);
+        TreeNode* right=root->right;
+        root->right=root->left;
+        root->left=NULL;
+        TreeNode* cur=root;
+        while(cur->right){
+            cur=cur->right;
+        }
+        cur->right=right;
+        
+    }
+};

Data Structures/Trees/Flatten_BinaryTree_to_LinkedList.cpp

@@ -0,0 +1,36 @@
+class Node :
+    """Class to define tree nodes, 
+        this has a value attribute to store the value, and 
+        left and right attributes to point to the left and right child respectively"""
+    def __init__(self, value):
+        self.value = value
+        self.right = None
+        self.left = None
+    
+def expression_tree_evaluation (node):
+    """A recursive function which evaluates the expression subtree passed to it
+        and returns the evaluated value"""
+    if node == None:    # Node doesn't exist
+        return 0
+    if node.left == None and node.right == None:    # leaf node containing an operand
+        return node.value
+    
+    # node is an operator
+    left_child = expression_tree_evaluation(node.left)
+    right_child = expression_tree_evaluation (node.right)
+
+    return eval(str(left_child)+node.value+str(right_child))
+
+
+# DRIVER CODE
+
+if __name__ == '__main__':
+    # Expression in the example : (5*4)+(100-2)
+    root = Node('+')
+    root.left = Node('*')
+    root.left.left = Node('5')
+    root.left.right = Node('4')
+    root.right = Node('-')
+    root.right.left = Node('100')
+    root.right.right = Node('20')
+    print (expression_tree_evaluation(root))

Data Structures/Trees/expression_tree_evaluation.py

@@ -0,0 +1,49 @@
+/* problem statement
+first input is n representing the number of days 
+after that we have n values ,representing the price of stock on that day
+ouput should be maximum profit , if you can buy and sell only one time
+*/
+
+#include <iostream>
+using namespace std;
+int main()
+{
+    int n;
+    cin >> n;   // it represent the number of days
+    int arr[n]; // this array contains the prices of stock on that day
+    for (int i = 0; i < n; i++)
+        cin >> arr[i];
+    int lsf = 9999999; //least so far
+    int op = 0;        //overall profit
+    int pist = 0;
+    for (int i = 0; i < n; i++)
+    {
+        if (arr[i] < lsf)
+        {
+            lsf = arr[i];
+        }
+        int pist = arr[i] - lsf; // if stock is sold today
+        if (pist > op)
+        {
+            op = pist;
+        }
+    }
+    cout << op << endl;
+}
+
+/* sample input values are
+9
+11
+6
+7
+19
+4
+1
+6
+18
+4
+*/
+
+/*sample output value for the upper input
+17
+*/

Dynamic Programming/Buy_And_Sell_Stocks.cpp

@@ -0,0 +1,24 @@
+import java.io.*;
+public class SquareRoot
+{
+    /* Time Comeplexity:-O(lg(n))
+    Space Complexity:- O(1)**/
+    public static void main(String args[])throws IOException
+    {
+        InputStreamReader read=new InputStreamReader(System.in);
+        BufferedReader in=new BufferedReader(read);
+        System.out.println("Enter your number");
+        int n=Integer.parseInt(in.readLine());
+        int x=n;
+            if(x<=1)
+                System.out.println(x);
+            int sqrt=x/2;
+            int quotient=x/sqrt;
+            while(sqrt>quotient)
+            {
+                sqrt=(sqrt+quotient)>>1;//bitwise operator used to make the process faster
+                quotient=x/sqrt;   
+            }
+            System.out.println("The square root of the number "+n+" is = "+sqrt);
+        }
+    }

Numbers/SquareRoot.java

@@ -24,6 +24,7 @@ This repository contains all the popular Competitive Programming questions and I
  <li><a href="https://github.com/smv1999/CompetitiveProgrammingQuestionBank/tree/master/General%20Questions">General Questions</a></li>
  <li><a href="https://github.com/smv1999/CompetitiveProgrammingQuestionBank/tree/master/Greedy">Greedy</a></li>
  <li><a href="https://github.com/smv1999/CompetitiveProgrammingQuestionBank/tree/master/Hackerrank%20solutions">HackerRank Solutions</a></li>
+ <li><a href="https://github.com/smv1999/CompetitiveProgrammingQuestionBank/tree/master/Hashing">Hashing</a></li>
  <li><a href="https://github.com/smv1999/CompetitiveProgrammingQuestionBank/tree/master/Numbers">Numbers</a></li>
  <li><a href="https://github.com/smv1999/CompetitiveProgrammingQuestionBank/tree/master/OOPs">OOPs</a></li>
  <li><a href="https://github.com/smv1999/CompetitiveProgrammingQuestionBank/tree/master/Passwords">Passwords</a></li>

README.md

@@ -0,0 +1,61 @@
+#include<stdio.h>
+#include<conio.h>
+void heapify(int arr[],int n,int i)
+{
+	int max=i; //parent node index
+	int left = 2*i +1; // left child node index
+	int right =2*i+2; //right child node index
+	int temp;
+	if(left<n && arr[left]> arr[max]) //if left child node is greater than parent 
+    {
+	    max =left;
+    }
+	if(right<n && arr[right]> arr[max])
+    {
+	    max =right;
+    }
+		if(max != i)
+		{
+			temp = arr[i];  //swapping the max element to the root node
+			arr[i]=arr[max];
+			arr[max]=temp;
+			heapify(arr,n,max); //every node element
+	    }
+}
+
+	
+void heapsort(int arr[],int n)
+{
+	int i,temp;
+
+	for(i=n/2-1;i>=0;i--)
+    {
+	    heapify(arr,n,i);
+    }
+    //swap the elements and heapify again
+	for(i=n-1;i>=0;i--)
+	{
+		temp=arr[0];
+		arr[0]=arr[i];
+		arr[i]=temp;
+		heapify(arr,i,0); //root node swap from 0th index
+	}
+}
+int main()	
+{
+	int arr[100],n,i;
+	printf("\n Enter the n of the elements:");
+	scanf("%d",&n);
+	printf("Enter the elements:");
+	for(i=0;i<n;i++)
+	{
+	    
+		scanf("%d",&arr[i]);
+	}
+	    heapsort(arr,n);
+	    printf("The Heap Sorted Array is:");
+	    for(i=0;i<n;i++)
+	    {    
+	    	printf("\t %d",arr[i]);
+        }    	
+}