646 problems solved

Author: kaidul

README.md

@@ -0,0 +1,27 @@
+class Solution {
+    string wordAfterTyping(string word) {
+        stack<char> Stack;
+        for(char ch : word) {
+            if(ch == '#') {
+                if(!Stack.empty()) {
+                    Stack.pop();
+                }
+            } else {
+                Stack.push(ch);
+            }
+        }
+        string result = "";
+        while(!Stack.empty()) {
+            result += Stack.top();
+            Stack.pop();
+        }
+        
+        reverse(result.begin(), result.end());
+        
+        return result;
+    }
+public:
+    bool backspaceCompare(string S, string T) {
+        return wordAfterTyping(S) == wordAfterTyping(T);
+    }
+};

source-code/Backspace_String_Compare.cpp

@@ -0,0 +1,47 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+    pair<int, int> longestConsecutive(TreeNode* root, int& longest) {
+        if (!root->left and !root->right) {
+            longest = max(longest, 1);
+            return {1, 1};
+        }
+        int incrSeqLeftLen = 1, decSeqLeftLen = 1, incrSeqRightLen = 1, decSeqRightLen = 1;
+        if (root->left) {
+            pair<int, int> leftSeqLen = longestConsecutive(root->left, longest);
+            if (root->left->val + 1 == root->val) {
+                incrSeqLeftLen = max(incrSeqLeftLen, leftSeqLen.first + 1);
+            } else if (root->left->val == root->val + 1) {
+                decSeqLeftLen = max(decSeqLeftLen, leftSeqLen.second + 1);
+            }
+        }
+        
+        if (root->right) {
+            pair<int, int> rightSeqLen = longestConsecutive(root->right, longest);
+            if (root->right->val + 1 == root->val) {
+                incrSeqRightLen = max(incrSeqRightLen, rightSeqLen.first + 1);
+            } else if (root->right->val == root->val + 1) {
+                decSeqRightLen = max(decSeqRightLen, rightSeqLen.second + 1);
+            }
+        }
+        
+        longest = max(longest, max(incrSeqLeftLen + decSeqRightLen - 1, decSeqLeftLen + incrSeqRightLen - 1));
+        
+        return {max(incrSeqLeftLen, incrSeqRightLen), max(decSeqLeftLen, decSeqRightLen)};
+    }
+public:
+    int longestConsecutive(TreeNode* root) {
+        if (!root) return 0;
+        int longest = INT_MIN;
+        longestConsecutive(root, longest);
+        
+        return longest;
+    }
+};

source-code/Binary_Tree_Longest_Consecutive_Sequence_II.cpp

@@ -0,0 +1,59 @@
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* left;
+    Node* right;
+
+    Node() {}
+
+    Node(int _val, Node* _left, Node* _right) {
+        val = _val;
+        left = _left;
+        right = _right;
+    }
+};
+*/
+class Solution {
+    void iterateBstLeft(Node* root, stack<Node*>& nodeStack) {
+        while (root) {
+            nodeStack.push(root);
+            root = root->left;
+        }
+    }
+    
+    void treeToDoublyList(stack<Node*>& nodeStack, Node*& head, Node*& tail) {
+        if (nodeStack.empty()) {
+            return;
+        }
+        Node* currNode = nodeStack.top();
+        nodeStack.pop();
+        iterateBstLeft(currNode->right, nodeStack);
+        currNode->left = currNode->right = nullptr;
+        if (!head) {
+            head = tail = currNode;
+        } else {
+            tail->right = currNode;
+            currNode->left = tail;
+            tail = currNode;
+        }
+        treeToDoublyList(nodeStack, head, tail);
+    }
+    
+public:
+    Node* treeToDoublyList(Node* root) {
+        stack<Node*> nodeStack;
+        Node* head = nullptr;
+        Node* tail = nullptr;
+        
+        iterateBstLeft(root, nodeStack);
+        treeToDoublyList(nodeStack, head, tail);
+        if (head) {
+            tail->right = head;
+            head->left = tail;
+        }
+        
+        return head;
+    }
+};

source-code/Convert_Binary_Search_Tree_to_Sorted_Doubly_Linked_List.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+    string customSortString(string S, string T) {
+        vector<int> order(30, -1);
+        vector<int> letter(30);
+        for (int i = 0; i < (int) S.length(); i++) {
+            order[S[i] - 'a'] = i;
+            letter[i] = S[i] - 'a';
+        }
+        string result = "";
+        vector<int> count(30, 0);
+        for (int i = 0; i < (int)T.length(); i++) {
+            if(order[T[i] - 'a'] != -1) {
+                count[order[T[i] - 'a']]++;    
+            } else {
+                result += T[i];
+            }
+        }
+        for (int i = 0; i < 26; i++) {
+            while (count[i]--) {
+                result += ('a' + letter[i]);
+            }
+        }
+        
+        return result;
+    }
+};

source-code/Custom_Sort_String.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    vector<int> diStringMatch(string S) {
+        int n = (int)S.length();
+        int low = 0, high = n;
+        vector<int> result;
+        for (int i = 0; i < n; i++) {
+            result.push_back(S[i] == 'D' ? high-- : low++);
+        }
+        assert(low == high);
+        result.push_back(high); // or low
+        
+        return result;
+    }
+};

source-code/DI_String_Match.cpp

@@ -0,0 +1,72 @@
+class MyCircularQueue {
+    int frontIndx;
+    int rearIndx;
+    int maxSize;
+    vector<int> container;
+    int getSize() {
+        return rearIndx - frontIndx + 1;
+    }
+public:
+    /** Initialize your data structure here. Set the size of the queue to be k. */
+    MyCircularQueue(int k) {
+        container = vector<int>(k);
+        this->frontIndx = 0;
+        this->rearIndx = -1;
+        this->maxSize = k;
+    }
+    
+    /** Insert an element into the circular queue. Return true if the operation is successful. */
+    bool enQueue(int value) {
+        if(isFull()) {
+            return false;
+        }
+        container[++rearIndx % maxSize] = value;
+        return true;
+    }
+    
+    /** Delete an element from the circular queue. Return true if the operation is successful. */
+    bool deQueue() {
+        if(isEmpty()) {
+            return false;
+        }
+        frontIndx++;
+        return true;
+    }
+    
+    /** Get the front item from the queue. */
+    int Front() {
+        if(isEmpty()) {
+            return -1;
+        }
+        return container[frontIndx % maxSize];
+    }
+    
+    /** Get the last item from the queue. */
+    int Rear() {
+        if(isEmpty()) {
+            return -1;
+        }
+        return container[rearIndx % maxSize];
+    }
+    
+    /** Checks whether the circular queue is empty or not. */
+    bool isEmpty() {
+        return getSize() == 0;
+    }
+    
+    /** Checks whether the circular queue is full or not. */
+    bool isFull() {
+        return getSize() == maxSize;
+    }
+};
+
+/**
+ * Your MyCircularQueue object will be instantiated and called as such:
+ * MyCircularQueue obj = new MyCircularQueue(k);
+ * bool param_1 = obj.enQueue(value);
+ * bool param_2 = obj.deQueue();
+ * int param_3 = obj.Front();
+ * int param_4 = obj.Rear();
+ * bool param_5 = obj.isEmpty();
+ * bool param_6 = obj.isFull();
+ */

source-code/Design_Circular_Queue.cpp

@@ -0,0 +1,34 @@
+class MyHashMap {
+    int[] entry;
+
+    /** Initialize your data structure here. */
+    public MyHashMap() {
+        entry = new int[1000001];
+        for(int i = 0; i < entry.length; i++) {
+            entry[i] = -1;
+        }
+    }
+    
+    /** value will always be non-negative. */
+    public void put(int key, int value) {
+        entry[key] = value;
+    }
+    
+    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
+    public int get(int key) {
+        return entry[key];
+    }
+    
+    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
+    public void remove(int key) {
+        entry[key] = -1;
+    }
+}
+
+/**
+ * Your MyHashMap object will be instantiated and called as such:
+ * MyHashMap obj = new MyHashMap();
+ * obj.put(key,value);
+ * int param_2 = obj.get(key);
+ * obj.remove(key);
+ */

source-code/Design_HashMap.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    vector<int> anagramMappings(vector<int>& A, vector<int>& B) {
+        int n = (int) A.size();
+        vector<int> result(n);
+        unordered_map<int, vector<int>> index;
+        for (int i = 0; i < n; i++) {
+            index[A[i]].push_back(i);
+        }
+        for (int i = 0; i < n; i++) {
+            int indx = index[B[i]].back();
+            result[indx] = i;
+            index[B[i]].pop_back();
+        }
+        
+        return result;
+    }
+};