This comparison is water , All can be solved by violence

6120. How many pairs can an array form

class Solution {
    
public:
    vector<int> numberOfPairs(vector<int>& nums) {
    
        map<int,int>mp;
        int res=0;
        int res2=0;
        for(auto x:nums)mp[x]++;
        for(auto x:mp)
        {
    
            res+=x.second/2;
            if(x.second%2)res2++;
        }
        vector<int>v;
        v.push_back(res),v.push_back(res2);
        return v;
    }
};

6164. The maximum sum of digits and equal pairs

class Solution {
    
public:
    int maximumSum(vector<int>& nums) {
    
        map<int,vector<int>>mp;
        sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size();i++)
        {
    
            int x=nums[i];
            int s=0;
            while(x)
            {
    
                s+=x%10;
                x/=10;
            }
            mp[s].push_back(nums[i]);
        }
        bool f=false;
        int res=0;
        for(auto x:mp)
        {
    
            if(x.second.size()>=2)
            {
    
                f=true;
                int sz=x.second.size();
                int s=x.second[sz-2]+x.second[sz-1];
                res=max(res,s);
            }
        }
        if(!f)return -1;
        else return res;
    }
};

6121. Query the number K Small numbers

class Solution {
    
public:
    vector<int> smallestTrimmedNumbers(vector<string>& nums, vector<vector<int>>& queries) {
    
        vector<int>res;
        for(int i=0;i<queries.size();i++)
        {
    
            vector<pair<string,int>>v;
            for(int j=0;j<nums.size();j++)
            {
    
                string s=nums[j].substr((int)nums[j].size()-queries[i][1],queries[i][1]);
                v.push_back({
    s,j});
            }
            sort(v.begin(),v.end(),[&](const pair<string,int>&a,const pair<string,int>&b)
            {
    
                if(a.first==b.first)return a.second<b.second;
                return a.first<b.first;
            });
            res.push_back(v[queries[i][0]-1].second);
        }
        return res;
    }
};

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

class Solution {
    
public:
int gcd(int a,int b)
{
    
    return b?gcd(b,a%b):a;
}
    int minOperations(vector<int>& nums, vector<int>& numsDivide) {
    
        int d=0;
        if(numsDivide.size()==1)d=numsDivide[0];
        else d=gcd(numsDivide[0],numsDivide[1]);
        for(int i=2;i<numsDivide.size();i++)
            d=gcd(d,numsDivide[i]);
        map<int,int>mp;
        for(int i=0;i<nums.size();i++)mp[nums[i]]++;
        int res=0;
        for(auto x:mp)
        {
    
            if(d%x.first==0)return res;
            else res+=x.second;
        }
        if(res==nums.size())return -1;
        else return res;
    }
};