Update previous work

Author: adam.lin

.vscode/settings.json

@@ -54,5 +54,6 @@
         "xstring": "cpp",
         "xtr1common": "cpp",
         "xutility": "cpp"
-    }
+    },
+    "C_Cpp.errorSquiggles": "enabled"
 }

152_maxProduct.cpp

@@ -0,0 +1,19 @@
+#include <vector>
+
+class Solution {
+public:
+    int maxProduct(std::vector<int>& nums) {
+        int n = nums.size();
+        int product = 0;
+        int maxProduct = 0;
+
+        for (int i = 0; i < n; ++i) {
+            for (int j = i; j < n; ++j) {
+                product = nums[i] * nums[j];
+                maxProduct = std::max(product, maxProduct);
+            }
+        }
+
+        return maxProduct;
+    }
+};

1_twoSum.cpp

@@ -0,0 +1,26 @@
+#include <vector>
+#include <unordered_map>
+
+using namespace std;
+
+class Solution {
+public:
+   vector<int> twoSum(vector<int>& nums, int target) {
+       //for store seen value
+       unordered_map<int, int> nonrepeat;
+
+       for (int i = 0; i < nums.size(); ++i) {
+           int answer = target - nums[i];
+
+           //unordered_map did not find anything, will return end(), means last position+1. 
+           if (nonrepeat.find(answer) == nonrepeat.end()) {
+               nonrepeat[nums[i]] = i;
+           }
+           else {
+               return vector<int> {nonrepeat[answer], i};
+           }
+
+       }
+       return{};
+   }
+};

20_validParentheses.cpp

@@ -0,0 +1,42 @@
+#include <stack>
+#include <string>
+
+class Solution {
+public:
+   bool isValid(std::string s) {
+	    std::stack<char> container;
+       for (int i = 0; i < s.length(); ++i)
+       {
+           if (s[i] == '(' || s[i] == '{' || s[i] == '[')
+           {
+               container.push(s[i]);
+           }
+           else if (s[i] == ')')
+           {
+               if (i == 0 || container.empty() || container.top() != '(')
+               {
+                   return false;
+               }
+               container.pop();
+           }
+           else if (s[i] == '}')
+           {
+               if (i == 0 || container.empty() || container.top() != '{')
+               {
+                   return false;
+               }
+               container.pop();
+           }
+           else if (s[i] == ']')
+           {
+               if (i == 0 || container.empty() || container.top() != '[')
+               {
+                   return false;
+               }
+               container.pop();
+           }
+
+       }
+       return container.empty();
+   }
+};

21_mergeTwoLists.cpp

@@ -0,0 +1,40 @@
+using namespace std;
+#include <iostream>
+
+// Definition for singly-linked list.
+struct ListNode {
+    int val;
+    ListNode *next;
+    ListNode() : val(0), next(nullptr) {}
+    ListNode(int x) : val(x), next(nullptr) {}
+    ListNode(int x, ListNode *next) : val(x), next(next) {}
+};
+
+class Solution {
+public:
+    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
+        ListNode* head = new ListNode(-1); // create a new ListNode and assign to first
+        ListNode* dummy = head;
+
+        while (list1 != nullptr && list2 != nullptr) {
+            if (list1->val <= list2->val) {
+                dummy->next = list1;
+                list1 = list1->next;
+            }
+            else {
+                dummy->next = list2;
+                list2 = list2->next;
+            }
+            dummy = dummy->next;
+        }
+
+        if (list1 != nullptr) {
+            dummy->next = list1;
+        }
+        else if (list2 != nullptr) {
+            dummy->next = list2;
+        }
+
+        return head->next;
+    }
+};

575_distributeCandies.cpp

@@ -0,0 +1,23 @@
+#include <iostream>
+#include <vector>
+#include <unordered_set>
+using namespace std;
+
+class Solution {
+public:
+   int distributeCandies(vector<int>& candyType) {
+       unordered_set<int> myunordered_set(candyType.begin(), candyType.end());
+       int rawN = candyType.size();
+       int unorderedN = myunordered_set.size();
+       return min(rawN / 2, unorderedN);
+
+       /*
+       if(rawN / 2 > unorderedN){
+           return unorderedN;
+       }
+       else{
+           return rawN / 2;
+       }
+       */
+   }
+};