add Day4

Jongeun/Day4/153_FindMinimuminRotatedSortedArray.cpp

@@ -0,0 +1,48 @@
+class Solution
+{
+public:
+    int findMin(vector<int> &nums)
+    {
+        int start = 0;
+        int end = nums.size() - 1;
+
+        // return minimum if the size is 1
+        if (end == 0)
+        {
+            return nums[end];
+        }
+
+        while ((end - start) > 1)
+        {
+            int mid = (start + end) / 2;
+            int m = min(nums[start], nums[end]);
+
+            // if min is less than both of start and end
+            if (nums[mid] < m)
+            {
+                end = mid;
+            }
+            else
+            {
+                // min is equal or bigger
+                if (nums[start] < nums[end])
+                {
+                    end = mid;
+                }
+                else
+                {
+                    start = mid;
+                }
+            }
+        }
+
+        if (nums[start] < nums[end])
+        {
+            return nums[start];
+        }
+        else
+        {
+            return nums[end];
+        }
+    }
+};

Jongeun/Day4/33_SearchinRotated ortedArray.cpp

@@ -0,0 +1,75 @@
+class Solution
+{
+public:
+    int search(vector<int> &nums, int target)
+    {
+        int start = 0;
+        int end = nums.size() - 1;
+
+        while (start <= end)
+        {
+            // not rotated
+            if (nums[start] < nums[end])
+            {
+                int mid = (start + end) / 2;
+                if (nums[mid] == target)
+                {
+                    return mid;
+                }
+                else if (target < nums[mid])
+                {
+                    end = mid - 1;
+                }
+                else
+                {
+                    start = mid + 1;
+                }
+            }
+            else
+            {
+                // rotated
+                int mid = (start + end) / 2;
+                if (nums[start] <= nums[mid])
+                {
+                    // mid positioned in left sorted part
+                    if (target == nums[mid])
+                    {
+                        return mid;
+                    }
+                    else
+                    {
+                        if (target >= nums[start] && target < nums[mid])
+                        {
+                            end = mid - 1;
+                        }
+                        else
+                        {
+                            start = mid + 1;
+                        }
+                    }
+                }
+                else
+                {
+                    // mid positioned in the right sorted part
+                    if (target == nums[mid])
+                    {
+                        return mid;
+                    }
+                    else
+                    {
+                        if (target > nums[mid] && target <= nums[end])
+                        {
+                            start = mid + 1;
+                        }
+                        else
+                        {
+                            end = mid - 1;
+                        }
+                    }
+                }
+            }
+        }
+
+        return -1;
+    }
+};

Jongeun/Day4/981_TimeBasedKeyValueStore.cpp

@@ -0,0 +1,81 @@
+class TimeMap
+{
+public:
+    TimeMap()
+    {
+    }
+
+    void set(string key, string value, int timestamp)
+    {
+        timeMap[key].push_back({timestamp, value});
+    }
+
+    string get(string key, int timestamp)
+    {
+
+        auto it = timeMap.find(key);
+        if (it != timeMap.end())
+        { // find the key
+            const vector<pair<int, string>> &timeVec = it->second;
+            int l = 0;
+            int r = timeVec.size() - 1;
+            int mid;
+
+            // if length == 1
+            if (r == 0)
+            {
+                if (timeVec[0].first <= timestamp)
+                {
+                    return timeVec[mid].second;
+                }
+            }
+
+            // until two things left
+            while (r - l > 1)
+            {
+                mid = (l + r) / 2;
+                if (timeVec[mid].first == timestamp)
+                {
+                    return timeVec[mid].second;
+                }
+                if (timeVec[mid].first < timestamp)
+                {
+                    l = mid + 1;
+                }
+                else
+                {
+                    r = mid - 1;
+                }
+            }
+
+            // two or one thing left
+            if (timestamp < timeVec[l].first)
+            {
+                return "";
+            }
+            else if (timestamp >= timeVec[r].first)
+            {
+                return timeVec[r].second;
+            }
+            else
+            {
+                return timeVec[l].second;
+            }
+        }
+        else
+        {
+            // not have key
+            return "";
+        }
+    }
+
+private:
+    unordered_map<string, vector<pair<int, string>>> timeMap;
+};
+
+/**
+ * Your TimeMap object will be instantiated and called as such:
+ * TimeMap* obj = new TimeMap();
+ * obj->set(key,value,timestamp);
+ * string param_2 = obj->get(key,timestamp);
+ */