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

impl Solution {
    pub fn array_rank_transform(mut arr: Vec<i32>) -> Vec<i32> {
        if arr.is_empty() {
            return arr;
        }

        let mut sorted: Vec<(i32, usize)> =
            arr.iter().copied().enumerate().map(|(i, num)| (num, i)).collect();

        sorted.sort_unstable();

        let (num, i) = sorted[0];
        let (mut prev, mut rank) = (num, 1);

        arr[i] = rank;
        for (num, i) in sorted.into_iter().skip(1) {
            if num != prev {
                rank += 1;
            }

            (arr[i], prev) = (rank, num);
        }

        arr
    }
}

class Solution {
    public int findPeakElement(int[] nums) {
        int l = 0, r = nums.length - 1;
        while (l < r) {
            int m = (l & r) + ((l ^ r) >>> 1); // r - (r - l + 1) / 2;
            if (nums[m] < nums[m + 1]) l = m + 1;
            else r = m;
        }
        return l;
    }
}

class Solution:
    def minSubarray(self, nums: List[int], p: int) -> int:
        sumOfNums = sum(nums)
        k = sumOfNums % p
        if k == 0:
            return 0
        
        result = n = len(nums)
        mod = defaultdict(int)
        mod[0] = -1
        s = 0
        for i in range(n):
            s = (s + nums[i]) % p
            target = (s - k + p) % p
            if target in mod:
                result = min(result, i - mod[target])
            mod[s] = i
        
        if result == n:
            return -1
        return result

function minSubarray(nums: number[], p: number): number {
    const n = nums.length;
    const x = _.sum(nums) % p
    if (x === 0) return 0;
    const map = new Map();
    map.set(0, -1);
    let cur = 0, res = n;
    for (let i = 0; i < n; i++) {
        cur = (cur + nums[i]) % p;
        let y = (cur - x + p) % p;
        if (map.has(y)) res = Math.min(res, i - map.get(y))
        map.set(cur, i)
    }
    return res === n ? -1 : res;
};

class Solution:
    def minSubarray(self, nums: List[int], p: int) -> int:
        needs = sum(nums)%p
        if needs == 0:
            return 0
        n = len(nums)
        ans = n
        prefix = {0: -1}
        sumSofar = 0
        for i, num in enumerate(nums):
            sumSofar += num
            key = (sumSofar%p - needs)%p
            if key in prefix:
                ans = min(ans, i - prefix[key])
            
            prefix[sumSofar%p] = i
        
        return -1 if ans == n else ans

class Solution {
    public int minSubarray(int[] nums, int p) {
        int n = nums.length;
        int min = n;
        int sum = 0;
        for (int num : nums) {
            sum = (sum + num) % p;
        }
        if (sum % p == 0) return 0;
        Map<Integer, Integer> map = new HashMap<>();
        map.put(0, -1);
        int prefix = 0;
        for (int i = 0; i < n; i++) {
            prefix = (prefix + nums[i]) % p;
            int key = (prefix - (sum % p) + p) % p;
            if (map.containsKey(key)) {
                min = Math.min(min, i - map.get(key));
            }
            map.put(prefix, i);
        }
        return min == n ? -1 : min;
    }
}