From a2a46780c8f6d49403ae2b0b3c9bf9ee8bae87cf Mon Sep 17 00:00:00 2001 From: zhangzc Date: Fri, 29 Oct 2021 18:18:20 +0800 Subject: [PATCH] update exercises --- .../solution.md" | 103 +++++++- .../solution.md" | 137 ++++++++++- .../solution.md" | 171 +++++++++++++- .../solution.md" | 223 +++++++++++++++++- .../solution.md" | 161 ++++++++++++- .../solution.md" | 205 +++++++++++++++- 6 files changed, 976 insertions(+), 24 deletions(-) diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/26_\347\247\273\351\231\244\345\205\203\347\264\240/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/26_\347\247\273\351\231\244\345\205\203\347\264\240/solution.md" index 276d13400..5d6f26c99 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/26_\347\247\273\351\231\244\345\205\203\347\264\240/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/26_\347\247\273\351\231\244\345\205\203\347\264\240/solution.md" @@ -3,30 +3,123 @@ ## aop ### before ```cpp - +#include +using namespace std; ``` ### after ```cpp - +int main() +{ + Solution sol; + int res; + vector nums{0, 1, 2, 2, 3, 0, 4, 2}; + res = sol.removeElement(nums, 2); + cout << res; + return 0; +} ``` ## 答案 ```cpp - +class Solution +{ +public: + int removeElement(vector &nums, int val) + { + int count = 0; + for (int i = 0; i < nums.size(); i++) + { + if (nums[i] != val) + { + nums[count++] = nums[i]; + } + } + return count; + } +}; ``` ## 选项 ### A ```cpp - +class Solution +{ +public: + int removeElement(vector &nums, int val) + { + int i = 0; + for (int j = 0; j < nums.size(); j++) + { + if (nums[j] != val) + { + nums[i] = nums[j]; + i++; + } + } + return i; + } +}; ``` ### B ```cpp - +class Solution +{ +public: + int removeElement(vector &nums, int val) + { + int n = nums.size(); + int i = 0; + while (i < n) + { + if (nums[i] == val) + { + nums[i] = nums[n - 1]; + n--; + } + else + i++; + } + return n; + } +}; ``` ### C ```cpp +class Solution +{ +public: + int removeElement(vector &nums, int val) + { + int tmp_len = nums.size(); + + if (tmp_len == 0) + return 0; + else + { + for (int ii = 1; ii < nums.size(); ii++) + { + if (nums[ii] == val) + tmp_len = tmp_len - 1; + } + + for (int i = 0; i < nums.size(); i++) + { + if (nums[i] == val) + { + for (int j = i; j < nums.size(); j++) + { + if (nums[j] != val) + { + nums[j] = nums[i]; + } + } + } + } + return tmp_len; + } + } +}; ``` diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/27_\345\256\236\347\216\260 strStr()/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/27_\345\256\236\347\216\260 strStr()/solution.md" index f2c409468..d4b3faa3e 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/27_\345\256\236\347\216\260 strStr()/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/27_\345\256\236\347\216\260 strStr()/solution.md" @@ -3,30 +3,157 @@ ## aop ### before ```cpp - +#include +using namespace std; ``` ### after ```cpp - +int main() +{ + Solution sol; + int res; + res = sol.strStr("hello", "ll"); + cout << res; + return 0; +} ``` ## 答案 ```cpp - +class Solution +{ +public: + int strStr(string haystack, string needle) + { + return haystack.find(needle); + } +}; ``` ## 选项 ### A ```cpp - +class Solution +{ +public: + int strStr(string haystack, string needle) + { + int l1 = haystack.size(); + int l2 = needle.size(); + int i = 0, j = 0; + while (i < l1 && j < l2) + { + if (haystack[i] == needle[j]) + { + i++; + j++; + } + else + { + i = i - j + 1; + j = 0; + } + } + if (j >= l2) + return (i - j); + else + return -1; + } +}; ``` ### B ```cpp +class Solution +{ +public: + vector next(string str) + { + vector v; + v.push_back(-1); + int i = 0, j = -1; + while (i < str.size()) + { + if (j == -1 || str[i] == str[j]) + { + ++i; + ++j; + v.push_back(j); + } + else + j = v[j]; + } + return v; + } + int strStr(string haystack, string needle) + { + int i = 0; + int j = 0; + int len1 = haystack.size(), len2 = needle.size(); + vector nextptr; + if (needle.empty()) + return 0; + + nextptr = next(needle); + while ((i < len1) && (j < len2)) + { + + if ((j == -1) || (haystack[i] == needle[j])) + + { + i++; + j++; + } + else + { + j = nextptr[j]; + } + } + + if (j == needle.size()) + return i - j; + else + return -1; + } +}; ``` ### C ```cpp - +class Solution +{ +public: + int strStr(string haystack, string needle) + { + int flag = 0; + int i, j; + int sizeofh = haystack.length(); + int sizeofn = needle.length(); + if (needle == "") + { + return 0; + } + for (i = 0; i < sizeofh; i++) + { + for (j = 0; j < sizeofn; j++) + { + if (i + j > sizeofh) + { + break; + } + if (haystack[i + j] != needle[j]) + { + break; + } + } + } + if (flag) + { + return i; + } + else + return -1; + } +}; ``` diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/28_\344\270\244\346\225\260\347\233\270\351\231\244/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/28_\344\270\244\346\225\260\347\233\270\351\231\244/solution.md" index c0aa249d7..0eba3fe94 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/28_\344\270\244\346\225\260\347\233\270\351\231\244/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/28_\344\270\244\346\225\260\347\233\270\351\231\244/solution.md" @@ -3,30 +3,191 @@ ## aop ### before ```cpp - +#include +using namespace std; ``` ### after ```cpp - +int main() +{ + Solution sol; + int res; + res = sol.divide(10, 3); + cout << res; + return 0; +} ``` ## 答案 ```cpp - +class Solution +{ +public: + int divide(int dividend, int divisor) + { + if (dividend == 0 || divisor == 1) + return dividend; + if (divisor == -1) + return dividend == INT_MIN ? INT_MAX : -dividend; + int sign = (dividend > 0) ^ (divisor > 0) ? -1 : 1; + int res = div(-abs(dividend), -abs(divisor)); + return sign == 1 ? res : -res; + } + int div(int a, int b) + { + if (a > b) + return 0; + int cnt = 1, val = b; + while (val - a + val >= 0) + { + cnt <<= 1; + val += val; + } + return div(a - val, b); + } +}; ``` ## 选项 ### A ```cpp - +class Solution +{ +public: + int divide(int dividend, int divisor) + { + int signal = 1; + unsigned int dvd = dividend; + if (dividend < 0) + { + signal *= -1; + dvd = ~dvd + 1; + } + unsigned int dvs = divisor; + if (divisor < 0) + { + signal *= -1; + dvs = ~dvs + 1; + } + int shift = 0; + while (dvd > dvs << shift) + { + shift++; + } + unsigned int res = 0; + while (dvd >= dvs) + { + while (dvd < dvs << shift) + { + shift--; + } + res |= (unsigned int)1 << shift; + dvd -= dvs << shift; + } + if (signal == 1 && res >= INT_MAX) + { + return INT_MAX; + } + else + { + return res * signal; + } + } +}; ``` ### B ```cpp - +class Solution +{ +public: + int divide(int dividend, int divisor) + { + if (dividend == INT_MIN && divisor == -1) + return INT_MAX; + if (dividend == 0) + return 0; + int sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1; + long x = (dividend < 0) ? -(long)dividend : (long)dividend; + long y = (divisor < 0) ? -(long)divisor : (long)divisor; + long result = 0; + while (x >= y) + { + long temp = y, mid = 1; + while (x >= (temp << 1)) + { + mid <<= 1; + temp <<= 1; + } + result += mid; + x -= temp; + } + return sign > 0 ? result : -result; + } +}; ``` ### C ```cpp +class Solution +{ +public: + int divide(int dividend, int divisor) + { + int INI_MIN = -2147483648, INI_MAX = 2147483647; + if (dividend == divisor) + return 1; + if (divisor == 1) + return dividend; + if (dividend == INI_MIN && divisor == -1) + return INI_MAX; + if (divisor == INI_MIN) + { + if (dividend == INI_MIN) + return 1; + else + return 0; + } + + bool sign = false; + if (dividend > 0 && divisor > 0 || dividend < 0 && divisor < 0) + { + sign = true; + } + + int result_1 = 0; + if (dividend == INI_MIN) + { + if (divisor > 0) + dividend = dividend + divisor; + else + dividend = dividend - divisor; + result_1++; + } + + dividend = abs(dividend); + divisor = abs(divisor); + while (dividend >= divisor) + { + unsigned int temp = divisor, res = 1; + + while (dividend >= (temp << 1)) + { + res <<= 1; + temp <<= 1; + } + result_1 += res; + dividend -= temp; + } + if (sign == true) + { + return result_1; + } + else + { + return -result_1; + } + } +}; ``` diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/29_\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/29_\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262/solution.md" index 6c1790f4e..8c7d570a5 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/29_\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/29_\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262/solution.md" @@ -3,30 +3,245 @@ ## aop ### before ```cpp - +#include +using namespace std; ``` ### after ```cpp +int main() +{ + Solution sol; + vector res; + string s = "barfoothefoobarman"; + vector words{"foo", "bar"}; + res = sol.findSubstring(s, words); + for (auto i : res) + cout << i << " "; + return 0; +} ``` ## 答案 ```cpp - +class Solution +{ +public: + vector findSubstring(string s, vector &words) + { + if (words.empty() || s.empty()) + return {}; + vector ans; + int len = words[0].length(), n = words.size(), total = n * len; + ; + int l = s.length(); + unordered_map list; + int i, j, left; + for (i = 0; i < n; i++) + list[words[i]]++; + for (i = 0; i <= l - total; i++) + { + unordered_map window; + bool flag = true; + left = i; + string str; + while (left - i < total) + { + str = s.substr(left, len); + if (list.count(str) == 1 && window[str] != list[str]) + { + window[str]++; + left += len; + } + else + { + flag = false; + } + } + if (flag) + ans.push_back(i); + } + return ans; + } +}; ``` ## 选项 ### A ```cpp - +class Solution +{ +public: + vector findSubstring(string s, vector &words) + { + vector res; + if (s.empty() || words.empty()) + { + return res; + } + unordered_map ht; + for (const auto &w : words) + { + ht[w]++; + } + int len = words[0].length(); + for (int i = 0, j = 0; i < s.length() - words.size() * len + 1; i++) + { + unordered_map counting; + for (j = 0; j < words.size(); j++) + { + string word = s.substr(i + j * len, len); + if (++counting[word] > ht[word]) + { + break; + } + } + if (j == words.size()) + { + res.push_back(i); + } + } + return res; + } +}; ``` ### B ```cpp - +class Solution +{ +public: + vector findSubstring(string s, vector &words) + { + if (words.empty() || s.empty()) + return {}; + vector ans; + unordered_map umap1; + unordered_map umap2; + int count = 0; + int left = 0; + for (string str : words) + ++umap1[str]; + int len = words[0].size(); + int slen = s.size(); + for (int i = 0; i < len; i++) + { + left = i; + count = 0; + umap2.clear(); + for (int j = i; j <= slen - len; j += len) + { + string temp = s.substr(j, len); + if (umap1.count(temp)) + { + umap2[temp]++; + count++; + while (umap2[temp] > umap1[temp]) + { + string temp2 = s.substr(left, len); + --umap2[temp2]; + --count; + left += len; + } + if (count == words.size()) + { + ans.push_back(left); + --umap2[s.substr(left, len)]; + --count; + left += len; + } + } + else + { + umap2.clear(); + count = 0; + left = j + len; + } + } + } + return ans; + } +}; ``` ### C ```cpp +class Solution +{ +public: + vector findSubstring(string s, vector &words) + { + vector result; + if (words.size() == 0 || s.length() == 0) + return result; + + map words_map; + int word_len = words[0].length(); + int word_num = words.size(); + if (word_len > s.length()) + return result; + for (vector::iterator it = words.begin(); it != words.end(); it++) + { + if (words_map.count(*it)) + words_map[*it]++; + else + words_map[*it] = 1; + } + + for (int i = 0; i < word_len; i++) + { + int left = i, right = i; + int cur_num = 0; + map s_map; + string right_str, left_string; + while (right <= s.length() - word_len) + { + right_str = s.substr(right, word_len); + + if (!words_map.count(right_str)) + { + right += word_len; + left = right; + cur_num = 0; + s_map.clear(); + } + else + { + + if (!s_map.count(right_str)) + s_map.insert(pair(right_str, 1)); + else + s_map[right_str] += 1; + + cur_num += 1; + right += word_len; + + if (s_map[right_str] > words_map[right_str]) + { + + while (s_map[right_str] > words_map[right_str]) + { + string left_str = s.substr(left, word_len); + s_map[left_str]--; + cur_num--; + left += word_len; + } + } + + if (cur_num == word_num) + { + + result.push_back(left); + + s_map[s.substr(left, word_len)]--; + left += word_len; + cur_num--; + } + } + } + } + return result; + } +}; ``` diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/30_\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/30_\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/solution.md" index f5ca32cde..e6a29c8aa 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/30_\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/30_\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/solution.md" @@ -12,21 +12,178 @@ ## 答案 ```cpp - +class Solution +{ +public: + void nextPermutation(vector &nums) + { + if (nums.size() <= 1) + return; + int i, j; + for (i = nums.size() - 2; i >= 0; i--) + { + if (nums.at(i) < nums.at(i + 1)) + break; + } + if (i < 0) + reverse(nums, 0, nums.size() - 1); + else + { + for (j = nums.size() - 1; j > i; j--) + { + if (nums.at(j) > nums.at(i)) + break; + } + swap(nums, i, j); + reverse(nums, i, nums.size() - 1); + } + } + void swap(vector &nums, int i, int j) + { + int temp = nums.at(j); + nums.at(j) = nums.at(i); + nums.at(i) = temp; + } + void reverse(vector &nums, int i, int j) + { + while (i < j) + { + swap(nums, i, j); + i++; + j--; + } + } +}; ``` ## 选项 ### A ```cpp - +class Solution +{ +public: + void nextPermutation(vector &nums) + { + if (nums.size() < 2) + { + return; + } + int i = nums.size() - 2; + while (i >= 0 && nums[i] >= nums[i + 1]) + { + i--; + } + if (i >= 0) + { + int j = nums.size() - 1; + while (j >= 0 && nums[j] >= nums[i]) + { + j--; + } + swap(nums.begin() + i, nums.begin() + j); + } + reverse(nums.begin() + i + 1, nums.end()); + } +}; ``` ### B ```cpp +class Solution +{ +public: + void nextPermutation(vector &num) + { + int index = num.size() - 1; + while (num[index - 1] >= num[index]) + { + index--; + } + + if (index == 0) + { + sort(num.begin(), num.end()); + return; + } + for (int i = num.size() - 1; i >= index; i--) + { + if (num[i] > num[index - 1]) + { + swap(num[i], num[index - 1]); + break; + } + } + + sort(num.begin() + index, num.end()); + return; + } +}; ``` ### C ```cpp +void reverse(vector &nums, int begin, int end) +{ + while (begin < end) + { + int temp = nums[begin]; + nums[begin] = nums[end]; + nums[end] = temp; + begin++; + end--; + } + return; +} + +int minIndex(vector nums, int begin, int end, int i) +{ + int min = nums[begin]; + int x = i; + for (int j = begin; j <= end; j++) + { + if (min >= nums[j] && nums[j] > nums[i]) + { + min = nums[j]; + x = j; + } + } + return x; +} + +class Solution +{ +public: + void nextPermutation(vector &nums) + { + if (nums.size() == 0 || nums.size() == 1) + { + return; + } + int size = nums.size(); + int i = 0; + for (i = size - 2; i >= 0; i--) + { + if (nums[i] < nums[i + 1]) + { + break; + } + } + if (i == -1) + { + reverse(nums, 0, size - 1); + return; + } + else + { + int min = minIndex(nums, i + 1, size - 1, i); + int temp = nums[i]; + nums[i] = nums[min]; + nums[min] = temp; + sort(nums.begin() + i + 1, nums.end()); + return; + } + } +}; ``` diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/32_\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/solution.md" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/32_\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/solution.md" index f264282d8..38088624c 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/32_\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/solution.md" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/32_\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/solution.md" @@ -3,30 +3,229 @@ ## aop ### before ```cpp - +#include +using namespace std; ``` ### after ```cpp +int main() +{ + Solution sol; + int res; + vector nums{4, 5, 6, 7, 0, 1, 2}; + int target = 0; + + res = sol.search(nums, target); + cout << res << " "; + return 0; +} ``` ## 答案 ```cpp - +class Solution +{ +public: + int search(vector &nums, int target) + { + return bs(nums, 0, nums.size(), target); + } + int bs(vector &nums, int i, int j, int &target) + { + if (i > j) + return -1; + int k = (i + j) / 2; + if (nums[k] == target) + return k; + if (nums[k] < nums[j]) + { + if (target < nums[k] || target > nums[j]) + return bs(nums, i + 1, k - 1, target); + else + return bs(nums, k - 1, j, target); + } + else + { + if (target > nums[k] || target < nums[i]) + return bs(nums, k + 1, j, target); + else + return bs(nums, i - 1, k, target); + } + } +}; ``` ## 选项 ### A ```cpp - +class Solution +{ +public: + int search(vector &nums, int target) + { + int lo = 0; + int hi = nums.size() - 1; + while (lo <= hi) + { + int mid = lo + (hi - lo) / 2; + if (nums[mid] == target) + { + return mid; + } + if (nums[lo] <= nums[mid]) + { + if (nums[lo] <= target && target < nums[mid]) + { + hi = mid - 1; + } + else + { + lo = mid + 1; + } + } + else + { + if (nums[mid] < target && target <= nums[hi]) + { + lo = mid + 1; + } + else + { + hi = mid - 1; + } + } + } + return -1; + } +}; ``` ### B ```cpp +class Solution +{ +public: + int search(vector &nums, int target) + { + int l = 0, r = nums.size() - 1; + while (l <= r) + { + int mid = (l + r) / 2; + int newMid = nums[0] > nums[mid] ? nums[mid] + 0x3f3f3f3f : nums[mid]; + int newTarget = nums[0] > target ? target + 0x3f3f3f3f : target; + if (newMid == newTarget) + return mid; + else if (newMid < newTarget) + l = mid + 1; + else if (newMid > newTarget) + r = mid - 1; + } + return -1; + } +}; ``` ### C ```cpp +class Solution +{ +public: + int search(vector &nums, int target) + { + int n = nums.size(); + if (n == 0) + return -1; + int loc = -1; + int i = 0; + int j = n - 1; + int cur = i; + while (i <= j) + { + if (nums[i] == target) + { + loc = i; + break; + } + else if (nums[j] == target) + { + loc = j; + break; + } + if ((nums[i] > target && nums[j] < target) || i == j) + { + break; + } + if (nums[i] < target) + { + int mid = (i + j) / 2; + if (i == mid || j == mid) + return loc; + while (nums[mid] < nums[i]) + { + j = mid - 1; + mid = (i + j) / 2; + } + if (nums[mid] < target) + { + i = mid; + continue; + } + else + { + j = mid; + while (i <= j) + { + mid = (i + j) / 2; + if (nums[mid] == target) + { + loc = mid; + break; + } + if (nums[mid] > target) + j = mid - 1; + else + i = mid + 1; + } + } + } + if (nums[j] > target) + { + int mid = (i + j) / 2; + if (i == mid || j == mid) + return loc; + while (nums[mid] > nums[j]) + { + i = mid + 1; + mid = (i + j) / 2; + } + if (nums[mid] > target) + { + j = mid; + continue; + } + else + { + i = mid; + while (i <= j) + { + mid = (i + j) / 2; + if (nums[mid] == target) + { + loc = mid; + break; + } + if (nums[mid] > target) + j = mid - 1; + else + i = mid + 1; + } + } + } + } + return loc; + } +}; ``` -- GitLab