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

class Solution:
    def minSubarray(self, A: List[int], p: int) -> int:
        n = len(A)
        target = sum(A) % p
        if target == 0:
            return 0
        
        d = {0:-1}
        curr_sum = 0
        ans = n
        for i,a in enumerate(A):
            curr_sum += a 
            temp = (curr_sum - target) % p
            if temp in d:
                ans = min(ans, i - d[temp])
            
            d[curr_sum % p] = i
        return ans if ans != n else -1

class Solution:
    def dividePlayers(self, skill: List[int]) -> int:
        skill.sort()
        m, n = len(skill) // 2, len(skill)
        target = skill[0] + skill[-1]
        result = 0
        for i in range(m):
            if skill[i] + skill[n - 1 - i] == target:
                result += skill[i] * skill[n - 1 - i]
            else:
                result = -1
                break

        return result

class Solution:
    def dividePlayers(self, skill: List[int]) -> int:
        total = sum(skill)
        n = len(skill)
        teams = n//2
        if total % teams != 0:
            return -1

        target = total//teams
        freq = defaultdict(int)
        ans = 0
        for s in skill:
            toBePaired = target - s
            if toBePaired in freq:
                freq[toBePaired] -= 1
                ans += toBePaired*s
                if freq[toBePaired] == 0:
                    freq.pop(toBePaired)
            else:
                freq[s] += 1
        
        return -1 if len(freq) != 0 else ans

function dividePlayers(skill: number[]): number {
    const n = skill.length;
    const sum = _.sum(skill);
    if (sum % (n/2) !== 0) return -1;
    const k = sum / (n/2);
    const map = new Map();
    for (const num of skill) map.set(num, (map.get(num) || 0) + 1);
    let res = 0;
    for (const key of map.keys()) {
        if (map.get(key) !== map.get(k - key)) return -1;
        res+= key * (k - key) * map.get(key) / 2;
    }
    return res;
};

class Solution {

    /**
     * @param Integer[] $skill
     * @return Integer
     */
    function dividePlayers($skill) {
        $length = count($skill);
        if ($length == 2) return $skill[0] * $skill[1];

        $end = $length-1;
        $sum = array_sum($skill);
        $numsOfTeam = count($skill)/2;
        if ($sum % $numsOfTeam > 0) return -1;

        sort($skill);
        $teamSkill = $sum / $numsOfTeam;
        $ans = 0;
        for ($i=0; $i<$numsOfTeam; $i++) {
            if ($skill[$i] + $skill[$end-$i] != $teamSkill) return -1;
            $ans += $skill[$i] * $skill[$end-$i];
        }

        return $ans;
    }
}

class Solution {
    public long dividePlayers(int[] skill) {
        int n = skill.length;
        if (n == 2) return skill[0] * skill[1];
        Arrays.sort(skill);
        long ans = 0, prefix = 0;
        for (int l = 0, r = n - 1; l < n / 2 && r >= n / 2;) {
            long sum = skill[l] + skill[r];
            if (prefix == 0 || prefix == sum) {
                prefix = sum;
                ans += (skill[l] * skill[r]);
            } else if (prefix != sum) return -1;
            l++; r--;
        }
        return ans;
    }
}

class Solution:
    def dividePlayers(self, skill: List[int]) -> int:
        n = len(skill)
        skill.sort()
        prefix = 0
        ans = 0
        r = n - 1
        for l in range(0, int(n / 2)):
            sum = skill[l] + skill[r]
            if prefix == 0 or prefix == sum:
                prefix = sum
                ans += (skill[l] * skill[r])
            elif prefix != sum:
                return -1
            r -= 1
        return ans

public class Solution {
    public long DividePlayers(int[] skill) {
        Array.Sort(skill);
        int n = skill.Length;
        long res = 0;
        int sPre = skill[0] + skill[n-1];
        for (int i = 0, j = n-1; i < j ; ++i, j--) {
            if (skill[i] + skill[j] == sPre) {
                sPre = skill[i] + skill[j];
                res = res + (skill[i] * skill[j]);
            }
            else {
                return -1;
            }
            
        }
        return res;
    }
}

public class Solution {
    public long DividePlayers(int[] skill) {
        {
            long res = 0;
            var n = skill.Length;
            var sum = skill.Sum(x => x);
            var subSum = sum % (n / 2) == 0 ? sum / (n/2) : -1;
            if (subSum <= 0)
            return -1;
            Array.Sort(skill);
            var left = 0;
            var right = n - 1;
            while (left < right)
            {
            if (skill[left] + skill[right] == subSum)
            {
                res += skill[left] * skill[right];
                left++;
                right--;
            }
            else return -1;
            }
            return res;
        }
    }
}

class Solution {
    public long dividePlayers(int[] skill) {
        long sum =0 ;
        int n = skill.length;
        int max =0;
        int min = Integer.MAX_VALUE;
        for(int num : skill){
            max = Math.max(max, num);
            min = Math.min(min, num);

        }
        int[] map = new int [1001];
        int cnt=0;
        int target = max + min;
        for(int i:skill){
            if(map[target-i]==0) {
                map[i]++;
            }
            else{
                sum+=i *(target-i);
                map[target-i]--;
                cnt++;
            }
        }
        return cnt!=n/2?-1:sum;
    }
}

var dividePlayers = function (skill) {
    const n = skill.length;
    let sum = 0, m = new Map(), ans = 0;
    for (const s of skill) {
        sum += s;
        m.set(s, (m.get(s) ?? 0) + 1);
    }
    if (sum % (n / 2)) {
        return -1;
    }
    sum /= n / 2;
    for (const [u, v] of m.entries()) {
        if (v !== m.get(sum - u)) {
            return -1;
        }
        ans += u * (sum - u) * v;
    }
    return ans / 2;
};

        d = Counter(skill)
        team = len(skill) // 2
        chemistry = sum(skill) // team
        ans = 0
        for s in skill:
            if d[s] != d[chemistry - s]:
                return -1
            ans += s * (chemistry - s)
        
        return ans // 2

class Solution {
    public long dividePlayers(int[] skill) {
        Arrays.sort(skill);
        int l=0, r=skill.length-1;
        int sum = skill[l] + skill[r];
        long res = 0;
        while(l<r){
            int currSum = skill[l]+skill[r];
            if(sum==currSum)
                res+=skill[l]*skill[r];
            else return -1;
            l++;
            r--;
        }
        return res;
    }
}