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 **(0-indexed)** 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 type`i - 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 non-empty.

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