diff --git a/Arrays/Find Permutation.cpp b/Arrays/Find Permutation.cpp
new file mode 100644
index 0000000..83c9ff2
--- /dev/null
+++ b/Arrays/Find Permutation.cpp	
@@ -0,0 +1,32 @@
+/*
+Solution by : Bhavik Dhandhalya
+Given a positive integer n and a string s consisting only of letters D or I, you have to find any permutation of first n positive integer that satisfy the given input string.
+
+D means the next number is smaller, while I means the next number is greater.
+
+Notes
+Length of given string s will always equal to n - 1
+Your solution should run in linear time and space.
+
+Input 1:
+
+n = 3
+s = ID
+Return: [1, 3, 2]
+
+Solution Complexity : O(N) time and O(1) space
+Refer this URL for lexicographically smaller permutation solution:
+https://leetcode.com/articles/find-permutation/
+*/
+
+vector<int> Solution::findPerm(const string A, int B) {
+    vector < int > ans;
+    int n = A.length();
+    int maxi = n + 1, mini = 1;
+    for (int i = 0; i < n; i++) {
+        if (A[i] == 'I') ans.push_back(mini++);
+        if (A[i] == 'D') ans.push_back(maxi--);
+    }
+    ans.push_back(maxi);
+    return ans;
+}
diff --git a/Arrays/Flip simple code.cpp b/Arrays/Flip simple code.cpp
new file mode 100644
index 0000000..5c5e87c
--- /dev/null
+++ b/Arrays/Flip simple code.cpp	
@@ -0,0 +1,51 @@
+/*
+You are given a binary string(i.e. with characters 0 and 1) S consisting of characters S1, S2, …, SN. In a single operation, you can choose two indices L and R such that 1 ≤ L ≤ R ≤ N and flip the characters SL, SL+1, …, SR. By flipping, we mean change character 0 to 1 and vice-versa.
+
+Your aim is to perform ATMOST one operation such that in final string number of 1s is maximised. If you don’t want to perform the operation, return an empty array. Else, return an array consisting of two elements denoting L and R. If there are multiple solutions, return the lexicographically smallest pair of L and R.
+
+Notes:
+
+Pair (a, b) is lexicographically smaller than pair (c, d) if a < c or, if a == c and b < d.
+For example,
+S = 010
+Output = [1 1]
+*/
+
+vector<int> Solution::flip(string A) {
+    int n = A.length();
+    int ones = 0;
+    int zeros = 0;
+    int L = INT_MAX, R = 0;
+    int ansL = 0, ansR = 0;
+    int prev = 0;
+    bool found = false;
+    
+    for (int i = 0; i < n; i++) {
+        ones += A[i] == '1';
+        zeros += A[i] == '0';
+        if (zeros) found = true;
+        
+        if (ones > zeros) {
+            ones = 0;
+            zeros = 0;
+            L = INT_MAX;
+            R = 0;
+        } else if (A[i] == '0') {
+            L = min(L, i);
+            R = i;
+            
+            if (zeros - ones > prev) {
+                ansR = R;
+                ansL = L;
+                prev = zeros - ones;
+            }
+        }
+    }
+    
+    vector < int > ans;
+    if (found) {
+        ans.push_back(ansL + 1);
+        ans.push_back(ansR + 1);
+    }
+    return ans;
+}
diff --git a/Arrays/MaxDistance.cpp b/Arrays/MaxDistance.cpp
index d330e72..bc867f0 100644
--- a/Arrays/MaxDistance.cpp
+++ b/Arrays/MaxDistance.cpp
@@ -1,41 +1,80 @@
 // https://www.interviewbit.com/problems/max-distance/
+
+int Solution::maximumGap(const vector<int> &A) {
+    // Base case     
+    if(A.size() <= 1)return 0;
+    
+    // Make two arrays such that one of them holds the minimum from the left
+    // and the other holds maximum from the right
+    vector<int> v1 (A.size(), 0), v2(A.size(), 0);
+    
+    // Fill the first array with minimum from the left
+    v1[0] = A[0];
+    for(int i = 1 ; i < A.size(); i++)v1[i] = min(v1[i-1], A[i]);
+    
+    // Fill the second array with maximum from the right
+    v2[A.size()-1] = A[A.size()-1];
+    for(int i = A.size()-2 ; i >= 0 ; i--)v2[i] = max(v2[i+1], A[i]);
+    
+    
+    int i = 0, j = 0;
+    int ans = -1;
+    // While we don't traverse the complete array, check if the minimum element is indeed
+    // less than the maximum element in the other array, if yes, update the answer.
+    // Move the pointer as required. If the element in second array is greater than
+    // that in first array, keep moving the second pointer and update the answer
+    // else move the first pointer.
+    while(j < A.size() && i < A.size()){
+        if(v2[j] >= v1[i]){
+            if(j-i > ans){
+                ans = j-i;
+            }
+            j = j + 1;
+        }else i = i + 1;
+    }
+    return ans;
+}
+
+
+
+
 // Here we are making an array to check whether all the elements on the left of an index are smaller than it or not
 // If true then we are checking for greater j such that A[j] is greater than A[i]. If so then that j is greater than all i on the left
 // also. On finding such a j or a false in the check array, we decrement i.
 
-int Solution::maximumGap(const vector<int> &A) {
-    // Do not write main() function.
-    // Do not read input, instead use the arguments to the function.
-    // Do not print the output, instead return values as specified
-    // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
-    vector<bool> tempArr(A.size());
-    int min = A[0];
-    int max_distance = 0;
-    int i = A.size()-1;
-    int j = A.size()-1;
+// int Solution::maximumGap(const vector<int> &A) {
+//     // Do not write main() function.
+//     // Do not read input, instead use the arguments to the function.
+//     // Do not print the output, instead return values as specified
+//     // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
+//     vector<bool> tempArr(A.size());
+//     int min = A[0];
+//     int max_distance = 0;
+//     int i = A.size()-1;
+//     int j = A.size()-1;
     
-    for(int i = 0; i < A.size(); i++){
-        if(A[i] > min){
-            tempArr[i] = false;
-        }
-        else{
-            min = A[i];
-            tempArr[i] = true;
-        }
-    }
+//     for(int i = 0; i < A.size(); i++){
+//         if(A[i] > min){
+//             tempArr[i] = false;
+//         }
+//         else{
+//             min = A[i];
+//             tempArr[i] = true;
+//         }
+//     }
 
-    LOOP:while(i >= 0){
-        if(tempArr[i] == false){
-            i--;
-            goto LOOP;
-        }
-        while((A[i] > A[j]) && (j > i)){
-            j--;
-        }
-        if((j-i) > max_distance){
-            max_distance = j-i;
-        }
-        i--;
-    }
-    return max_distance;
-}
+//     LOOP:while(i >= 0){
+//         if(tempArr[i] == false){
+//             i--;
+//             goto LOOP;
+//         }
+//         while((A[i] > A[j]) && (j > i)){
+//             j--;
+//         }
+//         if((j-i) > max_distance){
+//             max_distance = j-i;
+//         }
+//         i--;
+//     }
+//     return max_distance;
+// }
diff --git a/Arrays/MinStepsInInfiniteGrid.cpp b/Arrays/MinStepsInInfiniteGrid.cpp
index e4932a0..0d227f0 100644
--- a/Arrays/MinStepsInInfiniteGrid.cpp
+++ b/Arrays/MinStepsInInfiniteGrid.cpp
@@ -1,6 +1,9 @@
 // https://www.interviewbit.com/problems/min-steps-in-infinite-grid/
 // Input : X and Y co-ordinates of the points in order.
 // Each point is represented by (X[i], Y[i])
+
+// Explanatory code
+/*
 int Solution::coverPoints(vector<int> &X, vector<int> &Y) {
 
     int steps = 0, dx, dy, i = 0;
@@ -38,3 +41,19 @@ int Solution::coverPoints(vector<int> &X, vector<int> &Y) {
 
     return steps;
 }
+*/
+
+// Concise code
+int coverPoints(vector<int> &X, vector<int> &Y) {
+
+    int size1=X.size(),size2=Y.size(),ans=0;
+
+    for(int i=1;i<size1;i++)
+
+    {
+     ans = ans + (abs(X[i]-X[i-1])<abs(Y[i]-Y[i-1])?abs(Y[i]-Y[i-1]):abs(X[i]-X[i-1]));
+    }
+
+    return ans;
+} 
+
diff --git a/Backtracking/CombinationSum.cpp b/Backtracking/CombinationSum.cpp
new file mode 100644
index 0000000..4c2c668
--- /dev/null
+++ b/Backtracking/CombinationSum.cpp
@@ -0,0 +1,27 @@
+void aux(int i, int sum, int k, vector<int> &A, vector<int> &temp, set<vector<int>> &ans) {
+    if(i == A.size() || sum >= k){
+        if(sum == k){
+            ans.insert(temp);
+        }
+        return;
+    }
+
+    temp.push_back(A[i]);
+    aux(i, sum+A[i], k, A, temp, ans);
+    aux(i+1, sum+A[i], k, A, temp, ans);
+    temp.pop_back();
+    aux(i+1, sum, k, A, temp, ans);
+}
+
+vector<vector<int> > Solution::combinationSum(vector<int> &A, int B) {
+    set<vector<int>> ans;
+    sort(A.begin(), A.end());
+    vector<int> temp;
+    aux(0, 0, B, A, temp, ans);
+    vector<vector<int>> res;
+    
+    for(auto i = ans.begin(); i != ans.end(); i++){
+        res.push_back(*i);
+    }
+    return res;
+}
diff --git a/Backtracking/NQueens.cpp b/Backtracking/NQueens.cpp
new file mode 100644
index 0000000..8164dad
--- /dev/null
+++ b/Backtracking/NQueens.cpp
@@ -0,0 +1,50 @@
+vector<vector<string> >ans;
+int n;
+
+void recur(int ind, vector<int> pos)
+{
+    int i,j;
+    if(ind == n)
+    {
+       vector<string> valid;
+        for(i=0;i<n;i++)
+        {
+            string row = "";
+            for(j=0;j<n;j++)
+            {
+                if(j == pos[i])
+                    row += 'Q';
+                else
+                    row += '.';
+            }
+            valid.push_back(row);
+        }
+        ans.push_back(valid);
+    
+        return;
+    }
+    for(i = 0;i<n;i++)
+    {
+        bool flag = true;
+        for(j=0;j<pos.size();j++)
+        {
+            if(abs(ind-j) == abs(pos[j]-i) || i == pos[j])
+                flag = false;
+        }
+        if(!flag)
+            continue;
+        pos.push_back(i);
+        recur(ind+1,pos);
+        pos.pop_back();
+        //pos[ind] = -1;
+    }
+}
+vector<vector<string> > Solution::solveNQueens(int A) 
+{
+    ans.clear();
+    vector<int> pos;
+    int i;
+    n = A;
+    recur(0,pos);
+    return ans;
+}
diff --git a/Binary-Search/RotatedSortedArraySearch.cpp b/Binary-Search/RotatedSortedArraySearch.cpp
index 6f46735..6d6ce5d 100644
--- a/Binary-Search/RotatedSortedArraySearch.cpp
+++ b/Binary-Search/RotatedSortedArraySearch.cpp
@@ -1,5 +1,43 @@
 // https://www.interviewbit.com/problems/rotated-sorted-array-search/
 
+int search1(const vector<int> &arr, int low, int high, int B) 
+{ 
+    if (low > high) return -1; 
+  
+    int mid = (low) + (high-low)/2; 
+    if (arr[mid] == B) return mid; 
+  
+    if (arr[low] <= arr[mid]) 
+    { 
+        if (B >= arr[low] && B <= arr[mid]) 
+        return search1(arr, low, mid-1, B); 
+
+        return search1(arr, mid+1, high, B); 
+    } 
+  
+    else if (arr[mid] <= arr[high])
+    {
+    if (B >= arr[mid] && B <= arr[high]) 
+        return search1(arr, mid+1, high, B); 
+  
+    return search1(arr, low, mid-1, B); 
+    }
+} 
+
+
+int Solution::search(const vector<int> &A, int B) {
+    
+   int n = A.size();
+   int i = search1(A, 0, n-1, B); 
+  
+    if (i != -1) 
+    return i;
+    else
+    return -1;
+    
+}
+
+/*
 int findPivot(const vector<int> &A){
     int start = 0;
     int end = A.size()-1;
@@ -64,3 +102,4 @@ int Solution::search(const vector<int> &A, int B) {
     // B < A[pivot]
     
 }
+*/
diff --git a/Bit-Manipulation/DivideInteger.cpp b/Bit-Manipulation/DivideInteger.cpp
new file mode 100644
index 0000000..cc842e0
--- /dev/null
+++ b/Bit-Manipulation/DivideInteger.cpp
@@ -0,0 +1,18 @@
+int Solution::divide(int a, int b) {
+    if(a==0)
+    return 0;
+    if(b==0)
+    return (INT_MAX);
+   int sign=1;
+    //remove sign of operands
+    int t=0,q=0;
+    a=abs(a);
+    b=abs(b);
+    for(int i=31;i>=0;--i){
+        if(t+(b<<i)<=a){
+            t+=b<<i;
+            q+=1LL<<i;
+        }
+    }
+    return (sign*q>=INT_MAX||sign*q<INT_MIN)?INT_MAX:sign*q;
+}
diff --git a/DynamicProgramming/KingdomWar b/DynamicProgramming/KingdomWar
new file mode 100644
index 0000000..f51a0f9
--- /dev/null
+++ b/DynamicProgramming/KingdomWar
@@ -0,0 +1,35 @@
+int Solution::solve(vector<vector<int> > &A) {
+    int ans,i,j,dn,rig,r,c,sum;
+    int n=A.size();
+    int m=A[0].size();
+    vector<vector<int> > rsum=A;
+    for(r=0;r<n;r++)
+    {
+        for(c=m-2;c>=0;c--)
+        {
+            rsum[r][c]=A[r][c]+rsum[r][c+1];
+        }
+    }
+    int ma=A[n-1][m-1];
+    int dp[n][m];
+    memset(dp,0,sizeof(dp));
+    for(j=m-1;j>=0;j--)
+    {
+        for(i=n-1;i>=0;i--)
+        {
+            rig=0;
+            dn=0;
+            if(i!=n-1)
+            {
+                dn=dp[i+1][j];
+            }
+            if(j!=m-1)
+            {
+                rig=rsum[i][j+1];
+            }
+            dp[i][j]=A[i][j]+rig+dn;
+            ma=max(ma,dp[i][j]);
+        }
+    }
+    return(ma);
+}
diff --git a/DynamicProgramming/LargestAreaOfRectangleWithPermutations.cpp b/DynamicProgramming/LargestAreaOfRectangleWithPermutations.cpp
new file mode 100644
index 0000000..2144aca
--- /dev/null
+++ b/DynamicProgramming/LargestAreaOfRectangleWithPermutations.cpp
@@ -0,0 +1,47 @@
+int Solution::solve(vector<vector<int> > &A) {
+
+    int hist[A.size()+1][A[0].size()+1];
+
+    for (int i=0; i<A[0].size(); i++)
+    {
+        hist[0][i] = A[0][i];
+
+        for (int j=1; j<A.size(); j++)
+            hist[j][i] = (A[j][i]==0)? 0: hist[j-1][i]+1;
+    }
+
+
+    for (int i=0; i<A.size(); i++)
+    {
+        int count[A.size()+1];
+        memset( count, 0, (A.size()+1)*sizeof(int) );
+
+        for (int j=0; j<A[0].size(); j++)
+            count[hist[i][j]]++;
+
+        int col_no = 0;
+        for (int j=A.size(); j>=0; j--)
+        {
+            if (count[j] > 0)
+            {
+                for (int k=0; k<count[j]; k++)
+                {
+                    hist[i][col_no] = j;
+                    col_no++;
+                }
+            }
+        }
+    }
+
+    int curr_area, max_area = 0;
+    for (int i=0; i<A.size(); i++)
+    {
+        for (int j=0; j<A[0].size(); j++)
+        {
+            curr_area = (j+1)*hist[i][j];
+            if (curr_area > max_area)
+                max_area = curr_area;
+        }
+    }
+    return max_area;
+}
diff --git a/DynamicProgramming/Scramble String.cpp b/DynamicProgramming/Scramble String.cpp
new file mode 100644
index 0000000..157a4c9
--- /dev/null
+++ b/DynamicProgramming/Scramble String.cpp	
@@ -0,0 +1,41 @@
+int Solution::isScramble(string A, string B) 
+{
+    
+    int length1 = A.length();
+    //int length2 = B.length();
+    
+    if(length1 != B.length())
+    return false;
+    if(A == B)
+    return true;
+    
+    bool scrambled[length1][length1][length1];  
+    for (int i=0; i < length1; ++i)
+    {  
+     for (int j=0; j < length1; ++j)
+     {  
+       scrambled[i][j][0] = (A[i] == B[j]);  
+     }  
+   }  
+   
+   for (int k=1; k < length1; ++k) 
+   {
+     for (int i=0; i < length1 - k; ++i) 
+     { 
+       for (int j=0; j < length1 - k; ++j) 
+       {  
+         scrambled[i][j][k] = false;  
+         for (int p=0; p < k; ++p)
+         { 
+           if ((scrambled[i][j][p] && scrambled[i+p+1][j+p+1][k-p-1])  
+               || (scrambled[i][j+k-p][p] && scrambled[i+p+1][j][k-p-1])) {  
+             scrambled[i][j][k] = true;  
+             break;  
+           }  
+         }  
+       }  
+     }  
+   }  
+   
+   return scrambled[0][0][length1-1];  
+ }  
diff --git a/DynamicProgramming/Tushar'sBirthdayBombs.cpp b/DynamicProgramming/Tushar'sBirthdayBombs.cpp
new file mode 100644
index 0000000..2d1da5f
--- /dev/null
+++ b/DynamicProgramming/Tushar'sBirthdayBombs.cpp
@@ -0,0 +1,43 @@
+vector<int> Solution::solve(int A, vector<int> &B) 
+{
+    int mn = INT_MAX;
+    int n = B.size(),i,j,pos;
+    for(i=0;i<n;i++)
+    {
+        if(B[i]<mn)
+        {
+            mn = B[i];
+            pos = i;
+        }
+    }
+        //mn = min(B[i],mn);
+    int maxkick = A/mn;
+    
+    vector<int> order;
+    for(i=0;i<maxkick;i++)
+        order.push_back(pos);
+        
+    int rem = maxkick*mn;
+    rem = A-rem;
+    i = 0;
+    while(i<maxkick)
+    {
+        pos = order[i];
+        int ind = -1;
+        for(j=0;j<n;j++)
+        {
+            if(rem-B[j]+B[pos] >= 0) 
+            {
+                ind = j;
+                rem = rem-B[j]+B[pos];
+                break;
+            }
+        }
+        if(j == n)
+            break;
+        order[i] = j;
+        i++;
+       // pos = order.size();
+    }
+    return order;
+}
diff --git a/Graphs/CloneGraph.cpp b/Graphs/CloneGraph.cpp
new file mode 100644
index 0000000..ed6e982
--- /dev/null
+++ b/Graphs/CloneGraph.cpp
@@ -0,0 +1,46 @@
+/**
+ * Definition for undirected graph.
+ * struct UndirectedGraphNode {
+ *     int label;
+ *     vector<UndirectedGraphNode *> neighbors;
+ *     UndirectedGraphNode(int x) : label(x) {};
+ * };
+ */
+UndirectedGraphNode *Solution::cloneGraph(UndirectedGraphNode *node) {
+    std::map<int, UndirectedGraphNode*> m;
+    queue<UndirectedGraphNode*> q;
+
+    q.push(node);
+
+    while (!q.empty()) {
+        auto n = q.front();
+        q.pop();
+
+        UndirectedGraphNode* new_node = nullptr;
+
+        if (m.find(n->label) == m.end()) {
+            // not exist in map
+            new_node = new UndirectedGraphNode(n->label);
+            m[n->label] = new_node;
+        } else {
+            // exist in map
+            new_node = m[n->label];
+        }
+
+        for (auto neighbor: n->neighbors) {
+            if (m.find(neighbor->label) == m.end()) {
+                // not exist in map
+                m[neighbor->label] = new UndirectedGraphNode(neighbor->label);
+                new_node->neighbors.push_back(m[neighbor->label]);
+
+                q.push(neighbor);
+            } else {
+                // exist in map
+                new_node->neighbors.push_back(m[neighbor->label]);
+            }
+        }
+    }
+
+    return m[node->label];
+}
+
diff --git a/Graphs/LargestDistanceBetweenNodesOfATree.cpp b/Graphs/LargestDistanceBetweenNodesOfATree.cpp
new file mode 100644
index 0000000..9dd1ecd
--- /dev/null
+++ b/Graphs/LargestDistanceBetweenNodesOfATree.cpp
@@ -0,0 +1,58 @@
+pair<int, int> process(queue<pair<int, int> >& q, vector<int>& visited, unordered_map<int, vector<int> >& x){
+    // Typical BFS with keeping track of the longest distance and farthest element.
+    int maxi = INT_MIN, farthest = 0;
+    while(!q.empty()){
+        int node = q.front().first;
+        int distance = q.front().second;
+        q.pop();
+        if(distance > maxi){
+            maxi = distance;
+            farthest = node;
+        }
+        visited[node] = 1;
+        for(int i = 0; i < x[node].size(); i++){
+            if(!visited[x[node][i]]){
+                visited[x[node][i]] = 1;
+                q.push({x[node][i], distance+1});
+            }
+        }
+    }
+    return {maxi, farthest};
+}
+
+int Solution::solve(vector<int> &A) {
+    // Base Case
+    if(A.size() <= 1)return 0;
+    
+    // Visited array to keep track of visited elements
+    vector<int> visited(A.size(), 0);
+    
+    // Map to make the graph from given array
+    unordered_map<int, vector<int> > x;
+    x.clear();
+    
+    for(int i = 0; i < A.size(); i++){
+        // If the value is -1, it doesn't have any parent.
+        // Make the pairs in the adj. list type map
+        if( A[i] != -1){
+            x[A[i]].push_back(i);
+            x[i].push_back(A[i]);
+        }
+    }
+    
+    // Start from the first element in the array and mark it visited.
+    queue<pair<int, int> > q;
+    q.push({0, 0});
+    visited[0] = 1;
+
+    // Gets the farthest element from the first element
+    int farthest = process(q, visited, x).second;
+
+    vector<int> vis(A.size(), 0);
+    
+    // Now apply BFS on the farthest element found and return the distance
+    // of the farthest element found so far.
+    q.push({farthest, 0});
+    vis[farthest] = 1;
+    return process(q, vis, x).first;
+}
diff --git a/Graphs/SmallestSequenceWithGivenPrimes.cpp b/Graphs/SmallestSequenceWithGivenPrimes.cpp
new file mode 100644
index 0000000..befd7a6
--- /dev/null
+++ b/Graphs/SmallestSequenceWithGivenPrimes.cpp
@@ -0,0 +1,22 @@
+vector<int> Solution::solve(int A, int B, int C, int D)
+{
+    set<int> s;
+    swap(A,D);
+    int ctr = 0;
+    vector<int> ans;
+    s.insert(B);
+    s.insert(C);
+    s.insert(D);
+    while(ctr<A)
+    {
+        auto i = s.begin();
+        ans.push_back(*i);
+    
+        s.insert((*i)*B);
+        s.insert((*i)*C);
+        s.insert((*i)*D);
+        s.erase(i);
+        ctr++;
+    }
+    return ans;
+}
diff --git a/Graphs/SumOfFibonacciNumbers.cpp b/Graphs/SumOfFibonacciNumbers.cpp
index c81ba11..c50a11b 100644
--- a/Graphs/SumOfFibonacciNumbers.cpp
+++ b/Graphs/SumOfFibonacciNumbers.cpp
@@ -1,39 +1,61 @@
 // https://www.interviewbit.com/problems/sum-of-fibonacci-numbers/
 
-int Solution::fibsum(int A) {
-    // Do not write main() function.
-    // Do not read input, instead use the arguments to the function.
-    // Do not print the output, instead return values as specified
-    // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
+int Solution::fibsum(int n) {
+    vector <int> fib;
+ 		fib.push_back(1);fib.push_back(1);      // now u have 1 and 1 at v[0] and v[1]
+ 		for(int i=2;fib[i-1]<n;i++){
+ 			int val=fib[i-1]+fib[i-2];
+ 			fib.push_back(val);
+		 }
+		 int ans=0;
+		 int size=fib.size();
+		 size--;
+		 while(n>0){
+		 	while(fib[size]>n){        // find the largest fibonaci number < n
+		 		size--;
+			 }                         // now decraese the largest fibonaci number from n
+			 n=n-fib[size];
+			 ans++;
+		 }
+		 return ans;
+}
+
+
+
+// int Solution::fibsum(int A) {
+//     // Do not write main() function.
+//     // Do not read input, instead use the arguments to the function.
+//     // Do not print the output, instead return values as specified
+//     // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
     
-    vector<int> vec;
+//     vector<int> vec;
     
-    vec.push_back(1);
-    vec.push_back(1);
+//     vec.push_back(1);
+//     vec.push_back(1);
     
-    int fib, i = 2;
+//     int fib, i = 2;
     
-    while(fib <= A){
-        fib = vec[i-2] + vec[i-1];
-        vec.push_back(fib);
-        i++;
-    }
+//     while(fib <= A){
+//         fib = vec[i-2] + vec[i-1];
+//         vec.push_back(fib);
+//         i++;
+//     }
     
-    int j = vec.size()-1;
-    int sol = 0;
+//     int j = vec.size()-1;
+//     int sol = 0;
     
-    LOOP:while(A && j >= 0){
-        if(vec[j] == A){
-            sol++;
-            return sol;
-        }
-        else if(vec[j] < A){
-            sol++;
-            A = A - vec[j];
-            goto LOOP;
-        }
-        j--;
-    }
+//     LOOP:while(A && j >= 0){
+//         if(vec[j] == A){
+//             sol++;
+//             return sol;
+//         }
+//         else if(vec[j] < A){
+//             sol++;
+//             A = A - vec[j];
+//             goto LOOP;
+//         }
+//         j--;
+//     }
     
-    return 0;
-}
+//     return 0;
+// }
diff --git a/Graphs/WordSearchBoard.cpp b/Graphs/WordSearchBoard.cpp
new file mode 100644
index 0000000..88df2b3
--- /dev/null
+++ b/Graphs/WordSearchBoard.cpp
@@ -0,0 +1,49 @@
+vector<int> x({0, 1, -1, 0});
+vector<int> y({1, 0, 0, -1});
+ 
+// Check if the coordinates are safe to visit
+bool isSafe(int a, int b, int c, int d){
+    if(a >= 0 && a < c && b >= 0 && b < d)return true;
+    return false;
+}
+
+
+void explore(bool& pivot, int val, int a, int b, vector<string>& A, string B){
+    // If reached on the last index of the string,
+    // it means we have found the reqd. string and 
+    // so we return
+    if(val == B.size()-1){
+        pivot = true;
+        return;
+    }
+
+    for(int i = 0; i < x.size(); i++){
+        int first = a + x[i];
+        int second = b + y[i];
+        
+        // Explore the adjacent node only if its value is the next index in the
+        // given string
+        if(isSafe(first, second, A.size(), A[0].size()) && A[first][second] == B[val+1]){
+            explore(pivot, val+1, first, second, A, B);
+            // To reduce time limit.
+            if(pivot == true)return;
+        }
+    }
+
+}
+
+int Solution::exist(vector<string> &A, string B) {
+    int l = A.size(), m = A[0].size();
+    if(l == 0)return 0;
+
+    bool pivot = false;
+    for(int i = 0; i < l; i++){
+        for(int k = 0; k < m; k++){
+            if(A[i][k] == B[0]){
+                explore(pivot, 0, i, k, A, B);
+            }
+            if(pivot)return pivot;
+        }
+    }
+    return pivot;
+}
diff --git a/Graphs/knightOnAChess.cpp b/Graphs/knightOnAChess.cpp
new file mode 100644
index 0000000..b97ce52
--- /dev/null
+++ b/Graphs/knightOnAChess.cpp
@@ -0,0 +1,40 @@
+vector<int> x ({1, 2, 2, 1, -1, -2, -1, -2});
+vector<int> y ({2, 1, -1, -2, 2, 1, -2, -1});
+
+bool isSafe(int i , int j ,int N, int M){
+    if(i >= 0 && i < N && j >= 0 && j < M)return true;
+    
+    return false;
+}
+
+int explore(queue<pair<int, pair<int, int> > >& q, int A, int B, int C, int D, int E, int F, vector<vector<int> >& visited, int &count){
+    while(!q.empty()){
+        int distance = q.front().first;
+        int c = q.front().second.first;
+        int d = q.front().second.second;
+        q.pop();
+        if ( c == E && d == F)return distance;
+        visited[c][d] = 1;
+
+        for(int i = 0; i < x.size(); i++){
+            int first = c + x[i];
+            int second = d + y[i];
+            if(isSafe(first, second, A, B)){
+                if(visited[first][second] == 0){
+                    visited[first][second] = 1;
+                    q.push({distance+1, {first, second}});
+                }
+            }
+        }
+    }
+    return -1;
+}
+
+int Solution::knight(int A, int B, int C, int D, int E, int F) {
+    vector<vector<int> > visited (A, vector<int> (B, 0));
+    
+    int count  = 0;
+    queue<pair<int, pair<int, int> > > q;
+    q.push({0, {C-1, D-1}});
+    return explore(q, A, B, C-1, D-1, E-1, F-1, visited, count);
+}
diff --git a/Hashing/Anagrams.cpp b/Hashing/Anagrams.cpp
index cde7fc5..411090b 100644
--- a/Hashing/Anagrams.cpp
+++ b/Hashing/Anagrams.cpp
@@ -1,30 +1,12 @@
 // https://www.interviewbit.com/problems/anagrams/
 
-string mySort(string temp){
-    vector<int> str;
-    for(int i = 0; i < temp.size(); i++){
-        str.push_back((int)temp[i]);
-    }
-    sort(str.begin(), str.end());
-    string ans = "";
-    for(int i = 0; i < str.size(); i++){
-        ans = ans + (char)str[i];
-    }
-    
-    return ans;
-}
-
 vector<vector<int> > Solution::anagrams(const vector<string> &A) {
-    // Do not write main() function.
-    // Do not read input, instead use the arguments to the function.
-    // Do not print the output, instead return values as specified
-    // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
-    
     vector<vector<int> > sol;
     unordered_map<string, vector<int> > myMap;
-    
+    string temp;
     for(int i = 0; i < A.size(); i++){
-        string temp = mySort(A[i]);
+        temp = A[i];
+        sort(temp.begin(),temp.end());
         myMap[temp].push_back(i+1);
     }
     
diff --git a/Heaps-and-Maps/WaysToFormMaxHeap.cpp b/Heaps-and-Maps/WaysToFormMaxHeap.cpp
new file mode 100644
index 0000000..acf5370
--- /dev/null
+++ b/Heaps-and-Maps/WaysToFormMaxHeap.cpp
@@ -0,0 +1,47 @@
+long long dp[105];
+long long comb[105][105];
+#define MOD 1000000007
+int rec(int n)
+{
+    if(n<=1)
+        return 1;
+    if(dp[n] != -1)
+        return dp[n];
+    int i;
+    int fill = 0;
+    int pw = 2;
+    int left,right;
+    left = right = 0;
+    
+    while(fill+pw < n-1)
+    {
+        fill += pw;
+        left += pw/2;
+        right += pw/2;
+        pw *= 2;
+    }
+    int rem = n-1-fill;
+    if(rem > pw/2)
+    {
+        left += pw/2;
+        right += (rem-pw/2);
+    }
+    else
+        left += rem;
+
+    return dp[n] = (((rec(left)*1LL*rec(right))%MOD)*1LL*comb[n-1][left])%MOD;
+}
+int Solution::solve(int A)
+{
+    int i,j;
+    for(i=0;i<=100;i++)
+        dp[i] = -1;
+    comb[0][0] = 1;
+    for(i=1;i<=100;i++)
+    {
+        comb[i][0] = comb[i][i] = 1;
+        for(j=1;j<i;j++)
+            comb[i][j] = (comb[i-1][j-1]+comb[i-1][j])%MOD;
+    }
+    return rec(A);
+}
diff --git a/Linked-Lists/ReverseLinkedList.cpp b/Linked-Lists/ReverseLinkedList.cpp
index d46f086..d462627 100644
--- a/Linked-Lists/ReverseLinkedList.cpp
+++ b/Linked-Lists/ReverseLinkedList.cpp
@@ -29,3 +29,15 @@ ListNode* Solution::reverseList(ListNode* A) {
     
     return prev;
 }
+
+// A recursive implementation for the same problem.
+// 
+// ListNode* Solution::reverseList(ListNode* A) {
+//     if(!A || !A->next)return A;
+    
+//     ListNode* head = A->next;
+//     ListNode* p = reverseList(A->next);
+//     A->next->next = A;
+//     A->next = NULL;
+//     return p;
+// }
diff --git a/Math/CityTour.cpp b/Math/CityTour.cpp
new file mode 100644
index 0000000..790b517
--- /dev/null
+++ b/Math/CityTour.cpp
@@ -0,0 +1,164 @@
+static const int MODULUS = 1000000007;
+
+// compute 2^k modulo MODULUS
+int power2modulo(int k)
+{
+    long result = 1;
+    for (int i=0; i<k; i++) {
+        result = (result + result) % MODULUS;
+    }
+    return result;
+}
+
+// compute greatest common divisor
+int gcd(int A, int B) {
+    int T;
+    if (A < B)
+        std::swap(A, B);
+    while (B != 0) {
+        T = B;
+        B = A % B;
+        A = T;
+    }
+    return A;
+}
+
+// compute binomial coefficient with modulo arithmetic
+long binomial(int n, int r)
+{
+    priority_queue<int> numerator, denominator;
+    priority_queue<int> new_numerator, new_denominator;
+    int a = std::max(r, n - r);
+    int b = n - a;
+    long result = 1;
+    long T;
+    
+    // do not compute factorials, but push the terms that make up the factorials
+    for (int i=a+1; i<=n; i++) {
+        numerator.push(i);
+    }
+    for (int i=2; i<=b; i++) {
+        denominator.push(i);
+    }
+    
+    // we try to cancel out the GCD of each numerator with each denominator
+    int n_len = numerator.size();
+    for (int i=0; i<n_len; i++) {
+        int num = numerator.top();
+        numerator.pop();
+        if (num == 1)
+            break;  // we can exit here because we use priority_queue
+        int d_len = denominator.size();
+        for (int j=0; j<d_len; j++) {
+            int den = denominator.top();
+            denominator.pop();
+            // we reduce numerator and denominator using GCD
+            long factor = gcd(num, den);
+            num /= factor;
+            den /= factor;
+            if (den != 1) {
+                new_denominator.push(den);
+            }
+            if (num == 1) {
+                break;
+            }
+        }
+        if (num != 1) {
+            new_numerator.push(num);
+        }
+        while (!new_denominator.empty()) {
+            denominator.push(new_denominator.top());
+            new_denominator.pop();
+        }
+    }
+
+    // at this point we should have exhausted all the denominators    
+    assert(denominator.empty());
+    
+    // now we multiply the remaining numerator terms using modulo arithmetic
+    while (!new_numerator.empty()) {
+        result *= new_numerator.top();
+        result %= MODULUS;
+        new_numerator.pop();
+    }
+    
+    return result;
+}
+
+// A segment is defined by a length and a multiplier.
+// The length is the number of unvisited cities in a row.
+// The multiplier is how many different paths can be made to visit all the cities.
+typedef pair<int,int> segment_t;
+typedef vector<segment_t> segments_t;
+
+// Compute the number of permutations of paths,
+// Combine the two segments at a time for ease of understanding.
+// For example, consider two segments with 3 cities (AAA) and 4 cities (BBBB).
+// There are 7 choose 3 ways to interleave the cities from the two segments.
+// One such interleaving pattern is: ABAABBB.
+// If there are X different paths for the A cities and Y different paths for B,
+// the new combined segment has 7 cities and 7 choose 3 times X times Y paths.
+int arrangements(segments_t &segments) {
+    long num_paths;
+    while (true) {
+        auto itA = segments.begin();
+        auto itB = segments.end()-1;
+        if (itA == itB) {
+            num_paths = itA->second;
+            break;
+        } else {
+            itA->first += itB->first;
+            num_paths = binomial(itA->first, itB->first);
+            num_paths %= MODULUS;
+            num_paths = (num_paths * itA->second) % MODULUS;
+            num_paths = (num_paths * itB->second) % MODULUS;
+            itA->second = num_paths;
+            segments.erase(itB);
+        }
+    }
+    return num_paths;
+}
+
+int Solution::solve(int A, vector<int> &B) {
+    priority_queue<int> V;
+    segments_t segments;
+
+    if (B.size() == 0)
+        return 0;
+
+    // Insert B into priority queue V so we can sort the cities.
+    for (auto p : B) {
+        V.push(p);
+    }
+
+    int right = V.top();
+    V.pop();
+    if (right < A) {
+        // Account for corner case where last region is one-sided.
+        // In this case, there is only one path.
+        segments.push_back(pair<int,int>(A - right, 1));
+    }
+    while (!V.empty()) {
+        if ((V.top() + 1) == right) {
+            // We skip over adjacent cities that have been visited.
+            V.pop();
+            --right;
+        } else {
+            // We make a maximal segment of consecutive unvisited cities.
+            int consecutive = right;
+            right = V.top();
+            V.pop();
+            consecutive -= right + 1;
+            // For a segment of N consecutive unvisited cities bordered on both sides
+            // by visited cities, there are 2^^(N-1) posible paths.
+            // Record the length and number of paths.
+            segments.push_back(segment_t(consecutive, power2modulo(consecutive-1)));
+        }
+    }
+    if (right != 1) {
+        // Account for corner case where last region is one-sided.
+        segments.push_back(segment_t(right - 1, 1));
+    }
+
+    return arrangements(segments);
+}
\ No newline at end of file
diff --git a/Math/FizzBuzz.cpp b/Math/FizzBuzz.cpp
new file mode 100644
index 0000000..97c9a58
--- /dev/null
+++ b/Math/FizzBuzz.cpp
@@ -0,0 +1,17 @@
+//see this to check other variations of fizzbuzz: https://www.geeksforgeeks.org/fizz-buzz-implementation/
+
+vector<string> Solution::fizzBuzz(int A) {
+    vector<string> v;
+    for(int i=1; i<=A; i++)
+    {
+        if(i%15==0)
+            v.push_back("FizzBuzz");
+        else if(i%3==0)
+            v.push_back("Fizz");
+        else if(i%5==0)
+            v.push_back("Buzz");
+        else
+            v.push_back(to_string(i));
+    }
+    return v;
+}
diff --git a/Math/LargestCoprimeDivisor.cpp b/Math/LargestCoprimeDivisor.cpp
new file mode 100644
index 0000000..a83953b
--- /dev/null
+++ b/Math/LargestCoprimeDivisor.cpp
@@ -0,0 +1,10 @@
+//reference: https://www.geeksforgeeks.org/largest-number-divides-x-co-prime-y/
+//Note: you can write the function for gcd [i'm using inbuilt gcd function in c++]
+
+int Solution::cpFact(int x, int y) {
+
+    while (__gcd(x, y) != 1) {
+        x = x / __gcd(x, y);
+    }
+    return x;
+}
diff --git a/Math/NumbersOfLengthN.cpp b/Math/NumbersOfLengthN.cpp
new file mode 100644
index 0000000..ab47920
--- /dev/null
+++ b/Math/NumbersOfLengthN.cpp
@@ -0,0 +1,50 @@
+int all(bool digits[], int B, int total) {
+    bool isZero = digits[0] ? 1 : 0;
+    long long int count = 1;
+    if (B == 1) {
+        return total;
+    }
+    count *= isZero ? total - 1 : total;
+    count *= pow(total, B - 1);
+    return count;
+}
+int compare(bool digits[], int B, int C, int total) {
+    string c = to_string(C);
+    vector<int> count(10);
+    for (int i = 1; i < 10; i ++) {
+        count[i] = digits[i - 1] + count[i - 1];
+    }
+    int dp[B + 1];
+    dp[0] = 0;
+    bool flag = 1;
+    for (int i = 1; i <= B; i ++) {
+        dp[i] = dp[i - 1] * total;
+        if (flag || i == 1) {
+            int smallCount = count[c[i - 1] - '0'];
+            if (B != 1 && i == 1 && digits[0]) {
+                smallCount --;
+            }
+            dp[i] += smallCount;
+            if (!digits[c[i - 1] - '0']) {
+                flag = false;
+            }
+        }
+    }
+    return dp[B];
+}
+int Solution::solve(vector<int> &A, int B, int C) {
+    int length = log10(C) + 1;
+    bool digits[10] = {0};
+    int total = 0;
+    for (int i = 0; i < A.size(); i ++) {
+        digits[A[i]] = 1;
+        total ++;
+    }
+    if (B > length || B == 0) {
+        return 0;
+    } else if (B < length) {
+        return all(digits, B, total);
+    } else {
+        return compare(digits, B, C, total);    
+    }
+}
diff --git a/Math/SortedPermutationRank.cpp b/Math/SortedPermutationRank.cpp
new file mode 100644
index 0000000..4693785
--- /dev/null
+++ b/Math/SortedPermutationRank.cpp
@@ -0,0 +1,46 @@
+#define mod 1000003
+
+void buildFact(vector<long> &fact,int len){
+    fact.push_back(1);
+    fact.push_back(1);
+    for(int i = 2; i<= len ; i++){
+        fact.push_back((fact[i-1]*i)%mod);
+    }
+}
+
+int Solution::findRank(string A){
+    vector<long> fact;
+    // create a vector filled with factorial value of that index modulated
+    buildFact(fact,A.length());
+    
+    // created a sorted version of given string
+    string b = A;
+    sort(b.begin() , b.end());
+    
+    // create to Hash to store actual location of each character in sorted manner
+    unordered_map<char , int> pos;
+    for(int i = 0; i<b.length(); i++)
+        pos[b[i]] = i;
+    
+    // vector contains actual index for given index.
+    vector<int> v;
+    for(int i = 0; i<A.length(); i++)
+        v.push_back(pos[A[i]]);
+    
+    // setting vector for factorial arithmatics
+    for(int i = 0; i<v.size(); i++){
+        for(int j = i+1; j<v.size(); j++){
+            if(v[j] > v[i])
+                v[j]--;
+        }
+    }
+    reverse(v.begin() , v.end());
+    
+    // factorial arithmatics
+    long n = 0;
+    for(int i = 0; i < v.size() ; i++){
+        n = (n + v[i]*fact[i])%mod;
+    }
+    n++;
+    return n;
+}
diff --git a/Math/SortedPermutationRankWithRepeats.cpp b/Math/SortedPermutationRankWithRepeats.cpp
new file mode 100644
index 0000000..c42bdda
--- /dev/null
+++ b/Math/SortedPermutationRankWithRepeats.cpp
@@ -0,0 +1,62 @@
+#define MOD 1000003
+long long int fact(int n) {
+    if (n == 0 || n == 1) {
+        return 1;
+    }
+    return (fact(n - 1) * n) % MOD;
+}
+ long long int inverseNumber(int num) {
+    long long int ans = 1, base = (long long) num;
+    int power = MOD - 2;
+    while (power > 0) {
+        if (power == 1) {
+            return (ans * base) % MOD;
+        }
+        if (power % 2 == 0) {
+            base = (base * base) % MOD;
+            power /= 2;
+        } else {
+            ans = (ans * base) % MOD;
+            power--;
+        }
+    }
+    return ans;
+}
+int Solution::findRank(string A) {
+    if (A.size() <= 0) {
+        return 0;
+    }
+    int alpha[52] = {0};
+    for (int i = 0; i < A.size(); i ++) {
+        if (islower(A[i])) {
+            alpha[A[i] - 'a' + 26] ++;
+        } else {
+            alpha[A[i] - 'A'] ++;
+        }
+    }
+    long long int total = 0;
+    for (int i = 0; i < A.size(); i ++) {
+        long long localCount = 0;
+        int size = islower(A[i]) ? A[i] - 'a' + 26 : A[i] - 'A';
+        long long int count = (fact(A.size() - i - 1));
+        for (int j = 0; j < size; j ++) {
+            if (alpha[j]) {
+                alpha[j] --;
+                localCount = count;
+                for (int k = 0; k < 52; k ++) {
+                    if (alpha[k]) {
+                        localCount = (localCount * inverseNumber(fact(alpha[k]))) % MOD;
+                    }
+                }
+                alpha[j] ++;
+                total = (total + localCount) % MOD;
+            }
+        }
+        if (islower(A[i])) {
+            alpha[A[i] - 'a' + 26] --;
+        } else {
+            alpha[A[i] - 'A'] --;
+        }
+    }
+    return (total + 1) % MOD;
+}
diff --git a/Stacks-and-Queues/Simplify Directory Path.cpp b/Stacks-and-Queues/Simplify Directory Path.cpp
new file mode 100644
index 0000000..4246dae
--- /dev/null
+++ b/Stacks-and-Queues/Simplify Directory Path.cpp	
@@ -0,0 +1,36 @@
+//https://www.interviewbit.com/problems/simplify-directory-path/
+
+string Solution::simplifyPath(string A) {
+    stack<string> st;
+    
+    int len = A.length();
+    
+    for(int i=0;i<len;i++){
+        if(A[i]=='/'){
+            continue;
+        }
+        if(A[i]=='.'){
+            if(i+1<len && A[i+1]=='.'){
+                if(!st.empty())
+                    st.pop();
+                i++;
+            }
+        }
+        else{
+            string tem="";
+            while(i<len && A[i]!='/'){
+                tem = tem+A[i];
+                i++;
+            }
+            st.push(tem);
+        }
+    }
+    string ans = "";
+    while(!st.empty()){
+        ans = "/"+st.top()+ans;
+        st.pop();
+    }
+
+    return (ans=="")?"/":ans;
+    
+}
diff --git a/Strings/PalindromeString.cpp b/Strings/PalindromeString.cpp
index 650ffd3..081521c 100644
--- a/Strings/PalindromeString.cpp
+++ b/Strings/PalindromeString.cpp
@@ -1,5 +1,43 @@
 // https://www.interviewbit.com/problems/palindrome-string/
 
+int Solution::isPalindrome(string A) {
+    
+    int len = A.length();
+    
+    for(int i=0;i<len;i++)
+    {
+        A[i] = tolower(A[i]);
+    }
+    
+    int l = 0;
+    int h = len;
+    
+    while(l<=h)
+    {
+        if(!(A[l]>='a' && A[l]<='z') && !(A[l]>='0' && A[l]<='9'))
+        {
+            l++;
+        }
+        
+        else if(!(A[h]>='a' && A[h]<='z') && !(A[h]>='0' && A[h]<='9'))
+        {
+            h--;
+        }
+        else if(A[l] == A[h])
+        {
+            l++;
+            h--;
+        }
+        else
+        {
+            return 0;
+        }
+    }
+    
+    return 1;
+}
+
+/*
 int Solution::isPalindrome(string A) {
     // Do not write main() function.
     // Do not read input, instead use the arguments to the function.
@@ -85,3 +123,4 @@ int Solution::isPalindrome(string A) {
     
     return 1;
 }
+*/
diff --git a/Strings/PrettyJson.cpp b/Strings/PrettyJson.cpp
new file mode 100644
index 0000000..4957cff
--- /dev/null
+++ b/Strings/PrettyJson.cpp
@@ -0,0 +1,60 @@
+vector<string> Solution::prettyJSON(string A) 
+{
+    int n = A.size(),i,j;
+    vector< string >ans;
+    int tbctr = 0;
+    i = 0;
+    bool flag = false;
+    while(i<n)
+    {
+        string row = "";
+        for(j=0;j<tbctr;j++)
+            row += '\t';
+            flag = false;
+        for(j=i;j<n;j++)
+        {
+            if(A[j] == '[' || A[j] == '{')
+            {
+                if(flag)
+                    ans.push_back(row);
+                row = "";
+                for(int k=0;k<tbctr;k++)
+                    row += '\t';
+                row += A[j];
+                ans.push_back(row);
+                i = j+1;
+                tbctr++;
+                
+                break;
+            }
+            if(A[j] == ']' || A[j] == '}')
+            {
+                tbctr--;
+                if(flag)
+                    ans.push_back(row);
+                row = "";
+                for(int k=0;k<tbctr;k++)
+                    row += '\t';
+                row += A[j];
+                if(j + 1 < n && A[j+1] == ',')
+                    row += A[++j];
+                ans.push_back(row);
+                i = j+1;
+                break;
+            }
+            row += A[j];
+            flag = true;
+            i = j+1;
+            if(A[j] == ',')
+            {
+                if(flag)
+                    ans.push_back(row);
+                i = j+1;
+                break;
+            }
+        }
+      //  i = j+1;
+    //    i++;
+    }
+    return ans;
+}
diff --git a/Strings/Stringoholics.cpp b/Strings/Stringoholics.cpp
new file mode 100644
index 0000000..25f7e80
--- /dev/null
+++ b/Strings/Stringoholics.cpp
@@ -0,0 +1,91 @@
+#define MOD 1000000007
+typedef long long ll;
+
+// Helper function to return progressive sum
+
+ll prod(ll n) {
+    return ((n * (n + 1))) / 2;
+}
+
+// Function to return the min time taken to get the original string after rotation
+
+ll timeTaken(string s) {
+    if (s.size() == 1) {
+        return 1;
+    }
+    while (s.size() % 2 == 0) {
+        string firstHalf = string(s.begin(), s.begin() + s.size() / 2);
+        string secondHalf = string(s.begin() + s.size() / 2, s.end());
+        if (firstHalf == secondHalf) {
+            s = firstHalf;
+        } else break;
+    }
+    ll res = 1;
+    int i = 1;
+    for (; i < 2 * s.size(); i ++) {
+        if (prod(i) % s.size() == 0) {
+            return i;
+        }
+    }
+    return i; 
+}
+
+// Create sieve of erastothenes and map prime numbers
+
+unordered_map<ll, ll> makeSieve(int n = 500) {
+    unordered_map<ll, ll> umap;
+    vector<bool> num(n, 1);
+    for (int i = 2; i * i <= n; i ++) {
+        for (int j = 2; j * i <= n; j ++) {
+            num[i * j] = 0;
+        }
+    }
+    for (int i = 2; i < num.size(); i ++) {
+        if (num[i]) {
+            umap[i] = 0;    
+        }
+    }
+    return umap;
+}
+
+// Seperate the factors of the min. time to get LCM
+
+void seperateFactors(ll num, unordered_map<ll, ll> &umap) {
+    for (auto it: umap) {
+        ll exponentVal = 0;
+        if (num % it.first == 0) {
+            while (num % it.first == 0) {
+                exponentVal ++;
+                num /= it.first;
+            }
+            if (exponentVal > it.second) {
+                umap[it.first] = exponentVal;    
+            }
+        }
+    }
+    if (num != 1) {
+        umap[num] = 1;    
+    }
+    return;
+}
+
+// Driver
+
+int Solution::solve(vector<string> &A) {
+    ll res = 1;
+    auto umap = makeSieve();
+    for (int i = 0; i < A.size(); i ++) {
+        long long val = timeTaken(A[i]);
+        seperateFactors(val, umap);
+    }
+    for (auto it: umap) {
+        ll expVal = 1;
+        ll maxExp = it.second;
+        while (maxExp) {
+            expVal = (expVal * it.first) % MOD;
+            maxExp --;
+        }
+        res = (res * expVal) % MOD;
+    }
+    return res;
+}
\ No newline at end of file
diff --git a/Strings/ValidIPAddresses.cpp b/Strings/ValidIPAddresses.cpp
index 00a5bd1..f94148a 100644
--- a/Strings/ValidIPAddresses.cpp
+++ b/Strings/ValidIPAddresses.cpp
@@ -137,3 +137,51 @@ vector<string> Solution::restoreIpAddresses(string A) {
     
     return sol;
 }
+
+// Alternate solution using recursion
+
+// Helper function to check validity of a string
+
+bool checkValidNum(string a) {
+    return a.size() > 1 && a[0] == '0' ? 0 : stoll(a) >= 0 && stoll(a) <= 255;
+}
+
+// Helper function to check validity of a whole IP
+
+bool checkValidIP(string a) {
+    int occurences = count(a.begin(), a.end(), '.');
+    if (occurences != 3) {
+        return 0;
+    }
+    int start = 0;
+    while (a.find('.', start) != string::npos) {
+        string temp = a.substr(start, a.find('.', start) - start);
+        if (!checkValidNum(temp)) {
+            return 0;
+        }
+        start = a.find('.', start) + 1;
+    }
+    return checkValidNum(a.substr(start));
+}
+
+// Helper function to generate all possibilities
+
+void generate (string A, vector<string> &res, int index, string local) {
+    if (index >= A.size()) {
+        if (checkValidIP(local)) {
+            res.push_back(local);
+        }
+        return;
+    }
+    for (int i = 1; i <= A.size() - index; i ++) {
+        string temp = A.substr(index, i);
+        generate(A, res, index + i, local.size() ? local + "." + temp : temp);
+    }
+    return;
+}
+vector<string> Solution::restoreIpAddresses(string A) {
+    vector<string> res;
+    generate(A, res, 0, string());
+    return res;
+}
+
diff --git a/Trees/2-SumBinaryTree.cpp b/Trees/2-SumBinaryTree.cpp
index 35fc495..d4dcfd2 100644
--- a/Trees/2-SumBinaryTree.cpp
+++ b/Trees/2-SumBinaryTree.cpp
@@ -9,72 +9,212 @@
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
-
+// A shorter and intuitive method. Check out the next two solutions as well.
 int Solution::t2Sum(TreeNode* A, int B) {
+    // Base Case
+    if(!A)return 0;
     
-    stack<TreeNode*> st1;
-    stack<TreeNode*> st2;
-    
-    int val1 = 0, val2 = 0;
-    int done1 = 0, done2 = 0;
+    // Make two stacks for the two different traversals,
+    // one from the right side, other from the left.
+    stack<TreeNode*> s1, s2;
+    TreeNode* temp1 = A, *temp2 = A;
     
-    TreeNode* curr1 = A;
-    TreeNode* curr2 = A;
+    // Take temp1 to the extreme left
+    while(temp1){
+        s1.push(temp1);
+        temp1 = temp1->left;
+    }
     
+    // and temp2 to extreme right
+    while(temp2){
+        s2.push(temp2);
+        temp2 = temp2->right;
+    }
+    temp1 = s1.top();
+    temp2 = s2.top();
     
-    while(1){
-        while(done1 == 0){
-            if(curr1 != NULL){
-                st1.push(curr1);
-                curr1 = curr1->left;
+    // While we do not traverse the complete tree
+    while(temp1 and temp2 and temp1->val < temp2 -> val){
+        if(temp1->val + temp2->val == B)return 1;
+
+        if(temp1->val + temp2->val < B){
+            // Move Ahead the temp1 pointer
+            s1.pop();
+            // Check out the preorder traversal using stacks 
+            temp1 = temp1->right;
+            while(temp1){
+                s1.push(temp1);
+                temp1 = temp1->left;
             }
-            else{
-                if(st1.empty()){
-                    done1 = 1;
-                }
-                else{
-                    curr1 = st1.top();
-                    val1 = curr1->val;
-                    st1.pop();
-                    curr1 = curr1->right;
-                    done1 = 1;    
-                }
+            temp1 = s1.top();
+        }else{
+            // Move ahead the temp2 pointer
+            s2.pop();
+            // Inverse of preorder traversal using stacks 
+            // (not to be confused with postorder traversal)
+            temp2 = temp2->left;
+            while(temp2){
+                s2.push(temp2);
+                temp2 = temp2->right;
             }
+            temp2 = s2.top();
         }
+    }
+    return 0;
+}
+
+
+// int Solution::t2Sum(TreeNode* A, int B) {
+    
+//     stack<TreeNode*> st1;
+//     stack<TreeNode*> st2;
+    
+//     int val1 = 0, val2 = 0;
+//     int done1 = 0, done2 = 0;
+    
+//     TreeNode* curr1 = A;
+//     TreeNode* curr2 = A;
+    
+    
+//     while(1){
+//         while(done1 == 0){
+//             if(curr1 != NULL){
+//                 st1.push(curr1);
+//                 curr1 = curr1->left;
+//             }
+//             else{
+//                 if(st1.empty()){
+//                     done1 = 1;
+//                 }
+//                 else{
+//                     curr1 = st1.top();
+//                     val1 = curr1->val;
+//                     st1.pop();
+//                     curr1 = curr1->right;
+//                     done1 = 1;    
+//                 }
+//             }
+//         }
         
-        while(done2 == 0){
-            if(curr2 != NULL){
-                st2.push(curr2);
-                curr2 = curr2->right;
-            }
-            else{
-                if(st2.empty()){
-                    done2 = 1;
-                }
-                else{
-                    curr2 = st2.top();
-                    st2.pop();
-                    val2 = curr2->val;
-                    curr2 = curr2->left;
-                    done2 = 1;
-                }
-            }
-        }
+//         while(done2 == 0){
+//             if(curr2 != NULL){
+//                 st2.push(curr2);
+//                 curr2 = curr2->right;
+//             }
+//             else{
+//                 if(st2.empty()){
+//                     done2 = 1;
+//                 }
+//                 else{
+//                     curr2 = st2.top();
+//                     st2.pop();
+//                     val2 = curr2->val;
+//                     curr2 = curr2->left;
+//                     done2 = 1;
+//                 }
+//             }
+//         }
         
-        if(((val1 + val2) == B) && (val1 != val2)){
-            return 1;
-        }
-        else if((val1 + val2) < B){
-            done1 = 0;
-        }
-        else if((val1 + val2) > B){
-            done2 = 0;
-        }
+//         if(((val1 + val2) == B) && (val1 != val2)){
+//             return 1;
+//         }
+//         else if((val1 + val2) < B){
+//             done1 = 0;
+//         }
+//         else if((val1 + val2) > B){
+//             done2 = 0;
+//         }
         
-        if(val1 >= val2){
-            return 0;
-        }
-    }
+//         if(val1 >= val2){
+//             return 0;
+//         }
+//     }
     
-    return 0;
-}
+//     return 0;
+// }
+
+/*
+Another method if you are unable to get above method, although both of them work the same.
+*/
+
+
+// bool isPairPresent(int K, TreeNode* A, TreeNode* B, stack<TreeNode*> s1, stack<TreeNode*> s2){
+//     // Base Case
+//     if(!A)return 0;
+
+//     // Go to the extreme left
+//     while(A){
+//         s1.push(A);
+//         A = A ->left;
+//     }
+//     // Go to the extreme right
+//     while(B){
+//         s2.push(B);
+//         B = B->right;
+//     }
+
+//     Get the lowest and highest elements.
+//     A = s1.top(); s1.pop();
+//     B = s2.top(); s2.pop();
+    
+//     // Make the extremes as lowest and highest values (coz BST)
+//     int low = A->val, high = B->val;
+//     bool b1 = true;
+//     bool b2 = true;
+//     // While we don't cross the two pointers
+//     while(low < high){
+//         // Return if we have found the sum
+//         if(low + high == K)return 1;
+//         // If the sum is less, increase the lower pointer only.
+//         if(low + high < K){
+//             b2 = false;
+//             b1 = true;
+//         }
+//         // Else decrement the higher pointer only.
+//         else {
+//             b2 = true;
+//             b1 = false;
+//         }
+//         if(b1){
+//             // If the pointer is not NULL, take it to the extreme left
+//             // of its right child
+//             if(A){
+//                 A = A->right;
+//                 while(A){
+//                     s1.push(A);
+//                     A = A->left;
+//                 }
+//             }
+//             // Else just pop the top of the stack and make it as the lowest pointer.
+//             else {
+//                 A = s1.top();
+//                 s1.pop();
+//                 low = A->val;
+//             }
+//         }
+//         // Same as above.
+//         else if(b2){
+            
+//             if(B){
+//                 B = B->left;
+//                 while(B){
+//                     s2.push(B);
+//                     B = B->right;
+//                 }
+//             }else {
+//                 B = s2.top();
+//                 s2.pop();
+//                 high = B->val;
+//             }
+//         }
+//     }
+//     return 0;
+// }
+
+// int Solution::t2Sum(TreeNode* A, int B) {
+//     stack<TreeNode*> s1, s2;
+
+//     TreeNode *head1 = A, *head2 = A;
+    
+//     return isPairPresent(B, head1, head2, s1, s2);
+// }
diff --git a/Trees/BinaryTreeFromInorderAndPostorder.cpp b/Trees/BinaryTreeFromInorderAndPostorder.cpp
new file mode 100644
index 0000000..743e93b
--- /dev/null
+++ b/Trees/BinaryTreeFromInorderAndPostorder.cpp
@@ -0,0 +1,37 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+int search(vector<int> &in, int str, int end, int val){
+    for(int k=str; k<=end; k++)
+        if(in[k] == val)
+            return k;
+}
+
+TreeNode* getTre(vector<int> &post, vector<int> &in, int start, int end, int &treeIndex){
+
+    if(start > end)
+        return NULL;
+
+    TreeNode* node = new TreeNode(post[treeIndex--]);
+
+    if(start == end)
+        return node;
+
+    int root = search(in, start, end, node->val);
+
+    node->right = getTre(post, in, root+1, end, treeIndex);
+    node->left = getTre(post, in, start, root-1, treeIndex);
+
+    return node;
+}
+
+TreeNode* Solution::buildTree(vector<int> &in, vector<int> &post) {
+    int treeIndex = in.size()-1;
+    return getTre(post, in, 0, in.size()-1, treeIndex);
+}
diff --git a/Trees/ConstructBinaryTreeFromInorderAndPreorder.cpp b/Trees/ConstructBinaryTreeFromInorderAndPreorder.cpp
index 1076071..007d778 100644
--- a/Trees/ConstructBinaryTreeFromInorderAndPreorder.cpp
+++ b/Trees/ConstructBinaryTreeFromInorderAndPreorder.cpp
@@ -7,10 +7,10 @@
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
-int index(vector<int> v, int val, int start, int end){
+int index(vector<int> &inorder, int val, int start, int end){
     int i;
     for(i = start; i <= end; i++){
-        if(v[i] == val){
+        if(inorder[i] == val){
             return i;
         }
     }
diff --git a/Trees/HotelReviews.cpp b/Trees/HotelReviews.cpp
new file mode 100644
index 0000000..2fbb1ba
--- /dev/null
+++ b/Trees/HotelReviews.cpp
@@ -0,0 +1,115 @@
+struct TrieNode{
+    bool isWord;
+    unordered_map<char, TrieNode*> children;
+    TrieNode(bool word): isWord(word) {}
+};
+
+struct res {
+    int index, score;
+};
+
+void tokenize (string good_string, vector<string> &goodWords) {
+    good_string += "_";
+    string temp="";
+    
+    for (int i=0; i<good_string.length(); i++) {
+        if (good_string[i]!='_') {
+            temp += good_string[i];
+        } else {
+            if (temp.length()) {
+                goodWords.push_back(temp);
+                temp = "";
+            }
+        }
+    }
+}
+
+bool sortByScore (res lhs, res rhs) {
+    if (lhs.score > rhs.score) return true;
+    else if (lhs.score == rhs.score) return lhs.index < rhs.index;
+    return false;
+}
+
+void constructTrie(TrieNode* A, vector<string> goodWords) {
+    TrieNode* current = A;
+    
+    for (int i=0; i<goodWords.size(); i++) {
+        current = A;
+        
+        for (int j=0; j<goodWords[i].length(); j++) {
+            auto it = (current->children).find(goodWords[i][j]);
+            
+            if (it != (current->children).end()) {
+                current = it->second;
+            } else {
+                
+                TrieNode* B = new TrieNode(false);
+                (current->children)[goodWords[i][j]] = B;
+                current = B;
+                
+            }
+            
+            if (j == goodWords[i].length()-1) current->isWord = true;
+        }
+    }
+    
+}
+
+vector<int> sortReviews(vector<string> reviews, TrieNode* root) {
+    int score;
+    vector<res> result;
+    TrieNode* current;
+    
+    vector<string> temp;
+    
+    
+    
+    for (int i=0; i<reviews.size(); i++) {
+        res t;
+        temp.clear();
+        score = 0;
+        reviews[i] +=  "_";
+        tokenize(reviews[i], temp);
+        
+        for (int j=0; j<temp.size(); j++) {
+            current = root;
+            for (int k=0; k<temp[j].length(); k++) {
+                
+                auto it = (current->children).find(temp[j][k]);
+                if (it == (current->children).end()) {
+                    break;
+                }
+                
+                current = it->second;
+                
+                if (k == temp[j].length()-1 && current->isWord) score++; 
+            }
+        }
+        t.index = i;
+        t.score = score;
+        result.push_back(t);
+    }
+    
+    sort(result.begin(), result.end(), sortByScore);
+    
+    vector<int> ret;
+    
+    for (int i=0; i<result.size(); i++) {
+        ret.push_back(result[i].index);
+    }
+    
+    return ret;
+}
+
+vector<int> Solution::solve(string A, vector<string> &B) {
+    TrieNode* root = new TrieNode(false);
+    vector<string> good_words;
+    
+    tokenize(A, good_words);
+    
+    constructTrie(root, good_words);
+    
+    vector<int> result = sortReviews(B, root);
+    
+    return result;
+}
diff --git a/Trees/MinDepthOfABinaryTree.cpp b/Trees/MinDepthOfABinaryTree.cpp
new file mode 100644
index 0000000..da628e5
--- /dev/null
+++ b/Trees/MinDepthOfABinaryTree.cpp
@@ -0,0 +1,7 @@
+int Solution::minDepth(TreeNode* A) {
+    if(!A)return 0;
+    if(!A->left and !A->right) return 1;
+    if(!A->left)return minDepth(A->right) + 1;
+    if(!A->right)return minDepth(A->left) + 1;
+    return min(minDepth(A->left), minDepth(A->right)) + 1;
+}
diff --git a/Trees/MinimumDepthOfABinaryTree.cpp b/Trees/MinimumDepthOfABinaryTree.cpp
deleted file mode 100644
index 2eb4952..0000000
--- a/Trees/MinimumDepthOfABinaryTree.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// https://www.interviewbit.com/problems/min-depth-of-binary-tree/
-
-/**
- * Definition for binary tree
- * struct TreeNode {
- *     int val;
- *     TreeNode *left;
- *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
- * };
- */
-int depth(TreeNode* root){
-    if(root == NULL){
-        return 0;
-    }
-    else if(root->left == NULL && root->right == NULL){
-        return 1;
-    }
-    else if(root->left == NULL && root->right != NULL){
-        return 1 + depth(root->right);
-    }
-    else if(root->left != NULL && root->right == NULL){
-        return 1 + depth(root->left);
-    }
-    return min(1 + depth(root->right), 1 + depth(root->left));
-}
-
-int Solution::minDepth(TreeNode* A) {
-    // Do not write main() function.
-    // Do not read input, instead use the arguments to the function.
-    // Do not print the output, instead return values as specified
-    // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
-
-    return depth(A);
-    
-}
diff --git a/Trees/PopulateNextRightPointersTree.cpp b/Trees/PopulateNextRightPointersTree.cpp
index c76b483..e7dbac0 100644
--- a/Trees/PopulateNextRightPointersTree.cpp
+++ b/Trees/PopulateNextRightPointersTree.cpp
@@ -6,47 +6,89 @@
  *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
  * };
  */
+
+// A Non-recursive solution
 void Solution::connect(TreeLinkNode* A) {
-    if(A == NULL){
-        return;
-    }
+    if(A == NULL)return;
     
-    if(A->left != NULL){
-        if(A->right != NULL){
-            (A->left)->next = A->right;
-        }
-        else{
-            TreeLinkNode* temp = A;
-            while(temp->next != NULL){
-                if((temp->next)->left != NULL){
-                    (A->left)->next = (temp->next)->left;
-                    break;
-                }
-                else if((temp->next)->right != NULL){
-                    (A->left)->next = (temp->next)->right;
-                    break;
-                } 
-                temp = temp->next;
-            }    
+    queue<pair<int, TreeLinkNode*> > q;
+    
+    q.push({0, A});
+
+    while(!q.empty()){
+        pair<int, TreeLinkNode*> temp = q.front();
+
+        int level = temp.first;
+        q.pop();
+
+//      Keep putting the nodes until we are on the same level.
+        while(!q.empty() and q.front().first == level){
+            if(temp.second->left)
+                q.push({level+1, temp.second->left});
+            if(temp.second->right)
+                q.push({level+1, temp.second->right});
+
+            temp.second->next = q.front().second;
+            temp = q.front();
+
+            q.pop();
         }
+//      
+        temp.second->next = NULL;
+        
+//      if the control doesn't enter the above while loop, accomodate
+//      the left out nodes. (Consider a three node tree!)
+        if(temp.second->left)
+            q.push({level+1, temp.second->left});
+        if(temp.second->right)
+            q.push({level+1, temp.second->right});
+        
     }
+}
+
+
+// Recursive Solution
+// void Solution::connect(TreeLinkNode* A) {
+//     if(A == NULL){
+//         return;
+//     }
     
-    if(A->right != NULL){
-        TreeLinkNode* temp = A;
-        while(temp->next != NULL){
-            if((temp->next)->left != NULL){
-                (A->right)->next = (temp->next)->left;
-                break;
-            }
-            else if((temp->next)->right != NULL){
-                (A->right)->next = (temp->next)->right;
-                break;
-            } 
-            temp = temp->next;
-        }    
-    }
+//     if(A->left != NULL){
+//         if(A->right != NULL){
+//             (A->left)->next = A->right;
+//         }
+//         else{
+//             TreeLinkNode* temp = A;
+//             while(temp->next != NULL){
+//                 if((temp->next)->left != NULL){
+//                     (A->left)->next = (temp->next)->left;
+//                     break;
+//                 }
+//                 else if((temp->next)->right != NULL){
+//                     (A->left)->next = (temp->next)->right;
+//                     break;
+//                 } 
+//                 temp = temp->next;
+//             }    
+//         }
+//     }
     
+//     if(A->right != NULL){
+//         TreeLinkNode* temp = A;
+//         while(temp->next != NULL){
+//             if((temp->next)->left != NULL){
+//                 (A->right)->next = (temp->next)->left;
+//                 break;
+//             }
+//             else if((temp->next)->right != NULL){
+//                 (A->right)->next = (temp->next)->right;
+//                 break;
+//             } 
+//             temp = temp->next;
+//         }    
+//     }
     
-    connect(A->right);
-    connect(A->left);
-}
+    
+//     connect(A->right);
+//     connect(A->left);
+// }
diff --git a/Trees/VerticalOrderTraversalOfBinaryTree.cpp b/Trees/VerticalOrderTraversalOfBinaryTree.cpp
index 72c68b1..336eaba 100644
--- a/Trees/VerticalOrderTraversalOfBinaryTree.cpp
+++ b/Trees/VerticalOrderTraversalOfBinaryTree.cpp
@@ -7,74 +7,103 @@
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
-struct node{
-    TreeNode* root;
-    int dis;
-};
 
-void make(map<int, vector<int> >& m, queue<node>& q){
-    if(q.size() == 0){
-        return;
-    }
+vector<vector<int> > Solution::verticalOrderTraversal(TreeNode* A) {
+    vector<vector<int> > v;
+    if(A == NULL)return v;
     
-    TreeNode* root = (q.front()).root;
-    int dis = (q.front()).dis;
+    queue<pair <TreeNode*, int> > q;
+    q.push({A, 0});
     
-    if(!root){
-        return;
+    map<int, vector<int> > mp;
+    while(!q.empty()){
+        pair<TreeNode*, int> temp = q.front();
+        q.pop();
+        
+        if(temp.first->left){
+            q.push({temp.first->left, temp.second-1});
+        }
+        if(temp.first->right){
+            q.push({temp.first->right, temp.second+1});
+        }
+        
+        mp[temp.second].push_back(temp.first->val);
+    }
+
+    for(map<int, vector<int> >::iterator it = mp.begin(); it != mp.end(); it++){
+        v.push_back(it->second);
     }
+    return v;
+}
+
+// struct node{
+//     TreeNode* root;
+//     int dis;
+// };
+
+// void make(map<int, vector<int> >& m, queue<node>& q){
+//     if(q.size() == 0){
+//         return;
+//     }
     
-    m[dis].push_back(root->val);
+//     TreeNode* root = (q.front()).root;
+//     int dis = (q.front()).dis;
     
-    q.pop();
+//     if(!root){
+//         return;
+//     }
     
-    if(root->left){
-        node l1;
-        l1.root =  root->left;
-        l1.dis = dis-1;
-        q.push(l1);
-    }
+//     m[dis].push_back(root->val);
     
-    if(root->right){
-        node l1;
-        l1.root =  root->right;
-        l1.dis = dis+1;
-        q.push(l1);
-    }
+//     q.pop();
     
-    make(m, q);
-}
+//     if(root->left){
+//         node l1;
+//         l1.root =  root->left;
+//         l1.dis = dis-1;
+//         q.push(l1);
+//     }
+    
+//     if(root->right){
+//         node l1;
+//         l1.root =  root->right;
+//         l1.dis = dis+1;
+//         q.push(l1);
+//     }
+    
+//     make(m, q);
+// }
 
-vector<vector<int> > Solution::verticalOrderTraversal(TreeNode* A) {
-    map<int, vector<int> > m;
-    vector<vector<int> > sol;
-    queue<node> q;
+// vector<vector<int> > Solution::verticalOrderTraversal(TreeNode* A) {
+//     map<int, vector<int> > m;
+//     vector<vector<int> > sol;
+//     queue<node> q;
     
-    node n;
-    n.root = A;
-    n.dis = 0;
+//     node n;
+//     n.root = A;
+//     n.dis = 0;
     
-    q.push(n);
+//     q.push(n);
     
-    make(m, q);
+//     make(m, q);
     
-    map<int, vector<int> > :: iterator it = m.begin();
+//     map<int, vector<int> > :: iterator it = m.begin();
     
-    int curr = 0;
+//     int curr = 0;
     
-    while(it != m.end()){
-        vector<int> temp;
-        sol.push_back(temp);
+//     while(it != m.end()){
+//         vector<int> temp;
+//         sol.push_back(temp);
         
-        temp = it->second;
+//         temp = it->second;
         
-        for(int i = 0; i < temp.size(); i++){
-            sol[curr].push_back(temp[i]);
-        }
+//         for(int i = 0; i < temp.size(); i++){
+//             sol[curr].push_back(temp[i]);
+//         }
         
-        curr++;
-        it++;
-    }
+//         curr++;
+//         it++;
+//     }
     
-    return sol;
-}
+//     return sol;
+// }
diff --git a/Two-Pointers/3Sum.cpp b/Two-Pointers/3Sum.cpp
index 412b4ba..3e9b70d 100644
--- a/Two-Pointers/3Sum.cpp
+++ b/Two-Pointers/3Sum.cpp
@@ -14,7 +14,6 @@ int Solution::threeSumClosest(vector<int> &A, int B) {
     
     int i = 0;
     int sum, minDiff = INT_MAX;
-    int count = 0;
     
     while(i < A.size()-2){
         int left = i+1;
diff --git a/Two-Pointers/3SumZero.cpp b/Two-Pointers/3SumZero.cpp
index 63cc4eb..a4d019d 100644
--- a/Two-Pointers/3SumZero.cpp
+++ b/Two-Pointers/3SumZero.cpp
@@ -1,70 +1,106 @@
-// https://www.interviewbit.com/problems/3-sum-zero/
-
 vector<vector<int> > Solution::threeSum(vector<int> &A) {
-    // Do not write main() function.
-    // Do not read input, instead use the arguments to the function.
-    // Do not print the output, instead return values as specified
-    // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
+    vector<vector<int> > v;
+    
+    if(A.size() == 0)return v;
     
-    vector<vector<int> > sol;
+    vector<pair<int, int> > v1(A.size());
     
-    if(A.size() < 2){
-        return sol;
+    for(int i = 0; i < A.size(); i++){
+        v1[i] = {A[i], i};
     }
     
-    sort(A.begin(), A.end());
+    sort(v1.begin(), v1.end());
     
-    int i = 0;
+    set<vector<int> > mp;
     
-    while(i < A.size()-2){
+    for(int i = 0; i < A.size(); i++){
+        int firset = v1[i].first;
         int j = i+1;
         int k = A.size()-1;
-        LOOP:while(j < k){
-            int sum = A[i] + A[j] + A[k];
-            if(sum == 0){
-                vector<int> temp;
-                temp.push_back(A[i]);
-                temp.push_back(A[j]);
-                temp.push_back(A[k]);
-                sol.push_back(temp);
-                temp.erase(temp.begin(),temp.end());
-                while(A[j] == A[j+1]){
-                    j++;
-                    if(j == A.size()){
-                        break;
-                    }
-                }
-                j++;                
-            }
-            else if(sum > 0){
-                while(A[k] == A[k-1]){
-                    k--;
-                    if(k == 0){
-                        break;
-                    }
-                }
-                k--;
-            }
-            else{
-                while(A[j] == A[j+1]){
-                    j++;
-                    if(j == A.size()){
-                        break;
-                    }
+        while(j < k){
+            if(v1[j].first + v1[k].first + firset  == 0){
+                vector<int> v2({A[v1[i].second], A[v1[j].second], A[v1[k].second]});
+                sort(v2.begin(), v2.end());
+                if(mp.find(v2) == mp.end()){
+                    v.push_back(v2);
+                    mp.insert(v2);
                 }
+                j++; k--;
+            }else if(v1[j].first + v1[k].first + firset  < 0){
                 j++;
-            }
-            
-        }
-        while(A[i+1] == A[i]){
-            i++;
-            if(i == A.size()-1){
-                return sol;
-            }
+            }else k--;
         }
-        i++;
     }
+    return v;
+}
+
+// // https://www.interviewbit.com/problems/3-sum-zero/
+
+// vector<vector<int> > Solution::threeSum(vector<int> &A) {
+//     // Do not write main() function.
+//     // Do not read input, instead use the arguments to the function.
+//     // Do not print the output, instead return values as specified
+//     // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
     
-    return sol;
+//     vector<vector<int> > sol;
     
-}
+//     if(A.size() < 2){
+//         return sol;
+//     }
+    
+//     sort(A.begin(), A.end());
+    
+//     int i = 0;
+    
+//     while(i < A.size()-2){
+//         int j = i+1;
+//         int k = A.size()-1;
+//         LOOP:while(j < k){
+//             int sum = A[i] + A[j] + A[k];
+//             if(sum == 0){
+//                 vector<int> temp;
+//                 temp.push_back(A[i]);
+//                 temp.push_back(A[j]);
+//                 temp.push_back(A[k]);
+//                 sol.push_back(temp);
+//                 temp.erase(temp.begin(),temp.end());
+//                 while(A[j] == A[j+1]){
+//                     j++;
+//                     if(j == A.size()){
+//                         break;
+//                     }
+//                 }
+//                 j++;                
+//             }
+//             else if(sum > 0){
+//                 while(A[k] == A[k-1]){
+//                     k--;
+//                     if(k == 0){
+//                         break;
+//                     }
+//                 }
+//                 k--;
+//             }
+//             else{
+//                 while(A[j] == A[j+1]){
+//                     j++;
+//                     if(j == A.size()){
+//                         break;
+//                     }
+//                 }
+//                 j++;
+//             }
+            
+//         }
+//         while(A[i+1] == A[i]){
+//             i++;
+//             if(i == A.size()-1){
+//                 return sol;
+//             }
+//         }
+//         i++;
+//     }
+    
+//     return sol;
+    
+// }
diff --git a/Two-Pointers/SortByColor.cpp b/Two-Pointers/SortByColor.cpp
new file mode 100644
index 0000000..7f13b18
--- /dev/null
+++ b/Two-Pointers/SortByColor.cpp
@@ -0,0 +1,37 @@
+// https://www.interviewbit.com/problems/sort-by-color/
+
+void Solution::sortColors(vector<int> &A) {
+    // Do not write main() function.
+    // Do not read input, instead use the arguments to the function.
+    // Do not print the output, instead return values as specified
+    // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details
+
+    int lo = 0;  
+    int hi = A.size() - 1;  
+    int mid = 0;  
+      
+    // Iterate till all the elements 
+    // are sorted  
+    while (mid <= hi)  
+    {  
+        switch (A[mid])  
+        {  
+              
+            // If the element is 0  
+        case 0:  
+            swap(A[lo++], A[mid++]);  
+            break;  
+              
+            // If the element is 1 .  
+        case 1:  
+            mid++;  
+            break;  
+              
+            // If the element is 2  
+        case 2:  
+            swap(A[mid], A[hi--]);  
+            break;  
+        }  
+    }
+    
+}
\ No newline at end of file