add: [LC-4] accepted in C++ and JS

Author: davidyslu

LC-1005/LC-1005.cpp

@@ -12,7 +12,7 @@ class Solution {
      * 4. If there still have K (i.e., K > 0), determine whether the K is odd or even
      *    - If K is odd, then only change the first element into negative
      *    - If K is even, then no change
-     * 5. Sum up the array 
+     * 5. Sum up the array
      */
     int largestSumAfterKNegations(vector<int>& A, int K) {
         int i = 0, sum = 0;

LC-1528/LC-1528.cpp

@@ -1,3 +1,8 @@
+#include <string>
+#include <vector>
+
+using namespace std;
+
 class Solution {
 public:
     /**
@@ -6,14 +11,14 @@ class Solution {
      * 2. Sorting and concatenate to new string
      */
     string restoreString(string s, vector<int>& indices) {
-        vector<pair<char, int>> pairs;
+        vector< pair<char, int> > pairs;
         for (int i = 0; i < indices.size(); ++i) {
             pairs.push_back(make_pair(s[i], indices[i]));
         }
-        
+
         // Sorting
         sort(pairs.begin(), pairs.end(), compare);
-        
+
         // Concatenation
         string result = "";
         for (int i = 0; i < pairs.size(); ++i) {

LC-3/README.md

@@ -9,23 +9,23 @@ Given a string, find the length of the longest substring without repeating chara
 
 ```
 Input: "abcabcbb"
-Output: 3 
-Explanation: 
-The answer is "abc", with the length of 3. 
+Output: 3
+Explanation:
+The answer is "abc", with the length of 3.
 ```
 
 ```
 Input: "bbbbb"
 Output: 1
-Explanation: 
+Explanation:
 The answer is "b", with the length of 1.
 ```
 
 ```
 Input: "pwwkew"
 Output: 3
-Explanation: 
-The answer is "wke", with the length of 3. 
+Explanation:
+The answer is "wke", with the length of 3.
 Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
 ```
 

LC-4/LC-4.cpp

@@ -0,0 +1,30 @@
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+class Solution {
+public:
+    /**
+     * Concepts: Merging and Sorting
+     * 1. Merge two arrays into one array
+     * 2. Sorting
+     * 3. Return median of merged array
+     */
+    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+        int nums2Len = nums2.size();
+        for (int i = 0; i < nums2Len; ++i) {
+            nums1.push_back(nums2[i]);
+        }
+
+        sort(nums1.begin(), nums1.end());
+
+        int nums1Len = nums1.size();
+        if (nums1Len % 2 == 0) {
+            double a = nums1[nums1Len / 2 - 1];
+            double b = nums1[nums1Len / 2];
+            return (a + b) / 2;
+        }
+        return nums1[nums1Len / 2];
+    }
+};

LC-4/LC-4.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+
+var findMedianSortedArrays = function(nums1, nums2) {
+  /**
+   * Concepts: Merging and Sorting
+   * 1. Merge two arrays into one array
+   * 2. Sorting
+   * 3. Return median of merged array
+   */
+  const nums2Len = nums2.length;
+  nums1 = nums1.concat(nums2);
+  nums1 = nums1.sort((a, b) => a - b);
+
+  const nums1Len = nums1.length;
+  if (nums1Len % 2 === 0) {
+      return (nums1[Math.floor(nums1Len / 2) - 1] + nums1[Math.floor(nums1Len / 2)]) / 2;
+  }
+  return nums1[Math.floor(nums1Len / 2)];
+};

LC-4/README.md

@@ -0,0 +1,54 @@
+# LC-4 - Median of Two Sorted Arrays
+
+Given two sorted arrays `nums1` and `nums2` of size `m` and `n` respectively, return **the median** of the two sorted arrays.
+
+The overall run time complexity should be `O(log (m+n))`.
+
+---
+## Examples
+
+```
+Input: nums1 = [1,3], nums2 = [2]
+Output: 2.00000
+Explanation:
+merged array = [1,2,3] and median is 2.
+```
+
+```
+Input: nums1 = [1,2], nums2 = [3,4]
+Output: 2.50000
+Explanation:
+merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.
+```
+
+```
+Input: nums1 = [0,0], nums2 = [0,0]
+Output: 0.00000
+```
+
+```
+Input: nums1 = [], nums2 = [1]
+Output: 1.00000
+```
+
+```
+Input: nums1 = [2], nums2 = []
+Output: 2.00000
+```
+
+---
+## Notes
+
+- `nums1.length == m`
+- `nums2.length == n`
+- `0 <= m <= 1000`
+- `0 <= n <= 1000`
+- `1 <= m + n <= 2000`
+- `-106 <= nums1[i], nums2[i] <= 106`
+
+---
+## Solutions
+
+1. Merging and Sorting
+  - Time complexity: $O(n \log(n))$
+  - Space complexity: $O(1)$

LC-877/LC-877-1.cpp

@@ -17,7 +17,7 @@ class Solution {
         vector< vector<int> > DP(n, vector<int>(n, 0));
         for (int i = 0; i < n; ++i)
             DP[i][i] = piles[i];
-        
+
         for (int d = 1; d < n; ++d) {
             for (int i = 0; i < n - d; ++i)
                 DP[i][i + d] = max(piles[i] - DP[i + 1][i + d], piles[i + d] - DP[i][i + d - 1]);