Welcome to Subscribe On Youtube
Formatted question description: https://leetcode.ca/all/1744.html
1744. Can You Eat Your Favorite Candy on Your Favorite Day?
Level
Medium
Description
You are given a (0indexed) array of positive integers candiesCount
where candiesCount[i]
represents the number of candies of the ith
type you have. You are also given a 2D array queries
where queries[i] = [favoriteType_i, favoriteDay_i, dailyCap_i]
.
You play a game with the following rules:
 You start eating candies on day
0
.  You cannot eat any candy of type
i
unless you have eaten all candies of typei  1
.  You must eat at least one candy per day until you have eaten all the candies.
Construct a boolean array
answer such that answer.length == queries.length
and answer[i]
is true
if you can eat a candy of type favoriteType_i
on day favoriteDay_i
without eating more than dailyCap_i
candies on any day, and false
otherwise. Note that you can eat different types of candy on the same day, provided that you follow rule 2.
Return the constructed array answer
.
Example 1:
Input: candiesCount = [7,4,5,3,8], queries = [[0,2,2],[4,2,4],[2,13,1000000000]]
Output: [true,false,true]
Explanation:
1 If you eat 2 candies (type 0) on day 0 and 2 candies (type 0) on day 1, you will eat a candy of type 0 on day 2.
2 You can eat at most 4 candies each day.
If you eat 4 candies every day, you will eat 4 candies (type 0) on day 0 and 4 candies (type 0 and type 1) on day 1.
On day 2, you can only eat 4 candies (type 1 and type 2), so you cannot eat a candy of type 4 on day 2.
3 If you eat 1 candy each day, you will eat a candy of type 2 on day 13.
Example 2:
Input: candiesCount = [5,2,6,4,1], queries = [[3,1,2],[4,10,3],[3,10,100],[4,100,30],[1,3,1]]
Output: [false,true,true,false,false]
Constraints:
1 <= candiesCount.length <= 10^5
1 <= candiesCount[i] <= 10^5
1 <= queries.length <= 10^5
queries[i].length == 3
0 <= favoriteType_i < candiesCount.length
0 <= favoriteDay_i <= 10^9
1 <= dailyCap_i <= 10^9
Solution
Calculate array prefixSums
, where prefixSums[i + 1] = prefixSums[i] + candiesCount[i + 1]
for i >= 0
.
For each query that contains tuple (type, day, capacity)
, the allowed range of number of candies is [prefixSums[type] + 1, prefixSums[type + 1]]
, and the possible range of number of candies is [day + 1, (day + 1) * capacity]
. The query is true
if and only if the intersection of the two ranges is nonempty.
Finally, return the array of query results.

class Solution { public boolean[] canEat(int[] candiesCount, int[][] queries) { int length = candiesCount.length; long[] prefixSums = new long[length + 1]; for (int i = 0; i < length; i++) prefixSums[i + 1] = prefixSums[i] + candiesCount[i]; int queriesCount = queries.length; boolean[] answer = new boolean[queriesCount]; for (int i = 0; i < queriesCount; i++) { int type = queries[i][0], day = queries[i][1], capacity = queries[i][2]; long minCandies = prefixSums[type] + 1, maxCandies = prefixSums[type + 1]; long minPossible = day + 1; long maxPossible = (long) (day + 1) * capacity; answer[i] = minCandies <= maxPossible && maxCandies >= minPossible; } return answer; } } ############ class Solution { public boolean[] canEat(int[] candiesCount, int[][] queries) { int n = candiesCount.length; long[] s = new long[n + 1]; for (int i = 0; i < n; ++i) { s[i + 1] = s[i] + candiesCount[i]; } int m = queries.length; boolean[] ans = new boolean[m]; for (int i = 0; i < m; ++i) { int t = queries[i][0], day = queries[i][1], mx = queries[i][2]; long least = day, most = (long) (day + 1) * mx; ans[i] = least < s[t + 1] && most > s[t]; } return ans; } }

// OJ: https://leetcode.com/problems/canyoueatyourfavoritecandyonyourfavoriteday/ // Time: O(N + Q) // Space: O(N) class Solution { public: vector<bool> canEat(vector<int>& cnt, vector<vector<int>>& Q) { vector<bool> ans(Q.size()); vector<long long> pre(cnt.size() + 1); for (int i = 0; i < cnt.size(); ++i) pre[i + 1] = pre[i] + cnt[i]; for (int i = 0; i < Q.size(); ++i) { long long type = Q[i][0], day = Q[i][1], cap = Q[i][2]; long long prev = pre[type], cur = pre[type + 1]; long long mx = cur  1, mn = prev / cap; ans[i] = day >= mn && day <= mx; } return ans; } };

class Solution: def canEat(self, candiesCount: List[int], queries: List[List[int]]) > List[bool]: s = list(accumulate(candiesCount, initial=0)) ans = [] for t, day, mx in queries: least, most = day, (day + 1) * mx ans.append(least < s[t + 1] and most > s[t]) return ans ############ # 1744. Can You Eat Your Favorite Candy on Your Favorite Day? # https://leetcode.com/problems/canyoueatyourfavoritecandyonyourfavoriteday class Solution: def canEat(self, candiesCount: List[int], queries: List[List[int]]) > List[bool]: res = [] prefix = [0] + list(accumulate(candiesCount)) for favType, day, cap in queries: if (day+1) * cap > prefix[favType] and prefix[favType+1] >= (day+1) * 1: res.append(True) else: res.append(False) return res

func canEat(candiesCount []int, queries [][]int) (ans []bool) { n := len(candiesCount) s := make([]int, n+1) for i, v := range candiesCount { s[i+1] = s[i] + v } for _, q := range queries { t, day, mx := q[0], q[1], q[2] least, most := day, (day+1)*mx ans = append(ans, least < s[t+1] && most > s[t]) } return }