feat: add solutions to lc problem: No.1744

No.1744.Can You Eat Your Favorite Candy on Your Favorite Day

Author: yanglbme

solution/1700-1799/1744.Can You Eat Your Favorite Candy on Your Favorite Day/README.md

@@ -65,22 +65,89 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：前缀和**
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `candiesCount` 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+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
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+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;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+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;
+    }
+};
+```
 
+### **Go**
+
+```go
+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
+}
 ```
 
 ### **...**

solution/1700-1799/1744.Can You Eat Your Favorite Candy on Your Favorite Day/README_EN.md

@@ -59,13 +59,76 @@
 ### **Python3**
 
 ```python
-
+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
 ```
 
 ### **Java**
 
 ```java
+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;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+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;
+    }
+};
+```
 
+### **Go**
+
+```go
+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
+}
 ```
 
 ### **...**

solution/1700-1799/1744.Can You Eat Your Favorite Candy on Your Favorite Day/Solution.cpp

@@ -0,0 +1,17 @@
+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;
+    }
+};

solution/1700-1799/1744.Can You Eat Your Favorite Candy on Your Favorite Day/Solution.go

@@ -0,0 +1,13 @@
+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
+}

solution/1700-1799/1744.Can You Eat Your Favorite Candy on Your Favorite Day/Solution.java

@@ -0,0 +1,17 @@
+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;
+    }
+}

solution/1700-1799/1744.Can You Eat Your Favorite Candy on Your Favorite Day/Solution.py

@@ -0,0 +1,8 @@
+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