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

class Solution:
    def maxSatisfied(self, c: List[int], g: List[int], m: int) -> int:   
        max_secret, curr, res =  0 ,0 ,0 
        for i in range(len(c)):
            if g[i] == 0:
                res += c[i]
            else: 
                curr += c[i]
            if i >= m:
                curr -= c[i - m] if g[i - m] == 1 else 0
            max_secret = max(max_secret, curr)
        return res + max_secret

class Solution:
    def maxSatisfied(self, c: List[int], g: List[int], m: int) -> int:
        return sum([i * (1 - j) for i, j in  zip(c, g)]) + max([sum([c[j] * g[j] for j in range(i - m, i)]) for i in range(m, len(c) + 1)])

class Solution {
   public:
    int maxSatisfied(vector<int>& customers, vector<int>& grumpy, int minutes) {
        int res = 0, n = grumpy.size();
        for (int i = 0; i < n; ++i) res += customers[i] * (1 - grumpy[i]);

        int tmp = res;
        for (int i = 0; i < n; ++i) {
            if (grumpy[i] == 1) tmp += customers[i];
            if (i >= minutes && grumpy[i - minutes] == 1)
                tmp -= customers[i - minutes];
            res = max(res, tmp);
        }

        return res;
    }
};

class Solution {
    func maxSatisfied(_ customers: [Int], _ grumpy: [Int], _ minutes: Int) -> Int {

        var happies = 0
        var alls = 0

        var sumHappy:[Int] = [happies]
        var sumAll:[Int] = [alls]

        for (index, customer) in customers.enumerated() {
            let isHappy = grumpy[index] == 0
            if isHappy {
                happies += customer
            }
            alls += customer
            sumHappy.append(happies)
            sumAll.append(alls)
        }

        var result = 0
        let lastHappy = sumHappy.last!
        for index in minutes..<sumHappy.count {
            var current = lastHappy
            current -= sumHappy[index] - sumHappy[index - minutes]
            current += sumAll[index] - sumAll[index - minutes]

            result = max(result, current)
        }

        return result
    }
}

class Solution:
    def maxSatisfied(self, customers: List[int], grumpy: List[int], minutes: int) -> int:
        satisfied = 0
        maxSatisfiable = 0
        curSatisfiable = 0
        for right in range(len(customers)):
            satisfied += (grumpy[right] ^ 1) * customers[right]
            curSatisfiable += grumpy[right] * customers[right]
            if right >= minutes:
                curSatisfiable -= grumpy[right - minutes] * customers[right - minutes]
            maxSatisfiable = max(maxSatisfiable, curSatisfiable)
        
        return satisfied + maxSatisfiable

class Solution {
    fun maxSatisfied(customers: IntArray, grumpy: IntArray, minutes: Int): Int {
        var s = customers.foldIndexed(0
        ) { i, v, a -> if (i < minutes || grumpy[i] == 0) (v + customers[i]) else v }

        var m = s
        for (i in minutes..<customers.size) {
            val l = i - minutes
            if (grumpy[l] == 1) {
                s -= customers[l]
            }
            if (grumpy[i] == 1) {
                s += customers[i]
            }

            if (m < s) m = s
        }

        return m
    }
}

impl Solution {
    pub fn max_satisfied(customers: Vec<i32>, grumpy: Vec<i32>, minutes: i32) -> i32 {
        let happy_count =
            customers.iter().zip(grumpy.iter()).
                fold(0, |mut acc, (&c, &g)| {
                    if g == 0 {
                        acc += c;
                    }

                    acc
                });

        let mut lo = 0;
        let mut window_count = 0;
        let mut max_window_count = 0;
        let um = minutes as usize;
        let n = customers.len();

        for i in 0..n {
            if grumpy[i] == 1 {
                window_count += customers[i];
            }

            if i - lo + 1 == um {
                max_window_count = max_window_count.max(window_count);

                if grumpy[lo] == 1 {
                    window_count -= customers[lo];
                }

                lo += 1;
            }
        }

        happy_count + max_window_count
    }
}

class Solution {
    public int maxSatisfied(int[] customers, int[] grumpy, int minutes) {
        int n = customers.length;
        int satisfied = 0;
        int notSatisfiedInMinutes = 0;
        int maxNotsatisfiedInMinutes = 0;

        for (int i = 0; i < n; i++) {
            satisfied += (grumpy[i] == 0? customers[i] : 0);
        }

        for (int i = 0; i <= n - minutes; i++) {
            if (i == 0) {
                for (int j = 0; j < minutes; j++) {
                    notSatisfiedInMinutes += grumpy[j] * customers[j];
                }
            } else {
                notSatisfiedInMinutes += (grumpy[i + minutes - 1] * customers[i + minutes - 1] - grumpy[i - 1] * customers[i - 1]);
            }

            maxNotsatisfiedInMinutes = Math.max(maxNotsatisfiedInMinutes, notSatisfiedInMinutes);
        }

        return satisfied + maxNotsatisfiedInMinutes;
    }
}

object Solution {
  def maxSatisfied(customers: Array[Int], grumpy: Array[Int], minutes: Int): Int = {
    val n = customers.length
   
    val satisfied = (customers zip grumpy).collect { case (c, g) if g == 0 => c }.sum
    val initialWindowSatisfaction = (0 until minutes).map(i => grumpy(i) * customers(i)).sum
    val maxAdditionalSatisfaction = (1 to (n - minutes)).foldLeft((initialWindowSatisfaction, initialWindowSatisfaction)) {
      case ((currentMax, prevWindowSatisfaction), i) =>
        val newWindowSatisfaction = prevWindowSatisfaction + grumpy(i + minutes - 1) * customers(i + minutes - 1) - grumpy(i - 1) * customers(i - 1)
        (math.max(currentMax, newWindowSatisfaction), newWindowSatisfaction)
    }._1
    satisfied + maxAdditionalSatisfaction
  }
}