8 problems solved.

lintcoder · lintcoder · commit 518fc7b02826 · 2022-10-04T18:23:35.000+08:00
diff --git a/src/2409.cpp 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;
+        }
+    }
diff --git a/src/2413.cpp b/src/2413.cpp
@@ -0,0 +1,6 @@
+int smallestEvenMultiple(int n) {
+        if (n%2 == 0)
+            return n;
+        else
+            return 2*n;
+    }
diff --git a/src/2414.cpp 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;
+    }
diff --git a/src/2415.cpp b/src/2415.cpp
@@ -0,0 +1,43 @@
+TreeNode* reverseOddLevels(TreeNode* root) {
+        deque<TreeNode*> 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;
+    }
diff --git a/src/2418.cpp b/src/2418.cpp
@@ -0,0 +1,16 @@
+vector<string> sortPeople(vector<string>& names, vector<int>& heights) {
+        int len = names.size();
+        vector<string> res(len, "");
+        
+        map<int, string> 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;
+    }
diff --git a/src/2423.cpp 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;
+        }
+    }
diff --git a/src/2427.cpp 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;
+    }
diff --git a/src/2428.cpp b/src/2428.cpp
@@ -0,0 +1,19 @@
+int maxSum(vector<vector<int>>& 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;
+    }
