thảo luận Leetcode mỗi ngày

class Solution {
    func dividePlayers(_ skill: [Int]) -> Int {
        //guard skill.count % 2 == 0 else {
        //    return -1
        //}
        var dict:[Int: Int] = [:]
        var sum = 0
        for s in skill {
            sum += s
            dict[s, default:0] += 1
        }
        let half = skill.count/2
        guard sum%half == 0 else { return -1 }
        
        let chemistry = sum/half
        var sumChemistry = 0
        for (key, value) in dict {
            let teammate = abs(chemistry-key)
            guard value == dict[teammate] else {
                return -1
            }
            if teammate == key {
                if value%2 == 1 {
                    return -1
                }
                // The members have same skills.
                sumChemistry += key*teammate*value/2
            }
            if key < teammate {
                sumChemistry += key*teammate*value
            }
        }
        return sumChemistry
    }
}

class Solution {
public:
    long long dividePlayers(vector<int>& skill) {
        sort(begin(skill), end(skill));
        int n = skill.size(), s = skill[0] + skill[n - 1];
        long long res = 0;
        for (int i = 0; i < n / 2; ++i) {
            if (skill[i] + skill[n - 1 - i] != s) return -1;
            res += skill[i] * skill[n - 1 - i];
        }
        return res;
    }
};

class Solution {
public:
    long long dividePlayers(vector<int> const& skill) {
        int store[10001] = {}, mn = skill[0], mx = skill[0], n = skill.size();
        for (auto e : skill) {
            store[e] += 1;
            mn = min(mn, e);
            mx = max(mx, e);
        }
        long long res = 0;
        for (int i = 0; i < n; ++i) {
            if (store[skill[i]] != store[mn + mx - skill[i]]) return -1;
            if (store[skill[i]]) {
                res += skill[i] * (mn + mx - skill[i]);
                store[skill[i]] -= 1;
                store[mn + mx - skill[i]] -= 1;
            }
        }
        return res;
    }
};

class Solution {
    public long dividePlayers(int[] skill) {
        int n = skill.length;
        if (n == 2) return skill[0] * skill[1];
        long rs = 0L;
        long total = java.util.stream.IntStream.of(skill).sum();
        if (total % (n / 2) != 0) return -1;
        int sum2 = (int) total / (n / 2);
        java.util.Map<Integer, Integer> m = new java.util.HashMap<>();
        for (int e : skill) m.put(e, m.getOrDefault(e, 0) + 1);
        for (Integer e : m.keySet()) {
            if (!m.get(e).equals(m.get(sum2 - e))) return -1;
            rs += (long) (sum2 - e) * e * m.get(e);
        }
        return rs / 2;
    }
}

class Solution {
public:
    long long dividePlayers(vector<int>& skill) {
        auto itr_l = skill.begin(); auto itr_r = skill.end();
        std::sort(itr_l, itr_r);
        auto s = *itr_l + *(--itr_r);
        long long chem = static_cast<decltype(chem)>(*itr_l) * *itr_r;
        while (++itr_l < --itr_r) {
            if (*itr_l + *itr_r != s) return -1;
            chem += static_cast<decltype(chem)>(*itr_l) * *itr_r;
        }
        return chem;
    }
};