Welcome to Subscribe On Youtube
1744. Can You Eat Your Favorite Candy on Your Favorite Day
Description
You are given a (0indexed) array of positive integers candiesCount
where candiesCount[i]
represents the number of candies of the i^{th}
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}
Solutions

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; } }

using ll = long long; class Solution { public: vector<bool> canEat(vector<int>& candiesCount, vector<vector<int>>& queries) { int n = candiesCount.size(); vector<ll> s(n + 1); for (int i = 0; i < n; ++i) s[i + 1] = s[i] + candiesCount[i]; vector<bool> ans; for (auto& q : queries) { int t = q[0], day = q[1], mx = q[2]; ll least = day, most = 1ll * (day + 1) * mx; ans.emplace_back(least < s[t + 1] && most > s[t]); } 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

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 }