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

public class CustomStack {
    public int[] Stack;
    public int Index;
    public int[] Lazy;
    public int MaxSize;
    public CustomStack(int maxSize) {
        Stack = new int[maxSize];
        Index = -1;
        Lazy = new int[maxSize];
        MaxSize = maxSize;
    }
    
    public void Push(int x) {
        // Console.WriteLine("xx{0} , {1} , {2}", Index, MaxSize, x);
        if (Index+1 < MaxSize) Stack[++Index] = x;
        // Console.WriteLine("xxx{0} , {1} , {2}", Index, MaxSize, x);
    }
    
    public int Pop() {
        if (Index < 0) return -1;
        // Console.WriteLine("yy{0} , {1}", Index, MaxSize);
        int result = Stack[Index] + Lazy[Index];
        // Console.WriteLine("yyy{0} , {1} , {2}", Index, MaxSize, result);
        if (Index > 0) {
            Lazy[Index - 1] += Lazy[Index];
        }
        Lazy[Index] = 0;
        // Console.WriteLine("yyyy{0} , {1} , {2}", Index, MaxSize, result);
        Index--;
        return result;
    }
    
    public void Increment(int k, int val) {
        int maxK = Math.Min(k, Index+1);
        // Console.WriteLine("kkk{0}, {1}, {2}, {3}", k, Index+1, maxK, val);
        if (maxK > 0) Lazy[--maxK] += val;
        // Console.WriteLine("kkkk{0}, {1}, {2}, {3}", k, Index+1, maxK, Lazy[maxK]);
    }
}

/**
 * Your CustomStack object will be instantiated and called as such:
 * CustomStack obj = new CustomStack(maxSize);
 * obj.Push(x);
 * int param_2 = obj.Pop();
 * obj.Increment(k,val);
 */

struct CustomStack {
    data: Vec<i32>,
    deltas: Vec<i32>
}

impl CustomStack {
    fn new(maxSize: i32) -> Self {
        Self {
            data: Vec::with_capacity(maxSize as usize),
            deltas: Vec::with_capacity(maxSize as usize)
        }
    }

    fn push(&mut self, x: i32) {
        if self.data.len() == self.data.capacity() {
            return;
        }

        self.data.push(x);
        self.deltas.push(0);
    }

    fn pop(&mut self) -> i32 {
        match self.data.len() {
            0 => -1,
            1 => {
                self.deltas.pop();

                self.data.pop().unwrap()
            },
            _ => {
                let delta = self.deltas.pop().unwrap();
                let top = self.data.pop().unwrap();

                let n = self.data.len();
                self.data[n - 1] += delta;
                self.deltas[n - 1] += delta;

                top
            }
        }
    }

    fn increment(&mut self, k: i32, val: i32) {
        if self.data.is_empty() {
            return;
        }

        let index = (k as usize).min(self.data.len()) - 1;

        self.deltas[index] += val;
        self.data[index] += val;
    }
}

fn arrayManipulation(n: i32, queries: &[Vec<i32>]) -> i64 {
    let mut freqs = vec![0; n as usize + 1];

    for query in queries.iter() {
        let (a, b, k) = (query[0] as usize - 1, query[1] as usize, query[2] as i64);
        freqs[a] += k;
        freqs[b] -= k;
    }

    freqs.into_iter().fold((0, 0), |(max, current), freq| {
        (max.max(current + freq), current + freq)
    }).0
}

class Solution:
    def canArrange(self, arr: List[int], k: int) -> bool:
        counter = defaultdict(int)
        for num in arr:
            counter[num % k] += 1
        if counter[0] % 2 != 0:
            return False

        for i in range(1, k):
            if counter[i] != counter[k - i]:
                return False
        return True

class Solution:
    def canArrange(self, arr: List[int], k: int) -> bool:
        count = defaultdict(int)
        for num in arr:
            current = num%k
            if current == 0:
                count[current] += 1
                continue

            target = k - current
            if target in count:
                count[target] -= 1
                if count[target] == 0:
                    count.pop(target)
            else:
                count[current] += 1

        return len(count) == 0 or (len(count) == 1 and count[0] > 0 and count[0]%2 == 0)

class Solution {
public:
    bool canArrange(vector<int>& arr, int k) {
        unordered_map<int, int> cnt;

        for (int i = 0; i < arr.size(); i++) {
            cnt[(arr[i] % k + k) % k]++;
        }

        for (int i = 1; i < k; i++) {
            if (cnt[0] % 2 == 1) return false;
            if(cnt[i] != cnt[k - i]) return false;
        }
        
        return true;
    }
};

public class Solution {
    public bool CanArrange(int[] arr, int k) {
        int[] freq = new int[k];
        int n = arr.Length;
        for (int i = 0; i < n; i++){
            freq[(arr[i]%k + k)%k]++;
        }

        bool flag = freq[0] % 2 == 0;
        for (int i = 1; i < k && flag == true; i++) {
            // Console.WriteLine("{0}, {1}, {2}, {3}", freq[i], freq[k-i], i, k - i);
            flag = flag && (freq[i] == freq[k-i]);
        }
        return flag;
    }
}

function canArrange(arr: number[], k: number): boolean {
    const map = new Map();
    for (const num of arr) {
        const key = ((num % k) + k) % k
        map.set(key, (map.get(key) || 0) + 1);
    }
    for (const key of map.keys()) {
        if (key === 0) {if (map.get(key) & 1) return false;}
        else if (map.get(key) !== map.get(k - key)) return false;
    }
    return true;
};

class Solution:
    def canArrange(self, arr: List[int], k: int) -> bool:
        for i in range(len(arr)):
            arr[i] = arr[i] % k
        arr.sort()
        left = 0
        right = len(arr) - 1
        while left < len(arr) and  arr[left] == 0:
            left += 1
        if left % 2 != 0:
            return False
        while left < right:
            if arr[left] + arr[right] != k:
                return False
            left += 1
            right -= 1
        return True

class Solution:
    def canArrange(self, arr: List[int], k: int) -> bool:
        counting = defaultdict(int)
        for i in range(len(arr)):
            counting[arr[i] % k] += 1
        if counting[0] % 2 != 0:
            return False
        for i in range(1, k // 2 + 1):
            if counting[i] != counting[k-i]:
                return False
        return True

class Solution {
    public boolean canArrange(int[] arr, int k) {
        int[] freq = new int[k];
        for(int i:arr){
            freq[((i%k)+k)%k]++;
        }
 
        for(int i =1 ; i<(double)k/2;i++){

            if(freq[i]!= freq[k-i]) return false;
        }
        if(k%2==0){
            return freq[k/2]%2==0;
        }
        return true;
    }
}