Game 302 of leetcode

summary

This week's match is also relatively simple , Mainly focus on Hash application

2341. How many pairs can an array form

class Solution {
    
public:
    vector<int> numberOfPairs(vector<int>& nums) {
    
        int ans = 0;
        map<int, int> mp;
        for (auto& t : nums)
            mp[t] ++ ;
        for (auto& [u, v] : mp)
            ans += v / 2;
        return {
    ans, (int)nums.size() - ans * 2};
    }
};

2342. The maximum sum of digits and equal pairs

class Solution {
    
public:
    vector<int> a[100];
    int maximumSum(vector<int>& nums) {
    
        int n = nums.size();
        for (auto& t : nums)
            a[get(t)].push_back(t);
        int maxn = -1;
        for (int i = 0; i < 100; i ++ )
        {
    
            if (a[i].size() >= 2) {
    
                sort(a[i].begin(), a[i].end());
                int n = a[i].size();
                maxn = max(maxn, a[i][n - 1] + a[i][n - 2]);            
            }
        }
        return maxn;
    }

    int get(int u) {
    
        int ans = 0;
        while (u) {
    
            ans += u % 10;
            u /= 10;
        }
        return ans;
    }
};

2343. Query the number K Small numbers

class Solution {
    
public:
    vector<int> smallestTrimmedNumbers(vector<string>& nums, vector<vector<int>>& qs) {
    
        int n = nums.size(), m = qs.size();
        vector<pair<string, int>> strs(n);
        for (int i = 0; i < n; i ++ ) strs[i] = {
    nums[i], i};
        vector<int> res;
        for (auto& q: qs) {
    
            int k = q[0], trim = q[1];
            sort(strs.begin(), strs.end(), [&](pair<string, int>& a, pair<string, int>& b) {
    
                for (int i = a.first.size() - trim; i < a.first.size(); i ++ )
                    if (a.first[i] < b.first[i])
                        return true;
                    else if (a.first[i] > b.first[i])
                        return false;
                return a.second < b.second;
            });
            res.push_back(strs[k - 1].second);
        }
        return res;
    }
};

2344. The minimum number of deletions that make the array divisible

class Solution {
    
public:
    int minOperations(vector<int> &nums, vector<int> &numsDivide) {
    
        int g = 0;
        for (int x : numsDivide) g = gcd(g, x);
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++) if (g % nums[i] == 0) return i;
        return -1;
    }
};