algorithm004-01 · melody-li · Oct 20, 2019 · Oct 20, 2019
diff --git a/Week 01/id_166/1.cpp b/Week 01/id_166/1.cpp
@@ -0,0 +1,11 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> hashmap;
+        for(int i = 0; i < nums.size(); i++){
+        	if(hashmap.count(target - nums[i])) return {hashmap[target - nums[i]], i};
+        	hashmap[nums[i]] = i;
+		}
+		return {-1, -1};
+    }
+};
diff --git a/Week 01/id_166/189.cpp b/Week 01/id_166/189.cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+    void rotate(vector<int>& nums, int k) {
+
+        k = k % nums.size();
+        int len = nums.size();
+
+        while (k > 0 && len > 1 && len != k) {
+            for (int i = len - 1; i > k - 1; i--) {
+                swap(nums[i], nums[i - k]);
+            }
+
+            int tmp = k;
+            k = k - len % k;
+            len = tmp;
+        }
+
+    }
+
+};
diff --git a/Week 01/id_166/21.cpp b/Week 01/id_166/21.cpp
@@ -0,0 +1,28 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
+       if(l1 == NULL) {
+            return l2;
+        }
+        else if(l2 == NULL) {
+            return l1;
+        }
+        if(l1->val < l2->val) {
+            l1->next = mergeTwoLists(l1->next, l2);
+            return l1;
+        }
+        else{
+            l2->next = mergeTwoLists(l2->next, l1);
+            return l2;
+        }
+
+    }
+};
diff --git a/Week 01/id_166/26.cpp b/Week 01/id_166/26.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        if (nums.size() < 2) {
+            return nums.size();
+        }
+        int j=0;
+        for(int i=1;i<nums.size();i++) {
+            if (nums[i] != nums[j]) {
+                nums[++j] = nums[i];
+            }
+        }
+        return ++j;
+    }
+};
diff --git a/Week 01/id_166/283.cpp b/Week 01/id_166/283.cpp
@@ -0,0 +1,10 @@
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+        for (int lastNZeroFoundAt = 0, cur = 0; cur < nums.size(); cur++) {
+            if (nums[cur] != 0) {
+                swap(nums[lastNZeroFoundAt++], nums[cur]);
+            }
+        }
+    }
+};
diff --git a/Week 01/id_166/42.cpp b/Week 01/id_166/42.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    int trap(vector<int>& height) {
+        int n = height.size();
+		vector<int> left(n), right(n);
+		for (int i = 1; i < n; i++) {
+			left[i] = max(left[i - 1], height[i - 1]);
+		}
+		for (int i = n - 2; i >= 0; i--) {
+			right[i] = max(right[i + 1], height[i + 1]);
+		}
+		int water = 0;
+		for (int i = 0; i < n; i++) {
+			int level = min(left[i], right[i]);
+			water += max(0, level - height[i]);
+		}
+		return water;
+    }
+};
diff --git a/Week 01/id_166/66.cpp b/Week 01/id_166/66.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    vector<int> plusOne(vector<int>& digits) {
+        vector<int> ret(digits);
+		if (digits[0] == 0) {
+			ret[0] = 1;
+			return ret;
+		}
+
+		int index = digits.size() - 1;
+		int mod = 0;
+
+		while (index >= 0 && mod == 0) {
+			ret[index] += 1;
+			mod = ret[index--] % 10;
+		}
+
+		if (mod == 0) {
+			ret.insert(ret.begin(), 1);
+		}
+		return ret;
+    }
+};
diff --git a/Week 01/id_166/88.go b/Week 01/id_166/88.go
@@ -0,0 +1,25 @@
+func merge(nums1 []int, m int, nums2 []int, n int)  {
+    k := n+m-1
+    i := m-1
+    j:= n-1
+
+    if i < 0 && j < 0 {
+        return
+    }
+    for j >= 0&&i>=0 {
+        if nums1[i]>=nums2[j] {
+            nums1[k] = nums1[i]
+            k--
+            i--
+        }else {
+            nums1[k] = nums2[j]
+            j--
+            k--
+        }
+    }
+    for j>=0 {
+        nums1[k] = nums2[j]
+        k--
+        j--
+    }
+}
diff --git a/Week 01/id_166/MyCircularDeque.hpp b/Week 01/id_166/MyCircularDeque.hpp
@@ -0,0 +1,60 @@
+class MyCircularDeque {
+public:
+    MyCircularDeque(int k) { 
+        start = 0, end = 1, cap = k; 
+    }
+
+    bool insertFront(int value) {
+        if(mp.size() == cap) return false;
+        mp[start--] = value;
+        return true;
+    }
+
+    bool insertLast(int value) {
+        if(mp.size() == cap) return false;
+        mp[end++] = value;
+        return true;
+    }
+
+    bool deleteFront() {
+        if(!mp.size()) return false;
+        mp.erase(++start);
+        return true;
+    }
+
+    bool deleteLast() {
+        if(!mp.size()) return false;
+        mp.erase(--end);
+        return true;
+    }
+
+    int getFront() {
+        if(!mp.size()) return -1;
+        return mp[start + 1];
+    }
+
+    int getRear() {
+        if(!mp.size()) return -1;
+        return mp[end - 1];
+    }
+
+    bool isEmpty() { return !mp.size(); }
+
+    bool isFull() { return mp.size() == cap; }
+private:
+    unordered_map<int, int> mp;
+    int start, end, cap;    
+};
+
+/**
+ * Your MyCircularDeque object will be instantiated and called as such:
+ * MyCircularDeque* obj = new MyCircularDeque(k);
+ * bool param_1 = obj->insertFront(value);
+ * bool param_2 = obj->insertLast(value);
+ * bool param_3 = obj->deleteFront();
+ * bool param_4 = obj->deleteLast();
+ * int param_5 = obj->getFront();
+ * int param_6 = obj->getRear();
+ * bool param_7 = obj->isEmpty();
+ * bool param_8 = obj->isFull();
+ */