6 problems solved.

lintcoder · lintcoder · commit d64563eb72e5 · 2022-08-14T11:15:25.000+08:00
diff --git a/src/2265.cpp 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;     
+    }
diff --git a/src/2341.cpp b/src/2341.cpp
@@ -0,0 +1,16 @@
+vector<int> numberOfPairs(vector<int>& nums) {
+        int arr[101] = {0};
+        int len = nums.size();
+        
+        for (int i = 0; i < len; ++i)
+            arr[nums[i]]++;
+        
+        vector<int> res(2, 0);
+        for (int i = 0; i < 101; ++i)
+        {
+            res[0] += arr[i]/2;
+            res[1] += arr[i]%2;
+        }
+        
+        return res;
+    }
diff --git a/src/2347.cpp b/src/2347.cpp
@@ -0,0 +1,25 @@
+string bestHand(vector<int>& ranks, vector<char>& 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";
+    }
diff --git a/src/2351.cpp 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;
+    }
diff --git a/src/2363.cpp b/src/2363.cpp
@@ -0,0 +1,22 @@
+vector<vector<int>> mergeSimilarItems(vector<vector<int>>& items1, vector<vector<int>>& items2) {
+        int len1 = items1.size();
+        int len2 = items2.size();
+        
+        map<int, int> 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<vector<int>> res(sz, vector<int>(2, 0));
+        for (auto iter = mp.begin(); iter != mp.end(); ++iter)
+        {
+            res[k][0] = iter->first;
+            res[k][1] = iter->second;
+            ++k;
+        }
+        
+        return res;
+    }
diff --git a/src/2367.cpp b/src/2367.cpp
@@ -0,0 +1,27 @@
+int arithmeticTriplets(vector<int>& 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;
+    }
