2025.2.18

Author: HONGJICAI

cpp/.clang-format

@@ -3,6 +3,6 @@ IndentWidth: 4
 ---
 Language: Cpp
 # Force pointers to the type for C++.
-# AccessModifierOffset: -4
+AccessModifierOffset: -4
 DerivePointerAlignment: false
 PointerAlignment: Left

cpp/1.cpp

@@ -1,12 +1,12 @@
 class Solution {
 public:
-  vector<int> twoSum(vector<int> &nums, int target) {
-    unordered_map<int, int> map;
-    for (int i = 0; i < nums.size(); ++i) {
-      if (auto it = map.find(target - nums[i]); it != map.end())
-        return {it->second, i};
-      map[nums[i]] = i;
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> map;
+        for (int i = 0; i < nums.size(); ++i) {
+            if (auto it = map.find(target - nums[i]); it != map.end())
+                return {it->second, i};
+            map[nums[i]] = i;
+        }
+        return {};
     }
-    return {};
-  }
 };

cpp/11.cpp

@@ -1,11 +1,11 @@
 class Solution { // 16ms
 public:
-  int maxArea(vector<int> &height) {
-    int i = 0, j = height.size() - 1, result = 0;
-    while (i < j) {
-      result = max(result, min(height[i], height[j]) * (j - i));
-      height[i] < height[j] ? ++i : --j;
+    int maxArea(vector<int>& height) {
+        int i = 0, j = height.size() - 1, result = 0;
+        while (i < j) {
+            result = max(result, min(height[i], height[j]) * (j - i));
+            height[i] < height[j] ? ++i : --j;
+        }
+        return result;
     }
-    return result;
-  }
 };

cpp/13.cpp

@@ -1,25 +1,27 @@
-// notExactlyRight.cpp
-class Solution { // wrong at "IIIVM"
+class Solution {
+    static unordered_map<char, int> hash;
+
 public:
-  int romanToInt(string s) {
-    vector<int> st;
-    unordered_map<char, int> hash = {{'I', 1},   {'V', 5},   {'X', 10},
-                                     {'L', 50},  {'C', 100}, {'D', 500},
-                                     {'M', 1000}};
-    for (auto c : s) {
-      auto n = hash[c];
-      if (st.empty() || st.back() >= n) {
-        st.push_back(n);
-      } else {
-        int res = 0;
-        while (st.size() && st.back() < n) {
-          res += st.back();
-          st.pop_back();
+    int romanToInt(string s) {
+        vector<int> st;
+        for (auto c : s) {
+            auto n = hash[c];
+            if (st.empty() || st.back() >= n) {
+                st.push_back(n);
+            } else {
+                int res = 0;
+                while (st.size() && st.back() < n) {
+                    res += st.back();
+                    st.pop_back();
+                }
+                n -= res;
+                st.push_back(n);
+            }
         }
-        n -= res;
-        st.push_back(n);
-      }
+        return accumulate(st.begin(), st.end(), 0);
     }
-    return accumulate(st.begin(), st.end(), 0);
-  }
 };
+
+unordered_map<char, int> Solution::hash = {{'I', 1},   {'V', 5},   {'X', 10},
+                                           {'L', 50},  {'C', 100}, {'D', 500},
+                                           {'M', 1000}};

cpp/14.cpp

@@ -1,24 +1,8 @@
-class Solution { // 4ms
-public:
-  string longestCommonPrefix(vector<string> &strs) {
-    if (strs.size() == 0 || strs[0].size() == 0)
-      return "";
-    string pre = "";
-    for (int j = 0; j < strs[0].size(); ++j) {
-      char ch = strs[0][j];
-      for (int i = 1; i < strs.size(); ++i) {
-        if (strs[i].size() <= j || strs[i][j] != ch)
-          return pre;
-      }
-      pre += ch;
-    }
-    return pre;
-  }
-};
-class Solution2 { // why this takes 0ms?
+class Solution {
 public:
     string longestCommonPrefix(vector<string>& strs) {
-        if (strs.size() == 1) return strs[0];
+        if (strs.size() == 1)
+            return strs[0];
         string ret;
         for (int charN = 0; charN < strs[0].size(); ++charN) {
             for (int wordN = 0; wordN < strs.size(); ++wordN) {

cpp/15.cpp

@@ -1,52 +1,55 @@
-class Solution { // sortAndDoublePointer 100ms
+class Solution { // sortAndDoublePointer
 public:
-  vector<vector<int>> threeSum(vector<int> &nums) {
-    sort(nums.begin(), nums.end());
-    int n = nums.size();
-    vector<vector<int>> result;
-    for (int i = 0; i < n - 2; ++i) {
-      if (i > 0 && nums[i] == nums[i - 1])
-        continue;
-      for (int low = i + 1, high = n - 1; low < high;) {
-        if (int sum = nums[low] + nums[high]; sum == -nums[i]) {
-          result.push_back({nums[i], nums[low], nums[high]});
-          do {
-            ++low;
-          } while (low < high && nums[low - 1] == nums[low]);
-          do {
-            --high;
-          } while (low < high && nums[high + 1] == nums[high]);
-        } else if (sum > -nums[i])
-          --high;
-        else
-          ++low;
-      }
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        ranges::sort(nums);
+        int n = nums.size();
+        vector<vector<int>> result;
+        for (int i = 0; i < n - 2; ++i) {
+            if (i > 0 && nums[i] == nums[i - 1])
+                continue;
+            for (int low = i + 1, high = n - 1; low < high;) {
+                if (int sum = nums[low] + nums[high]; sum == -nums[i]) {
+                    result.push_back({nums[i], nums[low], nums[high]});
+                    do {
+                        ++low;
+                    } while (low < high && nums[low - 1] == nums[low]);
+                    do {
+                        --high;
+                    } while (low < high && nums[high + 1] == nums[high]);
+                } else if (sum > -nums[i])
+                    --high;
+                else
+                    ++low;
+            }
+        }
+        return result;
     }
-    return result;
-  }
 };
-class Solution2 { // same logic but 46ms
+class Solution2 { // same logic, but use lambda
 public:
     vector<vector<int>> threeSum(vector<int>& nums) {
         sort(nums.begin(), nums.end());
         vector<vector<int>> res;
-        auto find = [&res](vector<int>& nums, int k){
+        auto find = [&res](vector<int>& nums, int k) {
             int i = k + 1, j = nums.size() - 1;
-            while(i<j){
-                if(nums[i] + nums[j] +nums[k] == 0){
+            while (i < j) {
+                if (nums[i] + nums[j] + nums[k] == 0) {
                     res.push_back({nums[k], nums[i], nums[j]});
-                    while(++i < j && nums[i-1] == nums[i]);
-                    while(--j > i && nums[j+1] == nums[j]);
-                } else if (nums[i] + nums[j] +nums[k] > 0){
+                    while (++i < j && nums[i - 1] == nums[i])
+                        ;
+                    while (--j > i && nums[j + 1] == nums[j])
+                        ;
+                } else if (nums[i] + nums[j] + nums[k] > 0) {
                     --j;
-                } else{
+                } else {
                     ++i;
-                }            
+                }
             }
         };
-        for(int k=0;k<nums.size();){
+        for (int k = 0; k < nums.size();) {
             find(nums, k);
-            while(++k < nums.size() && nums[k-1] == nums[k]);
+            while (++k < nums.size() && nums[k - 1] == nums[k])
+                ;
         }
         return res;
     }

cpp/16.cpp

@@ -1,50 +1,51 @@
 // sort.cpp
 class Solution {
 public:
-  int threeSumClosest(vector<int> &nums, int target) {
-    sort(nums.begin(), nums.end());
-    int t = 0x7fffffff, j, k, n = nums.size(), s;
-    for (int i = 0; i < n; ++i) {
-      s = target - nums[i];
-      for (j = i + 1, k = n - 1; j < k;) {
-        int sum = nums[j] + nums[k];
-        if (abs(t) > abs(sum - s))
-          t = sum - s;
-        if (sum > s)
-          k--;
-        else if (sum < s)
-          ++j;
-        else
-          return target;
-      }
+    int threeSumClosest(vector<int>& nums, int target) {
+        sort(nums.begin(), nums.end());
+        int t = 0x7fffffff, j, k, n = nums.size(), s;
+        for (int i = 0; i < n; ++i) {
+            s = target - nums[i];
+            for (j = i + 1, k = n - 1; j < k;) {
+                int sum = nums[j] + nums[k];
+                if (abs(t) > abs(sum - s))
+                    t = sum - s;
+                if (sum > s)
+                    k--;
+                else if (sum < s)
+                    ++j;
+                else
+                    return target;
+            }
+        }
+        return target + t;
     }
-    return target + t;
-  }
 };
 class Solution2 {
 public:
     int threeSumClosest(vector<int> nums, int target) {
         sort(nums.begin(), nums.end());
         int ret = 1000000;
-        auto find = [&ret, &target](vector<int>& nums, int k){
+        auto find = [&ret, &target](vector<int>& nums, int k) {
             int i = k + 1, j = nums.size() - 1;
-            while(i<j){
+            while (i < j) {
                 int sum = nums[i] + nums[j] + nums[k];
-                if(abs(sum-target)<abs(ret-target)){
+                if (abs(sum - target) < abs(ret - target)) {
                     ret = sum;
                 }
-                if (sum > target){
+                if (sum > target) {
                     --j;
-                } else if (sum < target){
+                } else if (sum < target) {
                     ++i;
                 } else {
                     return;
                 }
             }
         };
-        for(int k=0;k<nums.size();++k){
+        for (int k = 0; k < nums.size(); ++k) {
             find(nums, k);
-            if(ret == target) return ret;
+            if (ret == target)
+                return ret;
         }
         return ret;
     }

cpp/17.cpp

@@ -1,43 +1,48 @@
 // dfs.cpp
 class Solution {
+    static vector<string> letter;
+    void dfs(vector<string>& letter, vector<string>& res, const string& digits,
+             string cur, int i) {
+        if (i == digits.size()) {
+            res.push_back(cur);
+            return;
+        }
+        for (int j = 0; j < letter[digits[i] - '0'].size(); ++j)
+            dfs(letter, res, digits, cur + letter[digits[i] - '0'][j], i + 1);
+    }
+
 public:
-  vector<string> letterCombinations(string digits) {
-    vector<string> letter = {"",    "",    "abc",  "def", "ghi",
-                             "jkl", "mno", "pqrs", "tuv", "wxyz"};
-    vector<string> res;
-    if (digits.size() == 0)
-      return res;
-    dfs(letter, res, digits, "", 0);
-    return res;
-  }
-  void dfs(vector<string> &letter, vector<string> &res, const string &digits,
-           string cur, int i) {
-    if (i == digits.size()) {
-      res.push_back(cur);
-      return;
+    vector<string> letterCombinations(string digits) {
+        vector<string> res;
+        if (digits.size() == 0)
+            return res;
+        dfs(letter, res, digits, "", 0);
+        return res;
     }
-    for (int j = 0; j < letter[digits[i] - '0'].size(); ++j)
-      dfs(letter, res, digits, cur + letter[digits[i] - '0'][j], i + 1);
-  }
 };
-class Solution2 {
-    vector<string> combine(vector<string> &a, vector<string> &b) {
+
+vector<string> Solution::letter = {"",    "",    "abc",  "def", "ghi",
+                                   "jkl", "mno", "pqrs", "tuv", "wxyz"};
+
+string keymap[] = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+class Solution {
+    vector<string> combine(vector<string>& a, string& b) {
         vector<string> res;
-        for (auto &i : a) {
-            for (auto &j : b) {
+        for (auto& i : a) {
+            for (auto& j : b) {
                 res.push_back(i + j);
             }
         }
         return res;
     }
+
 public:
     vector<string> letterCombinations(string digits) {
-        if (digits.empty()) return {};
-        vector<string> res;
-        string[] map = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
-        res.push_back("");
-        for (auto &d : digits) {
-            res = combine(res, map[d - '2']);
+        if (digits.empty())
+            return {};
+        vector<string> res = {""};
+        for (auto& d : digits) {
+            res = combine(res, keymap[d - '2']);
         }
         return res;
     }