From d8638eae93ec029aa647901aaaf727bd8b4374b2 Mon Sep 17 00:00:00 2001 From: lintcoder Date: Sun, 29 Oct 2017 10:33:14 +0800 Subject: [PATCH 01/97] 1.10 problems solved. --- 122.cpp | 31 +++++++++++++++++++++++++++++ 13.cpp | 62 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 447.cpp | 50 ++++++++++++++++++++++++++++++++++++++++++++++ 530.cpp | 25 +++++++++++++++++++++++ 538.cpp | 46 ++++++++++++++++++++++++++++++++++++++++++ 551.cpp | 39 ++++++++++++++++++++++++++++++++++++ 563.cpp | 14 +++++++++++++ 598.cpp | 17 ++++++++++++++++ 599.cpp | 54 +++++++++++++++++++++++++++++++++++++++++++++++++ 690.cpp | 24 ++++++++++++++++++++++ 10 files changed, 362 insertions(+) create mode 100644 122.cpp create mode 100644 13.cpp create mode 100644 447.cpp create mode 100644 530.cpp create mode 100644 538.cpp create mode 100644 551.cpp create mode 100644 563.cpp create mode 100644 598.cpp create mode 100644 599.cpp create mode 100644 690.cpp diff --git a/122.cpp b/122.cpp new file mode 100644 index 0000000..5236f4b --- /dev/null +++ b/122.cpp @@ -0,0 +1,31 @@ +int maxProfit(vector& prices) { + int len = prices.size(); + if (len <= 1) + return 0; + int pr = prices[0]; + int profit = 0; + int i = 1; + while (i < len) + { + if (prices[i] <= pr) + { + pr = prices[i]; + ++i; + } + else + { + while (i + 1 < len && prices[i + 1] >= prices[i]) + ++i; + profit += prices[i]-pr; + if (i >= len - 2) + break; + else + { + pr = prices[i + 1]; + i += 2; + } + } + } + + return profit; + } \ No newline at end of file diff --git a/13.cpp b/13.cpp new file mode 100644 index 0000000..654111f --- /dev/null +++ b/13.cpp @@ -0,0 +1,62 @@ +int romanToInt(string s) { + map mp; + mp['I'] = 1; + mp['V'] = 5; + mp['X'] = 10; + mp['L'] = 50; + mp['C'] = 100; + mp['D'] = 500; + mp['M'] = 1000; + + int len = s.size(); + char c = s[0]; + int sum = 0; + int val = mp[c]; + int i = 1; + bool flag = true; + while (i < len) + { + if (s[i] == c) + { + val += mp[c]; + if (!flag) + { + sum += val; + val = 0; + flag = true; + ++i; + if (i == len) + break; + c = s[i]; + val = mp[c]; + ++i; + } + else + ++i; + } + else if (mp[s[i]] < mp[c]) + { + sum += val; + val = mp[s[i]]; + c = s[i]; + flag = false; + ++i; + } + else + { + sum += -val + mp[s[i]]; + val = 0; + flag = true; + ++i; + if (i == len) + break; + c = s[i]; + val = mp[c]; + ++i; + } + } + if (val != 0) + sum += val; + + return sum; + } \ No newline at end of file diff --git a/447.cpp b/447.cpp new file mode 100644 index 0000000..e8567a7 --- /dev/null +++ b/447.cpp @@ -0,0 +1,50 @@ +int numberOfBoomerangs(vector>& points) { + int sz = points.size(); + int** distance = new int* [sz]; + for (int i = 0; i != sz; ++i) + distance[i] = new int[sz]; + for (int i = 0; i != sz; ++i) + { + for (int j = i; j != sz; ++j) + { + if (i == j) + distance[i][j] = 0; + else + { + int dx = points[i].first - points[j].first; + int dy = points[i].second - points[j].second; + distance[j][i] = distance[i][j] = dx * dx + dy * dy; + } + } + sort(distance[i], distance[i] + sz); + } + + int sum = 0; + for (int i = 0; i != sz; ++i) + { + int tmpdist = distance[i][0]; + int j = 1; + int cnt = 1; + while (j < sz) + { + if (distance[i][j] == tmpdist) + ++cnt; + else + { + if (cnt > 1) + sum += cnt * (cnt - 1); + tmpdist = distance[i][j]; + cnt = 1; + } + ++j; + } + if (cnt > 1) + sum += cnt * (cnt - 1); + } + + for (int i = 0; i != sz; ++i) + delete[] distance[i]; + delete[] distance; + + return sum; + } \ No newline at end of file diff --git a/530.cpp b/530.cpp new file mode 100644 index 0000000..011b2aa --- /dev/null +++ b/530.cpp @@ -0,0 +1,25 @@ +int getMinimumDifference(TreeNode* root) { + vector vec; + add2vec(vec, root); + sort(vec.begin(), vec.end()); + + int len = vec.size(); + int min_diff = abs(vec[1] - vec[0]); + for (int i = 2; i < len; ++i) + { + int diff = abs(vec[i] - vec[i - 1]); + if (diff < min_diff) + min_diff = diff; + } + + return min_diff; + } + + void add2vec(vector& vec, TreeNode* root) + { + if (root == NULL) + return; + vec.push_back(root->val); + add2vec(vec, root->left); + add2vec(vec, root->right); + } \ No newline at end of file diff --git a/538.cpp b/538.cpp new file mode 100644 index 0000000..b8c66ce --- /dev/null +++ b/538.cpp @@ -0,0 +1,46 @@ +TreeNode* convertBST(TreeNode* root) { + if (root == nullptr) + return nullptr; + deque dq; + if (root->left != nullptr) + getBSTValue(root->left, dq); + dq.push_back(root->val); + if (root->right != nullptr) + getBSTValue(root->right, dq); + + int len = dq.size(); + int sum = dq[len - 1]; + for (int i = len - 2; i >= 0; --i) + { + int val = dq[i]; + dq[i] += sum; + sum += val; + } + + int count = 0; + if (root->left != nullptr) + setBSTValue(root->left, dq, count); + root->val = dq[count++]; + if (root->right != nullptr) + setBSTValue(root->right, dq, count); + + return root; + } + + void getBSTValue(TreeNode* node, deque& dq) + { + if (node->left != nullptr) + getBSTValue(node->left, dq); + dq.push_back(node->val); + if (node->right != nullptr) + getBSTValue(node->right, dq); + } + + void setBSTValue(TreeNode* node, deque& dq, int& count) + { + if (node->left != nullptr) + setBSTValue(node->left, dq, count); + node->val = dq[count++]; + if (node->right != nullptr) + setBSTValue(node->right, dq, count); + } \ No newline at end of file diff --git a/551.cpp b/551.cpp new file mode 100644 index 0000000..c706d20 --- /dev/null +++ b/551.cpp @@ -0,0 +1,39 @@ +bool checkRecord(string s) { + size_t len = s.size(); + if (len <= 1) + return true; + + int num_A = 0, num_L = 0; + char status = s[0]; + if (status == 'A') + num_A++; + else if (status == 'L') + num_L++; + size_t i = 1; + while (i < len) + { + if (s[i] == 'P') + { + status = s[i]; + num_L = 0; + } + else if (s[i] == 'A') + { + if (num_A == 1) + return false; + num_A = 1; + num_L = 0; + status = s[i]; + } + else + { + if (num_L == 2) + return false; + num_L++; + status = s[i]; + } + i++; + } + + return true; + } \ No newline at end of file diff --git a/563.cpp b/563.cpp new file mode 100644 index 0000000..62ea3fe --- /dev/null +++ b/563.cpp @@ -0,0 +1,14 @@ +int findTilt(TreeNode* root) { + if (root == NULL) + return 0; + else + return abs(subSum(root->left) - subSum(root->right)) + findTilt(root->left) + findTilt(root->right); + } + + + int subSum(TreeNode* node) + { + if (node == NULL) + return 0; + return node->val + subSum(node->left) + subSum(node->right); + } \ No newline at end of file diff --git a/598.cpp b/598.cpp new file mode 100644 index 0000000..d89db32 --- /dev/null +++ b/598.cpp @@ -0,0 +1,17 @@ +int maxCount(int m, int n, vector>& ops) { + int row = ops.size(); + if (row == 0) + return m*n; + int col = ops[0].size(); + + int minrow = ops[0][0], mincol = ops[0][1]; + for (int i = 1; i < row; ++i) + { + if (ops[i][0] < minrow) + minrow = ops[i][0]; + if (ops[i][1] < mincol) + mincol = ops[i][1]; + } + + return minrow * mincol; + } \ No newline at end of file diff --git a/599.cpp b/599.cpp new file mode 100644 index 0000000..749220b --- /dev/null +++ b/599.cpp @@ -0,0 +1,54 @@ +vector findRestaurant(vector& list1, vector& list2) { + using SI = map; + SI mp1, mp2; + int len1 = list1.size(), len2 = list2.size(); + if (len1 == 0 || len2 == 0) + return {}; + + for (int i = 0; i < len1; ++i) + { + mp1.insert(pair(list1[i], i)); + } + for (int i = 0; i < len2; ++i) + { + mp2.insert(pair(list2[i], i)); + } + + vector res; + int index = 0, ct = 0; + int maxindex = 0; + for (int i = 0; i < len1; ++i) + { + if (mp2.find(list1[i]) != mp2.end()) + { + string s = list1[i]; + int sumindex = mp1[s] + mp2[s]; + if (maxindex == 0) + { + if (ct == 0) + { + maxindex = sumindex; + ct++; + res.push_back(s); + } + } + else + { + if (maxindex == sumindex) + { + res.push_back(s); + ct++; + } + else if (maxindex > sumindex) + { + res.push_back(s); + maxindex = sumindex; + index = ct; + ct++; + } + } + } + } + + return vector(res.begin() + index, res.end()); + } \ No newline at end of file diff --git a/690.cpp b/690.cpp new file mode 100644 index 0000000..e9e324c --- /dev/null +++ b/690.cpp @@ -0,0 +1,24 @@ +int getImportance(vector employees, int id) { + map mp; + int len = employees.size(); + for (int i = 0; i < len; ++i) + mp.insert(pair(employees[i]->id, employees[i])); + + deque dq; + dq.push_back(mp[id]); + int sum = 0; + while (!dq.empty()) + { + int sz = dq.size(); + for (int i = 0; i < sz; ++i) + { + sum += dq[i]->importance; + len = dq[i]->subordinates.size(); + for (int j = 0; j < len; ++j) + dq.push_back(mp[dq[i]->subordinates[j]]); + } + dq.erase(dq.begin(), dq.begin() + sz); + } + + return sum; + } \ No newline at end of file From 12350989e1530ab065ab6ab487362071d7040f5d Mon Sep 17 00:00:00 2001 From: lintcoder Date: Wed, 4 Apr 2018 11:36:11 +0800 Subject: [PATCH 02/97] 1.Modify the directory structure. 2.3 problems solved. --- 100.cpp => src/100.cpp | 0 104.cpp => src/104.cpp | 0 122.cpp => src/122.cpp | 0 125.cpp => src/125.cpp | 0 13.cpp => src/13.cpp | 0 136.cpp => src/136.cpp | 0 167.cpp => src/167.cpp | 0 169.cpp => src/169.cpp | 0 171.cpp => src/171.cpp | 0 206.cpp => src/206.cpp | 0 217.cpp => src/217.cpp | 0 226.cpp => src/226.cpp | 0 237.cpp => src/237.cpp | 0 242.cpp => src/242.cpp | 0 258.cpp => src/258.cpp | 0 268.cpp => src/268.cpp | 0 283.cpp => src/283.cpp | 0 292.cpp => src/292.cpp | 0 344.cpp => src/344.cpp | 0 349.cpp => src/349.cpp | 0 350.cpp => src/350.cpp | 0 371.cpp => src/371.cpp | 0 383.cpp => src/383.cpp | 0 387.cpp => src/387.cpp | 0 389.cpp => src/389.cpp | 0 401.cpp => src/401.cpp | 0 404.cpp => src/404.cpp | 0 409.cpp => src/409.cpp | 0 412.cpp => src/412.cpp | 0 src/443.cpp | 42 ++++++++++++++++++++++++++++++++++++++++++ 447.cpp => src/447.cpp | 0 448.cpp => src/448.cpp | 0 455.cpp => src/455.cpp | 0 461.cpp => src/461.cpp | 0 463.cpp => src/463.cpp | 0 476.cpp => src/476.cpp | 0 485.cpp => src/485.cpp | 0 492.cpp => src/492.cpp | 0 496.cpp => src/496.cpp | 0 500.cpp => src/500.cpp | 0 504.cpp => src/504.cpp | 0 506.cpp => src/506.cpp | 0 520.cpp => src/520.cpp | 0 530.cpp => src/530.cpp | 0 538.cpp => src/538.cpp | 0 551.cpp => src/551.cpp | 0 557.cpp => src/557.cpp | 0 561.cpp => src/561.cpp | 0 563.cpp => src/563.cpp | 0 566.cpp => src/566.cpp | 0 575.cpp => src/575.cpp | 0 598.cpp => src/598.cpp | 0 599.cpp => src/599.cpp | 0 606.cpp => src/606.cpp | 0 617.cpp => src/617.cpp | 0 637.cpp => src/637.cpp | 0 653.cpp => src/653.cpp | 0 657.cpp => src/657.cpp | 0 669.cpp => src/669.cpp | 0 682.cpp => src/682.cpp | 0 690.cpp => src/690.cpp | 0 src/693.cpp | 17 +++++++++++++++++ src/697.cpp | 36 ++++++++++++++++++++++++++++++++++++ 63 files changed, 95 insertions(+) rename 100.cpp => src/100.cpp (100%) rename 104.cpp => src/104.cpp (100%) rename 122.cpp => src/122.cpp (100%) rename 125.cpp => src/125.cpp (100%) rename 13.cpp => src/13.cpp (100%) rename 136.cpp => src/136.cpp (100%) rename 167.cpp => src/167.cpp (100%) rename 169.cpp => src/169.cpp (100%) rename 171.cpp => src/171.cpp (100%) rename 206.cpp => src/206.cpp (100%) rename 217.cpp => src/217.cpp (100%) rename 226.cpp => src/226.cpp (100%) rename 237.cpp => src/237.cpp (100%) rename 242.cpp => src/242.cpp (100%) rename 258.cpp => src/258.cpp (100%) rename 268.cpp => src/268.cpp (100%) rename 283.cpp => src/283.cpp (100%) rename 292.cpp => src/292.cpp (100%) rename 344.cpp => src/344.cpp (100%) rename 349.cpp => src/349.cpp (100%) rename 350.cpp => src/350.cpp (100%) rename 371.cpp => src/371.cpp (100%) rename 383.cpp => src/383.cpp (100%) rename 387.cpp => src/387.cpp (100%) rename 389.cpp => src/389.cpp (100%) rename 401.cpp => src/401.cpp (100%) rename 404.cpp => src/404.cpp (100%) rename 409.cpp => src/409.cpp (100%) rename 412.cpp => src/412.cpp (100%) create mode 100644 src/443.cpp rename 447.cpp => src/447.cpp (100%) rename 448.cpp => src/448.cpp (100%) rename 455.cpp => src/455.cpp (100%) rename 461.cpp => src/461.cpp (100%) rename 463.cpp => src/463.cpp (100%) rename 476.cpp => src/476.cpp (100%) rename 485.cpp => src/485.cpp (100%) rename 492.cpp => src/492.cpp (100%) rename 496.cpp => src/496.cpp (100%) rename 500.cpp => src/500.cpp (100%) rename 504.cpp => src/504.cpp (100%) rename 506.cpp => src/506.cpp (100%) rename 520.cpp => src/520.cpp (100%) rename 530.cpp => src/530.cpp (100%) rename 538.cpp => src/538.cpp (100%) rename 551.cpp => src/551.cpp (100%) rename 557.cpp => src/557.cpp (100%) rename 561.cpp => src/561.cpp (100%) rename 563.cpp => src/563.cpp (100%) rename 566.cpp => src/566.cpp (100%) rename 575.cpp => src/575.cpp (100%) rename 598.cpp => src/598.cpp (100%) rename 599.cpp => src/599.cpp (100%) rename 606.cpp => src/606.cpp (100%) rename 617.cpp => src/617.cpp (100%) rename 637.cpp => src/637.cpp (100%) rename 653.cpp => src/653.cpp (100%) rename 657.cpp => src/657.cpp (100%) rename 669.cpp => src/669.cpp (100%) rename 682.cpp => src/682.cpp (100%) rename 690.cpp => src/690.cpp (100%) create mode 100644 src/693.cpp create mode 100644 src/697.cpp diff --git a/100.cpp b/src/100.cpp similarity index 100% rename from 100.cpp rename to src/100.cpp diff --git a/104.cpp b/src/104.cpp similarity index 100% rename from 104.cpp rename to src/104.cpp diff --git a/122.cpp b/src/122.cpp similarity index 100% rename from 122.cpp rename to src/122.cpp diff --git a/125.cpp b/src/125.cpp similarity index 100% rename from 125.cpp rename to src/125.cpp diff --git a/13.cpp b/src/13.cpp similarity index 100% rename from 13.cpp rename to src/13.cpp diff --git a/136.cpp b/src/136.cpp similarity index 100% rename from 136.cpp rename to src/136.cpp diff --git a/167.cpp b/src/167.cpp similarity index 100% rename from 167.cpp rename to src/167.cpp diff --git a/169.cpp b/src/169.cpp similarity index 100% rename from 169.cpp rename to src/169.cpp diff --git a/171.cpp b/src/171.cpp similarity index 100% rename from 171.cpp rename to src/171.cpp diff --git a/206.cpp b/src/206.cpp similarity index 100% rename from 206.cpp rename to src/206.cpp diff --git a/217.cpp b/src/217.cpp similarity index 100% rename from 217.cpp rename to src/217.cpp diff --git a/226.cpp b/src/226.cpp similarity index 100% rename from 226.cpp rename to src/226.cpp diff --git a/237.cpp b/src/237.cpp similarity index 100% rename from 237.cpp rename to src/237.cpp diff --git a/242.cpp b/src/242.cpp similarity index 100% rename from 242.cpp rename to src/242.cpp diff --git a/258.cpp b/src/258.cpp similarity index 100% rename from 258.cpp rename to src/258.cpp diff --git a/268.cpp b/src/268.cpp similarity index 100% rename from 268.cpp rename to src/268.cpp diff --git a/283.cpp b/src/283.cpp similarity index 100% rename from 283.cpp rename to src/283.cpp diff --git a/292.cpp b/src/292.cpp similarity index 100% rename from 292.cpp rename to src/292.cpp diff --git a/344.cpp b/src/344.cpp similarity index 100% rename from 344.cpp rename to src/344.cpp diff --git a/349.cpp b/src/349.cpp similarity index 100% rename from 349.cpp rename to src/349.cpp diff --git a/350.cpp b/src/350.cpp similarity index 100% rename from 350.cpp rename to src/350.cpp diff --git a/371.cpp b/src/371.cpp similarity index 100% rename from 371.cpp rename to src/371.cpp diff --git a/383.cpp b/src/383.cpp similarity index 100% rename from 383.cpp rename to src/383.cpp diff --git a/387.cpp b/src/387.cpp similarity index 100% rename from 387.cpp rename to src/387.cpp diff --git a/389.cpp b/src/389.cpp similarity index 100% rename from 389.cpp rename to src/389.cpp diff --git a/401.cpp b/src/401.cpp similarity index 100% rename from 401.cpp rename to src/401.cpp diff --git a/404.cpp b/src/404.cpp similarity index 100% rename from 404.cpp rename to src/404.cpp diff --git a/409.cpp b/src/409.cpp similarity index 100% rename from 409.cpp rename to src/409.cpp diff --git a/412.cpp b/src/412.cpp similarity index 100% rename from 412.cpp rename to src/412.cpp diff --git a/src/443.cpp b/src/443.cpp new file mode 100644 index 0000000..304d9cd --- /dev/null +++ b/src/443.cpp @@ -0,0 +1,42 @@ +int compress(vector& chars) { + int len = chars.size(); + char c = chars[0]; + int i = 1, j = 0; + int ct = 1; + while (i < len) + { + if (chars[i] == c) + ++ct; + else + { + if (ct > 1) + modify_arr(chars, j, c, ct); + else + chars[j++] = c; + c = chars[i]; + ct = 1; + } + ++i; + } + if (ct > 1) + modify_arr(chars, j, c, ct); + else + chars[j++] = c; + + return j; + } + +void modify_arr(vector& chars, int& pos, char c, int num) +{ + char digit[4] = {'\0'}; + int i = 0; + chars[pos++] = c; + while (num > 0) + { + digit[i++] = num%10 + '0'; + num /= 10; + } + i = i - 1; + while (i >= 0) + chars[pos++] =digit[i--]; +} \ No newline at end of file diff --git a/447.cpp b/src/447.cpp similarity index 100% rename from 447.cpp rename to src/447.cpp diff --git a/448.cpp b/src/448.cpp similarity index 100% rename from 448.cpp rename to src/448.cpp diff --git a/455.cpp b/src/455.cpp similarity index 100% rename from 455.cpp rename to src/455.cpp diff --git a/461.cpp b/src/461.cpp similarity index 100% rename from 461.cpp rename to src/461.cpp diff --git a/463.cpp b/src/463.cpp similarity index 100% rename from 463.cpp rename to src/463.cpp diff --git a/476.cpp b/src/476.cpp similarity index 100% rename from 476.cpp rename to src/476.cpp diff --git a/485.cpp b/src/485.cpp similarity index 100% rename from 485.cpp rename to src/485.cpp diff --git a/492.cpp b/src/492.cpp similarity index 100% rename from 492.cpp rename to src/492.cpp diff --git a/496.cpp b/src/496.cpp similarity index 100% rename from 496.cpp rename to src/496.cpp diff --git a/500.cpp b/src/500.cpp similarity index 100% rename from 500.cpp rename to src/500.cpp diff --git a/504.cpp b/src/504.cpp similarity index 100% rename from 504.cpp rename to src/504.cpp diff --git a/506.cpp b/src/506.cpp similarity index 100% rename from 506.cpp rename to src/506.cpp diff --git a/520.cpp b/src/520.cpp similarity index 100% rename from 520.cpp rename to src/520.cpp diff --git a/530.cpp b/src/530.cpp similarity index 100% rename from 530.cpp rename to src/530.cpp diff --git a/538.cpp b/src/538.cpp similarity index 100% rename from 538.cpp rename to src/538.cpp diff --git a/551.cpp b/src/551.cpp similarity index 100% rename from 551.cpp rename to src/551.cpp diff --git a/557.cpp b/src/557.cpp similarity index 100% rename from 557.cpp rename to src/557.cpp diff --git a/561.cpp b/src/561.cpp similarity index 100% rename from 561.cpp rename to src/561.cpp diff --git a/563.cpp b/src/563.cpp similarity index 100% rename from 563.cpp rename to src/563.cpp diff --git a/566.cpp b/src/566.cpp similarity index 100% rename from 566.cpp rename to src/566.cpp diff --git a/575.cpp b/src/575.cpp similarity index 100% rename from 575.cpp rename to src/575.cpp diff --git a/598.cpp b/src/598.cpp similarity index 100% rename from 598.cpp rename to src/598.cpp diff --git a/599.cpp b/src/599.cpp similarity index 100% rename from 599.cpp rename to src/599.cpp diff --git a/606.cpp b/src/606.cpp similarity index 100% rename from 606.cpp rename to src/606.cpp diff --git a/617.cpp b/src/617.cpp similarity index 100% rename from 617.cpp rename to src/617.cpp diff --git a/637.cpp b/src/637.cpp similarity index 100% rename from 637.cpp rename to src/637.cpp diff --git a/653.cpp b/src/653.cpp similarity index 100% rename from 653.cpp rename to src/653.cpp diff --git a/657.cpp b/src/657.cpp similarity index 100% rename from 657.cpp rename to src/657.cpp diff --git a/669.cpp b/src/669.cpp similarity index 100% rename from 669.cpp rename to src/669.cpp diff --git a/682.cpp b/src/682.cpp similarity index 100% rename from 682.cpp rename to src/682.cpp diff --git a/690.cpp b/src/690.cpp similarity index 100% rename from 690.cpp rename to src/690.cpp diff --git a/src/693.cpp b/src/693.cpp new file mode 100644 index 0000000..7563627 --- /dev/null +++ b/src/693.cpp @@ -0,0 +1,17 @@ +bool hasAlternatingBits(int n) { + if (n <= 1) + return false; + else + { + int bit = n&0x1; + n >>= 1; + while (n > 0) + { + if ((n&0x1) == bit) + return false; + bit = 1-bit; + n >>= 1; + } + return true; + } + } \ No newline at end of file diff --git a/src/697.cpp b/src/697.cpp new file mode 100644 index 0000000..a4c60de --- /dev/null +++ b/src/697.cpp @@ -0,0 +1,36 @@ +int findShortestSubArray(vector& nums) { + int len = nums.size(); + map> mp; + for (int i = 0; i < len; ++i) + { + if (mp.find(nums[i]) == mp.end()) + mp.insert(pair>(nums[i], vector(1, i))); + else + mp[nums[i]].push_back(i); + } + + int maxlen = 0; + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + { + if (iter->second.size() > maxlen) + maxlen = iter->second.size(); + } + + auto iter = mp.begin(); + while (iter != mp.end() && iter->second.size() != maxlen) + ++iter; + int shortlength = iter->second[maxlen - 1] - iter->second[0] + 1; + ++iter; + + for (; iter != mp.end(); ++iter) + { + if (iter->second.size() == maxlen) + { + int dist = iter->second[maxlen - 1] - iter->second[0] + 1; + if (dist < shortlength) + shortlength = dist; + } + } + + return shortlength; + } \ No newline at end of file From 18d21d575f411945654d156f9feee76fd30c6eaa Mon Sep 17 00:00:00 2001 From: lintcoder Date: Sun, 8 Apr 2018 15:20:38 +0800 Subject: [PATCH 03/97] 1.15 problems solved. --- src/107.cpp | 30 ++++++++++++++++++++++++++++++ src/121.cpp | 29 +++++++++++++++++++++++++++++ src/541.cpp | 13 +++++++++++++ src/671.cpp | 44 ++++++++++++++++++++++++++++++++++++++++++++ src/674.cpp | 22 ++++++++++++++++++++++ src/717.cpp | 13 +++++++++++++ src/728.cpp | 24 ++++++++++++++++++++++++ src/744.cpp | 8 ++++++++ src/766.cpp | 28 ++++++++++++++++++++++++++++ src/771.cpp | 16 ++++++++++++++++ src/784.cpp | 46 ++++++++++++++++++++++++++++++++++++++++++++++ src/796.cpp | 16 ++++++++++++++++ src/804.cpp | 17 +++++++++++++++++ src/806.cpp | 17 +++++++++++++++++ src/811.cpp | 26 ++++++++++++++++++++++++++ 15 files changed, 349 insertions(+) create mode 100644 src/107.cpp create mode 100644 src/121.cpp create mode 100644 src/541.cpp create mode 100644 src/671.cpp create mode 100644 src/674.cpp create mode 100644 src/717.cpp create mode 100644 src/728.cpp create mode 100644 src/744.cpp create mode 100644 src/766.cpp create mode 100644 src/771.cpp create mode 100644 src/784.cpp create mode 100644 src/796.cpp create mode 100644 src/804.cpp create mode 100644 src/806.cpp create mode 100644 src/811.cpp diff --git a/src/107.cpp b/src/107.cpp new file mode 100644 index 0000000..0fe06be --- /dev/null +++ b/src/107.cpp @@ -0,0 +1,30 @@ +vector> levelOrderBottom(TreeNode* root) { + vector> res; + if (root == NULL) + return res; + else + { + TreeNode* node = root; + deque dq; + dq.push_back(node); + while (!dq.empty()) + { + int len = dq.size(); + vector vec; + for (int i = 0; i < len; ++i) + { + TreeNode* t = dq.front(); + vec.push_back(t->val); + if (t->left != NULL) + dq.push_back(t->left); + if (t->right != NULL) + dq.push_back(t->right); + dq.pop_front(); + } + + res.push_back(vec); + } + reverse(res.begin(), res.end()); + return res; + } + } \ No newline at end of file diff --git a/src/121.cpp b/src/121.cpp new file mode 100644 index 0000000..6e4b2f2 --- /dev/null +++ b/src/121.cpp @@ -0,0 +1,29 @@ +int maxProfit(vector& prices) { + int len = prices.size(); + int max = 0; + if (len >= 2) + max = domaxProfit(prices, 0, len - 1); + return max; + } + + int domaxProfit(vector& prices, int p, int q) + { + if (p >= q - 1) + return prices[q] > prices[p] ? prices[q] - prices[p] : 0; + else + { + int mid = p / 2 + q / 2; + int max1 = domaxProfit(prices, p, mid); + int max2 = domaxProfit(prices, mid + 1, q); + int submin = prices[p]; + int submax = 0; + for (int i = p; i <= mid; ++i) + if (prices[i] < submin) + submin = prices[i]; + for (int i = mid + 1; i <= q; ++i) + if (prices[i] > submax) + submax = prices[i]; + int max3 = submax > submin ? submax - submin : 0; + return max1 > max2 ? (max1 > max3 ? max1 : max3) : (max2 > max3 ? max2 : max3); + } + } \ No newline at end of file diff --git a/src/541.cpp b/src/541.cpp new file mode 100644 index 0000000..dd87c62 --- /dev/null +++ b/src/541.cpp @@ -0,0 +1,13 @@ +string reverseStr(string s, int k) { + int len = s.size(); + int num = len / (2 * k); + for (int i = 0; i < num; ++i) + reverse(s.begin() + i * 2 * k, s.begin() + (2 * i + 1) * k); + int remain = len % (2 * k); + if (remain >= k) + reverse(s.begin() + num * 2 * k, s.begin() + (num * 2 + 1) * k); + else + reverse(s.begin() + num * 2 * k, s.end()); + + return s; + } \ No newline at end of file diff --git a/src/671.cpp b/src/671.cpp new file mode 100644 index 0000000..02b57ba --- /dev/null +++ b/src/671.cpp @@ -0,0 +1,44 @@ +int findSecondMinimumValue(TreeNode* root) { + if (root == nullptr) + return -1; + int val = root->val; + if (root->left == nullptr) + return -1; + else + { + int min1 = root->left->val; + int min2 = root->right->val; + if (min1 == val && min2 != val) + { + min1 = findSecondMinimumValue(root->left); + if (min1 == -1) + return min2; + else + return min1 < min2 ? min1 : min2; + } + else if (min1 != val && min2 == val) + { + min2 = findSecondMinimumValue(root->right); + if (min2 == -1) + return min1; + else + return min1 < min2 ? min1 : min2; + } + else if (min1 != val && min2 != val) + return min1 < min2 ? min1 : min2; + else + { + min1 = findSecondMinimumValue(root->left); + min2 = findSecondMinimumValue(root->right); + + if (min1 == -1 && min2 == -1) + return -1; + else if (min1 == -1 && min2 != -1) + return min2; + else if (min1 != -1 && min2 == -1) + return min1; + else + return min1 < min2 ? min1 : min2; + } + } + } \ No newline at end of file diff --git a/src/674.cpp b/src/674.cpp new file mode 100644 index 0000000..f772eb6 --- /dev/null +++ b/src/674.cpp @@ -0,0 +1,22 @@ +int findLengthOfLCIS(vector& nums) { + int len = nums.size(); + if (len <= 1) + return len; + int maxlen = 1; + int count = 1; + for (int i = 1; i < len; ++i) + { + if (nums[i] > nums[i - 1]) + ++count; + else if (nums[i] <= nums[i - 1]) + { + if (count > maxlen) + maxlen = count; + count = 1; + } + } + if (count > maxlen) + maxlen = count; + + return maxlen; + } \ No newline at end of file diff --git a/src/717.cpp b/src/717.cpp new file mode 100644 index 0000000..c3dc420 --- /dev/null +++ b/src/717.cpp @@ -0,0 +1,13 @@ +bool isOneBitCharacter(vector& bits) { + int len = bits.size(); + int i = 0; + while (i < len - 2) + { + if (bits[i] == 0) + ++i; + else + i += 2; + } + + return bits[i] != 1; + } \ No newline at end of file diff --git a/src/728.cpp b/src/728.cpp new file mode 100644 index 0000000..1af1e49 --- /dev/null +++ b/src/728.cpp @@ -0,0 +1,24 @@ +vector selfDividingNumbers(int left, int right) { + vector res; + for (int i = left; i <= right; ++i) + { + if (isselfdivide(i)) + res.push_back(i); + } + + return res; + } + + bool isselfdivide(int num) + { + int n = num; + while (n != 0) + { + int r = n % 10; + if (r == 0 || num % r != 0) + return false; + n /= 10; + } + + return true; + } \ No newline at end of file diff --git a/src/744.cpp b/src/744.cpp new file mode 100644 index 0000000..b39f079 --- /dev/null +++ b/src/744.cpp @@ -0,0 +1,8 @@ +char nextGreatestLetter(vector& letters, char target) { + int len = letters.size(); + for (int i = 0; i < len; ++i) + if (letters[i] > target) + return letters[i]; + + return letters[0]; + } \ No newline at end of file diff --git a/src/766.cpp b/src/766.cpp new file mode 100644 index 0000000..fe523eb --- /dev/null +++ b/src/766.cpp @@ -0,0 +1,28 @@ +bool isToeplitzMatrix(vector>& matrix) { + int row = matrix.size(); + if (row == 0) + return false; + int col = matrix[0].size(); + if (row == 1 || col == 1) + return true; + + for (int i = row - 2; i >= 0; --i) + { + for (int j = i+1, k = 1; j < row && k < col; ++j, ++k) + { + if (matrix[j][k] != matrix[i][0]) + return false; + } + } + + for (int i = 1; i < col; ++i) + { + for (int j = 1, k = i+1; j < row && k < col; ++j, ++k) + { + if (matrix[j][k] != matrix[0][i]) + return false; + } + } + + return true; + } \ No newline at end of file diff --git a/src/771.cpp b/src/771.cpp new file mode 100644 index 0000000..ba7288d --- /dev/null +++ b/src/771.cpp @@ -0,0 +1,16 @@ +int numJewelsInStones(string J, string S) { + int len1 = J.size(); + int len2 = S.size(); + if (len1 == 0 || len2 == 0) + return 0; + set jewels; + for (int i = 0; i < len1; ++i) + jewels.insert(J[i]); + + int ct = 0; + for (int i = 0; i < len2; ++i) + if (jewels.find(S[i]) != jewels.end()) + ++ct; + + return ct; + } \ No newline at end of file diff --git a/src/784.cpp b/src/784.cpp new file mode 100644 index 0000000..cc39ad1 --- /dev/null +++ b/src/784.cpp @@ -0,0 +1,46 @@ +vector letterCasePermutation(string S) { + vector res; + vector letterpos; + + int len = S.size(); + int ct = 0; + for (int i = 0; i < len; ++i) + { + if (isalpha(S[i])) + { + letterpos.push_back(i); + ++ct; + } + } + if (ct == 0) + { + res.push_back(S); + return res; + } + + doPermutation(S, 1, ct, letterpos, res); + + return res; + } + + void doPermutation(string& S, int n, int ct, const vector& pos, vector& res) + { + if (n == ct) + { + res.push_back(S); + if (islower(S[pos[n-1]])) + S[pos[n-1]] = toupper(S[pos[n-1]]); + else + S[pos[n-1]] = tolower(S[pos[n-1]]); + res.push_back(S); + } + else + { + doPermutation(S, n+1, ct, pos, res); + if (islower(S[pos[n-1]])) + S[pos[n-1]] = toupper(S[pos[n-1]]); + else + S[pos[n-1]] = tolower(S[pos[n-1]]); + doPermutation(S, n+1, ct, pos, res); + } + } \ No newline at end of file diff --git a/src/796.cpp b/src/796.cpp new file mode 100644 index 0000000..7aaa310 --- /dev/null +++ b/src/796.cpp @@ -0,0 +1,16 @@ +bool rotateString(string A, string B) { + int lenA = A.size(); + int lenB = B.size(); + if (lenA != lenB) + return false; + if (lenA == 0 && lenB == 0) + return true; + int index = 0; + while (index < lenA && (index = B.find(A[0], index)) != string::npos) + { + if (A.substr(0, lenB - index) == B.substr(index) && A.substr(lenB-index) == B.substr(0, index)) + return true; + index++; + } + return false; + } \ No newline at end of file diff --git a/src/804.cpp b/src/804.cpp new file mode 100644 index 0000000..4671ac2 --- /dev/null +++ b/src/804.cpp @@ -0,0 +1,17 @@ +int uniqueMorseRepresentations(vector& words) { + const string morsecode[26] = {".-","-...","-.-.","-..",".","..-.","--.","....","..", + ".---","-.-",".-..","--","-.","---",".--.","--.-", + ".-.","...","-","..-","...-",".--","-..-","-.--","--.."}; + set transformations; + int len = words.size(); + for (int i = 0; i < len; ++i) + { + string trans; + int sz = words[i].size(); + for (int j = 0; j < sz; ++j) + trans += morsecode[words[i][j]-'a']; + transformations.insert(trans); + } + + return transformations.size(); + } \ No newline at end of file diff --git a/src/806.cpp b/src/806.cpp new file mode 100644 index 0000000..7519df5 --- /dev/null +++ b/src/806.cpp @@ -0,0 +1,17 @@ +vector numberOfLines(vector& widths, string S) { + int len = S.size(); + int line = 1, sz = 0; + for (int i = 0; i < len; ++i) + { + int n = widths[S[i]-'a']; + if (sz + n <= 100) + sz += n; + else + { + line++; + sz = n; + } + } + + return {line, sz}; + } \ No newline at end of file diff --git a/src/811.cpp b/src/811.cpp new file mode 100644 index 0000000..f12af12 --- /dev/null +++ b/src/811.cpp @@ -0,0 +1,26 @@ +vector subdomainVisits(vector& cpdomains) { + int sz = cpdomains.size(); + map mp; + vector res; + + for (int i = 0; i < sz; ++i) + { + abstractdomains(cpdomains[i], mp); + } + + for (auto iter : mp) + res.push_back(to_string(iter.second) + " " + iter.first); + + return res; + } + + void abstractdomains(const string& cpdomain, map& mp) + { + int index = cpdomain.find(' '); + int ct = stoi(cpdomain.substr(0, index)); + mp[cpdomain.substr(index+1)] += ct; + while ((index = cpdomain.find('.', index+1)) != string::npos) + { + mp[cpdomain.substr(index+1)] += ct; + } + } \ No newline at end of file From b9bb1563c87750e5190a88a139429d82f1d8ccad Mon Sep 17 00:00:00 2001 From: lintcoder Date: Mon, 16 Apr 2018 11:49:35 +0800 Subject: [PATCH 04/97] 12 problems solved. --- src/160.cpp | 39 +++++++++++++++++++++++++++++++++++ src/168.cpp | 18 +++++++++++++++++ src/189.cpp | 13 ++++++++++++ src/190.cpp | 7 +++++++ src/204.cpp | 36 +++++++++++++++++++++++++++++++++ src/278.cpp | 14 +++++++++++++ src/28.cpp | 31 ++++++++++++++++++++++++++++ src/400.cpp | 39 +++++++++++++++++++++++++++++++++++ src/475.cpp | 58 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/605.cpp | 41 +++++++++++++++++++++++++++++++++++++ src/69.cpp | 22 ++++++++++++++++++++ src/7.cpp | 22 ++++++++++++++++++++ 12 files changed, 340 insertions(+) create mode 100644 src/160.cpp create mode 100644 src/168.cpp create mode 100644 src/189.cpp create mode 100644 src/190.cpp create mode 100644 src/204.cpp create mode 100644 src/278.cpp create mode 100644 src/28.cpp create mode 100644 src/400.cpp create mode 100644 src/475.cpp create mode 100644 src/605.cpp create mode 100644 src/69.cpp create mode 100644 src/7.cpp diff --git a/src/160.cpp b/src/160.cpp new file mode 100644 index 0000000..4738627 --- /dev/null +++ b/src/160.cpp @@ -0,0 +1,39 @@ +ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { + if (headA == NULL || headB == NULL) + return NULL; + int len1 = 0, len2 = 0; + ListNode* p = headA, *q = headB; + while (p != NULL) + { + p = p->next; + len1++; + } + while (q != NULL) + { + q = q->next; + len2++; + } + p = headA; + q = headB; + while (len1 < len2) + { + q = q->next; + len2--; + } + while (len1 > len2) + { + p = p->next; + len1--; + } + while (p != NULL && q != NULL) + { + if (p == q) + return p; + else + { + p = p->next; + q = q->next; + } + } + return NULL; + } \ No newline at end of file diff --git a/src/168.cpp b/src/168.cpp new file mode 100644 index 0000000..2dc0a49 --- /dev/null +++ b/src/168.cpp @@ -0,0 +1,18 @@ +string convertToTitle(int n) { + char digit[26]; + digit[0] = 'Z'; + for (int i = 1; i < 26; ++i) + digit[i] = 'A' + i - 1; + string str; + while (n > 0) + { + int pos = n % 26; + str.push_back(digit[pos]); + if (pos == 0) + n = n / 26 - 1; + else + n = n / 26; + } + reverse(str.begin(), str.end()); + return str; + } \ No newline at end of file diff --git a/src/189.cpp b/src/189.cpp new file mode 100644 index 0000000..4dd2a9f --- /dev/null +++ b/src/189.cpp @@ -0,0 +1,13 @@ +void rotate(vector& nums, int k) { + int len = nums.size(); + k %= len; + + if (k == 0) + return; + else + { + reverse(nums.begin(), nums.begin() + len - k); + reverse(nums.begin() + len - k, nums.end()); + reverse(nums.begin(), nums.end()); + } + } \ No newline at end of file diff --git a/src/190.cpp b/src/190.cpp new file mode 100644 index 0000000..4c55543 --- /dev/null +++ b/src/190.cpp @@ -0,0 +1,7 @@ +uint32_t reverseBits(uint32_t n) { + uint32_t sum = 0; + bitset<32> bt(n); + for (int i = 0; i < 32; ++i) + sum = sum * 2 + bt[i]; + return sum; + } \ No newline at end of file diff --git a/src/204.cpp b/src/204.cpp new file mode 100644 index 0000000..d72e8a1 --- /dev/null +++ b/src/204.cpp @@ -0,0 +1,36 @@ +int countPrimes(int n) { + if (n <= 2) + return 0; + + int* arr = new int[n]; + for (int i = 0; i < n; ++i) + arr[i] = 1; + arr[0] = arr[1] = 0; + + for (int i = 2; i < n - 2; i += 2) + arr[i + 2] = 0; + + int lim = sqrt(n - 1); + int i = 3, j; + while (i <= lim) + { + if (arr[i] == 1) + { + int lim2 = (n - 1) / i; + for (j = i; j <= lim2; ++j) + arr[i * j] = 0; + + } + i += 2; + while (arr[i] == 0) + i += 2; + } + + int count = 0; + for (i = 0; i < n; ++i) + if (arr[i] == 1) + ++count; + delete[] arr; + + return count; + } \ No newline at end of file diff --git a/src/278.cpp b/src/278.cpp new file mode 100644 index 0000000..df52762 --- /dev/null +++ b/src/278.cpp @@ -0,0 +1,14 @@ +int firstBadVersion(int n) { + if (n < 1) + return 0; + int p = 1, q = n; + while (p < q) + { + int mid = p / 2 + q / 2; + if (isBadVersion(mid)) + q = mid; + else + p = mid + 1; + } + return p; + } \ No newline at end of file diff --git a/src/28.cpp b/src/28.cpp new file mode 100644 index 0000000..6ace445 --- /dev/null +++ b/src/28.cpp @@ -0,0 +1,31 @@ +int strStr(string haystack, string needle) { + int len1 = haystack.size(); + int len2 = needle.size(); + if (len1 < len2) + return -1; + if (len2 == 0) + return 0; + + int i = 0, pos = 0; + bool flag = false; + while (i < len1) + { + pos = haystack.find(needle[0], i); + if (pos == string::npos || len1 - pos < len2) + break; + else + { + if (haystack.substr(pos, len2) == needle) + { + flag = true; + break; + } + else + i = pos + 1; + } + } + if (flag) + return pos; + else + return -1; + } \ No newline at end of file diff --git a/src/400.cpp b/src/400.cpp new file mode 100644 index 0000000..9f7a4f1 --- /dev/null +++ b/src/400.cpp @@ -0,0 +1,39 @@ +int findNthDigit(int n) { + if (n <= 0) + return 0; + long long num = 1, ct = 1; + int predigits = 0, count = 9; + long long digits = 9 * num * ct; + while (n >= digits) + { + n -= digits; + num *= 10; + ++ct; + predigits += count; + count *= 10; + digits = 9 * num * ct; + } + + if (n == 0) + return 9; + else + { + int remain = n % ct; + int val = n / ct; + if (remain == 0) + return (predigits + val) % 10; + else + return selectNthDigit(predigits + val + 1, remain, ct); + } + } + + int selectNthDigit(int num, int pos, int totaldigit) + { + int n = totaldigit - pos; + while (n > 0) + { + num /= 10; + --n; + } + return num % 10; + } \ No newline at end of file diff --git a/src/475.cpp b/src/475.cpp new file mode 100644 index 0000000..e3d0bbe --- /dev/null +++ b/src/475.cpp @@ -0,0 +1,58 @@ +int findRadius(vector& houses, vector& heaters) { + int num1 = houses.size(); + int num2 = heaters.size(); + if (num1 == 0 || num2 == 0) + return 0; + sort(houses.begin(), houses.end()); + sort(heaters.begin(), heaters.end()); + int min_radius = 0, rad = 0; + int i = 0, j = 0; + if (houses[i] < heaters[j]) + { + min_radius = heaters[j] - houses[i]; + ++i; + while (i < num1 && houses[i] < heaters[j]) + ++i; + } + while (i < num1) + { + if (houses[i] == heaters[j]) + ++i; + else + { + if (j == num2) + break; + else + { + int rlimit = heaters[j + 1]; + if (houses[i] < rlimit) + { + int lrad = houses[i] - heaters[j]; + int rrad = heaters[j + 1] - houses[i]; + int tmp = lrad < rrad ? lrad : rrad; + if (tmp > rad) + rad = tmp; + ++i; + } + else if (houses[i] == rlimit) + ++i; + else + { + if (rad > min_radius) + min_radius = rad; + ++j; + } + } + } + } + if (rad > min_radius) + min_radius = rad; + if (i < num1) + { + int tmp = houses[num1 - 1] - heaters[num2 - 1]; + if (tmp > min_radius) + min_radius = tmp; + } + + return min_radius; + } \ No newline at end of file diff --git a/src/605.cpp b/src/605.cpp new file mode 100644 index 0000000..750db4f --- /dev/null +++ b/src/605.cpp @@ -0,0 +1,41 @@ +bool canPlaceFlowers(vector& flowerbed, int n) { + if (n == 0) + return true; + + int len = flowerbed.size(); + int i = 0; + if (len == 1) + return flowerbed[0] == 0; + + while (i < len && n > 0) + { + if (i == 0) + { + if (flowerbed[i] == 0 && flowerbed[i + 1] == 0) + { + n--; + i += 2; + } + else + ++i; + } + else if (i < len - 1) + { + if (flowerbed[i - 1] == 0 && flowerbed[i] == 0 && flowerbed[i + 1] == 0) + { + n--; + i += 2; + } + else + ++i; + } + else + { + if (n == 1) + return flowerbed[i - 1] == 0 && flowerbed[i] == 0; + else + return false; + } + } + return n == 0; + } \ No newline at end of file diff --git a/src/69.cpp b/src/69.cpp new file mode 100644 index 0000000..f5b9b10 --- /dev/null +++ b/src/69.cpp @@ -0,0 +1,22 @@ +int mySqrt(int x) { + if (x < 0) + return -1; + if (x <= 1) + return x; + int p = 1, q = x; + while (p < q - 1) + { + long long mid = p/2 + q/2 + (p%2 && q%2); + long long res = mid * mid; + if (res == x) + return mid; + else if (res < x) + p = mid; + else + q = mid - 1; + } + if (q <= x/q) + return q; + else + return p; + } \ No newline at end of file diff --git a/src/7.cpp b/src/7.cpp new file mode 100644 index 0000000..0e41ab6 --- /dev/null +++ b/src/7.cpp @@ -0,0 +1,22 @@ +int reverse(int x) { + int flag = 1; + if (x < 0) + { + if (x == INT_MIN) + return 0; + else + { + x = -x; + flag = -1; + } + } + long long sum = 0; + while (x > 0) + { + sum = sum * 10 + x % 10; + x /= 10; + if (sum > INT_MAX) + return 0; + } + return sum * flag; + } \ No newline at end of file From 3c857858397c8fd4a1024d180155be5d2a8d2d58 Mon Sep 17 00:00:00 2001 From: lintcoder Date: Tue, 17 Apr 2018 21:06:52 +0800 Subject: [PATCH 05/97] Solved 10 problems. --- src/14.cpp | 38 ++++++++++++++++++++++++++++++++++++++ src/203.cpp | 32 ++++++++++++++++++++++++++++++++ src/219.cpp | 38 ++++++++++++++++++++++++++++++++++++++ src/234.cpp | 36 ++++++++++++++++++++++++++++++++++++ src/290.cpp | 40 ++++++++++++++++++++++++++++++++++++++++ src/303.cpp | 16 ++++++++++++++++ src/507.cpp | 11 +++++++++++ src/58.cpp | 18 ++++++++++++++++++ src/633.cpp | 11 +++++++++++ src/88.cpp | 23 +++++++++++++++++++++++ 10 files changed, 263 insertions(+) create mode 100644 src/14.cpp create mode 100644 src/203.cpp create mode 100644 src/219.cpp create mode 100644 src/234.cpp create mode 100644 src/290.cpp create mode 100644 src/303.cpp create mode 100644 src/507.cpp create mode 100644 src/58.cpp create mode 100644 src/633.cpp create mode 100644 src/88.cpp diff --git a/src/14.cpp b/src/14.cpp new file mode 100644 index 0000000..3f87c5b --- /dev/null +++ b/src/14.cpp @@ -0,0 +1,38 @@ +string longestCommonPrefix(vector& strs) { + string prefix; + int sz = strs.size(); + if (sz == 0) + return prefix; + else if (sz == 1) + return strs[0]; + else + { + int minlen = strs[0].size(); + for (int i = 1; i < sz; ++i) + { + int len = strs[i].size(); + if (len < minlen) + minlen = len; + } + + int i, j = 0; + while (j < minlen) + { + char c = strs[0][j]; + for (i = 1; i < sz; ++i) + { + if (strs[i][j] != c) + break; + } + if (i != sz) + break; + else + { + prefix.push_back(c); + ++j; + } + } + + return prefix; + } + } \ No newline at end of file diff --git a/src/203.cpp b/src/203.cpp new file mode 100644 index 0000000..ecd67cc --- /dev/null +++ b/src/203.cpp @@ -0,0 +1,32 @@ +ListNode* removeElements(ListNode* head, int val) { + ListNode* p = head, *q; + while (p != NULL && p->val == val) + { + q = p->next; + delete p; + p = q; + } + if (p == NULL) + return NULL; + head = p; + q = p->next; + while (q != NULL) + { + while (q != NULL && q->val == val) + { + ListNode* k = q->next; + delete q; + q = k; + } + if (q != NULL) + { + p->next = q; + p = q; + q = q->next; + } + else + p->next = q; + } + + return head; + } \ No newline at end of file diff --git a/src/219.cpp b/src/219.cpp new file mode 100644 index 0000000..81e2fc5 --- /dev/null +++ b/src/219.cpp @@ -0,0 +1,38 @@ +bool containsNearbyDuplicate(vector& nums, int k) { + int sz = nums.size(); + vector vec; + for (int i = 0; i != sz; ++i) + vec.push_back(Elem(nums[i], i)); + sort(vec.begin(), vec.end(), cmp); + + int i = 0, j = 0; + while (i < sz) + { + int val = vec[i].val; + j = i + 1; + while (j < sz && vec[j].val == val) + { + if (vec[j].pos - vec[i].pos <= k) + return true; + else + { + i = j; + ++j; + } + } + if (j == sz) + return false; + else + i = j; + } + return false; + } + struct Elem{ + int val; + int pos; + Elem(int v, int p) : val(v), pos(p){} + }; + static bool cmp(Elem a, Elem b) + { + return a.val < b.val || a.pos < b.pos; + } \ No newline at end of file diff --git a/src/234.cpp b/src/234.cpp new file mode 100644 index 0000000..546398d --- /dev/null +++ b/src/234.cpp @@ -0,0 +1,36 @@ +bool isPalindrome(ListNode* head) { + ListNode* p = head; + int num = 0; + while (p != NULL) + { + p = p->next; + num++; + } + int lim = num / 2; + int n = 0; + if (lim > 0) + { + ListNode* h = head; + ListNode* q = h->next; + h->next = NULL; + n++; + while (n < lim) + { + p = q->next; + q->next = h; + h = q; + q = p; + n++; + } + if (num % 2 == 1) + q = q->next; + while (h != NULL && q != NULL) + { + if (h->val != q->val) + return false; + h = h->next; + q = q->next; + } + } + return true; + } \ No newline at end of file diff --git a/src/290.cpp b/src/290.cpp new file mode 100644 index 0000000..7719aa6 --- /dev/null +++ b/src/290.cpp @@ -0,0 +1,40 @@ +bool wordPattern(string pattern, string str) { + vector bijection(26, ""); + set stjection; + int sz = pattern.size(); + + if (sz == 0) + return false; + char c; + int index = 0, pos = 0; + for (int i = 0; i != sz; ++i) + { + c = pattern[i]; + if (i < sz - 1) + pos = str.find(' ', index); + else + pos = sz; + if (pos == -1) + return false; + else + { + string s = str.substr(index, pos - index); + string bi = bijection[c - 'a']; + if (bi != "") + { + if (bi != s) + return false; + } + else + { + if (stjection.find(s) != stjection.end()) + return false; + bijection[c - 'a'] = s; + stjection.insert(s); + } + } + index = pos + 1; + } + + return true; + } \ No newline at end of file diff --git a/src/303.cpp b/src/303.cpp new file mode 100644 index 0000000..c95cc17 --- /dev/null +++ b/src/303.cpp @@ -0,0 +1,16 @@ +public: + NumArray(vector nums) { + int len = nums.size(); + arry.assign(len, 0); + for (int i = 0; i < len; ++i) + arry[i] = nums[i]; + } + + int sumRange(int i, int j) { + int sum = arry[i]; + for (int m = i + 1; m <= j; ++m) + sum += arry[m]; + return sum; + } +private: + vector arry; \ No newline at end of file diff --git a/src/507.cpp b/src/507.cpp new file mode 100644 index 0000000..7a8aa79 --- /dev/null +++ b/src/507.cpp @@ -0,0 +1,11 @@ +bool checkPerfectNumber(int num) { + if (num <= 1) + return false; + int lim = sqrt(num); + int sum = 1; + for (int i = 2; i <= lim; ++i) + if (num % i == 0) + sum += i + num/i; + + return sum == num; + } \ No newline at end of file diff --git a/src/58.cpp b/src/58.cpp new file mode 100644 index 0000000..6bfcbc2 --- /dev/null +++ b/src/58.cpp @@ -0,0 +1,18 @@ +int lengthOfLastWord(string s) { + int sz = s.size(); + int len = 0; + int p = 0, q = 0; + while (p < sz) + { + p = s.find_first_not_of(' ', q); + if (p == string::npos) + break; + q = s.find(' ', p); + if (q == string::npos) + break; + len = q - p; + } + if (q == string::npos) + len = sz - p; + return len; + } \ No newline at end of file diff --git a/src/633.cpp b/src/633.cpp new file mode 100644 index 0000000..4783297 --- /dev/null +++ b/src/633.cpp @@ -0,0 +1,11 @@ +bool judgeSquareSum(int c) { + int lim = sqrt(c/2); + for (int i = 0; i <= lim; ++i) + { + int remain = c - i*i; + int tmp = sqrt(remain); + if (tmp * tmp == remain) + return true; + } + return false; + } \ No newline at end of file diff --git a/src/88.cpp b/src/88.cpp new file mode 100644 index 0000000..c39392a --- /dev/null +++ b/src/88.cpp @@ -0,0 +1,23 @@ +void merge(vector& nums1, int m, vector& nums2, int n) { + int* arr = new int[m + n]; + int i = 0, j = 0, k = 0; + while (i < m && j < n) + { + if (nums1[i] <= nums2[j]) + { + arr[k++] = nums1[i]; + i++; + } + else + { + arr[k++] = nums2[j]; + j++; + } + } + while (i < m) + arr[k++] = nums1[i++]; + while (j < n) + arr[k++] = nums2[j++]; + nums1.assign(arr, arr + m + n); + delete[] arr; + } \ No newline at end of file From be12b25af82ad67818aa84160abd74c81159f5a5 Mon Sep 17 00:00:00 2001 From: lintcoder Date: Fri, 20 Apr 2018 14:20:52 +0800 Subject: [PATCH 06/97] 15 problems solved. --- src/406.cpp | 30 ++++++++++++++++++++++++++++++ src/413.cpp | 23 +++++++++++++++++++++++ src/442.cpp | 38 ++++++++++++++++++++++++++++++++++++++ src/451.cpp | 34 ++++++++++++++++++++++++++++++++++ src/513.cpp | 26 ++++++++++++++++++++++++++ src/515.cpp | 37 +++++++++++++++++++++++++++++++++++++ src/526.cpp | 30 ++++++++++++++++++++++++++++++ src/537.cpp | 17 +++++++++++++++++ src/540.cpp | 47 +++++++++++++++++++++++++++++++++++++++++++++++ src/654.cpp | 27 +++++++++++++++++++++++++++ src/677.cpp | 27 +++++++++++++++++++++++++++ src/748.cpp | 42 ++++++++++++++++++++++++++++++++++++++++++ src/763.cpp | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/814.cpp | 47 +++++++++++++++++++++++++++++++++++++++++++++++ src/94.cpp | 34 ++++++++++++++++++++++++++++++++++ 15 files changed, 509 insertions(+) create mode 100644 src/406.cpp create mode 100644 src/413.cpp create mode 100644 src/442.cpp create mode 100644 src/451.cpp create mode 100644 src/513.cpp create mode 100644 src/515.cpp create mode 100644 src/526.cpp create mode 100644 src/537.cpp create mode 100644 src/540.cpp create mode 100644 src/654.cpp create mode 100644 src/677.cpp create mode 100644 src/748.cpp create mode 100644 src/763.cpp create mode 100644 src/814.cpp create mode 100644 src/94.cpp diff --git a/src/406.cpp b/src/406.cpp new file mode 100644 index 0000000..a437dab --- /dev/null +++ b/src/406.cpp @@ -0,0 +1,30 @@ +vector> reconstructQueue(vector>& people) { + auto cmp = [](const pair& a, const pair& b) { + return a.first > b.first || (a.first == b.first && a.second < b.second); + }; + + sort(people.begin(), people.end(), cmp); + + list> list_people(people.begin(), people.end()); + + int len = list_people.size(); + auto iter = list_people.begin(); + int i = 0, j = 0; + while (i < len) + { + if (i == iter->second) + iter++; + else + { + pair p(*iter); + iter = list_people.erase(iter); + auto insertpos = list_people.begin(); + advance(insertpos, p.second); + list_people.insert(insertpos, p); + } + ++i; + } + + people.assign(list_people.begin(), list_people.end()); + return people; + } \ No newline at end of file diff --git a/src/413.cpp b/src/413.cpp new file mode 100644 index 0000000..ec368ef --- /dev/null +++ b/src/413.cpp @@ -0,0 +1,23 @@ +int numberOfArithmeticSlices(vector& A) { + int len = A.size(); + if (len < 3) + return 0; + + int i = 0; + int sum = 0; + while (i < len - 2) + { + int dif = A[i + 1] - A[i]; + int j = i + 1; + while (j+1 < len && A[j+1] - A[j] == dif) + ++j; + if (j - i >= 2) + { + int n = j - i + 1 - 3 + 1; + sum += (1+n)*n/2; + } + i = j; + } + + return sum; + } \ No newline at end of file diff --git a/src/442.cpp b/src/442.cpp new file mode 100644 index 0000000..63e1c24 --- /dev/null +++ b/src/442.cpp @@ -0,0 +1,38 @@ +vector findDuplicates(vector& nums) { + vector res; + + int len = nums.size(); + int i = 0; + while (i < len) + { + if (nums[i] == i+1) + ++i; + else + { + int val = nums[i]; + nums[i] = 0; + while (true) + { + if (nums[val - 1] == val) + { + res.push_back(val); + break; + } + else if (nums[val - 1] == 0) + { + nums[val - 1] = val; + break; + } + else + { + int tmp = nums[val - 1]; + nums[val - 1] = val; + val = tmp; + } + } + ++i; + } + } + + return res; + } \ No newline at end of file diff --git a/src/451.cpp b/src/451.cpp new file mode 100644 index 0000000..bc9d2c2 --- /dev/null +++ b/src/451.cpp @@ -0,0 +1,34 @@ +string frequencySort(string s) { + map mp; + for (auto c : s) + mp[c]++; + + struct Elem + { + char ch; + int num; + Elem(char c, int n) : ch(c), num(n){}; + }; + + vector elemvec; + for (auto m : mp) + elemvec.push_back(Elem(m.first, m.second)); + + auto cmp = [=](const Elem& a, const Elem& b) { + return a.num > b.num; + }; + sort(elemvec.begin(), elemvec.end(), cmp); + + int sz = elemvec.size(); + int pos = 0; + string str(s.size(), '\0'); + for (int i = 0; i < sz; ++i) + { + int n = elemvec[i].num; + for (int j = pos; j < pos + n; ++j) + str[j] = elemvec[i].ch; + pos += n; + } + + return str; + } \ No newline at end of file diff --git a/src/513.cpp b/src/513.cpp new file mode 100644 index 0000000..4cb7043 --- /dev/null +++ b/src/513.cpp @@ -0,0 +1,26 @@ +int findBottomLeftValue(TreeNode* root) { + int depth = 0; + return dofindBottomLeftValue(root, depth); + } + + int dofindBottomLeftValue(TreeNode* node, int& depth) + { + int ldepth = depth, rdepth = depth; + int lval = 0, rval = 0; + + if (node->left == NULL && node->right == NULL) + return node->val; + if (node->left != NULL) + { + ldepth = depth + 1; + lval = dofindBottomLeftValue(node->left, ldepth); + } + if (node->right != NULL) + { + rdepth = depth + 1; + rval = dofindBottomLeftValue(node->right, rdepth); + } + + depth = ldepth >= rdepth ? ldepth : rdepth; + return ldepth >= rdepth ? lval : rval; + } \ No newline at end of file diff --git a/src/515.cpp b/src/515.cpp new file mode 100644 index 0000000..2669e24 --- /dev/null +++ b/src/515.cpp @@ -0,0 +1,37 @@ +vector largestValues(TreeNode* root) { + vector res; + deque dq; + + if (root == nullptr) + return res; + + res.push_back(root->val); + if (root->left != nullptr) + dq.push_back(root->left); + if (root->right != nullptr) + dq.push_back(root->right); + int len = 0; + while ((len = dq.size()) != 0) + { + TreeNode* node = dq[0]; + int maxval = node->val; + if (node->left != nullptr) + dq.push_back(node->left); + if (node->right != nullptr) + dq.push_back(node->right); + for (int i = 1; i < len; ++i) + { + node = dq[i]; + if (node->val > maxval) + maxval = node->val; + if (node->left != nullptr) + dq.push_back(node->left); + if (node->right != nullptr) + dq.push_back(node->right); + } + dq.erase(dq.begin(), dq.begin() + len); + res.push_back(maxval); + } + + return res; + } \ No newline at end of file diff --git a/src/526.cpp b/src/526.cpp new file mode 100644 index 0000000..e1270c1 --- /dev/null +++ b/src/526.cpp @@ -0,0 +1,30 @@ +int countArrangement(int N) { + if (N <= 2) + return N; + vector arr(N, 0); + int count = 0; + int total = 0; + + docountArrange(arr, N, count, total); + + return total; + } + + void docountArrange(vector& arr, int n, int count, int& total) + { + for (int i = 0; i < n; ++i) + { + if (arr[i] == 0) + { + if ((count + 1) % (i + 1) == 0 || (i + 1) % (count + 1) == 0) + { + arr[i] = 1; + if (count+1 < n) + docountArrange(arr, n, count+1, total); + else + total++; + arr[i] = 0; + } + } + } + } \ No newline at end of file diff --git a/src/537.cpp b/src/537.cpp new file mode 100644 index 0000000..05101a5 --- /dev/null +++ b/src/537.cpp @@ -0,0 +1,17 @@ +string complexNumberMultiply(string a, string b) { + int len1 = a.size(), len2 = b.size(); + if (len1 == 0 || len2 == 0) + return ""; + + size_t pos = 0; + int real1 = stoi(a, &pos); + int img1 = stoi(a.substr(pos + 1)); + + int real2 = stoi(b, &pos); + int img2 = stoi(b.substr(pos + 1)); + int real = real1*real2 - img1*img2; + int img = real1*img2 + real2*img1; + + return to_string(real) + "+" + to_string(img) + "i"; + + } \ No newline at end of file diff --git a/src/540.cpp b/src/540.cpp new file mode 100644 index 0000000..978a6ab --- /dev/null +++ b/src/540.cpp @@ -0,0 +1,47 @@ +int singleNonDuplicate(vector& nums) { + int len = nums.size(); + if (len == 1) + return nums[0]; + int single = 0; + doFindSingle(nums, 0, len - 1, single); + return single; + } + + bool doFindSingle(vector& nums, int p, int q, int& single) + { + if (p == q) + { + single = nums[p]; + return true; + } + else if (p == q - 1) + return false; + else + { + int mid = (p + q) / 2; + bool flag = false; + if (nums[mid] != nums[mid - 1] && nums[mid] != nums[mid + 1]) + { + single = nums[mid]; + return true; + } + else if (nums[mid] == nums[mid - 1]) + { + if (mid - 2 >= p) + flag = doFindSingle(nums, p, mid - 2, single); + if (!flag) + return doFindSingle(nums, mid + 1, q, single); + else + return flag; + } + else if (nums[mid] == nums[mid + 1]) + { + if (mid + 2 <= q) + flag = doFindSingle(nums, mid + 2, q, single); + if (!flag) + return doFindSingle(nums, p, mid - 1, single); + else + return flag; + } + } + } \ No newline at end of file diff --git a/src/654.cpp b/src/654.cpp new file mode 100644 index 0000000..7b11b1c --- /dev/null +++ b/src/654.cpp @@ -0,0 +1,27 @@ +TreeNode* constructMaximumBinaryTree(vector& nums) { + int len = nums.size(); + if (len == 0) + return nullptr; + return constructSubMaxBTree(nums, 0, len - 1); + } + + TreeNode* constructSubMaxBTree(vector& nums, int p, int q) + { + if (p > q) + return nullptr; + if (p == q) + return new TreeNode(nums[p]); + int r = p; + int maxval = nums[p]; + for (int i = p + 1; i <= q; ++i) + if (nums[i] > maxval) + { + maxval = nums[i]; + r = i; + } + TreeNode* node = new TreeNode(maxval); + node->left = constructSubMaxBTree(nums, p, r - 1); + node->right = constructSubMaxBTree(nums, r + 1, q); + + return node; + } \ No newline at end of file diff --git a/src/677.cpp b/src/677.cpp new file mode 100644 index 0000000..9a25829 --- /dev/null +++ b/src/677.cpp @@ -0,0 +1,27 @@ +public: + /** Initialize your data structure here. */ + MapSum() { + + } + + void insert(string key, int val) { + if (mp.find(key) != mp.end()) + mp[key] = val; + else + mp.insert(pair(key, val)); + } + + int sum(string prefix) { + int len = prefix.size(); + if (len == 0) + return 0; + + int count = 0; + for (auto elem : mp) + if (elem.first.substr(0, len) == prefix) + count += elem.second; + + return count; + } +private: + map mp; \ No newline at end of file diff --git a/src/748.cpp b/src/748.cpp new file mode 100644 index 0000000..edbb7d4 --- /dev/null +++ b/src/748.cpp @@ -0,0 +1,42 @@ +string shortestCompletingWord(string licensePlate, vector& words) { + int len = licensePlate.size(); + int num = 0; + int dict[26] = {0}; + int dst[26] = {0}; + for (int i = 0; i != len; ++i) + if (isalpha(licensePlate[i])) + { + dict[tolower(licensePlate[i]) - 'a']++; + ++num; + } + + int minlen = 1000; + int sz = words.size(); + string res; + + for (int i = 0; i != sz; ++i) + { + len = words[i].size(); + if (len < num || len >= minlen) + continue; + int tmp = num; + memcpy(dst, dict, sizeof(dict)); + for (int j = 0; j != len; ++j) + if (dict[words[i][j] - 'a'] != 0) + { + --dict[words[i][j] - 'a']; + --num; + if (num == 0) + break; + } + if (num == 0 && len < minlen) + { + minlen = len; + res = words[i]; + } + num = tmp; + memcpy(dict, dst, sizeof(dst)); + } + + return res; + } \ No newline at end of file diff --git a/src/763.cpp b/src/763.cpp new file mode 100644 index 0000000..c53c041 --- /dev/null +++ b/src/763.cpp @@ -0,0 +1,50 @@ +vector partitionLabels(string S) { + vector firstindex(26, -1); + vector lastindex(26, -1); + vector res; + int len = S.size(); + if (len == 0) + return res; + + for (int i = 0; i < len; ++i) + { + if (firstindex[S[i]-'a'] == -1) + { + firstindex[S[i]-'a'] = i; + lastindex[S[i]-'a'] = i; + } + else + lastindex[S[i]-'a'] = i; + } + vector> letterrange; + for (int i = 0; i < 26; ++i) + { + if (firstindex[i] != -1) + letterrange.push_back(make_pair(firstindex[i], lastindex[i])); + } + + auto cmp = [](const pair& l, const pair& r) { + return l.first < r.first; + }; + sort(letterrange.begin(), letterrange.end(), cmp); + + int i = 1; + int lpos = letterrange[0].first, rpos = letterrange[0].second; + len = letterrange.size(); + while (i < len) + { + if (letterrange[i].first < rpos) + { + rpos = letterrange[i].second > rpos ? letterrange[i].second : rpos; + } + else + { + res.push_back(rpos-lpos+1); + lpos = letterrange[i].first; + rpos = letterrange[i].second; + } + ++i; + } + res.push_back(rpos-lpos+1); + return res; + } \ No newline at end of file diff --git a/src/814.cpp b/src/814.cpp new file mode 100644 index 0000000..07c8802 --- /dev/null +++ b/src/814.cpp @@ -0,0 +1,47 @@ +TreeNode* pruneTree(TreeNode* root) { + if (root == nullptr) + return root; + + bool flag1 = false, flag2 = false; + if (root->left != nullptr) + { + flag1 = dopruneTree(root->left); + if (flag1) + root->left = nullptr; + } + if (root->right != nullptr) + { + flag2 = dopruneTree(root->right); + if (flag2) + root->right = nullptr; + } + if (flag1 && flag2 && root->val == 0) + { + delete root; + } + return root; + } + + bool dopruneTree(TreeNode* node) + { + bool flag1 = false, flag2 = false; + if (node->left != nullptr) + flag1 = dopruneTree(node->left); + else + flag1 = true; + if (node->right != nullptr) + flag2 = dopruneTree(node->right); + else + flag2 = true; + if (flag1) + node->left = nullptr; + if (flag2) + node->right = nullptr; + if (flag1 && flag2 && node->val == 0) + { + delete node; + return true; + } + else + return false; + } \ No newline at end of file diff --git a/src/94.cpp b/src/94.cpp new file mode 100644 index 0000000..8f6df3c --- /dev/null +++ b/src/94.cpp @@ -0,0 +1,34 @@ +vector inorderTraversal(TreeNode* root) { + vector res; + if (root == nullptr) + return res; + + deque dq; + deque flag; + dq.push_back(root); + flag.push_back(false); + + while (!dq.empty()) + { + TreeNode* node = dq.back(); + if (flag.back() == false && node->left != nullptr) + { + dq.push_back(node->left); + flag.back() = true; + flag.push_back(false); + } + else + { + res.push_back(node->val); + dq.pop_back(); + flag.pop_back(); + if (node->right != nullptr) + { + dq.push_back(node->right); + flag.push_back(false); + } + } + } + + return res; + } \ No newline at end of file From bb2559240adaa9a433cc50620ac8d2c2218ca437 Mon Sep 17 00:00:00 2001 From: lintcoder Date: Mon, 23 Apr 2018 11:59:55 +0800 Subject: [PATCH 07/97] 10 problems solved. --- src/19.cpp | 25 ++++++++++++++++ src/24.cpp | 31 ++++++++++++++++++++ src/299.cpp | 35 ++++++++++++++++++++++ src/36.cpp | 68 +++++++++++++++++++++++++++++++++++++++++++ src/396.cpp | 18 ++++++++++++ src/445.cpp | 66 ++++++++++++++++++++++++++++++++++++++++++ src/498.cpp | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/539.cpp | 29 +++++++++++++++++++ src/592.cpp | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/623.cpp | 44 ++++++++++++++++++++++++++++ 10 files changed, 481 insertions(+) create mode 100644 src/19.cpp create mode 100644 src/24.cpp create mode 100644 src/299.cpp create mode 100644 src/36.cpp create mode 100644 src/396.cpp create mode 100644 src/445.cpp create mode 100644 src/498.cpp create mode 100644 src/539.cpp create mode 100644 src/592.cpp create mode 100644 src/623.cpp diff --git a/src/19.cpp b/src/19.cpp new file mode 100644 index 0000000..8e0d0e9 --- /dev/null +++ b/src/19.cpp @@ -0,0 +1,25 @@ +ListNode* removeNthFromEnd(ListNode* head, int n) { + if (n <= 0) + return head; + vector vec; + ListNode* p = head; + int len = 0; + while (p != NULL) + { + vec.push_back(p); + p = p->next; + len++; + } + if (n == len) + { + head = vec[0]->next; + delete vec[0]; + } + else + { + vec[len - n - 1]->next = vec[len - n]->next; + delete vec[len - n]; + } + + return head; + } \ No newline at end of file diff --git a/src/24.cpp b/src/24.cpp new file mode 100644 index 0000000..3a424d7 --- /dev/null +++ b/src/24.cpp @@ -0,0 +1,31 @@ +ListNode* swapPairs(ListNode* head) { + if (head == NULL || head->next == NULL) + return head; + ListNode* p = head; + ListNode* q = head->next; + ListNode* h = q; + + p->next = q->next; + q->next = p; + ListNode* k = p->next; + int n = 1; + while (k != NULL) + { + if (n == 1) + { + q = p; + p = k; + k = k->next; + } + else + { + p->next = k->next; + q->next = k; + k->next = p; + k = p->next; + } + n = 1 - n; + } + + return h; + } \ No newline at end of file diff --git a/src/299.cpp b/src/299.cpp new file mode 100644 index 0000000..0c8aefe --- /dev/null +++ b/src/299.cpp @@ -0,0 +1,35 @@ +string getHint(string secret, string guess) { + int digitnum1[10] = {0}; + int digitnum2[10] = {0}; + + int sz = secret.size(); + int ctA = 0, ctB = 0; + for (int i = 0; i != sz; ++i) + { + digitnum1[secret[i] - '0']++; + digitnum2[guess[i] - '0']++; + if (secret[i] == guess[i]) + ctA++; + } + for (int i = 0; i != 10; ++i) + { + ctB += digitnum1[i] < digitnum2[i] ? digitnum1[i] : digitnum2[i]; + } + + return num2str(ctA) + "A" + num2str(ctB - ctA) + "B"; + } + + string num2str(int n) + { + if (n == 0) + return "0"; + + string str; + while (n != 0) + { + str.push_back(char(n % 10 + '0')); + n /= 10; + } + reverse(str.begin(), str.end()); + return str; + } \ No newline at end of file diff --git a/src/36.cpp b/src/36.cpp new file mode 100644 index 0000000..1a04f8b --- /dev/null +++ b/src/36.cpp @@ -0,0 +1,68 @@ +bool isValidSudoku(vector>& board) { + for (int i = 0; i < 9; ++i) + { + int arr1[9] = {0}; + for (int j = 0; j < 9; ++j) + { + if (board[i][j] == '.') + continue; + else if ((board[i][j] >= '1' && board[i][j] <= '9')) + { + int pos1 = board[i][j] - '1'; + if (arr1[pos1] == 1) + return false; + else + arr1[pos1] = 1; + } + else + return false; + } + } + + for (int i = 0; i < 9; ++i) + { + int arr2[9] = {0}; + for (int j = 0; j < 9; ++j) + { + if (board[j][i] == '.') + continue; + else if ((board[j][i] >= '1' && board[j][i] <= '9')) + { + int pos2 = board[j][i] - '1'; + if (arr2[pos2] == 1) + return false; + else + arr2[pos2] = 1; + } + else + return false; + } + } + + for (int i = 0; i < 9; i = i + 3) + { + for (int j = 0; j < 9; j = j + 3) + { + int arr[9] = {0}; + for (int m = i; m < i + 3; ++m) + { + for (int n = j; n < j + 3; ++n) + { + if (board[m][n] == '.') + continue; + else if (board[m][n] >= '1' && board[i][j] <= '9') + { + int pos = board[m][n] - '1'; + if (arr[pos] == 1) + return false; + else + arr[pos] = 1; + } + else + return false; + } + } + } + } + return true; + } \ No newline at end of file diff --git a/src/396.cpp b/src/396.cpp new file mode 100644 index 0000000..2717e41 --- /dev/null +++ b/src/396.cpp @@ -0,0 +1,18 @@ +int maxRotateFunction(vector& A) { + int sz = A.size(); + int sum = 0, subsum = 0; + int total = 0; + for (int i = 0; i < sz; ++i) + total += A[i]; + for (int i = 0; i < sz; ++i) + subsum += i * A[i]; + sum = subsum; + for (int i = 1; i < sz; ++i) + { + subsum = subsum + total - sz * A[sz - i]; + if (subsum > sum) + sum = subsum; + } + + return sum; + } \ No newline at end of file diff --git a/src/445.cpp b/src/445.cpp new file mode 100644 index 0000000..e8977dc --- /dev/null +++ b/src/445.cpp @@ -0,0 +1,66 @@ +ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { + string a = calculateNum(l1); + string b = calculateNum(l2); + + string c = stradd(a, b); + + ListNode* node = new ListNode(c[0]-'0'); + ListNode* root = node; + int sz = c.size(), i = 1; + while (i < sz) + { + node = new ListNode(c[i]-'0'); + node->next = root; + root = node; + ++i; + } + + return root; + } + + string calculateNum(ListNode* node) + { + string res; + while (node != nullptr) + { + res.push_back(char(node->val + '0')); + node = node->next; + } + + return res; + } + + string stradd(const string& a, const string& b) + { + string res; + int len1 = a.size(), len2 = b.size(); + int i = len1 - 1, j = len2 - 1; + int c = 0; + + while (i >= 0 && j >= 0) + { + int tmp = a[i] - '0' + b[j] - '0' + c; + res.push_back(char(tmp%10 + '0')); + c = tmp/10; + --i; + --j; + } + while (i >= 0) + { + int tmp = a[i] - '0' + c; + res.push_back(char(tmp%10 + '0')); + c = tmp/10; + --i; + } + while (j >= 0) + { + int tmp = b[j] - '0' + c; + res.push_back(char(tmp%10 + '0')); + c = tmp/10; + --j; + } + if (c > 0) + res.push_back(char(c + '0')); + + return res; + } \ No newline at end of file diff --git a/src/498.cpp b/src/498.cpp new file mode 100644 index 0000000..55a83a9 --- /dev/null +++ b/src/498.cpp @@ -0,0 +1,83 @@ +vector findDiagonalOrder(vector>& matrix) + { + vector res; + int row = matrix.size(); + if (row == 0) + return res; + if (row == 1) + return matrix[0]; + int col = matrix[0].size(); + if (col == 1) + { + for (int i = 0; i < row; ++i) + res.push_back(matrix[i][0]); + return res; + } + + int i = 0, j = 0; + bool down = false; + while (i < row && j < col) + { + res.push_back(matrix[i][j]); + if (i == row - 1 && j == col - 1) + break; + if (i == 0) + { + if (!down) + { + if (j < col - 1) + ++j; + else + ++i; + down = !down; + } + else + { + ++i; + --j; + } + } + else + { + if (down) + { + if (j == 0) + { + if (i < row - 1) + ++i; + else + ++j; + down = !down; + } + else + { + if (i < row - 1) + { + ++i; + --j; + } + else + { + ++j; + down = !down; + } + } + } + else + { + if (j < col - 1) + { + --i; + ++j; + } + else + { + ++i; + down = !down; + } + } + } + } + + return res; + } \ No newline at end of file diff --git a/src/539.cpp b/src/539.cpp new file mode 100644 index 0000000..10b82b6 --- /dev/null +++ b/src/539.cpp @@ -0,0 +1,29 @@ +int findMinDifference(vector& timePoints) { + int len = timePoints.size(); + if (len <= 1) + return 0; + sort(timePoints.begin(), timePoints.end()); + int mindiff = calcudiff(timePoints[0], timePoints[1]); + int diff; + for (int i = 2; i < len; ++i) + { + diff = calcudiff(timePoints[i - 1], timePoints[i]); + if (diff < mindiff) + mindiff = diff; + } + diff = calcudiff(timePoints[len - 1], timePoints[0]) + 1440; + if (diff < mindiff) + mindiff = diff; + + return mindiff; + } + + int calcudiff(const string& t1, const string& t2) + { + int h1 = stoi(t1.substr(0, 2)); + int h2 = stoi(t2.substr(0, 2)); + int min1 = stoi(t1.substr(3)); + int min2 = stoi(t2.substr(3)); + + return h2*60 + min2 - h1*60 - min1; + } \ No newline at end of file diff --git a/src/592.cpp b/src/592.cpp new file mode 100644 index 0000000..e405b20 --- /dev/null +++ b/src/592.cpp @@ -0,0 +1,82 @@ +string fractionAddition(string expression) { + vector numerator, denominator; + int len = expression.size(); + int i, pos; + + if (expression[0] == '-') + { + pos = expression.find_first_of("/", 1); + numerator.push_back(-1*stoi(expression.substr(1, pos - 1))); + i = pos + 1; + } + else + { + pos = expression.find_first_of("/", 0); + numerator.push_back(stoi(expression.substr(0, pos))); + i = pos + 1; + } + while (true) + { + pos = expression.find_first_of("+-", i); + if (pos != string::npos) + { + denominator.push_back(stoi(expression.substr(i, pos - i))); + i = pos; + } + else + { + denominator.push_back(stoi(expression.substr(i))); + break; + } + if (expression[i] == '-') + { + pos = expression.find_first_of("/", i); + numerator.push_back(-1*stoi(expression.substr(i+1, pos - (i+1)))); + i = pos + 1; + } + else + { + pos = expression.find_first_of("/", i); + numerator.push_back(stoi(expression.substr(i, pos - i))); + i = pos + 1; + } + } + + int sz = denominator.size(); + int res_n = 0, res_d = 0; + if (sz == 1) + { + int r = gcd(abs(numerator[0]), denominator[0]); + res_n = numerator[0]/r; + res_d = denominator[0]/r; + } + else + { + int r = denominator[0]; + for (int i = 1; i < sz; ++i) + r = r / gcd(r, denominator[i]) * denominator[i]; + + res_d = r; + for (int i = 0; i < sz; ++i) + res_n += r/denominator[i]*numerator[i]; + + + r = gcd(abs(res_n), res_d); + res_n = res_n/r; + res_d = res_d/r; + + } + return to_string(res_n) + "/" + to_string(res_d); + } + + int gcd(int a, int b) + { + while (b != 0) + { + int r = b; + b = a % b; + a = r; + } + + return a; + } \ No newline at end of file diff --git a/src/623.cpp b/src/623.cpp new file mode 100644 index 0000000..8b5a0d3 --- /dev/null +++ b/src/623.cpp @@ -0,0 +1,44 @@ +TreeNode* addOneRow(TreeNode* root, int v, int d) { + if (d == 1 || root == nullptr) + { + TreeNode* node = new TreeNode(v); + node->left = root; + return node; + } + else + { + deque dq; + dq.push_back(root); + int i = 1, j = 0; + int len = 0; + while (i < d - 1) + { + len = dq.size(); + j = 0; + while (j < len) + { + TreeNode* node = dq[j++]; + if (node->left != nullptr) + dq.push_back(node->left); + if (node->right != nullptr) + dq.push_back(node->right); + } + dq.erase(dq.begin(), dq.begin() + len); + ++i; + } + len = dq.size(); + j = 0; + while (j < len) + { + TreeNode* node = dq[j]; + TreeNode* lnode = new TreeNode(v); + lnode->left = dq[j]->left; + dq[j]->left = lnode; + TreeNode* rnode = new TreeNode(v); + rnode->right = dq[j]->right; + dq[j]->right = rnode; + ++j; + } + return root; + } + } \ No newline at end of file From b1d37058a7453cb64ebf522a04ce8bb54bb6fa8e Mon Sep 17 00:00:00 2001 From: lintcoder Date: Wed, 25 Apr 2018 17:33:48 +0800 Subject: [PATCH 08/97] 8 problems solved. --- src/102.cpp | 29 +++++++++++++++++++ src/112.cpp | 20 ++++++++++++++ src/141.cpp | 18 ++++++++++++ src/328.cpp | 24 ++++++++++++++++ src/392.cpp | 24 ++++++++++++++++ src/423.cpp | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/441.cpp | 16 +++++++++++ src/9.cpp | 24 ++++++++++++++++ 8 files changed, 235 insertions(+) create mode 100644 src/102.cpp create mode 100644 src/112.cpp create mode 100644 src/141.cpp create mode 100644 src/328.cpp create mode 100644 src/392.cpp create mode 100644 src/423.cpp create mode 100644 src/441.cpp create mode 100644 src/9.cpp diff --git a/src/102.cpp b/src/102.cpp new file mode 100644 index 0000000..c7f5fcd --- /dev/null +++ b/src/102.cpp @@ -0,0 +1,29 @@ +vector> levelOrder(TreeNode* root) { + vector> res; + deque dq[2]; + + TreeNode* node = root; + int i = 0; + if (node != NULL) + { + dq[0].push_back(node); + } + while (!dq[i].empty()) + { + vector vec; + while (!dq[i].empty()) + { + TreeNode* t = dq[i].front(); + vec.push_back(t->val); + if (t->left != NULL) + dq[1 - i].push_back(t->left); + if (t->right != NULL) + dq[1 - i].push_back(t->right); + dq[i].pop_front(); + } + res.push_back(vec); + i = 1 - i; + } + + return res; + } \ No newline at end of file diff --git a/src/112.cpp b/src/112.cpp new file mode 100644 index 0000000..09bc859 --- /dev/null +++ b/src/112.cpp @@ -0,0 +1,20 @@ +bool hasPathSum(TreeNode* root, int sum) { + if (root == NULL) + return false; + return dohasPathSum(root, 0, sum); + } + + bool dohasPathSum(TreeNode* node, int subsum, int sum) + { + int val = node->val; + TreeNode* lnode = node->left; + TreeNode* rnode = node->right; + bool flag = false; + if (lnode == NULL && rnode == NULL) + return subsum + val == sum; + else if (lnode != NULL) + flag = dohasPathSum(lnode, subsum + val, sum); + if (!flag && rnode != NULL) + flag = dohasPathSum(rnode, subsum + val, sum); + return flag; + } \ No newline at end of file diff --git a/src/141.cpp b/src/141.cpp new file mode 100644 index 0000000..5d6afc5 --- /dev/null +++ b/src/141.cpp @@ -0,0 +1,18 @@ +bool hasCycle(ListNode *head) { + ListNode* p = head; + ListNode* q = head; + while (p != NULL) + { + p = p->next; + if (p == NULL) + return false; + if (p == q || p->next == q) + return true; + p = p->next; + q = q->next; + if (p == q) + return true; + } + + return false; + } \ No newline at end of file diff --git a/src/328.cpp b/src/328.cpp new file mode 100644 index 0000000..63bbdd8 --- /dev/null +++ b/src/328.cpp @@ -0,0 +1,24 @@ +ListNode* oddEvenList(ListNode* head) { + if (head == nullptr || head->next == nullptr) + return head; + + ListNode* hodd = head; + ListNode* heven = head->next; + ListNode* p = hodd, *q = heven; + + while (q != nullptr && q->next != nullptr) + { + p->next = q->next; + if (q->next == nullptr) + break; + else + { + p = q->next; + q->next = p->next; + q = p->next; + } + } + + p->next = heven; + return hodd; + } \ No newline at end of file diff --git a/src/392.cpp b/src/392.cpp new file mode 100644 index 0000000..0109337 --- /dev/null +++ b/src/392.cpp @@ -0,0 +1,24 @@ +bool isSubsequence(string s, string t) { + int len1 = s.size(); + int len2 = t.size(); + if (len1 > len2) + return false; + else if (len1 == len2) + return s == t; + else + { + int index = 0; + int pos = 0; + for (int i = 0; i < len1; ++i) + { + if (index == len2) + return false; + pos = t.find(s[i], index); + if (pos == string::npos) + return false; + index = pos + 1; + } + + return true; + } + } \ No newline at end of file diff --git a/src/423.cpp b/src/423.cpp new file mode 100644 index 0000000..e6bd3ec --- /dev/null +++ b/src/423.cpp @@ -0,0 +1,80 @@ +string originalDigits(string s) { + int letters[26] = {0}; + int len = s.size(); + for (int i = 0; i < len; ++i) + letters[s[i] - 'a']++; + string res; + + if (letters['z' - 'a'] != 0) + { + letters['e' - 'a'] -= letters['z' - 'a']; + letters['r' - 'a'] -= letters['z' - 'a']; + letters['o' - 'a'] -= letters['z' - 'a']; + len -= 4*letters['z' - 'a']; + res = string(letters['z' - 'a'], '0'); + letters['z' - 'a'] = 0; + } + if (letters['w' - 'a'] != 0) + { + letters['t' - 'a'] -= letters['w' - 'a']; + letters['o' - 'a'] -= letters['w' - 'a']; + len -= 3*letters['w' - 'a']; + res += string(letters['w' - 'a'], '2'); + letters['w' - 'a'] = 0; + } + if (letters['u' - 'a'] != 0) + { + letters['f' - 'a'] -= letters['u' - 'a']; + letters['o' - 'a'] -= letters['u' - 'a']; + letters['r' - 'a'] -= letters['u' - 'a']; + len -= 4*letters['u' - 'a']; + res += string(letters['u' - 'a'], '4'); + letters['u' - 'a'] = 0; + } + if (letters['x' - 'a'] != 0) + { + letters['s' - 'a'] -= letters['x' - 'a']; + letters['i' - 'a'] -= letters['x' - 'a']; + len -= 3*letters['x' - 'a']; + res += string(letters['x' - 'a'], '6'); + letters['x' - 'a'] = 0; + } + if (letters['g' - 'a'] != 0) + { + letters['e' - 'a'] -= letters['g' - 'a']; + letters['i' - 'a'] -= letters['g' - 'a']; + letters['h' - 'a'] -= letters['g' - 'a']; + letters['t' - 'a'] -= letters['g' - 'a']; + len -= 5*letters['g' - 'a']; + res += string(letters['g' - 'a'], '8'); + letters['g' - 'a'] = 0; + } + if (letters['o' - 'a'] != 0) + { + res += string(letters['o' - 'a'], '1'); + } + if (letters['t' - 'a'] != 0) + { + res += string(letters['t' - 'a'], '3'); + } + if (letters['f' - 'a'] != 0) + { + letters['i' - 'a'] -= letters['f' - 'a']; + letters['v' - 'a'] -= letters['f' - 'a']; + letters['e' - 'a'] -= letters['f' - 'a']; + len -= 4*letters['f' - 'a']; + res += string(letters['f' - 'a'], '5'); + letters['f' - 'a'] = 0; + } + if (letters['s' - 'a'] != 0) + { + res += string(letters['s' - 'a'], '7'); + } + if (letters['i' - 'a'] != 0) + { + res += string(letters['i' - 'a'], '9'); + } + sort(res.begin(), res.end()); + + return res; + } \ No newline at end of file diff --git a/src/441.cpp b/src/441.cpp new file mode 100644 index 0000000..e5dcd3b --- /dev/null +++ b/src/441.cpp @@ -0,0 +1,16 @@ +int arrangeCoins(int n) { + if (n <= 0) + return 0; + int lim = sqrt(2) * sqrt(n) - 1; + int num = 0; + if (lim % 2 == 1) + num = (1 + lim) / 2 * lim; + else + num = lim / 2 * (1 + lim); + while (n - num >= lim + 1) + { + ++lim; + n -= num; + } + return lim; + } \ No newline at end of file diff --git a/src/9.cpp b/src/9.cpp new file mode 100644 index 0000000..962a749 --- /dev/null +++ b/src/9.cpp @@ -0,0 +1,24 @@ +bool isPalindrome(int x) { + if (x < 0) + return false; + if (x == 0) + return true; + int sum = 0; + while (true) + { + sum = sum * 10 + x % 10; + x /= 10; + if (sum == 0) + return false; + if (sum == x) + return true; + else if (sum > x) + break; + else + { + if (x < 10) + return false; + } + } + return sum == x * 10 + sum % 10; + } \ No newline at end of file From 8ddbe4678d28f8f8c76e0bc955160ad5ef72dcd2 Mon Sep 17 00:00:00 2001 From: lintcoder Date: Sat, 28 Apr 2018 16:51:10 +0800 Subject: [PATCH 09/97] 5 problems solved. --- src/151.cpp | 31 ++++++++++++++++++ src/165.cpp | 90 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/2.cpp | 46 +++++++++++++++++++++++++++ src/43.cpp | 59 +++++++++++++++++++++++++++++++++++ src/791.cpp | 16 ++++++++++ 5 files changed, 242 insertions(+) create mode 100644 src/151.cpp create mode 100644 src/165.cpp create mode 100644 src/2.cpp create mode 100644 src/43.cpp create mode 100644 src/791.cpp diff --git a/src/151.cpp b/src/151.cpp new file mode 100644 index 0000000..4863b13 --- /dev/null +++ b/src/151.cpp @@ -0,0 +1,31 @@ +void reverseWords(string &s) { + int len = s.size(); + vector word; + + int index = s.find_first_not_of(' '); + if (index == string::npos) + { + s = ""; + return; + } + + while (index != string::npos && index < len) + { + int pos = s.find_first_of(' ', index); + if (pos == string::npos) + { + word.push_back(s.substr(index)); + break; + } + else + { + word.push_back(s.substr(index, pos-index)); + index = s.find_first_not_of(' ', pos); + } + } + len = word.size(); + s = ""; + for (int i = len-1; i > 0; --i) + s += word[i] + " "; + s += word[0]; + } \ No newline at end of file diff --git a/src/165.cpp b/src/165.cpp new file mode 100644 index 0000000..f24863f --- /dev/null +++ b/src/165.cpp @@ -0,0 +1,90 @@ +int compareVersion(string version1, string version2) { + int len1 = version1.size(); + int len2 = version2.size(); + int i = 0, j = 0; + while (i < len1 && j < len2) + { + int pos1 = version1.find('.', i); + int pos2 = version2.find('.', j); + if (pos1 == string::npos) + { + if (pos2 == string::npos) + return docmp(version1.substr(i), version2.substr(j)); + else + { + string mainversion2 = version2.substr(j, pos2 - j); + int res = docmp(version1.substr(i), mainversion2); + if (res != 0) + return res; + else + return -1 * is_subversion_zero(version2.substr(pos2 + 1)); + } + } + else + { + string subversion1 = version1.substr(i, pos1 - i); + if (pos2 == string::npos) + { + int res = docmp(subversion1, version2.substr(j)); + if (res != 0) + return res; + else + return is_subversion_zero(version1.substr(pos1 + 1)); + } + else + { + string subversion2 = version2.substr(j, pos2 - j); + int res = docmp(subversion1, subversion2); + if (res != 0) + return res; + else + { + i = pos1 + 1; + j = pos2 + 1; + } + } + } + } + return 0; + } + + int docmp(const string& version1, const string& version2) + { + int first_num1 = version1.find_first_not_of('0'); + int first_num2 = version2.find_first_not_of('0'); + string v1, v2; + if (first_num1 == string::npos) + v1 = "0"; + else + v1 = version1.substr(first_num1); + if (first_num2 == string::npos) + v2 = "0"; + else + v2 = version2.substr(first_num2); + int len1 = v1.size(); + int len2 = v2.size(); + if (len1 < len2) + return -1; + else if (len1 == len2) + { + if (v1 < v2) + return -1; + else if (v1 == v2) + return 0; + else + return 1; + } + else + return 1; + } + + int is_subversion_zero(const string& str) + { + int len = str.size(); + for (int i = 0; i < len; ++i) + { + if (str[i] != '0' && str[i] != '.') + return 1; + } + return 0; + } \ No newline at end of file diff --git a/src/2.cpp b/src/2.cpp new file mode 100644 index 0000000..9cb1d40 --- /dev/null +++ b/src/2.cpp @@ -0,0 +1,46 @@ +ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { + if (l1 == nullptr) + return l2; + if (l2 == nullptr) + return l1; + + int sum = l1->val + l2->val; + int ct = sum/10; + ListNode* h = new ListNode(sum%10); + ListNode* node = h; + l1 = l1->next; + l2 = l2->next; + while (l1 && l2) + { + sum = l1->val + l2->val + ct; + node->next = new ListNode(sum%10); + ct = sum/10; + node = node->next; + l1 = l1->next; + l2 = l2->next; + } + while (l1) + { + sum = l1->val + ct; + node->next = new ListNode(sum%10); + ct = sum/10; + node = node->next; + l1 = l1->next; + } + while (l2) + { + sum = l2->val + ct; + node->next = new ListNode(sum%10); + ct = sum/10; + node = node->next; + l2 = l2->next; + } + if (ct != 0) + { + node->next = new ListNode(ct); + node = node->next; + } + node->next = nullptr; + + return h; + } \ No newline at end of file diff --git a/src/43.cpp b/src/43.cpp new file mode 100644 index 0000000..adbe6a2 --- /dev/null +++ b/src/43.cpp @@ -0,0 +1,59 @@ +string multiply(string num1, string num2) { + int len1 = num1.size(); + int len2 = num2.size(); + if (len1 == 0 || len2 == 0) + return ""; + if (num1 == "0" || num2 == "0") + return "0"; + + vector subsum; + vector digitlen; + int sum, ct; + for (int i = len2-1; i >= 0; --i) + { + if (num2[i] == '0') + continue; + sum = 0; + ct = 0; + string s(len2-1-i, '0'); + for (int j = len1-1; j >= 0; --j) + { + sum = (num2[i]-'0') * (num1[j]-'0') + ct; + s.push_back(sum%10+'0'); + ct = sum/10; + } + if (ct > 0) + s.push_back(ct+'0'); + subsum.push_back(s); + digitlen.push_back(s.size()); + } + + string res; + int len = subsum.size(); + int i = 0; + ct = 0; + while (true) + { + sum = 0; + bool flag = false; + for (int j = 0; j < len; ++j) + { + if (i < digitlen[j]) + { + sum += subsum[j][i] - '0'; + flag = true; + } + } + if (!flag) + break; + sum += ct; + res.push_back(sum%10+'0'); + ct = sum/10; + ++i; + } + if (ct > 0) + res.push_back(ct+'0'); + + reverse(res.begin(), res.end()); + return res; + } \ No newline at end of file diff --git a/src/791.cpp b/src/791.cpp new file mode 100644 index 0000000..6433c8d --- /dev/null +++ b/src/791.cpp @@ -0,0 +1,16 @@ +string customSortString(string S, string T) { + int len = S.size(); + if (len <= 1) + return T; + + vector prio(26, -1); + for (int i = 0; i < len; ++i) + prio[S[i]-'a'] = i; + + auto cmp = [=](char a, char b) { + return prio[a-'a'] < prio[b-'a']; + }; + + sort(T.begin(), T.end(), cmp); + return T; + } \ No newline at end of file From 2e109d82ad2752b263ac086f5d947adf91e2cf74 Mon Sep 17 00:00:00 2001 From: lintcoder Date: Sun, 6 May 2018 20:56:51 +0800 Subject: [PATCH 10/97] 10 problems solved. --- src/143.cpp | 45 ++++++++++++++++++++++++++++++++++++++++ src/144.cpp | 20 ++++++++++++++++++ src/477.cpp | 23 +++++++++++++++++++++ src/503.cpp | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/547.cpp | 38 ++++++++++++++++++++++++++++++++++ src/648.cpp | 46 +++++++++++++++++++++++++++++++++++++++++ src/676.cpp | 48 +++++++++++++++++++++++++++++++++++++++++++ src/725.cpp | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/86.cpp | 54 ++++++++++++++++++++++++++++++++++++++++++++++++ src/92.cpp | 45 ++++++++++++++++++++++++++++++++++++++++ 10 files changed, 435 insertions(+) create mode 100644 src/143.cpp create mode 100644 src/144.cpp create mode 100644 src/477.cpp create mode 100644 src/503.cpp create mode 100644 src/547.cpp create mode 100644 src/648.cpp create mode 100644 src/676.cpp create mode 100644 src/725.cpp create mode 100644 src/86.cpp create mode 100644 src/92.cpp diff --git a/src/143.cpp b/src/143.cpp new file mode 100644 index 0000000..0ed1bed --- /dev/null +++ b/src/143.cpp @@ -0,0 +1,45 @@ +void reorderList(ListNode* head) { + if (head == nullptr || head->next == nullptr || head->next->next == nullptr) + return; + + ListNode* h = head; + int i = 0; + while (h != nullptr) + { + h = h->next; + ++i; + } + int n = i%2 == 0 ? i/2 : i/2+1; + h = head; + ListNode* fronthalf = h; + ListNode* node = h; + while (n-- > 1) + node = node->next; + ListNode* s = node->next; + node->next = nullptr; + + node = s; + ListNode* backhalf = node; + node = node->next; + backhalf->next = nullptr; + s = nullptr; + while (node != nullptr) + { + s = node->next; + node->next = backhalf; + backhalf = node; + node = s; + } + head = fronthalf; + node = fronthalf; + s = backhalf; + while (node != nullptr && s != nullptr) + { + ListNode* tmp = node->next; + node->next = s; + node = tmp; + ListNode* tmp2 = s->next; + s->next = tmp; + s = tmp2; + } + } \ No newline at end of file diff --git a/src/144.cpp b/src/144.cpp new file mode 100644 index 0000000..d0b67af --- /dev/null +++ b/src/144.cpp @@ -0,0 +1,20 @@ +vector preorderTraversal(TreeNode* root) { + vector res; + if (root == nullptr) + return res; + deque dq; + dq.push_back(root); + + while (!dq.empty()) + { + TreeNode* node = dq.back(); + dq.pop_back(); + res.push_back(node->val); + if (node->right != nullptr) + dq.push_back(node->right); + if (node->left != nullptr) + dq.push_back(node->left); + } + + return res; + } \ No newline at end of file diff --git a/src/477.cpp b/src/477.cpp new file mode 100644 index 0000000..8650113 --- /dev/null +++ b/src/477.cpp @@ -0,0 +1,23 @@ +int totalHammingDistance(vector& nums) { + int len = nums.size(); + if (len < 2) + return 0; + + vector> bs(len, bitset<32>(0)); + for (int i = 0; i < len; ++i) + bs[i] = nums[i]; + + int ct = 0; + int flag[32][2] = {0}; + for (int i = 0; i < len; ++i) + { + for (int j = 0; j < 32; ++j) + { + flag[j][bs[i][j]]++; + } + } + + for (int i = 0; i < 32; ++i) + ct += flag[i][0] * flag[i][1]; + return ct; + } \ No newline at end of file diff --git a/src/503.cpp b/src/503.cpp new file mode 100644 index 0000000..ebd3b96 --- /dev/null +++ b/src/503.cpp @@ -0,0 +1,57 @@ +vector nextGreaterElements(vector& nums) { + vector res; + int sz = nums.size(); + + for (int i = 0; i < sz; ++i) + { + if (!findNextGreater(nums, res, nums[i], (i+1)%sz, (i+sz-1)%sz, sz)) + res.push_back(-1); + } + + return res; + } + + bool findNextGreater(const vector& nums, vector& res, int val, int p, int q, int sz) + { + if (p == q) + { + if (nums[p] > val) + { + res.push_back(nums[p]); + return true; + } + else + return false; + } + else if (p == q - 1) + { + if (nums[p] > val) + { + res.push_back(nums[p]); + return true; + } + if (nums[q] > val) + { + res.push_back(nums[q]); + return true; + } + return false; + } + else if (p < q) + { + int mid = (p + q)/2; + if (findNextGreater(nums, res, val, p, mid-1, sz)) + return true; + if (nums[mid] > val) + { + res.push_back(nums[mid]); + return true; + } + return findNextGreater(nums, res, val, mid+1, q, sz); + } + else + { + return findNextGreater(nums, res, val, p, sz - 1, sz) || findNextGreater(nums, res, val, 0, q, sz); + } + + } \ No newline at end of file diff --git a/src/547.cpp b/src/547.cpp new file mode 100644 index 0000000..fd49f2f --- /dev/null +++ b/src/547.cpp @@ -0,0 +1,38 @@ +int findCircleNum(vector>& M) { + int num = M.size(); + int count = 0; + for (int i = 0; i < num; ++i) + { + if (M[i][i] == 1) + { + M[i][i] = -1; + for (int j = 0; j < num; ++j) + { + if (j != i && M[i][j] == 1) + { + M[i][j] = M[j][i] = -1; + doSubFind(M, j, num); + } + } + count++; + } + } + + return count; + } + + void doSubFind(vector>& M, int row, const int num) + { + if (M[row][row] == 1) + { + M[row][row] = -1; + for (int i = 0; i < num; ++i) + { + if (i != row && M[row][i] == 1) + { + M[row][i] = M[i][row] = -1; + doSubFind(M, i, num); + } + } + } + } \ No newline at end of file diff --git a/src/648.cpp b/src/648.cpp new file mode 100644 index 0000000..4744f44 --- /dev/null +++ b/src/648.cpp @@ -0,0 +1,46 @@ +string replaceWords(vector& dict, string sentence) { + auto cmp = [](string& a, string& b) { + return a.size() < b.size(); + }; + sort(dict.begin(), dict.end(), cmp); + + string res; + int index = 0; + int len = sentence.size(); + int num = dict.size(); + while (index < len) + { + string replacestr; + int pos = sentence.find(' ', index); + if (pos == string::npos) + { + replacestr = sentence.substr(index); + findRoot(dict, num, replacestr); + res += " " + replacestr; + break; + } + else + { + replacestr = sentence.substr(index, pos - index); + findRoot(dict, num, replacestr); + res += " " + replacestr; + index = pos + 1; + } + } + + return res.substr(1); + } + + void findRoot(const vector& dict, int num, string& replacestr) + { + int len = replacestr.size(); + for (int i = 0; i < num; ++i) + { + int sz = dict[i].size(); + if (sz < len && dict[i] == replacestr.substr(0, sz)) + { + replacestr = dict[i]; + break; + } + } + } \ No newline at end of file diff --git a/src/676.cpp b/src/676.cpp new file mode 100644 index 0000000..7cdf5df --- /dev/null +++ b/src/676.cpp @@ -0,0 +1,48 @@ +public: + /** Initialize your data structure here. */ + MagicDictionary() { + if (!mdict.empty()) + mdict.clear(); + } + + /** Build a dictionary through a list of words */ + void buildDict(vector dict) { + int len = dict.size(); + for (int i = 0; i < len; ++i) + { + int sz = dict[i].size(); + if (mdict.find(sz) == mdict.end()) + mdict.insert(pair>(sz, list(1, dict[i]))); + else + mdict[sz].push_back(dict[i]); + } + } + + /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */ + bool search(string word) { + int len = word.size(); + if (mdict.find(len) == mdict.end()) + return false; + else + { + for (auto iter = mdict[len].begin(); iter != mdict[len].end(); ++iter) + if (check(word, *iter, len)) + return true; + return false; + } + } + +private: + map> mdict; + bool check(const string& a, const string& b, int len) + { + int ct = 0; + for (int i = 0; i < len; ++i) + if (a[i] != b[i]) + { + ++ct; + if (ct == 2) + return false; + } + return ct == 1; + } \ No newline at end of file diff --git a/src/725.cpp b/src/725.cpp new file mode 100644 index 0000000..fc41762 --- /dev/null +++ b/src/725.cpp @@ -0,0 +1,59 @@ +vector splitListToParts(ListNode* root, int k) { + vector res; + if (root == nullptr) + { + res.insert(res.end(), k, nullptr); + return res; + } + + int len = 0; + ListNode* h = root; + while (h != nullptr) + { + ++len; + h = h->next; + } + int each = len/k; + int remain = len%k; + int i = 0; + + h = root; + while (i < k) + { + if (i < remain) + { + ListNode* node = h; + ListNode* pre = h; + for (int j = 0; j < each+1; ++j) + { + pre = node; + node = node->next; + } + pre->next = nullptr; + res.push_back(h); + h = node; + } + else + { + if (h == nullptr) + { + res.push_back(nullptr); + } + else + { + ListNode* node = h; + ListNode* pre = h; + for (int j = 0; j < each; ++j) + { + pre = node; + node = node->next; + } + pre->next = nullptr; + res.push_back(h); + h = node; + } + } + ++i; + } + return res; + } \ No newline at end of file diff --git a/src/86.cpp b/src/86.cpp new file mode 100644 index 0000000..e6bed03 --- /dev/null +++ b/src/86.cpp @@ -0,0 +1,54 @@ +ListNode* partition(ListNode* head, int x) { + if (head == nullptr || head->next == nullptr) + return head; + + ListNode* less = nullptr, *nodel = nullptr; + ListNode* more = nullptr, *noder = nullptr; + ListNode* h = head; + while (h != nullptr) + { + if (h->val < x) + { + if (less == nullptr) + { + less = h; + nodel = h; + } + else + { + nodel->next = h; + nodel = h; + } + } + else + { + if (more == nullptr) + { + more = h; + noder = h; + } + else + { + noder->next = h; + noder = h; + } + } + h = h->next; + } + if (less == nullptr) + { + noder->next = nullptr; + less = more; + } + else if (more == nullptr) + { + nodel->next = nullptr; + } + else + { + nodel->next = more; + noder->next = nullptr; + } + + return less; + } \ No newline at end of file diff --git a/src/92.cpp b/src/92.cpp new file mode 100644 index 0000000..cb6524e --- /dev/null +++ b/src/92.cpp @@ -0,0 +1,45 @@ +ListNode* reverseBetween(ListNode* head, int m, int n) { + if (head == nullptr || head->next == nullptr || m >= n) + return head; + + ListNode* h = nullptr; + ListNode* prev = nullptr; + ListNode* first = nullptr; + int i = 0; + if (m == 1) + { + first = head; + } + else + { + h = head; + prev = head; + i = 1; + while (i < m-1) + { + prev = prev->next; + ++i; + } + first = prev->next; + } + + ListNode* last = first; + ListNode* node = first->next; + ++i; + while (i < n) + { + ListNode* t = node->next; + node->next = first; + first = node; + node = t; + ++i; + } + + if (prev == nullptr) + h = first; + else + prev->next = first; + last->next = node; + + return h; + } \ No newline at end of file From 5fac3f77c6491670e1db2460f26c363cf31e0fee Mon Sep 17 00:00:00 2001 From: lintcoder Date: Fri, 11 May 2018 14:23:43 +0800 Subject: [PATCH 11/97] 12 problems solved. --- src/138.cpp | 29 +++++++++++ src/240.cpp | 17 +++++++ src/529.cpp | 70 ++++++++++++++++++++++++++ src/565.cpp | 22 +++++++++ src/61.cpp | 30 ++++++++++++ src/655.cpp | 56 +++++++++++++++++++++ src/678.cpp | 50 +++++++++++++++++++ src/721.cpp | 50 +++++++++++++++++++ src/726.cpp | 139 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/817.cpp | 32 ++++++++++++ src/825.cpp | 34 +++++++++++++ src/831.cpp | 43 ++++++++++++++++ 12 files changed, 572 insertions(+) create mode 100644 src/138.cpp create mode 100644 src/240.cpp create mode 100644 src/529.cpp create mode 100644 src/565.cpp create mode 100644 src/61.cpp create mode 100644 src/655.cpp create mode 100644 src/678.cpp create mode 100644 src/721.cpp create mode 100644 src/726.cpp create mode 100644 src/817.cpp create mode 100644 src/825.cpp create mode 100644 src/831.cpp diff --git a/src/138.cpp b/src/138.cpp new file mode 100644 index 0000000..32759f2 --- /dev/null +++ b/src/138.cpp @@ -0,0 +1,29 @@ +RandomListNode *copyRandomList(RandomListNode *head) { + if (head == nullptr) + return nullptr; + RandomListNode* h = head; + map mp; + map mp_cp; + + int i = 0, j = 0; + RandomListNode* head_cp = new RandomListNode(h->label); + RandomListNode* node = head_cp; + mp[h] = i++; + mp_cp[j++] = head_cp; + h = h->next; + + while (h != nullptr) + { + node->next = new RandomListNode(h->label); + node = node->next; + mp[h] = i++; + mp_cp[j++] = node; + h = h->next; + } + for (auto m : mp) + { + if (m.first->random != nullptr) + mp_cp[m.second]->random = mp_cp[mp[m.first->random]]; + } + return head_cp; + } \ No newline at end of file diff --git a/src/240.cpp b/src/240.cpp new file mode 100644 index 0000000..e7b565b --- /dev/null +++ b/src/240.cpp @@ -0,0 +1,17 @@ +bool searchMatrix(vector>& matrix, int target) { + int row = matrix.size(); + if (row == 0) + return false; + int col = matrix[0].size(); + int i = 0, j = col - 1; + while (i < row && j >= 0) + { + if (matrix[i][j] == target) + return true; + else if (matrix[i][j] < target) + ++i; + else + --j; + } + return false; + } \ No newline at end of file diff --git a/src/529.cpp b/src/529.cpp new file mode 100644 index 0000000..8c7caa6 --- /dev/null +++ b/src/529.cpp @@ -0,0 +1,70 @@ +vector> updateBoard(vector>& board, vector& click) + { + int posR = click[0], posC = click[1]; + if (board[posR][posC] == 'M') + { + board[posR][posC] = 'X'; + return board; + } + else + { + int row = board.size(), col = board[0].size(); + updateAdjacentSquare(board, posR, posC, row, col); + return board; + } + } + + void updateAdjacentSquare(vector>& board, int r, int c, int row, int col) + { + if (board[r][c] == 'E') + { + int num = 0; + if (checkAdjacent(board, r, c, row, col, num)) + { + board[r][c] = num + '0'; + return; + } + else + { + board[r][c] = 'B'; + if (r > 0) + updateAdjacentSquare(board, r-1, c, row, col); + if (r < row - 1) + updateAdjacentSquare(board, r+1, c, row, col); + if (c > 0) + updateAdjacentSquare(board, r, c-1, row, col); + if (c < col - 1) + updateAdjacentSquare(board, r, c+1, row, col); + if (r > 0 && c > 0) + updateAdjacentSquare(board, r-1, c-1, row, col); + if (r > 0 && c < col - 1) + updateAdjacentSquare(board, r-1, c+1, row, col); + if (r < row - 1 && c > 0) + updateAdjacentSquare(board, r+1, c-1, row, col); + if (r < row - 1 && c < col - 1) + updateAdjacentSquare(board, r+1, c+1, row, col); + } + } + } + + bool checkAdjacent(vector>& board, int r, int c, int row, int col, int& num) + { + if (r > 0 && board[r - 1][c] == 'M') + num++; + if (r < row - 1 && board[r + 1][c] == 'M') + num++; + if (c > 0 && board[r][c - 1] == 'M') + num++; + if (c < col - 1 && board[r][c + 1] == 'M') + num++; + if (r > 0 && c > 0 && board[r-1][c-1] == 'M') + num++; + if (r > 0 && c < col - 1 && board[r-1][c+1] == 'M') + num++; + if (r < row - 1 && c > 0 && board[r+1][c-1] == 'M') + num++; + if (r < row - 1 && c < col - 1 && board[r+1][c+1] == 'M') + num++; + + return num != 0; + } \ No newline at end of file diff --git a/src/565.cpp b/src/565.cpp new file mode 100644 index 0000000..a5c38d8 --- /dev/null +++ b/src/565.cpp @@ -0,0 +1,22 @@ +int arrayNesting(vector& nums) { + int len = nums.size(); + int maxcount= 1; + int i = 0; + while (i < len) + { + int j = i; + int ct = 1; + while (nums[j] != j && nums[j] != -1) + { + int tmp = nums[j]; + nums[j] = -1; + j = tmp; + ct++; + } + if (ct - 1 > maxcount) + maxcount = ct - 1; + ++i; + } + + return maxcount; + } \ No newline at end of file diff --git a/src/61.cpp b/src/61.cpp new file mode 100644 index 0000000..fff83e6 --- /dev/null +++ b/src/61.cpp @@ -0,0 +1,30 @@ +ListNode* rotateRight(ListNode* head, int k) { + if (head == nullptr || head->next == nullptr) + return head; + + ListNode* h = head; + int len = 0; + while (h != nullptr) + { + ++len; + h = h->next; + } + int n = k % len; + if (n == 0) + return head; + h = head; + int i = 0, limit = len - n; + ListNode* node = nullptr; + while (i < limit) + { + node = h; + h = h->next; + ++i; + } + node->next = nullptr; + node = h; + while (node->next != nullptr) + node = node->next; + node->next = head; + return h; + } \ No newline at end of file diff --git a/src/655.cpp b/src/655.cpp new file mode 100644 index 0000000..94f5a0f --- /dev/null +++ b/src/655.cpp @@ -0,0 +1,56 @@ +vector> printTree(TreeNode* root) { + vector> res; + if (root == nullptr) + return res; + struct Elem + { + int val; + int pos; + Elem(int v, int p): val(v), pos(p){} + }; + + vector> levelvec; + deque dq; + levelvec.push_back(vector(1, Elem(root->val, 0))); + dq.push_back(root); + int sz = 0; + int layer = 0; + while ((sz = dq.size()) != 0) + { + vector vec; + for (int i = 0; i != sz; ++i) + { + TreeNode* node = dq[i]; + if (node->left != nullptr) + { + dq.push_back(node->left); + vec.push_back(Elem(node->left->val, levelvec[layer][i].pos * 2)); + } + if (node->right != nullptr) + { + dq.push_back(node->right); + vec.push_back(Elem(node->right->val, levelvec[layer][i].pos * 2 + 1)); + } + } + dq.erase(dq.begin(), dq.begin() + sz); + levelvec.push_back(vec); + layer++; + } + + int num = pow(2, layer) - 1; + for (int i = 0; i < layer; ++i) + res.push_back(vector(num, string(""))); + + for (int i = 0; i < layer; ++i) + { + int len = levelvec[i].size(); + int r = pow(2, layer - i); + int base = (r - 1)/2; + for (int j = 0; j < len; ++j) + { + res[i][base + r * levelvec[i][j].pos] = to_string(levelvec[i][j].val); + } + } + + return res; + } \ No newline at end of file diff --git a/src/678.cpp b/src/678.cpp new file mode 100644 index 0000000..35757c7 --- /dev/null +++ b/src/678.cpp @@ -0,0 +1,50 @@ +bool checkValidString(string s) { + int len = s.size(); + if (len == 0) + return true; + + int left = 0, star = 0; + vector pos1(len, 0); + vector pos2(len, 0); + int i = 0, j = 0, k = 0; + while (i < len) + { + if (s[i] == '(') + { + ++left; + pos1[j++] = i; + } + else if (s[i] == ')') + { + if (left > 0) + { + --left; + pos1[--j] = -1; + } + else if (star > 0) + { + --star; + pos2[--k] = -1; + } + else + return false; + } + else + { + ++star; + pos2[k++] = i; + } + ++i; + } + if (j > k) + return false; + + while (j > 0) + { + int m = pos1[--j]; + while (pos2[--k] < m); + if (k < j) + return false; + } + return true; + } \ No newline at end of file diff --git a/src/721.cpp b/src/721.cpp new file mode 100644 index 0000000..f13994b --- /dev/null +++ b/src/721.cpp @@ -0,0 +1,50 @@ +vector> accountsMerge(vector>& accounts) { + int num = accounts.size(); + if (num == 0 || num == 1) + return accounts; + + vector> res; + map> mp; + + for (int i = 0; i < num; ++i) + { + int len = accounts[i].size(); + for (int j = 1; j < len; ++j) + mp[accounts[i][j]].push_back(i); + } + + vector access(num, 0); + for (int i = 0; i < num; ++i) + { + if (access[i] == 1) + continue; + access[i] = 1; + set account; + merge(accounts, access, mp, i, account); + + vector ac(account.size()+1, ""); + ac[0] = accounts[i][0]; + copy(account.begin(), account.end(), ac.begin()+1); + sort(ac.begin()+1, ac.end()); + res.push_back(ac); + } + return res; + } + void merge(const vector>& accounts, vector& access, map>& mp, int index, set& ac) + { + ac.insert(accounts[index].begin()+1, accounts[index].end()); + int len = accounts[index].size(); + for (int i = 1; i < len; ++i) + { + int n = mp[accounts[index][i]].size(); + for (int j = 0; j < n; ++j) + { + int m = mp[accounts[index][i]][j]; + if (access[m] == 0) + { + access[m] = 1; + merge(accounts, access, mp, m, ac); + } + } + } + } \ No newline at end of file diff --git a/src/726.cpp b/src/726.cpp new file mode 100644 index 0000000..ddec8b6 --- /dev/null +++ b/src/726.cpp @@ -0,0 +1,139 @@ +string countOfAtoms(string formula) { + int len = formula.size(); + if (len <= 1) + return formula; + + int i = 0, num = 0; + string atomic; + map mp; + while (i < len) + { + if (isalpha(formula[i])) + { + if (i+1 < len && islower(formula[i+1])) + { + atomic = formula.substr(i, 2); + i += 2; + } + else + { + atomic = formula[i]; + ++i; + } + mp[atomic]++; + } + else if (isdigit(formula[i])) + { + auto iter = find_if(formula.begin()+i, formula.end(), not_digit); + if (iter == formula.end()) + { + num = stoi(formula.substr(i)); + mp[atomic] += num-1; + break; + } + else + { + num = stoi(formula.substr(i, iter-(formula.begin()+i))); + mp[atomic] += num-1; + i += iter-(formula.begin()+i); + } + } + else if (formula[i] == '(') + { + map submap; + ++i; + countOfGroup(formula, i, submap); + ++i; + if (i < len && isdigit(formula[i])) + { + auto iter = find_if(formula.begin()+i, formula.end(), not_digit); + if (iter == formula.end()) + num = stoi(formula.substr(i)); + else + { + num = stoi(formula.substr(i, iter-(formula.begin()+i))); + i += iter-(formula.begin()+i); + } + for (auto m : submap) + mp[m.first] += m.second*num; + if (iter == formula.end()) + break; + } + else + { + for (auto m : submap) + mp[m.first] += m.second; + } + } + } + num = mp.size(); + vector vec(num, ""); + i = 0; + for (auto m : mp) + vec[i++] = m.first; + sort(vec.begin(), vec.end()); + string res; + for (int i = 0; i < num; ++i) + { + res += vec[i]; + if (mp[vec[i]] > 1) + res += to_string(mp[vec[i]]); + } + + return res; + } + + static void countOfGroup(const string& formula, int& index, map& mp) + { + string atomic; + while (formula[index] != ')') + { + if (isalpha(formula[index])) + { + if (islower(formula[index+1])) + { + atomic = formula.substr(index, 2); + index += 2; + } + else + { + atomic = formula[index]; + ++index; + } + mp[atomic]++; + } + else if (isdigit(formula[index])) + { + auto iter = find_if(formula.begin()+index, formula.end(), not_digit); + + int num = stoi(formula.substr(index, iter-(formula.begin()+index))); + mp[atomic] += num-1; + index += iter-(formula.begin()+index); + } + else if (formula[index] == '(') + { + map submap; + ++index; + countOfGroup(formula, index, submap); + ++index; + if (isdigit(formula[index])) + { + auto iter = find_if(formula.begin()+index, formula.end(), not_digit); + int num = stoi(formula.substr(index, iter-(formula.begin()+index))); + index += iter-(formula.begin()+index); + for (auto m : submap) + mp[m.first] += m.second*num; + } + else + { + for (auto m : submap) + mp[m.first] += m.second; + } + } + } + } + + static bool not_digit(char c) + { + return !isdigit(c); + } \ No newline at end of file diff --git a/src/817.cpp b/src/817.cpp new file mode 100644 index 0000000..9b98719 --- /dev/null +++ b/src/817.cpp @@ -0,0 +1,32 @@ +int numComponents(ListNode* head, vector& G) { + int arr[10000] = {0}; + int len = G.size(); + for (int i = 0; i < len; ++i) + arr[G[i]] = 1; + + ListNode* h = head; + int ct = 0; + while (h != nullptr && arr[h->val] == 0) + h = h->next; + if (h == nullptr) + return ct; + bool flag = true; + h = h->next; + while (h != nullptr) + { + if (arr[h->val] == 0 && flag) + { + flag = false; + ++ct; + } + else if (arr[h->val] == 1 && !flag) + { + flag = true; + } + h = h->next; + } + if (flag) + ++ct; + + return ct; + } \ No newline at end of file diff --git a/src/825.cpp b/src/825.cpp new file mode 100644 index 0000000..1673d9c --- /dev/null +++ b/src/825.cpp @@ -0,0 +1,34 @@ +int numFriendRequests(vector& ages) { + int len = ages.size(); + if (len <= 1) + return 0; + + sort(ages.begin(), ages.end()); + int i = len-1; + int ct = 0; + while (i > 0) + { + int limit = ages[i]*0.5 + 7; + int last_age = ages[i]; + auto iter = upper_bound(ages.begin(), ages.begin()+i, limit); + + if (iter != ages.begin()+i) + { + int n = i - (iter-ages.begin()); + ct += n; + int tmp = i; + while (--i >= 0 && ages[i] == last_age) + { + ct += n-1; + n--; + } + ct += (tmp+1 - (i+1))*(tmp-(i+1))/2; + } + else + { + while (--i >= 0 && ages[i] == last_age); + } + } + + return ct; + } \ No newline at end of file diff --git a/src/831.cpp b/src/831.cpp new file mode 100644 index 0000000..318a7fd --- /dev/null +++ b/src/831.cpp @@ -0,0 +1,43 @@ +string maskPII(string S) { + int len = S.size(); + if (isalpha(S[0])) + { + int pos = S.find('@'); + int n = 7 + len - pos; + string res(n, '*'); + res[0] = tolower(S[0]); + res[6] = tolower(S[pos-1]); + int j = 7; + for (int i = pos; i < len; ++i) + if (isalpha(S[i])) + res[j++] = tolower(S[i]); + else + res[j++] = S[i]; + return res; + } + else + { + int i = 0, j = 0; + string digit(13, ' '); + while (i < len) + { + if (isdigit(S[i])) + digit[j++] = S[i]; + ++i; + } + if (j == 10) + return "***-***-" + digit.substr(j-4, 4); + else + { + string res(14+j-10, '*'); + res[0] = '+'; + res[j-10+1] = '-'; + res[j-10+5] = res[j-1] = '-'; + res[j] = digit[j-4]; + res[j+1] = digit[j-3]; + res[j+2] = digit[j-2]; + res[j+3] = digit[j-1]; + return res; + } + } + } \ No newline at end of file From 997c62a1085003019873ee79d8fae58b637622ca Mon Sep 17 00:00:00 2001 From: lintcoder Date: Thu, 17 May 2018 14:19:37 +0800 Subject: [PATCH 12/97] 10 problems solved. --- src/202.cpp | 23 +++++++++++++++++++++ src/21.cpp | 33 ++++++++++++++++++++++++++++++ src/231.cpp | 16 +++++++++++++++ src/257.cpp | 58 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/27.cpp | 26 ++++++++++++++++++++++++ src/326.cpp | 6 ++++++ src/405.cpp | 28 ++++++++++++++++++++++++++ src/415.cpp | 49 ++++++++++++++++++++++++++++++++++++++++++++ src/70.cpp | 18 +++++++++++++++++ src/747.cpp | 41 +++++++++++++++++++++++++++++++++++++ 10 files changed, 298 insertions(+) create mode 100644 src/202.cpp create mode 100644 src/21.cpp create mode 100644 src/231.cpp create mode 100644 src/257.cpp create mode 100644 src/27.cpp create mode 100644 src/326.cpp create mode 100644 src/405.cpp create mode 100644 src/415.cpp create mode 100644 src/70.cpp create mode 100644 src/747.cpp diff --git a/src/202.cpp b/src/202.cpp new file mode 100644 index 0000000..529abc1 --- /dev/null +++ b/src/202.cpp @@ -0,0 +1,23 @@ +bool isHappy(int n) { + set st; + int sum = 0; + while (true) + { + sum = 0; + while (n != 0) + { + sum += (n % 10) * (n % 10); + n /= 10; + } + if (sum == 1) + break; + if (st.find(sum) == st.end()) + { + st.insert(sum); + n = sum; + } + else + break; + } + return sum == 1; + } \ No newline at end of file diff --git a/src/21.cpp b/src/21.cpp new file mode 100644 index 0000000..169e2b0 --- /dev/null +++ b/src/21.cpp @@ -0,0 +1,33 @@ +ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { + if (l1 == NULL) + return l2; + if (l2 == NULL) + return l1; + ListNode* h = l1->val < l2->val ? l1 : l2; + ListNode* p = h; + ListNode* q = l1, *t = l2; + if (l1->val < l2->val) + q = q->next; + else + t = t->next; + while (q != NULL && t != NULL) + { + if (q->val < t->val) + { + p->next = q; + p = q; + q = q->next; + } + else + { + p->next = t; + p = t; + t = t->next; + } + } + if (q != NULL) + p->next = q; + else + p->next = t; + return h; + } \ No newline at end of file diff --git a/src/231.cpp b/src/231.cpp new file mode 100644 index 0000000..31daed6 --- /dev/null +++ b/src/231.cpp @@ -0,0 +1,16 @@ +bool isPowerOfTwo(int n) { + if (n <= 0) + return false; + int limit = sizeof(int) * 8; + int ct = 0; + for (int i = 0; i < limit; ++i) + { + if (((n >> i) & 1) == 1) + { + ++ct; + if (ct > 1) + return false; + } + } + return true; + } \ No newline at end of file diff --git a/src/257.cpp b/src/257.cpp new file mode 100644 index 0000000..ab2ee4d --- /dev/null +++ b/src/257.cpp @@ -0,0 +1,58 @@ +vector binaryTreePaths(TreeNode* root) { + vector paths; + if (root == NULL) + return paths; + else + { + string path(num2str(root->val)); + if (root->left != NULL || root->right != NULL) + { + if (root->left != NULL) + collectpath(paths, path, root->left); + if (root->right != NULL) + collectpath(paths, path, root->right); + } + else + paths.push_back(path); + return paths; + } + } + + void collectpath(vector& paths, const string& path, TreeNode* node) + { + string str(path + "->" + num2str(node->val)); + if (node->left != NULL || node->right != NULL) + { + string subpath(str); + if (node->left != NULL) + collectpath(paths, subpath, node->left); + if (node->right != NULL) + collectpath(paths, subpath, node->right); + } + else + paths.push_back(str); + } + + string num2str(int num) + { + if (num == 0) + return "0"; + + string str; + int flag = 0; + if (num < 0) + { + flag = 1; + num = -num; + } + while (num > 0) + { + str.push_back(num % 10 + '0'); + num /= 10; + } + if (flag) + str.push_back('-'); + reverse(str.begin(), str.end()); + + return str; + } \ No newline at end of file diff --git a/src/27.cpp b/src/27.cpp new file mode 100644 index 0000000..39ac16b --- /dev/null +++ b/src/27.cpp @@ -0,0 +1,26 @@ +int removeElement(vector& nums, int val) { + int sz = nums.size(); + int i = 0, j = sz - 1; + int sum = 0; + while (i <= j) + { + while (i <= j && nums[i] != val) + ++i; + while (i <= j && nums[j] == val) + { + ++sum; + --j; + } + if (i < j) + { + ++sum; + int tmp = nums[i]; + nums[i] = nums[j]; + nums[j] = tmp; + ++i; + --j; + } + } + + return sz - sum; + } \ No newline at end of file diff --git a/src/326.cpp b/src/326.cpp new file mode 100644 index 0000000..0010621 --- /dev/null +++ b/src/326.cpp @@ -0,0 +1,6 @@ +bool isPowerOfThree(int n) { + if (n <= 0) + return false; + int max3power = pow(3, (int)(log(INT_MAX) / log(3))); + return max3power % n == 0; + } \ No newline at end of file diff --git a/src/405.cpp b/src/405.cpp new file mode 100644 index 0000000..f7558cd --- /dev/null +++ b/src/405.cpp @@ -0,0 +1,28 @@ +string toHex(int num) { + if (num == 0) + return "0"; + bitset<32> bs(num); + int sum = 0; + bool flag = false; + string res; + for (int i = 1; i <= 32; ++i) + { + sum = sum * 2 + bs[32 - i]; + if (i % 4 == 0) + { + if (sum != 0) + { + char c = sum <= 9 ? sum + '0' : sum - 10 + 'a'; + res.push_back(c); + flag = true; + } + else + { + if (flag) + res.push_back('0'); + } + sum = 0; + } + } + return res; + } \ No newline at end of file diff --git a/src/415.cpp b/src/415.cpp new file mode 100644 index 0000000..613c5c0 --- /dev/null +++ b/src/415.cpp @@ -0,0 +1,49 @@ +string addStrings(string num1, string num2) { + int len1 = num1.size(); + int len2 = num2.size(); + int sum = 0, ct = 0; + int i = len1 - 1, j = len2 - 1; + string res; + while (i >= 0 && j >= 0) + { + sum = num1[i] - '0' + num2[j] - '0' + ct; + res.push_back(char(sum % 10 + '0')); + ct = sum / 10; + --i; + --j; + } + if (i >= 0) + { + while (i >= 0) + { + sum = num1[i] - '0' + ct; + res.push_back(char(sum % 10 + '0')); + ct = sum / 10; + --i; + } + if (ct > 0) + { + res.push_back(char(ct + '0')); + ct = 0; + } + } + if (j >= 0) + { + while (j >= 0) + { + sum = num2[j] - '0' + ct; + res.push_back(char(sum % 10 + '0')); + ct = sum / 10; + --j; + } + if (ct > 0) + { + res.push_back(char(ct + '0')); + ct = 0; + } + } + if (ct > 0) + res.push_back(char(ct + '0')); + reverse(res.begin(), res.end()); + return res; + } \ No newline at end of file diff --git a/src/70.cpp b/src/70.cpp new file mode 100644 index 0000000..bb7f440 --- /dev/null +++ b/src/70.cpp @@ -0,0 +1,18 @@ +int climbStairs(int n) { + if (n <= 1) + return 1; + if (n == 2) + return 2; + int* step = new int[n + 1]; + step[1] = 1; + step[2] = 2; + int i = 3; + while (i <= n) + { + step[i] = step[i - 1] + step[i - 2]; + ++i; + } + int res = step[n]; + delete step; + return res; + } \ No newline at end of file diff --git a/src/747.cpp b/src/747.cpp new file mode 100644 index 0000000..c0528ae --- /dev/null +++ b/src/747.cpp @@ -0,0 +1,41 @@ +int dominantIndex(vector& nums) { + int len = nums.size(); + if (len == 0) + return -1; + if (len == 1) + return 0; + int maxnum = 0, submaxnum = 0, pos = 0; + if (nums[0] > nums[1]) + { + maxnum = nums[0]; + submaxnum = nums[1]; + pos = 0; + } + else + { + maxnum = nums[1]; + submaxnum = nums[0]; + pos = 1; + } + int i = 2; + while (i < len) + { + if (nums[i] > maxnum) + { + submaxnum = maxnum; + maxnum = nums[i]; + pos = i; + } + else if (nums[i] > submaxnum) + { + submaxnum = nums[i]; + if (submaxnum >= 50) + return -1; + } + ++i; + } + if (maxnum >= submaxnum*2) + return pos; + else + return -1; + } \ No newline at end of file From bd6f213b7988aefd3f3e3771796017161d0d55d1 Mon Sep 17 00:00:00 2001 From: lintcoder Date: Fri, 25 May 2018 09:38:40 +0800 Subject: [PATCH 13/97] 10 problems solved. --- src/129.cpp | 25 ++++++++++++++++++++ src/319.cpp | 3 +++ src/394.cpp | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/436.cpp | 40 ++++++++++++++++++++++++++++++++ src/48.cpp | 17 ++++++++++++++ src/59.cpp | 18 ++++++++++++++ src/593.cpp | 62 +++++++++++++++++++++++++++++++++++++++++++++++++ src/611.cpp | 26 +++++++++++++++++++++ src/692.cpp | 36 ++++++++++++++++++++++++++++ src/77.cpp | 28 ++++++++++++++++++++++ 10 files changed, 322 insertions(+) create mode 100644 src/129.cpp create mode 100644 src/319.cpp create mode 100644 src/394.cpp create mode 100644 src/436.cpp create mode 100644 src/48.cpp create mode 100644 src/59.cpp create mode 100644 src/593.cpp create mode 100644 src/611.cpp create mode 100644 src/692.cpp create mode 100644 src/77.cpp diff --git a/src/129.cpp b/src/129.cpp new file mode 100644 index 0000000..aaf0426 --- /dev/null +++ b/src/129.cpp @@ -0,0 +1,25 @@ +int sumNumbers(TreeNode* root) { + if (root == nullptr) + return 0; + int sum = 0; + if (root->left == nullptr && root->right == nullptr) + return root->val; + if (root->left != nullptr) + subsumNumbers(root->left, root->val, sum); + if (root->right != nullptr) + subsumNumbers(root->right, root->val, sum); + return sum; + } + + void subsumNumbers(TreeNode* node, int sum, int& total) + { + if (node->left == nullptr && node->right == nullptr) + { + total += sum*10 + node->val; + return; + } + if (node->left != nullptr) + subsumNumbers(node->left, sum*10 + node->val, total); + if (node->right != nullptr) + subsumNumbers(node->right, sum*10 + node->val, total); + } \ No newline at end of file diff --git a/src/319.cpp b/src/319.cpp new file mode 100644 index 0000000..2d9c560 --- /dev/null +++ b/src/319.cpp @@ -0,0 +1,3 @@ +int bulbSwitch(int n) { + return sqrt(n); + } \ No newline at end of file diff --git a/src/394.cpp b/src/394.cpp new file mode 100644 index 0000000..35d2d05 --- /dev/null +++ b/src/394.cpp @@ -0,0 +1,67 @@ +string decodeString(string s) { + int len = s.size(); + if (len <= 1) + return s; + + int i = 0; + string res; + while (i < len) + { + if (isalpha(s[i])) + { + auto p = find_if(s.begin()+i, s.end(), not_alpha); + res.insert(res.end(), s.begin()+i, p); + if (p == s.end()) + break; + else + i = p-s.begin(); + } + else if (isdigit(s[i])) + { + auto p = find_if(s.begin()+i, s.end(), not_digit); + int n = stoi(s.substr(i, p-(s.begin()+i))); + int index = p-s.begin()+1; + string ds = decodeSubstring(s, index); + for (int i = 0; i < n; ++i) + res += ds; + i = index+1; + } + } + + return res; + } + + string decodeSubstring(const string& s, int& pos) + { + string res; + while (s[pos] != ']') + { + if (isalpha(s[pos])) + { + auto p = find_if(s.begin()+pos, s.end(), not_alpha); + res.insert(res.end(), s.begin()+pos, p); + pos = p-s.begin(); + } + else if (isdigit(s[pos])) + { + auto p = find_if(s.begin()+pos, s.end(), not_digit); + int n = stoi(s.substr(pos, p-(s.begin()+pos))); + int index = p-s.begin()+1; + string ds = decodeSubstring(s, index); + for (int i = 0; i < n; ++i) + res += ds; + pos = index+1; + } + } + return res; + } + + static bool not_alpha(char c) + { + return !isalpha(c); + } + + static bool not_digit(char c) + { + return !isdigit(c); + } \ No newline at end of file diff --git a/src/436.cpp b/src/436.cpp new file mode 100644 index 0000000..ce8bc57 --- /dev/null +++ b/src/436.cpp @@ -0,0 +1,40 @@ +vector findRightInterval(vector& intervals) { + int len = intervals.size(); + if (len <= 1) + return {-1}; + + struct Elem + { + Interval* val; + int pos; + Elem(Interval* v = nullptr, int p = -1) : val(v), pos(p){} + }; + + auto cmp = [](const Elem& a, const Elem& b) { + return a.val->start < b.val->start || (a.val->start == b.val->start && a.val->end < b.val->end); + }; + + vector res(len, -1); + vector vec(len, Elem()); + for (int i = 0; i < len; ++i) + { + vec[i].val = &intervals[i]; + vec[i].pos = i; + } + sort(vec.begin(), vec.end(), cmp); + + auto cmp2 = [](const Elem& a, const Elem& b) { + return a.val->start < b.val->end; + }; + + Elem tmp(new Interval(), 0); + for (int i = 0; i < len-1; ++i) + { + tmp.val->end = vec[i].val->end; + auto p = lower_bound(vec.begin()+i+1, vec.end(), tmp, cmp2); + if (p != vec.end()) + res[vec[i].pos] = p->pos; + } + + return res; + } \ No newline at end of file diff --git a/src/48.cpp b/src/48.cpp new file mode 100644 index 0000000..e2fa178 --- /dev/null +++ b/src/48.cpp @@ -0,0 +1,17 @@ +void rotate(vector>& matrix) { + int row = matrix.size(); + if (row <= 1) + return; + + for (int i = 0; i < row/2; ++i) + { + for (int j = i; j < row-1-i; ++j) + { + int tmp = matrix[row-1-i-(j-i)][i]; + matrix[row-1-i-(j-i)][i] = matrix[row-1-i][row-1-i-(j-i)]; + matrix[row-1-i][row-1-i-(j-i)] = matrix[j][row-1-i]; + matrix[j][row-1-i] = matrix[i][j]; + matrix[i][j] = tmp; + } + } + } \ No newline at end of file diff --git a/src/59.cpp b/src/59.cpp new file mode 100644 index 0000000..c3cc073 --- /dev/null +++ b/src/59.cpp @@ -0,0 +1,18 @@ +vector> generateMatrix(int n) { + vector> res(n, vector(n, 0)); + int ct = 1; + int limit = n%2 == 0 ? n/2 : n/2+1; + for (int i = 0; i < limit; ++i) + { + for (int j = i; j < n-i; ++j) + res[i][j] = ct++; + for (int j = i+1; j < n-i; ++j) + res[j][n-i-1] = ct++; + for (int j = n-i-2; j >= i; --j) + res[n-i-1][j] = ct++; + for (int j = n-i-2; j >= i+1; --j) + res[j][i] = ct++; + } + + return res; + } \ No newline at end of file diff --git a/src/593.cpp b/src/593.cpp new file mode 100644 index 0000000..1869be0 --- /dev/null +++ b/src/593.cpp @@ -0,0 +1,62 @@ +bool validSquare(vector& p1, vector& p2, vector& p3, vector& p4) { + if (p1 == p2 || p1 == p3 || p1 == p4 || p2 == p3 || p2 == p4 || p3 == p4) + return false; + + vector point[4]; + bool flag = false; + if (isparallel(p1, p2, p3, p4)) + { + point[0] = p1; + point[1] = p2; + point[2] = p3; + point[3] = p4; + flag = true; + } + else if (!flag && isparallel(p1, p3, p2, p4)) + { + point[0] = p1; + point[1] = p3; + point[2] = p2; + point[3] = p4; + } + else + return false; + + if ((point[0][0] == point[1][0] && point[0][0] == point[2][0] && point[0][0] == point[3][0]) || + ((point[0][1] == point[1][1] && point[0][1] == point[2][1] && point[0][1] == point[3][1]))) + return false; + if (point[0][0] == point[1][0]) + { + if (point[0][1] == point[2][1]) + { + return abs(point[0][1] - point[1][1]) == abs(point[0][0] - point[2][0]) && + (point[0][1]-point[1][1]) == (point[2][1]-point[3][1]); + } + else if (point[0][1] == point[3][1]) + { + return abs(point[0][1] - point[1][1]) == abs(point[0][0] - point[3][0]) && + (point[0][1]-point[1][1]) == (point[3][1]-point[2][1]); + } + } + else + { + if (((point[1][1]-point[0][1])*(point[2][1]-point[0][1]) == -(point[1][0] - point[0][0])*(point[2][0]-point[0][0])) && + ((point[0][1]-point[1][1])*(point[3][1]-point[1][1]) == -(point[0][0] - point[1][0])*(point[3][0]-point[1][0]))) + return distance(point[1], point[0]) == distance(point[2], point[0]); + else if (((point[1][1]-point[0][1])*(point[3][1]-point[0][1]) == -(point[1][0] - point[0][0])*(point[3][0]-point[0][0])) && + ((point[0][1]-point[1][1])*(point[2][1]-point[1][1]) == -(point[0][0] - point[1][0])*(point[2][0]-point[1][0]))) + return distance(point[1], point[0]) == distance(point[3], point[0]); + } + + return false; + } + + bool isparallel(vector& p1, vector& p2, vector& p3, vector& p4) + { + return (p2[1]-p1[1])*(p4[0]-p3[0]) == (p2[0]-p1[0])*(p4[1]-p3[1]); + } + + int distance(vector& p1, vector&p2) + { + return (p2[1]-p1[1])*(p2[1]-p1[1]) + (p2[0]-p1[0])*(p2[0]-p1[0]); + } \ No newline at end of file diff --git a/src/611.cpp b/src/611.cpp new file mode 100644 index 0000000..0e0c499 --- /dev/null +++ b/src/611.cpp @@ -0,0 +1,26 @@ +int triangleNumber(vector& nums) { + int len = nums.size(); + if (len < 3) + return 0; + + sort(nums.begin(), nums.end()); + int ct = 0; + for (int i = 0; i < len-2; ++i) + { + bool flag = true; + for (int j = i+1; j < len-1; ++j) + { + if (flag == false) + ct += len-1-j; + else + { + auto p = lower_bound(nums.begin()+j+1, nums.end(), nums[i]+nums[j]); + ct += p-nums.begin()-j-1; + if (p == nums.end()) + flag = false; + } + } + } + + return ct; + } \ No newline at end of file diff --git a/src/692.cpp b/src/692.cpp new file mode 100644 index 0000000..9d79d9f --- /dev/null +++ b/src/692.cpp @@ -0,0 +1,36 @@ +vector topKFrequent(vector& words, int k) { + int len = words.size(); + if (len == 0) + return words; + map mp; + for (int i = 0; i < len; ++i) + mp[words[i]]++; + + struct wordFreq + { + string w; + int ct; + wordFreq(const string& word = "", int n = 0) : w(word), ct(n){} + }; + + int num = mp.size(); + int j = 0; + vector vec(num, wordFreq()); + for (auto iter : mp) + { + vec[j].w = iter.first; + vec[j].ct = iter.second; + ++j; + } + + auto cmp = [](const wordFreq& a, const wordFreq& b) { + return a.ct > b.ct || (a.ct == b.ct && a.w < b.w); + }; + + sort(vec.begin(), vec.end(), cmp); + vector res(k, ""); + for (int i = 0; i < k; ++i) + res[i] = vec[i].w; + + return res; + } \ No newline at end of file diff --git a/src/77.cpp b/src/77.cpp new file mode 100644 index 0000000..fd28df9 --- /dev/null +++ b/src/77.cpp @@ -0,0 +1,28 @@ +vector> combine(int n, int k) { + vector> res; + if (n < k) + return res; + for (int i = 1; i <= n-k+1; ++i) + { + vector vec(k, 0); + vec[0] = i; + docombine(n, i+1, k, 1, vec, res); + } + + return res; + } + + void docombine(int n, int index, int k, int count, vector& vec, vector>& res) + { + if (count == k) + res.push_back(vec); + else + { + for (int i = index; i <= n-k+1+count; ++i) + { + vector tmp(vec); + tmp[count] = i; + docombine(n, i+1, k, count+1, tmp, res); + } + } + } \ No newline at end of file From 48b3bda86044760c436cbd8c2e64b8948946e934 Mon Sep 17 00:00:00 2001 From: lintcoder Date: Sun, 1 Jul 2018 10:15:23 +0800 Subject: [PATCH 14/97] 12 problems solved. --- src/101.cpp | 18 +++++++++ src/118.cpp | 24 ++++++++++++ src/191.cpp | 9 +++++ src/628.cpp | 23 +++++++++++ src/661.cpp | 59 ++++++++++++++++++++++++++++ src/788.cpp | 108 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/819.cpp | 52 +++++++++++++++++++++++++ src/821.cpp | 39 +++++++++++++++++++ src/824.cpp | 32 ++++++++++++++++ src/832.cpp | 22 +++++++++++ src/844.cpp | 70 ++++++++++++++++++++++++++++++++++ src/852.cpp | 22 +++++++++++ 12 files changed, 478 insertions(+) create mode 100644 src/101.cpp create mode 100644 src/118.cpp create mode 100644 src/191.cpp create mode 100644 src/628.cpp create mode 100644 src/661.cpp create mode 100644 src/788.cpp create mode 100644 src/819.cpp create mode 100644 src/821.cpp create mode 100644 src/824.cpp create mode 100644 src/832.cpp create mode 100644 src/844.cpp create mode 100644 src/852.cpp diff --git a/src/101.cpp b/src/101.cpp new file mode 100644 index 0000000..f98165b --- /dev/null +++ b/src/101.cpp @@ -0,0 +1,18 @@ +bool isSymmetric(TreeNode* root) { + if (root == NULL) + return true; + + return doisSymmetric(root->left, root->right); + } + + bool doisSymmetric(TreeNode* ln, TreeNode* rn) + { + if (ln == NULL && rn == NULL) + return true; + else if (ln != NULL && rn != NULL) + { + return ln->val == rn->val && doisSymmetric(ln->left, rn->right) && doisSymmetric(ln->right, rn->left); + } + else + return false; + } \ No newline at end of file diff --git a/src/118.cpp b/src/118.cpp new file mode 100644 index 0000000..30dd936 --- /dev/null +++ b/src/118.cpp @@ -0,0 +1,24 @@ +vector> generate(int numRows) { + vector> res; + for (int i = 1; i <= numRows; ++i) + { + vector rowvec; + if (i == 1) + rowvec.push_back(1); + else if (i == 2) + { + rowvec.push_back(1); + rowvec.push_back(1); + } + else + { + rowvec.push_back(1); + for (int j = 1; j < i - 1; ++j) + rowvec.push_back(res[i - 2][j - 1] + res[i - 2][j]); + rowvec.push_back(1); + } + res.push_back(rowvec); + } + + return res; + } \ No newline at end of file diff --git a/src/191.cpp b/src/191.cpp new file mode 100644 index 0000000..4b1f030 --- /dev/null +++ b/src/191.cpp @@ -0,0 +1,9 @@ +int hammingWeight(uint32_t n) { + bitset<32> bt(n); + int sum = 0; + for (int i = 0; i < 32; ++i) + if (bt[i] == 1) + sum++; + + return sum; + } \ No newline at end of file diff --git a/src/628.cpp b/src/628.cpp new file mode 100644 index 0000000..0f83307 --- /dev/null +++ b/src/628.cpp @@ -0,0 +1,23 @@ +int maximumProduct(vector& nums) { + int len = nums.size(); + if (len == 3) + return nums[0]*nums[1]*nums[2]; + + sort(nums.begin(), nums.end()); + if (nums[len-1] == 0) + return 0; + else if (nums[len-1] < 0) + return nums[0]*nums[1]*nums[2]; + else + { + int p1 = nums[len-1]*nums[len-2]*nums[len-3]; + int p2 = 0; + auto iter = lower_bound(nums.begin(), nums.end(), 0); + if (iter - nums.begin() >= 2) + p2 = nums[len-1]*nums[0]*nums[1]; + if (p1 > p2) + return p1; + else + return p2; + } + } \ No newline at end of file diff --git a/src/661.cpp b/src/661.cpp new file mode 100644 index 0000000..b1ff546 --- /dev/null +++ b/src/661.cpp @@ -0,0 +1,59 @@ +vector> imageSmoother(vector>& M) { + int row = M.size(); + if (row == 0) + return M; + int col = M[0].size(); + + vector> res(row, vector(col, 0)); + for (int i = 0; i < row; ++i) + { + for (int j = 0; j < col; ++j) + { + int sum = M[i][j]; + int ct = 1; + if (i > 0 && j > 0) + { + sum += M[i-1][j-1]; + ct++; + } + if (i > 0) + { + sum += M[i-1][j]; + ct++; + } + if (i > 0 && j < col-1) + { + sum += M[i-1][j+1]; + ct++; + } + if (j > 0) + { + sum += M[i][j-1]; + ct++; + } + if (j < col-1) + { + sum += M[i][j+1]; + ct++; + } + if (i < row-1 && j > 0) + { + sum += M[i+1][j-1]; + ct++; + } + if (i < row-1) + { + sum += M[i+1][j]; + ct++; + } + if (i < row-1 && j < col-1) + { + sum += M[i+1][j+1]; + ct++; + } + res[i][j] = sum/ct; + } + } + + return res; + } \ No newline at end of file diff --git a/src/788.cpp b/src/788.cpp new file mode 100644 index 0000000..d8df98c --- /dev/null +++ b/src/788.cpp @@ -0,0 +1,108 @@ +const int nogood[10] = {1, 2, 3, 3, 3, 4, 5, 5, 6, 7}; +const int good[10] = {4, 4, 7, 0, 0, 7, 7, 0, 4, 7}; +const int flag[10] = {0, 0, 1, -1, -1, 1, 1, -1, 0, 1}; +int rotatedDigits(int N) { + int n = 0, num = N; + while (num > 0) + { + num /= 10; + ++n; + } + int ct = 0; + if (n == 1) + return count1(N); + else if (n == 2) + return count2(N); + else if (n == 3) + return count3(N); + else if (n == 4) + return count4(N); + else + return count4(9999); + } + + int count1(int n) + { + if (n < 2) + return 0; + else if (n < 5) + return 1; + else if (n < 6) + return 2; + else if (n < 9) + return 3; + else + return 4; + } + + int count2(int n) + { + int digit = n/10; + int ct = 0; + for (int i = 0; i < digit; ++i) + ct += good[i]; + if (flag[digit] == 0) + ct += count1(n%10); + else if (flag[digit] == 1) + ct += nogood[n%10]; + return ct; + } + + int count3(int n) + { + int digit = n/100; + int ct = 0; + for (int i = 0; i < digit; ++i) + { + if (flag[i] == 0) + ct += 40; + else if (flag[i] == 1) + ct += 49; + } + if (flag[digit] == 0) + ct += count2(n%100); + else if (flag[digit] == 1) + { + for (int i = 0; i < n%100/10; ++i) + if (flag[i] != -1) + ct += 7; + digit = n%100/10; + if (flag[digit] != -1) + ct += nogood[n%10]; + } + return ct; + } + + int count4(int n) + { + int digit = n/1000; + int ct = 0; + int tmp = count3(999); + for (int i = 0; i < digit; ++i) + { + if (flag[i] == 0) + ct += tmp; + else if (flag[i] == 1) + ct += 343; + } + if (flag[digit] == 0) + ct += count3(n%1000); + else if (flag[digit] == 1) + { + digit = n%1000/100; + for (int i = 0; i < digit; ++i) + if (flag[i] != -1) + ct += 49; + if (flag[digit] != -1) + { + digit = n%100/10; + for (int i = 0; i < digit; ++i) + if (flag[i] != -1) + ct += 7; + if (flag[digit] != -1) + ct += nogood[n%10]; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/819.cpp b/src/819.cpp new file mode 100644 index 0000000..8909b8f --- /dev/null +++ b/src/819.cpp @@ -0,0 +1,52 @@ +string mostCommonWord(string paragraph, vector& banned) { + int len = paragraph.size(); + if (len == 0) + return ""; + int num = banned.size(); + + const char* exclude = " !?',;."; + map mp; + + int index = paragraph.find_first_not_of(exclude); + if (index == string::npos) + return ""; + + bool flag = false; + while (index != string::npos && index < len) + { + int pos = paragraph.find_first_of(exclude, index); + if (pos == string::npos) + { + flag = true; + break; + } + + string s = paragraph.substr(index, pos - index); + transform(s.begin(), s.end(), s.begin(), ::tolower); + if (find(banned.begin(), banned.end(), s) == banned.end()) + mp[s]++; + if (pos == len - 1) + break; + index = paragraph.find_first_not_of(exclude, pos+1); + } + if (flag) + { + string s = paragraph.substr(index); + transform(s.begin(), s.end(), s.begin(), ::tolower); + if (find(banned.begin(), banned.end(), s) == banned.end()) + mp[s]++; + } + + string res; + int maxnum = 0; + for (auto m : mp) + { + if (m.second > maxnum) + { + maxnum = m.second; + res = m.first; + } + } + + return res; + } \ No newline at end of file diff --git a/src/821.cpp b/src/821.cpp new file mode 100644 index 0000000..3f990f7 --- /dev/null +++ b/src/821.cpp @@ -0,0 +1,39 @@ +vector shortestToChar(string S, char C) { + vector res; + vector pos; + int len = S.size(); + int ct = 0; + for (int i = 0; i < len; ++i) + { + if (S[i] == C) + { + pos.push_back(i); + ct++; + } + } + + int i = 0; + int j = 0; + while (i < len) + { + if (S[i] == C) + { + res.push_back(0); + ++j; + } + else if (j == 0) + { + res.push_back(pos[j]-i); + } + else if (j < ct) + { + int p = pos[j]-i < i - pos[j-1] ? pos[j] - i : i - pos[j-1]; + res.push_back(p); + } + else + res.push_back(i - pos[j-1]); + ++i; + } + + return res; + } \ No newline at end of file diff --git a/src/824.cpp b/src/824.cpp new file mode 100644 index 0000000..40c50ec --- /dev/null +++ b/src/824.cpp @@ -0,0 +1,32 @@ +string toGoatLatin(string S) { + int len = S.size(); + if (len == 0) + return S; + + string res; + int i = 0, j = 1; + int pos = 0; + while ((pos = S.find(' ', i)) != string::npos) + { + string str = S.substr(i, pos-i); + if (isvowel(str[0])) + res += str + "ma" + string(j, 'a') + ' '; + else + res += str.substr(1) + str[0] + "ma" + string(j, 'a') + ' '; + ++j; + i = pos+1; + } + string str = S.substr(i); + if (isvowel(str[0])) + res += str + "ma" + string(j, 'a'); + else + res += str.substr(1) + str[0] + "ma" + string(j, 'a'); + + return res; + } + + bool isvowel(char c) + { + c = tolower(c); + return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'; + } \ No newline at end of file diff --git a/src/832.cpp b/src/832.cpp new file mode 100644 index 0000000..0322887 --- /dev/null +++ b/src/832.cpp @@ -0,0 +1,22 @@ +vector> flipAndInvertImage(vector>& A) { + int row = A.size(); + if (row == 0) + return A; + int col = A[0].size(); + for (int i = 0; i < row; ++i) + { + int lim = col/2; + for (int j = 0; j < lim; ++j) + { + if (A[i][j] == A[i][col-1-j]) + { + A[i][j] = 1 - A[i][j]; + A[i][col-1-j] = 1 - A[i][col-1-j]; + } + } + if (col%2 != 0) + A[i][lim] = 1 - A[i][lim]; + } + + return A; + } \ No newline at end of file diff --git a/src/844.cpp b/src/844.cpp new file mode 100644 index 0000000..b414c78 --- /dev/null +++ b/src/844.cpp @@ -0,0 +1,70 @@ +bool backspaceCompare(string S, string T) { + int len1 = S.size(); + int len2 = T.size(); + if (len1 == 0 && len2 == 0) + return true; + + string res1, res2; + int i = 0, j = 0; + while (i < len1 && S[i] == '#') + ++i; + while (j < len2 && T[j] == '#') + ++j; + if (i == len1 && j == len2) + return true; + else if (i == len1 && j != len2) + { + return isblank(T, j, len2); + } + else if (i != len1 && j == len2) + { + return isblank(S, i, len1); + } + else + { + string res1(len1-i, S[i]), res2(len2-j, T[j]); + ++i; + ++j; + int pos1 = 1, pos2 = 1; + while (i < len1) + { + if (isalpha(S[i])) + { + res1[pos1] = S[i]; + ++pos1; + } + else + { + if (pos1 > 0) + --pos1; + } + ++i; + } + while (j < len2) + { + if (isalpha(T[j])) + { + res2[pos2] = T[j]; + ++pos2; + } + else + { + if (pos2 > 0) + --pos2; + } + ++j; + } + return res1.substr(0, pos1) == res2.substr(0, pos2); + } + } + + bool isblank(const string& str, int pos, int len) + { + int ct = 0; + for (int i = pos; i < len; ++i) + if (isalpha(str[i])) + ++ct; + else if (ct > 0) + --ct; + return ct == 0; + } \ No newline at end of file diff --git a/src/852.cpp b/src/852.cpp new file mode 100644 index 0000000..f0efd3e --- /dev/null +++ b/src/852.cpp @@ -0,0 +1,22 @@ +int peakIndexInMountainArray(vector& A) { + int len = A.size(); + int p = 0, q = len-1; + while (p < q) + { + if (p == q-1) + { + if (A[p] > A[q]) + return p; + else + return q; + } + int mid = (p+q)/2; + if (A[mid] > A[mid-1] && A[mid] > A[mid+1]) + return mid; + else if (A[mid] < A[mid-1]) + q = mid-1; + else + p = mid+1; + } + return p; + } \ No newline at end of file From 4119a4155b3a90619b3d5b4ddcddd6cfa366a572 Mon Sep 17 00:00:00 2001 From: lintcoder Date: Sat, 15 Sep 2018 20:45:41 +0800 Subject: [PATCH 15/97] 7 problems solved. --- src/700.cpp | 17 +++++++++++++++++ src/709.cpp | 5 +++++ src/841.cpp | 30 ++++++++++++++++++++++++++++++ src/867.cpp | 17 +++++++++++++++++ src/872.cpp | 37 +++++++++++++++++++++++++++++++++++++ src/876.cpp | 22 ++++++++++++++++++++++ src/896.cpp | 20 ++++++++++++++++++++ 7 files changed, 148 insertions(+) create mode 100644 src/700.cpp create mode 100644 src/709.cpp create mode 100644 src/841.cpp create mode 100644 src/867.cpp create mode 100644 src/872.cpp create mode 100644 src/876.cpp create mode 100644 src/896.cpp diff --git a/src/700.cpp b/src/700.cpp new file mode 100644 index 0000000..dd86988 --- /dev/null +++ b/src/700.cpp @@ -0,0 +1,17 @@ +TreeNode* searchBST(TreeNode* root, int val) { + if (root == nullptr) + return root; + + TreeNode* node = root; + while (node != nullptr) + { + if (node->val == val) + return node; + else if (node->val < val) + node = node->right; + else + node = node->left; + } + + return nullptr; + } \ No newline at end of file diff --git a/src/709.cpp b/src/709.cpp new file mode 100644 index 0000000..e91d6a4 --- /dev/null +++ b/src/709.cpp @@ -0,0 +1,5 @@ +string toLowerCase(string str) { + transform(str.begin(), str.end(), str.begin(), ::tolower); + + return str; + } \ No newline at end of file diff --git a/src/841.cpp b/src/841.cpp new file mode 100644 index 0000000..c5b51e3 --- /dev/null +++ b/src/841.cpp @@ -0,0 +1,30 @@ +bool canVisitAllRooms(vector>& rooms) { + int N = rooms.size(); + if (N == 1) + return true; + + int* number = new int[N]; + memset(number, 0, N*sizeof(int)); + number[0] = 1; + int ct = 1; + + deque dq(rooms[0].begin(), rooms[0].end()); + + int len = dq.size(); + while (len != 0) + { + for (int i = 0; i < len; ++i) + { + if (number[dq[i]] == 0) + { + dq.insert(dq.end(), rooms[dq[i]].begin(), rooms[dq[i]].end()); + number[dq[i]] = 1; + ++ct; + } + } + dq.erase(dq.begin(), dq.begin() + len); + len = dq.size(); + } + delete []number; + return ct == N; + } \ No newline at end of file diff --git a/src/867.cpp b/src/867.cpp new file mode 100644 index 0000000..4337984 --- /dev/null +++ b/src/867.cpp @@ -0,0 +1,17 @@ +vector> transpose(vector>& A) { + int row = A.size(); + if (row == 0) + return A; + int col = A[0].size(); + + vector> res(col, vector(row, 0)); + for (int i = 0; i < row; ++i) + { + for (int j = 0; j < col; ++j) + { + res[j][i] = A[i][j]; + } + } + + return res; + } \ No newline at end of file diff --git a/src/872.cpp b/src/872.cpp new file mode 100644 index 0000000..c66e319 --- /dev/null +++ b/src/872.cpp @@ -0,0 +1,37 @@ +bool leafSimilar(TreeNode* root1, TreeNode* root2) { + if (root1 == nullptr && root2 == nullptr) + return true; + + if (root1 == nullptr || root2 == nullptr) + return false; + + vector leaf1, leaf2; + getLeaf(root1, leaf1); + getLeaf(root2, leaf2); + + int len1 = leaf1.size(); + int len2 = leaf2.size(); + if (len1 != len2) + return false; + + for (int i = 0; i < len1; ++i) + { + if (leaf1[i] != leaf2[i]) + return false; + } + + return true; + } + +void getLeaf(TreeNode* node, vector& vec) +{ + if (node->left == nullptr && node->right == nullptr) + vec.push_back(node->val); + else + { + if (node->left != nullptr) + getLeaf(node->left, vec); + if (node->right != nullptr) + getLeaf(node->right, vec); + } +} \ No newline at end of file diff --git a/src/876.cpp b/src/876.cpp new file mode 100644 index 0000000..aad922c --- /dev/null +++ b/src/876.cpp @@ -0,0 +1,22 @@ +ListNode* middleNode(ListNode* head) { + if (head == nullptr || head->next == nullptr) + return head; + + int len = 0; + ListNode* node = head; + while (node != nullptr) + { + node = node->next; + ++len; + } + int pos = len/2; + int i = 0; + node = head; + while (i != pos) + { + node = node->next; + ++i; + } + + return node; + } \ No newline at end of file diff --git a/src/896.cpp b/src/896.cpp new file mode 100644 index 0000000..e0e5d56 --- /dev/null +++ b/src/896.cpp @@ -0,0 +1,20 @@ +bool isMonotonic(vector& A) { + int len = A.size(); + if (len == 1) + return true; + + int pos = 1; + while (A[pos] == A[0]) + ++pos; + if (pos == len) + return true; + + bool flag = A[0] <= A[pos] ? true : false; + for (int i = pos; i < len-1; ++i) + { + if ((flag && A[i] > A[i+1]) || (!flag && A[i] < A[i+1])) + return false; + } + + return true; + } \ No newline at end of file From 317928932fc457db6565c470873f97515f7c6edb Mon Sep 17 00:00:00 2001 From: Troy Date: Thu, 22 Nov 2018 22:01:00 +0800 Subject: [PATCH 16/97] 5 problems solved. --- src/884.cpp | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ src/893.cpp | 28 ++++++++++++++++++++++++++++ src/905.cpp | 17 +++++++++++++++++ src/908.cpp | 9 +++++++++ src/929.cpp | 32 ++++++++++++++++++++++++++++++++ 5 files changed, 134 insertions(+) create mode 100644 src/884.cpp create mode 100644 src/893.cpp create mode 100644 src/905.cpp create mode 100644 src/908.cpp create mode 100644 src/929.cpp diff --git a/src/884.cpp b/src/884.cpp new file mode 100644 index 0000000..17e2f5d --- /dev/null +++ b/src/884.cpp @@ -0,0 +1,48 @@ +vector uncommonFromSentences(string A, string B) { + int len1 = A.size(); + int len2 = B.size(); + if (len1 == 0 && len2 == 0) + return {}; + + map mp; + string::size_type i = A.find_first_not_of(" "); + while (i != string::npos) + { + string::size_type pos = A.find(' ', i); + if (pos != string::npos) + { + mp[A.substr(i, pos-i)]++; + i = A.find_first_not_of(" ", pos+1); + } + else + { + mp[A.substr(i)]++; + break; + } + } + + i = B.find_first_not_of(" "); + while (i != string::npos) + { + string::size_type pos = B.find(' ', i); + if (pos != string::npos) + { + mp[B.substr(i, pos-i)]++; + i = B.find_first_not_of(" ", pos+1); + } + else + { + mp[B.substr(i)]++; + break; + } + } + + vector res; + for (auto& m : mp) + { + if (m.second == 1) + res.push_back(m.first); + } + + return res; + } \ No newline at end of file diff --git a/src/893.cpp b/src/893.cpp new file mode 100644 index 0000000..2c7b43a --- /dev/null +++ b/src/893.cpp @@ -0,0 +1,28 @@ +int numSpecialEquivGroups(vector& A) { + int len = A.size(); + vector> vec(len, vector(52, 0)); + for (int i = 0; i < len; ++i) + { + int sz = A[i].size(); + for (int j = 0; j < sz; ++j) + { + ++vec[i][j%2*26+A[i][j]-'a']; + } + } + + auto cmp = [](const vector& a, const vector& b) { + for (int i = 0; i < 52; ++i) + { + if (a[i] == b[i]) + continue; + else if (a[i] < b[i]) + return true; + else + return false; + } + return false; + }; + + sort(vec.begin(), vec.end(), cmp); + return unique(vec.begin(), vec.end()) - vec.begin(); + } \ No newline at end of file diff --git a/src/905.cpp b/src/905.cpp new file mode 100644 index 0000000..7746a20 --- /dev/null +++ b/src/905.cpp @@ -0,0 +1,17 @@ +vector sortArrayByParity(vector& A) { + int len = A.size(); + if (len <= 1) + return A; + int i = 0, j = len-1; + while (i < j) + { + while (i < j && A[i]%2 == 0) + ++i; + while (i < j && A[j]%2 == 1) + --j; + if (i < j) + swap(A[i], A[j]); + } + + return A; + } \ No newline at end of file diff --git a/src/908.cpp b/src/908.cpp new file mode 100644 index 0000000..1210f71 --- /dev/null +++ b/src/908.cpp @@ -0,0 +1,9 @@ +int smallestRangeI(vector& A, int K) { + int len = A.size(); + if (len <= 1) + return 0; + + sort(A.begin(), A.end()); + int diff = A[len-1] - A[0]; + return diff <= 2*K ? 0 : diff-2*K; + } \ No newline at end of file diff --git a/src/929.cpp b/src/929.cpp new file mode 100644 index 0000000..cd87fdb --- /dev/null +++ b/src/929.cpp @@ -0,0 +1,32 @@ +int numUniqueEmails(vector& emails) { + int len = emails.size(); + if (len <= 1) + return len; + + set uniqueEml; + for (int i = 0; i < len; ++i) + { + int sz = emails[i].size(); + string res(sz, ' '); + int j = 0, k = 0; + while (j < sz && emails[i][j] != '@') + { + if (emails[i][j] == '+') + break; + else if (emails[i][j] != '.') + res[k++] = emails[i][j]; + ++j; + } + while (emails[i][j] != '@') + ++j; + while (j < sz) + { + res[k] = emails[i][j]; + ++j; + ++k; + } + uniqueEml.insert(res.substr(0, k)); + } + + return uniqueEml.size(); + } \ No newline at end of file From 65fedc39abd9d9b71b9e356f8cd64c01537a88f2 Mon Sep 17 00:00:00 2001 From: Troy Date: Fri, 23 Nov 2018 22:29:12 +0800 Subject: [PATCH 17/97] 5 problems solved. --- src/225.cpp | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ src/434.cpp | 13 +++++++++++++ src/67.cpp | 39 +++++++++++++++++++++++++++++++++++++++ src/917.cpp | 20 ++++++++++++++++++++ src/942.cpp | 26 ++++++++++++++++++++++++++ 5 files changed, 147 insertions(+) create mode 100644 src/225.cpp create mode 100644 src/434.cpp create mode 100644 src/67.cpp create mode 100644 src/917.cpp create mode 100644 src/942.cpp diff --git a/src/225.cpp b/src/225.cpp new file mode 100644 index 0000000..3b2c094 --- /dev/null +++ b/src/225.cpp @@ -0,0 +1,49 @@ +class Stack { + private: + deque dq[2]; + int flag = 0; + int topelem; + int size = 0; +public: + // Push element x onto stack. + void push(int x) { + dq[flag].push_back(x); + topelem = x; + ++size; + } + + // Removes the element on top of the stack. + void pop() { + if (size > 0) + { + int i = 1; + while (i < size - 1) + { + dq[1 - flag].push_back(dq[flag].front()); + dq[flag].pop_front(); + ++i; + } + if (i == size - 1) + { + int val = dq[flag].front(); + dq[1 - flag].push_back(val); + dq[flag].pop_front(); + topelem = val; + } + dq[flag].pop_front(); + + flag = 1 - flag; + --size; + } + } + + // Get the top element. + int top() { + return topelem; + } + + // Return whether the stack is empty. + bool empty() { + return size == 0; + } +}; \ No newline at end of file diff --git a/src/434.cpp b/src/434.cpp new file mode 100644 index 0000000..4dd76bb --- /dev/null +++ b/src/434.cpp @@ -0,0 +1,13 @@ +int countSegments(string s) { + int sz = s.size(); + int i = 0, ct = 0; + while (i < sz) + { + i = s.find_first_not_of(" \t\n", i); + if (i == string::npos) + break; + i = s.find_first_of(" \t\n", i + 1); + ++ct; + } + return ct; + } \ No newline at end of file diff --git a/src/67.cpp b/src/67.cpp new file mode 100644 index 0000000..15f3e37 --- /dev/null +++ b/src/67.cpp @@ -0,0 +1,39 @@ +string addBinary(string a, string b) { + int len1 = a.size(); + int len2 = b.size(); + + string res(len1 > len2 ? len1 + 1 : len2 + 1, '0'); + int i = len1 - 1, j = len2 - 1; + int ct = 0, k = res.size() - 1; + while (i >= 0 && j >= 0) + { + int sum = a[i] - '0' + b[j] - '0' + ct; + res[k] = sum % 2 + '0'; + --k; + --i; + --j; + ct = sum >> 1 ? 1 : 0; + } + while (i >= 0) + { + int sum = a[i] - '0' + ct; + res[k] = sum % 2 + '0'; + --k; + --i; + ct = sum >> 1 ? 1 : 0; + } + while (j >= 0) + { + int sum = b[j] - '0' + ct; + res[k] = sum % 2 + '0'; + --k; + --j; + ct = sum >> 1 ? 1 : 0; + } + if (ct > 0) + res[k] = ct + '0'; + if (res[0] == '0') + return string(res.begin() + 1, res.end()); + else + return res; + } \ No newline at end of file diff --git a/src/917.cpp b/src/917.cpp new file mode 100644 index 0000000..190b700 --- /dev/null +++ b/src/917.cpp @@ -0,0 +1,20 @@ +string reverseOnlyLetters(string S) + { + int len = S.size(); + int i = 0, j = len-1; + while (i < j) + { + while (i < j && isalpha(S[i]) == false) + ++i; + while (i < j && isalpha(S[j]) == false) + --j; + if (i < j) + { + std::swap(S[i], S[j]); + ++i; + --j; + } + } + + return S; + } \ No newline at end of file diff --git a/src/942.cpp b/src/942.cpp new file mode 100644 index 0000000..785ca03 --- /dev/null +++ b/src/942.cpp @@ -0,0 +1,26 @@ +vector diStringMatch(string S) { + int len = S.size()+1; + if (len <= 1) + return {}; + + vector res(len, 0); + int k = len-2; + int i = len-1, j = 0; + while (k >= 0) + { + if (S[k] == 'I') + { + res[k+1] = i; + --i; + } + else + { + res[k+1] = j; + ++j; + } + --k; + } + res[0] = i; + + return res; + } \ No newline at end of file From 30bf4bcb2d4525f93f56f44cfc24b45ef3cc2c99 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 24 Nov 2018 20:16:50 +0800 Subject: [PATCH 18/97] 15 problems solved. --- src/1.cpp | 43 +++++++++++++++++++++++++++++++++++++++++++ src/110.cpp | 15 +++++++++++++++ src/119.cpp | 21 +++++++++++++++++++++ src/198.cpp | 29 +++++++++++++++++++++++++++++ src/232.cpp | 39 +++++++++++++++++++++++++++++++++++++++ src/263.cpp | 21 +++++++++++++++++++++ src/342.cpp | 3 +++ src/345.cpp | 27 +++++++++++++++++++++++++++ src/35.cpp | 3 +++ src/367.cpp | 15 +++++++++++++++ src/437.cpp | 30 ++++++++++++++++++++++++++++++ src/572.cpp | 28 ++++++++++++++++++++++++++++ src/645.cpp | 21 +++++++++++++++++++++ src/66.cpp | 21 +++++++++++++++++++++ src/83.cpp | 26 ++++++++++++++++++++++++++ 15 files changed, 342 insertions(+) create mode 100644 src/1.cpp create mode 100644 src/110.cpp create mode 100644 src/119.cpp create mode 100644 src/198.cpp create mode 100644 src/232.cpp create mode 100644 src/263.cpp create mode 100644 src/342.cpp create mode 100644 src/345.cpp create mode 100644 src/35.cpp create mode 100644 src/367.cpp create mode 100644 src/437.cpp create mode 100644 src/572.cpp create mode 100644 src/645.cpp create mode 100644 src/66.cpp create mode 100644 src/83.cpp diff --git a/src/1.cpp b/src/1.cpp new file mode 100644 index 0000000..fff2345 --- /dev/null +++ b/src/1.cpp @@ -0,0 +1,43 @@ +vector twoSum(vector& nums, int target) { + int len = nums.size(); + struct Elem + { + int val; + int pos; + Elem(int v, int p):val(v), pos(p){} + }; + auto cmp = [=](const Elem& a, const Elem& b) { + return a.val < b.val; + }; + auto binsearch = [=](const vector& vec, int p, int q, int v) { + while (p <= q) + { + int mid = (p + q) / 2; + if (vec[mid].val == v) + return vec[mid].pos; + else if (vec[mid].val < v) + p = mid + 1; + else + q = mid - 1; + } + return -1; + }; + + vector vec; + for (int i = 0; i < len; ++i) + vec.push_back(Elem(nums[i], i)); + + vector res; + sort(vec.begin(), vec.end(), cmp); + int pos = 0; + for (int i = 0; i < len; ++i) + { + if ((pos = binsearch(vec, i+1, len - 1, target - vec[i].val)) != -1) + { + res.push_back(vec[i].pos); + res.push_back(pos); + break; + } + } + return res; + } \ No newline at end of file diff --git a/src/110.cpp b/src/110.cpp new file mode 100644 index 0000000..aaa384a --- /dev/null +++ b/src/110.cpp @@ -0,0 +1,15 @@ +bool isBalanced(TreeNode* root) { + int depth = 0; + return doisBalanced(root, depth); + } + + bool doisBalanced(TreeNode* node, int& depth) + { + if (node == NULL) + return true; + int depth1 = depth, depth2 = depth; + if (!doisBalanced(node->left, depth1) || !doisBalanced(node->right, depth2) || abs(depth1 - depth2) > 1) + return false; + depth = depth1 > depth2 ? depth1 + 1 : depth2 + 1; + return true; + } \ No newline at end of file diff --git a/src/119.cpp b/src/119.cpp new file mode 100644 index 0000000..c2d8cff --- /dev/null +++ b/src/119.cpp @@ -0,0 +1,21 @@ +vector getRow(int rowIndex) { + if (rowIndex < 0) + return vector(); + vector res[2]; + res[0].resize(rowIndex + 1); + res[1].resize(rowIndex + 1); + res[0][0] = res[0][rowIndex] = 1; + + int i = 1; + int pos = 0; + while (i <= rowIndex) + { + pos = 1 - i % 2; + res[pos][0] = 1; + for (int j = 0; j < i - 1; ++j) + res[pos][j + 1] = res[1 - pos][j] + res[1 - pos][j + 1]; + res[pos][i] = 1; + ++i; + } + return res[pos]; + } \ No newline at end of file diff --git a/src/198.cpp b/src/198.cpp new file mode 100644 index 0000000..aabe156 --- /dev/null +++ b/src/198.cpp @@ -0,0 +1,29 @@ +int rob(vector& nums) { + int sz = nums.size(); + if (sz <= 0) + return 0; + vector> subsum(sz, vector(sz, -1)); + return collectmoney(nums, 0, sz - 1, subsum); + } + + int collectmoney(const vector& money, int p, int q, vector>& subsum) + { + if(subsum[p][q] != -1) + return subsum[p][q]; + if (p == q - 1) + { + subsum[p][q] = money[p] > money[q] ? money[p] : money[q]; + } + else if (p == q) + { + subsum[p][q] = money[p]; + } + else + { + int sum1 = money[p] + collectmoney(money, p + 2, q, subsum); + int sum2 = collectmoney(money, p + 1, q, subsum); + subsum[p][q] = sum1 > sum2 ? sum1 : sum2; + } + + return subsum[p][q]; + } \ No newline at end of file diff --git a/src/232.cpp b/src/232.cpp new file mode 100644 index 0000000..ca9f5b7 --- /dev/null +++ b/src/232.cpp @@ -0,0 +1,39 @@ +class Queue { +public: + // Push element x to the back of queue. + stack first, second; + void push(int x) { + first.push(x); + } + + // Removes the element from in front of queue. + void pop(void) { + if (second.empty()) + { + while (!first.empty()) + { + second.push(first.top()); + first.pop(); + } + } + second.pop(); + } + + // Get the front element. + int peek(void) { + if (second.empty()) + { + while (!first.empty()) + { + second.push(first.top()); + first.pop(); + } + } + return second.top(); + } + + // Return whether the queue is empty. + bool empty(void) { + return first.empty() && second.empty(); + } +}; \ No newline at end of file diff --git a/src/263.cpp b/src/263.cpp new file mode 100644 index 0000000..30d9cdf --- /dev/null +++ b/src/263.cpp @@ -0,0 +1,21 @@ +bool isUgly(int num) { + if (num <= 0) + return false; + if (num == 1) + return true; + else + { + while (num > 1) + { + if (num % 2 == 0) + num /= 2; + else if (num % 3 == 0) + num /= 3; + else if (num % 5 == 0) + num /= 5; + else + return false; + } + return true; + } + } \ No newline at end of file diff --git a/src/342.cpp b/src/342.cpp new file mode 100644 index 0000000..b95ee51 --- /dev/null +++ b/src/342.cpp @@ -0,0 +1,3 @@ +bool isPowerOfFour(int num) { + return (num & (num - 1)) == 0 && (num & 0x55555555) != 0; + } \ No newline at end of file diff --git a/src/345.cpp b/src/345.cpp new file mode 100644 index 0000000..7d7222c --- /dev/null +++ b/src/345.cpp @@ -0,0 +1,27 @@ +string reverseVowels(string s) { + int sz = s.size(); + int i = 0, j = sz - 1; + while (i < j) + { + while (i < j && !isvowel(s[i])) + ++i; + while (i < j && !isvowel(s[j])) + --j; + if (i < j) + { + char tmp = s[i]; + s[i] = s[j]; + s[j] = tmp; + ++i; + --j; + } + } + + return s; + } + + bool isvowel(char c) + { + c = tolower(c); + return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'; + } \ No newline at end of file diff --git a/src/35.cpp b/src/35.cpp new file mode 100644 index 0000000..f41b106 --- /dev/null +++ b/src/35.cpp @@ -0,0 +1,3 @@ +int searchInsert(vector& nums, int target) { + return lower_bound(nums.begin(), nums.end(), target) - nums.begin(); + } \ No newline at end of file diff --git a/src/367.cpp b/src/367.cpp new file mode 100644 index 0000000..95b8f38 --- /dev/null +++ b/src/367.cpp @@ -0,0 +1,15 @@ +bool isPerfectSquare(int num) { + int i = 1, j = num; + while (i <= j) + { + long long mid = i / 2 + j / 2 + (i % 2 && j % 2); + long long res = mid * mid; + if (res == num) + return true; + else if (res < num) + i = mid + 1; + else + j = mid - 1; + } + return false; + } \ No newline at end of file diff --git a/src/437.cpp b/src/437.cpp new file mode 100644 index 0000000..8fa6c04 --- /dev/null +++ b/src/437.cpp @@ -0,0 +1,30 @@ +int pathSum(TreeNode* root, int sum) { + if (root == NULL) + return 0; + vector sum_vec; + sum_vec.push_back(root->val); + int total = root->val == sum ? 1 : 0; + return total + dopathSum(root->left, sum_vec, sum) + dopathSum(root->right, sum_vec, sum); + } + + int dopathSum(TreeNode* node, const vector& vec, int sum) + { + if (node == NULL) + return 0; + else + { + int total = 0; + vector sum_vec(vec); + int len = sum_vec.size(); + for (int i = 0; i < len; ++i) + { + sum_vec[i] = sum_vec[i] + node->val; + if (sum_vec[i] == sum) + ++total; + } + sum_vec.push_back(node->val); + if (node->val == sum) + ++total; + return total + dopathSum(node->left, sum_vec, sum) + dopathSum(node->right, sum_vec, sum); + } + } \ No newline at end of file diff --git a/src/572.cpp b/src/572.cpp new file mode 100644 index 0000000..f9c739d --- /dev/null +++ b/src/572.cpp @@ -0,0 +1,28 @@ +bool isSubtree(TreeNode* s, TreeNode* t) { + return doisSubtree(s, t, false); + } + + bool doisSubtree(TreeNode* s, TreeNode* t, bool status) { + if (s == nullptr && t == nullptr) + return true; + else if (s == nullptr && t != nullptr) + return false; + else if (s != nullptr && t == nullptr) + return false; + else + { + bool flag = false; + if (s->val == t->val) + { + flag = doisSubtree(s->left, t->left, true) && doisSubtree(s->right, t->right, true); + if (flag) + return true; + } + if (status) + return false; + if (doisSubtree(s->left, t, false)) + return true; + else + return doisSubtree(s->right, t, false); + } + } \ No newline at end of file diff --git a/src/645.cpp b/src/645.cpp new file mode 100644 index 0000000..57042a2 --- /dev/null +++ b/src/645.cpp @@ -0,0 +1,21 @@ +vector findErrorNums(vector& nums) { + vector res(2, 0); + int len = nums.size(); + if (len <= 1) + return res; + vector flag(len, 1); + for (int i = 0; i < len; ++i) + { + if (flag[nums[i] - 1] == 1) + flag[nums[i] - 1] = 0; + else + res[0] = nums[i]; + } + for (int i = 0; i < len; ++i) + if (flag[i] == 1) + { + res[1] = i+1; + break; + } + return res; + } \ No newline at end of file diff --git a/src/66.cpp b/src/66.cpp new file mode 100644 index 0000000..e34a97b --- /dev/null +++ b/src/66.cpp @@ -0,0 +1,21 @@ +vector plusOne(vector& digits) { + int sz = digits.size(); + vector res(sz + 1, 0); + int cnt = 1; + for (int i = sz - 1; i >= 0; --i) + { + if (cnt != 0) + { + int sum = digits[i] + cnt; + res[i + 1] = sum % 10; + cnt =sum / 10; + } + else + res[i + 1] = digits[i]; + } + res[0] = cnt; + if (res[0] != 0) + return res; + else + return vector(res.begin() + 1, res.end()); + } \ No newline at end of file diff --git a/src/83.cpp b/src/83.cpp new file mode 100644 index 0000000..0c0d107 --- /dev/null +++ b/src/83.cpp @@ -0,0 +1,26 @@ +ListNode* deleteDuplicates(ListNode* head) { + if (head == NULL || head->next == NULL) + return head; + ListNode* h = head; + int key = h->val; + ListNode* p = h->next; + ListNode* q = h; + while (p != NULL) + { + while (p != NULL && p->val == key) + { + ListNode* k = p->next; + delete p; + p = k; + } + q->next = p; + q = p; + if (p != NULL) + { + key = p->val; + p = p->next; + } + } + + return h; + } \ No newline at end of file From fd8348dd20970319e6d330ccbf8fba316e3c3605 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 25 Nov 2018 20:48:17 +0800 Subject: [PATCH 19/97] 10 problems solved. --- src/111.cpp | 16 ++++++++++++++++ src/172.cpp | 10 ++++++++++ src/20.cpp | 18 ++++++++++++++++++ src/205.cpp | 26 ++++++++++++++++++++++++++ src/26.cpp | 21 +++++++++++++++++++++ src/374.cpp | 15 +++++++++++++++ src/38.cpp | 37 +++++++++++++++++++++++++++++++++++++ src/729.cpp | 29 +++++++++++++++++++++++++++++ src/849.cpp | 42 ++++++++++++++++++++++++++++++++++++++++++ src/937.cpp | 26 ++++++++++++++++++++++++++ 10 files changed, 240 insertions(+) create mode 100644 src/111.cpp create mode 100644 src/172.cpp create mode 100644 src/20.cpp create mode 100644 src/205.cpp create mode 100644 src/26.cpp create mode 100644 src/374.cpp create mode 100644 src/38.cpp create mode 100644 src/729.cpp create mode 100644 src/849.cpp create mode 100644 src/937.cpp diff --git a/src/111.cpp b/src/111.cpp new file mode 100644 index 0000000..d551379 --- /dev/null +++ b/src/111.cpp @@ -0,0 +1,16 @@ +int minDepth(TreeNode* root) { + if (root == NULL) + return 0; + if (root->left == NULL && root->right == NULL) + return 1; + else if (root->left != NULL && root->right == NULL) + return 1 + minDepth(root->left); + else if (root->left == NULL && root->right != NULL) + return 1 + minDepth(root->right); + else + { + int ldepth = minDepth(root->left); + int rdepth = minDepth(root->right); + return ldepth < rdepth ? ldepth + 1 : rdepth + 1; + } + } \ No newline at end of file diff --git a/src/172.cpp b/src/172.cpp new file mode 100644 index 0000000..e93057a --- /dev/null +++ b/src/172.cpp @@ -0,0 +1,10 @@ +int trailingZeroes(int n) { + int sum = 0; + while (n >= 5) + { + sum += n / 5; + n /= 5; + } + + return sum; + } \ No newline at end of file diff --git a/src/20.cpp b/src/20.cpp new file mode 100644 index 0000000..4cdea78 --- /dev/null +++ b/src/20.cpp @@ -0,0 +1,18 @@ +bool isValid(string s) { + int sz = s.size(); + if (sz % 2 == 1) + return false; + stack stk; + for (int i = 0; i != sz; ++i) + { + if (s[i] == '(' || s[i] == '[' || s[i] == '{') + stk.push(s[i]); + else + { + if (stk.empty() || ((s[i] == ')' && stk.top() != '(') || (s[i] == ']' && stk.top() != '[') || (s[i] == '}' && stk.top() != '{'))) + return false; + stk.pop(); + } + } + return stk.empty(); + } \ No newline at end of file diff --git a/src/205.cpp b/src/205.cpp new file mode 100644 index 0000000..aa85a74 --- /dev/null +++ b/src/205.cpp @@ -0,0 +1,26 @@ +bool isIsomorphic(string s, string t) { + map dict; + set st; + int sz = s.size(); + + for (int i = 0; i != sz; ++i) + { + map::iterator miter = dict.find(s[i]); + set::iterator siter = st.find(t[i]); + + if (miter == dict.end() && siter == st.end()) + { + dict[s[i]] = t[i]; + st.insert(t[i]); + } + else if (miter != dict.end() && siter != st.end()) + { + if (dict[s[i]] != t[i]) + return false; + } + else + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/26.cpp b/src/26.cpp new file mode 100644 index 0000000..1591912 --- /dev/null +++ b/src/26.cpp @@ -0,0 +1,21 @@ +int removeDuplicates(vector& nums) { + int sz = nums.size(); + if (sz <= 1) + return sz; + int val = nums[0]; + int i = 1, pos = 1, cnt = 1; + while (i < sz) + { + if (nums[i] == val) + ++i; + else + { + nums[pos] = nums[i]; + val = nums[i]; + pos++; + cnt++; + ++i; + } + } + return cnt; + } \ No newline at end of file diff --git a/src/374.cpp b/src/374.cpp new file mode 100644 index 0000000..44921cb --- /dev/null +++ b/src/374.cpp @@ -0,0 +1,15 @@ +int guessNumber(int n) { + int p = 1, q = n; + while (p < q) + { + int mid = p / 2 + q / 2; + int res = guess(mid); + if (res == 0) + return mid; + else if (res < 0) + q = mid - 1; + else + p = mid + 1; + } + return p; + } \ No newline at end of file diff --git a/src/38.cpp b/src/38.cpp new file mode 100644 index 0000000..d16301e --- /dev/null +++ b/src/38.cpp @@ -0,0 +1,37 @@ +string countAndSay(int n) { + if (n <= 0) + return ""; + deque dq; + dq.push_back(1); + + int i = 1; + while (i < n) + { + int len = dq.size(); + int ct = 1, num = dq.at(0); + for (int j = 1; j < len; ++j) + { + int val = dq.at(j); + if (val == num) + ++ct; + else + { + dq.push_back(ct); + dq.push_back(num); + num = val; + ct = 1; + } + } + dq.push_back(ct); + dq.push_back(num); + dq.erase(dq.begin(), dq.begin() + len); + ++i; + } + + int sz = dq.size(); + string res(sz + 1, '\0'); + for (int j = 0; j < sz; ++j) + res[j] = dq.at(j) + '0'; + + return res; + } \ No newline at end of file diff --git a/src/729.cpp b/src/729.cpp new file mode 100644 index 0000000..a5663e2 --- /dev/null +++ b/src/729.cpp @@ -0,0 +1,29 @@ +class MyCalendar { +public: + MyCalendar() { + + } + + bool book(int start, int end) { + auto iter = lower_bound(interval_begin.begin(), interval_begin.end(), end); + if (iter == interval_begin.begin()) + { + interval_begin.insert(interval_begin.begin(), start); + interval_end.insert(interval_end.begin(), end); + return true; + } + else + { + int pos = iter-interval_begin.begin()-1; + if (start < interval_end[pos]) + return false; + interval_begin.insert(iter, start); + interval_end.insert(interval_end.begin()+pos+1, end); + return true; + } + } + +private: + vector interval_begin; + vector interval_end; +}; \ No newline at end of file diff --git a/src/849.cpp b/src/849.cpp new file mode 100644 index 0000000..c83bd03 --- /dev/null +++ b/src/849.cpp @@ -0,0 +1,42 @@ +int maxDistToClosest(vector& seats) { + int len = seats.size(); + if (len == 1) + return 0; + + int maxDist = 0; + int maxInterval = 0, interval = 0; + int pos = 0, i = 0; + if (seats[0] == 0) + { + while (i < len && seats[i] == 0) + ++i; + maxDist = i; + } + pos = i; + ++i; + while (i < len) + { + if (seats[i] == 1) + { + interval = i - pos - 1; + pos = i; + if (interval > maxInterval) + { + maxInterval = interval; + } + } + ++i; + } + interval = len-1-pos; + if (interval > maxDist) + maxDist = interval; + + if (maxInterval > 0) + { + maxInterval = maxInterval%2 == 0 ? maxInterval/2 : maxInterval/2 + 1; + if (maxInterval > maxDist) + maxDist = maxInterval; + } + + return maxDist; + } \ No newline at end of file diff --git a/src/937.cpp b/src/937.cpp new file mode 100644 index 0000000..39c1ab7 --- /dev/null +++ b/src/937.cpp @@ -0,0 +1,26 @@ +vector reorderLogFiles(vector& logs) { + int len = logs.size(); + if (len <= 1) + return logs; + + map letter; + for (int i = 0; i < len; ++i) + { + int index = logs[i].find(' ') + 1; + letter[logs[i]] = logs[i].substr(index); + } + + auto cmp = [=](string& a, string& b) { + char c1 = letter[a][0]; + char c2 = letter[b][0]; + if (isdigit(c2)) + return true; + else if (isdigit(c1)) + return false; + else + return letter[a] < letter[b]; + }; + + sort(logs.begin(), logs.end(), cmp); + return logs; + } \ No newline at end of file From 34a48bacd1346720338539e12c2c38f223194bb8 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 2 Dec 2018 21:03:21 +0800 Subject: [PATCH 20/97] 3 problems solved. --- src/199.cpp | 3 +++ src/860.cpp | 44 ++++++++++++++++++++++++++++++++++++++++++++ src/888.cpp | 39 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 86 insertions(+) create mode 100644 src/199.cpp create mode 100644 src/860.cpp create mode 100644 src/888.cpp diff --git a/src/199.cpp b/src/199.cpp new file mode 100644 index 0000000..0b59094 --- /dev/null +++ b/src/199.cpp @@ -0,0 +1,3 @@ +vector rightSideView(TreeNode* root) { + + } \ No newline at end of file diff --git a/src/860.cpp b/src/860.cpp new file mode 100644 index 0000000..c6cc93e --- /dev/null +++ b/src/860.cpp @@ -0,0 +1,44 @@ +bool lemonadeChange(vector& bills) { + int len = bills.size(); + if (len == 0) + return true; + else if (len == 1) + return bills[0] == 5; + + int change[3] = {0}; + int i = 0; + while (i < len) + { + if (bills[i] == 5) + ++change[0]; + else if (bills[i] == 10) + { + if (change[0] > 0) + { + --change[0]; + ++change[1]; + } + else + return false; + } + else + { + if (change[0] > 0 && change[1] > 0) + { + --change[0]; + --change[1]; + ++change[2]; + } + else if (change[0] >= 3) + { + change[0] -= 3; + ++change[2]; + } + else + return false; + } + ++i; + } + + return true; + } \ No newline at end of file diff --git a/src/888.cpp b/src/888.cpp new file mode 100644 index 0000000..5f030b1 --- /dev/null +++ b/src/888.cpp @@ -0,0 +1,39 @@ +vector fairCandySwap(vector& A, vector& B) { + int len1 = A.size(); + int len2 = B.size(); + if (len1 == 1 && len2 == 1) + return {A[0], B[0]}; + + vector res(2, 0); + int arr1[100001] = {0}; + int arr2[100001] = {0}; + int sum1 = 0, sum2 = 0; + + for (int i = 0; i < len1; ++i) + { + sum1 += A[i]; + ++arr1[A[i]]; + } + for (int i = 0; i < len2; ++i) + { + sum2 += B[i]; + ++arr2[B[i]]; + } + + int diff = (sum1 - sum2)/2; + int i = 0; + int k = 0; + while (i < len1) + { + if (diff < 0 && A[i]-diff <= 100000 && B[A[i]-diff] != 0) + break; + else if (diff > 0 && A[i] > diff && B[A[i]-diff] != 0) + break; + ++i; + } + + res[0] = A[i]; + res[1] = A[i]-diff; + + return res; + } \ No newline at end of file From 59f2caf1803f2b9abc41ca9884d24bf07bbdadf6 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 8 Dec 2018 15:57:05 +0800 Subject: [PATCH 21/97] 3 problems solved. --- src/704.cpp | 19 +++++++++++++++++++ src/724.cpp | 32 ++++++++++++++++++++++++++++++++ src/859.cpp | 46 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 97 insertions(+) create mode 100644 src/704.cpp create mode 100644 src/724.cpp create mode 100644 src/859.cpp diff --git a/src/704.cpp b/src/704.cpp new file mode 100644 index 0000000..e9386c4 --- /dev/null +++ b/src/704.cpp @@ -0,0 +1,19 @@ +int search(vector& nums, int target) { + int len = nums.size(); + int i = 0, j = len-1; + while (i < j) + { + int mid = (i+j)/2; + if (nums[mid] == target) + return mid; + else if (nums[mid] < target) + i = mid+1; + else + j = mid-1; + } + + if (nums[i] == target) + return i; + else + return -1; + } \ No newline at end of file diff --git a/src/724.cpp b/src/724.cpp new file mode 100644 index 0000000..2e68189 --- /dev/null +++ b/src/724.cpp @@ -0,0 +1,32 @@ +int pivotIndex(vector& nums) { + int len = nums.size(); + if (len <= 1) + return len-1; + if (len == 2) + { + if (nums[1] == 0) + return 0; + else if (nums[0] == 0) + return 1; + else + return -1; + } + + vector subsum(len, 0); + int sum = 0; + for (int i = 0; i < len; ++i) + { + sum += nums[i]; + subsum[i] = sum; + } + + if (sum-nums[0] == 0) + return 0; + for (int i = 0; i < len-1; ++i) + { + if (subsum[i] == sum-subsum[i+1]) + return i+1; + } + + return -1; + } \ No newline at end of file diff --git a/src/859.cpp b/src/859.cpp new file mode 100644 index 0000000..9e989d9 --- /dev/null +++ b/src/859.cpp @@ -0,0 +1,46 @@ +bool buddyStrings(string A, string B) { + int len1 = A.size(); + int len2 = B.size(); + if (len1 != len2) + return false; + if (len1 < 2) + return false; + if (A == B) + { + array arr = {0}; + if (len1 > 26) + return true; + for (int i = 0; i < len1; ++i) + { + arr[A[i]-'a']++; + if (arr[A[i]-'a'] > 1) + return true; + } + return false; + } + char a, b; + int ct = 0; + for (int i = 0; i < len1; ++i) + { + if (A[i] != B[i]) + { + if (ct == 0) + { + a = A[i]; + b = B[i]; + ++ct; + } + else if (ct == 1) + { + if (a != B[i] || b != A[i]) + return false; + else + ++ct; + } + else + return false; + } + } + + return true; + } \ No newline at end of file From 492433da5a583ecf89e4c16c0a47fd0317d4c38d Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 3 Feb 2019 11:56:50 +0800 Subject: [PATCH 22/97] 5 problems solved. --- src/509.cpp | 14 +++++++ src/707.cpp | 113 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/953.cpp | 37 +++++++++++++++++ src/977.cpp | 9 +++++ src/985.cpp | 47 ++++++++++++++++++++++ 5 files changed, 220 insertions(+) create mode 100644 src/509.cpp create mode 100644 src/707.cpp create mode 100644 src/953.cpp create mode 100644 src/977.cpp create mode 100644 src/985.cpp diff --git a/src/509.cpp b/src/509.cpp new file mode 100644 index 0000000..a2b5ca5 --- /dev/null +++ b/src/509.cpp @@ -0,0 +1,14 @@ +int fib(int N) { + if (N <= 1) + return N; + int a = 0, b = 1; + int i = 2; + while (i <= N) + { + int t = a+b; + a = b; + b = t; + ++i; + } + return b; + } \ No newline at end of file diff --git a/src/707.cpp b/src/707.cpp new file mode 100644 index 0000000..dbadd04 --- /dev/null +++ b/src/707.cpp @@ -0,0 +1,113 @@ +class MyLinkedList { +public: + /** Initialize your data structure here. */ + MyLinkedList() { + } + + /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */ + int get(int index) { + if (index >= len) + return -1; + Node* node = head; + int i = 0; + while (node != nullptr && i != index) + { + node = node->next; + ++i; + } + return node->val; + } + + /** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */ + void addAtHead(int val) { + Node* tmp = new Node(val); + tmp->next = head; + head = tmp; + ++len; + if (len == 1) + tail = head; + } + + /** Append a node of value val to the last element of the linked list. */ + void addAtTail(int val) { + Node* node = new Node(val); + if (tail == nullptr) + { + head = node; + tail = node; + } + else + { + tail->next = node; + tail = node; + } + ++len; + } + + /** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */ + void addAtIndex(int index, int val) { + if (index > len) + return; + else if (index == len) + addAtTail(val); + else if (index == 0) + addAtHead(val); + else + { + Node* node = new Node(val); + Node* tmp = head; + Node* k = head->next; + int i = 1; + while (i < index) + { + tmp = k; + k = tmp->next; + ++i; + } + tmp->next = node; + node->next = k; + ++len; + } + } + + /** Delete the index-th node in the linked list, if the index is valid. */ + void deleteAtIndex(int index) { + if (index >= len || index < 0) + return; + if (index == 0) + { + Node* node = head; + head = head->next; + delete node; + --len; + } + else + { + Node* tmp = head; + Node* k = head->next; + int i = 1; + while (i < index) + { + tmp = k; + k = tmp->next; + ++i; + } + tmp->next = k->next; + delete k; + if (tmp->next == nullptr) + tail = tmp; + --len; + } + } +private: + struct Node + { + int val; + Node* next; + Node(int v):val(v){next = nullptr;} + }; + + Node* head = nullptr; + Node* tail = nullptr; + int len = 0; +}; diff --git a/src/953.cpp b/src/953.cpp new file mode 100644 index 0000000..3d0c82d --- /dev/null +++ b/src/953.cpp @@ -0,0 +1,37 @@ +bool isAlienSorted(vector& words, string order) { + int len = words.size(); + if (len == 1) + return true; + + map dict; + for (int i = 0; i < 26; ++i) + dict[order[i]] = i; + + auto cmp = [&](const string& a, const string& b) { + if (a == b) + return true; + int sz1 = a.size(); + int sz2 = b.size(); + int lim = sz1 < sz2 ? sz1 : sz2; + int i = 0; + while (i < lim) + { + if (dict[a[i]] < dict[b[i]]) + return true; + else if (dict[a[i]] > dict[b[i]]) + return false; + else + ++i; + } + + return sz1 <= sz2; + }; + + for (int i = 0; i < len-1; ++i) + { + if (!cmp(words[i], words[i+1])) + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/977.cpp b/src/977.cpp new file mode 100644 index 0000000..694d787 --- /dev/null +++ b/src/977.cpp @@ -0,0 +1,9 @@ +vector sortedSquares(vector& A) { + auto cmp = [](int a, int b) { + return abs(a) < abs(b); + }; + + sort(A.begin(), A.end(), cmp); + transform(A.begin(), A.end(), A.begin(), [](int n) {return n*n;}); + return A; + } \ No newline at end of file diff --git a/src/985.cpp b/src/985.cpp new file mode 100644 index 0000000..b6d4c26 --- /dev/null +++ b/src/985.cpp @@ -0,0 +1,47 @@ +vector sumEvenAfterQueries(vector& A, vector>& queries) { + size_t len = A.size(); + vector flag(len, false); + vector res(len, 0); + + int sum = 0; + for (int i = 0; i < len; ++i) + { + if (A[i]%2 == 0) + { + flag[i] = true; + sum += A[i]; + } + } + + len = queries.size(); + for (int i = 0; i < len; ++i) + { + if (flag[queries[i][1]] == true && abs(queries[i][0])%2 == 0) + { + A[queries[i][1]] += queries[i][0]; + sum += queries[i][0]; + res[i] = sum; + } + else if (flag[queries[i][1]] == true && abs(queries[i][0])%2 == 1) + { + sum -= A[queries[i][1]]; + A[queries[i][1]] += queries[i][0]; + res[i] = sum; + flag[queries[i][1]] = false; + } + else if (flag[queries[i][1]] == false && abs(queries[i][0])%2 == 0) + { + A[queries[i][1]] += queries[i][0]; + res[i] = sum; + } + else + { + A[queries[i][1]] += queries[i][0]; + sum += A[queries[i][1]]; + res[i] = sum; + flag[queries[i][1]] = true; + } + } + + return res; + } \ No newline at end of file From 7c638f609931cb34843005172177d66d82ace39a Mon Sep 17 00:00:00 2001 From: lintcoder Date: Sun, 17 Feb 2019 21:31:59 +0800 Subject: [PATCH 23/97] temporary commit --- resize.cpp | 108 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 resize.cpp diff --git a/resize.cpp b/resize.cpp new file mode 100644 index 0000000..6e614fd --- /dev/null +++ b/resize.cpp @@ -0,0 +1,108 @@ +#include +#include + +using std::cout; +using std::endl; + +inline double bilinear_filter(double x) +{ + if (x < 0.0) + x = -x; + if (x < 1.0) + return 1.0 - x; + return 0.0; +} + +int precompute_coeffs(int inSize, int outSize, int** boundsp, double** kkp) +{ + double filterscale = (double)inSize / outSize; + double scale = filterscale; + if (filterscale < 1.0) + filterscale = 1.0; + double support = 1.0 * filterscale; + int ksize = (int)ceil(support) * 2 + 1; + + double* kk = (double*)malloc(outSize * ksize * sizeof(double)); + int* bounds = (int*)malloc(outSize * 2* sizeof(int)); + double center = 0, ww = 0, ss = 0; + int xmin = 0, xmax = 0; + + for (int i = 0; i < outSize; ++i) + { + center = (i + 0.5) * scale; + ww = 0.0; + ss = 1.0 / filterscale; + + xmin = (int) (center - support + 0.5); + if (xmin < 0) + xmin = 0; + xmax = (int) (center + support + 0.5); + if (xmax > inSize) + xmax = inSize; + xmax -= xmin; + double* k = &kk[i * ksize]; + for (int j = 0; j < xmax; ++j) + { + double w = bilinear_filter((j + xmin - center + 0.5) * ss); + k[j] = w; + ww += w; + } + for (int j = 0; j < xmax; ++j) + { + if (ww != 0.0) + k[j] /= ww; + } + for (int j = xmax; j < ksize; ++j) + k[j] = 0; + bounds[i*2] = xmin; + bounds[i*2 + 1] = xmax; + } + *boundsp = bounds; + *kkp = kk; + + return ksize; +} + +void resize(const unsigned char* srcImg, unsigned char* dstImg, int srcSize, int dstSize) +{ + int srcWidth = srcSize; + int srcHeight = srcSize; + int dstWidth = dstSize; + int dstHeight = dstSize; + + int* bounds_horiz = nullptr, *bounds_vert = nullptr; + double* kk_horiz = nullptr, *kk_vert = nullptr; + + int ksize_horiz = precompute_coeffs(srcWidth, dstWidth, &bounds_horiz, &kk_horiz); + int ksize_vert = precompute_coeffs(srcHeight, dstHeight, &bounds_vert, &kk_vert); + + cout << ksize_horiz << " " << ksize_vert << endl; + int ybox_first = bounds_vert[0]; + int ybox_last = bounds_vert[dstHeight*2 - 2] + bounds_vert[dstHeight*2 - 1]; + + cout << ybox_first << " " << ybox_last << endl; + + for (int i = 0; i < dstHeight; ++i) + { + bounds_vert[i*2] -= ybox_first; + } + + free(bounds_horiz); + free(bounds_vert); + free(kk_horiz); + free(kk_vert); +} + +int main() +{ + unsigned char* imgData = new unsigned char[200*200]; + unsigned char* resizeImg = new unsigned char[64]; + resize(imgData, resizeImg, 200, 64); + + delete[] imgData; + delete[] resizeImg; + + int k = (64*3+3) & -4; + cout << k << endl; + return 0; +} From 5623dad393932b50f4a3be3b7ce67cd24421f928 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 14 Apr 2019 07:45:46 +0800 Subject: [PATCH 24/97] 2 problems solved. --- src/1002.cpp | 33 +++++++++++++++++++++++++++++++++ src/933.cpp | 25 +++++++++++++++++++++++++ 2 files changed, 58 insertions(+) create mode 100644 src/1002.cpp create mode 100644 src/933.cpp diff --git a/src/1002.cpp b/src/1002.cpp new file mode 100644 index 0000000..082e53c --- /dev/null +++ b/src/1002.cpp @@ -0,0 +1,33 @@ +vector commonChars(vector& A) { + vector res; + int len = A.size(); + if (len == 1) + { + transform(A[0].begin(), A[0].end(), back_inserter(res), [](char c) {return string(1, c); }); + return res; + } + else + { + vector> vec(len, vector(26, 0)); + for (int i = 0; i < len; ++i) + { + int sz = A[i].size(); + for (int j = 0; j < sz; ++j) + vec[i][A[i][j] - 'a']++; + } + + for (int i = 0; i < 26; ++i) + { + int minval = vec[0][i]; + for (int j = 1; j < len; ++j) + { + if (vec[j][i] < minval) + minval = vec[j][i]; + } + if (minval > 0) + res.insert(res.end(), minval, string(1, 'a' + i)); + } + + return res; + } + } \ No newline at end of file diff --git a/src/933.cpp b/src/933.cpp new file mode 100644 index 0000000..ed5def1 --- /dev/null +++ b/src/933.cpp @@ -0,0 +1,25 @@ +class RecentCounter { +public: + RecentCounter() { + memset(calls, 0, sizeof(int)*10000); + pos = -1; + } + + int ping(int t) { + int i; + for (i = 0; i <= pos; ++i) + { + if (calls[i] >= t-3000 && calls[i] <= t) + { + break; + } + } + + calls[pos+1] = t; + ++pos; + return pos-i+1; + } + + int calls[10000]; + int pos; +}; \ No newline at end of file From c4b076bd0d93746350c612e0e74d20019537d2a6 Mon Sep 17 00:00:00 2001 From: lintcoder Date: Sun, 7 Jul 2019 20:59:19 +0800 Subject: [PATCH 25/97] delete useless file. --- resize.cpp | 108 ----------------------------------------------------- 1 file changed, 108 deletions(-) delete mode 100644 resize.cpp diff --git a/resize.cpp b/resize.cpp deleted file mode 100644 index 6e614fd..0000000 --- a/resize.cpp +++ /dev/null @@ -1,108 +0,0 @@ -#include -#include - -using std::cout; -using std::endl; - -inline double bilinear_filter(double x) -{ - if (x < 0.0) - x = -x; - if (x < 1.0) - return 1.0 - x; - return 0.0; -} - -int precompute_coeffs(int inSize, int outSize, int** boundsp, double** kkp) -{ - double filterscale = (double)inSize / outSize; - double scale = filterscale; - if (filterscale < 1.0) - filterscale = 1.0; - double support = 1.0 * filterscale; - int ksize = (int)ceil(support) * 2 + 1; - - double* kk = (double*)malloc(outSize * ksize * sizeof(double)); - int* bounds = (int*)malloc(outSize * 2* sizeof(int)); - double center = 0, ww = 0, ss = 0; - int xmin = 0, xmax = 0; - - for (int i = 0; i < outSize; ++i) - { - center = (i + 0.5) * scale; - ww = 0.0; - ss = 1.0 / filterscale; - - xmin = (int) (center - support + 0.5); - if (xmin < 0) - xmin = 0; - xmax = (int) (center + support + 0.5); - if (xmax > inSize) - xmax = inSize; - xmax -= xmin; - double* k = &kk[i * ksize]; - for (int j = 0; j < xmax; ++j) - { - double w = bilinear_filter((j + xmin - center + 0.5) * ss); - k[j] = w; - ww += w; - } - for (int j = 0; j < xmax; ++j) - { - if (ww != 0.0) - k[j] /= ww; - } - for (int j = xmax; j < ksize; ++j) - k[j] = 0; - bounds[i*2] = xmin; - bounds[i*2 + 1] = xmax; - } - *boundsp = bounds; - *kkp = kk; - - return ksize; -} - -void resize(const unsigned char* srcImg, unsigned char* dstImg, int srcSize, int dstSize) -{ - int srcWidth = srcSize; - int srcHeight = srcSize; - int dstWidth = dstSize; - int dstHeight = dstSize; - - int* bounds_horiz = nullptr, *bounds_vert = nullptr; - double* kk_horiz = nullptr, *kk_vert = nullptr; - - int ksize_horiz = precompute_coeffs(srcWidth, dstWidth, &bounds_horiz, &kk_horiz); - int ksize_vert = precompute_coeffs(srcHeight, dstHeight, &bounds_vert, &kk_vert); - - cout << ksize_horiz << " " << ksize_vert << endl; - int ybox_first = bounds_vert[0]; - int ybox_last = bounds_vert[dstHeight*2 - 2] + bounds_vert[dstHeight*2 - 1]; - - cout << ybox_first << " " << ybox_last << endl; - - for (int i = 0; i < dstHeight; ++i) - { - bounds_vert[i*2] -= ybox_first; - } - - free(bounds_horiz); - free(bounds_vert); - free(kk_horiz); - free(kk_vert); -} - -int main() -{ - unsigned char* imgData = new unsigned char[200*200]; - unsigned char* resizeImg = new unsigned char[64]; - resize(imgData, resizeImg, 200, 64); - - delete[] imgData; - delete[] resizeImg; - - int k = (64*3+3) & -4; - cout << k << endl; - return 0; -} From 27f87e2e4e70fe9a1a2f37be8958ca2fb651f19f Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 28 Dec 2019 18:49:40 +0800 Subject: [PATCH 26/97] 12 problems solved --- src/1046.cpp | 44 ++++++++++++++++++++++++++++++++++++++++++++ src/1078.cpp | 46 ++++++++++++++++++++++++++++++++++++++++++++++ src/1108.cpp | 20 ++++++++++++++++++++ src/1122.cpp | 31 +++++++++++++++++++++++++++++++ src/1185.cpp | 35 +++++++++++++++++++++++++++++++++++ src/1200.cpp | 26 ++++++++++++++++++++++++++ src/1221.cpp | 27 +++++++++++++++++++++++++++ src/1281.cpp | 11 +++++++++++ src/1290.cpp | 10 ++++++++++ src/1295.cpp | 17 +++++++++++++++++ src/938.cpp | 26 ++++++++++++++++++++++++++ src/961.cpp | 13 +++++++++++++ 12 files changed, 306 insertions(+) create mode 100644 src/1046.cpp create mode 100644 src/1078.cpp create mode 100644 src/1108.cpp create mode 100644 src/1122.cpp create mode 100644 src/1185.cpp create mode 100644 src/1200.cpp create mode 100644 src/1221.cpp create mode 100644 src/1281.cpp create mode 100644 src/1290.cpp create mode 100644 src/1295.cpp create mode 100644 src/938.cpp create mode 100644 src/961.cpp diff --git a/src/1046.cpp b/src/1046.cpp new file mode 100644 index 0000000..ab6d547 --- /dev/null +++ b/src/1046.cpp @@ -0,0 +1,44 @@ +int lastStoneWeight(vector& stones) { + int sz = stones.size(); + if (sz == 1) + return stones[0]; + if (sz == 2) + return abs(stones[0] - stones[1]); + + sort(stones.rbegin(), stones.rend()); + int ct = sz; + int i = 0, j = 0; + int tmp = 0; + while (ct > 1) + { + tmp = stones[i]-stones[i+1]; + if (tmp == 0) + { + ct -= 2; + i += 2; + } + else + { + j = i+2; + int k = ct - 2; + while (k > 0 && stones[j] > tmp) + { + stones[j-1] = stones[j]; + --k; + ++j; + } + stones[j-1] = tmp; + ct--; + i++; + } + } + if (ct == 0) + return 0; + else + { + if (tmp != 0) + return tmp; + else + return stones[i]; + } + } \ No newline at end of file diff --git a/src/1078.cpp b/src/1078.cpp new file mode 100644 index 0000000..05bde8c --- /dev/null +++ b/src/1078.cpp @@ -0,0 +1,46 @@ +vector findOcurrences(string text, string first, string second) { + int i = 0; + int sz = text.size(); + + vector res; + while (i relativeSortArray(vector& arr1, vector& arr2) { + int len1 = arr1.size(); + int len2 = arr2.size(); + if (len1 == 0) + return arr1; + if (len2 == 0) + { + sort(arr1.begin(), arr1.end()); + return arr1; + } + + map mp; + for (int i = 0; i < len2; ++i) + mp[arr2[i]] = i; + + auto cmp = [&mp](int a, int b){ + auto iter1 = mp.find(a); + auto iter2 = mp.find(b); + if (iter1 != mp.end() && iter2 != mp.end()) + return mp[a] < mp[b]; + else if (iter1 != mp.end() && iter2 == mp.end()) + return true; + else if (iter1 == mp.end() && iter2 != mp.end()) + return false; + else + return a < b; + }; + + sort(arr1.begin(), arr1.end(), cmp); + return arr1; + } \ No newline at end of file diff --git a/src/1185.cpp b/src/1185.cpp new file mode 100644 index 0000000..6b89c9c --- /dev/null +++ b/src/1185.cpp @@ -0,0 +1,35 @@ +string dayOfTheWeek(int day, int month, int year) { + int month_days[12] = {31,28,31,30,31,30,31,31,30,31,30,31}; + string dow[7] = {"Thursday", "Friday", "Saturday", "Sunday", "Monday", "Tuesday", "Wednesday"}; + + int sum = 0; + if (year == 1971) + { + if (month == 1) + sum += day; + else + { + for (int i = 0; i < month-1; ++i) + sum += month_days[i]; + sum += day; + } + } + else + { + for (int i = 1971; i < year; ++i) + { + if ((i%4 == 0 && i%100 != 0) || (i%400 == 0)) + sum += 366; + else + sum += 365; + } + for (int i = 0; i < month-1; ++i) + sum += month_days[i]; + if (((year%4 == 0 && year%100 != 0) || (year%400 == 0)) && (month > 2)) + sum++; + sum += day; + } + + sum %= 7; + return dow[sum]; + } \ No newline at end of file diff --git a/src/1200.cpp b/src/1200.cpp new file mode 100644 index 0000000..491e4ae --- /dev/null +++ b/src/1200.cpp @@ -0,0 +1,26 @@ +vector> minimumAbsDifference(vector& arr) { + int len = arr.size(); + sort(arr.begin(), arr.end()); + + map> mp; + int minval = 2e6; + for (int i = 0; i < len-1; ++i) + { + int t = abs(arr[i+1]-arr[i]); + if (t <= minval) + { + minval = t; + mp[minval].push_back(i); + } + } + + int sz = mp[minval].size(); + vector> res(sz, vector(2,0)); + for (int i = 0; i < sz; ++i) + { + res[i][0] = arr[mp[minval][i]]; + res[i][1] = arr[mp[minval][i]+1]; + } + + return res; + } \ No newline at end of file diff --git a/src/1221.cpp b/src/1221.cpp new file mode 100644 index 0000000..a88e0ea --- /dev/null +++ b/src/1221.cpp @@ -0,0 +1,27 @@ +int balancedStringSplit(string s) { + int len = s.size(); + if (len == 0) + return 0; + if (len == 2) + return 1; + + int lct = 0, rct = 0; + int i = 0; + int ct = 0; + while (i < len) + { + if (s[i] == 'L') + ++lct; + else + ++rct; + if (lct == rct) + { + ++ct; + lct = 0; + rct = 0; + } + ++i; + } + + return ct; + } \ No newline at end of file diff --git a/src/1281.cpp b/src/1281.cpp new file mode 100644 index 0000000..1a9856e --- /dev/null +++ b/src/1281.cpp @@ -0,0 +1,11 @@ +int subtractProductAndSum(int n) { + int product = 1, sum = 0; + while (n != 0) + { + product *= n%10; + sum += n%10; + n /= 10; + } + + return product - sum; + } \ No newline at end of file diff --git a/src/1290.cpp b/src/1290.cpp new file mode 100644 index 0000000..dbe2da5 --- /dev/null +++ b/src/1290.cpp @@ -0,0 +1,10 @@ +int getDecimalValue(ListNode* head) { + int res = 0; + while (head != NULL) + { + res = res*2 + head->val; + head = head->next; + } + + return res; + } \ No newline at end of file diff --git a/src/1295.cpp b/src/1295.cpp new file mode 100644 index 0000000..e15c653 --- /dev/null +++ b/src/1295.cpp @@ -0,0 +1,17 @@ +int findNumbers(vector& nums) { + int len = nums.size(); + int ct = 0; + for (int i = 0; i < len; ++i) + { + int t = 0; + while (nums[i] != 0) + { + nums[i] /= 10; + ++t; + } + if (t%2 == 0) + ++ct; + } + + return ct; + } \ No newline at end of file diff --git a/src/938.cpp b/src/938.cpp new file mode 100644 index 0000000..6b80497 --- /dev/null +++ b/src/938.cpp @@ -0,0 +1,26 @@ +int rangeSumBST(TreeNode* root, int L, int R) { + if (root == nullptr || L > R) + return 0; + vector value; + midTravel(root, value); + auto p = lower_bound(value.begin(), value.end(), L); + if (p == value.end()) + return 0; + + int sum = 0; + auto q = upper_bound(value.begin(), value.end(), R); + for (auto iter = p; iter != q; ++iter) + sum += *iter; + + return sum; + } + + void midTravel(TreeNode* node, vector& value) + { + if (node != nullptr) + { + midTravel(node->left, value); + value.push_back(node->val); + midTravel(node->right, value); + } + } \ No newline at end of file diff --git a/src/961.cpp b/src/961.cpp new file mode 100644 index 0000000..f2661e9 --- /dev/null +++ b/src/961.cpp @@ -0,0 +1,13 @@ +int repeatedNTimes(vector& A) { + int ct[10000] = {0}; + int len = A.size(); + int i = 0; + for (; i < len; ++i) + { + ct[A[i]]++; + if (ct[A[i]] == (len/2)) + break; + } + + return A[i]; + } \ No newline at end of file From 34f56ddcc1bb43a9105b24b6a98a4efc3be73080 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 29 Dec 2019 13:53:27 +0800 Subject: [PATCH 27/97] 11 problems solved. --- src/1009.cpp | 16 ++++++++++++++++ src/1017.cpp | 24 ++++++++++++++++++++++++ src/1089.cpp | 53 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/1160.cpp | 28 +++++++++++++++++++++++++++ src/1207.cpp | 32 +++++++++++++++++++++++++++++++ src/1282.cpp | 21 +++++++++++++++++++++ src/1287.cpp | 20 ++++++++++++++++++++ src/5296.cpp | 19 +++++++++++++++++++ src/5297.cpp | 23 +++++++++++++++++++++++ src/912.cpp | 4 ++++ src/922.cpp | 28 +++++++++++++++++++++++++++ 11 files changed, 268 insertions(+) create mode 100644 src/1009.cpp create mode 100644 src/1017.cpp create mode 100644 src/1089.cpp create mode 100644 src/1160.cpp create mode 100644 src/1207.cpp create mode 100644 src/1282.cpp create mode 100644 src/1287.cpp create mode 100644 src/5296.cpp create mode 100644 src/5297.cpp create mode 100644 src/912.cpp create mode 100644 src/922.cpp diff --git a/src/1009.cpp b/src/1009.cpp new file mode 100644 index 0000000..7956013 --- /dev/null +++ b/src/1009.cpp @@ -0,0 +1,16 @@ +int bitwiseComplement(int N) { + if (N <= 1) + return 1-N; + int ct = 0; + int i = 0; + while (N != 0) + { + int tmp = N%2; + if (tmp == 0) + ct += pow(2, i); + N /= 2; + ++i; + } + + return ct; + } \ No newline at end of file diff --git a/src/1017.cpp b/src/1017.cpp new file mode 100644 index 0000000..9fe6298 --- /dev/null +++ b/src/1017.cpp @@ -0,0 +1,24 @@ +string baseNeg2(int N) { + if (N <= 1) + return to_string(N); + string res; + while (N != 1) + { + if (abs(N)%2 == 0) + { + N /= -2; + res.push_back('0'); + } + else + { + if (N > 0) + N = -N/2; + else + N = (-N)/2+1; + res.push_back('1'); + } + } + res.push_back('1'); + reverse(res.begin(), res.end()); + return res; + } \ No newline at end of file diff --git a/src/1089.cpp b/src/1089.cpp new file mode 100644 index 0000000..371ddd7 --- /dev/null +++ b/src/1089.cpp @@ -0,0 +1,53 @@ +void duplicateZeros(vector& arr) { + int len = arr.size(); + if (len <= 1) + return; + if (len == 2) + { + if (arr[0] == 0) + arr[1] = 0; + return; + } + + int pos = 0; + int ct = 0; + int i = 0; + while (i < len && ct < len) + { + if (arr[i] != 0) + ++ct; + else + ct += 2; + ++i; + } + if (i == len) + return; + --i; + int j = len-1; + if (ct == len && arr[i] == 0) + { + arr[j] = 0; + arr[j-1] = 0; + j -= 2; + --i; + } + else + { + arr[j] = arr[i]; + --j; + --i; + } + + while (j >= 0 && i >= 0) + { + if (arr[i] != 0) + arr[j--] = arr[i]; + else + { + arr[j] = 0; + arr[j-1] = 0; + j -= 2; + } + --i; + } + } \ No newline at end of file diff --git a/src/1160.cpp b/src/1160.cpp new file mode 100644 index 0000000..8d056e2 --- /dev/null +++ b/src/1160.cpp @@ -0,0 +1,28 @@ +int countCharacters(vector& words, string chars) { + int sz = words.size(); + int len = chars.size(); + + char num[26] = {0}; + for (int i = 0; i < len; ++i) + num[chars[i]-'a']++; + + char tmp[26]; + int sum = 0; + for (int i = 0; i < sz; ++i) + { + memset(tmp, 0, 26*sizeof(char)); + int wsz = words[i].size(); + int j = 0; + for (j = 0; j < wsz; ++j) + { + int p = words[i][j]-'a'; + tmp[p]++; + if (tmp[p] > num[p]) + break; + } + if (j == wsz) + sum += wsz; + } + + return sum; + } \ No newline at end of file diff --git a/src/1207.cpp b/src/1207.cpp new file mode 100644 index 0000000..60f09d1 --- /dev/null +++ b/src/1207.cpp @@ -0,0 +1,32 @@ +bool uniqueOccurrences(vector& arr) { + int len = arr.size(); + if (len <= 1) + return true; + if (len == 2) + return arr[0] == arr[1]; + + char num[1001] = {0}; + sort(arr.begin(), arr.end()); + int i = 1; + int last = arr[0]; + int ct = 1; + while (i < len) + { + if (arr[i] == last) + ++ct; + else + { + if (num[ct] == 0) + { + num[ct] = 1; + last = arr[i]; + ct = 1; + } + else + return false; + } + ++i; + } + + return true; + } \ No newline at end of file diff --git a/src/1282.cpp b/src/1282.cpp new file mode 100644 index 0000000..4507acf --- /dev/null +++ b/src/1282.cpp @@ -0,0 +1,21 @@ +vector> groupThePeople(vector& groupSizes) { + int len = groupSizes.size(); + vector> res; + map> mp; + for (int i = 0; i < len; ++i) + mp[groupSizes[i]].push_back(i); + + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + { + int sz = (iter->second).size(); + vector tmp(iter->first, 0); + for (int i = 0; i < sz; i += iter->first) + { + for (int j = i; j < i+iter->first; ++j) + tmp[j-i] = (iter->second)[j]; + res.push_back(tmp); + } + } + + return res; + } \ No newline at end of file diff --git a/src/1287.cpp b/src/1287.cpp new file mode 100644 index 0000000..5d47aa4 --- /dev/null +++ b/src/1287.cpp @@ -0,0 +1,20 @@ +int findSpecialInteger(vector& arr) { + int len = arr.size(); + if (len <= 3) + return arr[0]; + int n = int(len*0.25)+1; + int i = len-1; + int j = len*0.25; + while(i >= j) + { + if (arr[i] != arr[i-n+1]) + { + auto iter = lower_bound(arr.begin()+i-n+1, arr.begin()+i+1, arr[i]); + i = iter-1-arr.begin(); + } + else + break; + } + + return arr[i]; + } \ No newline at end of file diff --git a/src/5296.cpp b/src/5296.cpp new file mode 100644 index 0000000..2b9e185 --- /dev/null +++ b/src/5296.cpp @@ -0,0 +1,19 @@ +vector getAllElements(TreeNode* root1, TreeNode* root2) { + vector res; + midtravel(root1, res); + midtravel(root2, res); + + sort(res.begin(), res.end()); + + return move(res); + } + + void midtravel(TreeNode* node, vector& vec) + { + if (node != nullptr) + { + midtravel(node->left, vec); + vec.push_back(node->val); + midtravel(node->right, vec); + } + } \ No newline at end of file diff --git a/src/5297.cpp b/src/5297.cpp new file mode 100644 index 0000000..adba5f4 --- /dev/null +++ b/src/5297.cpp @@ -0,0 +1,23 @@ +bool canReach(vector& arr, int start) { + int len = arr.size(); + if (len == 1) + return arr[0] == 0; + vector flag(len, 0); + + return search(arr, start, len, flag); + } + + bool search(vector& arr, int pos, int len, vector& flag) + { + if (pos < 0 || pos >= len) + return false; + if (arr[pos] == 0) + return true; + if (flag[pos] == 1) + return false; + + flag[pos] = 1; + int p1 = pos + arr[pos]; + int p2 = pos - arr[pos]; + return search(arr, p1, len, flag) || search(arr, p2, len, flag); + } \ No newline at end of file diff --git a/src/912.cpp b/src/912.cpp new file mode 100644 index 0000000..16defb2 --- /dev/null +++ b/src/912.cpp @@ -0,0 +1,4 @@ +vector sortArray(vector& nums) { + sort(nums.begin(), nums.end()); + return move(nums); + } \ No newline at end of file diff --git a/src/922.cpp b/src/922.cpp new file mode 100644 index 0000000..f6cbf9d --- /dev/null +++ b/src/922.cpp @@ -0,0 +1,28 @@ +vector sortArrayByParityII(vector& A) { + int len = A.size(); + int i = 0, j = len-1; + while (i < j) + { + if ((i%2 == 0 && A[i]%2 == 0) || (i%2 == 1 && A[i]%2 == 1)) + ++i; + else + { + while ((j%2 == 0 && A[j]%2 == 0) || (j%2 == 1 && A[j]%2 == 1)) + --j; + int t = j; + while (i < t) + { + if ((i%2 == 0 && A[t]%2 == 0) || (i%2 == 1 && A[t]%2 == 1)) + { + swap(A[i], A[t]); + break; + } + else + --t; + } + ++i; + } + } + + return move(A); + } \ No newline at end of file From 408c730cacb5e4668ca15aa3aa3b30eeae69c13c Mon Sep 17 00:00:00 2001 From: Troy Date: Wed, 1 Jan 2020 19:06:54 +0800 Subject: [PATCH 28/97] 5 problems solved. --- src/1237.cpp | 25 +++++++++++++++++++++++++ src/1298.cpp | 33 +++++++++++++++++++++++++++++++++ src/1304.cpp | 22 ++++++++++++++++++++++ src/1305.cpp | 19 +++++++++++++++++++ src/965.cpp | 14 ++++++++++++++ 5 files changed, 113 insertions(+) create mode 100644 src/1237.cpp create mode 100644 src/1298.cpp create mode 100644 src/1304.cpp create mode 100644 src/1305.cpp create mode 100644 src/965.cpp diff --git a/src/1237.cpp b/src/1237.cpp new file mode 100644 index 0000000..6f28041 --- /dev/null +++ b/src/1237.cpp @@ -0,0 +1,25 @@ +vector> findSolution(CustomFunction& customfunction, int z) { + vector> res; + int limity = 1000; + for (int i = 1; i <= 1000; ++i) + { + int p = 1, q = limity; + while (p <= q) + { + int mid = (p+q)/2; + int tmp = customfunction.f(i, mid); + if (tmp == z) + { + res.push_back({i, mid}); + limity = mid; + break; + } + else if (tmp < z) + p = mid+1; + else + q = mid-1; + } + } + + return res; + } \ No newline at end of file diff --git a/src/1298.cpp b/src/1298.cpp new file mode 100644 index 0000000..eb46079 --- /dev/null +++ b/src/1298.cpp @@ -0,0 +1,33 @@ +int maxCandies(vector& status, vector& candies, vector>& keys, vector>& containedBoxes, vector& initialBoxes) { + int sum = 0; + int len = status.size(); + vector flag(len, 0); + + deque dq(initialBoxes.begin(), initialBoxes.end()); + int sz = dq.size(); + while (sz > 0) + { + int i = 0; + for (i = 0; i < sz; ++i) + if (status[dq[i]] == 1 && flag[dq[i]] == 0) + break; + if (i == sz) + break; + + int n = dq[i]; + dq.erase(dq.begin()+i); + + flag[n] = 1; + sum += candies[n]; + + int l = keys[n].size(); + for (int j = 0; j < l; ++j) + status[keys[n][j]] = 1; + l = containedBoxes[n].size(); + for (int j = 0; j < l; ++j) + dq.push_back(containedBoxes[n][j]); + sz = dq.size(); + } + + return sum; + } \ No newline at end of file diff --git a/src/1304.cpp b/src/1304.cpp new file mode 100644 index 0000000..25b6993 --- /dev/null +++ b/src/1304.cpp @@ -0,0 +1,22 @@ +vector sumZero(int n) { + vector res(n, 0); + if (n%2 == 0) + { + for (int i = 0; i < n/2; ++i) + { + res[i] = i+1; + res[n-1-i] = -(i+1); + } + } + else + { + res[n/2] = 0; + for (int i = 0; i < n/2; ++i) + { + res[i] = i+1; + res[n-1-i] = -(i+1); + } + } + + return res; + } \ No newline at end of file diff --git a/src/1305.cpp b/src/1305.cpp new file mode 100644 index 0000000..2b9e185 --- /dev/null +++ b/src/1305.cpp @@ -0,0 +1,19 @@ +vector getAllElements(TreeNode* root1, TreeNode* root2) { + vector res; + midtravel(root1, res); + midtravel(root2, res); + + sort(res.begin(), res.end()); + + return move(res); + } + + void midtravel(TreeNode* node, vector& vec) + { + if (node != nullptr) + { + midtravel(node->left, vec); + vec.push_back(node->val); + midtravel(node->right, vec); + } + } \ No newline at end of file diff --git a/src/965.cpp b/src/965.cpp new file mode 100644 index 0000000..677c744 --- /dev/null +++ b/src/965.cpp @@ -0,0 +1,14 @@ +bool isUnivalTree(TreeNode* root) { + if (root == nullptr) + return true; + return isUnivalSubTree(root->left, root->val) && isUnivalSubTree(root->right, root->val); + } + + bool isUnivalSubTree(TreeNode* node, int key) + { + if (node == nullptr) + return true; + if (node->val != key) + return false; + return isUnivalSubTree(node->left, key) && isUnivalSubTree(node->right, key); + } \ No newline at end of file From 081a0422ca19a5ee0e19f3525480147ba7dc9513 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 4 Jan 2020 19:22:47 +0800 Subject: [PATCH 29/97] 5 problems solved. --- src/155.cpp | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/31.cpp | 23 +++++++++++++++++++++++ src/46.cpp | 17 +++++++++++++++++ src/53.cpp | 36 ++++++++++++++++++++++++++++++++++++ src/56.cpp | 33 +++++++++++++++++++++++++++++++++ 5 files changed, 160 insertions(+) create mode 100644 src/155.cpp create mode 100644 src/31.cpp create mode 100644 src/46.cpp create mode 100644 src/53.cpp create mode 100644 src/56.cpp diff --git a/src/155.cpp b/src/155.cpp new file mode 100644 index 0000000..fa225e9 --- /dev/null +++ b/src/155.cpp @@ -0,0 +1,51 @@ +class MinStack { +public: + /** initialize your data structure here. */ + MinStack() { + len = 0; + } + + void push(int x) { + st.push_back(x); + ++len; + if (len == 1) + minval = x; + else + minval = x < minval ? x : minval; + } + + void pop() { + if (len > 0) + { + --len; + st.erase(--st.end()); + if (len > 0) + { + auto lim = st.end(); + int t = *st.begin(); + for (auto iter = st.begin(); iter != lim; ++iter) + if (*iter < t) + t = *iter; + minval = t; + } + } + } + + int top() { + if (len > 0) + return st.back(); + else + return 0; + } + + int getMin() { + if (len > 0) + return minval; + else + return 0; + } + + list st; + int minval; + int len; +}; \ No newline at end of file diff --git a/src/31.cpp b/src/31.cpp new file mode 100644 index 0000000..da52715 --- /dev/null +++ b/src/31.cpp @@ -0,0 +1,23 @@ +void nextPermutation(vector& nums) { + int len = nums.size(); + if (len <= 1) + return; + if (len == 2) + swap(nums[0], nums[1]); + else + { + int i = len - 1; + while (i > 0 && nums[i-1] >= nums[i]) + --i; + if (i == 0) + reverse(nums.begin(), nums.end()); + else + { + int j = len - 1; + while (j >= i && nums[j] <= nums[i-1]) + --j; + swap(nums[i-1], nums[j]); + reverse(nums.begin()+i, nums.end()); + } + } + } \ No newline at end of file diff --git a/src/46.cpp b/src/46.cpp new file mode 100644 index 0000000..df66e1c --- /dev/null +++ b/src/46.cpp @@ -0,0 +1,17 @@ +vector> permute(vector& nums) { + sort(nums.begin(), nums.end()); + int len = nums.size(); + long long total = 1; + for (int i = len; i >= 1; --i) + total *= i; + vector> res(total, vector(len, 0)); + res[0].assign(nums.begin(), nums.end()); + + int i = 1; + while (next_permutation(nums.begin(), nums.end())) + { + res[i++].assign(nums.begin(), nums.end()); + } + + return move(res); + } \ No newline at end of file diff --git a/src/53.cpp b/src/53.cpp new file mode 100644 index 0000000..a5764f7 --- /dev/null +++ b/src/53.cpp @@ -0,0 +1,36 @@ +int maxSubArray(vector& nums) { + int len = nums.size(); + if (len == 0) + return 0; + if (len == 1) + return nums[0]; + + int i = 1; + int maxsum = nums[0]; + int tmp = maxsum; + while (i < len) + { + if (tmp <= 0) + { + if (nums[i] >= tmp) + { + tmp = nums[i]; + if (tmp > maxsum) + maxsum = tmp; + } + ++i; + } + else + { + tmp += nums[i]; + if (tmp > maxsum) + maxsum = tmp; + ++i; + } + } + + if (tmp > maxsum) + maxsum = tmp; + + return maxsum; + } \ No newline at end of file diff --git a/src/56.cpp b/src/56.cpp new file mode 100644 index 0000000..409cff6 --- /dev/null +++ b/src/56.cpp @@ -0,0 +1,33 @@ +vector> merge(vector>& intervals) { + int len = intervals.size(); + if (len <= 1) + return move(intervals); + + auto cmp = [](vector& a, vector& b) { + return a[0] < b[0] || (a[0] == b[0] && a[1] < b[1]); + }; + + sort(intervals.begin(), intervals.end(), cmp); + + vector> res; + int b = intervals[0][0], e = intervals[0][1]; + int i = 1; + while (i < len) + { + if (intervals[i][0] > e) + { + res.push_back({b, e}); + b = intervals[i][0]; + e = intervals[i][1]; + ++i; + } + else + { + e = intervals[i][1] > e ? intervals[i][1] : e; + ++i; + } + } + res.push_back({b, e}); + + return move(res); + } \ No newline at end of file From adf05b7993f5e2e9dbf871fc0fb4a282390ba7f5 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 11 Jan 2020 20:46:31 +0800 Subject: [PATCH 30/97] 4 problems solved. --- src/1309.cpp | 24 ++++++++++++++++++++ src/3.cpp | 38 +++++++++++++++++++++++++++++++ src/78.cpp | 23 +++++++++++++++++++ src/79.cpp | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 148 insertions(+) create mode 100644 src/1309.cpp create mode 100644 src/3.cpp create mode 100644 src/78.cpp create mode 100644 src/79.cpp diff --git a/src/1309.cpp b/src/1309.cpp new file mode 100644 index 0000000..a1e2e9c --- /dev/null +++ b/src/1309.cpp @@ -0,0 +1,24 @@ +string freqAlphabets(string s) { + int len = s.size(); + int i = 0; + string res; + while (i < len) + { + int p = s.find('#', i); + if (p != -1) + { + for (; i < p-2; ++i) + res.push_back(s[i]-'1'+'a'); + int t = (s[i]-'0')*10+(s[i+1]-'0'); + res.push_back(t-10+'j'); + i = p+1; + } + else + { + for (; i < len; ++i) + res.push_back(s[i]-'1'+'a'); + } + } + + return res; + } \ No newline at end of file diff --git a/src/3.cpp b/src/3.cpp new file mode 100644 index 0000000..d738990 --- /dev/null +++ b/src/3.cpp @@ -0,0 +1,38 @@ +int lengthOfLongestSubstring(string s) { + int len = s.size(); + if (len <= 1) + return len; + + map pos; + pos[s[0]] = 0; + + int i = 1, tmp = 1; + int maxlen = 1; + int index = 0; + while (i < len) + { + if (pos.find(s[i]) == pos.end() || pos[s[i]] == -1) + { + ++tmp; + pos[s[i]] = i; + ++i; + } + else + { + if (tmp > maxlen) + maxlen = tmp; + int t = pos[s[i]]; + for (int j = index; j <=t; ++j) + pos[s[j]] = -1; + tmp = i-t; + pos[s[i]] = i; + index = t+1; + ++i; + } + } + + if (tmp > maxlen) + maxlen = tmp; + + return maxlen; + } \ No newline at end of file diff --git a/src/78.cpp b/src/78.cpp new file mode 100644 index 0000000..0a1ca91 --- /dev/null +++ b/src/78.cpp @@ -0,0 +1,23 @@ +vector> subsets(vector& nums) { + vector> res; + res.push_back({}); + int len = nums.size(); + if (len == 0) + return res; + + vector vec; + search(nums, 0, len, vec, res); + + return move(res); + } + + void search(vector& nums, int index, int len, vector& vec, vector>& res) + { + for (int i = index; i < len; ++i) + { + vector tmp(vec); + tmp.push_back(nums[i]); + res.push_back(tmp); + search(nums, i+1, len, tmp, res); + } + } \ No newline at end of file diff --git a/src/79.cpp b/src/79.cpp new file mode 100644 index 0000000..1a6c18a --- /dev/null +++ b/src/79.cpp @@ -0,0 +1,63 @@ +bool exist(vector>& board, string word) { + int row = board.size(); + if (row == 0) + return word == ""; + int col = board[0].size(); + + if (col == 0) + return word == ""; + int total = row*col; + + int sz = word.size(); + for (int i = 0; i < row; ++i) + { + for (int j = 0; j < col; ++j) + { + if (board[i][j] == word[0]) + { + vector flag(total, 0); + flag[i*col+j] = 1; + bool res = search(board, row, col, i, j, 1, sz, word, flag); + if (res) + { + return true; + } + } + } + } + + return false; + } + + bool search(const vector>& board, int row, int col, int r, int c, int ct, int sz, const string& word, vector& flag) + { + if (ct == sz) + return true; + bool res = false; + if (r > 0 && flag[(r-1)*col+c] == 0 && board[r-1][c] == word[ct]) + { + vector flag1(flag); + flag1[(r-1)*col+c] = 1; + res = search(board, row, col, r-1, c, ct+1, sz, word, flag1); + } + if (!res && r < row-1 && flag[(r+1)*col+c] == 0 && board[r+1][c] == word[ct]) + { + vector flag1(flag); + flag1[(r+1)*col+c] = 1; + res = search(board, row, col, r+1, c, ct+1, sz, word, flag1); + } + if (!res && c > 0 && flag[r*col+c-1] == 0 && board[r][c-1] == word[ct]) + { + vector flag1(flag); + flag1[r*col+c-1] = 1; + res = search(board, row, col, r, c-1, ct+1, sz, word, flag1); + } + if (!res && c < col-1 && flag[r*col+c+1] == 0 && board[r][c+1] == word[ct]) + { + vector flag1(flag); + flag1[r*col+c+1] = 1; + res = search(board, row, col, r, c+1, ct+1, sz, word, flag1); + } + + return res; + } \ No newline at end of file From 12ef63e70bad630adaa9d59fd25e24e4c19006ca Mon Sep 17 00:00:00 2001 From: lintcoder Date: Sun, 19 Jan 2020 20:19:23 +0800 Subject: [PATCH 31/97] 5 problems solved. --- src/1299.cpp | 20 ++++++++++++++++++++ src/1313.cpp | 16 ++++++++++++++++ src/1323.cpp | 16 ++++++++++++++++ src/581.cpp | 19 +++++++++++++++++++ src/98.cpp | 27 +++++++++++++++++++++++++++ 5 files changed, 98 insertions(+) create mode 100644 src/1299.cpp create mode 100644 src/1313.cpp create mode 100644 src/1323.cpp create mode 100644 src/581.cpp create mode 100644 src/98.cpp diff --git a/src/1299.cpp b/src/1299.cpp new file mode 100644 index 0000000..faae7f2 --- /dev/null +++ b/src/1299.cpp @@ -0,0 +1,20 @@ +vector replaceElements(vector& arr) { + int len = arr.size(); + if (len == 1) + return {-1}; + + vector res(len, -1); + int maxnum = -1; + int i = len-1; + while (i > 0) + { + if (arr[i] > maxnum) + { + maxnum = arr[i]; + } + res[i-1] = maxnum; + --i; + } + + return res; + } diff --git a/src/1313.cpp b/src/1313.cpp new file mode 100644 index 0000000..6ca4dca --- /dev/null +++ b/src/1313.cpp @@ -0,0 +1,16 @@ +vector decompressRLElist(vector& nums) { + int len = nums.size(); + int total = 0; + for (int i = 0; i < len; i += 2) + total += nums[i]; + vector res(total, 0); + int k = 0; + for (int i = 0; i < len; i += 2) + { + int lim = k+nums[i]; + for (; k < lim; ++k) + res[k] = nums[i+1]; + } + + return res; + } diff --git a/src/1323.cpp b/src/1323.cpp new file mode 100644 index 0000000..762d1d9 --- /dev/null +++ b/src/1323.cpp @@ -0,0 +1,16 @@ +int maximum69Number (int num) { + string s = to_string(num); + int res = 0; + int len = s.size(); + for (int i = 0; i < len; ++i) + if (s[i] == '6') + { + s[i] = '9'; + break; + } + + for (int i = 0; i < len; ++i) + res = res*10 + (s[i]-'0'); + + return res; + } diff --git a/src/581.cpp b/src/581.cpp new file mode 100644 index 0000000..bfdf9f4 --- /dev/null +++ b/src/581.cpp @@ -0,0 +1,19 @@ +int findUnsortedSubarray(vector& nums) { + int len = nums.size(); + if (len <= 1) + return 0; + + vector vec(nums); + sort(vec.begin(), vec.end()); + int i = 0; + for (i = 0; i < len; ++i) + if (nums[i] != vec[i]) + break; + if (i == len) + return 0; + int j = len-1; + for (j = len-1; j >= 0; --j) + if (nums[j] != vec[j]) + break; + return j-i+1; + } diff --git a/src/98.cpp b/src/98.cpp new file mode 100644 index 0000000..c200ed4 --- /dev/null +++ b/src/98.cpp @@ -0,0 +1,27 @@ +bool isValidBST(TreeNode* root) { + if (root == NULL) + return true; + list lst; + midtravel(root, lst); + auto lim = lst.end(); + --lim; + for (auto iter = lst.begin(); iter != lim; ++iter) + { + auto tmp = iter; + tmp++; + if ((*iter)->val >= (*tmp)->val) + return false; + } + + return true; + } + + void midtravel(TreeNode* node, list& lst) + { + if (node != NULL) + { + midtravel(node->left, lst); + lst.push_back(node); + midtravel(node->right, lst); + } + } From 6e254fa59e34dcbec066ee850a297fd547ead04c Mon Sep 17 00:00:00 2001 From: Troy Date: Thu, 23 Jan 2020 15:38:56 +0800 Subject: [PATCH 32/97] 4 problems solved. --- src/22.cpp | 31 +++++++++++++++++++++++++++++++ src/34.cpp | 12 ++++++++++++ src/62.cpp | 23 +++++++++++++++++++++++ src/64.cpp | 41 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 107 insertions(+) create mode 100644 src/22.cpp create mode 100644 src/34.cpp create mode 100644 src/62.cpp create mode 100644 src/64.cpp diff --git a/src/22.cpp b/src/22.cpp new file mode 100644 index 0000000..630e3aa --- /dev/null +++ b/src/22.cpp @@ -0,0 +1,31 @@ +vector generateParenthesis(int n) { + if (n <= 0) + return {}; + + vector res; + string s; + generate(s, 0, 0, n, res); + + return res; + } + + void generate(const string& s, int left, int right, int n, vector& res) + { + if (left == n && right == n) + res.push_back(s); + else + { + if (left < n) + { + string tmp(s); + tmp.push_back('('); + generate(tmp, left+1, right, n, res); + } + if (left > right) + { + string tmp(s); + tmp.push_back(')'); + generate(tmp, left, right+1, n, res); + } + } + } \ No newline at end of file diff --git a/src/34.cpp b/src/34.cpp new file mode 100644 index 0000000..25d62f9 --- /dev/null +++ b/src/34.cpp @@ -0,0 +1,12 @@ +vector searchRange(vector& nums, int target) { + vector res(2, -1); + if (!binary_search(nums.begin(), nums.end(), target)) + return res; + + auto iter = lower_bound(nums.begin(), nums.end(), target); + res[0] = iter-nums.begin(); + iter = upper_bound(nums.begin(), nums.end(), target); + res[1] = iter-1-nums.begin(); + + return res; + } \ No newline at end of file diff --git a/src/62.cpp b/src/62.cpp new file mode 100644 index 0000000..6de5a1b --- /dev/null +++ b/src/62.cpp @@ -0,0 +1,23 @@ +int uniquePaths(int m, int n) { + vector> path(m, vector(n, 0)); + + return search(0, 0, m, n, path); + } + + int search(int p, int q, int m, int n, vector>& path) + { + if (p < m-1 && q < n-1) + { + if (path[p][q] == 0) + { + int t = search(p+1, q, m, n, path) + search(p, q+1, m, n, path); + path[p][q] = t; + + return t; + } + else + return path[p][q]; + } + else + return 1; + } \ No newline at end of file diff --git a/src/64.cpp b/src/64.cpp new file mode 100644 index 0000000..411ed85 --- /dev/null +++ b/src/64.cpp @@ -0,0 +1,41 @@ +int minPathSum(vector>& grid) { + int row = grid.size(); + if (row == 0) + return 0; + int col = grid[0].size(); + + vector> sum(row, vector(col, -1)); + return search(0, 0, row, col, grid, sum); + } + + int search(int p, int q, int m, int n, const vector>& grid, vector>& sum) + { + if (sum[p][q] == -1) + { + if (p < m-1 && q < n-1) + { + int v1 = search(p+1, q, m, n, grid, sum); + int v2 = search(p, q+1, m, n, grid, sum); + sum[p][q] = v1 < v2 ? v1+grid[p][q] : v2+grid[p][q]; + return sum[p][q]; + } + else if (p == m-1) + { + int t = 0; + for (int i = q; i < n; ++i) + t += grid[p][i]; + sum[p][q] = t; + return t; + } + else + { + int t = 0; + for (int i = p; i < m; ++i) + t += grid[i][q]; + sum[p][q] = t; + return t; + } + } + else + return sum[p][q]; + } \ No newline at end of file From 3b016bff05bbd028ac5312c149e242e9e7c9c1d1 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 1 Feb 2020 03:24:04 +0800 Subject: [PATCH 33/97] 5 problems solved. --- src/1021.cpp | 27 +++++++++++++++++++++++++++ src/142.cpp | 34 ++++++++++++++++++++++++++++++++++ src/17.cpp | 26 ++++++++++++++++++++++++++ src/215.cpp | 6 ++++++ src/23.cpp | 37 +++++++++++++++++++++++++++++++++++++ 5 files changed, 130 insertions(+) create mode 100644 src/1021.cpp create mode 100644 src/142.cpp create mode 100644 src/17.cpp create mode 100644 src/215.cpp create mode 100644 src/23.cpp diff --git a/src/1021.cpp b/src/1021.cpp new file mode 100644 index 0000000..661809d --- /dev/null +++ b/src/1021.cpp @@ -0,0 +1,27 @@ +string removeOuterParentheses(string S) { + int len = S.size(); + if (len == 0 || len == 2) + return ""; + + int i = 0, last = 0; + int left = 0, right = 0; + string res(""); + while (i < len) + { + if (S[i] == '(') + ++left; + else + { + ++right; + if (left == right) + { + if (i - last + 1 > 2) + res.insert(res.end(), S.begin()+last+1, S.begin()+i); + last = i+1; + } + } + ++i; + } + + return res; + } \ No newline at end of file diff --git a/src/142.cpp b/src/142.cpp new file mode 100644 index 0000000..289418d --- /dev/null +++ b/src/142.cpp @@ -0,0 +1,34 @@ +ListNode *detectCycle(ListNode *head) { + if (head == nullptr || head->next == head) + return head; + ListNode* fast = head; + ListNode* slow = head; + fast = fast->next; + if (fast == nullptr) + return nullptr; + fast = fast->next; + slow = slow->next; + while (fast != nullptr && slow != nullptr) + { + if (fast != slow) + { + fast = fast->next; + slow = slow->next; + if (fast == nullptr) + return nullptr; + else + fast = fast->next; + } + else + break; + } + if (fast == nullptr) + return nullptr; + slow = head; + while (slow != fast) + { + slow = slow->next; + fast = fast->next; + } + return slow; + } \ No newline at end of file diff --git a/src/17.cpp b/src/17.cpp new file mode 100644 index 0000000..32286fc --- /dev/null +++ b/src/17.cpp @@ -0,0 +1,26 @@ +vector letterCombinations(string digits) { + int len = digits.size(); + vector res; + if (len == 0) + return res; + string dict[10] = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"}; + int num[10] = {0,0,3,3,3,3,3,4,3,4}; + + string s; + search(digits, 0, len, dict, num, s, res); + + return move(res); + } + + void search(const string& digits, int ct, int len, const string* dict, const int* num, string s, vector& res) + { + if (ct < len) + { + int index = digits[ct]-'0'; + int n = num[index]; + for (int i = 0; i < n; ++i) + search(digits, ct+1, len, dict, num, s+dict[index][i], res); + } + else + res.push_back(s); + } \ No newline at end of file diff --git a/src/215.cpp b/src/215.cpp new file mode 100644 index 0000000..edd9e4d --- /dev/null +++ b/src/215.cpp @@ -0,0 +1,6 @@ +int findKthLargest(vector& nums, int k) { + sort(nums.begin(), nums.end()); + int len = nums.size(); + + return nums[len-1-(k-1)]; + } \ No newline at end of file diff --git a/src/23.cpp b/src/23.cpp new file mode 100644 index 0000000..33a6633 --- /dev/null +++ b/src/23.cpp @@ -0,0 +1,37 @@ +ListNode* mergeKLists(vector& lists) { + ListNode* head = nullptr; + lists.erase(remove(lists.begin(), lists.end(), nullptr), lists.end()); + int len = lists.size(); + if (len == 0) + return head; + if (len == 1) + return lists[0]; + + struct cmp + { + bool operator()(ListNode* a, ListNode* b) + { + return a->val > b->val; + } + }; + priority_queue, cmp> pq; + for (int i = 0; i < len; ++i) + pq.push(lists[i]); + head = pq.top(); + pq.pop(); + if (head->next != nullptr) + pq.push(head->next); + ListNode* node = head; + while (!pq.empty()) + { + ListNode* tmp = pq.top(); + pq.pop(); + if (tmp->next != nullptr) + pq.push(tmp->next); + node->next = tmp; + node = tmp; + } + node->next = nullptr; + + return head; + } \ No newline at end of file From e6f47f74c83895bd2a636f2ddb3c42895cc3b117 Mon Sep 17 00:00:00 2001 From: Troy Date: Mon, 3 Feb 2020 18:43:32 +0800 Subject: [PATCH 34/97] 4 problems solved. --- src/1047.cpp | 28 ++++++++++++++++++++++++ src/1341.cpp | 30 ++++++++++++++++++++++++++ src/145.cpp | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/199.cpp | 22 +++++++++++++++++++ 4 files changed, 141 insertions(+) create mode 100644 src/1047.cpp create mode 100644 src/1341.cpp create mode 100644 src/145.cpp diff --git a/src/1047.cpp b/src/1047.cpp new file mode 100644 index 0000000..44c4d83 --- /dev/null +++ b/src/1047.cpp @@ -0,0 +1,28 @@ +string removeDuplicates(string S) { + int len = S.size(); + if (len == 1) + return S; + string res; + stack stk; + for (int i = 0; i < len; ++i) + { + if (stk.empty()) + stk.push(S[i]); + else + { + if (stk.top() == S[i]) + stk.pop(); + else + stk.push(S[i]); + } + } + + while (!stk.empty()) + { + res.push_back(stk.top()); + stk.pop(); + } + + reverse(res.begin(), res.end()); + return res; + } \ No newline at end of file diff --git a/src/1341.cpp b/src/1341.cpp new file mode 100644 index 0000000..429e6ca --- /dev/null +++ b/src/1341.cpp @@ -0,0 +1,30 @@ +vector kWeakestRows(vector>& mat, int k) { + int row = mat.size(); + if (row == 1) + return {0}; + int col = mat[0].size(); + + struct Elem + { + int num; + int index; + Elem(int n = 0, int id = -1):num(n),index(id){} + }; + auto cmp = [](const Elem& a, const Elem& b){ + return a.num < b.num || (a.num == b.num && a.index < b.index); + }; + + vector vec(row, Elem()); + for (int i = 0; i < row; ++i) + { + vec[i].num = mat[i].rend() - upper_bound(mat[i].rbegin(), mat[i].rend(), 0); + vec[i].index = i; + } + + sort(vec.begin(), vec.end(), cmp); + vector res(k, -1); + for (int i = 0; i < k; ++i) + res[i] = vec[i].index; + + return res; + } \ No newline at end of file diff --git a/src/145.cpp b/src/145.cpp new file mode 100644 index 0000000..7505d65 --- /dev/null +++ b/src/145.cpp @@ -0,0 +1,61 @@ +vector postorderTraversal(TreeNode* root) { + vector res; + if (root == nullptr) + return res; + + deque dq; + deque flag; + + dq.push_back(root); + flag.push_back(0); + + while (!dq.empty()) + { + TreeNode* node = dq.back(); + int status = flag.back(); + if (status == 0) + { + if (node->left != nullptr) + { + flag.back() = 1; + dq.push_back(node->left); + flag.push_back(0); + } + else if (node->right != nullptr) + { + flag.back() = 2; + dq.push_back(node->right); + flag.push_back(0); + } + else + { + res.push_back(node->val); + dq.pop_back(); + flag.pop_back(); + } + } + else if (status == 1) + { + if (node->right != nullptr) + { + flag.back() = 2; + dq.push_back(node->right); + flag.push_back(0); + } + else + { + res.push_back(node->val); + dq.pop_back(); + flag.pop_back(); + } + } + else + { + res.push_back(node->val); + dq.pop_back(); + flag.pop_back(); + } + } + + return res; + } \ No newline at end of file diff --git a/src/199.cpp b/src/199.cpp index 0b59094..8e250ac 100644 --- a/src/199.cpp +++ b/src/199.cpp @@ -1,3 +1,25 @@ vector rightSideView(TreeNode* root) { + if (root == nullptr) + return {}; + deque dq; + dq.push_back(root); + int len = 1; + vector res; + while (len > 0) + { + for (int i = 0; i < len; ++i) + { + TreeNode* node = dq[i]; + if (node->left != nullptr) + dq.push_back(node->left); + if (node->right != nullptr) + dq.push_back(node->right); + } + res.push_back(dq[len-1]->val); + dq.erase(dq.begin(), dq.begin()+len); + len = dq.size(); + } + + return res; } \ No newline at end of file From 3028f46982df62538e8c3ba26c300fc492a54c62 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 9 Feb 2020 19:02:15 +0800 Subject: [PATCH 35/97] 7 problems solved. --- src/1022.cpp | 26 ++++++++++++++++++++++++++ src/1291.cpp | 16 ++++++++++++++++ src/1296.cpp | 25 +++++++++++++++++++++++++ src/1346.cpp | 13 +++++++++++++ src/1347.cpp | 18 ++++++++++++++++++ src/1348.cpp | 46 ++++++++++++++++++++++++++++++++++++++++++++++ src/15.cpp | 37 +++++++++++++++++++++++++++++++++++++ 7 files changed, 181 insertions(+) create mode 100644 src/1022.cpp create mode 100644 src/1291.cpp create mode 100644 src/1296.cpp create mode 100644 src/1346.cpp create mode 100644 src/1347.cpp create mode 100644 src/1348.cpp create mode 100644 src/15.cpp diff --git a/src/1022.cpp b/src/1022.cpp new file mode 100644 index 0000000..72584cc --- /dev/null +++ b/src/1022.cpp @@ -0,0 +1,26 @@ +int sumRootToLeaf(TreeNode* root) { + if (root == nullptr) + return 0; + + int res = 0; + int sum = 0; + search(root, res, sum); + + return sum; + } + + void search(TreeNode* node, int res, int& sum) + { + res = res*2 + node->val; + if (node->left != nullptr || node->right != nullptr) + { + if (node->left != nullptr) + search(node->left, res, sum); + if (node->right != nullptr) + search(node->right, res, sum); + } + else + { + sum += res; + } + } \ No newline at end of file diff --git a/src/1291.cpp b/src/1291.cpp new file mode 100644 index 0000000..813e6e6 --- /dev/null +++ b/src/1291.cpp @@ -0,0 +1,16 @@ +vector sequentialDigits(int low, int high) { + vector> nums{{12,23,34,45,56,67,78,89},{123,234,345,456,567,678,789},{1234,2345,3456,4567,5678,6789}, + {12345,23456,34567,45678,56789},{123456,234567,345678,456789},{1234567,2345678,3456789},{12345678,23456789}, + {123456789}}; + + vector res; + for (int i = 0; i < 8; ++i) + { + int sz = nums[i].size(); + for (int j = 0; j < sz; ++j) + if (nums[i][j] >= low && nums[i][j] <= high) + res.push_back(nums[i][j]); + } + + return res; + } \ No newline at end of file diff --git a/src/1296.cpp b/src/1296.cpp new file mode 100644 index 0000000..043cc7e --- /dev/null +++ b/src/1296.cpp @@ -0,0 +1,25 @@ +bool isPossibleDivide(vector& nums, int k) { + int len = nums.size(); + if (len%k != 0) + return false; + + map mp; + for (int i = 0; i < len; ++i) + mp[nums[i]]++; + + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + { + if (iter->second == 0) + continue; + int t = iter->first; + for (int i = t+1; i < t+k; ++i) + { + if (mp[i] < iter->second) + return false; + else + mp[i] -= iter->second; + } + } + + return true; + } \ No newline at end of file diff --git a/src/1346.cpp b/src/1346.cpp new file mode 100644 index 0000000..36f7a4b --- /dev/null +++ b/src/1346.cpp @@ -0,0 +1,13 @@ +bool checkIfExist(vector& arr) { + int len = arr.size(); + for (int i = 0; i < len-1; ++i) + { + for (int j = i+1; j < len; ++j) + { + if (arr[i]*2 == arr[j] || arr[i] == arr[j]*2) + return true; + } + } + + return false; + } \ No newline at end of file diff --git a/src/1347.cpp b/src/1347.cpp new file mode 100644 index 0000000..3f2f95e --- /dev/null +++ b/src/1347.cpp @@ -0,0 +1,18 @@ +int minSteps(string s, string t) { + vector ct1(26, 0); + vector ct2(26, 0); + int len = s.size(); + for (int i = 0; i < len; ++i) + { + ct1[s[i]-'a']++; + ct2[t[i]-'a']++; + } + + for (int i = 0; i < 26; ++i) + { + if (ct1[i] > 0 && ct2[i] > 0) + len -= min(ct1[i], ct2[i]); + } + + return len; + } \ No newline at end of file diff --git a/src/1348.cpp b/src/1348.cpp new file mode 100644 index 0000000..0102159 --- /dev/null +++ b/src/1348.cpp @@ -0,0 +1,46 @@ +class TweetCounts { +public: + TweetCounts() { + } + + void recordTweet(string tweetName, int time) { + mp[tweetName].push_back(time); + } + + vector getTweetCountsPerFrequency(string freq, string tweetName, int startTime, int endTime) { + if (mp.find(tweetName) != mp.end()) + { + int ct = 0; + int interval = 0; + if (freq == "minute") + { + ct = (endTime-startTime+60)/60; + interval = 60; + } + else if (freq == "hour") + { + ct = (endTime-startTime+3600)/3600; + interval = 3600; + } + else + { + ct = (endTime-startTime+86400)/86400; + interval = 86400; + } + vector res(ct, 0); + int len = mp[tweetName].size(); + for (int i = 0; i < len; ++i) + { + if (mp[tweetName][i] < startTime || mp[tweetName][i] >= endTime+1) + continue; + res[(mp[tweetName][i]-startTime)/interval]++; + } + + return res; + } + else + return {}; + } + private: + map> mp; +}; diff --git a/src/15.cpp b/src/15.cpp new file mode 100644 index 0000000..194b31f --- /dev/null +++ b/src/15.cpp @@ -0,0 +1,37 @@ +vector> threeSum(vector& nums) { + vector> res; + int len = nums.size(); + if (len < 3) + return res; + + sort(nums.begin(), nums.end()); + int i = 0, j = 0; + while (i < len-2) + { + if (nums[i] > 0) + break; + j = i+1; + while (j < len-1) + { + if (nums[i]+nums[j] > 0) + { + break; + } + bool ans = binary_search(nums.begin()+j+1, nums.end(), -nums[i]-nums[j]); + if (ans) + res.push_back({nums[i], nums[j], -nums[i]-nums[j]}); + auto iter = upper_bound(nums.begin()+j+1, nums.end(), nums[j]); + if (iter == nums.end()) + break; + j = iter-nums.begin(); + } + + auto iter2 = upper_bound(nums.begin()+i+1, nums.end(), nums[i]); + if (iter2 == nums.end()) + break; + else + i = iter2-nums.begin(); + } + + return res; + } \ No newline at end of file From f9094095c767656fd5e9741d8ce6c4224a48b4e7 Mon Sep 17 00:00:00 2001 From: Troy Date: Thu, 13 Feb 2020 21:00:52 +0800 Subject: [PATCH 36/97] 5 problems solved. --- src/1260.cpp | 20 ++++++++++++++++ src/1331.cpp | 42 +++++++++++++++++++++++++++++++++ src/341.cpp | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/454.cpp | 25 ++++++++++++++++++++ src/944.cpp | 16 +++++++++++++ 5 files changed, 168 insertions(+) create mode 100644 src/1260.cpp create mode 100644 src/1331.cpp create mode 100644 src/341.cpp create mode 100644 src/454.cpp create mode 100644 src/944.cpp diff --git a/src/1260.cpp b/src/1260.cpp new file mode 100644 index 0000000..a331ce1 --- /dev/null +++ b/src/1260.cpp @@ -0,0 +1,20 @@ +vector> shiftGrid(vector>& grid, int k) { + int row = grid.size(); + int col = grid[0].size(); + int sz = row*col; + k %= sz; + if (k == 0) + return grid; + vector> res(row, vector(col, 0)); + for (int i = 0; i < row; ++i) + { + for (int j = 0; j < col; ++j) + { + int t = (i*col+j+k)%sz; + int r = t/col, c = t%col; + res[r][c] = grid[i][j]; + } + } + + return res; + } \ No newline at end of file diff --git a/src/1331.cpp b/src/1331.cpp new file mode 100644 index 0000000..737615d --- /dev/null +++ b/src/1331.cpp @@ -0,0 +1,42 @@ +vector arrayRankTransform(vector& arr) { + int len = arr.size(); + if (len == 0) + return {}; + if (len == 1) + return {1}; + + struct Elem + { + int val; + int pos; + int rank; + Elem(int v = 0, int p = -1, int r = 1):val(v), pos(p), rank(r){} + }; + + vector vec(len); + for (int i = 0; i < len; ++i) + { + vec[i].val = arr[i]; + vec[i].pos = i; + } + + auto cmp = [](const Elem& a, const Elem& b) { + return a.val < b.val; + }; + + sort(vec.begin(), vec.end(), cmp); + vector res(len, 1); + int rank = 1; + for (int i = 1; i < len; ++i) + { + if (vec[i].val > vec[i-1].val) + { + ++rank; + } + vec[i].rank = rank; + } + for (int i = 0; i < len; ++i) + res[vec[i].pos] = vec[i].rank; + + return res; + } \ No newline at end of file diff --git a/src/341.cpp b/src/341.cpp new file mode 100644 index 0000000..b9a42f4 --- /dev/null +++ b/src/341.cpp @@ -0,0 +1,65 @@ +class NestedIterator { +public: + NestedIterator(vector &nestedList) { + skF.push(nestedList.begin()); + skL.push(nestedList.end()); + } + + int next() { + nit iter = skF.top(); + int res = iter->getInteger(); + ++iter; + skF.pop(); + skF.push(iter); + return res; + } + + bool hasNext() { + int sz = skF.size(); + while (sz != 0) + { + if (skF.top() == skL.top()) + { + skF.pop(); + skL.pop(); + sz--; + if (sz > 0) + { + nit iter = skF.top(); + iter++; + skF.pop(); + skF.push(iter); + } + else + break; + } + else + { + nit iter = skF.top(); + if (iter->isInteger()) + return true; + else + { + auto& t = iter->getList(); + if (t.size() == 0) + { + iter++; + skF.pop(); + skF.push(iter); + } + else + { + skF.push(t.begin()); + skL.push(t.end()); + ++sz; + } + } + } + } + + return false; + } + + using nit = vector::iterator; + stack skF, skL; +}; \ No newline at end of file diff --git a/src/454.cpp b/src/454.cpp new file mode 100644 index 0000000..c927ce8 --- /dev/null +++ b/src/454.cpp @@ -0,0 +1,25 @@ +int fourSumCount(vector& A, vector& B, vector& C, vector& D) { + vector sum; + int len = A.size(); + for (int i = 0; i < len; ++i) + { + for (int j = 0; j < len; ++j) + sum.push_back(A[i]+B[j]); + } + sort(sum.begin(), sum.end()); + + int res = 0; + for (int i = 0; i < len; ++i) + { + for (int j = 0; j < len; ++j) + { + int t = -(C[i]+D[j]); + if (binary_search(sum.begin(), sum.end(), t)) + { + res += upper_bound(sum.begin(), sum.end(), t) - lower_bound(sum.begin(), sum.end(), t); + } + } + } + + return res; + } \ No newline at end of file diff --git a/src/944.cpp b/src/944.cpp new file mode 100644 index 0000000..d440c5e --- /dev/null +++ b/src/944.cpp @@ -0,0 +1,16 @@ +int minDeletionSize(vector& A) { + int len = A.size(); + int sz = A[0].size(); + int ct = 0; + for (int i = 0; i < sz; ++i) + { + for (int j = 0; j < len-1; ++j) + if (A[j][i] > A[j+1][i]) + { + ++ct; + break; + } + } + + return ct; + } \ No newline at end of file From 3fffff6f4bf6c6734c337c089d40e87bc0120b20 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 16 Feb 2020 17:00:03 +0800 Subject: [PATCH 37/97] 5 problems solved. --- src/1103.cpp | 33 +++++++++++++++++++++++++++++++++ src/1137.cpp | 15 +++++++++++++++ src/1170.cpp | 40 ++++++++++++++++++++++++++++++++++++++++ src/1189.cpp | 36 ++++++++++++++++++++++++++++++++++++ src/559.cpp | 26 ++++++++++++++++++++++++++ 5 files changed, 150 insertions(+) create mode 100644 src/1103.cpp create mode 100644 src/1137.cpp create mode 100644 src/1170.cpp create mode 100644 src/1189.cpp create mode 100644 src/559.cpp diff --git a/src/1103.cpp b/src/1103.cpp new file mode 100644 index 0000000..f9c9fc1 --- /dev/null +++ b/src/1103.cpp @@ -0,0 +1,33 @@ +vector distributeCandies(int candies, int num_people) { + int turn = 1; + while (true) + { + int t = (1+num_people*turn)*num_people*turn/2; + if (t >= candies) + break; + ++turn; + } + + vector res(num_people, 0); + for (int i = 1; i <= num_people; ++i) + res[i-1] = i*(turn-1) + (turn-1)*(turn-2)*num_people/2; + int i = 0; + candies -= (1+(turn-1)*num_people)*(turn-1)*num_people/2; + while (candies > 0 && i < num_people) + { + int n = i+1+(turn-1)*num_people; + if (n <= candies) + { + res[i] += n; + candies -= n; + } + else + { + res[i] += candies; + break; + } + ++i; + } + + return res; + } \ No newline at end of file diff --git a/src/1137.cpp b/src/1137.cpp new file mode 100644 index 0000000..2aba1fa --- /dev/null +++ b/src/1137.cpp @@ -0,0 +1,15 @@ +int tribonacci(int n) { + int arr[3] = {0,1,1}; + if (n <= 2) + return arr[n]; + + for (int i = 3; i <= n; ++i) + { + int t = arr[0] + arr[1] + arr[2]; + arr[0] = arr[1]; + arr[1] = arr[2]; + arr[2] = t; + } + + return arr[2]; + } \ No newline at end of file diff --git a/src/1170.cpp b/src/1170.cpp new file mode 100644 index 0000000..efc66fa --- /dev/null +++ b/src/1170.cpp @@ -0,0 +1,40 @@ +vector numSmallerByFrequency(vector& queries, vector& words) { + int len = queries.size(); + int sz = words.size(); + + vector res(len, 0); + vector freq(sz, 0); + for (int i = 0; i < sz; ++i) + freq[i] = calFreq(words[i]); + sort(freq.begin(), freq.end()); + + for (int i = 0; i < len; ++i) + { + int t = calFreq(queries[i]); + auto iter = upper_bound(freq.begin(), freq.end(), t); + res[i] = freq.end() - iter; + } + + return res; + } + + int calFreq(const string& str) + { + int len = str.size(); + int ct = 1; + char minval = str[0]; + for (int i = 1; i < len; ++i) + { + if (str[i] < minval) + { + minval = str[i]; + ct = 1; + } + else if (str[i] == minval) + { + ++ct; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/1189.cpp b/src/1189.cpp new file mode 100644 index 0000000..6953b94 --- /dev/null +++ b/src/1189.cpp @@ -0,0 +1,36 @@ +int maxNumberOfBalloons(string text) { + int len = text.size(); + if (len <= 5) + return 0; + + int arr[5] = {0}; + for (int i = 0; i < len; ++i) + { + switch(text[i]) + { + case 'a': + arr[0]++; + break; + case 'b': + arr[1]++; + break; + case 'l': + arr[4]++; + break; + case 'n': + arr[2]++; + break; + case 'o': + arr[3]++; + break; + } + } + + arr[3] /= 2; + arr[4] /= 2; + int minnum = arr[0]; + for (int i = 1; i < 5; ++i) + if (arr[i] < minnum) + minnum = arr[i]; + return minnum; + } \ No newline at end of file diff --git a/src/559.cpp b/src/559.cpp new file mode 100644 index 0000000..a9b658e --- /dev/null +++ b/src/559.cpp @@ -0,0 +1,26 @@ +int maxDepth(Node* root) { + if (root == nullptr) + return 0; + int maxdepth = 0; + maxdepth = search(root); + + return maxdepth+1; + } + + int search(Node* node) + { + auto& vec = node->children; + int len = vec.size(); + if (len == 0) + return 0; + + int maxd = 0; + for (int i = 0; i < len; ++i) + { + int t = search(vec[i]); + if (t > maxd) + maxd = t; + } + + return maxd+1; + } From b73b12d03dbb90bb00eddb8604662ff2f4b89940 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 22 Feb 2020 10:22:28 +0800 Subject: [PATCH 38/97] 6 problems solved. --- src/1030.cpp | 35 +++++++++++++++++++++++++++++++++++ src/1217.cpp | 22 ++++++++++++++++++++++ src/1351.cpp | 11 +++++++++++ src/589.cpp | 21 +++++++++++++++++++++ src/590.cpp | 22 ++++++++++++++++++++++ src/976.cpp | 15 +++++++++++++++ 6 files changed, 126 insertions(+) create mode 100644 src/1030.cpp create mode 100644 src/1217.cpp create mode 100644 src/1351.cpp create mode 100644 src/589.cpp create mode 100644 src/590.cpp create mode 100644 src/976.cpp diff --git a/src/1030.cpp b/src/1030.cpp new file mode 100644 index 0000000..eb8306a --- /dev/null +++ b/src/1030.cpp @@ -0,0 +1,35 @@ +vector> allCellsDistOrder(int R, int C, int r0, int c0) { + int total = R*C; + vector> res(total, vector(2, 0)); + struct Elem + { + int r; + int c; + int dist; + Elem(int _r = 0, int _c = 0):r(_r),c(_c){} + }; + + vector vec(total); + for (int i = 0; i < R; ++i) + { + for (int j = 0; j < C; ++j) + { + vec[i*C+j].r = i; + vec[i*C+j].c = j; + vec[i*C+j].dist = abs(i-r0) + abs(j-c0); + } + } + + auto cmp = [](const Elem& a, const Elem& b){ + return a.dist < b.dist; + }; + sort(vec.begin(), vec.end(), cmp); + + for (int i = 0; i < total; ++i) + { + res[i][0] = vec[i].r; + res[i][1] = vec[i].c; + } + + return res; + } \ No newline at end of file diff --git a/src/1217.cpp b/src/1217.cpp new file mode 100644 index 0000000..1d19f3a --- /dev/null +++ b/src/1217.cpp @@ -0,0 +1,22 @@ +int minCostToMoveChips(vector& chips) { + int len = chips.size(); + if (len == 1) + return 0; + + int minval = 100; + for (int i = 0; i >& grid) { + int row = grid.size(); + int col = grid[0].size(); + int ct = 0; + for (int i = 0; i < row; ++i) + { + ct += lower_bound(grid[i].rbegin(), grid[i].rend(), 0) - grid[i].rbegin(); + } + + return ct; + } \ No newline at end of file diff --git a/src/589.cpp b/src/589.cpp new file mode 100644 index 0000000..990d329 --- /dev/null +++ b/src/589.cpp @@ -0,0 +1,21 @@ +vector preorder(Node* root) { + if (root == nullptr) + return {}; + vector res; + search(root, res); + + return res; + } + + void search(Node* node, vector& res) + { + res.push_back(node->val); + int len = (node->children).size(); + if (len != 0) + { + for (int i = 0; i < len; ++i) + { + search((node->children)[i], res); + } + } + } \ No newline at end of file diff --git a/src/590.cpp b/src/590.cpp new file mode 100644 index 0000000..02a936f --- /dev/null +++ b/src/590.cpp @@ -0,0 +1,22 @@ +vector postorder(Node* root) { + if (root == nullptr) + return {}; + + vector res; + search(root, res); + + return res; + } + + void search(Node* node, vector& res) + { + int len = (node->children).size(); + if (len != 0) + { + for (int i = 0; i < len; ++i) + { + search((node->children)[i], res); + } + } + res.push_back(node->val); + } \ No newline at end of file diff --git a/src/976.cpp b/src/976.cpp new file mode 100644 index 0000000..794f897 --- /dev/null +++ b/src/976.cpp @@ -0,0 +1,15 @@ +int largestPerimeter(vector& A) { + sort(A.begin(), A.end()); + int len = A.size(); + int maxPeri = 0; + for (int i = len-1; i >= 2; --i) + { + if (A[i-2] + A[i-1] >A[i]) + { + maxPeri = A[i-2] + A[i-1] + A[i]; + break; + } + } + + return maxPeri; + } \ No newline at end of file From 313ffafc02d14fc1010aa6ffdfea3399d81dfbac Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 23 Feb 2020 12:48:18 +0800 Subject: [PATCH 39/97] 6 problems solved. --- src/1175.cpp | 30 ++++++++++++++++++++++++++++++ src/1356.cpp | 19 +++++++++++++++++++ src/733.cpp | 33 +++++++++++++++++++++++++++++++++ src/762.cpp | 32 ++++++++++++++++++++++++++++++++ src/993.cpp | 39 +++++++++++++++++++++++++++++++++++++++ src/997.cpp | 32 ++++++++++++++++++++++++++++++++ 6 files changed, 185 insertions(+) create mode 100644 src/1175.cpp create mode 100644 src/1356.cpp create mode 100644 src/733.cpp create mode 100644 src/762.cpp create mode 100644 src/993.cpp create mode 100644 src/997.cpp diff --git a/src/1175.cpp b/src/1175.cpp new file mode 100644 index 0000000..c7d1afb --- /dev/null +++ b/src/1175.cpp @@ -0,0 +1,30 @@ +int numPrimeArrangements(int n) { + if (n == 1) + return 1; + + int prime[] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61, + 67,71,73,79,83,89,97}; + int len = sizeof(prime)/sizeof(prime[0]); + int ct = 0; + for (int i = 0; i < len; ++i) + { + if (prime[i] <= n) + ++ct; + else + break; + } + + int mod = 1e9+7; + long long res = 1; + for (int i = 1; i <= ct; ++i) + { + res = (res*i)%mod; + } + ct = n-ct; + for (int i = 1; i <= ct; ++i) + { + res = (res*i)%mod; + } + + return res; + } \ No newline at end of file diff --git a/src/1356.cpp b/src/1356.cpp new file mode 100644 index 0000000..8e6d446 --- /dev/null +++ b/src/1356.cpp @@ -0,0 +1,19 @@ +vector sortByBits(vector& arr) { + int len = arr.size(); + if (len == 1) + return arr; + vector> vec; + for (int i = 0; i < len; ++i) + vec.push_back(arr[i]); + auto cmp = [](const bitset<32>& a, const bitset<32>& b) { + int m = a.count(), n = b.count(); + return m < n || (m == n && a.to_ulong() < b.to_ulong()); + }; + + sort(vec.begin(), vec.end(), cmp); + vector res(len); + for (int i = 0; i < len; ++i) + res[i] = vec[i].to_ulong(); + + return res; + } \ No newline at end of file diff --git a/src/733.cpp b/src/733.cpp new file mode 100644 index 0000000..57c7dee --- /dev/null +++ b/src/733.cpp @@ -0,0 +1,33 @@ +vector> floodFill(vector>& image, int sr, int sc, int newColor) { + int row = image.size(); + int col = image[0].size(); + vector> flag(row, vector(col, 0)); + vector> res(image); + + deque> dq; + dq.push_back(make_pair(sr, sc)); + int color = image[sr][sc]; + + int len = 1; + while (len != 0) + { + for (int i = 0; i < len; ++i) + { + int m = dq[i].first, n = dq[i].second; + res[m][n] = newColor; + flag[m][n] = 1; + if (m > 0 && flag[m-1][n] == 0 && image[m-1][n] == color) + dq.push_back(make_pair(m-1, n)); + if (m < row-1 && flag[m+1][n] == 0 && image[m+1][n] == color) + dq.push_back(make_pair(m+1, n)); + if (n > 0 && flag[m][n-1] == 0 && image[m][n-1] == color) + dq.push_back(make_pair(m, n-1)); + if (n < col-1 && flag[m][n+1] == 0 && image[m][n+1] == color) + dq.push_back(make_pair(m, n+1)); + } + dq.erase(dq.begin(), dq.begin()+len); + len = dq.size(); + } + + return res; + } \ No newline at end of file diff --git a/src/762.cpp b/src/762.cpp new file mode 100644 index 0000000..abd2339 --- /dev/null +++ b/src/762.cpp @@ -0,0 +1,32 @@ +int countPrimeSetBits(int L, int R) { + bitset<32> num(L); + string s = num.to_string(); + set prime{2,3,5,7,11,13,17,19,23,29,31}; + int ct = num.count(); + + int res = 0; + while (L <= R) + { + if (prime.find(ct) != prime.end()) + ++res; + int t = 1; + for (int i = 31; i >= 0; --i) + { + char c = s[i] + t; + if (c == '1') + { + ++ct; + s[i] = '1'; + break; + } + else + { + --ct; + s[i] = '0'; + } + } + ++L; + } + + return res; + } \ No newline at end of file diff --git a/src/993.cpp b/src/993.cpp new file mode 100644 index 0000000..296483c --- /dev/null +++ b/src/993.cpp @@ -0,0 +1,39 @@ +bool isCousins(TreeNode* root, int x, int y) { + deque dq; + dq.push_back(root); + int ct = 1; + int n = 0; + int p[2] = {-1,-1}; + while (ct != 0) + { + ct = 0; + int len = dq.size(); + for (int i = 0; i < len; ++i) + { + if (dq[i] == nullptr) + { + dq.push_back(nullptr); + dq.push_back(nullptr); + } + else if (dq[i]->val == x || dq[i]->val == y) + { + p[n++] = i; + } + else + { + dq.push_back(dq[i]->left); + dq.push_back(dq[i]->right); + ++ct; + } + } + if (n == 1 || n == 2 || ct == 0) + break; + dq.erase(dq.begin(), dq.begin()+len); + } + + if (n == 1) + return false; + if (n == 2) + return p[0]/2 != p[1]/2; + return false; + } \ No newline at end of file diff --git a/src/997.cpp b/src/997.cpp new file mode 100644 index 0000000..096237a --- /dev/null +++ b/src/997.cpp @@ -0,0 +1,32 @@ +int findJudge(int N, vector>& trust) { + vector> vec(N); + int len = trust.size(); + for (int i = 0; i < len; ++i) + { + vec[trust[i][1]-1].push_back(trust[i][0]); + } + + int judge = -1; + int ct = 0; + for (int i = 0; i < N; ++i) + if (vec[i].size() == N-1) + { + judge = i+1; + ++ct; + } + if (ct != 1) + return -1; + for (int i = 0; i < N; ++i) + { + if (i != judge-1 && vec[i].size() != 0) + { + for (auto iter = vec[i].begin(); iter != vec[i].end(); ++iter) + { + if (*iter == judge) + return -1; + } + } + } + + return judge; + } \ No newline at end of file From e5650c7f69f157da76c49967315ba50a5f605c97 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 29 Feb 2020 11:39:37 +0800 Subject: [PATCH 40/97] 6 problems solved. --- src/1037.cpp | 11 +++++++++ src/1128.cpp | 28 +++++++++++++++++++++ src/1154.cpp | 19 +++++++++++++++ src/1184.cpp | 22 +++++++++++++++++ src/1232.cpp | 35 ++++++++++++++++++++++++++ src/594.cpp | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 184 insertions(+) create mode 100644 src/1037.cpp create mode 100644 src/1128.cpp create mode 100644 src/1154.cpp create mode 100644 src/1184.cpp create mode 100644 src/1232.cpp create mode 100644 src/594.cpp diff --git a/src/1037.cpp b/src/1037.cpp new file mode 100644 index 0000000..66ea512 --- /dev/null +++ b/src/1037.cpp @@ -0,0 +1,11 @@ +bool isBoomerang(vector>& points) { + if (points[0] == points[1] || points[0] == points[2] || points[1] == points[2]) + return false; + if (points[0][0] == points[1][0]) + return points[0][0] != points[2][0]; + else if (points[0][1] == points[1][1]) + return points[0][1] != points[2][1]; + else + return (points[1][1]-points[0][1])*(points[2][0]-points[1][0]) != + (points[2][1]-points[1][1])*(points[1][0]-points[0][0]); + } \ No newline at end of file diff --git a/src/1128.cpp b/src/1128.cpp new file mode 100644 index 0000000..672456b --- /dev/null +++ b/src/1128.cpp @@ -0,0 +1,28 @@ +int numEquivDominoPairs(vector>& dominoes) { + int len = dominoes.size(); + if (len == 1) + return 0; + vector> vec(9, vector(9, 0)); + for (int i = 0; i < len; ++i) + { + int r = dominoes[i][0]; + int c = dominoes[i][1]; + if (r > c) + { + int t = r; + r = c; + c = t; + } + vec[r-1][c-1]++; + } + + int res = 0; + for (int i = 0; i < 9; ++i) + { + for (int j = i; j < 9; ++j) + if (vec[i][j] != 0) + res += vec[i][j]*(vec[i][j]-1)/2; + } + + return res; + } \ No newline at end of file diff --git a/src/1154.cpp b/src/1154.cpp new file mode 100644 index 0000000..01d98a3 --- /dev/null +++ b/src/1154.cpp @@ -0,0 +1,19 @@ +int dayOfYear(string date) { + int days[12] = {31,28,31,30,31,30,31,31,30,31,30,31}; + + int num = 0; + if (date[5] == '0') + num = date[6]-'0'-1; + else + num = date[6]-'0'+9; + int ct = 0; + for (int i = 0; i < num; ++i) + ct += days[i]; + ct += (date[8]-'0')*10 + (date[9]-'0'); + + int year = atoi(date.substr(0,4).c_str()); + if (num >= 2 && ((year%4 == 0 && year%100 != 0) || year%400 == 0)) + ++ct; + + return ct; + } \ No newline at end of file diff --git a/src/1184.cpp b/src/1184.cpp new file mode 100644 index 0000000..40e0f6c --- /dev/null +++ b/src/1184.cpp @@ -0,0 +1,22 @@ +int distanceBetweenBusStops(vector& distance, int start, int destination) { + int len = distance.size(); + if (len == 1 || start == destination) + return 0; + if (start > destination) + { + int t = start; + start = destination; + destination = t; + } + + int dist = 0, sum = 0; + for (int i = 0; i < len; ++i) + { + sum += distance[i]; + if (i >= start && i < destination) + dist += distance[i]; + } + + sum -= dist; + return dist < sum ? dist : sum; + } \ No newline at end of file diff --git a/src/1232.cpp b/src/1232.cpp new file mode 100644 index 0000000..8583732 --- /dev/null +++ b/src/1232.cpp @@ -0,0 +1,35 @@ +bool checkStraightLine(vector>& coordinates) { + int len = coordinates.size(); + if (len == 2) + return true; + + int dx = coordinates[1][0]-coordinates[0][0], dy = coordinates[1][1]-coordinates[0][1]; + if (dx == 0) + { + for (int i = 2; i < len; ++i) + if (coordinates[i][0] != coordinates[0][0]) + return false; + return true; + } + else if (dy == 0) + { + for (int i = 2; i < len; ++i) + if (coordinates[i][1] != coordinates[0][1]) + return false; + return true; + } + else + { + for (int i = 2; i < len; ++i) + { + int dy1 = coordinates[1][1]-coordinates[0][1]; + int dx2 = coordinates[i][0]-coordinates[1][0]; + int dy2 = coordinates[i][1]-coordinates[1][1]; + int dx1 = coordinates[1][0]-coordinates[0][0]; + if (dy1*dx2 != dy2*dx1) + return false; + } + + return true; + } + } \ No newline at end of file diff --git a/src/594.cpp b/src/594.cpp new file mode 100644 index 0000000..eabb28b --- /dev/null +++ b/src/594.cpp @@ -0,0 +1,69 @@ +int findLHS(vector& nums) { + int len = nums.size(); + if (len <= 1) + return 0; + + sort(nums.begin(), nums.end()); + int a = nums[0], b = nums[1]; + int maxlen = 0; + int sublen = (b-a == 1) ? 2 : 0; + int i = 2; + int p = -1, q = -1; + if (sublen == 2) + { + p = 0; + q = 1; + } + while (i < len) + { + if (sublen != 0) + { + if (nums[i] == nums[i-1]) + { + ++sublen; + q = i; + } + else + { + if (nums[i]-nums[i-1] == 1) + { + int j = i-1; + while (j >= 0 && nums[j] == nums[i-1]) + --j; + p = j+1; + q = i; + if (sublen > maxlen) + maxlen = sublen; + sublen = i-j; + } + else + { + p = -1; + q = -1; + if (sublen > maxlen) + maxlen = sublen; + sublen = 0; + } + } + } + else + { + if (nums[i]-nums[i-1] == 1) + { + int j = i-1; + while (j >= 0 && nums[j] == nums[i-1]) + --j; + p = j+1; + q = i; + if (sublen > maxlen) + maxlen = sublen; + sublen = i-j; + } + } + ++i; + } + + if (sublen > maxlen) + maxlen = sublen; + return maxlen; + } \ No newline at end of file From 50a0106b052c9bf5f81af4bd79cee9eafec0b71c Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 1 Mar 2020 12:09:29 +0800 Subject: [PATCH 41/97] 5 problems solved. --- src/1010.cpp | 20 +++++++++ src/1018.cpp | 16 ++++++++ src/783.cpp | 37 +++++++++++++++++ src/830.cpp | 35 ++++++++++++++++ src/994.cpp | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 222 insertions(+) create mode 100644 src/1010.cpp create mode 100644 src/1018.cpp create mode 100644 src/783.cpp create mode 100644 src/830.cpp create mode 100644 src/994.cpp diff --git a/src/1010.cpp b/src/1010.cpp new file mode 100644 index 0000000..846d2d1 --- /dev/null +++ b/src/1010.cpp @@ -0,0 +1,20 @@ +int numPairsDivisibleBy60(vector& time) { + int len = time.size(); + if (len == 1) + return 0; + + vector vec(60); + for (int i = 0; i < len; ++i) + { + vec[time[i]%60]++; + } + + int sum = 0; + sum += vec[0]*(vec[0]-1)/2 + vec[30]*(vec[30]-1)/2; + for (int i = 1; i <= 29; ++i) + { + sum += vec[i]*vec[60-i]; + } + + return sum; + } \ No newline at end of file diff --git a/src/1018.cpp b/src/1018.cpp new file mode 100644 index 0000000..b9db574 --- /dev/null +++ b/src/1018.cpp @@ -0,0 +1,16 @@ +vector prefixesDivBy5(vector& A) { + int len = A.size(); + int sum = 0; + vector vec(len); + for (int i = 0; i < len; ++i) + { + sum = sum*2 + A[i]; + sum %= 5; + if (sum%5 == 0) + vec[i] = true; + else + vec[i] = false; + } + + return vec; + } \ No newline at end of file diff --git a/src/783.cpp b/src/783.cpp new file mode 100644 index 0000000..3ea6331 --- /dev/null +++ b/src/783.cpp @@ -0,0 +1,37 @@ +int minDiffInBST(TreeNode* root) { + int mindiff = INT_MAX; + int ct = 0; + int m = 0, n = 0; + search(root, mindiff, m, n, ct); + + return mindiff; + } + + void search(TreeNode* node, int& mindiff, int& m, int& n, int& ct) + { + if (node->left != nullptr) + search(node->left, mindiff, m, n, ct); + if (ct == 0) + { + m = node->val; + ++ct; + } + else if (ct == 1) + { + n = node->val; + int diff = n-m; + if (diff < mindiff) + mindiff = diff; + ++ct; + } + else + { + m = n; + n = node->val; + int diff = n-m; + if (diff < mindiff) + mindiff = diff; + } + if (node->right != nullptr) + search(node->right, mindiff, m, n, ct); + } \ No newline at end of file diff --git a/src/830.cpp b/src/830.cpp new file mode 100644 index 0000000..433afe2 --- /dev/null +++ b/src/830.cpp @@ -0,0 +1,35 @@ +vector> largeGroupPositions(string S) { + int len = S.size(); + if (len <= 2) + return {}; + + int ct = 1; + int c = S[0]; + int i = 1; + int p = 0, q = 0; + vector> res; + while (i < len) + { + if (S[i] == c) + { + ++ct; + q = i; + } + else + { + if (ct >= 3) + { + res.push_back({p, q}); + } + p = i; + q = i; + c = S[i]; + ct = 1; + } + ++i; + } + if (ct >= 3) + res.push_back({p, q}); + + return res; + } \ No newline at end of file diff --git a/src/994.cpp b/src/994.cpp new file mode 100644 index 0000000..5289a5c --- /dev/null +++ b/src/994.cpp @@ -0,0 +1,114 @@ +int orangesRotting(vector>& grid) { + int row = grid.size(); + int col = grid[0].size(); + if (row == 1 && col == 1) + return grid[0][0] == 1 ? -1 : 0; + + int ct = 0; + vector> flag(row, vector(col, 0)); + while (true) + { + bool flag2 = false; + for (int i = 0; i < row; ++i) + { + for (int j = 0; j < col; ++j) + { + if (flag[i][j] == 0 && grid[i][j] == 2) + { + flag2 |= search(grid, row, col, flag, i, j); + } + } + } + if (!flag2) + break; + else + ++ct; + flag.assign(row, vector(col, 0)); + } + + for (int i = 0; i < row; ++i) + { + for (int j = 0; j < col; ++j) + if (grid[i][j] == 1) + return -1; + } + + return ct; + } + + bool search(vector>& grid, int row, int col, vector>& flag, int m, int n) + { + deque> dq; + dq.push_back(make_pair(m, n)); + int len = 1; + bool status = false; + while (len != 0) + { + for (int i = 0; i < len; ++i) + { + int p = dq[i].first, q = dq[i].second; + flag[p][q] = 1; + grid[p][q] = 0; + if (p > 0 && flag[p-1][q] == 0 && grid[p-1][q] != 0) + { + if (grid[p-1][q] == 1) + { + grid[p-1][q] = 2; + status = true; + } + else + { + grid[p-1][q] = 0; + dq.push_back(make_pair(p-1, q)); + } + flag[p-1][q] = 1; + } + if (p < row-1 && flag[p+1][q] == 0 && grid[p+1][q] != 0) + { + if (grid[p+1][q] == 1) + { + grid[p+1][q] = 2; + status = true; + } + else + { + grid[p+1][q] = 0; + dq.push_back(make_pair(p+1, q)); + } + flag[p+1][q] = 1; + } + if (q > 0 && flag[p][q-1] == 0 && grid[p][q-1] != 0) + { + if (grid[p][q-1] == 1) + { + grid[p][q-1] = 2; + status = true; + } + else + { + grid[p][q-1] = 0; + dq.push_back(make_pair(p, q-1)); + } + flag[p][q-1] = 1; + } + if (q < col-1 && flag[p][q+1] == 0 && grid[p][q+1] != 0) + { + if (grid[p][q+1] == 1) + { + grid[p][q+1] = 2; + status = true; + } + else + { + grid[p][q+1] = 0; + dq.push_back(make_pair(p, q+1)); + } + flag[p][q+1] = 1; + } + } + dq.erase(dq.begin(), dq.begin()+len); + len = dq.size(); + } + + return status; + } \ No newline at end of file From 7d1ff607bce9c217a4321fe066e77ba5ff802fe1 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 7 Mar 2020 19:34:07 +0800 Subject: [PATCH 42/97] 4 problems solved. --- src/1360.cpp | 41 +++++++++++++++++++++++++++++++++++++++++ src/1365.cpp | 20 ++++++++++++++++++++ src/532.cpp | 29 +++++++++++++++++++++++++++++ src/970.cpp | 38 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 128 insertions(+) create mode 100644 src/1360.cpp create mode 100644 src/1365.cpp create mode 100644 src/532.cpp create mode 100644 src/970.cpp diff --git a/src/1360.cpp b/src/1360.cpp new file mode 100644 index 0000000..a6ab149 --- /dev/null +++ b/src/1360.cpp @@ -0,0 +1,41 @@ +int daysBetweenDates(string date1, string date2) { + + int mdays[12] = {31,28,31,30,31,30, + 31,31,30,31,30,31}; + int year1 = atoi(date1.substr(0, 4).c_str()); + int year2 = atoi(date2.substr(0, 4).c_str()); + int month1 = (date1[5]-'0')*10 + (date1[6]-'0'); + int month2 = (date2[5]-'0')*10 + (date2[6]-'0'); + int day1 = (date1[8]-'0')*10 + (date1[9]-'0'); + int day2 = (date2[8]-'0')*10 + (date2[9]-'0'); + + int interval1 = 0, interval2 = 0; + for (int i = 1971; i < year1; ++i) + interval1 += (i-1972)%4 != 0 ? 365 : 366; + for (int i = 1971; i < year2; ++i) + interval2 += (i-1972)%4 != 0 ? 365 : 366; + + for (int i = 1; i < month1; ++i) + { + interval1 += mdays[i-1]; + if (i == 2) + { + if ((year1-1972)%4 == 0 && year1 != 2100) + interval1 += 1; + } + } + + for (int i = 1; i < month2; ++i) + { + interval2 += mdays[i-1]; + if (i == 2) + { + if ((year2-1972)%4 == 0 && year2 != 2100) + interval2 += 1; + } + } + interval1 += day1; + interval2 += day2; + + return abs(interval1-interval2); + } \ No newline at end of file diff --git a/src/1365.cpp b/src/1365.cpp new file mode 100644 index 0000000..265282a --- /dev/null +++ b/src/1365.cpp @@ -0,0 +1,20 @@ +vector smallerNumbersThanCurrent(vector& nums) { + int len = nums.size(); + vector ct(101); + vector sum(101); + for (int i = 0; i < len; ++i) + ++ct[nums[i]]; + + int subsum = 0; + for (int i = 1; i < 101; ++i) + { + subsum += ct[i-1]; + sum[i] = subsum; + } + + vector res(len); + for (int i = 0; i < len; ++i) + res[i] = sum[nums[i]]; + + return res; + } \ No newline at end of file diff --git a/src/532.cpp b/src/532.cpp new file mode 100644 index 0000000..9c0568d --- /dev/null +++ b/src/532.cpp @@ -0,0 +1,29 @@ +int findPairs(vector& nums, int k) { + sort(nums.begin(), nums.end()); + int len = nums.size(); + if (len <= 1) + return 0; + if (len == 2) + return nums[1]-nums[0] == k ? 1 : 0; + int i = 0; + int j = 1; + int ct = 0; + while (i < len-1 && j < len) + { + int t = nums[j] - nums[i]; + if (t < k) + ++j; + else + { + if (t == k) + ++ct; + int n = i+1; + while (n < len && nums[n] == nums[i]) + ++n; + i = n; + j = i+1; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/970.cpp b/src/970.cpp new file mode 100644 index 0000000..17df167 --- /dev/null +++ b/src/970.cpp @@ -0,0 +1,38 @@ +vector powerfulIntegers(int x, int y, int bound) { + if (bound <= 1) + return {}; + if (bound == 2) + return {2}; + if (x == 1 && y == 1) + return {2}; + if (x == 1 || y == 1) + { + int t = x != 1 ? x : y; + int x = 1; + int sz = log(bound-1)/log(t)+1; + vector res(sz); + for (int i = 0; i < sz; ++i) + { + res[i] = 1+x; + x *= t; + } + return res; + } + + int m = log(bound)/log(x); + int n = log(bound)/log(y); + set st; + for (int i = 0; i <= m; ++i) + { + for (int j = 0; j <= n; ++j) + { + double t = pow(x, i) + pow(y, j); + if (t <= bound) + st.insert(t); + } + } + + vector res; + res.assign(st.begin(), st.end()); + return res; + } \ No newline at end of file From 1543f0cd9df9e437054a6b6f23b06c983d7dcfb4 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 8 Mar 2020 18:14:52 +0800 Subject: [PATCH 43/97] 5 problems solved. --- src/1302.cpp | 24 +++++++++++++++++++++++ src/1329.cpp | 34 ++++++++++++++++++++++++++++++++ src/235.cpp | 33 +++++++++++++++++++++++++++++++ src/414.cpp | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/643.cpp | 22 +++++++++++++++++++++ 5 files changed, 168 insertions(+) create mode 100644 src/1302.cpp create mode 100644 src/1329.cpp create mode 100644 src/235.cpp create mode 100644 src/414.cpp create mode 100644 src/643.cpp diff --git a/src/1302.cpp b/src/1302.cpp new file mode 100644 index 0000000..44ee38b --- /dev/null +++ b/src/1302.cpp @@ -0,0 +1,24 @@ +int deepestLeavesSum(TreeNode* root) { + deque dq; + dq.push_back(root); + int len = 1; + int sum = 0; + while (len != 0) + { + int subsum = 0; + for (int i = 0; i < len; ++i) + { + TreeNode* node = dq[i]; + subsum += node->val; + if (node->left != nullptr) + dq.push_back(node->left); + if (node->right != nullptr) + dq.push_back(node->right); + } + sum = subsum; + dq.erase(dq.begin(), dq.begin()+len); + len = dq.size(); + } + + return sum; + } \ No newline at end of file diff --git a/src/1329.cpp b/src/1329.cpp new file mode 100644 index 0000000..c2be805 --- /dev/null +++ b/src/1329.cpp @@ -0,0 +1,34 @@ +vector> diagonalSort(vector>& mat) { + int row = mat.size(); + int col = mat[0].size(); + if (row == 1 || col == 1) + return mat; + + int minval = row < col ? row : col; + vector vec(minval); + for (int i = row-2; i >= 0; --i) + { + int k = row-i; + if (col < k) + k = col; + for (int j = 0; j < k; ++j) + vec[j] = mat[i+j][j]; + sort(vec.begin(), vec.begin()+k); + for (int j = 0; j < k; ++j) + mat[i+j][j] = vec[j]; + } + + for (int i = 1; i < col-1; ++i) + { + int k = col-i; + if (row < k) + k = row; + for (int j = 0; j < k; ++j) + vec[j] = mat[j][i+j]; + sort(vec.begin(), vec.begin()+k); + for (int j = 0; j < k; ++j) + mat[j][i+j] = vec[j]; + } + + return mat; + } \ No newline at end of file diff --git a/src/235.cpp b/src/235.cpp new file mode 100644 index 0000000..4717ee6 --- /dev/null +++ b/src/235.cpp @@ -0,0 +1,33 @@ +TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { + if (root == p || root == q) + return root; + vector path; + TreeNode* node = root; + while (node != nullptr) + { + path.push_back(node); + if (node->val > p->val) + { + node = node->left; + } + else if (node->val == p->val) + break; + else + { + node = node->right; + } + } + + node = root; + int len = path.size(); + int i = 0; + while (i < len && node == path[i]) + { + if (node == p || node == q) + return node; + node = node->val > q->val ? node->left : node->right; + ++i; + } + + return path[i-1]; + } \ No newline at end of file diff --git a/src/414.cpp b/src/414.cpp new file mode 100644 index 0000000..864033a --- /dev/null +++ b/src/414.cpp @@ -0,0 +1,55 @@ +int thirdMax(vector& nums) { + int len = nums.size(); + if (len == 1) + return nums[0]; + if (len == 2) + return nums[0] > nums[1] ? nums[0] : nums[1]; + int arr[3] = {0}; + arr[0] = nums[0]; + int ct = 1; + int i = 1; + while (i < len) + { + if (ct == 1) + { + if (nums[i] != arr[0]) + { + arr[1] = nums[i]; + ++ct; + } + } + else if (ct == 2) + { + if (nums[i] != arr[0] && nums[i] != arr[1]) + { + arr[2] = nums[i]; + ++ct; + sort(arr, arr+3); + } + } + else + { + if (nums[i] > arr[0] && nums[i] < arr[1]) + arr[0] = nums[i]; + else if (nums[i] > arr[1] && nums[i] < arr[2]) + { + arr[0] = arr[1]; + arr[1] = nums[i]; + } + else if (nums[i] > arr[2]) + { + arr[0] = arr[1]; + arr[1] = arr[2]; + arr[2] = nums[i]; + } + } + ++i; + } + + if (ct == 1) + return arr[0]; + else if (ct == 2) + return arr[0] > arr[1] ? arr[0] : arr[1]; + else + return arr[0]; + } \ No newline at end of file diff --git a/src/643.cpp b/src/643.cpp new file mode 100644 index 0000000..2aef11f --- /dev/null +++ b/src/643.cpp @@ -0,0 +1,22 @@ +double findMaxAverage(vector& nums, int k) { + int maxsum = INT_MIN; + int len = nums.size(); + if (len <= k-1) + return 0; + int subsum = 0; + for (int i = 0; i < k; ++i) + subsum += nums[i]; + if (subsum > maxsum) + maxsum = subsum; + int i = 0, j = k; + while (j < len) + { + subsum = subsum - nums[i] + nums[j]; + if (subsum > maxsum) + maxsum = subsum; + ++i; + ++j; + } + + return (double)maxsum/k; + } \ No newline at end of file From cd1d8e42daa96d9368ff4c5ea6cbc7b58b728939 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 14 Mar 2020 09:23:08 +0800 Subject: [PATCH 44/97] 6 problems solved. --- src/1161.cpp | 37 ++++++++++++++++++++++++++++++++++ src/1370.cpp | 35 ++++++++++++++++++++++++++++++++ src/1374.cpp | 8 ++++++++ src/701.cpp | 13 ++++++++++++ src/914.cpp | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/941.cpp | 25 +++++++++++++++++++++++ 6 files changed, 174 insertions(+) create mode 100644 src/1161.cpp create mode 100644 src/1370.cpp create mode 100644 src/1374.cpp create mode 100644 src/701.cpp create mode 100644 src/914.cpp create mode 100644 src/941.cpp diff --git a/src/1161.cpp b/src/1161.cpp new file mode 100644 index 0000000..6673893 --- /dev/null +++ b/src/1161.cpp @@ -0,0 +1,37 @@ +int maxLevelSum(TreeNode* root) { + if (root == nullptr) + return 1; + if (root->left == nullptr && root->right == nullptr) + return 1; + + deque dq; + dq.push_back(root); + int len = 1; + int maxval = root->val; + int level = 1; + int ct = 0; + while (len != 0) + { + ++ct; + int sum = 0; + for (int i = 0; i < len; ++i) + { + TreeNode* node = dq[i]; + sum += node->val; + if (node->left != nullptr) + dq.push_back(node->left); + if (node->right != nullptr) + dq.push_back(node->right); + } + + if (sum > maxval) + { + maxval = sum; + level = ct; + } + dq.erase(dq.begin(), dq.begin()+len); + len = dq.size(); + } + + return level; + } \ No newline at end of file diff --git a/src/1370.cpp b/src/1370.cpp new file mode 100644 index 0000000..8b522d4 --- /dev/null +++ b/src/1370.cpp @@ -0,0 +1,35 @@ +string sortString(string s) { + int len = s.size(); + if (len == 1) + return s; + + vector num(26, 0); + for (int i = 0; i < len; ++i) + num[s[i]-'a']++; + int k = 0; + string res(len, ' '); + while (k < len) + { + for (int i = 0; i < 26; ++i) + { + if (num[i] > 0) + { + res[k++] = 'a'+i; + --num[i]; + } + } + + if (k == len) + break; + for (int i = 25; i >= 0; --i) + { + if (num[i] > 0) + { + res[k++] = 'a'+i; + --num[i]; + } + } + } + + return res; + } \ No newline at end of file diff --git a/src/1374.cpp b/src/1374.cpp new file mode 100644 index 0000000..b0b8f18 --- /dev/null +++ b/src/1374.cpp @@ -0,0 +1,8 @@ +string generateTheString(int n) { + if (n == 1) + return "a"; + else if (n%2 == 0) + return string(1, 'a') + string(n-1, 'b'); + else + return string(n, 'a'); + } \ No newline at end of file diff --git a/src/701.cpp b/src/701.cpp new file mode 100644 index 0000000..d8bf870 --- /dev/null +++ b/src/701.cpp @@ -0,0 +1,13 @@ +TreeNode* insertIntoBST(TreeNode* root, int val) { + if (root == nullptr) + { + TreeNode* node = new TreeNode(val); + return node; + } + else if (val < root->val) + root->left = insertIntoBST(root->left, val); + else + root->right = insertIntoBST(root->right, val); + + return root; + } \ No newline at end of file diff --git a/src/914.cpp b/src/914.cpp new file mode 100644 index 0000000..5b0ed69 --- /dev/null +++ b/src/914.cpp @@ -0,0 +1,56 @@ +bool hasGroupsSizeX(vector& deck) { + int len = deck.size(); + if (len <= 1) + return false; + if (len == 2) + return deck[0] == deck[1]; + + map mp; + for (int i = 0; i < len; ++i) + mp[deck[i]]++; + + int sz = mp.size(); + if (sz == 1) + return true; + auto iter = mp.begin(); + int a = iter->second; + ++iter; + int b = iter->second; + ++iter; + int div = gcd(a, b); + if (div == 1) + return false; + for (; iter != mp.end(); ++iter) + { + div = gcd(iter->second, div); + if (div == 1) + return false; + } + + return true; + } + + int gcd(int a, int b) + { + if (a > b) + { + int t = a; + a = b; + b = t; + } + + while (a != 1) + { + b %= a; + if (b == 0) + break; + if (a > b) + { + int t = a; + a = b; + b = t; + } + } + + return a; + } \ No newline at end of file diff --git a/src/941.cpp b/src/941.cpp new file mode 100644 index 0000000..8b11d72 --- /dev/null +++ b/src/941.cpp @@ -0,0 +1,25 @@ +bool validMountainArray(vector& A) { + int len = A.size(); + if (len < 3) + return false; + + int i = 1; + for (i = 1; i < len; ++i) + { + if (A[i] == A[i-1]) + return false; + if (A[i] < A[i-1]) + break; + } + if (i == 1 || i == len) + return false; + if (i == len-1) + return true; + for (; i < len-1; ++i) + { + if (A[i] <= A[i+1]) + return false; + } + + return true; + } \ No newline at end of file From f9c7b9de17e8aac7b2855a24b2200e14c24c1dd0 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 22 Mar 2020 01:30:14 +0800 Subject: [PATCH 45/97] 5 problems solved. --- src/1008.cpp | 31 +++++++++++++++++++++++++++++++ src/1380.cpp | 35 +++++++++++++++++++++++++++++++++++ src/501.cpp | 37 +++++++++++++++++++++++++++++++++++++ src/680.cpp | 38 ++++++++++++++++++++++++++++++++++++++ src/868.cpp | 34 ++++++++++++++++++++++++++++++++++ 5 files changed, 175 insertions(+) create mode 100644 src/1008.cpp create mode 100644 src/1380.cpp create mode 100644 src/501.cpp create mode 100644 src/680.cpp create mode 100644 src/868.cpp diff --git a/src/1008.cpp b/src/1008.cpp new file mode 100644 index 0000000..144daba --- /dev/null +++ b/src/1008.cpp @@ -0,0 +1,31 @@ +TreeNode* bstFromPreorder(vector& preorder) { + int len = preorder.size(); + if (len == 0) + return nullptr; + if (len == 1) + return new TreeNode(preorder[0]); + + return search(preorder, 0, len-1); + } + + TreeNode* search(vector& vec, int p, int q) + { + if (p > q) + return nullptr; + if (p == q) + return new TreeNode(vec[p]); + TreeNode* node = new TreeNode(vec[p]); + int i = 0; + for (i = p+1; i <= q; ++i) + { + if (vec[i] > vec[p]) + break; + } + + if (vec[p+1] < vec[p]) + node->left = search(vec, p+1, i-1); + if (i <= q) + node->right = search(vec, i, q); + + return node; + } \ No newline at end of file diff --git a/src/1380.cpp b/src/1380.cpp new file mode 100644 index 0000000..4963194 --- /dev/null +++ b/src/1380.cpp @@ -0,0 +1,35 @@ +vector luckyNumbers (vector>& matrix) { + int row = matrix.size(); + int col = matrix[0].size(); + + vector res; + for (int i = 0; i < row; ++i) + { + int minval = matrix[i][0]; + int index = 0; + int j = 0; + for (j = 1; j < col; ++j) + { + if (matrix[i][j] < minval) + { + index = j; + minval = matrix[i][j]; + } + } + + bool flag = true; + for (j = 0; j < row; ++j) + { + if (matrix[j][index] > minval) + { + flag = false; + break; + } + } + + if (flag) + res.push_back(minval); + } + + return res; + } \ No newline at end of file diff --git a/src/501.cpp b/src/501.cpp new file mode 100644 index 0000000..ab50209 --- /dev/null +++ b/src/501.cpp @@ -0,0 +1,37 @@ +vector findMode(TreeNode* root) { + if (root == nullptr) + return {}; + if (root->left == nullptr && root->right == nullptr) + return {root->val}; + + map mp; + mp[root->val] = 1; + if (root->left != nullptr) + search(root->left, mp); + if (root->right != nullptr) + search(root->right, mp); + int m = 0; + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + { + if (iter->second > m) + m = iter->second; + } + + vector res; + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + { + if (iter->second == m) + res.push_back(iter->first); + } + + return res; + } + + void search(TreeNode* node, map& mp) + { + mp[node->val]++; + if (node->left != nullptr) + search(node->left, mp); + if (node->right != nullptr) + search(node->right, mp); + } \ No newline at end of file diff --git a/src/680.cpp b/src/680.cpp new file mode 100644 index 0000000..2f4948c --- /dev/null +++ b/src/680.cpp @@ -0,0 +1,38 @@ +bool validPalindrome(string s) { + int len = s.size(); + if (len <= 2) + return true; + + return search(s, 0, len-1, false); + } + + bool search(const string& s, int p, int q, bool flag) + { + if (p >= q) + return true; + if (flag) + { + while (p < q) + { + if (s[p] != s[q]) + return false; + else + { + ++p; + --q; + } + } + + return true; + } + else + { + if (s[p] == s[q]) + { + return search(s, p+1, q-1, false) || search(s, p+1, q, true) + || search(s, p, q-1, true); + } + else + return search(s, p+1, q, true) || search(s, p, q-1, true); + } + } \ No newline at end of file diff --git a/src/868.cpp b/src/868.cpp new file mode 100644 index 0000000..0333c03 --- /dev/null +++ b/src/868.cpp @@ -0,0 +1,34 @@ +int binaryGap(int N) { + int index[2] = {-1,-1}; + int ct = 0; + int i = 0, maxdist = 0; + while (N != 0) + { + if (N%2 == 1) + { + if (ct < 2) + { + index[ct++] = i; + } + else + { + int t = index[1] - index[0]; + if (t > maxdist) + maxdist = t; + index[0] = index[1]; + index[1] = i; + } + } + N /= 2; + ++i; + } + if (ct < 2) + return 0; + else + { + int t = index[1] - index[0]; + if (t > maxdist) + maxdist = t; + return maxdist; + } + } \ No newline at end of file From ad2603744acbcc8bef480820e0cb22fa38402770 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 19 Apr 2020 01:31:31 +0800 Subject: [PATCH 46/97] 11 problems solved. --- src/1261.cpp | 46 ++++++++++++++++++++++++++++++++++++++++++++++ src/1314.cpp | 22 ++++++++++++++++++++++ src/1379.cpp | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/1381.cpp | 36 ++++++++++++++++++++++++++++++++++++ src/1385.cpp | 15 +++++++++++++++ src/1387.cpp | 34 ++++++++++++++++++++++++++++++++++ src/1389.cpp | 14 ++++++++++++++ src/1394.cpp | 24 ++++++++++++++++++++++++ src/1395.cpp | 23 +++++++++++++++++++++++ src/1403.cpp | 24 ++++++++++++++++++++++++ src/1408.cpp | 22 ++++++++++++++++++++++ 11 files changed, 310 insertions(+) create mode 100644 src/1261.cpp create mode 100644 src/1314.cpp create mode 100644 src/1379.cpp create mode 100644 src/1381.cpp create mode 100644 src/1385.cpp create mode 100644 src/1387.cpp create mode 100644 src/1389.cpp create mode 100644 src/1394.cpp create mode 100644 src/1395.cpp create mode 100644 src/1403.cpp create mode 100644 src/1408.cpp diff --git a/src/1261.cpp b/src/1261.cpp new file mode 100644 index 0000000..c51aa29 --- /dev/null +++ b/src/1261.cpp @@ -0,0 +1,46 @@ +class FindElements { +public: + FindElements(TreeNode* root) { + head = root; + if (root != nullptr) + { + root->val = 0; + deque dq; + dq.push_back(root); + elem.push_back(0); + int len = 1; + + while(len != 0) + { + for (int i = 0; i < len; ++i) + { + TreeNode* node = dq[i]; + if (node->left != nullptr) + { + node->left->val = 2*node->val + 1; + elem.push_back(node->left->val); + dq.push_back(node->left); + } + if (node->right != nullptr) + { + node->right->val = 2*node->val + 2; + elem.push_back(node->right->val); + dq.push_back(node->right); + } + } + + dq.erase(dq.begin(), dq.begin()+len); + len = dq.size(); + } + + sort(elem.begin(), elem.end()); + } + } + + bool find(int target) { + return binary_search(elem.begin(), elem.end(), target); + } +private: + TreeNode* head; + vector elem; +}; \ No newline at end of file diff --git a/src/1314.cpp b/src/1314.cpp new file mode 100644 index 0000000..89d5238 --- /dev/null +++ b/src/1314.cpp @@ -0,0 +1,22 @@ +vector> matrixBlockSum(vector>& mat, int K) { + int row = mat.size(); + int col = mat[0].size(); + vector> res(row, vector(col, 0)); + + for (int i = 0; i < row; ++i) + { + for (int j = 0; j < col; ++j) + { + for (int m = i-K; m <= i+K; ++m) + { + for (int n = j-K; n <= j+K; ++n) + { + if (m >= 0 && m < row && n >= 0 && n < col) + res[i][j] += mat[m][n]; + } + } + } + } + + return res; + } \ No newline at end of file diff --git a/src/1379.cpp b/src/1379.cpp new file mode 100644 index 0000000..cab0cb9 --- /dev/null +++ b/src/1379.cpp @@ -0,0 +1,50 @@ +TreeNode* getTargetCopy(TreeNode* original, TreeNode* cloned, TreeNode* target) { + vector paths; + search(original, target, paths); + + int len = paths.size(); + TreeNode* node = cloned; + for (int i = 0; i < len; ++i) + { + if (paths[i] == 0) + node = node->left; + else + node = node->right; + } + + return node; + } + + bool search(TreeNode* ori, TreeNode* target, vector& paths) + { + if (ori != target) + { + if (ori->left == nullptr && ori->right == nullptr) + return false; + bool flag = false; + vector tmp(paths); + if (ori->left != nullptr) + { + tmp.push_back(0); + flag = search(ori->left, target, tmp); + } + + if (!flag && ori->right != nullptr) + { + tmp.swap(paths); + tmp.push_back(1); + flag = search(ori->right, target, tmp); + if (flag) + paths.swap(tmp); + return flag; + } + else + { + if (flag) + paths.swap(tmp); + return flag; + } + } + else + return true; + } \ No newline at end of file diff --git a/src/1381.cpp b/src/1381.cpp new file mode 100644 index 0000000..a484c7d --- /dev/null +++ b/src/1381.cpp @@ -0,0 +1,36 @@ +class CustomStack { +public: + CustomStack(int maxSize) { + maxCap = maxSize; + curSz = 0; + dq.assign(maxCap, -1); + } + + void push(int x) { + if (curSz < maxCap) + { + dq[curSz++] = x; + } + } + + int pop() { + if (curSz > 0) + { + --curSz; + return dq[curSz]; + } + else + return -1; + } + + void increment(int k, int val) { + if (curSz < k) + k = curSz; + for (int i = 0; i < k; ++i) + dq[i] += val; + } +private: + deque dq; + int maxCap; + int curSz; +}; \ No newline at end of file diff --git a/src/1385.cpp b/src/1385.cpp new file mode 100644 index 0000000..2e405cd --- /dev/null +++ b/src/1385.cpp @@ -0,0 +1,15 @@ +int findTheDistanceValue(vector& arr1, vector& arr2, int d) { + int len1 = arr1.size(), len2 = arr2.size(); + int ct = 0; + for (int i = 0; i < len1; ++i) + { + int j = 0; + for (j = 0; j < len2; ++j) + if (abs(arr1[i]-arr2[j]) <= d) + break; + if (j == len2) + ++ct; + } + + return ct; + } \ No newline at end of file diff --git a/src/1387.cpp b/src/1387.cpp new file mode 100644 index 0000000..0e84b67 --- /dev/null +++ b/src/1387.cpp @@ -0,0 +1,34 @@ +int getKth(int lo, int hi, int k) { + struct Elem + { + int val; + int ct; + Elem(int v = 0, int n = 0):val(v),ct(n){} + }; + + vector res(hi-lo+1); + for (int i = lo; i <= hi; ++i) + { + int t = i; + int ct = 0; + while (t != 1) + { + if (t%2 == 0) + t /= 2; + else + t = t*3+1; + ++ct; + } + + res[i-lo].val = i; + res[i-lo].ct = ct; + } + + auto cmp = [](const Elem& a, const Elem& b) { + return a.ct < b.ct || (a.ct == b.ct && a.val < b.val); + }; + + sort(res.begin(), res.end(), cmp); + + return res[k-1].val; + } \ No newline at end of file diff --git a/src/1389.cpp b/src/1389.cpp new file mode 100644 index 0000000..16caf39 --- /dev/null +++ b/src/1389.cpp @@ -0,0 +1,14 @@ +vector createTargetArray(vector& nums, vector& index) { + int len = nums.size(); + vector res(len, -1); + for (int i = 0; i < len; ++i) + { + if (res[index[i]] == -1) + res[index[i]] = nums[i]; + else + res.insert(res.begin()+index[i], 1, nums[i]); + } + + res.resize(len); + return res; + } \ No newline at end of file diff --git a/src/1394.cpp b/src/1394.cpp new file mode 100644 index 0000000..501a60b --- /dev/null +++ b/src/1394.cpp @@ -0,0 +1,24 @@ +int findLucky(vector& arr) { + int len = arr.size(); + if (len == 1) + return arr[0] == 1 ? 1 : -1; + sort(arr.begin(), arr.end()); + int i = len-1; + while (i >= 0) + { + int tmp = arr[i]; + if (i-tmp+1 >= 0 && arr[i-tmp+1] == tmp) + { + if (i-tmp < 0 || arr[i-tmp] != tmp) + return tmp; + else + i = i-tmp; + } + + for (; i >= 0; --i) + if (arr[i] != tmp) + break; + } + + return -1; + } \ No newline at end of file diff --git a/src/1395.cpp b/src/1395.cpp new file mode 100644 index 0000000..f469ad4 --- /dev/null +++ b/src/1395.cpp @@ -0,0 +1,23 @@ +int numTeams(vector& rating) { + int len = rating.size(); + if (len < 3) + return 0; + + int ct = 0; + for (int i = 0; i < len-2; ++i) + { + for (int j = i+1; j < len-1; ++j) + { + bool flag = rating[i] < rating[j] ? true : false; + for (int k = j+1; k < len; ++k) + { + if (flag && rating[j] < rating[k]) + ++ct; + else if (!flag && rating[j] > rating[k]) + ++ct; + } + } + } + + return ct; + } \ No newline at end of file diff --git a/src/1403.cpp b/src/1403.cpp new file mode 100644 index 0000000..d4b8f9c --- /dev/null +++ b/src/1403.cpp @@ -0,0 +1,24 @@ +vector minSubsequence(vector& nums) { + int len = nums.size(); + if (len == 1) + return move(nums); + + int sum = 0; + for (int i = 0; i < len; ++i) + sum += nums[i]; + + sort(nums.begin(), nums.end()); + vector res; + int subsum = 0; + int i = len-1; + for (i = len-1; i >= 0; --i) + { + subsum += nums[i]; + if (subsum > sum-subsum) + break; + } + + res.assign(nums.rbegin(), nums.rbegin()+len-i); + + return res; + } \ No newline at end of file diff --git a/src/1408.cpp b/src/1408.cpp new file mode 100644 index 0000000..9d691c5 --- /dev/null +++ b/src/1408.cpp @@ -0,0 +1,22 @@ +vector stringMatching(vector& words) { + int len = words.size(); + auto cmp = [](const string& a, const string& b) { + return a.size() < b.size(); + }; + + sort(words.begin(), words.end(), cmp); + vector res; + for (int i = 0; i < len-1; ++i) + { + for (int j = i+1; j < len; ++j) + { + if (words[j].find(words[i]) != string::npos) + { + res.push_back(words[i]); + break; + } + } + } + + return res; + } \ No newline at end of file From d455edbb653d12573420627d66054aca7789b294 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 25 Apr 2020 17:49:06 +0800 Subject: [PATCH 47/97] 4 problems solved. --- src/1110.cpp | 79 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/1325.cpp | 51 +++++++++++++++++++++++++++++++++ src/1338.cpp | 29 +++++++++++++++++++ src/1409.cpp | 25 +++++++++++++++++ 4 files changed, 184 insertions(+) create mode 100644 src/1110.cpp create mode 100644 src/1325.cpp create mode 100644 src/1338.cpp create mode 100644 src/1409.cpp diff --git a/src/1110.cpp b/src/1110.cpp new file mode 100644 index 0000000..56726e5 --- /dev/null +++ b/src/1110.cpp @@ -0,0 +1,79 @@ +vector delNodes(TreeNode* root, vector& to_delete) { + vector vec; + struct Elem + { + TreeNode* node; + bool status; + Elem(TreeNode* tn = nullptr, bool flag = false):node(tn), status(flag){} + }; + + deque dq; + dq.push_back(Elem(root, true)); + + int index = 0, len = 1; + bool flag = true; + while (flag) + { + flag = false; + int lim = len; + for (int i = index; i < lim; ++i) + { + TreeNode* tmp = dq[i].node; + if (tmp->left != nullptr) + { + flag = true; + dq.push_back(Elem(tmp->left, true)); + len++; + } + if (tmp->right != nullptr) + { + flag = true; + dq.push_back(Elem(tmp->right, true)); + len++; + } + } + index = lim; + } + + int len1 = dq.size(); + int len2 = to_delete.size(); + map mp; + mp.insert(make_pair(root, nullptr)); + for (int i = 0; i < len1; ++i) + { + TreeNode* node = dq[i].node; + if (node->left != nullptr) + mp[node->left] = node; + if (node->right != nullptr) + mp[node->right] = node; + } + + for (int i = 0; i < len2; ++i) + { + for (int j = 0; j < len1; ++j) + { + if (dq[j].node->val == to_delete[i]) + { + dq[j].status = false; + if (dq[j].node->left != nullptr) + mp[dq[j].node->left] = nullptr; + if (dq[j].node->right != nullptr) + mp[dq[j].node->right] = nullptr; + } + else if (dq[j].node->left != nullptr && dq[j].node->left->val == to_delete[i]) + dq[j].node->left = nullptr; + else if (dq[j].node->right != nullptr && dq[j].node->right->val == to_delete[i]) + dq[j].node->right = nullptr; + } + } + + for (int i = 0; i < len1; ++i) + { + if (dq[i].status && mp[dq[i].node] == nullptr) + { + vec.push_back(dq[i].node); + } + } + + return vec; + } \ No newline at end of file diff --git a/src/1325.cpp b/src/1325.cpp new file mode 100644 index 0000000..8224dfe --- /dev/null +++ b/src/1325.cpp @@ -0,0 +1,51 @@ +TreeNode* removeLeafNodes(TreeNode* root, int target) { + if (root == nullptr) + return nullptr; + + vector> vec; + stack stk; + + search(root, target, stk, vec); + int len = vec.size(); + for (int i = 0; i < len; ++i) + { + TreeNode* node = vec[i].top(); + vec[i].pop(); + while (!vec[i].empty()) + { + TreeNode* par = vec[i].top(); + if (par->left == node) + par->left = nullptr; + else + par->right = nullptr; + delete node; + if (par->val == target && par->left == nullptr && par->right == nullptr) + { + node = par; + vec[i].pop(); + } + else + break; + } + if (vec[i].empty()) + return nullptr; + } + + return root; + } + + void search(TreeNode* node, int target, stack stk, vector>& vec) + { + stk.push(node); + if (node->val == target && node->left == nullptr && node->right == nullptr) + { + vec.push_back(stk); + } + else + { + if (node->left != nullptr) + search(node->left, target, stk, vec); + if (node->right != nullptr) + search(node->right, target, stk, vec); + } + } \ No newline at end of file diff --git a/src/1338.cpp b/src/1338.cpp new file mode 100644 index 0000000..05813a6 --- /dev/null +++ b/src/1338.cpp @@ -0,0 +1,29 @@ +int minSetSize(vector& arr) { + int len = arr.size(); + if (len == 2) + return 1; + + map mp; + for (int i = 0; i < len; ++i) + { + mp[arr[i]]++; + } + + int sz = mp.size(); + vector vec(sz); + int i = 0; + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + vec[i++] = iter->second; + sort(vec.begin(), vec.end()); + int sum = 0; + int ct = 0; + for (i = sz-1; i >= 0; --i) + { + sum += vec[i]; + ++ct; + if (sum >= len/2) + break; + } + + return ct; + } \ No newline at end of file diff --git a/src/1409.cpp b/src/1409.cpp new file mode 100644 index 0000000..6b4c8f5 --- /dev/null +++ b/src/1409.cpp @@ -0,0 +1,25 @@ +vector processQueries(vector& queries, int m) { + vector arr(m); + for (int i = 0; i < m; ++i) + arr[i] = i+1; + + int len = queries.size(); + vector res(len); + for (int i = 0; i < len; ++i) + { + int j; + for (j = m-1; j >= 0; --j) + { + if (arr[j] == queries[i]) + { + res[i] = j; + break; + } + } + for (; j >= 1; --j) + arr[j] = arr[j-1]; + arr[0] = queries[i]; + } + + return res; + } \ No newline at end of file From 42eef0a8318985a274d68a3cd3fa74bfb0652389 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 2 May 2020 19:00:51 +0800 Subject: [PATCH 48/97] 4 problems solved. --- src/1399.cpp | 24 ++++++++++++++++++++++++ src/1413.cpp | 16 ++++++++++++++++ src/1417.cpp | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/1422.cpp | 21 +++++++++++++++++++++ 4 files changed, 112 insertions(+) create mode 100644 src/1399.cpp create mode 100644 src/1413.cpp create mode 100644 src/1417.cpp create mode 100644 src/1422.cpp diff --git a/src/1399.cpp b/src/1399.cpp new file mode 100644 index 0000000..76276fd --- /dev/null +++ b/src/1399.cpp @@ -0,0 +1,24 @@ +int countLargestGroup(int n) { + map mp; + int maxnum = 0; + for (int i = 1; i <= n; ++i) + { + int tmp = i, sum = 0; + while (tmp != 0) + { + sum += tmp%10; + tmp /= 10; + } + + mp[sum]++; + if (mp[sum] > maxnum) + maxnum = mp[sum]; + } + + int ct = 0; + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + if (iter->second == maxnum) + ++ct; + + return ct; + } \ No newline at end of file diff --git a/src/1413.cpp b/src/1413.cpp new file mode 100644 index 0000000..48c61ac --- /dev/null +++ b/src/1413.cpp @@ -0,0 +1,16 @@ +int minStartValue(vector& nums) { + int len = nums.size(); + int minval = nums[0]; + int sum = minval; + for (int i = 1; i < len; ++i) + { + sum += nums[i]; + if (sum < minval) + minval = sum; + } + + if (minval >= 0) + return 1; + else + return abs(minval) + 1; + } \ No newline at end of file diff --git a/src/1417.cpp b/src/1417.cpp new file mode 100644 index 0000000..5c8aea1 --- /dev/null +++ b/src/1417.cpp @@ -0,0 +1,51 @@ +string reformat(string s) { + int len = s.size(); + if (len == 1) + return s; + int digit = 0; + for (int i = 0; i < len; ++i) + if (s[i] >= '0' && s[i] <= '9') + ++digit; + if (len%2 == 0 && digit != len/2) + return ""; + else if (len%2 == 1 && (digit < len/2 || digit > len/2+1)) + return ""; + + string res(len, ' '); + if (len%2 == 1 && digit == len/2) + { + int p = 0, q = 1; + for (int i = 0; i < len; ++i) + { + if (s[i] >= '0' && s[i] <= '9') + { + res[q] = s[i]; + q += 2; + } + else + { + res[p] = s[i]; + p += 2; + } + } + } + else + { + int p = 0, q = 1; + for (int i = 0; i < len; ++i) + { + if (s[i] >= '0' && s[i] <= '9') + { + res[p] = s[i]; + p += 2; + } + else + { + res[q] = s[i]; + q += 2; + } + } + } + + return res; + } \ No newline at end of file diff --git a/src/1422.cpp b/src/1422.cpp new file mode 100644 index 0000000..c596419 --- /dev/null +++ b/src/1422.cpp @@ -0,0 +1,21 @@ +int maxScore(string s) { + int len = s.size(); + int arr[2] = {0, 0}; + for (int i = 0; i < len; ++i) + arr[s[i]-'0']++; + + int num1 = 0, num2 = 0; + int maxscore = 0; + for (int i = 0; i < len-1; ++i) + { + if (s[i] == '0') + ++num1; + else + ++num2; + int tmp = num1 + arr[1]-num2; + if (tmp > maxscore) + maxscore = tmp; + } + + return maxscore; + } \ No newline at end of file From 8711b584ae84ac03dc98f56ce8bc9aff64c4d6da Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 23 May 2020 12:46:32 +0800 Subject: [PATCH 49/97] 6 problems solved. --- src/1431.cpp | 18 ++++++++++++++++++ src/1436.cpp | 21 +++++++++++++++++++++ src/1441.cpp | 26 ++++++++++++++++++++++++++ src/1446.cpp | 26 ++++++++++++++++++++++++++ src/1448.cpp | 26 ++++++++++++++++++++++++++ src/1450.cpp | 11 +++++++++++ 6 files changed, 128 insertions(+) create mode 100644 src/1431.cpp create mode 100644 src/1436.cpp create mode 100644 src/1441.cpp create mode 100644 src/1446.cpp create mode 100644 src/1448.cpp create mode 100644 src/1450.cpp diff --git a/src/1431.cpp b/src/1431.cpp new file mode 100644 index 0000000..78bbd07 --- /dev/null +++ b/src/1431.cpp @@ -0,0 +1,18 @@ +vector kidsWithCandies(vector& candies, int extraCandies) { + int len = candies.size(); + int maxmum = candies[0]; + for (int i = 1; i < len; ++i) + { + if (candies[i] > maxmum) + maxmum = candies[i]; + } + + vector res(len); + for (int i = 0; i < len; ++i) + { + if (candies[i]+extraCandies >= maxmum) + res[i] = true; + } + + return res; + } \ No newline at end of file diff --git a/src/1436.cpp b/src/1436.cpp new file mode 100644 index 0000000..49b88ef --- /dev/null +++ b/src/1436.cpp @@ -0,0 +1,21 @@ +string destCity(vector>& paths) { + map mp; + int len = paths.size(); + for (int i = 0; i < len; ++i) + { + if (mp.find(paths[i][0]) == mp.end()) + mp[paths[i][0]] = -1; + else + mp[paths[i][0]] = 0; + if (mp.find(paths[i][1]) == mp.end()) + mp[paths[i][1]] = 1; + else + mp[paths[i][1]] = 0; + } + + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + if (iter->second == 1) + return iter->first; + + return ""; + } \ No newline at end of file diff --git a/src/1441.cpp b/src/1441.cpp new file mode 100644 index 0000000..42d7d9c --- /dev/null +++ b/src/1441.cpp @@ -0,0 +1,26 @@ +vector buildArray(vector& target, int n) { + vector res(n*2); + int len = target.size(); + int last = 0; + int ct = 0; + for (int i = 0; i < len; ++i) + { + int tmp = target[i]-last-1; + if (tmp == 0) + res[ct++] = "Push"; + else + { + for (int j = 0; j < tmp; ++j) + { + res[ct] = "Push"; + res[ct+1] = "Pop"; + ct += 2; + } + res[ct++] = "Push"; + } + last = target[i]; + } + + res.resize(ct); + return res; + } \ No newline at end of file diff --git a/src/1446.cpp b/src/1446.cpp new file mode 100644 index 0000000..3398e9e --- /dev/null +++ b/src/1446.cpp @@ -0,0 +1,26 @@ +int maxPower(string s) { + int len = s.size(); + int maxmum = 1; + + char c = s[0]; + int i = 1, ct = 1; + while (i < len) + { + if (s[i] == c) + ++ct; + else + { + if (ct > maxmum) + maxmum = ct; + ct = 1; + c = s[i]; + } + + ++i; + } + + if (ct > maxmum) + maxmum = ct; + + return maxmum; + } \ No newline at end of file diff --git a/src/1448.cpp b/src/1448.cpp new file mode 100644 index 0000000..e5a2818 --- /dev/null +++ b/src/1448.cpp @@ -0,0 +1,26 @@ +int goodNodes(TreeNode* root) { + if (root == nullptr) + return 0; + int ct = 1; + int maxmum = root->val; + + if (root->left != nullptr) + search(root->left, maxmum, ct); + if (root->right != nullptr) + search(root->right, maxmum, ct); + + return ct; + } + + void search(TreeNode* node, int maxmum, int& ct) + { + if (node->val >= maxmum) + { + ++ct; + maxmum = node->val; + } + if (node->left != nullptr) + search(node->left, maxmum, ct); + if (node->right != nullptr) + search(node->right, maxmum, ct); + } \ No newline at end of file diff --git a/src/1450.cpp b/src/1450.cpp new file mode 100644 index 0000000..666a611 --- /dev/null +++ b/src/1450.cpp @@ -0,0 +1,11 @@ +int busyStudent(vector& startTime, vector& endTime, int queryTime) { + int len = startTime.size(); + int ct = 0; + for (int i = 0; i < len; ++i) + { + if (queryTime >= startTime[i] && queryTime <= endTime[i]) + ++ct; + } + + return ct; + } \ No newline at end of file From ac29fb9c511503eb1081ae1d9deeed245b6c3613 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 21 Jun 2020 16:50:21 +0800 Subject: [PATCH 50/97] 5 problems solved. --- src/1455.cpp | 29 +++++++++++++++++++++++++++++ src/1460.cpp | 13 +++++++++++++ src/1464.cpp | 23 +++++++++++++++++++++++ src/1480.cpp | 12 ++++++++++++ src/1486.cpp | 10 ++++++++++ 5 files changed, 87 insertions(+) create mode 100644 src/1455.cpp create mode 100644 src/1460.cpp create mode 100644 src/1464.cpp create mode 100644 src/1480.cpp create mode 100644 src/1486.cpp diff --git a/src/1455.cpp b/src/1455.cpp new file mode 100644 index 0000000..ee72503 --- /dev/null +++ b/src/1455.cpp @@ -0,0 +1,29 @@ +int isPrefixOfWord(string sentence, string searchWord) { + int len = sentence.size(); + int len2 = searchWord.size(); + int i = 0; + int ct = 1; + while (i < len) + { + int index = sentence.find(' ', i); + if (index == string::npos) + { + if (len-i >= len2 && sentence.substr(i, len2) == searchWord) + return ct; + else + break; + } + else + { + if (index-i >= len2 && sentence.substr(i, len2) == searchWord) + return ct; + else + { + i = index+1; + ++ct; + } + } + } + + return -1; + } \ No newline at end of file diff --git a/src/1460.cpp b/src/1460.cpp new file mode 100644 index 0000000..9a19fa1 --- /dev/null +++ b/src/1460.cpp @@ -0,0 +1,13 @@ +bool canBeEqual(vector& target, vector& arr) { + int len = target.size(); + sort(target.begin(), target.end()); + sort(arr.begin(), arr.end()); + + for (int i = 0; i < len; ++i) + { + if (target[i] != arr[i]) + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/1464.cpp b/src/1464.cpp new file mode 100644 index 0000000..b682f55 --- /dev/null +++ b/src/1464.cpp @@ -0,0 +1,23 @@ +int maxProduct(vector& nums) { + int len = nums.size(); + int arr[2] = {0,0}; + arr[0] = nums[0]; + arr[1] = nums[1]; + if (arr[0] < arr[1]) + swap(arr[0], arr[1]); + for (int i = 2; i < len; ++i) + { + if (nums[i] > arr[1]) + { + if (nums[i] > arr[0]) + { + arr[1] = arr[0]; + arr[0] = nums[i]; + } + else + arr[1] = nums[i]; + } + } + + return (arr[0]-1)*(arr[1]-1); + } \ No newline at end of file diff --git a/src/1480.cpp b/src/1480.cpp new file mode 100644 index 0000000..e3a5db6 --- /dev/null +++ b/src/1480.cpp @@ -0,0 +1,12 @@ +vector runningSum(vector& nums) { + int len = nums.size(); + vector res(len); + int sum = 0; + for (int i = 0; i < len; ++i) + { + sum += nums[i]; + res[i] = sum; + } + + return res; + } \ No newline at end of file diff --git a/src/1486.cpp b/src/1486.cpp new file mode 100644 index 0000000..be36eef --- /dev/null +++ b/src/1486.cpp @@ -0,0 +1,10 @@ +int xorOperation(int n, int start) { + int res = 0; + for (int i = 0; i < n; ++i) + { + int tmp = start + 2*i; + res ^= tmp; + } + + return res; + } \ No newline at end of file From 8bf1af49204ca5c2da92769585ff6dd665f9b319 Mon Sep 17 00:00:00 2001 From: lintcoder Date: Thu, 8 Oct 2020 19:16:27 +0800 Subject: [PATCH 51/97] 8 problems solved. --- src/1470.cpp | 12 ++++++++++++ src/1491.cpp | 17 +++++++++++++++++ src/1502.cpp | 12 ++++++++++++ src/1528.cpp | 8 ++++++++ src/1534.cpp | 21 +++++++++++++++++++++ src/1550.cpp | 12 ++++++++++++ src/1588.cpp | 21 +++++++++++++++++++++ src/1603.cpp | 46 ++++++++++++++++++++++++++++++++++++++++++++++ 8 files changed, 149 insertions(+) create mode 100644 src/1470.cpp create mode 100644 src/1491.cpp create mode 100644 src/1502.cpp create mode 100644 src/1528.cpp create mode 100644 src/1534.cpp create mode 100644 src/1550.cpp create mode 100644 src/1588.cpp create mode 100644 src/1603.cpp diff --git a/src/1470.cpp b/src/1470.cpp new file mode 100644 index 0000000..a3b585f --- /dev/null +++ b/src/1470.cpp @@ -0,0 +1,12 @@ +vector shuffle(vector& nums, int n) { + vector res(n*2); + int j = 0; + for (int i = 0; i < n; ++i) + { + res[j] = nums[i]; + res[j+1] = nums[i+n]; + j += 2; + } + + return res; + } \ No newline at end of file diff --git a/src/1491.cpp b/src/1491.cpp new file mode 100644 index 0000000..ad89f24 --- /dev/null +++ b/src/1491.cpp @@ -0,0 +1,17 @@ +double average(vector& salary) { + int len = salary.size(); + int minval = 1e6, maxval = 0; + double sum = 0; + for (int i = 0; i < len; ++i) + { + sum += salary[i]; + if (salary[i] < minval) + minval = salary[i]; + if (salary[i] > maxval) + maxval = salary[i]; + } + + sum -= (minval+maxval); + + return sum/(len-2); + } \ No newline at end of file diff --git a/src/1502.cpp b/src/1502.cpp new file mode 100644 index 0000000..2c21187 --- /dev/null +++ b/src/1502.cpp @@ -0,0 +1,12 @@ +bool canMakeArithmeticProgression(vector& arr) { + int len = arr.size(); + sort(arr.begin(), arr.end()); + int diff = arr[1]-arr[0]; + for (int i = 2; i < len; ++i) + { + if (arr[i]-arr[i-1] != diff) + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/1528.cpp b/src/1528.cpp new file mode 100644 index 0000000..0410a21 --- /dev/null +++ b/src/1528.cpp @@ -0,0 +1,8 @@ +string restoreString(string s, vector& indices) { + int n = s.size(); + string res(n,' '); + for (int i= 0; i < n; ++i) + res[indices[i]] = s[i]; + + return res; + } \ No newline at end of file diff --git a/src/1534.cpp b/src/1534.cpp new file mode 100644 index 0000000..ae7dff0 --- /dev/null +++ b/src/1534.cpp @@ -0,0 +1,21 @@ +int countGoodTriplets(vector& arr, int a, int b, int c) { + int len = arr.size(); + int ct = 0; + for (int i = 0; i < len-2; ++i) + { + for (int j = i+1; j < len-1; ++j) + { + if (abs(arr[i]-arr[j]) <= a) + { + for (int k = j+1; k < len; ++k) + { + if (abs(arr[j]-arr[k]) <= b && abs(arr[i]-arr[k]) <= c) + ++ct; + } + } + } + } + + + return ct; + } \ No newline at end of file diff --git a/src/1550.cpp b/src/1550.cpp new file mode 100644 index 0000000..f0747cf --- /dev/null +++ b/src/1550.cpp @@ -0,0 +1,12 @@ +bool threeConsecutiveOdds(vector& arr) { + int len = arr.size(); + for (int i = 0; i < len-2; ++i) + { + if (arr[i]%2 == 1 && arr[i+1]%2 == 1 && arr[i+2]%2 == 1) + { + return true; + } + } + + return false; + } \ No newline at end of file diff --git a/src/1588.cpp b/src/1588.cpp new file mode 100644 index 0000000..cfeaaec --- /dev/null +++ b/src/1588.cpp @@ -0,0 +1,21 @@ +int sumOddLengthSubarrays(vector& arr) { + int len = arr.size(); + int res = 0; + for (int i = 1; i <= len ; i += 2) + { + int tmp = 0; + for (int j = 0; j < i; ++j) + tmp += arr[j]; + + res += tmp; + + for (int j = 0; j < len-i; ++j) + { + tmp -= arr[j]; + tmp += arr[j+i]; + res += tmp; + } + } + + return res; + } \ No newline at end of file diff --git a/src/1603.cpp b/src/1603.cpp new file mode 100644 index 0000000..41ebb92 --- /dev/null +++ b/src/1603.cpp @@ -0,0 +1,46 @@ +class ParkingSystem { +public: + ParkingSystem(int big, int medium, int small) { + mbig = big; + mmedium = medium; + msmall = small; + } + + bool addCar(int carType) { + if (carType == 1) + { + if (mbig > 0) + { + --mbig; + return true; + } + else + return false; + } + else if (carType == 2) + { + if (mmedium > 0) + { + --mmedium; + return true; + } + else + return false; + } + else + { + if (msmall > 0) + { + --msmall; + return true; + } + else + return false; + } + } + +private: + int mbig; + int mmedium; + int msmall; +}; From 7b965b8b18068174fab193692b8c5fcb304ddf7b Mon Sep 17 00:00:00 2001 From: Troy Date: Fri, 1 Jan 2021 16:32:45 +0800 Subject: [PATCH 52/97] 9 problems solved. --- src/1475.cpp | 17 +++++++++++++++++ src/1572.cpp | 10 ++++++++++ src/1662.cpp | 38 ++++++++++++++++++++++++++++++++++++++ src/1672.cpp | 15 +++++++++++++++ src/1678.cpp | 28 ++++++++++++++++++++++++++++ src/1684.cpp | 23 +++++++++++++++++++++++ src/1688.cpp | 3 +++ src/1694.cpp | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/1704.cpp | 30 ++++++++++++++++++++++++++++++ 9 files changed, 215 insertions(+) create mode 100644 src/1475.cpp create mode 100644 src/1572.cpp create mode 100644 src/1662.cpp create mode 100644 src/1672.cpp create mode 100644 src/1678.cpp create mode 100644 src/1684.cpp create mode 100644 src/1688.cpp create mode 100644 src/1694.cpp create mode 100644 src/1704.cpp diff --git a/src/1475.cpp b/src/1475.cpp new file mode 100644 index 0000000..e4378f8 --- /dev/null +++ b/src/1475.cpp @@ -0,0 +1,17 @@ +vector finalPrices(vector& prices) { + int len = prices.size(); + vector res(prices.begin(), prices.end()); + for (int i = 0; i < len-1; ++i) + { + for (int j = i+1; j < len; ++j) + { + if (prices[j] <= prices[i]) + { + res[i] = prices[i]-prices[j]; + break; + } + } + } + + return res; + } \ No newline at end of file diff --git a/src/1572.cpp b/src/1572.cpp new file mode 100644 index 0000000..58dba13 --- /dev/null +++ b/src/1572.cpp @@ -0,0 +1,10 @@ +int diagonalSum(vector>& mat) { + int row = mat.size(); + int sum = 0; + for (int i = 0; i < row; ++i) + sum += mat[i][i] + mat[row-1-i][i]; + + if (row%2 == 1) + sum -= mat[row/2][row/2]; + return sum; + } \ No newline at end of file diff --git a/src/1662.cpp b/src/1662.cpp new file mode 100644 index 0000000..f3bff9a --- /dev/null +++ b/src/1662.cpp @@ -0,0 +1,38 @@ +bool arrayStringsAreEqual(vector& word1, vector& word2) { + int i1 = 0, j1 = 0, i2 = 0, j2 = 0; + int len1 = word1.size(); + int len2 = word2.size(); + + int sz1 = word1[0].size(); + int sz2 = word2[0].size(); + while (i1 < len1 && i2 < len2) + { + while (j1 < sz1 && j2 < sz2) + { + if (word1[i1][j1] != word2[i2][j2]) + return false; + ++j1; + ++j2; + } + if (j1 == sz1) + { + ++i1; + if (i1 < len1) + { + sz1 = word1[i1].size(); + j1 = 0; + } + } + if (j2 == sz2) + { + ++i2; + if (i2 < len2) + { + sz2 = word2[i2].size(); + j2 = 0; + } + } + } + + return (i1 == len1 && i2 == len2); + } \ No newline at end of file diff --git a/src/1672.cpp b/src/1672.cpp new file mode 100644 index 0000000..91e7f7d --- /dev/null +++ b/src/1672.cpp @@ -0,0 +1,15 @@ +int maximumWealth(vector>& accounts) { + int row = accounts.size(); + if (row == 0) + return 0; + int col = accounts[0].size(); + int maxwealth = 0; + for (int i = 0; i < row; ++i) + { + int wealth = accumulate(accounts[i].begin(), accounts[i].end(), 0); + if (wealth >maxwealth) + maxwealth = wealth; + } + + return maxwealth; + } \ No newline at end of file diff --git a/src/1678.cpp b/src/1678.cpp new file mode 100644 index 0000000..5df51a5 --- /dev/null +++ b/src/1678.cpp @@ -0,0 +1,28 @@ +string interpret(string command) { + stringstream ss; + int len = command.size(); + int i = 0; + while (i < len) + { + if (command[i] == 'G') + { + ss << 'G'; + ++i; + } + else if (command[i] == '(') + { + if (command[i+1] == ')') + { + ss << 'o'; + i += 2; + } + else + { + ss << "al"; + i += 4; + } + } + } + + return ss.str(); + } \ No newline at end of file diff --git a/src/1684.cpp b/src/1684.cpp new file mode 100644 index 0000000..ddec417 --- /dev/null +++ b/src/1684.cpp @@ -0,0 +1,23 @@ +int countConsistentStrings(string allowed, vector& words) { + int flag[26] = {0}; + int len = allowed.size(); + for (int i = 0; i < len; ++i) + flag[allowed[i]-'a'] = 1; + + int sz = words.size(); + int ct = 0; + for (int i = 0; i < sz; ++i) + { + int n = words[i].size(); + int j = 0; + for (; j < n; ++j) + { + if (flag[words[i][j]-'a'] == 0) + break; + } + if (j == n) + ++ct; + } + + return ct; + } \ No newline at end of file diff --git a/src/1688.cpp b/src/1688.cpp new file mode 100644 index 0000000..b8f952c --- /dev/null +++ b/src/1688.cpp @@ -0,0 +1,3 @@ +int numberOfMatches(int n) { + return n-1; + } \ No newline at end of file diff --git a/src/1694.cpp b/src/1694.cpp new file mode 100644 index 0000000..783b237 --- /dev/null +++ b/src/1694.cpp @@ -0,0 +1,51 @@ +string reformatNumber(string number) { + int len = number.size(); + if (len == 2) + return number; + + string str(len, ' '); + int j = 0; + for (int i = 0; i < len; ++i) + { + if (number[i] != ' ' && number[i] != '-') + str[j++] = number[i]; + } + + if (j <= 3) + return str.substr(0, j); + + int r = j%3; + int lim = r == 0 ? j : (r == 1 ? j-4 : j-2); + int n = 0; + if (r == 0) + n = j+j/3-1; + else if (r == 1) + n = j-4+(j-4)/3-1+6; + else + n = j-2+(j-2)/3-1+3; + + string res(n, ' '); + int i = 0, k = 0; + while (i < lim) + { + res[k++] = str[i++]; + if (k < n && i%3 == 0) + res[k++] = '-'; + } + + if (r == 1) + { + res[k] = str[i]; + res[k+1] = str[i+1]; + res[k+2] = '-'; + res[k+3] = str[i+2]; + res[k+4] = str[i+3]; + } + else if (r == 2) + { + res[k] = str[i]; + res[k+1] = str[i+1]; + } + + return res; + } \ No newline at end of file diff --git a/src/1704.cpp b/src/1704.cpp new file mode 100644 index 0000000..6487765 --- /dev/null +++ b/src/1704.cpp @@ -0,0 +1,30 @@ +bool halvesAreAlike(string s) { + int len = s.size(); + int n1 = 0, n2 = 0; + for (int i = 0; i < len/2; ++i) + { + switch(tolower(s[i])) + { + case 'a': + case 'e': + case 'i': + case 'o': + case 'u': + ++n1; + } + } + for (int i = len/2; i < len; ++i) + { + switch(tolower(s[i])) + { + case 'a': + case 'e': + case 'i': + case 'o': + case 'u': + ++n2; + } + } + + return n1 == n2; + } \ No newline at end of file From a878ba95892e7f35bed1a01c13de9a9ebf23411c Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 10 Jan 2021 21:24:19 +0800 Subject: [PATCH 53/97] 5 problems solved. --- src/1507.cpp | 15 +++++++++++++++ src/1598.cpp | 18 ++++++++++++++++++ src/1619.cpp | 12 ++++++++++++ src/1636.cpp | 12 ++++++++++++ src/1720.cpp | 11 +++++++++++ 5 files changed, 68 insertions(+) create mode 100644 src/1507.cpp create mode 100644 src/1598.cpp create mode 100644 src/1619.cpp create mode 100644 src/1636.cpp create mode 100644 src/1720.cpp diff --git a/src/1507.cpp b/src/1507.cpp new file mode 100644 index 0000000..b5f376e --- /dev/null +++ b/src/1507.cpp @@ -0,0 +1,15 @@ +string reformatDate(string date) { + map mp{{"Jan","01"},{"Feb","02"},{"Mar","03"},{"Apr","04"}, + {"May","05"},{"Jun","06"},{"Jul","07"},{"Aug","08"}, + {"Sep","09"},{"Oct","10"},{"Nov","11"},{"Dec","12"}}; + int index = date.find(' '); + stringstream ss; + ss << *(date.rbegin()+3) << *(date.rbegin()+2) << *(date.rbegin()+1) << *date.rbegin() << '-'; + string month = mp[date.substr(index+1, 3)]; + ss << month << '-'; + if (index == 3) + ss <<'0'; + ss << date.substr(0, index-2); + + return ss.str(); + } \ No newline at end of file diff --git a/src/1598.cpp b/src/1598.cpp new file mode 100644 index 0000000..1589142 --- /dev/null +++ b/src/1598.cpp @@ -0,0 +1,18 @@ +int minOperations(vector& logs) { + int len = logs.size(); + int depth = 0; + for (int i = 0; i < len; ++i) + { + if (logs[i] == "../") + { + if (depth > 0) + --depth; + } + else if (logs[i] == "./") + ; + else + ++depth; + } + + return depth; + } \ No newline at end of file diff --git a/src/1619.cpp b/src/1619.cpp new file mode 100644 index 0000000..deaa599 --- /dev/null +++ b/src/1619.cpp @@ -0,0 +1,12 @@ +double trimMean(vector& arr) { + sort(arr.begin(), arr.end()); + int len = arr.size(); + int k = len*0.05; + double mean = 0; + for (int i = k; i < len-k; ++i) + { + mean += arr[i]; + } + + return mean/(len-2*k); + } \ No newline at end of file diff --git a/src/1636.cpp b/src/1636.cpp new file mode 100644 index 0000000..7d18b73 --- /dev/null +++ b/src/1636.cpp @@ -0,0 +1,12 @@ +vector frequencySort(vector& nums) { + map mp; + for (auto v : nums) + mp[v]++; + + auto cmp = [&mp](int a, int b) { + return mp[a] < mp[b] || (mp[a] == mp[b] && a > b); + }; + sort(nums.begin(), nums.end(), cmp); + + return nums; + } \ No newline at end of file diff --git a/src/1720.cpp b/src/1720.cpp new file mode 100644 index 0000000..bf50cda --- /dev/null +++ b/src/1720.cpp @@ -0,0 +1,11 @@ +vector decode(vector& encoded, int first) { + int len = encoded.size(); + vector res(len+1, 0); + res[0] = first; + for (int i = 0; i < len; ++i) + { + res[i+1] = encoded[i]^res[i]; + } + + return res; + } \ No newline at end of file From 22291efd70918c756e2fa7c39a701a496a992899 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 30 Jan 2021 19:35:26 +0800 Subject: [PATCH 54/97] 7 problems solved. --- src/1437.cpp | 29 +++++++++++++++++++++++++++++ src/1576.cpp | 32 ++++++++++++++++++++++++++++++++ src/1608.cpp | 34 ++++++++++++++++++++++++++++++++++ src/1629.cpp | 21 +++++++++++++++++++++ src/1646.cpp | 22 ++++++++++++++++++++++ src/1710.cpp | 21 +++++++++++++++++++++ src/1716.cpp | 7 +++++++ 7 files changed, 166 insertions(+) create mode 100644 src/1437.cpp create mode 100644 src/1576.cpp create mode 100644 src/1608.cpp create mode 100644 src/1629.cpp create mode 100644 src/1646.cpp create mode 100644 src/1710.cpp create mode 100644 src/1716.cpp diff --git a/src/1437.cpp b/src/1437.cpp new file mode 100644 index 0000000..f43fc6a --- /dev/null +++ b/src/1437.cpp @@ -0,0 +1,29 @@ +bool kLengthApart(vector& nums, int k) { + int len = nums.size(); + int i = 0; + while (i < len && nums[i] == 0) + ++i; + if (i == len) + return true; + + int j = i+1; + int n = 0; + while (j < len) + { + if (nums[j] == 0) + ++n; + else + { + if (n < k) + return false; + else + { + n = 0; + i = j; + } + } + ++j; + } + + return true; + } \ No newline at end of file diff --git a/src/1576.cpp b/src/1576.cpp new file mode 100644 index 0000000..272916c --- /dev/null +++ b/src/1576.cpp @@ -0,0 +1,32 @@ +string modifyString(string s) { + int len = s.size(); + int i = 0; + if (s[i] == '?') + { + if (i+1 < len && s[i+1] != '?') + s[i] = s[i+1] < 'z' ? s[i+1]+1 : 'a'; + else + s[i] = 'a'; + } + ++i; + + while (i < len) + { + if (s[i] == '?') + { + if (i+1 < len && s[i+1] != '?') + { + char c = s[i-1] < s[i+1] ? s[i-1] : s[i+1]; + if (c == 'z') + s[i] = 'a'; + else + s[i] = c+1 != s[i-1]+s[i+1]-c ? c+1 : (c+1 < 'z' ? c+2 : 'a'); + } + else + s[i] = s[i-1] < 'z' ? s[i-1]+1 : 'a'; + } + ++i; + } + + return s; + } \ No newline at end of file diff --git a/src/1608.cpp b/src/1608.cpp new file mode 100644 index 0000000..970e7ee --- /dev/null +++ b/src/1608.cpp @@ -0,0 +1,34 @@ +int specialArray(vector& nums) { + int len = nums.size(); + sort(nums.begin(), nums.end()); + map mp; + int k = nums[len-1]; + mp[k] = 1; + for (int i = len-2; i >= 0; --i) + { + if (nums[i] == k) + { + mp[k]++; + } + else + { + mp[nums[i]] = mp[k] + 1; + k = nums[i]; + } + } + + int n = mp.begin()->first; + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + { + if (iter->first == iter->second) + return iter->first; + else if (iter->first > iter->second) + { + if (iter == mp.begin() || iter->second > n) + return iter->second; + } + n = iter->first; + } + + return -1; + } \ No newline at end of file diff --git a/src/1629.cpp b/src/1629.cpp new file mode 100644 index 0000000..c68c265 --- /dev/null +++ b/src/1629.cpp @@ -0,0 +1,21 @@ +char slowestKey(vector& releaseTimes, string keysPressed) { + int len = releaseTimes.size(); + int maxtime = releaseTimes[0]; + char c = keysPressed[0]; + for (int i = 1; i < len; ++i) + { + int duration = releaseTimes[i] - releaseTimes[i-1]; + if (duration > maxtime) + { + maxtime = duration; + c = keysPressed[i]; + } + else if (duration == maxtime) + { + if (keysPressed[i] > c) + c = keysPressed[i]; + } + } + + return c; + } \ No newline at end of file diff --git a/src/1646.cpp b/src/1646.cpp new file mode 100644 index 0000000..fc4623a --- /dev/null +++ b/src/1646.cpp @@ -0,0 +1,22 @@ +int getMaximumGenerated(int n) { + if (n <= 1) + return n; + + vector vec(n+1, 0); + vec[0] = 0; + vec[1] = 1; + int i = 2; + int maxvalue = 1; + while (i <= n) + { + if (i%2 == 0) + vec[i] = vec[i/2]; + else + vec[i] = vec[i/2] + vec[i/2+1]; + if (vec[i] > maxvalue) + maxvalue = vec[i]; + ++i; + } + + return maxvalue; + } \ No newline at end of file diff --git a/src/1710.cpp b/src/1710.cpp new file mode 100644 index 0000000..8cf056b --- /dev/null +++ b/src/1710.cpp @@ -0,0 +1,21 @@ +int maximumUnits(vector>& boxTypes, int truckSize) { + int len = boxTypes.size(); + auto cmp = [&boxTypes](const vector& a, const vector& b) { + return a[1] > b[1] || (a[1]==b[1] && a[0] > b[0]); + }; + + sort(boxTypes.begin(), boxTypes.end(), cmp); + + int i = truckSize; + int j = 0; + int sum = 0; + while (i > 0 && j < len) + { + int n = boxTypes[j][0] <= i ? boxTypes[j][0] : i; + sum += n*boxTypes[j][1]; + i -= n; + ++j; + } + + return sum; + } \ No newline at end of file diff --git a/src/1716.cpp b/src/1716.cpp new file mode 100644 index 0000000..08b7005 --- /dev/null +++ b/src/1716.cpp @@ -0,0 +1,7 @@ +int totalMoney(int n) { + int p = n/7; + int r = n%7; + int sum = 28*p + p*(p-1)*7/2; + + return sum + ((p+1)+(p+r))*r/2; + } \ No newline at end of file From fa7a62b4b41a7abef1da5a5523d2b6f111b1441a Mon Sep 17 00:00:00 2001 From: Troy Date: Wed, 10 Feb 2021 07:54:38 +0800 Subject: [PATCH 55/97] 6 problems solved. --- src/1556.cpp | 17 +++++++++++++++++ src/1592.cpp | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/1732.cpp | 13 +++++++++++++ src/1736.cpp | 26 ++++++++++++++++++++++++++ src/1742.cpp | 43 +++++++++++++++++++++++++++++++++++++++++++ src/1748.cpp | 13 +++++++++++++ 6 files changed, 163 insertions(+) create mode 100644 src/1556.cpp create mode 100644 src/1592.cpp create mode 100644 src/1732.cpp create mode 100644 src/1736.cpp create mode 100644 src/1742.cpp create mode 100644 src/1748.cpp diff --git a/src/1556.cpp b/src/1556.cpp new file mode 100644 index 0000000..d73156c --- /dev/null +++ b/src/1556.cpp @@ -0,0 +1,17 @@ +string thousandSeparator(int n) { + string s = to_string(n); + int len = s.size(); + int m = len +(len-1)/3; + string res(m, ' '); + int i = 0, j = m-1; + while (i < len) + { + res[j] = s[len-1-i]; + --j; + ++i; + if (j >= 0 && i%3 == 0) + res[j--] = '.'; + } + + return res; + } \ No newline at end of file diff --git a/src/1592.cpp b/src/1592.cpp new file mode 100644 index 0000000..86c6f88 --- /dev/null +++ b/src/1592.cpp @@ -0,0 +1,51 @@ +string reorderSpaces(string text) { + int len = text.size(); + vector> wordpos; + bool flag = false; + int i = 0; + int lh = 0, rh = 0; + int word = 0, space = 0; + while (i < len) + { + if (text[i] == ' ') + { + if (flag) + { + rh = i-1; + flag = false; + wordpos.push_back(make_pair(lh, rh)); + } + ++space; + } + else + { + if (!flag) + { + lh = i; + ++word; + flag = true; + } + rh = i; + } + ++i; + } + if (text[len-1] != ' ') + wordpos.push_back(make_pair(lh, rh)); + + int n = word > 1 ? space/(word-1) : 0; + int remain = space - n*(word-1); + int k = 0; + + string res(len, ' '); + for (int i = 0; i < word-1; ++i) + { + for (int j = wordpos[i].first; j <= wordpos[i].second; ++j) + res[k++] = text[j]; + k += n; + } + + for (int j = wordpos[word-1].first; j <= wordpos[word-1].second; ++j) + res[k++] = text[j]; + + return res; + } \ No newline at end of file diff --git a/src/1732.cpp b/src/1732.cpp new file mode 100644 index 0000000..38d92f4 --- /dev/null +++ b/src/1732.cpp @@ -0,0 +1,13 @@ +int largestAltitude(vector& gain) { + int high = 0; + int highest = 0; + int len = gain.size(); + for (int i = 0; i < len; ++i) + { + high += gain[i]; + if (high > highest) + highest = high; + } + + return highest; + } \ No newline at end of file diff --git a/src/1736.cpp b/src/1736.cpp new file mode 100644 index 0000000..4ead306 --- /dev/null +++ b/src/1736.cpp @@ -0,0 +1,26 @@ +string maximumTime(string time) { + if (time[0] == '?') + { + if (time[1] == '?' || time[1] < '4') + time[0] = '2'; + else + time[0] = '1'; + } + if (time[1] == '?') + { + if (time[0] == '0' || time[0] == '1') + time[1] = '9'; + else + time[1] = '3'; + } + if (time[3] == '?') + { + time[3] = '5'; + } + if (time[4] == '?') + { + time[4] = '9'; + } + + return time; + } \ No newline at end of file diff --git a/src/1742.cpp b/src/1742.cpp new file mode 100644 index 0000000..0e73c7e --- /dev/null +++ b/src/1742.cpp @@ -0,0 +1,43 @@ +int countBalls(int lowLimit, int highLimit) { + int box[50] = {0}; + int i = lowLimit; + int sum = 0; + while (i > 0) + { + sum += i%10; + i /= 10; + } + box[sum]++; + + int last = lowLimit%10; + i = lowLimit+1; + while (i <= highLimit) + { + if (last < 9) + { + sum++; + box[sum]++; + ++last; + } + else + { + sum = 0; + int t = i; + while (t > 0) + { + sum += t%10; + t /= 10; + } + box[sum]++; + last = i%10; + } + ++i; + } + + int maxballs = 0; + for (int j = 0; j < 50; ++j) + if (box[j] > maxballs) + maxballs = box[j]; + + return maxballs; + } \ No newline at end of file diff --git a/src/1748.cpp b/src/1748.cpp new file mode 100644 index 0000000..097d6f0 --- /dev/null +++ b/src/1748.cpp @@ -0,0 +1,13 @@ +int sumOfUnique(vector& nums) { + int arr[101] = {0}; + int len = nums.size(); + for (int i = 0; i < len; ++i) + arr[nums[i]]++; + + int sum = 0; + for (int i = 1; i <= 100; ++i) + if (arr[i] == 1) + sum += i; + + return sum; + } \ No newline at end of file From 41f8c438576a1f4f6b8444732440134c7c032057 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 13 Feb 2021 19:25:22 +0800 Subject: [PATCH 56/97] 6 problems solved. --- src/1561.cpp | 15 +++++++++++++++ src/1641.cpp | 18 ++++++++++++++++++ src/1669.cpp | 25 +++++++++++++++++++++++++ src/1689.cpp | 11 +++++++++++ src/1721.cpp | 34 ++++++++++++++++++++++++++++++++++ src/890.cpp | 38 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 141 insertions(+) create mode 100644 src/1561.cpp create mode 100644 src/1641.cpp create mode 100644 src/1669.cpp create mode 100644 src/1689.cpp create mode 100644 src/1721.cpp create mode 100644 src/890.cpp diff --git a/src/1561.cpp b/src/1561.cpp new file mode 100644 index 0000000..ce4ed75 --- /dev/null +++ b/src/1561.cpp @@ -0,0 +1,15 @@ +int maxCoins(vector& piles) { + int len = piles.size(); + sort(piles.begin(), piles.end()); + int sum = 0; + int lim = len/3; + int i = len-2; + while (i >= 0 && lim > 0) + { + sum += piles[i]; + i -= 2; + --lim; + } + + return sum; + } \ No newline at end of file diff --git a/src/1641.cpp b/src/1641.cpp new file mode 100644 index 0000000..bfbc619 --- /dev/null +++ b/src/1641.cpp @@ -0,0 +1,18 @@ +int countVowelStrings(int n) { + int ct = 0; + for (int i = 0; i < 5; ++i) + dfs(0, i, n, ct); + + return ct; + } + + void dfs(int index, int v, int n, int& ct) + { + if (index == n-1) + ++ct; + else + { + for (int i = v; i < 5; ++i) + dfs(index+1, i, n, ct); + } + } \ No newline at end of file diff --git a/src/1669.cpp b/src/1669.cpp new file mode 100644 index 0000000..417780c --- /dev/null +++ b/src/1669.cpp @@ -0,0 +1,25 @@ +ListNode* mergeInBetween(ListNode* list1, int a, int b, ListNode* list2) { + ListNode* p = list1, *q = list2; + ListNode* pr = list1; + int i = 0; + while (i < a-1) + { + p = p->next; + pr = p; + ++i; + } + while (i < b) + { + pr = pr->next; + ++i; + } + + while (q->next != nullptr) + q = q->next; + + p->next = list2; + q->next = pr->next; + pr->next = nullptr; + + return list1; + } \ No newline at end of file diff --git a/src/1689.cpp b/src/1689.cpp new file mode 100644 index 0000000..78abae3 --- /dev/null +++ b/src/1689.cpp @@ -0,0 +1,11 @@ +int minPartitions(string n) { + int len = n.size(); + char c = '0'; + for (int i = 0; i < len; ++i) + { + if (n[i] > c) + c = n[i]; + } + + return c-'0'; + } \ No newline at end of file diff --git a/src/1721.cpp b/src/1721.cpp new file mode 100644 index 0000000..f2f13a3 --- /dev/null +++ b/src/1721.cpp @@ -0,0 +1,34 @@ +ListNode* swapNodes(ListNode* head, int k) { + int ct = 0; + ListNode* p = head; + while (p != nullptr) + { + p = p->next; + ++ct; + } + + int i = 0, j = ct - k + 1; + int m = 0; + if (k == j) + return head; + + p = head; + ListNode* nodearr[2]; + while (p != nullptr) + { + ++i; + if (i == k || i == j) + { + nodearr[m++] = p; + if (m == 2) + break; + } + p = p->next; + } + + int tmp = nodearr[0]->val; + nodearr[0]->val = nodearr[1]->val; + nodearr[1]->val = tmp; + + return head; + } \ No newline at end of file diff --git a/src/890.cpp b/src/890.cpp new file mode 100644 index 0000000..e16af5a --- /dev/null +++ b/src/890.cpp @@ -0,0 +1,38 @@ +vector findAndReplacePattern(vector& words, string pattern) { + int len = pattern.size(); + map> mp; + for (int i = 0; i < len; ++i) + { + mp[pattern[i]].push_back(i); + } + + int sz = words.size(); + vector res; + for (int i = 0; i < sz; ++i) + { + int flag[26] = {0}; + auto last = mp.end(); + auto iter = mp.begin(); + for (; iter != last; ++iter) + { + vector& vec = iter->second; + int n = vec.size(); + if (flag[words[i][vec[0]]-'a']== 1) + break; + int j = 1; + for (j = 1; j < n; ++j) + { + if (words[i][vec[0]] != words[i][vec[j]]) + break; + } + if (j != n) + break; + flag[words[i][vec[0]]-'a'] = 1; + } + + if (iter == last) + res.push_back(words[i]); + } + + return res; + } \ No newline at end of file From 8733de7db7c79f7813d96b4598d174745e9a7878 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 27 Feb 2021 19:59:04 +0800 Subject: [PATCH 57/97] 7 problems solved. --- src/1415.cpp | 38 +++++++++++++++++++++++++++ src/1433.cpp | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/1457.cpp | 41 +++++++++++++++++++++++++++++ src/1652.cpp | 45 ++++++++++++++++++++++++++++++++ src/1752.cpp | 38 +++++++++++++++++++++++++++ src/1758.cpp | 24 +++++++++++++++++ src/1768.cpp | 26 ++++++++++++++++++ 7 files changed, 286 insertions(+) create mode 100644 src/1415.cpp create mode 100644 src/1433.cpp create mode 100644 src/1457.cpp create mode 100644 src/1652.cpp create mode 100644 src/1752.cpp create mode 100644 src/1758.cpp create mode 100644 src/1768.cpp diff --git a/src/1415.cpp b/src/1415.cpp new file mode 100644 index 0000000..efd36d2 --- /dev/null +++ b/src/1415.cpp @@ -0,0 +1,38 @@ +string getHappyString(int n, int k) { + int maxn = 3*pow(2, n-1); + if (k > maxn) + return ""; + + string res(n, ' '); + int ct = 0; + for (int i = 0; i < 3; ++i) + { + dfs('a'+i, 0, n, ct, k, res); + if (ct == k) + break; + } + + return res; + } + + void dfs(char c, int m, int n, int& ct, int k, string& res) + { + if (ct < k) + { + res[m++] = c; + if (m == n) + { + ++ct; + if (ct == k) + return; + } + else + { + for (int i = 0; i < 3; ++i) + { + if ('a'+i != c) + dfs('a'+i, m, n, ct, k, res); + } + } + } + } \ No newline at end of file diff --git a/src/1433.cpp b/src/1433.cpp new file mode 100644 index 0000000..e4a21db --- /dev/null +++ b/src/1433.cpp @@ -0,0 +1,74 @@ +bool checkIfCanBreak(string s1, string s2) { + int len = s1.size(); + if (len == 1) + return true; + + int num[2][26]; + memset(num, 0, 2*26*sizeof(int)); + for (int i = 0; i < len; ++i) + { + num[0][s1[i]-'a']++; + num[1][s2[i]-'a']++; + } + + int i = 25; + for (; i >= 0; --i) + { + if (num[0][i] != num[1][i]) + break; + } + if (i <= 0) + return true; + if (num[0][i] > num[1][i]) + { + int j = i; + int r = num[0][i]; + while (i >= 0 && j >= 0) + { + if (r >= num[1][j]) + { + r -= num[1][j]; + --j; + } + else + { + --i; + for (; i >= j; --i) + { + r += num[0][i]; + if (r >= num[1][j]) + break; + } + if (i < j) + return false; + } + } + return true; + } + else + { + int j = i; + int r = num[1][i]; + while (i >= 0 && j >= 0) + { + if (r >= num[0][j]) + { + r -= num[0][j]; + --j; + } + else + { + --i; + for (; i >= j; --i) + { + r += num[1][i]; + if (r >= num[0][j]) + break; + } + if (i < j) + return false; + } + } + return true; + } + } \ No newline at end of file diff --git a/src/1457.cpp b/src/1457.cpp new file mode 100644 index 0000000..f8edbd3 --- /dev/null +++ b/src/1457.cpp @@ -0,0 +1,41 @@ +int pseudoPalindromicPaths (TreeNode* root) { + int arr[10] = {0}; + int ct = 0; + + search(root, arr, ct); + + return ct; + } + + void search(TreeNode* node, int* arr, int& ct) + { + int v = node->val; + arr[v]++; + if (node->left == nullptr && node->right == nullptr) + { + int n = 0; + for (int i = 1; i < 10; ++i) + { + if (arr[i]%2 == 1) + { + ++n; + if (n == 2) + break; + } + } + if (n < 2) + ++ct; + + return; + } + if (node->left != nullptr) + { + search(node->left, arr, ct); + arr[node->left->val]--; + } + if (node->right != nullptr) + { + search(node->right, arr, ct); + arr[node->right->val]--; + } + } \ No newline at end of file diff --git a/src/1652.cpp b/src/1652.cpp new file mode 100644 index 0000000..dabf698 --- /dev/null +++ b/src/1652.cpp @@ -0,0 +1,45 @@ +vector decrypt(vector& code, int k) { + int len = code.size(); + if (len == 1) + return {0}; + + vector res(len, 0); + if (k == 0) + return res; + if (k > 0) + { + int i = 0, j = 1; + int sum = 0; + for (; j <= k; ++j) + sum += code[(i+j)%len]; + res[0] = sum; + ++i; + int last = (k+1)%len; + while (i < len) + { + sum += code[last] - code[i]; + res[i] = sum; + last = (last+1)%len; + ++i; + } + return res; + } + else + { + int i = 0, j = 1; + int sum = 0; + for (; j <= -k; ++j) + sum += code[(i-j+len)%len]; + res[0] = sum; + ++i; + int last = len+k; + while (i < len) + { + sum += code[i-1] - code[last]; + res[i] = sum; + last = (last+1)%len; + ++i; + } + return res; + } + } \ No newline at end of file diff --git a/src/1752.cpp b/src/1752.cpp new file mode 100644 index 0000000..d32920f --- /dev/null +++ b/src/1752.cpp @@ -0,0 +1,38 @@ +bool check(vector& nums) { + int len = nums.size(); + if (len <= 2) + return true; + int i = 0; + while (i < len-1 && nums[i] == nums[i+1]) + ++i; + if (i == len-1) + return true; + + int val = 0; + bool flag = false; + if (nums[i] < nums[i+1]) + flag = true; + if (flag) + { + val = nums[i]; + ++i; + while (i < len && nums[i] >= nums[i-1]) + ++i; + if (i == len) + return true; + if (nums[i] > val) + return false; + ++i; + while (i < len && nums[i] >= nums[i-1] && nums[i] <= val) + ++i; + return i == len; + } + else + { + val = nums[i]; + ++i; + while (i < len-1 && nums[i] <= nums[i+1] && nums[i+1] <= val) + ++i; + return i == len-1; + } + } \ No newline at end of file diff --git a/src/1758.cpp b/src/1758.cpp new file mode 100644 index 0000000..86ec463 --- /dev/null +++ b/src/1758.cpp @@ -0,0 +1,24 @@ +int minOperations(string s) { + int len = s.size(); + int sum1 = 0, sum2 = 0; + for (int i = 0; i < len; ++i) + { + if (i%2 == 0 && s[i] == '1') + ++sum1; + else if (i%2 == 1 && s[i] == '0') + ++sum1; + } + + for (int i = 0; i < len; ++i) + { + if (i%2 == 0 && s[i] == '0') + ++sum2; + else if (i%2 == 1 && s[i] == '1') + ++sum2; + } + + if (sum1 < sum2) + return sum1; + else + return sum2; + } \ No newline at end of file diff --git a/src/1768.cpp b/src/1768.cpp new file mode 100644 index 0000000..fc667d5 --- /dev/null +++ b/src/1768.cpp @@ -0,0 +1,26 @@ +string mergeAlternately(string word1, string word2) { + int len1 = word1.size(); + int len2 = word2.size(); + string res(len1+len2, ' '); + int i = 0, j = 0; + int k = 0; + while (i < len1 && j < len2) + { + if (k%2 == 0) + res[k++] = word1[i++]; + else + res[k++] = word2[j++]; + } + if (i < len1) + { + for (; i < len1; ++i) + res[k++] = word1[i]; + } + else if (j < len2) + { + for (; j < len2; ++j) + res[k++] = word2[j]; + } + + return res; + } \ No newline at end of file From 0078ac6c2d257ef0e747b72ed48f1073166cbabc Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 6 Mar 2021 19:46:01 +0800 Subject: [PATCH 58/97] 5 problems solved. --- src/1315.cpp | 37 +++++++++++++++++++++++++++++++++++++ src/1523.cpp | 6 ++++++ src/1544.cpp | 27 +++++++++++++++++++++++++++ src/1640.cpp | 39 +++++++++++++++++++++++++++++++++++++++ src/1773.cpp | 19 +++++++++++++++++++ 5 files changed, 128 insertions(+) create mode 100644 src/1315.cpp create mode 100644 src/1523.cpp create mode 100644 src/1544.cpp create mode 100644 src/1640.cpp create mode 100644 src/1773.cpp diff --git a/src/1315.cpp b/src/1315.cpp new file mode 100644 index 0000000..cf24ac8 --- /dev/null +++ b/src/1315.cpp @@ -0,0 +1,37 @@ +int sumEvenGrandparent(TreeNode* root) { + return search(root); + } + + int search(TreeNode* node) + { + if (node == nullptr) + return 0; + else if (node->val % 2 == 1) + return search(node->left) + search(node->right); + else + { + int sum = 0; + TreeNode* l1 = node->left; + TreeNode* l2 = node->right; + if (l1 != nullptr) + { + TreeNode* ll1 = l1->left; + TreeNode* ll2 = l1->right; + if (ll1 != nullptr) + sum += ll1->val; + if (ll2 != nullptr) + sum += ll2->val; + } + if (l2 != nullptr) + { + TreeNode* lr1 = l2->left; + TreeNode* lr2 = l2->right; + if (lr1 != nullptr) + sum += lr1->val; + if (lr2 != nullptr) + sum += lr2->val; + } + + return sum + search(l1) + search(l2); + } + } \ No newline at end of file diff --git a/src/1523.cpp b/src/1523.cpp new file mode 100644 index 0000000..65f6174 --- /dev/null +++ b/src/1523.cpp @@ -0,0 +1,6 @@ +int countOdds(int low, int high) { + if (low%2 == 1 && high%2 == 1) + return (high-low)/2 + 1; + else + return (high-low+1)/2; + } \ No newline at end of file diff --git a/src/1544.cpp b/src/1544.cpp new file mode 100644 index 0000000..4f6e67f --- /dev/null +++ b/src/1544.cpp @@ -0,0 +1,27 @@ +string makeGood(string s) { + int len = s.size(); + string res(len, ' '); + int i = 0, j = 0; + res[j] = s[i]; + ++i; + ++j; + while (i < len) + { + if (j == 0) + { + res[j++] = s[i++]; + } + else if ((islower(res[j-1]) && isupper(s[i]) && res[j-1] == tolower(s[i])) + || (isupper(res[j-1]) && islower(s[i]) && res[j-1] == toupper(s[i]))) + { + --j; + ++i; + } + else + { + res[j++] = s[i++]; + } + } + + return res.substr(0, j); + } \ No newline at end of file diff --git a/src/1640.cpp b/src/1640.cpp new file mode 100644 index 0000000..3620234 --- /dev/null +++ b/src/1640.cpp @@ -0,0 +1,39 @@ +bool canFormArray(vector& arr, vector>& pieces) { + int len = arr.size(); + struct Elem + { + int pos; + int length; + Elem(int p = -1, int l = 0): pos(p), length(l){} + }; + + int n = pieces.size(); + map mp; + int sum = 0; + for (int i = 0; i < n; ++i) + { + int m = pieces[i].size(); + mp.insert(make_pair(pieces[i][0], Elem(i, m))); + sum += m; + } + + if (len != sum) + return false; + + int i = 0; + while (i < len) + { + auto iter = mp.find(arr[i]); + if (iter == mp.end()) + return false; + for (int k = 0; k < (iter->second).length; ++k) + { + if (arr[i] != pieces[(iter->second).pos][k]) + return false; + else + ++i; + } + } + + return true; + } \ No newline at end of file diff --git a/src/1773.cpp b/src/1773.cpp new file mode 100644 index 0000000..103d6c9 --- /dev/null +++ b/src/1773.cpp @@ -0,0 +1,19 @@ +int countMatches(vector>& items, string ruleKey, string ruleValue) { + int len = items.size(); + int pos = -1; + if (ruleKey == "type") + pos = 0; + else if (ruleKey == "color") + pos = 1; + else + pos = 2; + + int ct = 0; + for (int i = 0; i < len; ++i) + { + if (items[i][pos] == ruleValue) + ++ct; + } + + return ct; + } \ No newline at end of file From a5ccc9a274d47fb2e8c71bc0188ff2356c188c6f Mon Sep 17 00:00:00 2001 From: Troy Date: Thu, 25 Mar 2021 12:26:41 +0800 Subject: [PATCH 59/97] 8 problems solved. --- src/1013.cpp | 35 +++++++++++++++++++++++++++++++++++ src/1476.cpp | 24 ++++++++++++++++++++++++ src/1539.cpp | 22 ++++++++++++++++++++++ src/1582.cpp | 28 ++++++++++++++++++++++++++++ src/1700.cpp | 21 +++++++++++++++++++++ src/1769.cpp | 17 +++++++++++++++++ src/1779.cpp | 22 ++++++++++++++++++++++ src/1790.cpp | 26 ++++++++++++++++++++++++++ 8 files changed, 195 insertions(+) create mode 100644 src/1013.cpp create mode 100644 src/1476.cpp create mode 100644 src/1539.cpp create mode 100644 src/1582.cpp create mode 100644 src/1700.cpp create mode 100644 src/1769.cpp create mode 100644 src/1779.cpp create mode 100644 src/1790.cpp diff --git a/src/1013.cpp b/src/1013.cpp new file mode 100644 index 0000000..e50cff0 --- /dev/null +++ b/src/1013.cpp @@ -0,0 +1,35 @@ +bool canThreePartsEqualSum(vector& A) { + int len = A.size(); + int sum = 0; + for (int i = 0; i < len; ++i) + { + sum += A[i]; + } + if (sum%3 != 0) + return false; + + int i = 0; + int subsum = 0; + while (i >& rectangle) { + data.assign(rectangle.begin(), rectangle.end()); + row = rectangle.size(); + col = rectangle[0].size(); + } + + void updateSubrectangle(int row1, int col1, int row2, int col2, int newValue) { + for (int i = row1; i <= row2; ++i) + { + fill(data[i].begin()+col1, data[i].begin()+col2+1, newValue); + } + } + + int getValue(int row, int col) { + return data[row][col]; + } + + private: + vector> data; + int row; + int col; +}; \ No newline at end of file diff --git a/src/1539.cpp b/src/1539.cpp new file mode 100644 index 0000000..b51b153 --- /dev/null +++ b/src/1539.cpp @@ -0,0 +1,22 @@ +int findKthPositive(vector& arr, int k) { + int flag[2000] = {0}; + int len = arr.size(); + for (int i = 0; i < len; ++i) + flag[arr[i]-1] = 1; + + int ct = 0; + for (int i = 0; i < 2000; ++i) + { + if (flag[i] == 0) + { + ++ct; + if (ct == k) + { + ct = i+1; + break; + } + } + } + + return ct; + } \ No newline at end of file diff --git a/src/1582.cpp b/src/1582.cpp new file mode 100644 index 0000000..fd59b0a --- /dev/null +++ b/src/1582.cpp @@ -0,0 +1,28 @@ +int numSpecial(vector>& mat) { + int row = mat.size(); + int col = mat[0].size(); + map rowmp, colmp; + for (int i = 0; i < row; ++i) + { + for (int j = 0; j < col; ++j) + { + if (mat[i][j] == 1) + { + rowmp[i]++; + colmp[j]++; + } + } + } + + int ct = 0; + for (int i = 0; i < row; ++i) + { + for (int j = 0; j < col; ++j) + { + if (mat[i][j] == 1 && rowmp[i] == 1 && colmp[j] == 1) + ++ct; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/1700.cpp b/src/1700.cpp new file mode 100644 index 0000000..461be5d --- /dev/null +++ b/src/1700.cpp @@ -0,0 +1,21 @@ +int countStudents(vector& students, vector& sandwiches) { + deque stu(students.begin(), students.end()); + + int len = sandwiches.size(); + int remain = len; + int i = 0, j = 0; + while (i < len) + { + for (j = 0; j < remain; ++j) + if (sandwiches[i] == stu[j]) + break; + if (j == remain) + break; + stu.insert(stu.end(), stu.begin(), stu.begin()+j); + stu.erase(stu.begin(), stu.begin()+j+1); + ++i; + --remain; + } + + return remain; + } \ No newline at end of file diff --git a/src/1769.cpp b/src/1769.cpp new file mode 100644 index 0000000..fbb2ecc --- /dev/null +++ b/src/1769.cpp @@ -0,0 +1,17 @@ +vector minOperations(string boxes) { + int len = boxes.size(); + vector res(len, 0); + + for (int i = 0; i < len; ++i) + { + int ct = 0; + for (int j = 0; j < len; ++j) + { + if (boxes[j] == '1') + ct += abs(j-i); + } + res[i] = ct; + } + + return res; + } \ No newline at end of file diff --git a/src/1779.cpp b/src/1779.cpp new file mode 100644 index 0000000..b6ba82e --- /dev/null +++ b/src/1779.cpp @@ -0,0 +1,22 @@ +int nearestValidPoint(int x, int y, vector>& points) { + int len = points.size(); + int minv = numeric_limits::max(); + int pos = -1; + + for (int i = 0; i < len; ++i) + { + if (points[i][0] == x || points[i][1] == y) + { + int dist = abs(x-points[i][0]) + abs(y-points[i][1]); + if (dist == 0) + return i; + else if (dist < minv) + { + minv = dist; + pos = i; + } + } + } + + return pos; + } \ No newline at end of file diff --git a/src/1790.cpp b/src/1790.cpp new file mode 100644 index 0000000..cf70004 --- /dev/null +++ b/src/1790.cpp @@ -0,0 +1,26 @@ +bool areAlmostEqual(string s1, string s2) { + if (s1 == s2) + return true; + int len = s1.size(); + int ct = 0; + char arr[4]; + for (int i = 0; i < len; ++i) + { + if (s1[i] != s2[i]) + { + if (ct == 2) + return false; + arr[ct*2] = s1[i]; + arr[ct*2+1] = s2[i]; + ++ct; + } + } + + if (ct == 1) + return false; + + if (arr[0] == arr[3] && arr[1] == arr[2]) + return true; + else + return false; + } \ No newline at end of file From c02953bdd962f6048cc674d7bf7b6efdf350de0c Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 17 Apr 2021 19:02:56 +0800 Subject: [PATCH 60/97] 8 problems solved. --- src/1233.cpp | 24 ++++++++++++++++++++++++ src/1343.cpp | 21 +++++++++++++++++++++ src/1508.cpp | 20 ++++++++++++++++++++ src/1701.cpp | 15 +++++++++++++++ src/1726.cpp | 19 +++++++++++++++++++ src/1806.cpp | 27 +++++++++++++++++++++++++++ src/287.cpp | 13 +++++++++++++ src/950.cpp | 44 ++++++++++++++++++++++++++++++++++++++++++++ 8 files changed, 183 insertions(+) create mode 100644 src/1233.cpp create mode 100644 src/1343.cpp create mode 100644 src/1508.cpp create mode 100644 src/1701.cpp create mode 100644 src/1726.cpp create mode 100644 src/1806.cpp create mode 100644 src/287.cpp create mode 100644 src/950.cpp diff --git a/src/1233.cpp b/src/1233.cpp new file mode 100644 index 0000000..35421b6 --- /dev/null +++ b/src/1233.cpp @@ -0,0 +1,24 @@ +vector removeSubfolders(vector& folder) { + int len = folder.size(); + sort(folder.begin(), folder.end()); + list lst(folder.begin(), folder.end()); + + auto iter = lst.begin(); + auto iter_next = ++iter; + --iter; + while (true) + { + auto iter_end = lst.end(); + if (iter == iter_end || iter_next == iter_end) + break; + if ((*iter_next).find(*iter) == 0 && (*iter_next)[(*iter).size()] == '/') + iter_next = lst.erase(iter_next); + else + { + ++iter; + ++iter_next; + } + } + + return vector(lst.begin(), lst.end()); + } \ No newline at end of file diff --git a/src/1343.cpp b/src/1343.cpp new file mode 100644 index 0000000..5ceef61 --- /dev/null +++ b/src/1343.cpp @@ -0,0 +1,21 @@ +int numOfSubarrays(vector& arr, int k, int threshold) { + int len = arr.size(); + int sum = 0; + int ct = 0; + const int thres = k*threshold; + + for (int i = 0; i < k; ++i) + sum += arr[i]; + if (sum >= thres) + ++ct; + int j = k; + while (j < len) + { + sum += arr[j]-arr[j-k]; + if (sum >= thres) + ++ct; + ++j; + } + + return ct; + } \ No newline at end of file diff --git a/src/1508.cpp b/src/1508.cpp new file mode 100644 index 0000000..462189c --- /dev/null +++ b/src/1508.cpp @@ -0,0 +1,20 @@ +int rangeSum(vector& nums, int n, int left, int right) { + vector res(n*(n+1)/2, 0); + int k = -1; + for (int i = 0; i < n; ++i) + { + res[++k] = nums[i]; + for (int j = i+1; j < n; ++j) + { + int tmp = res[k] + nums[j]; + res[++k] = tmp; + } + } + + sort(res.begin(), res.end()); + long long sum = 0; + for (int i = left-1; i < right; ++i) + sum += res[i]; + + return sum%(1000000000+7); + } \ No newline at end of file diff --git a/src/1701.cpp b/src/1701.cpp new file mode 100644 index 0000000..a1f083f --- /dev/null +++ b/src/1701.cpp @@ -0,0 +1,15 @@ +double averageWaitingTime(vector>& customers) { + int len = customers.size(); + double avgWaitTime = 0; + int prefinishtime = 0; + int i = 0; + + while (i < len) + { + avgWaitTime += customers[i][0] >= prefinishtime ? customers[i][1] : prefinishtime-customers[i][0]+customers[i][1]; + prefinishtime = customers[i][0] >= prefinishtime ? customers[i][0]+customers[i][1] : prefinishtime+customers[i][1]; + ++i; + } + + return avgWaitTime / len; + } \ No newline at end of file diff --git a/src/1726.cpp b/src/1726.cpp new file mode 100644 index 0000000..5280744 --- /dev/null +++ b/src/1726.cpp @@ -0,0 +1,19 @@ +int tupleSameProduct(vector& nums) { + int len = nums.size(); + map mp; + for (int i = 0; i < len; ++i) + { + for (int j = i+1; j < len; ++j) + mp[nums[i]*nums[j]]++; + } + + int sum = 0; + auto iterend = mp.end(); + for (auto iter = mp.begin(); iter != iterend; ++iter) + { + if (iter->second > 1) + sum += iter->second*(iter->second-1)*4; + } + + return sum; + } \ No newline at end of file diff --git a/src/1806.cpp b/src/1806.cpp new file mode 100644 index 0000000..1e9756b --- /dev/null +++ b/src/1806.cpp @@ -0,0 +1,27 @@ +int reinitializePermutation(int n) { + vector arr(n, 0); + for (int i = 0; i < n; ++i) + arr[i] = i; + + int ct = 0; + vector tmp(n, 0); + while (true) + { + ++ct; + int k = 0; + for (int i = 0; i < n; ++i) + { + if (i%2 == 0) + tmp[i] = arr[i/2]; + else + tmp[i] = arr[n/2+(i-1)/2]; + if (tmp[i] == i) + ++k; + } + if (k == n) + break; + swap(arr, tmp); + } + + return ct; + } \ No newline at end of file diff --git a/src/287.cpp b/src/287.cpp new file mode 100644 index 0000000..54b3da3 --- /dev/null +++ b/src/287.cpp @@ -0,0 +1,13 @@ +int findDuplicate(vector& nums) { + int len = nums.size(); + sort(nums.begin(), nums.end()); + int i = 1; + while (i < len) + { + if (nums[i] == nums[i-1]) + break; + ++i; + } + + return nums[i]; + } \ No newline at end of file diff --git a/src/950.cpp b/src/950.cpp new file mode 100644 index 0000000..27c642b --- /dev/null +++ b/src/950.cpp @@ -0,0 +1,44 @@ +vector deckRevealedIncreasing(vector& deck) { + int len = deck.size(); + sort(deck.begin(), deck.end()); + vector res(len, 0); + vector flag(len, 0); + + int ct = 0; + int v = 0; + int i = 0; + while (ct < len) + { + int j; + for (j = i; j < len; ++j) + { + if (flag[j] == 0) + { + flag[j] = 1-v; + if (flag[j] == 1) + res[j] = deck[ct++]; + v = 1-v; + i = (j+1)%len; + break; + } + } + + if (j == len) + { + for (j = 0; j < i; ++j) + { + if (flag[j] == 0) + { + flag[j] = 1-v; + if (flag[j] == 1) + res[j] = deck[ct++]; + v = 1-v; + i = (j+1)%len; + break; + } + } + } + } + + return res; + } \ No newline at end of file From 7f5ef72fe725fc89678c88016e9d144dafc3cd74 Mon Sep 17 00:00:00 2001 From: Troy Date: Thu, 29 Apr 2021 18:44:49 +0800 Subject: [PATCH 61/97] 6 problems solved. --- src/1266.cpp | 25 ++++++++++++++ src/1827.cpp | 14 ++++++++ src/1833.cpp | 20 ++++++++++++ src/1837.cpp | 10 ++++++ src/746.cpp | 15 +++++++++ src/82.cpp | 92 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 176 insertions(+) create mode 100644 src/1266.cpp create mode 100644 src/1827.cpp create mode 100644 src/1833.cpp create mode 100644 src/1837.cpp create mode 100644 src/746.cpp create mode 100644 src/82.cpp diff --git a/src/1266.cpp b/src/1266.cpp new file mode 100644 index 0000000..661b35e --- /dev/null +++ b/src/1266.cpp @@ -0,0 +1,25 @@ +int minTimeToVisitAllPoints(vector>& points) { + int len = points.size(); + if (len == 1) + return 0; + int a = points[0][0], b = points[0][1]; + int sum = 0; + for (int i = 1; i < len; ++i) + { + int c = points[i][0], d = points[i][1]; + if (a == c && b != d) + sum += abs(b-d); + else if (a != c && b == d) + sum += abs(a-c); + else if (a != c && b != d) + { + int mindiff = abs(a-c) < abs(b-d) ? abs(a-c) : abs(b-d); + int delta = abs(abs(a-c)-abs(b-d)); + sum += mindiff + delta; + } + a = c; + b = d; + } + + return sum; + } \ No newline at end of file diff --git a/src/1827.cpp b/src/1827.cpp new file mode 100644 index 0000000..f7f8db9 --- /dev/null +++ b/src/1827.cpp @@ -0,0 +1,14 @@ +int minOperations(vector& nums) { + int len = nums.size(); + int sum = 0; + for (int i = 1; i < len; ++i) + { + if (nums[i] <= nums[i-1]) + { + sum += nums[i-1]-nums[i]+1; + nums[i] = nums[i-1]+1; + } + } + + return sum; + } \ No newline at end of file diff --git a/src/1833.cpp b/src/1833.cpp new file mode 100644 index 0000000..55db4e8 --- /dev/null +++ b/src/1833.cpp @@ -0,0 +1,20 @@ +int maxIceCream(vector& costs, int coins) { + int len = costs.size(); + sort(costs.begin(), costs.end()); + + int n = 0; + int i = 0; + while (i < len && coins > 0) + { + if (coins >= costs[i]) + { + coins -= costs[i]; + ++i; + ++n; + } + else + break; + } + + return n; + } \ No newline at end of file diff --git a/src/1837.cpp b/src/1837.cpp new file mode 100644 index 0000000..17aaedb --- /dev/null +++ b/src/1837.cpp @@ -0,0 +1,10 @@ +int sumBase(int n, int k) { + int sum = 0; + while (n >= k) + { + sum += n%k; + n /= k; + } + + return sum+n; + } \ No newline at end of file diff --git a/src/746.cpp b/src/746.cpp new file mode 100644 index 0000000..d9f72b8 --- /dev/null +++ b/src/746.cpp @@ -0,0 +1,15 @@ +int minCostClimbingStairs(vector& cost) { + int len = cost.size(); + vector dp(len+1, 0); + + dp[0] = 0; + dp[1] = 0; + int i = 2; + while (i <= len) + { + dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2]); + ++i; + } + + return dp[len]; + } \ No newline at end of file diff --git a/src/82.cpp b/src/82.cpp new file mode 100644 index 0000000..13c66b4 --- /dev/null +++ b/src/82.cpp @@ -0,0 +1,92 @@ +ListNode* deleteDuplicates(ListNode* head) { + if (head == nullptr || head->next == nullptr) + return head; + + ListNode* node = head; + int refval = head->val; + ListNode* tmp = node->next; + bool flag = false; + while (tmp != nullptr) + { + if (tmp->val == refval) + { + ListNode* p = tmp->next; + delete tmp; + tmp = p; + flag = true; + } + else + { + if (!flag) + { + head = node; + break; + } + else + { + delete node; + node = tmp; + tmp = tmp->next; + refval = node->val; + flag = false; + } + } + } + + if (tmp == nullptr) + { + if (flag) + { + delete node; + return nullptr; + } + else + { + head = node; + return head; + } + } + + flag = false; + refval = tmp->val; + ListNode* tmp2 = tmp->next; + ListNode* lastnode = node; + while (tmp2 != nullptr) + { + if (tmp2->val == refval) + { + ListNode* p = tmp2->next; + tmp->next = p; + delete tmp2; + tmp2 = p; + flag = true; + } + else + { + if (!flag) + { + refval = tmp2->val; + lastnode = tmp; + tmp = tmp2; + tmp2 = tmp2->next; + } + else + { + lastnode->next = tmp2; + delete tmp; + refval = tmp2->val; + tmp = tmp2; + tmp2 = tmp2->next; + flag = false; + } + } + } + + if (flag) + { + lastnode->next = nullptr; + delete tmp; + } + + return head; + } \ No newline at end of file From f3a1249463a8f8e45047251f2433af94c8ecbb53 Mon Sep 17 00:00:00 2001 From: Troy Date: Tue, 4 May 2021 20:03:03 +0800 Subject: [PATCH 62/97] 8 problems solved. --- src/147.cpp | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/1614.cpp | 21 +++++++++++++++++++++ src/1812.cpp | 3 +++ src/1816.cpp | 13 +++++++++++++ src/1822.cpp | 13 +++++++++++++ src/1832.cpp | 17 +++++++++++++++++ src/1844.cpp | 9 +++++++++ src/1848.cpp | 37 +++++++++++++++++++++++++++++++++++++ 8 files changed, 163 insertions(+) create mode 100644 src/147.cpp create mode 100644 src/1614.cpp create mode 100644 src/1812.cpp create mode 100644 src/1816.cpp create mode 100644 src/1822.cpp create mode 100644 src/1832.cpp create mode 100644 src/1844.cpp create mode 100644 src/1848.cpp diff --git a/src/147.cpp b/src/147.cpp new file mode 100644 index 0000000..adde8e8 --- /dev/null +++ b/src/147.cpp @@ -0,0 +1,50 @@ +ListNode* insertionSortList(ListNode* head) { + if (head == nullptr || head->next == nullptr) + return head; + + ListNode* node = head; + ListNode* p = head->next; + node->next = nullptr; + while (p != nullptr) + { + ListNode* p1 = node; + if (p->val <= p1->val) + { + ListNode* tmp = p->next; + p->next = p1; + node = p; + p = tmp; + } + else + { + ListNode* p2 = p1; + while (p1->next != nullptr && p1->val < p->val) + { + p2 = p1; + p1 = p1->next; + } + ListNode* tmp = p->next; + if (p1->next == nullptr) + { + if (p1->val < p->val) + { + p1->next = p; + p->next = nullptr; + } + else + { + p2->next = p; + p->next = p1; + } + } + else + { + p2->next = p; + p->next = p1; + } + p = tmp; + } + } + + return node; + } \ No newline at end of file diff --git a/src/1614.cpp b/src/1614.cpp new file mode 100644 index 0000000..d919639 --- /dev/null +++ b/src/1614.cpp @@ -0,0 +1,21 @@ +int maxDepth(string s) { + int len = s.size(); + int maxdepth = 0; + int depth = 0; + int i = 0; + + while (i < len) + { + if (s[i] == '(') + ++depth; + else if (s[i] == ')') + { + if (depth > maxdepth) + maxdepth = depth; + --depth; + } + ++i; + } + + return maxdepth; + } \ No newline at end of file diff --git a/src/1812.cpp b/src/1812.cpp new file mode 100644 index 0000000..839a4ac --- /dev/null +++ b/src/1812.cpp @@ -0,0 +1,3 @@ +bool squareIsWhite(string coordinates) { + return ((coordinates[0]-'a')+(coordinates[1]-'1'))%2 == 0 ? false : true; + } \ No newline at end of file diff --git a/src/1816.cpp b/src/1816.cpp new file mode 100644 index 0000000..62d53a3 --- /dev/null +++ b/src/1816.cpp @@ -0,0 +1,13 @@ +string truncateSentence(string s, int k) { + int i = 0; + int index = 0; + int pos = 0; + while (i < k) + { + pos = s.find(' ', index); + ++i; + index = pos+1; + } + + return s.substr(0, pos); + } \ No newline at end of file diff --git a/src/1822.cpp b/src/1822.cpp new file mode 100644 index 0000000..b604233 --- /dev/null +++ b/src/1822.cpp @@ -0,0 +1,13 @@ +int arraySign(vector& nums) { + int len = nums.size(); + int ct = 0; + for (int i = 0; i < len; ++i) + { + if (nums[i] < 0) + ++ct; + else if (nums[i] == 0) + return 0; + } + + return ct%2 == 0 ? 1 : -1; + } \ No newline at end of file diff --git a/src/1832.cpp b/src/1832.cpp new file mode 100644 index 0000000..438c55d --- /dev/null +++ b/src/1832.cpp @@ -0,0 +1,17 @@ +bool checkIfPangram(string sentence) { + int len = sentence.size(); + if (len < 26) + return false; + int arr[26] = {0}; + int ct = 0; + for (int i = 0; i < len; ++i) + { + if (arr[sentence[i]-'a'] == 0) + { + ++ct; + arr[sentence[i]-'a'] = 1; + } + } + + return ct == 26; + } \ No newline at end of file diff --git a/src/1844.cpp b/src/1844.cpp new file mode 100644 index 0000000..00725fa --- /dev/null +++ b/src/1844.cpp @@ -0,0 +1,9 @@ +string replaceDigits(string s) { + int len = s.size(); + for (int i = 0; i < len-1; i += 2) + { + s[i+1] = s[i] + (s[i+1]-'0'); + } + + return s; + } \ No newline at end of file diff --git a/src/1848.cpp b/src/1848.cpp new file mode 100644 index 0000000..535f736 --- /dev/null +++ b/src/1848.cpp @@ -0,0 +1,37 @@ +int getMinDistance(vector& nums, int target, int start) { + int len = nums.size(); + if (nums[start] == target) + return 0; + int i = start-1, j = start+1; + int ct = 1; + while (i >= 0 && j < len) + { + if (nums[i] == target || nums[j] == target) + break; + --i; + ++j; + ++ct; + } + if (i >= 0 && j < len) + return ct; + + while (i >= 0) + { + if (nums[i] == target) + break; + --i; + ++ct; + } + if (i >= 0) + return ct; + + while (j < len) + { + if (nums[j] == target) + return ct; + ++j; + ++ct; + } + + return ct; + } \ No newline at end of file From 1d092eaea9492385d7da322c2a4032764392a586 Mon Sep 17 00:00:00 2001 From: Troy Date: Thu, 20 May 2021 20:21:35 +0800 Subject: [PATCH 63/97] 6 problems solved. --- src/1624.cpp | 22 ++++++++++++++++++++++ src/1685.cpp | 18 ++++++++++++++++++ src/1796.cpp | 23 +++++++++++++++++++++++ src/1805.cpp | 46 ++++++++++++++++++++++++++++++++++++++++++++++ src/1828.cpp | 24 ++++++++++++++++++++++++ src/1859.cpp | 38 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 171 insertions(+) create mode 100644 src/1624.cpp create mode 100644 src/1685.cpp create mode 100644 src/1796.cpp create mode 100644 src/1805.cpp create mode 100644 src/1828.cpp create mode 100644 src/1859.cpp diff --git a/src/1624.cpp b/src/1624.cpp new file mode 100644 index 0000000..786df95 --- /dev/null +++ b/src/1624.cpp @@ -0,0 +1,22 @@ +int maxLengthBetweenEqualCharacters(string s) { + vector> vec(26, vector(2, -1)); + int len = s.size(); + + for (int i = 0; i < len; ++i) + { + if (vec[s[i]-'a'][0] == -1) + vec[s[i]-'a'][0] = i; + else + vec[s[i]-'a'][1] = i; + } + + int maxdelta = 0; + for (int i = 0; i < 26; ++i) + { + int delta = vec[i][1]-vec[i][0]; + if (vec[i][1] != -1 && delta > maxdelta) + maxdelta = delta; + } + + return maxdelta-1; + } \ No newline at end of file diff --git a/src/1685.cpp b/src/1685.cpp new file mode 100644 index 0000000..125654d --- /dev/null +++ b/src/1685.cpp @@ -0,0 +1,18 @@ + vector getSumAbsoluteDifferences(vector& nums) { + int len = nums.size(); + vector accusum(len, 0); + int sum = 0; + for (int i = 0; i < len; ++i) + { + sum += nums[i]; + accusum[i] = sum; + } + + vector res(len, 0); + for (int i = 0; i < len; ++i) + { + res[i] = accusum[len-1]-accusum[i]-(len-1-i)*nums[i]+(i+1)*nums[i]-accusum[i]; + } + + return res; + } \ No newline at end of file diff --git a/src/1796.cpp b/src/1796.cpp new file mode 100644 index 0000000..fbde2b2 --- /dev/null +++ b/src/1796.cpp @@ -0,0 +1,23 @@ +int secondHighest(string s) { + int len = s.size(); + if (len <= 1) + return -1; + + int maxdigit = -1, sndmaxdigit = -1; + for (int i = 0; i < len; ++i) + { + if (isdigit(s[i])) + { + int t = s[i]-'0'; + if (t > maxdigit) + { + sndmaxdigit = maxdigit; + maxdigit = t; + } + else if (t < maxdigit && t > sndmaxdigit) + sndmaxdigit = t; + } + } + + return sndmaxdigit; + } \ No newline at end of file diff --git a/src/1805.cpp b/src/1805.cpp new file mode 100644 index 0000000..34db94e --- /dev/null +++ b/src/1805.cpp @@ -0,0 +1,46 @@ +int numDifferentIntegers(string word) { + int len = word.size(); + for (int i = 0; i < len; ++i) + { + if (!isdigit(word[i])) + word[i] = ' '; + } + + int i = 0; + int lh = -1, rh = -1; + set st; + bool flag = false; + + while (i < len) + { + if (word[i] == ' ') + ++i; + else + { + lh = i; + while (i < len && word[i] == '0') + ++i; + if (i == len) + { + flag = true; + break; + } + else if (word[i] == ' ') + flag = true; + else + { + lh = i; + while (i < len && word[i] != ' ') + ++i; + st.insert(word.substr(lh, i-lh)); + if (i == len) + break; + } + } + } + + if (flag) + st.insert("0"); + + return st.size(); + } \ No newline at end of file diff --git a/src/1828.cpp b/src/1828.cpp new file mode 100644 index 0000000..5553cad --- /dev/null +++ b/src/1828.cpp @@ -0,0 +1,24 @@ +vector countPoints(vector>& points, vector>& queries) { + int plen = points.size(); + int qlen = queries.size(); + + vector r2(qlen, 0); + for (int i = 0; i < qlen; ++i) + r2[i] = queries[i][2]*queries[i][2]; + + vector res(qlen, 0); + for (int i = 0; i < qlen; ++i) + { + int ct = 0; + for (int j = 0; j < plen; ++j) + { + if (((queries[i][0]-points[j][0])*(queries[i][0]-points[j][0]) + + (queries[i][1]-points[j][1])*(queries[i][1]-points[j][1])) <= r2[i]) + ++ct; + } + + res[i] = ct; + } + + return res; + } \ No newline at end of file diff --git a/src/1859.cpp b/src/1859.cpp new file mode 100644 index 0000000..b439bb2 --- /dev/null +++ b/src/1859.cpp @@ -0,0 +1,38 @@ +string sortSentence(string s) { + int len = s.size(); + vector> pos(9, vector(2, -1)); + + int i = 0; + int lh = 0, rh = 0; + int ct = 0; + while (i < len) + { + while (i < len && s[i] != ' ') + ++i; + rh = i-2; + pos[s[i-1]-'0'-1][0] = lh; + pos[s[i-1]-'0'-1][1] = rh; + ct += rh-lh+2; + if (i == len) + { + --ct; + break; + } + lh = i+1; + ++i; + } + + string res(ct, ' '); + int k = 0; + for (int i = 0; i < 9; ++i) + { + if (pos[i][0] == -1) + break; + for (int j = pos[i][0]; j <= pos[i][1]; ++j) + res[k++] = s[j]; + if (k < ct) + res[k++] = ' '; + } + + return res; + } \ No newline at end of file From f4df8f7cd3c946c4836834fc07dedf68e056633c Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 5 Jun 2021 21:35:56 +0800 Subject: [PATCH 64/97] 6 problems solved. --- src/1784.cpp | 15 +++++++++++++++ src/1791.cpp | 9 +++++++++ src/1869.cpp | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/1876.cpp | 46 ++++++++++++++++++++++++++++++++++++++++++++++ src/1877.cpp | 15 +++++++++++++++ src/1880.cpp | 14 ++++++++++++++ 6 files changed, 150 insertions(+) create mode 100644 src/1784.cpp create mode 100644 src/1791.cpp create mode 100644 src/1869.cpp create mode 100644 src/1876.cpp create mode 100644 src/1877.cpp create mode 100644 src/1880.cpp diff --git a/src/1784.cpp b/src/1784.cpp new file mode 100644 index 0000000..345ef17 --- /dev/null +++ b/src/1784.cpp @@ -0,0 +1,15 @@ +bool checkOnesSegment(string s) { + int len1 = 0; + int len = s.size(); + if (len == 1) + return true; + + int i = 1; + while (i < len && s[i] == '1') + ++i; + if (i == len) + return true; + while (i < len && s[i] == '0') + ++i; + return i == len; + } \ No newline at end of file diff --git a/src/1791.cpp b/src/1791.cpp new file mode 100644 index 0000000..12be14f --- /dev/null +++ b/src/1791.cpp @@ -0,0 +1,9 @@ +int findCenter(vector>& edges) { + int a = edges[0][0], b = edges[0][1]; + int c = edges[1][0], d = edges[1][1]; + + if (c == a || c == b) + return c; + else + return d; + } \ No newline at end of file diff --git a/src/1869.cpp b/src/1869.cpp new file mode 100644 index 0000000..759ddf9 --- /dev/null +++ b/src/1869.cpp @@ -0,0 +1,51 @@ +bool checkZeroOnes(string s) { + int len1 = 0; + int len0 = 0; + int maxlen1 = 0, maxlen0 = 0; + + int len = s.size(); + int i = 1; + + if (len == 0) + return false; + if (s[0] == '1') + len1 = 1; + else + len0 = 1; + + while (i < len) + { + if (s[i] == '1') + { + if (len1 > 0) + ++len1; + else + { + if (len0 > maxlen0) + maxlen0 = len0; + len0 = 0; + len1 = 1; + } + } + else + { + if (len0 > 0) + ++len0; + else + { + if (len1 > maxlen1) + maxlen1 = len1; + len0 = 1; + len1 = 0; + } + } + ++i; + } + + if (len1 > 0 && len1 > maxlen1) + maxlen1 = len1; + if (len0 > 0 && len0 > maxlen0) + maxlen0 = len0; + + return maxlen1 > maxlen0; + } \ No newline at end of file diff --git a/src/1876.cpp b/src/1876.cpp new file mode 100644 index 0000000..bc54622 --- /dev/null +++ b/src/1876.cpp @@ -0,0 +1,46 @@ +int countGoodSubstrings(string s) { + int len = s.size(); + if (len < 3) + return 0; + + int ct = 0; + int a = s[0], b = s[1]; + + int i = 2; + while (i < len) + { + if (a != b) + { + if (s[i] != a && s[i] != b) + { + a = b; + b = s[i]; + ++ct; + ++i; + } + else if (s[i] == a) + { + a = b; + b = s[i]; + ++i; + } + else + { + a = b; + if (i+1 >= len) + break; + b = s[i+1]; + i += 2; + } + } + else + { + if (i+1 >= len) + break; + b = s[i]; + ++i; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/1877.cpp b/src/1877.cpp new file mode 100644 index 0000000..5238163 --- /dev/null +++ b/src/1877.cpp @@ -0,0 +1,15 @@ +int minPairSum(vector& nums) { + sort(nums.begin(), nums.end()); + + int len = nums.size(); + int maxval = 0; + int n = len/2; + for (int i = 0; i < n; ++i) + { + int val = nums[i]+nums[len-1-i]; + if (val > maxval) + maxval = val; + } + + return maxval; + } \ No newline at end of file diff --git a/src/1880.cpp b/src/1880.cpp new file mode 100644 index 0000000..35863bb --- /dev/null +++ b/src/1880.cpp @@ -0,0 +1,14 @@ +bool isSumEqual(string firstWord, string secondWord, string targetWord) { + int len1 = firstWord.size(); + int len2 = secondWord.size(); + int len = targetWord.size(); + int val1 = 0, val2 = 0, val = 0; + for (int i = 0; i < len1; ++i) + val1 = 10*val1 + firstWord[i]-'a'; + for (int i = 0; i < len2; ++i) + val2 = 10*val2 + secondWord[i]-'a'; + for (int i = 0; i < len; ++i) + val = 10*val + targetWord[i]-'a'; + + return val1 + val2 == val; + } \ No newline at end of file From 4e67506627a396f29ba90320404217ad007821f7 Mon Sep 17 00:00:00 2001 From: Troy Date: Fri, 9 Jul 2021 22:21:39 +0800 Subject: [PATCH 65/97] 5 problems solved. --- src/1903.cpp | 29 +++++++++++++++++++++++++++++ src/1909.cpp | 41 +++++++++++++++++++++++++++++++++++++++++ src/1920.cpp | 10 ++++++++++ src/398.cpp | 22 ++++++++++++++++++++++ src/921.cpp | 30 ++++++++++++++++++++++++++++++ 5 files changed, 132 insertions(+) create mode 100644 src/1903.cpp create mode 100644 src/1909.cpp create mode 100644 src/1920.cpp create mode 100644 src/398.cpp create mode 100644 src/921.cpp diff --git a/src/1903.cpp b/src/1903.cpp new file mode 100644 index 0000000..825a4d5 --- /dev/null +++ b/src/1903.cpp @@ -0,0 +1,29 @@ +string largestOddNumber(string num) { + int len = num.size(); + int index = -1; + bool flag = false; + for (int i = len-1; i >= 0; --i) + { + int tmp = num[i]-'0'; + switch (tmp) + { + case 1: + case 3: + case 5: + case 7: + case 9: + index = i; + flag = true; + break; + default: + break; + } + if (flag) + break; + } + + if (index == -1) + return ""; + else + return num.substr(0, index+1); + } \ No newline at end of file diff --git a/src/1909.cpp b/src/1909.cpp new file mode 100644 index 0000000..dbdc394 --- /dev/null +++ b/src/1909.cpp @@ -0,0 +1,41 @@ +bool canBeIncreasing(vector& nums) { + int len = nums.size(); + if (len <= 2) + return true; + + int i = 0; + for (; i < len-1; ++i) + { + if (nums[i+1] <= nums[i]) + break; + } + if (i >= len-2) + return true; + int j = i; + if (i == 0 || (i > 0 && nums[i+1] > nums[i-1])) + { + i += 1; + for (; i < len-1; ++i) + { + if (nums[i+1] <= nums[i]) + break; + } + if (i == len-1) + return true; + } + + i = j; + if (i > 0 && nums[i] < nums[i+2]) + { + i += 2; + for (; i < len-1; ++i) + { + if (nums[i+1] <= nums[i]) + break; + } + if (i == len-1) + return true; + } + + return false; + } \ No newline at end of file diff --git a/src/1920.cpp b/src/1920.cpp new file mode 100644 index 0000000..047cc1b --- /dev/null +++ b/src/1920.cpp @@ -0,0 +1,10 @@ +vector buildArray(vector& nums) { + int len = nums.size(); + vector res(len, 0); + for (int i = 0; i < len; ++i) + { + res[i] = nums[nums[i]]; + } + + return res; + } \ No newline at end of file diff --git a/src/398.cpp b/src/398.cpp new file mode 100644 index 0000000..8f3c8d7 --- /dev/null +++ b/src/398.cpp @@ -0,0 +1,22 @@ +Solution(vector& nums) { + int len = nums.size(); + for (int i = 0; i < len; ++i) + { + elems[nums[i]].vals.push_back(i); + elems[nums[i]].len++; + } + } + + int pick(int target) { + int len = elems[target].len; + + return elems[target].vals[rand()%len]; + } + + struct Elem + { + vector vals; + int len; + Elem():vals({}), len(0){} + }; + map elems; \ No newline at end of file diff --git a/src/921.cpp b/src/921.cpp new file mode 100644 index 0000000..e2a74d8 --- /dev/null +++ b/src/921.cpp @@ -0,0 +1,30 @@ +int minAddToMakeValid(string s) { + int len = s.size(); + if (len <= 1) + return len; + int i = 0; + int left = 0, ct = 0; + while (i < len) + { + if (s[i] == '(') + { + ++left; + ++ct; + } + else + { + if (left > 0) + { + --left; + --ct; + } + else + { + ++ct; + } + } + ++i; + } + + return ct; + } \ No newline at end of file From 243fef6a5ee8a0c77636adfb2a9879d091ae24c6 Mon Sep 17 00:00:00 2001 From: Troy Date: Fri, 1 Oct 2021 19:53:55 +0800 Subject: [PATCH 66/97] 12 problems solved. --- src/1114.cpp | 34 ++++++++++++++++++++++++++++++++++ src/1418.cpp | 39 +++++++++++++++++++++++++++++++++++++++ src/1913.cpp | 6 ++++++ src/1929.cpp | 8 ++++++++ src/1935.cpp | 31 +++++++++++++++++++++++++++++++ src/1941.cpp | 22 ++++++++++++++++++++++ src/1967.cpp | 11 +++++++++++ src/1979.cpp | 31 +++++++++++++++++++++++++++++++ src/1991.cpp | 21 +++++++++++++++++++++ src/2000.cpp | 15 +++++++++++++++ src/2006.cpp | 14 ++++++++++++++ src/2011.cpp | 13 +++++++++++++ 12 files changed, 245 insertions(+) create mode 100644 src/1114.cpp create mode 100644 src/1418.cpp create mode 100644 src/1913.cpp create mode 100644 src/1929.cpp create mode 100644 src/1935.cpp create mode 100644 src/1941.cpp create mode 100644 src/1967.cpp create mode 100644 src/1979.cpp create mode 100644 src/1991.cpp create mode 100644 src/2000.cpp create mode 100644 src/2006.cpp create mode 100644 src/2011.cpp diff --git a/src/1114.cpp b/src/1114.cpp new file mode 100644 index 0000000..3c96dee --- /dev/null +++ b/src/1114.cpp @@ -0,0 +1,34 @@ +class Foo { +public: + Foo() { + flag1 = 0; + flag2 = 0; + } + + void first(function printFirst) { + + // printFirst() outputs "first". Do not change or remove this line. + printFirst(); + flag1 = 1; + } + + void second(function printSecond) { + + // printSecond() outputs "second". Do not change or remove this line. + while (flag1 == 0) + ; + printSecond(); + flag2 = 1; + } + + void third(function printThird) { + + // printThird() outputs "third". Do not change or remove this line. + while (flag2 == 0) + ; + printThird(); + } +private: + volatile int flag1; + volatile int flag2; +}; \ No newline at end of file diff --git a/src/1418.cpp b/src/1418.cpp new file mode 100644 index 0000000..8e496d1 --- /dev/null +++ b/src/1418.cpp @@ -0,0 +1,39 @@ +vector> displayTable(vector>& orders) { + int len = orders.size(); + map> mp; + set st; + + for (int i = 0; i < len; ++i) + { + mp[atoi(orders[i][1].c_str())][orders[i][2]]++; + st.insert(orders[i][2]); + } + + int reslen = mp.size()+1; + int foodnum = st.size(); + vector> res(reslen, vector(foodnum+1, "0")); + res[0][0] = "Table"; + + int i = 1; + for (auto iter = st.begin(); iter != st.end(); ++iter) + { + res[0][i++] = *iter; + } + + i = 1; + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + { + res[i][0] = to_string(iter->first); + int j = 1; + for (auto iterJ = st.begin(); iterJ != st.end(); ++iterJ) + { + if ((iter->second).find(*iterJ) == iter->second.end()) + res[i][j++] = "0"; + else + res[i][j++] = to_string((iter->second)[*iterJ]); + } + ++i; + } + + return res; + } \ No newline at end of file diff --git a/src/1913.cpp b/src/1913.cpp new file mode 100644 index 0000000..6b50b35 --- /dev/null +++ b/src/1913.cpp @@ -0,0 +1,6 @@ +int maxProductDifference(vector& nums) { + sort(nums.begin(), nums.end()); + int len = nums.size(); + + return nums[len-1]*nums[len-2] - nums[0]*nums[1]; + } \ No newline at end of file diff --git a/src/1929.cpp b/src/1929.cpp new file mode 100644 index 0000000..eb53997 --- /dev/null +++ b/src/1929.cpp @@ -0,0 +1,8 @@ +vector getConcatenation(vector& nums) { + int len = nums.size(); + vector res(2*len); + res.assign(nums.begin(), nums.end()); + res.insert(res.end(), nums.begin(), nums.end()); + + return res; + } \ No newline at end of file diff --git a/src/1935.cpp b/src/1935.cpp new file mode 100644 index 0000000..2103442 --- /dev/null +++ b/src/1935.cpp @@ -0,0 +1,31 @@ +int canBeTypedWords(string text, string brokenLetters) { + int flag[26] = {0}; + int len = brokenLetters.size(); + for (int i = 0; i < len; ++i) + { + flag[brokenLetters[i]-'a'] = 1; + } + + int textlen = text.size(); + int res = 0; + int i = 0; + bool isbroke = false; + while (i < textlen) + { + if (text[i] == ' ') + { + if (isbroke == false) + ++res; + isbroke = false; + } + else if (!isbroke && flag[text[i]-'a'] == 1) + { + isbroke = true; + } + ++i; + } + if (isbroke == false) + ++res; + + return res; + } \ No newline at end of file diff --git a/src/1941.cpp b/src/1941.cpp new file mode 100644 index 0000000..580b859 --- /dev/null +++ b/src/1941.cpp @@ -0,0 +1,22 @@ +bool areOccurrencesEqual(string s) { + int counts[26] = {0}; + int len = s.size(); + for (int i = 0; i < len; ++i) + { + ++counts[s[i]-'a']; + } + + int num = 0; + for (int i = 0; i < 26; ++i) + { + if (counts[i] > 0) + { + if (num == 0) + num = counts[i]; + else if (counts[i] != num) + return false; + } + } + + return true; + } \ No newline at end of file diff --git a/src/1967.cpp b/src/1967.cpp new file mode 100644 index 0000000..26f182c --- /dev/null +++ b/src/1967.cpp @@ -0,0 +1,11 @@ +int numOfStrings(vector& patterns, string word) { + int len = patterns.size(); + int res = 0; + for (int i = 0; i < len; ++i) + { + if (word.find(patterns[i]) != string::npos) + ++res; + } + + return res; + } \ No newline at end of file diff --git a/src/1979.cpp b/src/1979.cpp new file mode 100644 index 0000000..2a647a0 --- /dev/null +++ b/src/1979.cpp @@ -0,0 +1,31 @@ +int findGCD(vector& nums) { + int len = nums.size(); + int minval = nums[0], maxval = nums[0]; + for (int i = 1; i < len; ++i) + { + if (nums[i] < minval) + minval = nums[i]; + if (nums[i] > maxval) + maxval = nums[i]; + } + + return gcd(minval, maxval); + } + + int gcd(int a, int b) + { + if (a > b) + { + int tmp = a; + a = b; + b = tmp; + } + + if (b%a == 0) + return a; + else + { + b %= a; + return gcd(b, a); + } + } \ No newline at end of file diff --git a/src/1991.cpp b/src/1991.cpp new file mode 100644 index 0000000..41ce089 --- /dev/null +++ b/src/1991.cpp @@ -0,0 +1,21 @@ +int findMiddleIndex(vector& nums) { + int len = nums.size(); + vector subsum(len+1, 0); + int sum = 0; + subsum[0] = 0; + for (int i = 1; i < len+1; ++i) + { + sum += nums[i-1]; + subsum[i] = sum; + } + + int tmp = subsum[len]; + for (int i = 0; i < len; ++i) + { + if (subsum[i] == tmp-nums[i]) + return i; + tmp -= nums[i]; + } + + return -1; + } \ No newline at end of file diff --git a/src/2000.cpp b/src/2000.cpp new file mode 100644 index 0000000..f691c7a --- /dev/null +++ b/src/2000.cpp @@ -0,0 +1,15 @@ +string reversePrefix(string word, char ch) { + int index = word.find(ch); + if (index != string::npos) + { + int i = 0, j = index; + while (i < j) + { + swap(word[i], word[j]); + ++i; + --j; + } + } + + return word; + } \ No newline at end of file diff --git a/src/2006.cpp b/src/2006.cpp new file mode 100644 index 0000000..186f9ba --- /dev/null +++ b/src/2006.cpp @@ -0,0 +1,14 @@ +int countKDifference(vector& nums, int k) { + int res = 0; + int len = nums.size(); + for (int i = 0; i < len-1; ++i) + { + for (int j = i+1; j < len; ++j) + { + if (abs(nums[i]-nums[j]) == k) + ++res; + } + } + + return res; + } \ No newline at end of file diff --git a/src/2011.cpp b/src/2011.cpp new file mode 100644 index 0000000..ee6ed88 --- /dev/null +++ b/src/2011.cpp @@ -0,0 +1,13 @@ +int finalValueAfterOperations(vector& operations) { + int len = operations.size(); + int result = 0; + for (int i = 0; i < len; ++i) + { + if (operations[i].find('+') != string::npos) + ++result; + else + --result; + } + + return result; + } \ No newline at end of file From 541756281092fd67ac231539efbc0abb8c88c6a0 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 10 Oct 2021 20:51:33 +0800 Subject: [PATCH 67/97] 6 problems solved. --- src/116.cpp | 26 ++++++++++++++++++ src/117.cpp | 56 +++++++++++++++++++++++++++++++++++++++ src/1893.cpp | 30 +++++++++++++++++++++ src/227.cpp | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/25.cpp | 53 +++++++++++++++++++++++++++++++++++++ src/57.cpp | 64 +++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 303 insertions(+) create mode 100644 src/116.cpp create mode 100644 src/117.cpp create mode 100644 src/1893.cpp create mode 100644 src/227.cpp create mode 100644 src/25.cpp create mode 100644 src/57.cpp diff --git a/src/116.cpp b/src/116.cpp new file mode 100644 index 0000000..b9c91ae --- /dev/null +++ b/src/116.cpp @@ -0,0 +1,26 @@ +Node* connect(Node* root) { + if (root == nullptr || (root->left == nullptr && root->right == nullptr)) + return root; + + doconnect(root); + + return root; + } + + void doconnect(Node* node) + { + if (node->left != nullptr) + { + Node* tmp = node; + Node* nd = node->left; + while (tmp->next != nullptr) + { + nd->next = tmp->right; + nd = tmp->next->left; + tmp->right->next = nd; + tmp = tmp->next; + } + nd->next = tmp->right; + doconnect(node->left); + } + } \ No newline at end of file diff --git a/src/117.cpp b/src/117.cpp new file mode 100644 index 0000000..2e88289 --- /dev/null +++ b/src/117.cpp @@ -0,0 +1,56 @@ +Node* connect(Node* root) { + if (root == nullptr || (root->left == nullptr && root->right == nullptr)) + return root; + + doconnect(root); + + return root; + } + + void doconnect(Node* node) + { + Node* tmp = node; + Node* first = nullptr; + while (tmp != nullptr) + { + if (tmp->left != nullptr) + { + first = tmp->left; + break; + } + if (tmp->right != nullptr) + { + first = tmp->right; + break; + } + tmp = tmp->next; + } + + if (first != nullptr) + { + Node* nd = first; + if (tmp->left == first && tmp->right != nullptr) + { + nd->next = tmp->right; + nd = tmp->right; + } + + Node* cur = tmp->next; + while (cur != nullptr) + { + if (cur->left != nullptr) + { + nd->next = cur->left; + nd = cur->left; + } + if (cur->right != nullptr) + { + nd->next = cur->right; + nd = cur->right; + } + cur = cur->next; + } + + doconnect(first); + } + } \ No newline at end of file diff --git a/src/1893.cpp b/src/1893.cpp new file mode 100644 index 0000000..d27d97a --- /dev/null +++ b/src/1893.cpp @@ -0,0 +1,30 @@ +bool isCovered(vector>& ranges, int left, int right) { + int len = ranges.size(); + if (len == 0) + return false; + auto cmp = [](const vector& a, const vector& b) { + return (a[0] < b[0] || (a[0]==b[0] && a[1] < b[1])); + }; + sort(ranges.begin(), ranges.end(), cmp); + + int lh = left, rh = right; + for (int i = 0; i < len; ++i) + { + if (lh >= ranges[i][0] && lh <= ranges[i][1]) + { + if (rh <= ranges[i][1]) + return true; + else + lh = ranges[i][1]+1; + } + if (rh >= ranges[i][0] && rh <= ranges[i][1]) + { + if (lh >= ranges[i][0]) + return true; + else + rh = ranges[i][0]-1; + } + } + + return false; + } \ No newline at end of file diff --git a/src/227.cpp b/src/227.cpp new file mode 100644 index 0000000..eee90f8 --- /dev/null +++ b/src/227.cpp @@ -0,0 +1,74 @@ +int calculate(string s) { + int len = s.size(); + int i = 0; + deque dq; + + int n = 0; + while (i < len) + { + if (s[i] != ' ') + { + dq.push_back(s[i]); + ++n; + } + ++i; + } + + i = 0; + int v = 0; + deque number; + deque op; + bool flag = false; + while (i < n) + { + if (dq[i] >= '0' && dq[i] <= '9') + { + v = v*10 + (dq[i]-'0'); + ++i; + flag = true; + } + else + { + if (dq[i] == '+' || dq[i] == '-') + { + number.push_back(v); + op.push_back(dq[i]); + v = 0; + ++i; + flag = false; + } + else + { + char c = dq[i]; + ++i; + int v2 = 0; + while (i < n && dq[i] >= '0' && dq[i] <= '9') + { + v2 = v2*10 + (dq[i]-'0'); + ++i; + } + if (c == '*') + v *= v2; + else + v /= v2; + flag = true; + } + } + } + if (flag) + number.push_back(v); + + int k = op.size(); + int j = 0; + int sum = number[0]; + while (j < k) + { + if (op[j] == '+') + sum += number[j+1]; + else + sum -= number[j+1]; + ++j; + } + + return sum; + } \ No newline at end of file diff --git a/src/25.cpp b/src/25.cpp new file mode 100644 index 0000000..4e17b25 --- /dev/null +++ b/src/25.cpp @@ -0,0 +1,53 @@ +ListNode* reverseKGroup(ListNode* head, int k) { + if (head == nullptr || head->next == nullptr || k == 1) + return head; + + int sz = 0; + ListNode* tmp = head; + while (tmp != nullptr) + { + tmp = tmp->next; + ++sz; + } + + int q = sz/k; + int r = sz - q*k; + int i = 1, n = 0; + ListNode* h = nullptr; + ListNode* tail = nullptr; + ListNode* ps = head, *pds = head, *pde = head; + ps = ps->next; + while (i < k) + { + ListNode* pp = ps->next; + ps->next = pds; + pds = ps; + ps = pp; + ++i; + } + h = pds; + ++n; + tail = pde; + + while (n < q) + { + pds = ps; + pde = ps; + i = 1; + ps = ps->next; + while (i < k) + { + ListNode* pp = ps->next; + ps->next = pds; + pds = ps; + ps = pp; + ++i; + } + tail->next = pds; + tail = pde; + ++n; + } + + tail->next = ps; + return h; + } \ No newline at end of file diff --git a/src/57.cpp b/src/57.cpp new file mode 100644 index 0000000..dbb4ce2 --- /dev/null +++ b/src/57.cpp @@ -0,0 +1,64 @@ +vector> insert(vector>& intervals, vector& newInterval) { + vector> res; + int len = intervals.size(); + if (len == 0) + { + res.push_back(newInterval); + return res; + } + + int pos[2] = {-1,-1}; + for (int i = 0; i < 2; ++i) + { + int j = 0; + for (; j < len; ++j) + { + if (newInterval[i] <= intervals[j][1]) + { + pos[i] = j; + break; + } + } + if (pos[i] == -1) + pos[i] = len; + } + + if (pos[0] == pos[1]) + { + if (pos[0] == len || newInterval[1] < intervals[pos[0]][0]) + { + res.reserve(len+1); + for (int i = 0; i < pos[0]; ++i) + res.push_back(intervals[i]); + res.push_back(newInterval); + for (int i = pos[0]; i < len; ++i) + res.push_back(intervals[i]); + return res; + } + else + { + intervals[pos[0]][0] = newInterval[0] < intervals[pos[0]][0] ? newInterval[0] : intervals[pos[0]][0]; + return intervals; + } + } + else + { + for (int i = 0; i < pos[0]; ++i) + res.push_back(intervals[i]); + int lh = newInterval[0] < intervals[pos[0]][0] ? newInterval[0] : intervals[pos[0]][0]; + if (pos[1] == len || newInterval[1] < intervals[pos[1]][0]) + { + res.push_back({lh, newInterval[1]}); + for (int i = pos[1]; i < len; ++i) + res.push_back(intervals[i]); + } + else + { + res.push_back({lh, intervals[pos[1]][1]}); + for (int i = pos[1]+1; i < len; ++i) + res.push_back(intervals[i]); + } + + return res; + } + } \ No newline at end of file From b625037e90353b1c61e6fc260436401c6533c8fb Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 30 Oct 2021 20:59:56 +0800 Subject: [PATCH 68/97] 7 problems solved. --- src/1984.cpp | 16 ++++++++++++++++ src/1995.cpp | 19 +++++++++++++++++++ src/2016.cpp | 18 ++++++++++++++++++ src/2022.cpp | 16 ++++++++++++++++ src/2032.cpp | 34 ++++++++++++++++++++++++++++++++++ src/2042.cpp | 32 ++++++++++++++++++++++++++++++++ src/2047.cpp | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 184 insertions(+) create mode 100644 src/1984.cpp create mode 100644 src/1995.cpp create mode 100644 src/2016.cpp create mode 100644 src/2022.cpp create mode 100644 src/2032.cpp create mode 100644 src/2042.cpp create mode 100644 src/2047.cpp diff --git a/src/1984.cpp b/src/1984.cpp new file mode 100644 index 0000000..af6b64f --- /dev/null +++ b/src/1984.cpp @@ -0,0 +1,16 @@ +int minimumDifference(vector& nums, int k) { + if (k == 1) + return 0; + sort(nums.begin(), nums.end()); + int len = nums.size(); + int mindiff = 1e5; + + for (int i = len-1; i >= k-1; --i) + { + int diff = nums[i]-nums[i-k+1]; + if (diff < mindiff) + mindiff = diff; + } + + return mindiff; + } \ No newline at end of file diff --git a/src/1995.cpp b/src/1995.cpp new file mode 100644 index 0000000..6441f2e --- /dev/null +++ b/src/1995.cpp @@ -0,0 +1,19 @@ +int countQuadruplets(vector& nums) { + int len = nums.size(); + int ct = 0; + + for (int i = 0; i < len-3; ++i) + { + for (int j = i+1; j < len-2; ++j) + { + for (int m = j+1; m < len-1; ++m) + { + for (int n = m+1; n < len; ++n) + if (nums[i]+nums[j]+nums[m] == nums[n]) + ++ct; + } + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2016.cpp b/src/2016.cpp new file mode 100644 index 0000000..acc1f9f --- /dev/null +++ b/src/2016.cpp @@ -0,0 +1,18 @@ + int maximumDifference(vector& nums) { + int len = nums.size(); + int maxdiff = 0; + for (int i = 0; i < len-1; ++i) + { + for (int j = i+1; j < len; ++j) + { + int diff = nums[j]-nums[i]; + if (diff > maxdiff) + maxdiff = diff; + } + } + + if (maxdiff == 0) + maxdiff = -1; + + return maxdiff; + } \ No newline at end of file diff --git a/src/2022.cpp b/src/2022.cpp new file mode 100644 index 0000000..c5b2deb --- /dev/null +++ b/src/2022.cpp @@ -0,0 +1,16 @@ +vector> construct2DArray(vector& original, int m, int n) { + int len = original.size(); + if (m*n != len) + return {}; + + vector> res(m, vector(n, 0)); + for (int i = 0; i < m; ++i) + { + for (int j = 0; j < n; ++j) + { + res[i][j] = original[i*n + j]; + } + } + + return res; + } \ No newline at end of file diff --git a/src/2032.cpp b/src/2032.cpp new file mode 100644 index 0000000..87bb930 --- /dev/null +++ b/src/2032.cpp @@ -0,0 +1,34 @@ +vector twoOutOfThree(vector& nums1, vector& nums2, vector& nums3) { + int arr[101][3]; + memset(arr, 0, 303*sizeof(int)); + int len1 = nums1.size(); + int len2 = nums2.size(); + int len3 = nums3.size(); + for (int i = 0; i < 100; ++i) + { + if (i < len1) + { + if (arr[nums1[i]][0] == 0) + ++arr[nums1[i]][0]; + } + if (i < len2) + { + if (arr[nums2[i]][1] == 0) + ++arr[nums2[i]][1]; + } + if (i < len3) + { + if (arr[nums3[i]][2] == 0) + ++arr[nums3[i]][2]; + } + } + + vector res; + for (int i = 0; i < 101; ++i) + { + if (arr[i][0] + arr[i][1] + arr[i][2] >= 2) + res.push_back(i); + } + + return res; + } \ No newline at end of file diff --git a/src/2042.cpp b/src/2042.cpp new file mode 100644 index 0000000..327d919 --- /dev/null +++ b/src/2042.cpp @@ -0,0 +1,32 @@ + bool areNumbersAscending(string s) { + int len = s.size(); + int index = 0; + int pos = s.find(' ', index); + int lastnum = 0; + while (pos != string::npos) + { + if (isdigit(s[index])) + { + int sum = 0; + for (int i = index; i < pos; ++i) + sum = 10*sum + (s[i]-'0'); + if (sum <= lastnum) + return false; + else + lastnum = sum; + } + index = pos+1; + pos = s.find(' ', index); + } + + if (isdigit(s[index])) + { + int sum = 0; + for (int i = index; i < len; ++i) + sum = 10*sum + (s[i]-'0'); + if (sum <= lastnum) + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/2047.cpp b/src/2047.cpp new file mode 100644 index 0000000..277d589 --- /dev/null +++ b/src/2047.cpp @@ -0,0 +1,49 @@ +int countValidWords(string sentence) { + auto first = sentence.begin(); + auto last = sentence.end(); + auto p = first, q = first; + auto func = [](char c){ + return c == ' '; + }; + + int ct = 0; + p = find_if_not(p, last, func); + q = find_if(p, last, func); + while (p != last && q != last) + { + if (isValid(sentence, p, q)) + ++ct; + p = find_if_not(q, last, func); + if (p != last) + q = find_if(p, last, func); + } + + if (p != last && isValid(sentence, p, q)) + ++ct; + + return ct; + } + + bool isValid(const string& sentence, string::iterator& p, string::iterator& q) + { + int hyphennum = 0; + for (auto iter = p; iter != q; ++iter) + { + if (isdigit(*iter)) + return false; + if (*iter == '-') + { + ++hyphennum; + if (hyphennum > 1) + return false; + if (iter == p || iter == q-1) + return false; + if (!isalpha(*(iter-1)) || !(isalpha(*(iter+1)))) + return false; + } + if ((*iter == ',' || *iter == '.' || *iter == '!') && (iter != q-1)) + return false; + } + + return true; + } \ No newline at end of file From a262417b0119ae78f3fc484a9fc20f3850c84b02 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 31 Oct 2021 18:45:33 +0800 Subject: [PATCH 69/97] 8 problems solved. --- src/1897.cpp | 20 ++++++++++++++++++++ src/1945.cpp | 29 +++++++++++++++++++++++++++++ src/1952.cpp | 12 ++++++++++++ src/1957.cpp | 30 ++++++++++++++++++++++++++++++ src/1961.cpp | 25 +++++++++++++++++++++++++ src/2027.cpp | 17 +++++++++++++++++ src/2053.cpp | 20 ++++++++++++++++++++ src/2057.cpp | 10 ++++++++++ 8 files changed, 163 insertions(+) create mode 100644 src/1897.cpp create mode 100644 src/1945.cpp create mode 100644 src/1952.cpp create mode 100644 src/1957.cpp create mode 100644 src/1961.cpp create mode 100644 src/2027.cpp create mode 100644 src/2053.cpp create mode 100644 src/2057.cpp diff --git a/src/1897.cpp b/src/1897.cpp new file mode 100644 index 0000000..0913f03 --- /dev/null +++ b/src/1897.cpp @@ -0,0 +1,20 @@ +bool makeEqual(vector& words) { + int len = words.size(); + int num[26] = {0}; + for (int i = 0; i < len; ++i) + { + int sz = words[i].size(); + for (int j = 0; j < sz; ++j) + { + ++num[words[i][j]-'a']; + } + } + + for (int i = 0; i < 26; ++i) + { + if (num[i]%len != 0) + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/1945.cpp b/src/1945.cpp new file mode 100644 index 0000000..7930fc6 --- /dev/null +++ b/src/1945.cpp @@ -0,0 +1,29 @@ +int getLucky(string s, int k) { + const int val[26] = {1,2,3,4,5,6,7,8,9, + 1,2,3,4,5,6,7,8,9,10, + 2,3,4,5,6,7,8}; + int len = s.size(); + int sum = 0; + for (int i = 0; i < len; ++i) + { + sum += val[s[i]-'a']; + } + if (sum < 10) + return sum; + + while (--k) + { + int tmp = 0; + while (sum > 0) + { + tmp += sum%10; + sum /= 10; + } + + sum = tmp; + if (sum < 10) + break; + } + + return sum; + } \ No newline at end of file diff --git a/src/1952.cpp b/src/1952.cpp new file mode 100644 index 0000000..e47dbd8 --- /dev/null +++ b/src/1952.cpp @@ -0,0 +1,12 @@ +bool isThree(int n) { + int num[25] = {2,3,5,7,11,13,17,19,23,29,31, + 37,41,43,47,53,59,61,67,71,73, + 79,83,89,97}; + for (int i = 0; i < 25; ++i) + { + if (num[i]*num[i] == n) + return true; + } + + return false; + } \ No newline at end of file diff --git a/src/1957.cpp b/src/1957.cpp new file mode 100644 index 0000000..4b6cd9f --- /dev/null +++ b/src/1957.cpp @@ -0,0 +1,30 @@ +string makeFancyString(string s) { + int len = s.size(); + if (len < 3) + return s; + + stringstream ss; + int ct = 1; + int lastchar = s[0]; + int i = 1; + ss << s[0]; + while (i < len) + { + if (s[i] == lastchar) + { + ++ct; + if (ct < 3) + ss << s[i]; + ++i; + } + else + { + ct = 1; + lastchar = s[i]; + ss << s[i]; + ++i; + } + } + + return ss.str(); + } \ No newline at end of file diff --git a/src/1961.cpp b/src/1961.cpp new file mode 100644 index 0000000..3afc5cc --- /dev/null +++ b/src/1961.cpp @@ -0,0 +1,25 @@ +bool isPrefixString(string s, vector& words) { + int len = words.size(); + int sz = s.size(); + int k = 0; + for (int i = 0; i < len; ++i) + { + int len2 = words[i].size(); + if (len2 > sz-k) + return false; + for (int j = 0; j < len2; ++j) + { + if (words[i][j] != s[k]) + return false; + else + ++k; + } + if (k == sz) + break; + } + + if (k < sz) + return false; + + return true; + } \ No newline at end of file diff --git a/src/2027.cpp b/src/2027.cpp new file mode 100644 index 0000000..f5d3280 --- /dev/null +++ b/src/2027.cpp @@ -0,0 +1,17 @@ +int minimumMoves(string s) { + int len = s.size(); + int i = 0; + int ct = 0; + while (i < len) + { + if (s[i] == 'O') + ++i; + else + { + ++ct; + i += 3; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2053.cpp b/src/2053.cpp new file mode 100644 index 0000000..93e6cf0 --- /dev/null +++ b/src/2053.cpp @@ -0,0 +1,20 @@ +string kthDistinct(vector& arr, int k) { + map mp; + int len = arr.size(); + for (int i = 0; i < len; ++i) + mp[arr[i]]++; + + int ct = 1; + for (int i = 0; i < len; ++i) + { + if (mp[arr[i]] == 1) + { + if (ct == k) + return arr[i]; + else + ++ct; + } + } + + return ""; + } \ No newline at end of file diff --git a/src/2057.cpp b/src/2057.cpp new file mode 100644 index 0000000..84e1dc0 --- /dev/null +++ b/src/2057.cpp @@ -0,0 +1,10 @@ +int smallestEqual(vector& nums) { + int len = nums.size(); + for (int i = 0; i < len; ++i) + { + if (i%10 == nums[i]) + return i; + } + + return -1; + } \ No newline at end of file From 7f089b74cb4ae4b21f00f822a06724858b134cab Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 21 Nov 2021 11:46:24 +0800 Subject: [PATCH 70/97] 5 problems solved. --- src/1925.cpp | 26 ++++++++++++++++ src/2068.cpp | 19 ++++++++++++ src/2074.cpp | 87 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/228.cpp | 29 ++++++++++++++++++ src/338.cpp | 26 ++++++++++++++++ 5 files changed, 187 insertions(+) create mode 100644 src/1925.cpp create mode 100644 src/2068.cpp create mode 100644 src/2074.cpp create mode 100644 src/228.cpp create mode 100644 src/338.cpp diff --git a/src/1925.cpp b/src/1925.cpp new file mode 100644 index 0000000..4a14b7c --- /dev/null +++ b/src/1925.cpp @@ -0,0 +1,26 @@ +int countTriples(int n) { + int ct = 0; + vector vec(n, 0); + for (int i = 1; i <= n; ++i) + vec[i-1] = i*i; + + int lim = int(n/sqrt(2))+1; + for (int i = 0; i < lim; ++i) + { + for (int j = i; j < n; ++j) + { + for (int k = j+1; k < n; ++k) + { + if (vec[k] == vec[i]+vec[j]) + { + if (i != j) + ct += 2; + else + ++ct; + } + } + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2068.cpp b/src/2068.cpp new file mode 100644 index 0000000..f939b94 --- /dev/null +++ b/src/2068.cpp @@ -0,0 +1,19 @@ +bool checkAlmostEquivalent(string word1, string word2) { + int len = word1.size(); + vector vec1(26, 0); + vector vec2(26, 0); + + for (int i = 0; i < len; ++i) + { + vec1[word1[i]-'a']++; + vec2[word2[i]-'a']++; + } + + for (int i = 0; i < 26; ++i) + { + if (abs(vec1[i]-vec2[i]) > 3) + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/2074.cpp b/src/2074.cpp new file mode 100644 index 0000000..46605da --- /dev/null +++ b/src/2074.cpp @@ -0,0 +1,87 @@ +ListNode* reverseEvenLengthGroups(ListNode* head) { + if (head == nullptr || head->next == nullptr || head->next->next == nullptr) + return head; + + int ct = 0; + ListNode* p = head; + while (p != nullptr) + { + ++ct; + p = p->next; + } + + int lim = 2*ct; + int n = sqrt(lim); + int tmp = n*(n+1); + int r = 0; + if (tmp == lim) + ; + else if (tmp < lim) + r = ct-tmp/2; + else + { + r = ct-n*(n-1)/2; + --n; + } + + ListNode* pre = head; + ListNode* post = pre->next; + ListNode* cur = post->next; + int i = 2; + bool flag = true; + while (i <= n) + { + if (flag) + { + p = post; + for (int j = 1; j < i; ++j) + { + pre->next = cur; + ListNode* tmp = cur->next; + cur->next = p; + p = cur; + cur = tmp; + } + post->next = cur; + } + else + { + for (int j = 0; j < i; ++j) + { + pre = cur; + cur = cur->next; + } + post = cur; + if (cur != nullptr) + cur = cur->next; + } + flag = !flag; + ++i; + } + + if (r > 0) + { + if (!flag) + { + pre = post; + post = post->next; + if (cur != nullptr) + cur = cur->next; + } + if (r%2 == 0) + { + p = post; + for (int j = 1; j < r; ++j) + { + pre->next = cur; + ListNode* tmp = cur->next; + cur->next = p; + p = cur; + cur = tmp; + } + post->next = cur; + } + } + + return head; + } \ No newline at end of file diff --git a/src/228.cpp b/src/228.cpp new file mode 100644 index 0000000..616ffbc --- /dev/null +++ b/src/228.cpp @@ -0,0 +1,29 @@ +vector summaryRanges(vector& nums) { + int len = nums.size(); + if (len == 0) + return {}; + vector res; + + int i = 0, j = 0; + while (j < len-1) + { + if (nums[j] == nums[j+1]-1) + ++j; + else + { + if (i == j) + res.push_back(to_string(nums[i])); + else + res.push_back(to_string(nums[i]) + "->" + to_string(nums[j])); + i = j+1; + j = i; + } + } + + if (i == j) + res.push_back(to_string(nums[i])); + else + res.push_back(to_string(nums[i]) + "->" + to_string(nums[j])); + + return res; + } \ No newline at end of file diff --git a/src/338.cpp b/src/338.cpp new file mode 100644 index 0000000..c9caf35 --- /dev/null +++ b/src/338.cpp @@ -0,0 +1,26 @@ +vector countBits(int num) { + int binarr[32] = {0}; + int ct = 0; + vector res(num+1, 0); + + for (int i = 0; i < num; ++i) + { + for (int j = 0; j < 32; ++j) + { + if (binarr[j] == 0) + { + ++ct; + res[i+1] = ct; + binarr[j] = 1; + break; + } + else + { + binarr[j] = 0; + --ct; + } + } + } + + return res; + } \ No newline at end of file From c02693004390ad4aa57d1fb799e94725fb55f783 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 18 Dec 2021 14:07:05 +0800 Subject: [PATCH 71/97] 6 problems solved. --- src/1886.cpp | 66 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/2078.cpp | 16 +++++++++++++ src/2085.cpp | 21 +++++++++++++++++ src/2089.cpp | 17 ++++++++++++++ src/2099.cpp | 32 +++++++++++++++++++++++++ src/2103.cpp | 26 +++++++++++++++++++++ 6 files changed, 178 insertions(+) create mode 100644 src/1886.cpp create mode 100644 src/2078.cpp create mode 100644 src/2085.cpp create mode 100644 src/2089.cpp create mode 100644 src/2099.cpp create mode 100644 src/2103.cpp diff --git a/src/1886.cpp b/src/1886.cpp new file mode 100644 index 0000000..dc47415 --- /dev/null +++ b/src/1886.cpp @@ -0,0 +1,66 @@ +bool findRotation(vector>& mat, vector>& target) { + int row = mat.size(); + bool flag = true; + + for (int r = 0; r < row; ++r) + { + for (int c = 0; c < row; ++c) + { + if (mat[r][c] != target[r][c]) + { + flag = false; + break; + } + } + } + + if (!flag) + { + flag = true; + for (int r = 0; r < row; ++r) + { + for (int c = 0; c < row; ++c) + { + if (mat[r][c] != target[row-1-r][row-1-c]) + { + flag = false; + break; + } + } + } + } + + if (!flag) + { + flag = true; + for (int r = 0; r < row; ++r) + { + for (int c = 0; c < row; ++c) + { + if (mat[r][c] != target[row-1-c][r]) + { + flag = false; + break; + } + } + } + } + + if (!flag) + { + flag = true; + for (int r = 0; r < row; ++r) + { + for (int c = 0; c < row; ++c) + { + if (mat[r][c] != target[c][row-1-r]) + { + flag = false; + break; + } + } + } + } + + return flag; + } \ No newline at end of file diff --git a/src/2078.cpp b/src/2078.cpp new file mode 100644 index 0000000..7c29390 --- /dev/null +++ b/src/2078.cpp @@ -0,0 +1,16 @@ +int maxDistance(vector& colors) { + int maxdist = 0; + int len = colors.size(); + for (int i = 0; i < len-1; ++i) + { + for (int j = i+1; j < len; ++j) + { + if (colors[i] != colors[j]) + { + maxdist = j-i > maxdist ? j-i : maxdist; + } + } + } + + return maxdist; + } \ No newline at end of file diff --git a/src/2085.cpp b/src/2085.cpp new file mode 100644 index 0000000..7676671 --- /dev/null +++ b/src/2085.cpp @@ -0,0 +1,21 @@ +int countWords(vector& words1, vector& words2) { + int len1 = words1.size(); + int len2 = words2.size(); + + map mp1, mp2; + for (int i = 0; i < len1; ++i) + mp1[words1[i]]++; + for (int i = 0; i < len2; ++i) + mp2[words2[i]]++; + + int ct = 0; + for (auto iter = mp1.begin(); iter != mp1.end(); ++iter) + { + if (iter->second == 1 && mp2[iter->first] == 1) + { + ++ct; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2089.cpp b/src/2089.cpp new file mode 100644 index 0000000..7552bad --- /dev/null +++ b/src/2089.cpp @@ -0,0 +1,17 @@ +vector targetIndices(vector& nums, int target) { + int len = nums.size(); + int arr[101] = {0}; + for (int i = 0; i < len; ++i) + arr[nums[i]]++; + + if (arr[target] == 0) + return {}; + + vector res(arr[target], 0); + int ct = 0; + ct = accumulate(arr, arr+target, ct); + for (int i = 0; i < arr[target]; ++i) + res[i] = ct+i; + + return res; + } \ No newline at end of file diff --git a/src/2099.cpp b/src/2099.cpp new file mode 100644 index 0000000..0b74b98 --- /dev/null +++ b/src/2099.cpp @@ -0,0 +1,32 @@ +vector maxSubsequence(vector& nums, int k) { + struct Elem + { + int val; + int pos; + Elem(int v = 0, int p = 0):val(v),pos(p){} + }; + + int len = nums.size(); + vector vec(len, Elem()); + for (int i = 0; i < len; ++i) + { + vec[i].val = nums[i]; + vec[i].pos = i; + } + + auto cmp = [](const Elem& a, const Elem& b) { + return (a.val < b.val) || (a.val == b.val && a.pos < b.pos); + }; + auto cmp2 = [](const Elem& a, const Elem& b) { + return a.pos < b.pos; + }; + + sort(vec.begin(), vec.end(), cmp); + sort(vec.begin()+len-k, vec.end(), cmp2); + + vector res(k, 0); + for (int i = 0; i < k; ++i) + res[i] = vec[i+len-k].val; + + return res; + } \ No newline at end of file diff --git a/src/2103.cpp b/src/2103.cpp new file mode 100644 index 0000000..a056368 --- /dev/null +++ b/src/2103.cpp @@ -0,0 +1,26 @@ +int countPoints(string rings) { + vector> flag{10, {0,0,0}}; + int len = rings.size(); + + int i = 0; + while (i < len) + { + int pos = rings[i+1]-'0'; + if (rings[i] == 'R') + flag[pos][0] = 1; + else if (rings[i] == 'G') + flag[pos][1] = 1; + else + flag[pos][2] = 1; + i += 2; + } + + int ct = 0; + for (int i = 0; i < 10; ++i) + { + if (flag[i][0] == 1 && flag[i][1] == 1 && flag[i][2] == 1) + ++ct; + } + + return ct; + } \ No newline at end of file From 55a13cb94d755c3725e27005b27153792c4dde24 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 1 Jan 2022 17:01:41 +0800 Subject: [PATCH 72/97] 5 problems solved. --- src/1807.cpp | 36 ++++++++++++++++++++++++++++++++++++ src/2108.cpp | 20 ++++++++++++++++++++ src/2114.cpp | 12 ++++++++++++ src/2119.cpp | 3 +++ src/2120.cpp | 40 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 111 insertions(+) create mode 100644 src/1807.cpp create mode 100644 src/2108.cpp create mode 100644 src/2114.cpp create mode 100644 src/2119.cpp create mode 100644 src/2120.cpp diff --git a/src/1807.cpp b/src/1807.cpp new file mode 100644 index 0000000..8aa9779 --- /dev/null +++ b/src/1807.cpp @@ -0,0 +1,36 @@ +string evaluate(string s, vector>& knowledge) { + int len = knowledge.size(); + map dict; + for (int i = 0; i < len; ++i) + dict.insert(make_pair(knowledge[i][0], knowledge[i][1])); + + stringstream ss; + int sz = s.size(); + int i = 0; + while (i < sz) + { + if (s[i] != '(') + { + ss << s[i]; + ++i; + } + else + { + string key; + key.reserve(10); + int j = i+1; + while (j < sz && s[j] != ')') + { + key.push_back(s[j]); + ++j; + } + if (dict.find(key) != dict.end()) + ss << dict[key]; + else + ss << '?'; + i = j+1; + } + } + + return ss.str(); + } \ No newline at end of file diff --git a/src/2108.cpp b/src/2108.cpp new file mode 100644 index 0000000..ec22c26 --- /dev/null +++ b/src/2108.cpp @@ -0,0 +1,20 @@ +string firstPalindrome(vector& words) { + int len = words.size(); + for (int i = 0; i < len; ++i) + { + bool flag = true; + int sz = words[i].size(); + for (int j = 0; j < sz/2; ++j) + { + if (words[i][j] != words[i][sz-1-j]) + { + flag = false; + break; + } + } + if (flag) + return words[i]; + } + + return ""; + } \ No newline at end of file diff --git a/src/2114.cpp b/src/2114.cpp new file mode 100644 index 0000000..2792585 --- /dev/null +++ b/src/2114.cpp @@ -0,0 +1,12 @@ +int mostWordsFound(vector& sentences) { + int len = sentences.size(); + int maxn = 0; + for (int i = 0; i < len; ++i) + { + int n = count(sentences[i].begin(), sentences[i].end(), ' '); + if (n > maxn) + maxn = n; + } + + return maxn+1; + } \ No newline at end of file diff --git a/src/2119.cpp b/src/2119.cpp new file mode 100644 index 0000000..f75bf6c --- /dev/null +++ b/src/2119.cpp @@ -0,0 +1,3 @@ +bool isSameAfterReversals(int num) { + return num >= 10 ? num%10 != 0 : true; + } \ No newline at end of file diff --git a/src/2120.cpp b/src/2120.cpp new file mode 100644 index 0000000..2a5f81f --- /dev/null +++ b/src/2120.cpp @@ -0,0 +1,40 @@ +vector executeInstructions(int n, vector& startPos, string s) { + int len = s.size(); + vector res(len, 0); + for (int i = 0; i < len; ++i) + { + int r = startPos[0], c = startPos[1]; + int j = i; + for (; j < len; ++j) + { + if (s[j] == 'L') + { + if (c == 0) + break; + --c; + } + else if (s[j] == 'R') + { + if (c == n-1) + break; + ++c; + } + else if (s[j] == 'U') + { + if (r == 0) + break; + --r; + } + else + { + if (r == n-1) + break; + ++r; + } + } + + res[i] = j-i; + } + + return res; + } \ No newline at end of file From b4d2fdc1eced068ac32806b393b997171f209bb4 Mon Sep 17 00:00:00 2001 From: Troy Date: Tue, 11 Jan 2022 20:38:43 +0800 Subject: [PATCH 73/97] 5 problems solved. --- src/108.cpp | 18 ++++++++++++++++++ src/2124.cpp | 15 +++++++++++++++ src/2125.cpp | 32 ++++++++++++++++++++++++++++++++ src/2129.cpp | 26 ++++++++++++++++++++++++++ src/2133.cpp | 37 +++++++++++++++++++++++++++++++++++++ 5 files changed, 128 insertions(+) create mode 100644 src/108.cpp create mode 100644 src/2124.cpp create mode 100644 src/2125.cpp create mode 100644 src/2129.cpp create mode 100644 src/2133.cpp diff --git a/src/108.cpp b/src/108.cpp new file mode 100644 index 0000000..f824ed6 --- /dev/null +++ b/src/108.cpp @@ -0,0 +1,18 @@ +TreeNode* sortedArrayToBST(vector& nums) { + int len = nums.size(); + return generate(nums, 0, len-1); + } + + TreeNode* generate(vector& nums, int p, int q) + { + TreeNode* node = nullptr; + if (p <= q) + { + int lim = (p+q)/2; + node = new TreeNode(nums[lim]); + node->left = generate(nums, p, lim-1); + node->right = generate(nums, lim+1, q); + } + + return node; + } \ No newline at end of file diff --git a/src/2124.cpp b/src/2124.cpp new file mode 100644 index 0000000..ccac962 --- /dev/null +++ b/src/2124.cpp @@ -0,0 +1,15 @@ +bool checkString(string s) { + int len = s.size(); + int i = 0; + while (i < len && s[i] == 'a') + ++i; + if (i >= len-1) + return true; + for (; i < len; ++i) + { + if (s[i] == 'a') + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/2125.cpp b/src/2125.cpp new file mode 100644 index 0000000..85dbf6b --- /dev/null +++ b/src/2125.cpp @@ -0,0 +1,32 @@ +int numberOfBeams(vector& bank) { + int row = bank.size(); + if (row == 1) + return 0; + int col = bank[0].size(); + vector devices(row, 0); + for (int i = 0; i < row; ++i) + { + for (int j = 0; j < col; ++j) + { + if (bank[i][j] == '1') + devices[i]++; + } + } + + int i = 0, j = 1; + int res = 0; + while (i < row-1 && devices[i] == 0) + ++i; + while (i < row-1) + { + j = i+1; + while (j < row && devices[j] == 0) + ++j; + if (j == row) + break; + res += devices[i]*devices[j]; + i = j; + } + + return res; + } \ No newline at end of file diff --git a/src/2129.cpp b/src/2129.cpp new file mode 100644 index 0000000..29eaa97 --- /dev/null +++ b/src/2129.cpp @@ -0,0 +1,26 @@ +string capitalizeTitle(string title) { + int len = title.size(); + int i = 0, pos = 0; + int n = 0; + while (i < len) + { + if (title[i] != ' ') + { + title[i] = tolower(title[i]); + ++n; + } + else + { + if (n > 2) + title[pos] = toupper(title[pos]); + n = 0; + pos = i+1; + } + ++i; + } + + if (n > 2) + title[pos] = toupper(title[pos]); + + return title; + } \ No newline at end of file diff --git a/src/2133.cpp b/src/2133.cpp new file mode 100644 index 0000000..2fdcf33 --- /dev/null +++ b/src/2133.cpp @@ -0,0 +1,37 @@ +bool checkValid(vector>& matrix) { + int n = matrix.size(); + vector flag(n, 0); + for (int i = 0; i < n; ++i) + { + flag.assign(n, 0); + int ct = 0; + for (int j = 0; j < n; ++j) + { + if (flag[matrix[i][j]-1] == 0) + { + flag[matrix[i][j]-1] = 1; + ++ct; + } + } + if (ct != n) + return false; + } + + for (int i = 0; i < n; ++i) + { + flag.assign(n, 0); + int ct = 0; + for (int j = 0; j < n; ++j) + { + if (flag[matrix[j][i]-1] == 0) + { + flag[matrix[j][i]-1] = 1; + ++ct; + } + } + if (ct != n) + return false; + } + + return true; + } \ No newline at end of file From 22c0111fec83fd48d7cabe168d9892683d3d37b2 Mon Sep 17 00:00:00 2001 From: Troy Date: Fri, 21 Jan 2022 21:34:23 +0800 Subject: [PATCH 74/97] 5 problems solved. --- src/1252.cpp | 24 ++++++++++++++++++++++++ src/1725.cpp | 18 ++++++++++++++++++ src/2138.cpp | 30 ++++++++++++++++++++++++++++++ src/495.cpp | 24 ++++++++++++++++++++++++ src/74.cpp | 19 +++++++++++++++++++ 5 files changed, 115 insertions(+) create mode 100644 src/1252.cpp create mode 100644 src/1725.cpp create mode 100644 src/2138.cpp create mode 100644 src/495.cpp create mode 100644 src/74.cpp diff --git a/src/1252.cpp b/src/1252.cpp new file mode 100644 index 0000000..b2c63da --- /dev/null +++ b/src/1252.cpp @@ -0,0 +1,24 @@ +int oddCells(int m, int n, vector>& indices) { + vector> vec(m, vector(n, 0)); + int len = indices.size(); + for (int i = 0; i < len; ++i) + { + int row = indices[i][0], col = indices[i][1]; + for (int r = 0; r < m; ++r) + vec[r][col]++; + for (int c = 0; c < n; ++c) + vec[row][c]++; + } + + int ct = 0; + for (int i = 0; i < m; ++i) + { + for (int j = 0; j < n; ++j) + { + if (vec[i][j]%2 == 1) + ++ct; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/1725.cpp b/src/1725.cpp new file mode 100644 index 0000000..40eeff5 --- /dev/null +++ b/src/1725.cpp @@ -0,0 +1,18 @@ +int countGoodRectangles(vector>& rectangles) { + int len = rectangles.size(); + int n = 0; + int maxlen = 0; + for (int i = 0; i < len; ++i) + { + int k = rectangles[i][0] < rectangles[i][1] ? rectangles[i][0] : rectangles[i][1]; + if (k > maxlen) + { + maxlen = k; + n = 1; + } + else if (k == maxlen) + ++n; + } + + return n; + } \ No newline at end of file diff --git a/src/2138.cpp b/src/2138.cpp new file mode 100644 index 0000000..fd76f3b --- /dev/null +++ b/src/2138.cpp @@ -0,0 +1,30 @@ +vector divideString(string s, int k, char fill) { + int len = s.size(); + int n = (len+k-1)/k; + int total = n*k; + vector res(n, string(k, ' ')); + int i = 0, j = 0, m = -1; + while (i < len) + { + if (i%k == 0) + { + ++m; + j = 0; + res[m][j] = s[i]; + } + else + { + res[m][j] = s[i]; + } + ++i; + ++j; + } + + while (i < total) + { + res[m][j++] = fill; + ++i; + } + + return res; + } \ No newline at end of file diff --git a/src/495.cpp b/src/495.cpp new file mode 100644 index 0000000..a0b7296 --- /dev/null +++ b/src/495.cpp @@ -0,0 +1,24 @@ +int findPoisonedDuration(vector& timeSeries, int duration) { + int len = timeSeries.size(); + int time = 0; + int bg = timeSeries[0], ed = timeSeries[0]+duration-1; + int i = 1; + while (i < len) + { + if (timeSeries[i] > ed) + { + time += ed-bg+1; + bg = timeSeries[i]; + ed = timeSeries[i]+duration-1; + } + else + { + ed = timeSeries[i]+duration-1; + } + ++i; + } + + time += ed-bg+1; + + return time; + } \ No newline at end of file diff --git a/src/74.cpp b/src/74.cpp new file mode 100644 index 0000000..1903fac --- /dev/null +++ b/src/74.cpp @@ -0,0 +1,19 @@ +bool searchMatrix(vector>& matrix, int target) { + int m = matrix.size(); + int n = matrix[0].size(); + + int p = 0, q = m*n-1; + while (p <= q) + { + int mid = (p+q)/2; + int r = mid/n, c = mid%n; + if (matrix[r][c] == target) + return true; + else if (matrix[r][c] < target) + p = mid+1; + else + q = mid-1; + } + + return false; + } \ No newline at end of file From 7938f9dceb761fefaa2bed8e31cc2aca23764010 Mon Sep 17 00:00:00 2001 From: Troy Date: Mon, 7 Feb 2022 10:46:03 +0800 Subject: [PATCH 75/97] 5 problems solved. --- src/2144.cpp | 20 ++++++++++++++++++++ src/2148.cpp | 28 ++++++++++++++++++++++++++++ src/2154.cpp | 13 +++++++++++++ src/2160.cpp | 23 +++++++++++++++++++++++ src/2164.cpp | 20 ++++++++++++++++++++ 5 files changed, 104 insertions(+) create mode 100644 src/2144.cpp create mode 100644 src/2148.cpp create mode 100644 src/2154.cpp create mode 100644 src/2160.cpp create mode 100644 src/2164.cpp diff --git a/src/2144.cpp b/src/2144.cpp new file mode 100644 index 0000000..f730b58 --- /dev/null +++ b/src/2144.cpp @@ -0,0 +1,20 @@ +int minimumCost(vector& cost) { + sort(cost.begin(), cost.end()); + int len = cost.size(); + int costSum = 0; + int i = len-1; + while (i >= 0) + { + costSum += cost[i]; + --i; + if (i < 0) + break; + costSum += cost[i]; + --i; + if (i < 0) + break; + --i; + } + + return costSum; + } \ No newline at end of file diff --git a/src/2148.cpp b/src/2148.cpp new file mode 100644 index 0000000..9a24a2d --- /dev/null +++ b/src/2148.cpp @@ -0,0 +1,28 @@ +int countElements(vector& nums) { + int minval = 1e6, maxval = -1e6; + int minnum = 0, maxnum = 0; + int len = nums.size(); + for (int i = 0; i < len; ++i) + { + if (nums[i] < minval) + { + minval = nums[i]; + minnum = 1; + } + else if (nums[i] == minval) + { + ++minnum; + } + if (nums[i] > maxval) + { + maxval = nums[i]; + maxnum = 1; + } + else if (nums[i] == maxval) + { + ++maxnum; + } + } + + return (len-minnum-maxnum) > 0 ? (len-minnum-maxnum) : 0; + } \ No newline at end of file diff --git a/src/2154.cpp b/src/2154.cpp new file mode 100644 index 0000000..29018c0 --- /dev/null +++ b/src/2154.cpp @@ -0,0 +1,13 @@ +int findFinalValue(vector& nums, int original) { + sort(nums.begin(), nums.end()); + int len = nums.size(); + int i = 0; + while (i < len) + { + if (nums[i] == original) + original *= 2; + ++i; + } + + return original; + } \ No newline at end of file diff --git a/src/2160.cpp b/src/2160.cpp new file mode 100644 index 0000000..8b8666b --- /dev/null +++ b/src/2160.cpp @@ -0,0 +1,23 @@ +int minimumSum(int num) { + int arr[4] = {0}; + int i = 0; + while (num > 0) + { + arr[i++] = num%10; + num /= 10; + } + for (int i = 0; i < 3; ++i) + { + for (int j = i+1; j < 4; ++j) + { + if (arr[i] > arr[j]) + { + int tmp = arr[i]; + arr[i] = arr[j]; + arr[j] = tmp; + } + } + } + + return arr[0]*10+arr[3] + arr[1]*10+arr[2]; + } \ No newline at end of file diff --git a/src/2164.cpp b/src/2164.cpp new file mode 100644 index 0000000..c89d201 --- /dev/null +++ b/src/2164.cpp @@ -0,0 +1,20 @@ +vector sortEvenOdd(vector& nums) { + int len = nums.size(); + if (len <= 2) + return nums; + for (int i = 0, j = 1; (i < len-1 || j < len-1); i += 2, j += 2) + { + for (int m = i+2; m < len; m += 2) + { + if (nums[i] > nums[m]) + swap(nums[i], nums[m]); + } + for (int n = j+2; n < len; n += 2) + { + if (nums[j] < nums[n]) + swap(nums[j], nums[n]); + } + } + + return nums; + } \ No newline at end of file From 1f7f8ff07a1da6282438f40f33397fba11d63be1 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 27 Feb 2022 19:01:47 +0800 Subject: [PATCH 76/97] 10 problems solved. --- src/1901.cpp | 39 +++++++++++++++++++++++++++++++++++++++ src/2091.cpp | 27 +++++++++++++++++++++++++++ src/2095.cpp | 30 ++++++++++++++++++++++++++++++ src/2130.cpp | 20 ++++++++++++++++++++ src/2150.cpp | 20 ++++++++++++++++++++ src/2161.cpp | 8 ++++++++ src/2169.cpp | 20 ++++++++++++++++++++ src/2176.cpp | 14 ++++++++++++++ src/2177.cpp | 10 ++++++++++ src/2181.cpp | 28 ++++++++++++++++++++++++++++ 10 files changed, 216 insertions(+) create mode 100644 src/1901.cpp create mode 100644 src/2091.cpp create mode 100644 src/2095.cpp create mode 100644 src/2130.cpp create mode 100644 src/2150.cpp create mode 100644 src/2161.cpp create mode 100644 src/2169.cpp create mode 100644 src/2176.cpp create mode 100644 src/2177.cpp create mode 100644 src/2181.cpp diff --git a/src/1901.cpp b/src/1901.cpp new file mode 100644 index 0000000..43d2b41 --- /dev/null +++ b/src/1901.cpp @@ -0,0 +1,39 @@ +vector findPeakGrid(vector>& mat) { + int row = mat.size(); + int col = mat[0].size(); + + vector pos(2, -1); + search(mat, row, col, 0, col-1, pos); + + return pos; + } + + bool search(vector>& mat, int row, int col, int lh, int rh, vector& pos) + { + if (lh <= rh) + { + int mid = (lh+rh)/2; + for (int i = 0; i < row; ++i) + { + bool flag = true; + if (i > 0) + flag &= mat[i][mid] > mat[i-1][mid]; + if (i < row-1) + flag &= mat[i][mid] > mat[i+1][mid]; + if (mid > 0) + flag &= mat[i][mid] > mat[i][mid-1]; + if (mid < col-1) + flag &= mat[i][mid] > mat[i][mid+1]; + if (flag) + { + pos[0] = i; + pos[1] = mid; + return true; + } + } + + return search(mat, row, col, lh, mid-1, pos) || search(mat, row, col, mid+1, rh, pos); + } + else + return false; + } \ No newline at end of file diff --git a/src/2091.cpp b/src/2091.cpp new file mode 100644 index 0000000..9d6c998 --- /dev/null +++ b/src/2091.cpp @@ -0,0 +1,27 @@ +int minimumDeletions(vector& nums) { + int len = nums.size(); + if (len <= 2) + return len; + + int maxval = -1e6, minval = 1e6; + int maxpos = 0, minpos = 0; + for (int i = 0; i < len; ++i) + { + if (nums[i] < minval) + { + minval = nums[i]; + minpos = i; + } + if (nums[i] > maxval) + { + maxval = nums[i]; + maxpos = i; + } + } + + int n1 = minpos > maxpos ? minpos+1 : maxpos+1; + int n2 = minpos > maxpos ? len-maxpos : len-minpos; + int n3 = (minpos < len-1-minpos ? minpos+1 : len-minpos) + (maxpos < len-1-maxpos ? maxpos+1 : len-maxpos); + + return min(min(n1, n2), n3); + } \ No newline at end of file diff --git a/src/2095.cpp b/src/2095.cpp new file mode 100644 index 0000000..5b0fa45 --- /dev/null +++ b/src/2095.cpp @@ -0,0 +1,30 @@ +ListNode* deleteMiddle(ListNode* head) { + if (head->next == nullptr) + { + delete head; + return nullptr; + } + + int ct = 0; + ListNode* node = head; + while (node != nullptr) + { + ++ct; + node = node->next; + } + + int n = ct/2; + int i = 0; + ListNode* h = head, *cur = h; + node = h->next; + while (i != n-1) + { + cur = node; + node = node->next; + ++i; + } + + cur->next = node->next; + delete node; + return h; + } \ No newline at end of file diff --git a/src/2130.cpp b/src/2130.cpp new file mode 100644 index 0000000..7a4f8d0 --- /dev/null +++ b/src/2130.cpp @@ -0,0 +1,20 @@ +int pairSum(ListNode* head) { + vector num(1e5, 0); + int n = 0; + while (head != nullptr) + { + num[n++] = head->val; + head = head->next; + } + + int lim = n/2-1; + int maxval = 0; + for (int i = 0; i <= lim; ++i) + { + int tmp = num[i] + num[n-1-i]; + if (tmp > maxval) + maxval = tmp; + } + + return maxval; + } \ No newline at end of file diff --git a/src/2150.cpp b/src/2150.cpp new file mode 100644 index 0000000..7180d55 --- /dev/null +++ b/src/2150.cpp @@ -0,0 +1,20 @@ +vector findLonely(vector& nums) { + int len = nums.size(); + if (len == 1) + return nums; + sort(nums.begin(), nums.end()); + + vector res; + if (nums[1] > nums[0]+1) + res.push_back(nums[0]); + + for (int i = 1; i < len-1; ++i) + { + if ((nums[i] > nums[i-1]+1) && (nums[i] < nums[i+1]-1)) + res.push_back(nums[i]); + } + if (nums[len-1] > nums[len-2]+1) + res.push_back(nums[len-1]); + + return res; + } \ No newline at end of file diff --git a/src/2161.cpp b/src/2161.cpp new file mode 100644 index 0000000..0d6fc06 --- /dev/null +++ b/src/2161.cpp @@ -0,0 +1,8 @@ +vector pivotArray(vector& nums, int pivot) { + auto cmp = [&](int a, int b) { + return (a < pivot && b == pivot) || (a < pivot && b > pivot) || (a == pivot && b > pivot); + }; + + stable_sort(nums.begin(), nums.end(), cmp); + return nums; + } \ No newline at end of file diff --git a/src/2169.cpp b/src/2169.cpp new file mode 100644 index 0000000..0a2d4e3 --- /dev/null +++ b/src/2169.cpp @@ -0,0 +1,20 @@ +int countOperations(int num1, int num2) { + int ct = 0; + while (num1 != 0 && num2 != 0) + { + if (num1 >= num2) + { + int tmp = num1/num2; + num1 = num1 - tmp*num2; + ct += tmp; + } + else + { + int tmp = num2/num1; + num2 = num2 - tmp*num1; + ct += tmp; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2176.cpp b/src/2176.cpp new file mode 100644 index 0000000..aacd9b0 --- /dev/null +++ b/src/2176.cpp @@ -0,0 +1,14 @@ +int countPairs(vector& nums, int k) { + int ct = 0; + int len = nums.size(); + for (int i = 0; i < len-1; ++i) + { + for (int j = i+1; j < len; ++j) + { + if (nums[i] == nums[j] && (i*j%k == 0)) + ++ct; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2177.cpp b/src/2177.cpp new file mode 100644 index 0000000..6d03b04 --- /dev/null +++ b/src/2177.cpp @@ -0,0 +1,10 @@ +vector sumOfThree(long long num) { + if (num%3 != 0) + return {}; + vector res(3, 0); + res[0] = num/3-1; + res[1] = num/3; + res[2] = num/3+1; + + return res; + } \ No newline at end of file diff --git a/src/2181.cpp b/src/2181.cpp new file mode 100644 index 0000000..19207e5 --- /dev/null +++ b/src/2181.cpp @@ -0,0 +1,28 @@ +ListNode* mergeNodes(ListNode* head) { + ListNode* p = head->next; + delete head; + + ListNode* h = p; + ListNode* cur = h; + ListNode* node = p->next; + while (node != nullptr) + { + ListNode* tmp = node; + node = node->next; + if (tmp->val != 0) + { + cur->val += tmp->val; + } + else + { + cur->next = node; + cur = node; + if (node == nullptr) + break; + node = node->next; + } + delete tmp; + } + + return h; + } \ No newline at end of file From cd67d2398ca71dc06da8d1f6d6a6f29e33f98b00 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 12 Mar 2022 20:30:49 +0800 Subject: [PATCH 77/97] 7 problems solved. --- src/1846.cpp | 15 +++++++++++++++ src/2023.cpp | 24 ++++++++++++++++++++++++ src/2058.cpp | 38 ++++++++++++++++++++++++++++++++++++++ src/2109.cpp | 25 +++++++++++++++++++++++++ src/2185.cpp | 18 ++++++++++++++++++ src/2190.cpp | 21 +++++++++++++++++++++ src/2194.cpp | 19 +++++++++++++++++++ 7 files changed, 160 insertions(+) create mode 100644 src/1846.cpp create mode 100644 src/2023.cpp create mode 100644 src/2058.cpp create mode 100644 src/2109.cpp create mode 100644 src/2185.cpp create mode 100644 src/2190.cpp create mode 100644 src/2194.cpp diff --git a/src/1846.cpp b/src/1846.cpp new file mode 100644 index 0000000..8af9942 --- /dev/null +++ b/src/1846.cpp @@ -0,0 +1,15 @@ +int maximumElementAfterDecrementingAndRearranging(vector& arr) { + int len = arr.size(); + sort(arr.begin(), arr.end()); + + arr[0] = 1; + for (int i = 1; i < len; ++i) + { + if (arr[i] > arr[i-1]+1) + { + arr[i] = arr[i-1]+1; + } + } + + return arr[len-1]; + } \ No newline at end of file diff --git a/src/2023.cpp b/src/2023.cpp new file mode 100644 index 0000000..acc38f2 --- /dev/null +++ b/src/2023.cpp @@ -0,0 +1,24 @@ +int numOfPairs(vector& nums, string target) { + int len = nums.size(); + int targetlen = target.size(); + vector sz_vec(len, 0); + for (int i = 0; i < len; ++i) + sz_vec[i] = nums[i].size(); + + int ct = 0; + for (int i = 0; i < len-1; ++i) + { + for (int j = i+1; j < len; ++j) + { + if (sz_vec[i] + sz_vec[j] == targetlen) + { + if (nums[i] + nums[j] == target) + ct += 1; + if (nums[j] + nums[i] == target) + ct += 1; + } + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2058.cpp b/src/2058.cpp new file mode 100644 index 0000000..b35c6b3 --- /dev/null +++ b/src/2058.cpp @@ -0,0 +1,38 @@ +vector nodesBetweenCriticalPoints(ListNode* head) { + ListNode* pre = head, *cur = head->next, *post = head->next->next; + int lastindex = -1, nextindex = -1, firstindex = -1; + int n = 1; + int mindist = 1e5; + while (post != nullptr) + { + if ((cur->val < pre->val && cur->val < post->val) + || (cur->val > pre->val && cur->val > post->val)) + { + lastindex = nextindex; + nextindex = n; + if (lastindex == -1) + { + firstindex = n; + } + else + { + int dist = nextindex - lastindex; + if (dist < mindist) + mindist = dist; + } + } + pre = cur; + cur = post; + post = post->next; + ++n; + } + + vector res(2, -1); + if (lastindex != -1 && nextindex != -1) + { + res[0] = mindist; + res[1] = nextindex - firstindex; + } + + return res; + } \ No newline at end of file diff --git a/src/2109.cpp b/src/2109.cpp new file mode 100644 index 0000000..3ebf338 --- /dev/null +++ b/src/2109.cpp @@ -0,0 +1,25 @@ +string addSpaces(string s, vector& spaces) { + int sz = s.size(); + int len = spaces.size(); + int n = sz + len; + int i = 0, j = 0, k = 0; + + string res(n, ' '); + while (i < n && j < len) + { + if (i < spaces[j]+j) + { + res[i++] = s[k++]; + } + else + { + ++i; + ++j; + } + } + + if (i < n) + copy(s.begin()+k, s.end(), res.begin()+i); + + return res; + } \ No newline at end of file diff --git a/src/2185.cpp b/src/2185.cpp new file mode 100644 index 0000000..bbc1b2e --- /dev/null +++ b/src/2185.cpp @@ -0,0 +1,18 @@ +int prefixCount(vector& words, string pref) { + int len = words.size(); + int n = pref.size(); + int ct = 0; + for (int i = 0; i < len; ++i) + { + int j = 0; + for (j = 0; j < n; ++j) + { + if (words[i][j] != pref[j]) + break; + } + if (j == n) + ++ct; + } + + return ct; + } \ No newline at end of file diff --git a/src/2190.cpp b/src/2190.cpp new file mode 100644 index 0000000..ff8aca7 --- /dev/null +++ b/src/2190.cpp @@ -0,0 +1,21 @@ +int mostFrequent(vector& nums, int key) { + int len = nums.size(); + int target = 0, maxnum = 0; + for (int i = 0; i < len; ++i) + { + int tmp = nums[i], ct = 0; + for (int j = 0; j < len-1; ++j) + { + if (nums[j] == key && nums[j+1] == tmp) + ++ct; + } + + if (ct > maxnum) + { + target = tmp; + maxnum = ct; + } + } + + return target; + } \ No newline at end of file diff --git a/src/2194.cpp b/src/2194.cpp new file mode 100644 index 0000000..6f58f82 --- /dev/null +++ b/src/2194.cpp @@ -0,0 +1,19 @@ +vector cellsInRange(string s) { + int m = s[4]-s[1]+1; + int n = s[3]-s[0]+1; + int sum = m*n; + + vector res(sum, " "); + int k = 0; + for (int i = 0; i < n; ++i) + { + for (int j = 0; j < m; ++j) + { + res[k][0] = s[0]+i; + res[k][1] = s[1]+j; + ++k; + } + } + + return res; + } \ No newline at end of file From 894efd461ed875c1f3fa1fd62aea95792192cb1c Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 20 Mar 2022 16:48:31 +0800 Subject: [PATCH 78/97] 5 problems solved. --- src/1525.cpp | 36 ++++++++++++++++++++++++++++++++++++ src/1861.cpp | 43 +++++++++++++++++++++++++++++++++++++++++++ src/2200.cpp | 30 ++++++++++++++++++++++++++++++ src/2206.cpp | 16 ++++++++++++++++ src/2210.cpp | 26 ++++++++++++++++++++++++++ 5 files changed, 151 insertions(+) create mode 100644 src/1525.cpp create mode 100644 src/1861.cpp create mode 100644 src/2200.cpp create mode 100644 src/2206.cpp create mode 100644 src/2210.cpp diff --git a/src/1525.cpp b/src/1525.cpp new file mode 100644 index 0000000..5d85f20 --- /dev/null +++ b/src/1525.cpp @@ -0,0 +1,36 @@ +int numSplits(string s) { + int charNum1[26] = {0}; + int charNum2[26] = {0}; + int len = s.size(), ct = 0; + for (int i = 0; i < len; ++i) + { + int idx = s[i]-'a'; + if (charNum1[idx] == 0) + { + ++ct; + } + charNum1[idx]++; + } + + int n = 0, sum = 0; + for (int i = 0; i < len; ++i) + { + int idx = s[i]-'a'; + if (charNum2[idx] == 0) + { + charNum2[idx] = 1; + ++n; + } + if (charNum1[idx] > 0) + { + --charNum1[idx]; + if (charNum1[idx] == 0) + --ct; + } + + if (n == ct) + ++sum; + } + + return sum; + } \ No newline at end of file diff --git a/src/1861.cpp b/src/1861.cpp new file mode 100644 index 0000000..5c7b118 --- /dev/null +++ b/src/1861.cpp @@ -0,0 +1,43 @@ +vector> rotateTheBox(vector>& box) { + int m = box.size(); + int n = box[0].size(); + vector> res(n, vector(m, '.')); + + for (int i = 0; i < m; ++i) + { + int col = m-1-i; + int j = n-1, k = n-1, idx = n; + bool flag = false; + while (j >= 0) + { + if (box[i][j] == '.') + { + if (!flag) + { + idx = j; + flag = true; + } + } + else if (box[i][j] == '*') + { + idx = n; + flag = false; + res[k][col] = '*'; + } + else + { + if (idx != n) + { + res[idx][col] = '#'; + --idx; + } + else + res[k][col] = '#'; + } + --j; + --k; + } + } + + return res; + } \ No newline at end of file diff --git a/src/2200.cpp b/src/2200.cpp new file mode 100644 index 0000000..2dce6a6 --- /dev/null +++ b/src/2200.cpp @@ -0,0 +1,30 @@ +vector findKDistantIndices(vector& nums, int key, int k) { + int len = nums.size(); + vector pos; + int ct = 0; + for (int i = 0; i < len; ++i) + { + if (nums[i] == key) + { + pos.push_back(i); + ++ct; + } + } + + vector res; + int lh = -1, rh = -1; + for (int i = 0; i < ct; ++i) + { + int l = pos[i]-k > 0 ? pos[i]-k : 0; + int r = pos[i]+k < len ? pos[i]+k : len-1; + lh = l >= rh+1 ? l : rh+1; + rh = r; + for (int j = lh; j <= rh; ++j) + res.push_back(j); + + if (rh == len-1) + break; + } + + return res; + } \ No newline at end of file diff --git a/src/2206.cpp b/src/2206.cpp new file mode 100644 index 0000000..3c7a614 --- /dev/null +++ b/src/2206.cpp @@ -0,0 +1,16 @@ +bool divideArray(vector& nums) { + int arr[501] = {0}; + int len = nums.size(); + for (int i = 0; i < len; ++i) + { + arr[nums[i]]++; + } + + for (int i = 0; i < 501; ++i) + { + if (arr[i]%2 == 1) + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/2210.cpp b/src/2210.cpp new file mode 100644 index 0000000..2dc6f4e --- /dev/null +++ b/src/2210.cpp @@ -0,0 +1,26 @@ +int countHillValley(vector& nums) { + int len = nums.size(); + int i = 1; + while (i < len-1 && nums[i] == nums[i-1]) + ++i; + if (i == len-1) + return 0; + + int prepos = i-1; + int ct = 0; + while (i < len) + { + int j = i; + ++i; + while (i < len && nums[i] == nums[i-1]) + ++i; + if (i == len) + break; + if ((nums[j] < nums[prepos] && nums[j] < nums[i]) + || (nums[j] > nums[prepos] && nums[j] > nums[i])) + ++ct; + prepos = j; + } + + return ct; + } \ No newline at end of file From cff8589aea3f8f854c9a167e1969e4c8e82f1a18 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 9 Apr 2022 17:04:32 +0800 Subject: [PATCH 79/97] 8 problems solved. --- src/2180.cpp | 17 ++++++++++++++++ src/2196.cpp | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/2215.cpp | 20 +++++++++++++++++++ src/222.cpp | 16 +++++++++++++++ src/2220.cpp | 11 +++++++++++ src/2221.cpp | 13 +++++++++++++ src/2224.cpp | 23 ++++++++++++++++++++++ src/2225.cpp | 21 ++++++++++++++++++++ 8 files changed, 176 insertions(+) create mode 100644 src/2180.cpp create mode 100644 src/2196.cpp create mode 100644 src/2215.cpp create mode 100644 src/222.cpp create mode 100644 src/2220.cpp create mode 100644 src/2221.cpp create mode 100644 src/2224.cpp create mode 100644 src/2225.cpp diff --git a/src/2180.cpp b/src/2180.cpp new file mode 100644 index 0000000..d3b282c --- /dev/null +++ b/src/2180.cpp @@ -0,0 +1,17 @@ +int countEven(int num) { + int ct = 0; + for (int i = 1; i <= num; ++i) + { + int n = i; + int sum = 0; + while (n > 0) + { + sum += n%10; + n /= 10; + } + if (sum%2 == 0) + ++ct; + } + + return ct; + } \ No newline at end of file diff --git a/src/2196.cpp b/src/2196.cpp new file mode 100644 index 0000000..63adc3f --- /dev/null +++ b/src/2196.cpp @@ -0,0 +1,55 @@ +TreeNode* createBinaryTree(vector>& descriptions) { + map nodeflag; + map> nodepos; + int len = descriptions.size(); + + for (int i = 0; i < len; ++i) + { + nodeflag[descriptions[i][0]] |= 1; + nodeflag[descriptions[i][1]] |= 2; + if (descriptions[i][2] == 1) + nodepos[descriptions[i][0]].first = descriptions[i][1]; + else + nodepos[descriptions[i][0]].second = descriptions[i][1]; + } + + int headval = 0; + auto iterLast = nodeflag.end(); + for (auto iter = nodeflag.begin(); iter != iterLast; ++iter) + { + if (iter->second == 1) + { + headval = iter->first; + break; + } + } + + TreeNode* head = new TreeNode(headval); + deque dq; + dq.push_back(head); + int k = 1; + while (k != 0) + { + int n = 0; + for (int i = 0; i < k; ++i) + { + TreeNode* node = dq[i]; + if (nodepos[node->val].first != 0) + { + node->left = new TreeNode(nodepos[node->val].first); + dq.push_back(node->left); + ++n; + } + if (nodepos[node->val].second != 0) + { + node->right = new TreeNode(nodepos[node->val].second); + dq.push_back(node->right); + ++n; + } + } + dq.erase(dq.begin(), dq.begin()+k); + k = n; + } + + return head; + } \ No newline at end of file diff --git a/src/2215.cpp b/src/2215.cpp new file mode 100644 index 0000000..042fb84 --- /dev/null +++ b/src/2215.cpp @@ -0,0 +1,20 @@ +vector> findDifference(vector& nums1, vector& nums2) { + int arr1[2001] = {0}; + int arr2[2001] = {0}; + int len1 = nums1.size(), len2 = nums2.size(); + for (int i = 0; i < len1; ++i) + arr1[nums1[i]+1000] = 1; + for (int i = 0; i < len2; ++i) + arr2[nums2[i]+1000] = 1; + + vector> res(2, vector()); + for (int i = 0; i < 2001; ++i) + { + if (arr1[i] != 0 && arr2[i] == 0) + res[0].push_back(i-1000); + if (arr1[i] == 0 && arr2[i] != 0) + res[1].push_back(i-1000); + } + + return res; + } \ No newline at end of file diff --git a/src/222.cpp b/src/222.cpp new file mode 100644 index 0000000..d6358e4 --- /dev/null +++ b/src/222.cpp @@ -0,0 +1,16 @@ +int countNodes(TreeNode* root) { + int ct = 0; + search(root, ct); + + return ct; + } + + void search(TreeNode* node, int& n) + { + if (node != nullptr) + { + ++n; + search(node->left, n); + search(node->right, n); + } + } \ No newline at end of file diff --git a/src/2220.cpp b/src/2220.cpp new file mode 100644 index 0000000..05891f0 --- /dev/null +++ b/src/2220.cpp @@ -0,0 +1,11 @@ +int minBitFlips(int start, int goal) { + bitset<32> bs(start), bg(goal); + int ct = 0; + for (int i = 0; i < 32; ++i) + { + if (bs[i] != bg[i]) + ++ct; + } + + return ct; + } \ No newline at end of file diff --git a/src/2221.cpp b/src/2221.cpp new file mode 100644 index 0000000..2bf679c --- /dev/null +++ b/src/2221.cpp @@ -0,0 +1,13 @@ +int triangularSum(vector& nums) { + int len = nums.size(); + while (len > 1) + { + for (int i = 0; i < len-1; ++i) + { + nums[i] = (nums[i]+nums[i+1])%10; + } + --len; + } + + return nums[0]; + } \ No newline at end of file diff --git a/src/2224.cpp b/src/2224.cpp new file mode 100644 index 0000000..f4badc3 --- /dev/null +++ b/src/2224.cpp @@ -0,0 +1,23 @@ +int convertTime(string current, string correct) { + int curMinutes = ((current[0]-'0')*10+(current[1]-'0'))*60 + ((current[3]-'0')*10+(current[4]-'0')); + int corrMinutes = ((correct[0]-'0')*10+(correct[1]-'0'))*60 + ((correct[3]-'0')*10+(correct[4]-'0')); + int delta = corrMinutes - curMinutes; + int ct = 0; + if (delta >= 60) + { + ct += delta/60; + delta %= 60; + } + if (delta >= 15) + { + ct += delta/15; + delta %= 15; + } + if (delta >= 5) + { + ct += delta/5; + delta %= 5; + } + + return ct + delta; + } \ No newline at end of file diff --git a/src/2225.cpp b/src/2225.cpp new file mode 100644 index 0000000..3724382 --- /dev/null +++ b/src/2225.cpp @@ -0,0 +1,21 @@ +vector> findWinners(vector>& matches) { + map> mp; + int len = matches.size(); + for (int i = 0; i < len; ++i) + { + mp[matches[i][0]].first++; + mp[matches[i][1]].second++; + } + + vector> res(2, vector{}); + auto iterLast = mp.end(); + for (auto iter = mp.begin(); iter != iterLast; ++iter) + { + if (iter->second.second == 0) + res[0].push_back(iter->first); + if (iter->second.second == 1) + res[1].push_back(iter->first); + } + + return res; + } \ No newline at end of file From 7954d523f53447001f7b1fc70dcce357f51b38bc Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 16 Apr 2022 15:37:17 +0800 Subject: [PATCH 80/97] 6 problems solved. --- src/2165.cpp | 34 +++++++++++++++++++++++++++++++ src/2186.cpp | 15 ++++++++++++++ src/2201.cpp | 28 ++++++++++++++++++++++++++ src/2232.cpp | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/2235.cpp | 3 +++ src/2236.cpp | 3 +++ 6 files changed, 139 insertions(+) create mode 100644 src/2165.cpp create mode 100644 src/2186.cpp create mode 100644 src/2201.cpp create mode 100644 src/2232.cpp create mode 100644 src/2235.cpp create mode 100644 src/2236.cpp diff --git a/src/2165.cpp b/src/2165.cpp new file mode 100644 index 0000000..309c0e7 --- /dev/null +++ b/src/2165.cpp @@ -0,0 +1,34 @@ +long long smallestNumber(long long num) { + if (num == 0) + return 0; + else if (num < 0) + { + num = -num; + string s = to_string(num); + sort(s.begin(), s.end(), greater()); + return -1*stoll(s, nullptr); + } + else + { + string s = to_string(num); + sort(s.begin(), s.end()); + int len = s.size(); + int i = 0; + for (i = 0; i < len; ++i) + { + if(s[i] != '0') + break; + } + if (i != len) + { + char c = s[i]; + for (; i >= 1; --i) + { + s[i] = s[i-1]; + } + s[0] = c; + } + + return stoll(s, nullptr); + } + } \ No newline at end of file diff --git a/src/2186.cpp b/src/2186.cpp new file mode 100644 index 0000000..9b1fdb8 --- /dev/null +++ b/src/2186.cpp @@ -0,0 +1,15 @@ +int minSteps(string s, string t) { + int num1[26] = {0}; + int num2[26] = {0}; + int len1 = s.size(), len2 = t.size(); + for (int i = 0; i < len1; ++i) + num1[s[i]-'a']++; + for (int i = 0; i < len2; ++i) + num2[t[i]-'a']++; + + int ct = 0; + for (int i = 0; i < 26; ++i) + ct += abs(num1[i]-num2[i]); + + return ct; + } \ No newline at end of file diff --git a/src/2201.cpp b/src/2201.cpp new file mode 100644 index 0000000..049bac2 --- /dev/null +++ b/src/2201.cpp @@ -0,0 +1,28 @@ +int digArtifacts(int n, vector>& artifacts, vector>& dig) { + map,int> mp; + int len = artifacts.size(); + for (int i = 0; i < len; ++i) + { + int r1 = artifacts[i][0], c1 = artifacts[i][1]; + int r2 = artifacts[i][2], c2 = artifacts[i][3]; + for (int j = r1; j <= r2; ++j) + { + for (int k = c1; k <= c2; ++k) + mp[make_pair(j,k)] = i+1; + } + } + + int sz = dig.size(); + for (int i = 0; i < sz; ++i) + mp[make_pair(dig[i][0], dig[i][1])] = 0; + + set st; + auto iterLast = mp.end(); + for (auto iter = mp.begin(); iter != iterLast; ++iter) + { + if (iter->second != 0) + st.insert(iter->second); + } + + return len - st.size(); + } \ No newline at end of file diff --git a/src/2232.cpp b/src/2232.cpp new file mode 100644 index 0000000..05b6b4b --- /dev/null +++ b/src/2232.cpp @@ -0,0 +1,56 @@ +string minimizeResult(string expression) { + int num1 = 0, num2 = 0; + int len = expression.size(); + int index = expression.find('+'); + int m = len-1-index; + for (int i = 0; i < index; ++i) + num1 = num1*10 + (expression[i]-'0'); + for (int i = index+1; i < len; ++i) + num2 = num2*10 + (expression[i]-'0'); + + int digit1[20] = {1,num1}, digit2[20] = {num2,1}; + int n = pow(10, index-1); + for (int i = 1; i < index; ++i) + { + digit1[i*2] = num1/n; + digit1[i*2+1] = num1%n; + n /= 10; + } + n = 10; + for (int i = 1; i < m; ++i) + { + digit2[i*2] = num2/n; + digit2[i*2+1] = num2%n; + n *= 10; + } + + int minval = 1e9; + int p = 0, q = 0; + for (int i = 0; i < index; ++i) + { + for (int j = 0; j < m; ++j) + { + int val = digit1[i*2]*(digit1[i*2+1] + digit2[j*2])*digit2[j*2+1]; + if (val < minval) + { + minval = val; + p = i; + q = j; + } + } + } + + string res(len+2, ' '); + int k = 0; + for (int i = 0; i < len+2; ++i) + { + if (i == p) + res[i] = '('; + else if (i == len+1-q) + res[i] = ')'; + else + res[i] = expression[k++]; + } + + return res; + } \ No newline at end of file diff --git a/src/2235.cpp b/src/2235.cpp new file mode 100644 index 0000000..f9c2614 --- /dev/null +++ b/src/2235.cpp @@ -0,0 +1,3 @@ +int sum(int num1, int num2) { + return num1 + num2; + } \ No newline at end of file diff --git a/src/2236.cpp b/src/2236.cpp new file mode 100644 index 0000000..d9c043b --- /dev/null +++ b/src/2236.cpp @@ -0,0 +1,3 @@ +bool checkTree(TreeNode* root) { + return root->val == root->left->val + root->right->val; + } \ No newline at end of file From 105d7d8273f082d4a277ebbefcafdf77497364a1 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 23 Apr 2022 21:14:43 +0800 Subject: [PATCH 81/97] 5 problems solved. --- src/1051.cpp | 14 ++++++++++++++ src/2149.cpp | 20 ++++++++++++++++++++ src/2239.cpp | 21 +++++++++++++++++++++ src/2243.cpp | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/883.cpp | 22 ++++++++++++++++++++++ 5 files changed, 128 insertions(+) create mode 100644 src/1051.cpp create mode 100644 src/2149.cpp create mode 100644 src/2239.cpp create mode 100644 src/2243.cpp create mode 100644 src/883.cpp diff --git a/src/1051.cpp b/src/1051.cpp new file mode 100644 index 0000000..b76da84 --- /dev/null +++ b/src/1051.cpp @@ -0,0 +1,14 @@ +int heightChecker(vector& heights) { + int len = heights.size(); + vector ori(heights); + sort(heights.begin(), heights.end()); + + int ct = 0; + for (int i = 0; i < len; ++i) + { + if (ori[i] != heights[i]) + ++ct; + } + + return ct; + } \ No newline at end of file diff --git a/src/2149.cpp b/src/2149.cpp new file mode 100644 index 0000000..e1368a1 --- /dev/null +++ b/src/2149.cpp @@ -0,0 +1,20 @@ +vector rearrangeArray(vector& nums) { + int len = nums.size(); + vector res(len, 0); + int even = 0, odd = 1; + for (int i = 0; i < len; ++i) + { + if (nums[i] > 0) + { + res[even] = nums[i]; + even += 2; + } + else + { + res[odd] = nums[i]; + odd += 2; + } + } + + return res; + } \ No newline at end of file diff --git a/src/2239.cpp b/src/2239.cpp new file mode 100644 index 0000000..58c60d0 --- /dev/null +++ b/src/2239.cpp @@ -0,0 +1,21 @@ +int findClosestNumber(vector& nums) { + int mindist = 1e5; + int val = -1e5; + int len = nums.size(); + for (int i = 0; i < len; ++i) + { + int tmp = abs(nums[i]); + if (tmp < mindist) + { + mindist = tmp; + val = nums[i]; + } + else if (tmp == mindist) + { + if (nums[i] > val) + val = nums[i]; + } + } + + return val; + } \ No newline at end of file diff --git a/src/2243.cpp b/src/2243.cpp new file mode 100644 index 0000000..0fe56f1 --- /dev/null +++ b/src/2243.cpp @@ -0,0 +1,51 @@ +string digitSum(string s, int k) { + int len = s.size(); + while (len > k) + { + int n = len/k; + int j = 0, sum = 0, m = 0; + for (int i = 0; i < n; ++i) + { + sum = 0; + for (j = i*k; j < (i+1)*k; ++j) + { + sum += s[j]-'0'; + } + + int lim = sum > 0 ? log10(sum) : 0; + int idx = m+lim; + int tmp = idx; + while (lim >= 0) + { + s[idx--] = sum%10+'0'; + sum /= 10; + --lim; + } + m = tmp+1; + } + + if (j < len) + { + sum = 0; + for (int i = j; i < len; ++i) + { + sum += s[i]-'0'; + } + int lim = sum > 0 ? log10(sum) : 0; + int idx = m+lim; + int tmp = idx; + while (lim >= 0) + { + s[idx--] = sum%10+'0'; + sum /= 10; + --lim; + } + m = tmp+1; + len = m; + } + else + len = m; + } + + return s.substr(0,len); + } \ No newline at end of file diff --git a/src/883.cpp b/src/883.cpp new file mode 100644 index 0000000..1dd6301 --- /dev/null +++ b/src/883.cpp @@ -0,0 +1,22 @@ +int projectionArea(vector>& grid) { + int n = grid.size(); + int area = 0; + for (int i = 0; i < n; ++i) + { + int maxvalrow = 0; + int maxvalcol = 0; + for (int j = 0; j < n; ++j) + { + if (grid[i][j] > 0) + area++; + if (grid[i][j] > maxvalrow) + maxvalrow = grid[i][j]; + if (grid[j][i] > maxvalcol) + maxvalcol = grid[j][i]; + } + + area += maxvalrow + maxvalcol; + } + + return area; + } \ No newline at end of file From de6b81ff1d1e676cbeb11bea8098936a9bfce853 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 1 May 2022 10:09:49 +0800 Subject: [PATCH 82/97] 5 problems solved. --- src/120.cpp | 12 ++++++++++++ src/1974.cpp | 13 +++++++++++++ src/2231.cpp | 34 ++++++++++++++++++++++++++++++++++ src/2248.cpp | 21 +++++++++++++++++++++ src/2255.cpp | 21 +++++++++++++++++++++ 5 files changed, 101 insertions(+) create mode 100644 src/120.cpp create mode 100644 src/1974.cpp create mode 100644 src/2231.cpp create mode 100644 src/2248.cpp create mode 100644 src/2255.cpp diff --git a/src/120.cpp b/src/120.cpp new file mode 100644 index 0000000..3ff4b9f --- /dev/null +++ b/src/120.cpp @@ -0,0 +1,12 @@ +int minimumTotal(vector>& triangle) { + int len = triangle.size(); + for (int i = len-2; i >= 0; --i) + { + for (int j = 0; j < i+1; ++j) + { + triangle[i][j] = triangle[i+1][j] intersection(vector>& nums) { + int len = nums.size(); + int arr[1001] = {0}; + for (int i = 0; i < len; ++i) + { + int sz = nums[i].size(); + for (int j = 0; j < sz; ++j) + ++arr[nums[i][j]]; + } + + vector res(1000, 0); + int k = 0; + for (int i = 0; i < 1001; ++i) + { + if (arr[i] == len) + res[k++] = i; + } + + + return vector(res.begin(), res.begin()+k); + } \ No newline at end of file diff --git a/src/2255.cpp b/src/2255.cpp new file mode 100644 index 0000000..c82a174 --- /dev/null +++ b/src/2255.cpp @@ -0,0 +1,21 @@ +int countPrefixes(vector& words, string s) { + int len = words.size(); + int lens = s.size(); + int ct = 0, j; + for (int i = 0; i < len; ++i) + { + int sz = words[i].size(); + if (sz <= lens) + { + for (j = 0; j < sz; ++j) + { + if (words[i][j] != s[j]) + break; + } + if(j == sz) + ++ct; + } + } + + return ct; + } \ No newline at end of file From 5489bff922d5c21419ba51cfc2a9672569e383ab Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 28 May 2022 20:28:28 +0800 Subject: [PATCH 83/97] 6 problems solved. --- src/2244.cpp | 27 +++++++++++++++++++++++++++ src/2259.cpp | 23 +++++++++++++++++++++++ src/2264.cpp | 46 ++++++++++++++++++++++++++++++++++++++++++++++ src/2269.cpp | 23 +++++++++++++++++++++++ src/2278.cpp | 11 +++++++++++ src/2279.cpp | 28 ++++++++++++++++++++++++++++ 6 files changed, 158 insertions(+) create mode 100644 src/2244.cpp create mode 100644 src/2259.cpp create mode 100644 src/2264.cpp create mode 100644 src/2269.cpp create mode 100644 src/2278.cpp create mode 100644 src/2279.cpp diff --git a/src/2244.cpp b/src/2244.cpp new file mode 100644 index 0000000..706455d --- /dev/null +++ b/src/2244.cpp @@ -0,0 +1,27 @@ +int minimumRounds(vector& tasks) { + map mp; + int len = tasks.size(); + for (int i = 0; i < len; ++i) + { + mp[tasks[i]]++; + } + + int ct = 0; + for (auto& kv : mp) + { + if (kv.second < 2) + return -1; + else if (kv.second%2 == 0) + { + int n = kv.second/3; + ct += n%2 == 0 ? n+(kv.second-n*3)/2 : n-1+(kv.second-(n-1)*3)/2; + } + else + { + int n = kv.second/3; + ct += n%2 == 1 ? n+(kv.second-n*3)/2 : n-1+(kv.second-(n-1)*3)/2; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2259.cpp b/src/2259.cpp new file mode 100644 index 0000000..fa03fd1 --- /dev/null +++ b/src/2259.cpp @@ -0,0 +1,23 @@ +string removeDigit(string number, char digit) { + int len = number.size(); + int pos = len; + for (int i = 0; i < len; ++i) + { + if (number[i] == digit) + { + pos = i; + if (i < len-1 && number[i] < number[i+1]) + break; + } + } + + string res(len-1, ' '); + int k = 0; + for (int i = 0; i < len; ++i) + { + if (i != pos) + res[k++] = number[i]; + } + + return res; + } \ No newline at end of file diff --git a/src/2264.cpp b/src/2264.cpp new file mode 100644 index 0000000..5f98a1a --- /dev/null +++ b/src/2264.cpp @@ -0,0 +1,46 @@ +string largestGoodInteger(string num) { + int len = num.size(); + int i = 1, ct = 1; + char c = num[0]; + char goodchar = ' '; + + while (i < len) + { + if (num[i] == c) + { + ++ct; + if (ct == 3) + { + if (goodchar == ' ') + goodchar = c; + else if (c > goodchar) + goodchar = c; + + int j = i+1; + while (j < len && num[j] == c) + ++j; + if (j == len) + break; + else + { + c = num[j]; + ct = 1; + i = j+1; + } + } + else + ++i; + } + else + { + c = num[i]; + ct = 1; + ++i; + } + } + + if (goodchar != ' ') + return string(3, goodchar); + else + return ""; + } \ No newline at end of file diff --git a/src/2269.cpp b/src/2269.cpp new file mode 100644 index 0000000..c2d742a --- /dev/null +++ b/src/2269.cpp @@ -0,0 +1,23 @@ +int divisorSubstrings(int num, int k) { + string s = to_string(num); + int len = s.size(); + + int i, ct = 0; + int sum = 0; + for (i = 0; i < k; ++i) + sum = sum*10 + s[i]-'0'; + + if (sum > 0 && num%sum == 0) + ++ct; + i = 0; + int coef = pow(10, k-1); + for (int j = k; j < len; ++j) + { + sum = (sum - (s[i]-'0')*coef)*10 + s[j]-'0'; + if (sum > 0 && num%sum == 0) + ++ct; + ++i; + } + + return ct; + } \ No newline at end of file diff --git a/src/2278.cpp b/src/2278.cpp new file mode 100644 index 0000000..c6a6ebb --- /dev/null +++ b/src/2278.cpp @@ -0,0 +1,11 @@ +int percentageLetter(string s, char letter) { + int len = s.size(); + int ct = 0; + for (int i = 0; i < len; ++i) + { + if (s[i] == letter) + ++ct; + } + + return ct*100/len; + } \ No newline at end of file diff --git a/src/2279.cpp b/src/2279.cpp new file mode 100644 index 0000000..016c9e1 --- /dev/null +++ b/src/2279.cpp @@ -0,0 +1,28 @@ +int maximumBags(vector& capacity, vector& rocks, int additionalRocks) { + int len = capacity.size(); + vector lessvec(len, 0); + + for (int i = 0; i < len; ++i) + { + lessvec[i] = capacity[i]-rocks[i]; + } + + sort(lessvec.begin(), lessvec.end()); + + int ct = 0; + for (int i = 0; i < len; ++i) + { + if (lessvec[i] == 0) + ++ct; + else + { + if (additionalRocks >= lessvec[i]) + { + additionalRocks -= lessvec[i]; + ++ct; + } + } + } + + return ct; + } \ No newline at end of file From 3f73ee1ce6ef38a7a31d33ad788ceb94bb79456c Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 10 Jul 2022 13:20:43 +0800 Subject: [PATCH 84/97] 9 problems solved. --- src/2283.cpp | 17 +++++++++++++++++ src/2293.cpp | 17 +++++++++++++++++ src/2299.cpp | 27 +++++++++++++++++++++++++++ src/2303.cpp | 19 +++++++++++++++++++ src/2309.cpp | 19 +++++++++++++++++++ src/2315.cpp | 26 ++++++++++++++++++++++++++ src/2319.cpp | 21 +++++++++++++++++++++ src/2325.cpp | 27 +++++++++++++++++++++++++++ src/2331.cpp | 10 ++++++++++ 9 files changed, 183 insertions(+) create mode 100644 src/2283.cpp create mode 100644 src/2293.cpp create mode 100644 src/2299.cpp create mode 100644 src/2303.cpp create mode 100644 src/2309.cpp create mode 100644 src/2315.cpp create mode 100644 src/2319.cpp create mode 100644 src/2325.cpp create mode 100644 src/2331.cpp diff --git a/src/2283.cpp b/src/2283.cpp new file mode 100644 index 0000000..a51d69a --- /dev/null +++ b/src/2283.cpp @@ -0,0 +1,17 @@ +bool digitCount(string num) { + int arr[10] = {0}; + int len = num.size(); + + for (int i = 0; i < len; ++i) + { + arr[num[i]-'0']++; + } + + for (int i = 0; i < len; ++i) + { + if (arr[i] != num[i]-'0') + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/2293.cpp b/src/2293.cpp new file mode 100644 index 0000000..129bbbb --- /dev/null +++ b/src/2293.cpp @@ -0,0 +1,17 @@ +int minMaxGame(vector& nums) { + int len = nums.size(); + while (len != 1) + { + int n = len/2; + for (int i = 0; i < n; ++i) + { + if (i%2 == 0) + nums[i] = min(nums[i*2], nums[i*2+1]); + else + nums[i] = max(nums[i*2], nums[i*2+1]); + } + len /= 2; + } + + return nums[0]; + } \ No newline at end of file diff --git a/src/2299.cpp b/src/2299.cpp new file mode 100644 index 0000000..edaae39 --- /dev/null +++ b/src/2299.cpp @@ -0,0 +1,27 @@ +bool strongPasswordCheckerII(string password) { + string special = "!@#$%^&*()-+"; + int len = password.size(); + if (len < 8) + return false; + int lowernum = 0, uppernum = 0, digitnum = 0, specialnum = 0; + char last = password[0]; + for (int i = 0; i < len; ++i) + { + if (password[i] >= 'a' && password[i] <='z') + ++lowernum; + else if (password[i] >= 'A' && password[i] <= 'Z') + ++uppernum; + else if (password[i] >= '0' && password[i] <= '9') + ++digitnum; + else if (special.find(password[i]) != string::npos) + ++specialnum; + if (i >= 1) + { + if (password[i] == last) + return false; + last = password[i]; + } + } + + return lowernum >= 1 && uppernum >= 1 && digitnum >= 1 && specialnum >= 1; + } \ No newline at end of file diff --git a/src/2303.cpp b/src/2303.cpp new file mode 100644 index 0000000..27373a0 --- /dev/null +++ b/src/2303.cpp @@ -0,0 +1,19 @@ +double calculateTax(vector>& brackets, int income) { + int len = brackets.size(); + double taxes = 0; + int last = 0; + + for (int i = 0; i < len; ++i) + { + int num = brackets[i][0]-last; + double val = num < income ? num : income; + taxes += val*brackets[i][1]/100; + + if (income <= num) + break; + income -= num; + last = brackets[i][0]; + } + + return taxes; + } \ No newline at end of file diff --git a/src/2309.cpp b/src/2309.cpp new file mode 100644 index 0000000..ed18f02 --- /dev/null +++ b/src/2309.cpp @@ -0,0 +1,19 @@ +string greatestLetter(string s) { + char digitnum[52] = {0}; + int len = s.size(); + + for (int i = 0; i < len; ++i) + { + if (s[i] >= 'a' && s[i] <= 'z') + digitnum[s[i]-'a'] = 1; + else + digitnum[s[i]-'A'+26] = 1; + } + for (int i = 25; i >= 0; --i) + { + if (digitnum[i] == 1 && digitnum[i+26] == 1) + return string(1,'A'+i); + } + + return ""; + } \ No newline at end of file diff --git a/src/2315.cpp b/src/2315.cpp new file mode 100644 index 0000000..f3d4769 --- /dev/null +++ b/src/2315.cpp @@ -0,0 +1,26 @@ +int countAsterisks(string s) { + int len = s.size(); + int i = 0; + int ct = 0; + bool flag = false; + + while (i < len) + { + if (flag == false) + { + if (s[i] == '*') + ++ct; + else if (s[i] == '|') + flag = true; + ++i; + } + else + { + if (s[i] == '|') + flag = false; + ++i; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2319.cpp b/src/2319.cpp new file mode 100644 index 0000000..6477c73 --- /dev/null +++ b/src/2319.cpp @@ -0,0 +1,21 @@ +bool checkXMatrix(vector>& grid) { + int n = grid.size(); + for (int i = 0; i < n; ++i) + { + for (int j = 0; j < n; ++j) + { + if(i == j || i+j == n-1) + { + if(grid[i][j] == 0) + return false; + } + else + { + if(grid[i][j] != 0) + return false; + } + } + } + + return true; + } \ No newline at end of file diff --git a/src/2325.cpp b/src/2325.cpp new file mode 100644 index 0000000..59f4e9b --- /dev/null +++ b/src/2325.cpp @@ -0,0 +1,27 @@ +string decodeMessage(string key, string message) { + array transTb{}; + array flag{}; + + int len = key.size(); + int j = 0; + for (int i = 0; i < len; ++i) + { + if(key[i] != ' ' && flag[key[i]-'a'] == false) + { + transTb[key[i]-'a'] = 'a'+j; + flag[key[i]-'a'] = true; + ++j; + if(j == 26) + break; + } + } + + int mlen = message.size(); + for (int i = 0; i < mlen; ++i) + { + if(message[i] != ' ') + message[i] = transTb[message[i]-'a']; + } + + return move(message); + } \ No newline at end of file diff --git a/src/2331.cpp b/src/2331.cpp new file mode 100644 index 0000000..de25409 --- /dev/null +++ b/src/2331.cpp @@ -0,0 +1,10 @@ +bool evaluateTree(TreeNode* root) { + if (root->val == 0) + return false; + else if (root->val == 1) + return true; + else if (root->val == 2) + return evaluateTree(root->left) || evaluateTree(root->right); + else + return evaluateTree(root->left) && evaluateTree(root->right); + } \ No newline at end of file From d64563eb72e52338d10ac7347b2efdd767c8ac67 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 14 Aug 2022 11:15:25 +0800 Subject: [PATCH 85/97] 6 problems solved. --- src/2265.cpp | 25 +++++++++++++++++++++++++ src/2341.cpp | 16 ++++++++++++++++ src/2347.cpp | 25 +++++++++++++++++++++++++ src/2351.cpp | 17 +++++++++++++++++ src/2363.cpp | 22 ++++++++++++++++++++++ src/2367.cpp | 27 +++++++++++++++++++++++++++ 6 files changed, 132 insertions(+) create mode 100644 src/2265.cpp create mode 100644 src/2341.cpp create mode 100644 src/2347.cpp create mode 100644 src/2351.cpp create mode 100644 src/2363.cpp create mode 100644 src/2367.cpp diff --git a/src/2265.cpp b/src/2265.cpp new file mode 100644 index 0000000..6081001 --- /dev/null +++ b/src/2265.cpp @@ -0,0 +1,25 @@ +int averageOfSubtree(TreeNode* root) { + if (root == nullptr) + return 0; + + int ct = 0; + int n = 0; + search(root, n, ct); + + return ct; + } + + int search(TreeNode* node, int& n, int& ct) + { + int sum = node->val; + int p = 0, q = 0; + if(node->left != nullptr) + sum += search(node->left, p, ct); + if(node->right != nullptr) + sum += search(node->right, q, ct); + + if(sum/(p+q+1) == node->val) + ++ct; + n = p+q+1; + return sum; + } \ No newline at end of file diff --git a/src/2341.cpp b/src/2341.cpp new file mode 100644 index 0000000..f7ffa7b --- /dev/null +++ b/src/2341.cpp @@ -0,0 +1,16 @@ +vector numberOfPairs(vector& nums) { + int arr[101] = {0}; + int len = nums.size(); + + for (int i = 0; i < len; ++i) + arr[nums[i]]++; + + vector res(2, 0); + for (int i = 0; i < 101; ++i) + { + res[0] += arr[i]/2; + res[1] += arr[i]%2; + } + + return res; + } \ No newline at end of file diff --git a/src/2347.cpp b/src/2347.cpp new file mode 100644 index 0000000..9df9ddb --- /dev/null +++ b/src/2347.cpp @@ -0,0 +1,25 @@ +string bestHand(vector& ranks, vector& suits) { + int nrank[14] = {0}; + char suit = suits[0]; + int n = 0, maxnum = 0; + + for (int i = 0; i < 5; ++i) + { + if (suits[i] == suit) + ++n; + nrank[ranks[i]]++; + if (maxnum < 2 && nrank[ranks[i]] == 2) + maxnum = 2; + else if (nrank[ranks[i]] == 3) + maxnum = 3; + } + + if (n == 5) + return "Flush"; + else if (maxnum == 3) + return "Three of a Kind"; + else if (maxnum == 2) + return "Pair"; + else + return "High Card"; + } \ No newline at end of file diff --git a/src/2351.cpp b/src/2351.cpp new file mode 100644 index 0000000..e8f7fc1 --- /dev/null +++ b/src/2351.cpp @@ -0,0 +1,17 @@ +char repeatedCharacter(string s) { + int num[26] = {0}; + int len = s.size(); + + char c; + for (int i = 0; i < len; ++i) + { + if (num[s[i]-'a'] == 1) + { + c = s[i]; + break; + } + ++num[s[i]-'a']; + } + + return c; + } \ No newline at end of file diff --git a/src/2363.cpp b/src/2363.cpp new file mode 100644 index 0000000..c0aca63 --- /dev/null +++ b/src/2363.cpp @@ -0,0 +1,22 @@ +vector> mergeSimilarItems(vector>& items1, vector>& items2) { + int len1 = items1.size(); + int len2 = items2.size(); + + map mp; + for (int i = 0; i < len1; ++i) + mp[items1[i][0]] += items1[i][1]; + for (int i = 0; i < len2; ++i) + mp[items2[i][0]] += items2[i][1]; + + int sz = mp.size(); + int k = 0; + vector> res(sz, vector(2, 0)); + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + { + res[k][0] = iter->first; + res[k][1] = iter->second; + ++k; + } + + return res; + } \ No newline at end of file diff --git a/src/2367.cpp b/src/2367.cpp new file mode 100644 index 0000000..fbce900 --- /dev/null +++ b/src/2367.cpp @@ -0,0 +1,27 @@ +int arithmeticTriplets(vector& nums, int diff) { + int len = nums.size(); + int ct = 0; + for (int i = 0; i < len-2; ++i) + { + for (int j = i+1; j < len-1; ++j) + { + if(diff == nums[j]-nums[i]) + { + for (int k = j+1; k < len; ++k) + { + if (nums[k]-nums[j] == diff) + { + ++ct; + break; + } + else if(nums[k]-nums[j] > diff) + break; + } + } + else if(nums[j]-nums[i] > diff) + break; + } + } + + return ct; + } \ No newline at end of file From fb3318f437056c6770b1ffb40963d4961a39693b Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 17 Sep 2022 20:07:48 +0800 Subject: [PATCH 86/97] 6 problems solved. --- src/2336.cpp | 35 +++++++++++++++++++++++++++++++++++ src/2373.cpp | 24 ++++++++++++++++++++++++ src/2390.cpp | 26 ++++++++++++++++++++++++++ src/2399.cpp | 18 ++++++++++++++++++ src/2404.cpp | 29 +++++++++++++++++++++++++++++ src/2405.cpp | 23 +++++++++++++++++++++++ 6 files changed, 155 insertions(+) create mode 100644 src/2336.cpp create mode 100644 src/2373.cpp create mode 100644 src/2390.cpp create mode 100644 src/2399.cpp create mode 100644 src/2404.cpp create mode 100644 src/2405.cpp diff --git a/src/2336.cpp b/src/2336.cpp new file mode 100644 index 0000000..52cd591 --- /dev/null +++ b/src/2336.cpp @@ -0,0 +1,35 @@ +class SmallestInfiniteSet { +public: + SmallestInfiniteSet() { + for(int i = 0; i < 1001; ++i) + arr[i] = 1; + curSmallest = 1; + } + + int popSmallest() { + int rt = curSmallest; + arr[curSmallest] = 0; + for(int i = rt+1; i <= 1000; ++i) + { + if(arr[i] == 1) + { + curSmallest = i; + break; + } + } + + return rt; + } + + void addBack(int num) { + if(num <= 1000 && arr[num] == 0) + { + arr[num] = 1; + if(num < curSmallest) + curSmallest = num; + } + } +private: + int arr[1001]; + int curSmallest; +}; \ No newline at end of file diff --git a/src/2373.cpp b/src/2373.cpp new file mode 100644 index 0000000..c735d4b --- /dev/null +++ b/src/2373.cpp @@ -0,0 +1,24 @@ +vector> largestLocal(vector>& grid) { + int row = grid.size(); + int n = row-2; + vector> res(n, vector(n, 0)); + + for (int i = 1; i < row-1; ++i) + { + for (int j = 1; j < row-1; ++j) + { + int maxvalue = 0; + for (int p = i-1; p <= i+1; ++p) + { + for (int q = j-1; q <= j+1; ++q) + { + if (grid[p][q] > maxvalue) + maxvalue = grid[p][q]; + } + } + res[i-1][j-1] = maxvalue; + } + } + + return res; + } \ No newline at end of file diff --git a/src/2390.cpp b/src/2390.cpp new file mode 100644 index 0000000..6c5db42 --- /dev/null +++ b/src/2390.cpp @@ -0,0 +1,26 @@ +string removeStars(string s) { + int len = s.size(); + string res(len, ' '); + + int i = 0, j = 0; + while (i < len) + { + if(s[i] != '*') + { + res[j++] = s[i]; + } + else + { + if(j > 0) + { + --j; + } + } + + ++i; + } + + res.resize(j); + + return res; + } \ No newline at end of file diff --git a/src/2399.cpp b/src/2399.cpp new file mode 100644 index 0000000..174fbe3 --- /dev/null +++ b/src/2399.cpp @@ -0,0 +1,18 @@ +bool checkDistances(string s, vector& distance) { + int len = s.size(); + vector indexarr(26, -1); + for (int i = 0; i < len; ++i) + { + if (indexarr[s[i]-'a'] == -1) + { + indexarr[s[i]-'a'] = i; + } + else + { + if ((abs(indexarr[s[i]-'a']-i)-1) != distance[s[i]-'a']) + return false; + } + } + + return true; + } \ No newline at end of file diff --git a/src/2404.cpp b/src/2404.cpp new file mode 100644 index 0000000..d07ee08 --- /dev/null +++ b/src/2404.cpp @@ -0,0 +1,29 @@ +int mostFrequentEven(vector& nums) { + int len = nums.size(); + map mp; + + for (int i = 0; i < len; ++i) + { + if (nums[i]%2 == 0) + mp[nums[i]]++; + } + + int maxnum = 0, val = 0; + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + { + if (iter->second > maxnum) + { + maxnum = iter->second; + val = iter->first; + } + else if (iter->second == maxnum && iter->first < val) + { + val = iter->first; + } + } + + if (maxnum == 0) + return -1; + else + return val; + } \ No newline at end of file diff --git a/src/2405.cpp b/src/2405.cpp new file mode 100644 index 0000000..b892693 --- /dev/null +++ b/src/2405.cpp @@ -0,0 +1,23 @@ +int partitionString(string s) { + int len = s.size(); + int i = 0; + int ct = 0; + + while (i < len) + { + vector flag(26, 0); + ++ct; + while (i < len) + { + if (flag[s[i]-'a'] == 0) + { + flag[s[i]-'a'] = 1; + ++i; + } + else + break; + } + } + + return ct; + } \ No newline at end of file From 518fc7b02826434cfa1b21aa7d2a51c8fe16857a Mon Sep 17 00:00:00 2001 From: Troy Date: Tue, 4 Oct 2022 18:23:35 +0800 Subject: [PATCH 87/97] 8 problems solved. --- src/2409.cpp | 40 ++++++++++++++++++++++++++++ src/2413.cpp | 6 +++++ src/2414.cpp | 28 ++++++++++++++++++++ src/2415.cpp | 43 ++++++++++++++++++++++++++++++ src/2418.cpp | 16 +++++++++++ src/2423.cpp | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/2427.cpp | 18 +++++++++++++ src/2428.cpp | 19 +++++++++++++ 8 files changed, 245 insertions(+) create mode 100644 src/2409.cpp create mode 100644 src/2413.cpp create mode 100644 src/2414.cpp create mode 100644 src/2415.cpp create mode 100644 src/2418.cpp create mode 100644 src/2423.cpp create mode 100644 src/2427.cpp create mode 100644 src/2428.cpp diff --git a/src/2409.cpp b/src/2409.cpp new file mode 100644 index 0000000..d84d483 --- /dev/null +++ b/src/2409.cpp @@ -0,0 +1,40 @@ +int countDaysTogether(string arriveAlice, string leaveAlice, string arriveBob, string leaveBob) { + int accum[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334}; + + int m1 = (arriveAlice[0]-'0')*10 + (arriveAlice[1]-'0')-1; + int d1 = (arriveAlice[3]-'0')*10 + (arriveAlice[4]-'0'); + int m2 = (leaveAlice[0]-'0')*10 + (leaveAlice[1]-'0')-1; + int d2 = (leaveAlice[3]-'0')*10 + (leaveAlice[4]-'0'); + int m3 = (arriveBob[0]-'0')*10 + (arriveBob[1]-'0')-1; + int d3 = (arriveBob[3]-'0')*10 + (arriveBob[4]-'0'); + int m4 = (leaveBob[0]-'0')*10 + (leaveBob[1]-'0')-1; + int d4 = (leaveBob[3]-'0')*10 + (leaveBob[4]-'0'); + + int start1 = accum[m1]+d1, end1 = accum[m2]+d2; + int start2 = accum[m3]+d3, end2 = accum[m4]+d4; + + if (start1 < start2) + { + if (start2 <= end1) + { + if (end1 < end2) + return end1-start2+1; + else + return end2-start2+1; + } + else + return 0; + } + else + { + if (start1 <= end2) + { + if (end2 < end1) + return end2-start1+1; + else + return end1-start1+1; + } + else + return 0; + } + } \ No newline at end of file diff --git a/src/2413.cpp b/src/2413.cpp new file mode 100644 index 0000000..063b88d --- /dev/null +++ b/src/2413.cpp @@ -0,0 +1,6 @@ +int smallestEvenMultiple(int n) { + if (n%2 == 0) + return n; + else + return 2*n; + } \ No newline at end of file diff --git a/src/2414.cpp b/src/2414.cpp new file mode 100644 index 0000000..6230d8b --- /dev/null +++ b/src/2414.cpp @@ -0,0 +1,28 @@ +int longestContinuousSubstring(string s) { + int len = s.size(); + + int i = 1; + int maxlen = 1, n = 1; + char c = s[0]; + + while (i < len) + { + if (s[i] == c+1) + { + ++n; + } + else + { + if (n > maxlen) + maxlen = n; + n = 1; + } + c = s[i]; + ++i; + } + + if (n > maxlen) + maxlen = n; + + return maxlen; + } \ No newline at end of file diff --git a/src/2415.cpp b/src/2415.cpp new file mode 100644 index 0000000..8aea412 --- /dev/null +++ b/src/2415.cpp @@ -0,0 +1,43 @@ +TreeNode* reverseOddLevels(TreeNode* root) { + deque dq; + dq.push_back(root); + + bool flag = true; + + while (!dq.empty()) + { + int n = dq.size(); + int ct = 0; + for (int i = 0; i < n; ++i) + { + TreeNode* node = dq[i]; + if (node->left != nullptr) + { + dq.push_back(node->left); + dq.push_back(node->right); + ct += 2; + } + } + + if (ct > 0) + { + if (flag) + { + int lim = ct/2; + for (int i = 0; i < lim; ++i) + { + int tmp = dq[n+i]->val; + dq[n+i]->val = dq[n+ct-1-i]->val; + dq[n+ct-1-i]->val = tmp; + } + } + + flag = !flag; + dq.erase(dq.begin(), dq.begin()+n); + } + else + break; + } + + return root; + } \ No newline at end of file diff --git a/src/2418.cpp b/src/2418.cpp new file mode 100644 index 0000000..b8bb181 --- /dev/null +++ b/src/2418.cpp @@ -0,0 +1,16 @@ +vector sortPeople(vector& names, vector& heights) { + int len = names.size(); + vector res(len, ""); + + map mp; + for (int i = 0; i < len; ++i) + { + mp[heights[i]] = names[i]; + } + + int k = 0; + for (auto iter = mp.rbegin(); iter != mp.rend(); ++iter) + res[k++] = iter->second; + + return res; + } \ No newline at end of file diff --git a/src/2423.cpp b/src/2423.cpp new file mode 100644 index 0000000..ff1b2c3 --- /dev/null +++ b/src/2423.cpp @@ -0,0 +1,75 @@ +bool equalFrequency(string word) { + int len = word.size(); + int arr[26] = {0}; + + for (int i = 0; i < len; ++i) + { + arr[word[i]-'a']++; + } + + int v1 = 0, v2 = 0; + int n1 = 0, n2 = 0; + + for (int i = 0; i < 26; ++i) + { + if (arr[i] != 0) + { + if (v1 == 0) + { + v1 = arr[i]; + } + else if (v2 == 0 && v1 != arr[i]) + { + v2 = arr[i]; + } + else if (v2 != 0 && v1 != arr[i] && v2 != arr[i]) + return false; + } + } + + if (v1 == 1 && v2 == 0) + return true; + + for (int i = 0; i < 26; ++i) + { + if (arr[i] != 0) + { + if (arr[i] == v1) + ++n1; + if (arr[i] == v2) + ++n2; + } + } + + if (n2 == 0) + { + if (n1 == 1) + return true; + else + return false; + } + + if (n1 != 1 && n2 != 1) + return false; + else if (n1 == 1 && n2 != 1) + { + if (v1 == 1 || v1-v2 == 1) + return true; + else + return false; + } + else if (n1 != 1 && n2 == 1) + { + if (v2 == 1 || v2-v1 == 1) + return true; + else + return false; + } + else + { + if (v1 == 1 || v2 == 1 || abs(v1-v2) == 1) + return true; + else + return false; + } + } \ No newline at end of file diff --git a/src/2427.cpp b/src/2427.cpp new file mode 100644 index 0000000..08d4b07 --- /dev/null +++ b/src/2427.cpp @@ -0,0 +1,18 @@ +int commonFactors(int a, int b) { + int c; + if (a < b) + c = a; + else + c = b; + + int lim = sqrt(c); + int ct = 1; + + for (int i = 2; i <= c; ++i) + { + if ((a%i == 0) && (b%i == 0)) + ++ct; + } + + return ct; + } \ No newline at end of file diff --git a/src/2428.cpp b/src/2428.cpp new file mode 100644 index 0000000..16e6edd --- /dev/null +++ b/src/2428.cpp @@ -0,0 +1,19 @@ +int maxSum(vector>& grid) { + int row = grid.size(); + int col = grid[0].size(); + + int maxsum = 0, sum = 0; + + for (int r = 0; r < row-2; ++r) + { + for (int c = 0; c < col-2; ++c) + { + sum = grid[r][c]+grid[r][c+1]+grid[r][c+2]+grid[r+1][c+1]+ + grid[r+2][c]+grid[r+2][c+1]+grid[r+2][c+2]; + if (sum > maxsum) + maxsum = sum; + } + } + + return maxsum; + } \ No newline at end of file From bbae6de0c61f5ff147fd6d1d472ff2b42cb9a535 Mon Sep 17 00:00:00 2001 From: Troy Date: Sun, 13 Nov 2022 20:23:03 +0800 Subject: [PATCH 88/97] 7 problems solved. --- src/2441.cpp | 17 ++++++++++++++ src/2446.cpp | 3 +++ src/2451.cpp | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/2455.cpp | 17 ++++++++++++++ src/2456.cpp | 36 ++++++++++++++++++++++++++++++ src/2460.cpp | 23 +++++++++++++++++++ src/2469.cpp | 3 +++ 7 files changed, 162 insertions(+) create mode 100644 src/2441.cpp create mode 100644 src/2446.cpp create mode 100644 src/2451.cpp create mode 100644 src/2455.cpp create mode 100644 src/2456.cpp create mode 100644 src/2460.cpp create mode 100644 src/2469.cpp diff --git a/src/2441.cpp b/src/2441.cpp new file mode 100644 index 0000000..823c7d3 --- /dev/null +++ b/src/2441.cpp @@ -0,0 +1,17 @@ +int findMaxK(vector& nums) { + int len = nums.size(); + sort(nums.begin(), nums.end()); + + int i = 0, j = len-1; + while (i < j) + { + if (nums[i] == -nums[j]) + return nums[j]; + else if (-nums[i] < nums[j]) + --j; + else + ++i; + } + + return -1; + } \ No newline at end of file diff --git a/src/2446.cpp b/src/2446.cpp new file mode 100644 index 0000000..be04a21 --- /dev/null +++ b/src/2446.cpp @@ -0,0 +1,3 @@ +bool haveConflict(vector& event1, vector& event2) { + return !((event2[0] > event1[1]) || (event2[1] < event1[0])); + } \ No newline at end of file diff --git a/src/2451.cpp b/src/2451.cpp new file mode 100644 index 0000000..c0e6fef --- /dev/null +++ b/src/2451.cpp @@ -0,0 +1,63 @@ +string oddString(vector& words) { + int len = words.size(); + int n = words[0].size(); + int i = 0; + + vector> diffarr(2, vector(n, 0)); + for (i = 0; i < 2; ++i) + { + for (int j = 1; j < n; ++j) + { + diffarr[i][j-1] = (int)words[i][j] - (int)words[i][j-1]; + } + } + + bool flag = false; + int pos = 0; + for (i = 0; i < n-1; ++i) + { + if (diffarr[0][i] != diffarr[1][i]) + { + flag = true; + break; + } + } + + if (flag) + { + for (int j = 1; j < n; ++j) + { + int tmp = (int)words[2][j] - (int)words[2][j-1]; + if (tmp != diffarr[0][j-1]) + { + pos = 0; + break; + } + if (tmp != diffarr[1][j-1]) + { + pos = 1; + break; + } + } + + return words[pos]; + } + else + { + for (i = 2; i < len; ++i) + { + for (int j = 1; j < n; ++j) + { + int tmp = (int)words[i][j] - (int)words[i][j-1]; + if (tmp != diffarr[0][j-1]) + { + pos = i; + i = len; + break; + } + } + } + + return words[pos]; + } + } \ No newline at end of file diff --git a/src/2455.cpp b/src/2455.cpp new file mode 100644 index 0000000..f2e67aa --- /dev/null +++ b/src/2455.cpp @@ -0,0 +1,17 @@ +int averageValue(vector& nums) { + int len = nums.size(); + int ct = 0, sum = 0; + for (int i = 0; i < len; ++i) + { + if (nums[i]%6 == 0) + { + sum += nums[i]; + ++ct; + } + } + + if (ct != 0) + return sum/ct; + else + return 0; + } \ No newline at end of file diff --git a/src/2456.cpp b/src/2456.cpp new file mode 100644 index 0000000..bd683cc --- /dev/null +++ b/src/2456.cpp @@ -0,0 +1,36 @@ +vector> mostPopularCreator(vector& creators, vector& ids, vector& views) { + int len = creators.size(); + map> mp; + + long long maxview = 0; + for (int i = 0; i < len; ++i) + { + if (views[i] > get<1>(mp[creators[i]])) + { + get<1>(mp[creators[i]]) = views[i]; + get<2>(mp[creators[i]]) = ids[i]; + } + else if (views[i] == get<1>(mp[creators[i]])) + { + if (get<2>(mp[creators[i]]) == "") + get<2>(mp[creators[i]]) = ids[i]; + else if (ids[i] < get<2>(mp[creators[i]])) + get<2>(mp[creators[i]]) = ids[i]; + + } + get<0>(mp[creators[i]]) += views[i]; + if (get<0>(mp[creators[i]]) > maxview) + maxview = get<0>(mp[creators[i]]); + } + + vector> res; + for (auto iter = mp.begin(); iter != mp.end(); ++iter) + { + if (get<0>(iter->second) == maxview) + { + res.push_back({iter->first, get<2>(iter->second)}); + } + } + + return res; + } \ No newline at end of file diff --git a/src/2460.cpp b/src/2460.cpp new file mode 100644 index 0000000..890fb41 --- /dev/null +++ b/src/2460.cpp @@ -0,0 +1,23 @@ +vector applyOperations(vector& nums) { + int len = nums.size(); + int i = 0; + while (i < len-1) + { + if (nums[i] == nums[i+1]) + { + nums[i] *= 2; + nums[i+1] = 0; + } + ++i; + } + + i = 0; + vector res(len, 0); + for (int j = 0; j < len; ++j) + { + if(nums[j] != 0) + res[i++] = nums[j]; + } + + return res; + } \ No newline at end of file diff --git a/src/2469.cpp b/src/2469.cpp new file mode 100644 index 0000000..7bcfb3f --- /dev/null +++ b/src/2469.cpp @@ -0,0 +1,3 @@ +vector convertTemperature(double celsius) { + return {celsius+273.15, celsius*1.8+32}; + } \ No newline at end of file From 091b974efaec6bedb2e00fac293af088a0e06ba2 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 3 Dec 2022 15:08:22 +0800 Subject: [PATCH 89/97] 6 problems solved. --- src/2437.cpp | 39 +++++++++++++++++++++++++++++++++++++++ src/2475.cpp | 18 ++++++++++++++++++ src/2482.cpp | 34 ++++++++++++++++++++++++++++++++++ src/2483.cpp | 27 +++++++++++++++++++++++++++ src/2485.cpp | 8 ++++++++ src/2486.cpp | 21 +++++++++++++++++++++ 6 files changed, 147 insertions(+) create mode 100644 src/2437.cpp create mode 100644 src/2475.cpp create mode 100644 src/2482.cpp create mode 100644 src/2483.cpp create mode 100644 src/2485.cpp create mode 100644 src/2486.cpp diff --git a/src/2437.cpp b/src/2437.cpp new file mode 100644 index 0000000..bf768c0 --- /dev/null +++ b/src/2437.cpp @@ -0,0 +1,39 @@ +int countTime(string time) { + int sum = 0; + if (time[0] == '?') + { + if (time[1] == '?') + sum = 24; + else if (time[1] < '4') + sum = 3; + else + sum = 2; + } + else + { + if (time[1] == '?') + { + if (time[0] != '2') + sum = 10; + else + sum = 4; + } + else + sum = 1; + } + + if (time[3] == '?') + { + if (time[4] == '?') + sum *= 60; + else + sum *= 6; + } + else + { + if (time[4] == '?') + sum *= 10; + } + + return sum; + } \ No newline at end of file diff --git a/src/2475.cpp b/src/2475.cpp new file mode 100644 index 0000000..a0f75ae --- /dev/null +++ b/src/2475.cpp @@ -0,0 +1,18 @@ +int unequalTriplets(vector& nums) { + int len = nums.size(); + int ct = 0; + + for (int i = 0; i < len-2; ++i) + { + for (int j = i+1; j < len-1; ++j) + { + for (int k = j+1; k < len; ++k) + { + if (nums[i] != nums[j] && nums[i] != nums[k] && nums[j] != nums[k]) + ++ct; + } + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2482.cpp b/src/2482.cpp new file mode 100644 index 0000000..5ca0926 --- /dev/null +++ b/src/2482.cpp @@ -0,0 +1,34 @@ +vector> onesMinusZeros(vector>& grid) { + int m = grid.size(); + int n = grid[0].size(); + + vector onesRow(m, 0); + vector zerosRow(m, 0); + vector onesCol(n, 0); + vector zerosCol(n, 0); + for (int i = 0; i < m; ++i) + { + for (int j = 0; j < n; ++j) + { + if (grid[i][j] == 1) + { + onesRow[i]++; + onesCol[j]++; + } + else + { + zerosRow[i]++; + zerosCol[j]++; + } + } + } + + vector> diff(m, vector(n, 0)); + for (int i = 0; i < m; ++i) + { + for (int j = 0; j < n; ++j) + diff[i][j] = onesRow[i] + onesCol[j] - zerosRow[i] - zerosCol[j]; + } + + return diff; + } \ No newline at end of file diff --git a/src/2483.cpp b/src/2483.cpp new file mode 100644 index 0000000..e7a8a38 --- /dev/null +++ b/src/2483.cpp @@ -0,0 +1,27 @@ +int bestClosingTime(string customers) { + int len = customers.size(); + + int minpenalty = 0; + for (int i = 0; i < len; ++i) + { + if (customers[i] != 'N') + ++minpenalty; + } + + int penalty = minpenalty; + int h = len; + for (int i = len-1; i >= 0; --i) + { + if (customers[i] == 'Y') + ++penalty; + else + --penalty; + if (penalty <= minpenalty) + { + minpenalty = penalty; + h = i; + } + } + + return h; + } \ No newline at end of file diff --git a/src/2485.cpp b/src/2485.cpp new file mode 100644 index 0000000..625e9ed --- /dev/null +++ b/src/2485.cpp @@ -0,0 +1,8 @@ +int pivotInteger(int n) { + int sum = (n*n+n)/2; + int lim = sqrt(sum); + if (lim*lim == sum) + return lim; + else + return -1; + } \ No newline at end of file diff --git a/src/2486.cpp b/src/2486.cpp new file mode 100644 index 0000000..3a03452 --- /dev/null +++ b/src/2486.cpp @@ -0,0 +1,21 @@ +int appendCharacters(string s, string t) { + int len1 = s.size(); + int len2 = t.size(); + + int i = 0, j = 0; + while (i < len1 && j < len2) + { + if (s[i] == t[j]) + { + ++i; + ++j; + } + else + ++i; + } + + if (j == len2) + return 0; + else + return len2-j; + } \ No newline at end of file From 2e0f1876bf18cd0e17f6fed872d824e00b4a2420 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 17 Dec 2022 20:41:58 +0800 Subject: [PATCH 90/97] 6 problems solved. --- src/2407.cpp | 18 +++++++++++++ src/2491.cpp | 21 +++++++++++++++ src/2492.cpp | 17 +++++++++++++ src/2497.cpp | 36 ++++++++++++++++++++++++++ src/2501.cpp | 22 ++++++++++++++++ src/63.cpp | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 186 insertions(+) create mode 100644 src/2407.cpp create mode 100644 src/2491.cpp create mode 100644 src/2492.cpp create mode 100644 src/2497.cpp create mode 100644 src/2501.cpp create mode 100644 src/63.cpp diff --git a/src/2407.cpp b/src/2407.cpp new file mode 100644 index 0000000..58ba2a3 --- /dev/null +++ b/src/2407.cpp @@ -0,0 +1,18 @@ +int countDistinctIntegers(vector& nums) { + set st; + int len = nums.size(); + for (int i = 0; i < len; ++i) + { + st.insert(nums[i]); + int val = 0; + int tmp = nums[i]; + while (tmp != 0) + { + val = val*10 + tmp%10; + tmp /= 10; + } + st.insert(val); + } + + return st.size(); + } \ No newline at end of file diff --git a/src/2491.cpp b/src/2491.cpp new file mode 100644 index 0000000..4a6b787 --- /dev/null +++ b/src/2491.cpp @@ -0,0 +1,21 @@ +bool isCircularSentence(string sentence) { + int len = sentence.size(); + char first = sentence[0], last = sentence[0]; + int i = 1; + + while (i < len) + { + if (sentence[i] == ' ') + { + last = sentence[i-1]; + if (sentence[i+1] != last) + return false; + else + ++i; + } + else + ++i; + } + + return sentence[i-1] == first; + } \ No newline at end of file diff --git a/src/2492.cpp b/src/2492.cpp new file mode 100644 index 0000000..578c3be --- /dev/null +++ b/src/2492.cpp @@ -0,0 +1,17 @@ +long long dividePlayers(vector& skill) { + int len = skill.size(); + sort(skill.begin(), skill.end()); + + int n = len/2; + int v = skill[0] + skill[len-1]; + long long sum = skill[0] * skill[len-1]; + for (int i = 1; i < n; ++i) + { + if (skill[i] + skill[len-1-i] != v) + return -1; + else + sum += skill[i] * skill[len-1-i]; + } + + return sum; + } \ No newline at end of file diff --git a/src/2497.cpp b/src/2497.cpp new file mode 100644 index 0000000..b076614 --- /dev/null +++ b/src/2497.cpp @@ -0,0 +1,36 @@ +int maximumValue(vector& strs) { + int len = strs.size(); + int maxval = 0; + for (int i = 0; i < len; ++i) + { + int n = strs[i].size(); + bool flag = false; + int j = 0; + int val = 0; + while (j < n) + { + if (isdigit(strs[i][j])) + val = val*10 + (strs[i][j]-'0'); + else + { + flag = true; + break; + } + ++j; + } + + if (flag) + { + if (n > maxval) + maxval = n; + } + else + { + if (val > maxval) + maxval = val; + } + cout << val << endl; + } + + return maxval; + } \ No newline at end of file diff --git a/src/2501.cpp b/src/2501.cpp new file mode 100644 index 0000000..4cdf665 --- /dev/null +++ b/src/2501.cpp @@ -0,0 +1,22 @@ +int deleteGreatestValue(vector>& grid) { + int m = grid.size(); + int n = grid[0].size(); + + for (int i = 0; i < m; ++i) + sort(grid[i].begin(), grid[i].end()); + + int sum = 0; + for (int i = n-1; i >= 0; --i) + { + int maxval = 0; + for (int j = 0; j < m; ++j) + { + if (grid[j][i] > maxval) + maxval = grid[j][i]; + } + + sum += maxval; + } + + return sum; + } \ No newline at end of file diff --git a/src/63.cpp b/src/63.cpp new file mode 100644 index 0000000..5d0205e --- /dev/null +++ b/src/63.cpp @@ -0,0 +1,72 @@ +int uniquePathsWithObstacles(vector>& obstacleGrid) { + int row = obstacleGrid.size(); + int col = obstacleGrid[0].size(); + + if (row == 1 && col == 1) + { + return obstacleGrid[0][0] == 0 ? 1 : 0; + } + + vector> dp(row, vector(col, 0)); + int r = 0, c = 0; + while (r < row) + { + if (obstacleGrid[r][0] == 0) + { + dp[r][0] = 1; + ++r; + } + else + { + while (r < row) + { + dp[r][0] = -1; + ++r; + } + } + } + + while (c < col) + { + if (obstacleGrid[0][c] == 0) + { + dp[0][c] = 1; + ++c; + } + else + { + while (c < col) + { + dp[0][c] = -1; + ++c; + } + } + } + + r = 1; + while (r < row) + { + c = 1; + while (c < col) + { + if (obstacleGrid[r][c] == 0) + { + if (dp[r-1][c] == -1 && dp[r][c-1] == -1) + dp[r][c] = -1; + else + { + if (dp[r-1][c] != -1) + dp[r][c] += dp[r-1][c]; + if (dp[r][c-1] != -1) + dp[r][c] += dp[r][c-1]; + } + } + else + dp[r][c] = -1; + ++c; + } + ++r; + } + + return dp[row-1][col-1] > 0 ? dp[row-1][col-1] : 0; + } \ No newline at end of file From a05fcbeefaadc4be19827669207572ea668ac8b9 Mon Sep 17 00:00:00 2001 From: Troy Date: Sat, 11 Feb 2023 19:42:07 +0800 Subject: [PATCH 91/97] 9 problems solved. --- src/2506.cpp | 41 +++++++++++++++++++++++++++++++++++++++++ src/2515.cpp | 25 +++++++++++++++++++++++++ src/2520.cpp | 13 +++++++++++++ src/2529.cpp | 6 ++++++ src/2535.cpp | 17 +++++++++++++++++ src/2544.cpp | 20 ++++++++++++++++++++ src/2549.cpp | 6 ++++++ src/2553.cpp | 14 ++++++++++++++ src/2558.cpp | 28 ++++++++++++++++++++++++++++ 9 files changed, 170 insertions(+) create mode 100644 src/2506.cpp create mode 100644 src/2515.cpp create mode 100644 src/2520.cpp create mode 100644 src/2529.cpp create mode 100644 src/2535.cpp create mode 100644 src/2544.cpp create mode 100644 src/2549.cpp create mode 100644 src/2553.cpp create mode 100644 src/2558.cpp diff --git a/src/2506.cpp b/src/2506.cpp new file mode 100644 index 0000000..c19f178 --- /dev/null +++ b/src/2506.cpp @@ -0,0 +1,41 @@ +int similarPairs(vector& words) { + int len = words.size(); + vector> letters(len, vector(27, 0)); + + for (int i = 0; i < len; ++i) + { + int n = words[i].size(); + for (int j = 0; j < n; ++j) + { + if (letters[i][words[i][j]-'a'] == 0) + { + letters[i][words[i][j]-'a'] = 1; + letters[i][26]++; + } + } + } + + int ct = 0; + for (int i = 0; i < len-1; ++i) + { + for (int j = i+1; j < len; ++j) + { + if (letters[i][26] == letters[j][26]) + { + bool flag = true; + for (int k = 0; k < 26; ++k) + { + if (letters[i][k] != letters[j][k]) + { + flag = false; + break; + } + } + if (flag) + ++ct; + } + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2515.cpp b/src/2515.cpp new file mode 100644 index 0000000..d25e3b9 --- /dev/null +++ b/src/2515.cpp @@ -0,0 +1,25 @@ +int closetTarget(vector& words, string target, int startIndex) { + int len = words.size(); + int i = startIndex; + int mindist = len; + int n = 0; + + while (n < len) + { + if (words[i] == target) + { + int dist1 = abs(i-startIndex); + int dist2 = len-dist1; + if (dist1 < mindist) + mindist = dist1; + if (dist2 < mindist) + mindist = dist2; + } + ++i; + ++n; + if (i == len) + i = 0; + } + + return mindist != len ? mindist : -1; + } \ No newline at end of file diff --git a/src/2520.cpp b/src/2520.cpp new file mode 100644 index 0000000..070a816 --- /dev/null +++ b/src/2520.cpp @@ -0,0 +1,13 @@ +int countDigits(int num) { + int ct = 0; + int val = num; + while (val != 0) + { + int t = val%10; + if (t != 0 && num%t == 0) + ++ct; + val /= 10; + } + + return ct; + } \ No newline at end of file diff --git a/src/2529.cpp b/src/2529.cpp new file mode 100644 index 0000000..ada8070 --- /dev/null +++ b/src/2529.cpp @@ -0,0 +1,6 @@ +int maximumCount(vector& nums) { + int pos = nums.end() - upper_bound(nums.begin(), nums.end(), 0); + int neg = lower_bound(nums.begin(), nums.end(), 0) - nums.begin(); + + return pos > neg ? pos : neg; + } \ No newline at end of file diff --git a/src/2535.cpp b/src/2535.cpp new file mode 100644 index 0000000..830220b --- /dev/null +++ b/src/2535.cpp @@ -0,0 +1,17 @@ +int differenceOfSum(vector& nums) { + int elesum = 0, digitsum = 0; + int len = nums.size(); + + for (int i = 0; i < len; ++i) + { + elesum += nums[i]; + int tmp = nums[i]; + while (tmp != 0) + { + digitsum += tmp%10; + tmp /= 10; + } + } + + return abs(elesum - digitsum); + } \ No newline at end of file diff --git a/src/2544.cpp b/src/2544.cpp new file mode 100644 index 0000000..373ef14 --- /dev/null +++ b/src/2544.cpp @@ -0,0 +1,20 @@ +int alternateDigitSum(int n) { + int sum = 0; + int m = log10(n); + const bool arr[10] = {true, false, true, false, true, false, true, false, true, false}; + bool flag = arr[m]; + + while (n != 0) + { + int tmp = n%10; + if (flag) + sum += tmp; + else + sum -= tmp; + flag = !flag; + + n /= 10; + } + + return sum; + } \ No newline at end of file diff --git a/src/2549.cpp b/src/2549.cpp new file mode 100644 index 0000000..b425aca --- /dev/null +++ b/src/2549.cpp @@ -0,0 +1,6 @@ +int distinctIntegers(int n) { + if (n < 3) + return 1; + else + return n-1; + } \ No newline at end of file diff --git a/src/2553.cpp b/src/2553.cpp new file mode 100644 index 0000000..7ea62b1 --- /dev/null +++ b/src/2553.cpp @@ -0,0 +1,14 @@ +vector separateDigits(vector& nums) { + list tmplist; + int len = nums.size(); + for (int i = len-1; i >= 0; --i) + { + while (nums[i] != 0) + { + tmplist.push_front(nums[i]%10); + nums[i] /= 10; + } + } + + return vector(tmplist.begin(), tmplist.end()); + } \ No newline at end of file diff --git a/src/2558.cpp b/src/2558.cpp new file mode 100644 index 0000000..53283ea --- /dev/null +++ b/src/2558.cpp @@ -0,0 +1,28 @@ +long long pickGifts(vector& gifts, int k) { + int len = gifts.size(); + long long sum = 0; + for (int i = 0; i < len; ++i) + sum += gifts[i]; + + for (int i = 0; i < k; ++i) + { + int index = 0; + int maxval = 0; + for (int j = 0; j < len; ++j) + { + if (gifts[j] > maxval) + { + index = j; + maxval = gifts[j]; + } + } + + int r = sqrt(maxval); + if (r == maxval) + break; + sum -= gifts[index]-r; + gifts[index] = r; + } + + return sum; + } \ No newline at end of file From 6a8b705c3f2a92f17b9c8b7e7e98f7a8d15c766d Mon Sep 17 00:00:00 2001 From: Troy Date: Tue, 4 Apr 2023 21:41:49 +0800 Subject: [PATCH 92/97] 6 problems solved. --- src/2540.cpp | 27 +++++++++++++++++++++++++++ src/2562.cpp | 18 ++++++++++++++++++ src/2570.cpp | 39 +++++++++++++++++++++++++++++++++++++++ src/2574.cpp | 18 ++++++++++++++++++ src/2586.cpp | 13 +++++++++++++ src/2595.cpp | 13 +++++++++++++ 6 files changed, 128 insertions(+) create mode 100644 src/2540.cpp create mode 100644 src/2562.cpp create mode 100644 src/2570.cpp create mode 100644 src/2574.cpp create mode 100644 src/2586.cpp create mode 100644 src/2595.cpp diff --git a/src/2540.cpp b/src/2540.cpp new file mode 100644 index 0000000..7046927 --- /dev/null +++ b/src/2540.cpp @@ -0,0 +1,27 @@ +int getCommon(vector& nums1, vector& nums2) { + int len1 = nums1.size(), len2 = nums2.size(); + int i = 0, j = 0; + while (i < len1 && j < len2) + { + if (nums1[i] == nums2[j]) + return nums1[i]; + else if (nums1[i] < nums2[j]) + ++i; + else + ++j; + } + + while (i < len1 && nums1[i] < nums2[len2-1]) + ++i; + while (j < len2 && nums2[j] < nums1[len1-1]) + ++j; + + if (i == len1 || nums1[i] > nums2[len2-1]) + return -1; + else if (j == len2 || nums2[j] > nums1[len1-1]) + return -1; + else if (i < len1) + return nums2[len2-1]; + else + return nums1[len1-1]; + } \ No newline at end of file diff --git a/src/2562.cpp b/src/2562.cpp new file mode 100644 index 0000000..df3ca22 --- /dev/null +++ b/src/2562.cpp @@ -0,0 +1,18 @@ +long long findTheArrayConcVal(vector& nums) { + int len = nums.size(); + int lim = len/2; + long long concatsum = 0; + + const long long coeff[] = {10, 100, 1000, 10000, 100000}; + + for (int i = 0; i < lim; ++i) + { + int n = log10(nums[len-1-i]); + concatsum += nums[i]*coeff[n] + nums[len-1-i]; + } + + if (len%2 != 0) + concatsum += nums[lim]; + + return concatsum; + } \ No newline at end of file diff --git a/src/2570.cpp b/src/2570.cpp new file mode 100644 index 0000000..9a85e14 --- /dev/null +++ b/src/2570.cpp @@ -0,0 +1,39 @@ +vector> mergeArrays(vector>& nums1, vector>& nums2) { + int len1 = nums1.size(); + int len2 = nums2.size(); + int i = 0, j = 0; + + vector> res; + while (i < len1 && j < len2) + { + if (nums1[i][0] == nums2[j][0]) + { + res.push_back({nums1[i][0], nums1[i][1]+nums2[j][1]}); + ++i; + ++j; + } + else if (nums1[i][0] < nums2[j][0]) + { + res.push_back(nums1[i]); + ++i; + } + else + { + res.push_back(nums2[j]); + ++j; + } + } + + while (i < len1) + { + res.push_back(nums1[i]); + ++i; + } + while (j < len2) + { + res.push_back(nums2[j]); + ++j; + } + + return res; + } \ No newline at end of file diff --git a/src/2574.cpp b/src/2574.cpp new file mode 100644 index 0000000..8679018 --- /dev/null +++ b/src/2574.cpp @@ -0,0 +1,18 @@ +vector leftRigthDifference(vector& nums) { + int len = nums.size(); + int sum = 0; + + vector leftsum(len, 0); + vector res(len, 0); + for (int i = 0; i < len; ++i) + { + leftsum[i] = sum; + sum += nums[i]; + } + for (int i = 0; i < len; ++i) + { + res[i] = abs(leftsum[i]-(sum-leftsum[i]-nums[i])); + } + + return res; + } \ No newline at end of file diff --git a/src/2586.cpp b/src/2586.cpp new file mode 100644 index 0000000..b5d4fd8 --- /dev/null +++ b/src/2586.cpp @@ -0,0 +1,13 @@ +int vowelStrings(vector& words, int left, int right) { + int ct = 0; + for (int i = left; i <= right; ++i) + { + char s = words[i][0], e = *words[i].rbegin(); + if ((s == 'a' || s == 'e' || s == 'i' || + s == 'o' || s == 'u') && (e == 'a' || e == 'e' || + e == 'i' || e == 'o' || e == 'u')) + ++ct; + } + + return ct; + } \ No newline at end of file diff --git a/src/2595.cpp b/src/2595.cpp new file mode 100644 index 0000000..e4f8a23 --- /dev/null +++ b/src/2595.cpp @@ -0,0 +1,13 @@ +vector evenOddBit(int n) { + vector res(2, 0); + int i = 0; + + while (n != 0) + { + res[i] += n & 0x1; + i = 1-i; + n >>= 1; + } + + return res; + } \ No newline at end of file From f7a2ebf3f508006a9dc2d01163aea24b6f3d1d02 Mon Sep 17 00:00:00 2001 From: Troy Date: Tue, 6 Jun 2023 22:31:12 +0800 Subject: [PATCH 93/97] 8 problems solved. --- src/2639.cpp | 26 ++++++++++++++++++++++++++ src/2643.cpp | 22 ++++++++++++++++++++++ src/2651.cpp | 3 +++ src/2652.cpp | 12 ++++++++++++ src/2678.cpp | 11 +++++++++++ src/2706.cpp | 28 ++++++++++++++++++++++++++++ src/2710.cpp | 11 +++++++++++ src/2716.cpp | 13 +++++++++++++ 8 files changed, 126 insertions(+) create mode 100644 src/2639.cpp create mode 100644 src/2643.cpp create mode 100644 src/2651.cpp create mode 100644 src/2652.cpp create mode 100644 src/2678.cpp create mode 100644 src/2706.cpp create mode 100644 src/2710.cpp create mode 100644 src/2716.cpp diff --git a/src/2639.cpp b/src/2639.cpp new file mode 100644 index 0000000..e2d33db --- /dev/null +++ b/src/2639.cpp @@ -0,0 +1,26 @@ +vector findColumnWidth(vector>& grid) { + int row = grid.size(); + int col = grid[0].size(); + + vector res(col, 0); + for (int i = 0; i < col; ++i) + { + int maxlen = 0; + for (int j = 0; j < row; ++j) + { + int n = 1; + if (grid[j][i] != 0) + { + n = log10(abs(grid[j][i]))+1; + if (grid[j][i] < 0) + ++n; + } + if (n > maxlen) + maxlen = n; + } + + res[i] = maxlen; + } + + return res; + } \ No newline at end of file diff --git a/src/2643.cpp b/src/2643.cpp new file mode 100644 index 0000000..97d3b8c --- /dev/null +++ b/src/2643.cpp @@ -0,0 +1,22 @@ +vector rowAndMaximumOnes(vector>& mat) { + int row = mat.size(); + int col = mat[0].size(); + + vector res(2, 0); + for (int r = 0; r < row; ++r) + { + int ct = 0; + for (int c = 0; c < col; ++c) + { + if (mat[r][c] == 1) + ++ct; + } + if (ct > res[1]) + { + res[0] = r; + res[1] = ct; + } + } + + return res; + } \ No newline at end of file diff --git a/src/2651.cpp b/src/2651.cpp new file mode 100644 index 0000000..7fed89f --- /dev/null +++ b/src/2651.cpp @@ -0,0 +1,3 @@ + int findDelayedArrivalTime(int arrivalTime, int delayedTime) { + return (arrivalTime + delayedTime) % 24; + } \ No newline at end of file diff --git a/src/2652.cpp b/src/2652.cpp new file mode 100644 index 0000000..76ede1e --- /dev/null +++ b/src/2652.cpp @@ -0,0 +1,12 @@ +int sumOfMultiples(int n) { + const int arr[7] = {n/3, n/5, n/7, n/15, n/21, n/35, n/105}; + int sum1 = 3*arr[0] + arr[0]*(arr[0]-1)*3/2; + int sum2 = 5*arr[1] + arr[1]*(arr[1]-1)*5/2; + int sum3 = 7*arr[2] + arr[2]*(arr[2]-1)*7/2; + int sum4 = 15*arr[3] + arr[3]*(arr[3]-1)*15/2; + int sum5 = 21*arr[4] + arr[4]*(arr[4]-1)*21/2; + int sum6 = 35*arr[5] + arr[5]*(arr[5]-1)*35/2; + int sum7 = 105*arr[6] + arr[6]*(arr[6]-1)*105/2; + + return sum1+sum2+sum3-sum4-sum5-sum6+sum7; + } \ No newline at end of file diff --git a/src/2678.cpp b/src/2678.cpp new file mode 100644 index 0000000..836dc38 --- /dev/null +++ b/src/2678.cpp @@ -0,0 +1,11 @@ +int countSeniors(vector& details) { + int ct = 0; + int len = details.size(); + for (int i = 0; i < len; ++i) + { + if ((details[i][11] > '6') || (details[i][11] == '6' && details[i][12] > '0')) + ++ct; + } + + return ct; + } \ No newline at end of file diff --git a/src/2706.cpp b/src/2706.cpp new file mode 100644 index 0000000..084d4ea --- /dev/null +++ b/src/2706.cpp @@ -0,0 +1,28 @@ +int buyChoco(vector& prices, int money) { + int minprice1 = 101; + int minprice2 = 101; + int len = prices.size(); + + for (int i = 0; i < len; ++i) + { + if (minprice1 == 101) + { + if (prices[i] < minprice1) + minprice1 = prices[i]; + } + else if (prices[i] < minprice1) + { + minprice2 = minprice1; + minprice1 = prices[i]; + } + else if (prices[i] < minprice2) + { + minprice2 = prices[i]; + } + } + + if (minprice1 + minprice2 <= money) + return money - minprice1 - minprice2; + else + return money; + } \ No newline at end of file diff --git a/src/2710.cpp b/src/2710.cpp new file mode 100644 index 0000000..08852f1 --- /dev/null +++ b/src/2710.cpp @@ -0,0 +1,11 @@ +string removeTrailingZeros(string num) { + int len = num.size(); + int i; + for (i = len-1; i >= 0; --i) + { + if (num[i] != '0') + break; + } + + return num.substr(0, i+1); + } \ No newline at end of file diff --git a/src/2716.cpp b/src/2716.cpp new file mode 100644 index 0000000..5b5ff2e --- /dev/null +++ b/src/2716.cpp @@ -0,0 +1,13 @@ +int minimizedStringLength(string s) { + char arr[26] = {0}; + int len = s.size(); + int ct = 0; + for (int i = 0; i < len; ++i) + { + arr[s[i]-'a']++; + if (arr[s[i]-'a'] == 1) + ++ct; + } + + return ct; + } \ No newline at end of file From 384f316b5e713c0e15943cb4de6cf91ab0ff5881 Mon Sep 17 00:00:00 2001 From: Troy Date: Fri, 7 Jul 2023 21:01:01 +0800 Subject: [PATCH 94/97] 5 problems solved. --- src/2729.cpp | 20 ++++++++++++++++++++ src/2733.cpp | 47 +++++++++++++++++++++++++++++++++++++++++++++++ src/2744.cpp | 25 +++++++++++++++++++++++++ src/2745.cpp | 5 +++++ src/2748.cpp | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 145 insertions(+) create mode 100644 src/2729.cpp create mode 100644 src/2733.cpp create mode 100644 src/2744.cpp create mode 100644 src/2745.cpp create mode 100644 src/2748.cpp diff --git a/src/2729.cpp b/src/2729.cpp new file mode 100644 index 0000000..806f10d --- /dev/null +++ b/src/2729.cpp @@ -0,0 +1,20 @@ +bool isFascinating(int n) { + if (n > 333) + return false; + string s1 = to_string(n); + string s2 = to_string(n*2); + string s3 = to_string(n*3); + + int arr[11] = {0}; + for (int i = 0; i < 3; ++i) + { + arr[s1[i]-'0']++; + arr[s2[i]-'0']++; + arr[s3[i]-'0']++; + if (arr[s1[i]-'0'] > 1 || arr[s2[i]-'0'] > 1 || arr[s3[i]-'0'] > 1 + || s1[i]-'0' == 0 || s2[i]-'0' == 0 || s3[i]-'0' == 0) + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/2733.cpp b/src/2733.cpp new file mode 100644 index 0000000..6589f7c --- /dev/null +++ b/src/2733.cpp @@ -0,0 +1,47 @@ +int findNonMinOrMax(vector& nums) { + int len = nums.size(); + if (len <= 2) + return -1; + + int minval = 101, maxval = 0; + int ct = 0; + int res = 0; + + for (int i = 0; i < len; ++i) + { + if (nums[i] < minval) + { + if (minval != 101) + { + ++ct; + if (ct == 2) + { + res = minval; + break; + } + } + minval = nums[i]; + } + if (nums[i] > maxval) + { + if (maxval != 0) + { + ++ct; + if (ct == 2) + { + res = maxval; + break; + } + } + maxval = nums[i]; + } + + if (nums[i] != minval && nums[i] != maxval) + { + res = nums[i]; + break; + } + } + + return res; + } \ No newline at end of file diff --git a/src/2744.cpp b/src/2744.cpp new file mode 100644 index 0000000..f2e5111 --- /dev/null +++ b/src/2744.cpp @@ -0,0 +1,25 @@ +int maximumNumberOfStringPairs(vector& words) { + int len = words.size(); + int ct = 0; + vector flag(len, 0); + + for (int i = 0; i < len-1; ++i) + { + if (flag[i] == 1) + continue; + for (int j = i+1; j < len; ++j) + { + if (flag[i] == 0) + { + if (words[i][0] == words[j][1] && words[i][1] == words[j][0]) + { + ++ct; + flag[i] = 1; + flag[j] = 1; + } + } + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2745.cpp b/src/2745.cpp new file mode 100644 index 0000000..212a211 --- /dev/null +++ b/src/2745.cpp @@ -0,0 +1,5 @@ +int longestString(int x, int y, int z) { + int common = x < y ? x : y; + int diff = x > common ? 1 : (y > common ? 1 : 0); + return (common*2 + diff + z) * 2; + } \ No newline at end of file diff --git a/src/2748.cpp b/src/2748.cpp new file mode 100644 index 0000000..f8d0d44 --- /dev/null +++ b/src/2748.cpp @@ -0,0 +1,48 @@ +int countBeautifulPairs(vector& nums) { + int len = nums.size(); + int ct = 0; + vector> digits(len, {0,0}); + + for (int i = 0; i != len; ++i) + { + int x = nums[i]%10; + int y = nums[i]; + while (y >= 10) + { + y /= 10; + } + digits[i][1] = x; + digits[i][0] = y; + if (x%2 == 0) + digits[i][1] = 2; + if (x%3 == 0) + digits[i][1] = 3; + if (x == 6) + digits[i][1] = 6; + if (y%2 == 0) + digits[i][0] = 2; + if (y%3 == 0) + digits[i][0] = 3; + if (y == 6) + digits[i][0] = 6; + } + + for (int i = 0; i < len-1; ++i) + { + for (int j = i+1; j < len; ++j) + { + if ((digits[i][0] == 2 && digits[j][1] == 2) || (digits[i][0] == 2 && digits[j][1] == 6)) + ; + else if ((digits[i][0] == 3 && digits[j][1] == 3) || (digits[i][0] == 3 && digits[j][1] == 6)) + ; + else if ((digits[i][0] == 6 && digits[j][1] == 2) || (digits[i][0] == 6 && digits[j][1] == 3) || (digits[i][0] == 6 && digits[j][1] == 6)) + ; + else if ((digits[i][0] == digits[j][1]) && digits[i][0] != 1) + ; + else + ++ct; + } + } + + return ct; + } \ No newline at end of file From a8462540b3f4a25a5761cb1caebfbe56a14adddf Mon Sep 17 00:00:00 2001 From: Troy Date: Thu, 3 Oct 2024 19:36:08 +0800 Subject: [PATCH 95/97] 30 problems solved --- src/2769.cpp | 3 ++ src/2798.cpp | 10 +++++++ src/2824.cpp | 14 +++++++++ src/2828.cpp | 14 +++++++++ src/2833.cpp | 13 +++++++++ src/2848.cpp | 28 ++++++++++++++++++ src/2859.cpp | 20 +++++++++++++ src/2864.cpp | 18 ++++++++++++ src/2894.cpp | 16 +++++++++++ src/2928.cpp | 19 +++++++++++++ src/2942.cpp | 12 ++++++++ src/2951.cpp | 11 ++++++++ src/2956.cpp | 31 ++++++++++++++++++++ src/2960.cpp | 14 +++++++++ src/2965.cpp | 24 ++++++++++++++++ src/2974.cpp | 13 +++++++++ src/3005.cpp | 26 +++++++++++++++++ src/3042.cpp | 26 +++++++++++++++++ src/3090.cpp | 27 ++++++++++++++++++ src/3110.cpp | 11 ++++++++ src/3210.cpp | 10 +++++++ src/3232.cpp | 13 +++++++++ src/3238.cpp | 23 +++++++++++++++ src/3242.cpp | 80 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/3248.cpp | 28 ++++++++++++++++++ src/3270.cpp | 19 +++++++++++++ src/3274.cpp | 6 ++++ src/3280.cpp | 24 ++++++++++++++++ src/3285.cpp | 12 ++++++++ src/3289.cpp | 15 ++++++++++ 30 files changed, 580 insertions(+) create mode 100644 src/2769.cpp create mode 100644 src/2798.cpp create mode 100644 src/2824.cpp create mode 100644 src/2828.cpp create mode 100644 src/2833.cpp create mode 100644 src/2848.cpp create mode 100644 src/2859.cpp create mode 100644 src/2864.cpp create mode 100644 src/2894.cpp create mode 100644 src/2928.cpp create mode 100644 src/2942.cpp create mode 100644 src/2951.cpp create mode 100644 src/2956.cpp create mode 100644 src/2960.cpp create mode 100644 src/2965.cpp create mode 100644 src/2974.cpp create mode 100644 src/3005.cpp create mode 100644 src/3042.cpp create mode 100644 src/3090.cpp create mode 100644 src/3110.cpp create mode 100644 src/3210.cpp create mode 100644 src/3232.cpp create mode 100644 src/3238.cpp create mode 100644 src/3242.cpp create mode 100644 src/3248.cpp create mode 100644 src/3270.cpp create mode 100644 src/3274.cpp create mode 100644 src/3280.cpp create mode 100644 src/3285.cpp create mode 100644 src/3289.cpp diff --git a/src/2769.cpp b/src/2769.cpp new file mode 100644 index 0000000..5dd5f43 --- /dev/null +++ b/src/2769.cpp @@ -0,0 +1,3 @@ +int theMaximumAchievableX(int num, int t) { + return num + (t << 1); + } \ No newline at end of file diff --git a/src/2798.cpp b/src/2798.cpp new file mode 100644 index 0000000..2fd378f --- /dev/null +++ b/src/2798.cpp @@ -0,0 +1,10 @@ +int numberOfEmployeesWhoMetTarget(vector& hours, int target) { + int n = hours.size(), ct = 0; + for (int i = 0; i < n; ++i) + { + if (hours[i] >= target) + ++ct; + } + + return ct; + } \ No newline at end of file diff --git a/src/2824.cpp b/src/2824.cpp new file mode 100644 index 0000000..81389c5 --- /dev/null +++ b/src/2824.cpp @@ -0,0 +1,14 @@ +int countPairs(vector& nums, int target) { + int len = nums.size(); + int ct = 0; + for (int i = 0; i < len-1; ++i) + { + for (int j = i+1; j < len; ++j) + { + if (nums[i]+nums[j] < target) + ++ct; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2828.cpp b/src/2828.cpp new file mode 100644 index 0000000..ef2b1c0 --- /dev/null +++ b/src/2828.cpp @@ -0,0 +1,14 @@ +bool isAcronym(vector& words, string s) { + int len = words.size(); + int sz = s.size(); + if (len != sz) + return false; + + for (int i = 0; i < len; ++i) + { + if(words[i][0] != s[i]) + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/2833.cpp b/src/2833.cpp new file mode 100644 index 0000000..e81b89f --- /dev/null +++ b/src/2833.cpp @@ -0,0 +1,13 @@ +int furthestDistanceFromOrigin(string moves) { + int nl = 0, nr = 0; + int len = moves.size(); + for (int i = 0; i < len; ++i) + { + if (moves[i] == 'L') + ++nl; + if (moves[i] == 'R') + ++nr; + } + + return abs(nl-nr) + len-nl-nr; + } \ No newline at end of file diff --git a/src/2848.cpp b/src/2848.cpp new file mode 100644 index 0000000..3fb2f2e --- /dev/null +++ b/src/2848.cpp @@ -0,0 +1,28 @@ +int numberOfPoints(vector>& nums) { + auto cmp = [](const vector& a, const vector& b){ + return (a[0]& nums, int k) { + int len = nums.size(); + int sum = 0; + int i = pow(2, k)-1; + for (; i < len; ++i) + { + int tmp = i; + int ct = 0; + while (tmp != 0) + { + if((tmp & 0x1) != 0) + ++ct; + tmp >>= 1; + } + if(ct == k) + sum += nums[i]; + } + + return sum; + } \ No newline at end of file diff --git a/src/2864.cpp b/src/2864.cpp new file mode 100644 index 0000000..4bcd458 --- /dev/null +++ b/src/2864.cpp @@ -0,0 +1,18 @@ + string maximumOddBinaryNumber(string s) { + int len = s.size(); + string res(len, '0'); + + int ct = 0; + for (int i = 0; i < len; ++i) + { + if(s[i] == '1') + ++ct; + } + res[len-1] = '1'; + for (int i = 1; i < ct; ++i) + { + res[i-1] = '1'; + } + + return res; + } \ No newline at end of file diff --git a/src/2894.cpp b/src/2894.cpp new file mode 100644 index 0000000..bc49eb3 --- /dev/null +++ b/src/2894.cpp @@ -0,0 +1,16 @@ +int differenceOfSums(int n, int m) { + int res = (1+n)*n/2; + if (m > n) + return res; + int v = n, sum = 0; + while (v%m != 0) + --v; + while (v > 0) + { + res -= v; + sum += v; + v -= m; + } + + return res-sum; + } \ No newline at end of file diff --git a/src/2928.cpp b/src/2928.cpp new file mode 100644 index 0000000..58ae1b0 --- /dev/null +++ b/src/2928.cpp @@ -0,0 +1,19 @@ +int distributeCandies(int n, int limit) { + int ct = 0; + for (int i = 0; i <= n; ++i) + { + if (i > limit) + break; + for (int j = 0; j <= n-i; ++j) + { + if (j > limit) + break; + if (n-i-j > limit) + continue; + else + ++ct; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/2942.cpp b/src/2942.cpp new file mode 100644 index 0000000..9276ca5 --- /dev/null +++ b/src/2942.cpp @@ -0,0 +1,12 @@ +vector findWordsContaining(vector& words, char x) { + int len = words.size(); + vector res; + + for (int i = 0; i < len; ++i) + { + if (words[i].find(x) != string::npos) + res.push_back(i); + } + + return res; + } \ No newline at end of file diff --git a/src/2951.cpp b/src/2951.cpp new file mode 100644 index 0000000..7a20234 --- /dev/null +++ b/src/2951.cpp @@ -0,0 +1,11 @@ +vector findPeaks(vector& mountain) { + vector res; + int len = mountain.size(); + for (int i = 1; i < len-1; ++i) + { + if (mountain[i] > mountain[i-1] && mountain[i] > mountain[i+1]) + res.push_back(i); + } + + return res; + } \ No newline at end of file diff --git a/src/2956.cpp b/src/2956.cpp new file mode 100644 index 0000000..a5173ee --- /dev/null +++ b/src/2956.cpp @@ -0,0 +1,31 @@ +vector findIntersectionValues(vector& nums1, vector& nums2) { + int n = nums1.size(); + int m = nums2.size(); + sort(nums1.begin(), nums1.end()); + sort(nums2.begin(), nums2.end()); + + int i = 0, j = 0; + int a = 0, b = 0; + while (i < n && j < m) + { + if (nums1[i] < nums2[j]) + ++i; + else if(nums1[i] > nums2[j]) + ++j; + else + { + while (i < n && nums1[i] == nums2[j]) + { + ++a; + ++i; + } + while (j < m && nums1[i-1] == nums2[j]) + { + ++b; + ++j; + } + } + } + + return {a, b}; + } \ No newline at end of file diff --git a/src/2960.cpp b/src/2960.cpp new file mode 100644 index 0000000..cb40487 --- /dev/null +++ b/src/2960.cpp @@ -0,0 +1,14 @@ +int countTestedDevices(vector& batteryPercentages) { + int n = batteryPercentages.size(); + int m = 0; + + for (int i = 0; i < n; ++i) + { + if (batteryPercentages[i] > m) + { + ++m; + } + } + + return m; + } \ No newline at end of file diff --git a/src/2965.cpp b/src/2965.cpp new file mode 100644 index 0000000..777ad86 --- /dev/null +++ b/src/2965.cpp @@ -0,0 +1,24 @@ +vector findMissingAndRepeatedValues(vector>& grid) { + int n = grid.size(); + int m = n*n+1; + int a, b; + vector vec(m, 0); + + for (int r = 0; r < n; ++r) + { + for (int c = 0; c < n; ++c) + { + vec[grid[r][c]]++; + } + } + + for (int i = 1; i < m; ++i) + { + if (vec[i] == 2) + a = i; + if (vec[i] == 0) + b = i; + } + + return {a, b}; + } \ No newline at end of file diff --git a/src/2974.cpp b/src/2974.cpp new file mode 100644 index 0000000..7feb9ae --- /dev/null +++ b/src/2974.cpp @@ -0,0 +1,13 @@ +vector numberGame(vector& nums) { + int len = nums.size(); + sort(nums.begin(), nums.end()); + vector res(len, 0); + + for (int i = 0; i < len/2; ++i) + { + res[i*2] = nums[i*2+1]; + res[i*2+1] = nums[i*2]; + } + + return res; + } \ No newline at end of file diff --git a/src/3005.cpp b/src/3005.cpp new file mode 100644 index 0000000..1ed79fc --- /dev/null +++ b/src/3005.cpp @@ -0,0 +1,26 @@ +int maxFrequencyElements(vector& nums) { + int freq[101] = {0}; + int len = nums.size(); + + for (int i = 0; i < len; ++i) + { + freq[nums[i]]++; + } + + int maxfreq = 0; + int ct = 0; + for (int i = 0; i < 101; ++i) + { + if (freq[i] > maxfreq) + { + maxfreq = freq[i]; + ct = 1; + } + else if (maxfreq > 0 && freq[i] == maxfreq) + { + ++ct; + } + } + + return ct*maxfreq; + } \ No newline at end of file diff --git a/src/3042.cpp b/src/3042.cpp new file mode 100644 index 0000000..8b1b407 --- /dev/null +++ b/src/3042.cpp @@ -0,0 +1,26 @@ + int countPrefixSuffixPairs(vector& words) { + int len = words.size(); + int i, j, k, ct = 0; + + for (i = 0; i < len-1; ++i) + { + int len1 = words[i].size(); + for (j = i+1; j < len; ++j) + { + int len2 = words[j].size(); + if (len1 > len2) + continue; + for (k = 0; k < len1; ++k) + { + if (words[i][k] != words[j][k] || + words[i][k] != words[j][len2-1-(len1-1-k)]) + break; + } + + if (k == len1) + ++ct; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/3090.cpp b/src/3090.cpp new file mode 100644 index 0000000..066cd67 --- /dev/null +++ b/src/3090.cpp @@ -0,0 +1,27 @@ +int maximumLengthSubstring(string s) { + size_t len {s.size()}; + size_t i = 0, j = 1, maxlength = 0; + int arr[26] = {0}; + + arr[s[i]-'a']++; + + while (j < len) + { + if (arr[s[j]-'a'] == 2) + { + if (j-i > maxlength) + maxlength = j-i; + arr[s[i]-'a']--; + ++i; + } + else + { + arr[s[j]-'a']++; + ++j; + } + } + if (j-i > maxlength) + maxlength = j-i; + + return maxlength; + } \ No newline at end of file diff --git a/src/3110.cpp b/src/3110.cpp new file mode 100644 index 0000000..694e7c8 --- /dev/null +++ b/src/3110.cpp @@ -0,0 +1,11 @@ +int scoreOfString(string s) { + int len = s.size(); + int sum = 0; + + for (int i = 1; i < len; ++i) + { + sum += abs(s[i]-s[i-1]); + } + + return sum; + } \ No newline at end of file diff --git a/src/3210.cpp b/src/3210.cpp new file mode 100644 index 0000000..60d6987 --- /dev/null +++ b/src/3210.cpp @@ -0,0 +1,10 @@ +string getEncryptedString(string s, int k) { + int len = s.size(); + if (k%len == 0) + return s; + else + { + int p = k%len; + return s.substr(p) + s.substr(0, p); + } + } \ No newline at end of file diff --git a/src/3232.cpp b/src/3232.cpp new file mode 100644 index 0000000..8aa39ce --- /dev/null +++ b/src/3232.cpp @@ -0,0 +1,13 @@ +bool canAliceWin(vector& nums) { + int len = nums.size(); + int oddsum = 0, evensum = 0; + for (int i = 0; i < len; ++i) + { + if (nums[i] < 10) + oddsum += nums[i]; + else + evensum += nums[i]; + } + + return oddsum != evensum; + } \ No newline at end of file diff --git a/src/3238.cpp b/src/3238.cpp new file mode 100644 index 0000000..c376a59 --- /dev/null +++ b/src/3238.cpp @@ -0,0 +1,23 @@ +int winningPlayerCount(int n, vector>& pick) { + vector> nums(10, vector(11,0)); + + int len = pick.size(); + for (int i = 0; i < len; ++i) + { + nums[pick[i][0]][pick[i][1]]++; + } + int sum = 0; + for (int i = 0; i < n; ++i) + { + for (int j = 0; j < 11; ++j) + { + if (nums[i][j] > i) + { + ++sum; + break; + } + } + } + + return sum; + } \ No newline at end of file diff --git a/src/3242.cpp b/src/3242.cpp new file mode 100644 index 0000000..c8ec28d --- /dev/null +++ b/src/3242.cpp @@ -0,0 +1,80 @@ +class NeighborSum { +public: + NeighborSum(vector>& grid) { + n = grid.size(); + pos.assign(n*n, pair(-1,-1)); + for (int i = 0; i < n; ++i) + { + elems.push_back(grid[i]); + } + } + + int adjacentSum(int value) { + int r = -1, c = -1; + if (pos[value].first != -1) + { + r = pos[value].first; + c = pos[value].second; + } + else + { + getPos(value); + r = pos[value].first; + c = pos[value].second; + } + + int sum = 0; + if (r > 0) sum += elems[r-1][c]; + if (r < n-1) sum += elems[r+1][c]; + if (c > 0) sum += elems[r][c-1]; + if (c < n-1) sum += elems[r][c+1]; + + return sum; + } + + int diagonalSum(int value) { + int r = -1, c = -1; + if (pos[value].first != -1) + { + r = pos[value].first; + c = pos[value].second; + } + else + { + getPos(value); + r = pos[value].first; + c = pos[value].second; + } + + int sum = 0; + if (r > 0 && c > 0) sum += elems[r-1][c-1]; + if (r > 0 && c < n-1) sum += elems[r-1][c+1]; + if (r < n-1 && c > 0) sum += elems[r+1][c-1]; + if (r < n-1 && c < n-1) sum += elems[r+1][c+1]; + + return sum; + } + +private: + vector> elems; + vector> pos; + int n; + + void getPos(int value) + { + int r = -1, c = -1; + + for (int i = 0; r==-1 && i < n; ++i) + { + for (int j = 0; j < n; ++j) + if (elems[i][j] == value) + { + r = i; + c = j; + pos[value].first = r; + pos[value].second = c; + break; + } + } + } +}; \ No newline at end of file diff --git a/src/3248.cpp b/src/3248.cpp new file mode 100644 index 0000000..886514e --- /dev/null +++ b/src/3248.cpp @@ -0,0 +1,28 @@ +int finalPositionOfSnake(int n, vector& commands) { + int len = commands.size(); + int r = 0, c = 0; + map mp{{"UP", 0}, {"RIGHT", 1}, {"DOWN", 2}, {"LEFT", 3}}; + + for (int i = 0; i < len; ++i) + { + switch (mp[commands[i]]) + { + case 0: + r -= 1; + break; + case 1: + c += 1; + break; + case 2: + r += 1; + break; + case 3: + c -= 1; + break; + default: + break; + } + } + + return r*n + c; + } \ No newline at end of file diff --git a/src/3270.cpp b/src/3270.cpp new file mode 100644 index 0000000..fbfcfbb --- /dev/null +++ b/src/3270.cpp @@ -0,0 +1,19 @@ +int generateKey(int num1, int num2, int num3) { + int i = 0, k = 1, res = 0; + while (i < 4) + { + int r1 = num1%10; + int r2 = num2%10; + int r3 = num3%10; + + int tmp = r1 < r2 ? (r1 < r3 ? r1 : r3) : (r2 < r3 ? r2 : r3); + res += tmp * k; + num1 /= 10; + num2 /= 10; + num3 /= 10; + k *= 10; + ++i; + } + + return res; + } \ No newline at end of file diff --git a/src/3274.cpp b/src/3274.cpp new file mode 100644 index 0000000..a1564f2 --- /dev/null +++ b/src/3274.cpp @@ -0,0 +1,6 @@ +bool checkTwoChessboards(string coordinate1, string coordinate2) { + int coldiff = abs(coordinate1[0]-coordinate2[0]); + int rowdiff = abs(coordinate1[1]-coordinate2[1]); + + return (coldiff+rowdiff) % 2 == 0; + } \ No newline at end of file diff --git a/src/3280.cpp b/src/3280.cpp new file mode 100644 index 0000000..e528647 --- /dev/null +++ b/src/3280.cpp @@ -0,0 +1,24 @@ +string convertDateToBinary(string date) { + const string sdate[] = {"1", "10", "11", "100", "101", "110", "111", + "1000", "1001", "1010", "1011", "1100", "1101", "1110", + "1111", "10000", "10001", "10010", "10011", "10100", "10101", + "10110", "10111", "11000", "11001", "11010", "11011", "11100", + "11101", "11110", "11111"}; + + int year = (date[0]-'0')*1000 + (date[1]-'0')*100 + (date[2]-'0')*10 + (date[3]-'0'); + int month = (date[5]-'0')*10 + (date[6]-'0'); + int day = (date[8]-'0')*10 + (date[9]-'0'); + + string sy; + while (year != 0) + { + sy.push_back(year%2 + '0'); + year /= 2; + } + reverse(sy.begin(), sy.end()); + + stringstream ss; + ss << sy << '-' << sdate[month-1] << '-' << sdate[day-1]; + + return ss.str(); + } \ No newline at end of file diff --git a/src/3285.cpp b/src/3285.cpp new file mode 100644 index 0000000..653f117 --- /dev/null +++ b/src/3285.cpp @@ -0,0 +1,12 @@ +vector stableMountains(vector& height, int threshold) { + vector res; + int len = height.size(); + + for (int i = 1; i < len; ++i) + { + if (height[i-1] > threshold) + res.push_back(i); + } + + return res; + } \ No newline at end of file diff --git a/src/3289.cpp b/src/3289.cpp new file mode 100644 index 0000000..596de33 --- /dev/null +++ b/src/3289.cpp @@ -0,0 +1,15 @@ +vector getSneakyNumbers(vector& nums) { + int flag[100] = {0}; + int len = nums.size(), k = 0; + + vector res(2, 0); + for (int i = 0; i < len; ++i) + { + if (flag[nums[i]] == 0) + flag[nums[i]] = 1; + else + res[k++] = nums[i]; + } + + return res; + } \ No newline at end of file From 60b9f9f46963a98feb6d8fd43b1aee7609d42aa5 Mon Sep 17 00:00:00 2001 From: Troy Date: Thu, 3 Oct 2024 20:55:09 +0800 Subject: [PATCH 96/97] 5 problems solved. --- src/2778.cpp | 23 +++++++++++++++++++++++ src/3099.cpp | 11 +++++++++++ src/3131.cpp | 6 ++++++ src/3162.cpp | 13 +++++++++++++ src/3194.cpp | 15 +++++++++++++++ 5 files changed, 68 insertions(+) create mode 100644 src/2778.cpp create mode 100644 src/3099.cpp create mode 100644 src/3131.cpp create mode 100644 src/3162.cpp create mode 100644 src/3194.cpp diff --git a/src/2778.cpp b/src/2778.cpp new file mode 100644 index 0000000..cdb7558 --- /dev/null +++ b/src/2778.cpp @@ -0,0 +1,23 @@ +int sumOfSquares(vector& nums) { + int n = nums.size(); + int squareSum = 0; + int lim = sqrt(n); + + for (int i = 1; i < lim; ++i) + { + if (n%i == 0) + { + squareSum += nums[i-1]*nums[i-1] + nums[n/i-1]*nums[n/i-1]; + } + } + + int tmp = n/lim; + if (n%lim == 0) + { + squareSum += nums[lim-1]*nums[lim-1]; + if (tmp != lim) + squareSum += nums[tmp-1]*nums[tmp-1]; + } + + return squareSum; + } \ No newline at end of file diff --git a/src/3099.cpp b/src/3099.cpp new file mode 100644 index 0000000..cc307d3 --- /dev/null +++ b/src/3099.cpp @@ -0,0 +1,11 @@ +int sumOfTheDigitsOfHarshadNumber(int x) { + int tmp = x; + int sum = 0; + while (tmp > 0) + { + sum += tmp%10; + tmp /= 10; + } + + return x%sum == 0 ? sum : -1; + } \ No newline at end of file diff --git a/src/3131.cpp b/src/3131.cpp new file mode 100644 index 0000000..b3ab58f --- /dev/null +++ b/src/3131.cpp @@ -0,0 +1,6 @@ +int addedInteger(vector& nums1, vector& nums2) { + int sum2 = accumulate(nums2.begin(), nums2.end(), 0); + int sum1 = accumulate(nums1.begin(), nums1.end(), 0); + int n = nums1.size(); + return (sum2-sum1)/n; + } \ No newline at end of file diff --git a/src/3162.cpp b/src/3162.cpp new file mode 100644 index 0000000..828b6a6 --- /dev/null +++ b/src/3162.cpp @@ -0,0 +1,13 @@ +int numberOfPairs(vector& nums1, vector& nums2, int k) { + int ct = 0; + for (int a: nums1) + { + for (int b: nums2) + { + if (a%(b*k) == 0) + ++ct; + } + } + + return ct; + } \ No newline at end of file diff --git a/src/3194.cpp b/src/3194.cpp new file mode 100644 index 0000000..fc4533e --- /dev/null +++ b/src/3194.cpp @@ -0,0 +1,15 @@ +double minimumAverage(vector& nums) { + sort(nums.begin(), nums.end()); + int n = nums.size(); + int k = n/2; + + double minaverage = nums.back(); + for (int i = 0; i < k; ++i) + { + double tmp = (nums[i]+nums[n-1-i])/2.0; + if (tmp < minaverage) + minaverage = tmp; + } + + return minaverage; + } \ No newline at end of file From 9d223532971735d7eb48fc10fa83562ec2b5da04 Mon Sep 17 00:00:00 2001 From: Troy Date: Fri, 4 Oct 2024 20:08:10 +0800 Subject: [PATCH 97/97] 5 problems solved. --- src/3120.cpp | 30 ++++++++++++++++++++++++++++++ src/3151.cpp | 10 ++++++++++ src/3168.cpp | 18 ++++++++++++++++++ src/3184.cpp | 10 ++++++++++ src/3300.cpp | 16 ++++++++++++++++ 5 files changed, 84 insertions(+) create mode 100644 src/3120.cpp create mode 100644 src/3151.cpp create mode 100644 src/3168.cpp create mode 100644 src/3184.cpp create mode 100644 src/3300.cpp diff --git a/src/3120.cpp b/src/3120.cpp new file mode 100644 index 0000000..0698645 --- /dev/null +++ b/src/3120.cpp @@ -0,0 +1,30 @@ +int numberOfSpecialChars(string word) { + int num[26] = {0}; + int ct = 0; + for (char c: word) + { + if (islower(c)) + { + if (num[c-'a'] == 0) + num[c-'a'] = 1; + if (num[c-'a'] == 2) + { + num[c-'a'] = 3; + ++ct; + } + } + else + { + char tmp = tolower(c); + if (num[tmp-'a'] == 0) + num[tmp-'a'] = 2; + if (num[tmp-'a'] == 1) + { + num[tmp-'a'] = 3; + ++ct; + } + } + } + + return ct; + } \ No newline at end of file diff --git a/src/3151.cpp b/src/3151.cpp new file mode 100644 index 0000000..10eab77 --- /dev/null +++ b/src/3151.cpp @@ -0,0 +1,10 @@ +bool isArraySpecial(vector& nums) { + int n = nums.size(); + for (int i = 0; i < n-1; ++i) + { + if ((nums[i]+nums[i+1]) % 2 == 0) + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/3168.cpp b/src/3168.cpp new file mode 100644 index 0000000..4a3764b --- /dev/null +++ b/src/3168.cpp @@ -0,0 +1,18 @@ +int minimumChairs(string s) { + int maxentry = 0, ct = 0; + for (auto c: s) + { + if (c == 'E') + ++ct; + else + { + if (ct > maxentry) + { + maxentry = ct; + } + --ct; + } + } + + return maxentry > ct ? maxentry : ct; + } \ No newline at end of file diff --git a/src/3184.cpp b/src/3184.cpp new file mode 100644 index 0000000..10eab77 --- /dev/null +++ b/src/3184.cpp @@ -0,0 +1,10 @@ +bool isArraySpecial(vector& nums) { + int n = nums.size(); + for (int i = 0; i < n-1; ++i) + { + if ((nums[i]+nums[i+1]) % 2 == 0) + return false; + } + + return true; + } \ No newline at end of file diff --git a/src/3300.cpp b/src/3300.cpp new file mode 100644 index 0000000..18767a8 --- /dev/null +++ b/src/3300.cpp @@ -0,0 +1,16 @@ +int minElement(vector& nums) { + int minval = 100; + for (int a: nums) + { + int tmp = 0; + while (a > 0) + { + tmp += a%10; + a /= 10; + } + if (tmp < minval) + minval = tmp; + } + + return minval; + } \ No newline at end of file