Update previous work

Author: adam.lin

.gitignore

@@ -1 +1,3 @@
 .vscode/
+*.pdb
+Backup/

121_maxProfit.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int left = 0;
+        int right = 1;
+        int maxProfit = 0;
+        int profit = 0;
+
+        while(right < prices.size()){
+            if(prices[left] < prices[right]){
+                profit = prices[right] - prices[left];
+                maxProfit = max(profit, maxProfit);
+            }
+            else{
+                left = right;
+            }
+
+            right++;
+        }
+
+        return maxProfit;
+    }
+};

141_hasCycle.cpp

@@ -0,0 +1,26 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool hasCycle(ListNode *head) {
+        ListNode *slowPtr = head;
+        ListNode *fastPtr = head;
+
+        while (fastPtr != nullptr && fastPtr->next != nullptr){
+            slowPtr = slowPtr->next;
+            fastPtr = fastPtr->next->next;
+
+            if (slowPtr == fastPtr){
+                return true;
+            }
+        }
+
+        return false;
+    }
+};

28_strStr.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int strStr(string haystack, string needle) {
+
+        if(needle.size() > haystack.size())
+            return -1;
+
+        for(int i = 0; i <= haystack.size() - needle.size(); i++){
+            if(haystack.substr(i, needle.size()) == needle){
+                return i;
+            }
+        }
+
+        return -1;
+    }
+};

454_fourSumCount.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
+        unordered_map<int, int> ABSumCounter, CDSumCounter;
+
+        for(auto a : A){
+            for(auto b : B){
+                ABSumCounter[a+b] += 1;
+            }
+        }
+
+        for(auto c : C){
+            for(auto d : D){
+                CDSumCounter[c+d] += 1;
+            }
+        }
+
+        int ans = 0;
+        for(auto abit = ABSumCounter.begin(); abit != ABSumCounter.end(); abit++){
+            auto cdit = CDSumCounter.find(-abit->first);
+            if(cdit != CDSumCounter.end()){
+                //we are finding +`++combination, so use product
+                ans += (abit->second * cdit->second);
+            }
+        }
+
+        return ans;
+    }
+};

53_maxSubArray.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        int sum = 0;
+        int maxSum = nums[0];
+
+        for (int i = 0; i < nums.size(); i++){
+            if (sum < 0){
+                sum = 0;
+            }
+            sum += nums[i];
+            maxSum = max(sum, maxSum);
+        }
+
+        return maxSum;
+    }
+};