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

class Solution {
    public int chalkReplacer(int[] chalk, int k) {
        int n = chalk.length;
        long sum = 0 ;
        for(int c:chalk){
            sum+= c;
        }
        k%=sum;
        int index =0;
        while(k>0){
            if(k>=chalk[index] ){
                k-=chalk[index++];
            }
            else{
                break;
            }
        }
        return index;
    }
}

impl Solution {
    pub fn chalk_replacer(chalk: Vec<i32>, k: i32) -> i32 {
        assert!(chalk.len() > 0);

        let chalk_sum: isize = chalk.iter().map(|c| *c as isize).sum();
        let (mut k, mut i) = (k as isize % chalk_sum, 0);
        loop {
            k -= chalk[i] as isize;
            if k < 0 {
                return i as i32;
            }
            i += 1;
        }
    }
}

impl Solution {
    pub fn chalk_replacer(chalk: Vec<i32>, k: i32) -> i32 {
        assert!(chalk.len() > 0);

        let chalk_sums: Vec<_> = chalk.iter().scan(0, |sum, &c| {
            *sum = *sum + c as isize;
            Some(*sum)
        }).collect();

        let sum = chalk_sums.last().unwrap().to_owned();
        match chalk_sums.binary_search(&(k as isize % sum)) {
            Ok(i) => i as i32 + 1,
            Err(i) => i as i32,
        }
    }
}

class Solution {
    func chalkReplacer(_ chalk: [Int], _ k: Int) -> Int {
        var ch = k % chalk.reduce(0, +)
        for (idx, s) in chalk.enumerated() {
            if ch >= s {
                ch -= s
            } else {
                return idx
            }
        }
        return 0
    }
}

public class Solution
{
    public int ChalkReplacer(int[] chalk, int k)
    {
        long[] prefix = new long[chalk.Length];
        prefix[0] = chalk[0];

        int n = chalk.Length;
        for (int i = 1; i < n; i++)
        {
            prefix[i] = prefix[i - 1] + chalk[i];
        }

        long remainder = k % prefix[^1];
        int index = Array.BinarySearch(prefix, remainder);

        if (index > 0)
        {
            return (index + 1) % n;
        }

        return ~index;
    }
}

class Solution {
    public int chalkReplacer(int[] chalk, int k) {
        long sum = 0;
        for(int c:chalk)
            sum+=c;
        int r = (int) (k%sum);
        sum = 0;
        for(int i = 0;i<chalk.length;i++){
            sum+=chalk[i];
            if(sum>r)
                return i;
        }
        return 0;
    }
}

/**
 * @param {number[]} chalk
 * @param {number} k
 * @return {number}
 */
var chalkReplacer = function (chalk, k) {
    const n = chalk.length;
    for (let i = 1; i < n; i++) {
        chalk[i] += chalk[i - 1];
    }
    const countChalks = t => {
        if (!t) {
            return 0;
        }
        t--;
        const u = Math.trunc(t / n), v = t % n;
        return u * chalk[n - 1] + chalk[v];
    };
    let l = 0, h = k + 1;
    while (l < h) {
        const m = (l + h) >> 1;
        if (countChalks(m) <= k) {
            l = m + 1;
        } else {
            h = m;
        }
    }
    return (l + n - 1) % n;
};

class Solution {
    public int chalkReplacer(int[] chalk, int k) {
        int index = 0;
        while (k >= chalk[index]) {
            k -= chalk[index];
            index++;
            if (index >= chalk.length) {
                index = 0;
            }
        }
        return index;
    }
}

class Solution:
    def chalkReplacer(self, chalk: List[int], k: int) -> int:
        total_chalk = sum(chalk)
        k %= total_chalk
        
        for i, c in enumerate(chalk):
            if k < c:
                return i
            k -= c

function chalkReplacer(chalk: number[], k: number): number {
    let idx = 0;
    while (k >= 0) {
        if (idx === chalk.length) idx = 0;
        if (k < chalk[idx]) return idx;
        k-= chalk[idx], idx++;
    }
    return -1;
};

function chalkReplacer(chalk: number[], k: number): number {
    let idx = 0;
    const sum = _.sum(chalk);
    let mod = k % sum;
    while (mod >= 0) {
        if (mod < chalk[idx]) return idx;
        mod-= chalk[idx++];
    }
    return -1;
};

class Solution {

    /**
     * @param Integer[] $chalk
     * @param Integer $k
     * @return Integer
     */
    function chalkReplacer($chalk, $k) {      
        $sum = array_sum($chalk);
        $remain = $k % $sum;
        if ($remain === 0) return 0;
      
        $p = 0;
        $ch = $chalk[$p];
        while ($remain >= $ch) {
            $remain -= $ch;
            $p++;
            if (!isset($chalk[$p])) $p = 0;
            $ch = $chalk[$p];
        }
        return $p;
    }
}

class Solution {
    public int chalkReplacer(int[] chalk, int k) {
        long sum = 0;

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

        long remain = k % sum;
        for(int i = 0; i < chalk.length; i++) {
            remain -= chalk[i];
            if (remain < 0)
                return i;
        }
        

        return chalk.length - 1;
    }
}