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

class Solution:
    def missingRolls(self, rolls: List[int], mean: int, n: int) -> List[int]:
        total = sum(rolls)
        m = len(rolls)
        target = mean*(m + n) - total
        if n <= target <= 6*n:
            ans = [1]*n
            target -= n
            for i in range(n):
                if target < 5:
                    ans[i] += target
                    break
                else:
                    ans[i] += 5
                    target -= 5

            return ans

        return []

class Solution {
    public int[] missingRolls(int[] rolls, int mean, int n) {
        int m = rolls.length;
        int sumOfM =0;
        for(int roll:rolls){
            sumOfM+=roll;
        }
        int remain = mean*(n+m)-sumOfM;
        if(remain>6*n || remain<1*n) return new int[0];
        int[] res = new int[n];
        for(int i =0; i < n ; i++){
            res[i]=remain/(n-i);
            remain-= res[i];
        }
        return res;
    }
}

function missingRolls(rolls: number[], mean: number, n: number): number[] {
    const m = rolls.length;
    let total = mean * (n + m) - _.sum(rolls);
    if (total > n * 6 || total < n) return [];
    const res: number[] = []
    while (total > 0) {
        const num = Math.floor(total / n);
        res.push(num);
        total-= num;
        n--;
    }
    return res;
};

function missingRolls(rolls: number[], mean: number, n: number): number[] {
    const m = rolls.length;
    let total = mean * (n + m) - _.sum(rolls);
    if (total > n * 6 || total < n) return [];
    const div = Math.floor(total / n), mod = total % n;
    const res = new Array(n).fill(div);
    for (let i = 0; i < mod; i++) res[i]+= 1;
    return res;
};

class Solution:
    def missingRolls(self, rolls: List[int], mean: int, n: int) -> List[int]:
        m = len(rolls)
        missing = mean * (m + n) - sum(rolls)
        if missing < n or missing > 6 * n:
            return []
        ans = []
        while n > 0:
            temp = missing // n
            ans.append(temp)
            missing -= temp
            n -= 1
        return ans

class Solution {
    func missingRolls(_ rolls: [Int], _ mean: Int, _ n: Int) -> [Int] {
        let total = mean * (rolls.count + n)
        let added = rolls.reduce(0, +)
        guard (added + n) <= total else { return [] }
        guard (added + 6*n) >= total else { return [] }

        var remain = total - added
        var remainDiv = remain%n
        var average = remain/n

        var result = Array(repeating:average+1, count:remainDiv)
        result += Array(repeating:average, count:n-remainDiv)

        return result
    }
}

public class Solution {
    public int[] MissingRolls(int[] rolls, int mean, int n) {
        var m = rolls.Length;
        var sumN = (m + n) * mean - rolls.Sum();
        if (sumN <= 0 || ((double)sumN / n) > 6 || sumN < n)
            return Array.Empty<int>();
        var avg = sumN / n;
        var res = new int[n];
        var valueLeft = sumN - avg * n;
        for (int i = 0; i < n; i++)
        {
            res[i] = (valueLeft <= 6 - avg) ? avg + valueLeft : 6;
            valueLeft -= res[i] - avg;
        }

        return res;
    }
}

class Solution {
    public int[] missingRolls(int[] rolls, int mean, int n) {
        int[] ans = new int[n];
        int sum = 0;
        int multi = (rolls.length + n) * mean;
        for (int roll : rolls) {
            sum += roll;
        }
        int sub = multi - sum;
        if (n == 0 || sub < 0 || sub < n || sub > n * 6) {
            return new int[0];
        }
        int mod = sub % n;
        for (int i = 0; i < n; i++) {
            ans[i] = sub / n;
        }
        while (mod > 0) {
            ans[mod--] += 1;
        }
        return ans;
    }
}

impl Solution {
    pub fn missing_rolls(rolls: Vec<i32>, mean: i32, n: i32) -> Vec<i32> {
        let (m, n, ni) = (rolls.len(), n as usize, n);

        let S = rolls.iter().fold(0, |a, &b| a + b);

        let N = mean * (m + n) as i32 - S;

        if N < ni || N > 6 * ni {
            return vec![];
        }

        let mut result = vec![N / ni; n];

        let rem = (N % ni) as usize;

        for i in 0..rem {
            result[i] += 1;
        }

        result
    }
}

class Solution:
    def missingRolls(self, rolls: List[int], mean: int, n: int) -> List[int]:
        m = len(rolls)
        sumM = sum(rolls)
        sumN = mean * (m + n) - sumM
        list = []
        if (n<= sumN <= 6*n):
            dice = sumN // n
            r = sumN - dice*n
            list = [dice]*(n-r)
            for i in range(0,r):
                list.append(dice + 1)
        return list

class Solution {
    List<Integer> list = new LinkedList<>();

    public int[] missingRolls(int[] rolls, int mean, int n) {
        int k = rolls.length;
        int sum = 0;

        for (int i : rolls) {
            sum += i;
        }

        int remain = mean * (k + n) - sum;
        int[] arr = new int[n];
        sum = 6 * n;

        if (sum < remain)
            return new int[0];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = 6;
        }

        int diff;
        for (int i = 0; i < arr.length; i++) {
            if (sum == remain) {
                return arr;
            }

            diff = sum - remain;
            if (diff > 5) {
                arr[i] -= 5;
                sum -= 5;
            } else {
                arr[i] -= diff;
                sum -= diff;
            }
        }

        return sum == remain ? arr : new int[0];
    }
}