Trees

ashnarayan13 · ashnarayan13 · commit 96b9a1a30ecc · 2021-01-08T18:57:21.000+05:30
diff --git a/.gitignore b/.gitignore
@@ -1,6 +1,7 @@
 hackerrank/build/
 hackerrank/cmake-build-debug/
 hackerrank/.idea/
+hackerrank/.vscode/
 DCP/build/
 DCP/cmake-build-debug/
 DCP/.idea/
diff --git a/hackerrank/CMakeLists.txt b/hackerrank/CMakeLists.txt
@@ -98,4 +98,10 @@ add_executable(insert_node_dll src/insert_node_dll.cpp)
 
 add_executable(reverse_dll src/reverse_dll.cpp)
 
-add_executable(merge_ll src/merge_ll.cpp)
+add_executable(merge_ll src/merge_ll.cpp)
+
+add_executable(tree_traversal src/tree_traversal.cpp)
+
+add_executable(tree_insert src/tree_insert.cpp)
+
+add_executable(dynamic_seq src/dynamic_seq.cpp)
diff --git a/hackerrank/src/dynamic_seq.cpp b/hackerrank/src/dynamic_seq.cpp
@@ -0,0 +1,124 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+string ltrim(const string &);
+string rtrim(const string &);
+vector<string> split(const string &);
+
+/*
+ * Complete the 'dynamicArray' function below.
+ *
+ * The function is expected to return an INTEGER_ARRAY.
+ * The function accepts following parameters:
+ *  1. INTEGER n
+ *  2. 2D_INTEGER_ARRAY queries
+ */
+
+vector<int> dynamicArray(int n, vector<vector<int>> queries) {
+    vector<vector<int>> arrayCreation(n);
+    vector<int> answers;
+    int currentAnswer = 0;
+    for(auto const& val:queries)
+    {
+        int currRes = (val[1]^currentAnswer)%n;
+        if(val[0] == 1)
+        {
+            arrayCreation[currRes].push_back(val[2]);
+        }
+        else
+        {
+            // Should be 2
+            int modIdx = val[2]%arrayCreation[currRes].size();
+            currentAnswer = arrayCreation[currRes][modIdx];
+            answers.push_back(currentAnswer);
+        }
+    }
+    return answers;
+}
+
+int main()
+{
+    ofstream fout(getenv("OUTPUT_PATH"));
+
+    string first_multiple_input_temp;
+    getline(cin, first_multiple_input_temp);
+
+    vector<string> first_multiple_input = split(rtrim(first_multiple_input_temp));
+
+    int n = stoi(first_multiple_input[0]);
+
+    int q = stoi(first_multiple_input[1]);
+
+    vector<vector<int>> queries(q);
+
+    for (int i = 0; i < q; i++) {
+        queries[i].resize(3);
+
+        string queries_row_temp_temp;
+        getline(cin, queries_row_temp_temp);
+
+        vector<string> queries_row_temp = split(rtrim(queries_row_temp_temp));
+
+        for (int j = 0; j < 3; j++) {
+            int queries_row_item = stoi(queries_row_temp[j]);
+
+            queries[i][j] = queries_row_item;
+        }
+    }
+
+    vector<int> result = dynamicArray(n, queries);
+
+    for (int i = 0; i < result.size(); i++) {
+        fout << result[i];
+
+        if (i != result.size() - 1) {
+            fout << "\n";
+        }
+    }
+
+    fout << "\n";
+
+    fout.close();
+
+    return 0;
+}
+
+string ltrim(const string &str) {
+    string s(str);
+
+    s.erase(
+        s.begin(),
+        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
+    );
+
+    return s;
+}
+
+string rtrim(const string &str) {
+    string s(str);
+
+    s.erase(
+        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
+        s.end()
+    );
+
+    return s;
+}
+
+vector<string> split(const string &str) {
+    vector<string> tokens;
+
+    string::size_type start = 0;
+    string::size_type end = 0;
+
+    while ((end = str.find(" ", start)) != string::npos) {
+        tokens.push_back(str.substr(start, end - start));
+
+        start = end + 1;
+    }
+
+    tokens.push_back(str.substr(start));
+
+    return tokens;
+}
diff --git a/hackerrank/src/tree_insert.cpp b/hackerrank/src/tree_insert.cpp
@@ -0,0 +1,142 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Node {
+    public:
+        int data;
+        Node *left;
+        Node *right;
+        Node(int d) {
+            data = d;
+            left = NULL;
+            right = NULL;
+        }
+};
+
+class Solution {
+    public:
+  	
+  	void preOrder(Node *root) {
+		
+      	if( root == NULL )
+          	return;
+      
+      	std::cout << root->data << " ";
+      	
+      	preOrder(root->left);
+      	preOrder(root->right);
+    }
+
+/*
+Node is defined as 
+
+class Node {
+    public:
+        int data;
+        Node *left;
+        Node *right;
+        Node(int d) {
+            data = d;
+            left = NULL;
+            right = NULL;
+        }
+};
+
+*/
+
+    Node * insert(Node * root, int data) {
+        if(root == NULL)
+        {
+            root = new Node(data);
+            return root;
+        }
+        Node* dummy = root;
+        while(root != NULL)
+        {
+            if(root->data > data)
+            {
+                // Go left
+                if(root->left)
+                {
+                    root = root->left;
+                }
+                else
+                {
+                    root->left = new Node(data);
+                    break;
+                }
+            }
+            else
+            {
+                // Go right
+                if(root->right)
+                {
+                    root = root->right;
+                }
+                else
+                {
+                    root->right = new Node(data);
+                    break;
+                }
+            }
+        }
+        return dummy;
+    }
+
+    Node * rec(Node * cur, int data)
+    {
+        if(cur == NULL)
+        {
+            cur = new Node(data);
+        }
+        else if(cur->data > data)
+        {
+            cur->left = rec(cur->left, data);
+        }
+        else
+        {
+            cur->right = rec(cur->right, data);
+        }
+        return cur;
+        
+    }
+
+    Node * insertRec(Node * root, int data)
+    {
+        if(root==NULL)
+        {
+            root = new Node(data);
+            return root;
+        }
+        else
+        {
+            Node* dummy = root;
+            rec(dummy, data);
+            return root;
+        }
+        
+    }
+
+};
+
+int main() {
+  
+    Solution myTree;
+    Node* root = NULL;
+    
+    int t;
+    int data;
+
+    std::cin >> t;
+
+    while(t-- > 0) {
+        std::cin >> data;
+        //root = myTree.insert(root, data);
+        root = myTree.insertRec(root, data);
+    }
+  	
+    myTree.preOrder(root);
+  
+    return 0;
+}
diff --git a/hackerrank/src/tree_traversal.cpp b/hackerrank/src/tree_traversal.cpp
