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/100.cpp b/src/100.cpp similarity index 100% rename from 100.cpp rename to src/100.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/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/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/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/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/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 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/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/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/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/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/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/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/104.cpp b/src/104.cpp similarity index 100% rename from 104.cpp rename to src/104.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/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/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/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/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 & 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/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/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/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/1108.cpp b/src/1108.cpp new file mode 100644 index 0000000..268df05 --- /dev/null +++ b/src/1108.cpp @@ -0,0 +1,20 @@ +string defangIPaddr(string address) { + int sz = address.size(); + string res(sz+6, ' '); + int i = 0, j = 0; + while (i < sz) + { + if (address[i] != '.') + res[j++] = address[i]; + else + { + res[j] = '['; + res[j+1] = '.'; + res[j+2] = ']'; + j += 3; + } + ++i; + } + + return res; + } \ No newline at end of file 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/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/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/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/1122.cpp b/src/1122.cpp new file mode 100644 index 0000000..dea1824 --- /dev/null +++ b/src/1122.cpp @@ -0,0 +1,31 @@ +vector 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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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]> 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/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/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/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 & 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/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/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/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/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/125.cpp b/src/125.cpp similarity index 100% rename from 125.cpp rename to src/125.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/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/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/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/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/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/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/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/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/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/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/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/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/13.cpp b/src/13.cpp new file mode 100644 index 0000000..654111f --- /dev/null +++ b/src/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/1351.cpp b/src/1351.cpp new file mode 100644 index 0000000..380fafb --- /dev/null +++ b/src/1351.cpp @@ -0,0 +1,11 @@ +int countNegatives(vector>& 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/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/136.cpp b/src/136.cpp similarity index 100% rename from 136.cpp rename to src/136.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/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/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/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/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/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/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/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/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 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 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/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/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/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/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/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/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 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/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/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/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/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/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/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/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/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 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/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/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/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/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/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/1476.cpp b/src/1476.cpp new file mode 100644 index 0000000..25d3ce0 --- /dev/null +++ b/src/1476.cpp @@ -0,0 +1,24 @@ +class SubrectangleQueries { +public: + SubrectangleQueries(vector>& 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/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 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/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 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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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; +}; 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/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/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/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/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/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/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/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/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/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/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/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/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/167.cpp b/src/167.cpp similarity index 100% rename from 167.cpp rename to src/167.cpp 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/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/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/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/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/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/169.cpp b/src/169.cpp similarity index 100% rename from 169.cpp rename to src/169.cpp 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/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/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/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/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 diff --git a/171.cpp b/src/171.cpp similarity index 100% rename from 171.cpp rename to src/171.cpp 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 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/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 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/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/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/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 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 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/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 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/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/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 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/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/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/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/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/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/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/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/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/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/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/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 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 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/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 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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/1974.cpp b/src/1974.cpp new file mode 100644 index 0000000..4841229 --- /dev/null +++ b/src/1974.cpp @@ -0,0 +1,13 @@ +int minTimeToType(string word) { + int len = word.size(); + int cur = 'a'; + int ct = 0; + for (int i = 0; i < len; ++i) + { + int tmp = abs(word[i]-cur); + ct += tmp < 26-tmp ? tmp : 26-tmp; + cur = word[i]; + } + + return ct + len; + } \ 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/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/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/199.cpp b/src/199.cpp new file mode 100644 index 0000000..8e250ac --- /dev/null +++ b/src/199.cpp @@ -0,0 +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 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/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/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/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/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 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/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/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/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/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/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/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/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/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 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/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 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/206.cpp b/src/206.cpp similarity index 100% rename from 206.cpp rename to src/206.cpp 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/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/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/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/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/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 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/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/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 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/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/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 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/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/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/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/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/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/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/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 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/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/217.cpp b/src/217.cpp similarity index 100% rename from 217.cpp rename to src/217.cpp 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/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/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 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/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/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/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 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/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/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/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/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 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 diff --git a/src/2231.cpp b/src/2231.cpp new file mode 100644 index 0000000..311079f --- /dev/null +++ b/src/2231.cpp @@ -0,0 +1,34 @@ +int largestInteger(int num) { + string s = to_string(num); + int len = s.size(); + int odd[10] = {0}; + int even[10] = {0}; + int nodd = 0, neven = 0; + for (int i = 0; i < len; ++i) + { + if ((s[i]-'0')%2 == 0) + even[neven++] = i; + else + odd[nodd++] = i; + } + + for (int i = 0; i < len; ++i) + { + if ((s[i]-'0')%2 == 0) + { + for (int j = 0; j < neven; ++j) + { + if (i < even[j] && s[i] < s[even[j]]) + swap(s[i], s[even[j]]); + } + } + else + { + for (int j = 0; j < nodd; ++j) + if (i < odd[j] && s[i] < s[odd[j]]) + swap(s[i], s[odd[j]]); + } + } + + return stoi(s); + } \ 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 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/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/2248.cpp b/src/2248.cpp new file mode 100644 index 0000000..a0ddead --- /dev/null +++ b/src/2248.cpp @@ -0,0 +1,21 @@ +vector 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/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/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 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/226.cpp b/src/226.cpp similarity index 100% rename from 226.cpp rename to src/226.cpp 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/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/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/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/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 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/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/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 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/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/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/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/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 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/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/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/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/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 diff --git a/237.cpp b/src/237.cpp similarity index 100% rename from 237.cpp rename to src/237.cpp 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/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/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/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 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/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/242.cpp b/src/242.cpp similarity index 100% rename from 242.cpp rename to src/242.cpp 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 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/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 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 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/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/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/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/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/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 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/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/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/258.cpp b/src/258.cpp similarity index 100% rename from 258.cpp rename to src/258.cpp 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 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/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/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/268.cpp b/src/268.cpp similarity index 100% rename from 268.cpp rename to src/268.cpp 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/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 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 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/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/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/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/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/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/283.cpp b/src/283.cpp similarity index 100% rename from 283.cpp rename to src/283.cpp 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/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/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/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/292.cpp b/src/292.cpp similarity index 100% rename from 292.cpp rename to src/292.cpp 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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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 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/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/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/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/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 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 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 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/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/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/344.cpp b/src/344.cpp similarity index 100% rename from 344.cpp rename to src/344.cpp 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/349.cpp b/src/349.cpp similarity index 100% rename from 349.cpp rename to src/349.cpp 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/350.cpp b/src/350.cpp similarity index 100% rename from 350.cpp rename to src/350.cpp 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/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/371.cpp b/src/371.cpp similarity index 100% rename from 371.cpp rename to src/371.cpp 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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/447.cpp b/src/447.cpp new file mode 100644 index 0000000..e8567a7 --- /dev/null +++ b/src/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/448.cpp b/src/448.cpp similarity index 100% rename from 448.cpp rename to src/448.cpp 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/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/455.cpp b/src/455.cpp similarity index 100% rename from 455.cpp rename to src/455.cpp 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/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/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/476.cpp b/src/476.cpp similarity index 100% rename from 476.cpp rename to src/476.cpp 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/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/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/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/496.cpp b/src/496.cpp similarity index 100% rename from 496.cpp rename to src/496.cpp 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/500.cpp b/src/500.cpp similarity index 100% rename from 500.cpp rename to src/500.cpp 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/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/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/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/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/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/520.cpp b/src/520.cpp similarity index 100% rename from 520.cpp rename to src/520.cpp 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/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/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/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/530.cpp b/src/530.cpp new file mode 100644 index 0000000..011b2aa --- /dev/null +++ b/src/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/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/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/538.cpp b/src/538.cpp new file mode 100644 index 0000000..b8c66ce --- /dev/null +++ b/src/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/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/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/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/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/551.cpp b/src/551.cpp new file mode 100644 index 0000000..c706d20 --- /dev/null +++ b/src/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/557.cpp b/src/557.cpp similarity index 100% rename from 557.cpp rename to src/557.cpp 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; + } 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 diff --git a/561.cpp b/src/561.cpp similarity index 100% rename from 561.cpp rename to src/561.cpp diff --git a/src/563.cpp b/src/563.cpp new file mode 100644 index 0000000..62ea3fe --- /dev/null +++ b/src/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/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/566.cpp b/src/566.cpp similarity index 100% rename from 566.cpp rename to src/566.cpp 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 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/575.cpp b/src/575.cpp similarity index 100% rename from 575.cpp rename to src/575.cpp 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/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/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/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/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/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/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/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 diff --git a/src/598.cpp b/src/598.cpp new file mode 100644 index 0000000..d89db32 --- /dev/null +++ b/src/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/src/599.cpp b/src/599.cpp new file mode 100644 index 0000000..749220b --- /dev/null +++ b/src/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/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/606.cpp b/src/606.cpp similarity index 100% rename from 606.cpp rename to src/606.cpp 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/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/617.cpp b/src/617.cpp similarity index 100% rename from 617.cpp rename to src/617.cpp 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/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 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/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 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/637.cpp b/src/637.cpp similarity index 100% rename from 637.cpp rename to src/637.cpp 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 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 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/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/653.cpp b/src/653.cpp similarity index 100% rename from 653.cpp rename to src/653.cpp 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/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/657.cpp b/src/657.cpp similarity index 100% rename from 657.cpp rename to src/657.cpp 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/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/669.cpp b/src/669.cpp similarity index 100% rename from 669.cpp rename to src/669.cpp 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/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/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/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/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/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/682.cpp b/src/682.cpp similarity index 100% rename from 682.cpp rename to src/682.cpp 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/690.cpp b/src/690.cpp new file mode 100644 index 0000000..e9e324c --- /dev/null +++ b/src/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 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/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 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 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/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/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/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/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/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/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/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/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/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/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/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/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/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/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 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/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/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 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/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/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/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/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 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/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/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/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/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/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 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 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 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/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/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/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 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/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/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 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/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 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/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/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/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/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 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 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/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/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/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 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/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 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 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/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 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 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/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 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 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/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/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/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/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 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 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 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 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 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 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/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 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 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 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 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 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/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 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 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 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 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/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); + } + } 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 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/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 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