Skip to content

Commit 531383c

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0875. Koko Eating Bananas
1 parent a899e74 commit 531383c

File tree

10 files changed

+392
-17
lines changed

10 files changed

+392
-17
lines changed

Diff for: ‎solution/0800-0899/0875.Koko Eating Bananas/README.md

+94-1
Original file line numberDiff line numberDiff line change
@@ -52,22 +52,115 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55+
二分查找。
56+
5557
<!-- tabs:start -->
5658

5759
### **Python3**
5860

5961
<!-- 这里可写当前语言的特殊实现逻辑 -->
6062

6163
```python
62-
64+
class Solution:
65+
def minEatingSpeed(self, piles: List[int], h: int) -> int:
66+
left, right = 1, sum(piles)
67+
while left < right:
68+
mid = (left + right) >> 1
69+
s = sum([(pile + mid - 1) // mid for pile in piles])
70+
if s <= h:
71+
right = mid
72+
else:
73+
left = mid + 1
74+
return left
6375
```
6476

6577
### **Java**
6678

6779
<!-- 这里可写当前语言的特殊实现逻辑 -->
6880

6981
```java
82+
class Solution {
83+
public int minEatingSpeed(int[] piles, int h) {
84+
int mx = 0;
85+
for (int pile : piles) {
86+
mx = Math.max(mx, pile);
87+
}
88+
int left = 1, right = mx;
89+
while (left < right) {
90+
int mid = (left + right) >>> 1;
91+
int s = 0;
92+
for (int pile : piles) {
93+
s += (pile + mid - 1) / mid;
94+
}
95+
if (s <= h) {
96+
right = mid;
97+
} else {
98+
left = mid + 1;
99+
}
100+
}
101+
return left;
102+
}
103+
}
104+
```
105+
106+
### **C++**
107+
108+
```cpp
109+
class Solution {
110+
public:
111+
int minEatingSpeed(vector<int>& piles, int h) {
112+
int mx = 0;
113+
for (auto pile : piles) {
114+
mx = max(mx, pile);
115+
}
116+
int left = 1, right = mx;
117+
while (left < right) {
118+
int mid = left + right >> 1;
119+
int s = 0;
120+
for (auto pile : piles) {
121+
s += (pile + mid - 1) / mid;
122+
}
123+
if (s <= h) {
124+
right = mid;
125+
} else {
126+
left = mid + 1;
127+
}
128+
}
129+
return left;
130+
}
131+
};
132+
```
70133
134+
### **Go**
135+
136+
```go
137+
func minEatingSpeed(piles []int, h int) int {
138+
mx := 0
139+
for _, pile := range piles {
140+
mx = max(mx, pile)
141+
}
142+
left, right := 1, mx
143+
for left < right {
144+
mid := (left + right) >> 1
145+
s := 0
146+
for _, pile := range piles {
147+
s += (pile + mid - 1) / mid
148+
}
149+
if s <= h {
150+
right = mid
151+
} else {
152+
left = mid + 1
153+
}
154+
}
155+
return left
156+
}
157+
158+
func max(a, b int) int {
159+
if a > b {
160+
return a
161+
}
162+
return b
163+
}
71164
```
72165

73166
### **...**

Diff for: ‎solution/0800-0899/0875.Koko Eating Bananas/README_EN.md

+94-1
Original file line numberDiff line numberDiff line change
@@ -46,18 +46,111 @@
4646

4747
## Solutions
4848

49+
Binary search.
50+
4951
<!-- tabs:start -->
5052

5153
### **Python3**
5254

5355
```python
54-
56+
class Solution:
57+
def minEatingSpeed(self, piles: List[int], h: int) -> int:
58+
left, right = 1, sum(piles)
59+
while left < right:
60+
mid = (left + right) >> 1
61+
s = sum([(pile + mid - 1) // mid for pile in piles])
62+
if s <= h:
63+
right = mid
64+
else:
65+
left = mid + 1
66+
return left
5567
```
5668

5769
### **Java**
5870

5971
```java
72+
class Solution {
73+
public int minEatingSpeed(int[] piles, int h) {
74+
int mx = 0;
75+
for (int pile : piles) {
76+
mx = Math.max(mx, pile);
77+
}
78+
int left = 1, right = mx;
79+
while (left < right) {
80+
int mid = (left + right) >>> 1;
81+
int s = 0;
82+
for (int pile : piles) {
83+
s += (pile + mid - 1) / mid;
84+
}
85+
if (s <= h) {
86+
right = mid;
87+
} else {
88+
left = mid + 1;
89+
}
90+
}
91+
return left;
92+
}
93+
}
94+
```
95+
96+
### **C++**
97+
98+
```cpp
99+
class Solution {
100+
public:
101+
int minEatingSpeed(vector<int>& piles, int h) {
102+
int mx = 0;
103+
for (auto pile : piles) {
104+
mx = max(mx, pile);
105+
}
106+
int left = 1, right = mx;
107+
while (left < right) {
108+
int mid = left + right >> 1;
109+
int s = 0;
110+
for (auto pile : piles) {
111+
s += (pile + mid - 1) / mid;
112+
}
113+
if (s <= h) {
114+
right = mid;
115+
} else {
116+
left = mid + 1;
117+
}
118+
}
119+
return left;
120+
}
121+
};
122+
```
60123
124+
### **Go**
125+
126+
```go
127+
func minEatingSpeed(piles []int, h int) int {
128+
mx := 0
129+
for _, pile := range piles {
130+
mx = max(mx, pile)
131+
}
132+
left, right := 1, mx
133+
for left < right {
134+
mid := (left + right) >> 1
135+
s := 0
136+
for _, pile := range piles {
137+
s += (pile + mid - 1) / mid
138+
}
139+
if s <= h {
140+
right = mid
141+
} else {
142+
left = mid + 1
143+
}
144+
}
145+
return left
146+
}
147+
148+
func max(a, b int) int {
149+
if a > b {
150+
return a
151+
}
152+
return b
153+
}
61154
```
62155

63156
### **...**

Diff for: ‎solution/0800-0899/0875.Koko Eating Bananas/Solution.cpp

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public:
3+
int minEatingSpeed(vector<int>& piles, int h) {
4+
int mx = 0;
5+
for (auto pile : piles) {
6+
mx = max(mx, pile);
7+
}
8+
int left = 1, right = mx;
9+
while (left < right) {
10+
int mid = left + right >> 1;
11+
int s = 0;
12+
for (auto pile : piles) {
13+
s += (pile + mid - 1) / mid;
14+
}
15+
if (s <= h) {
16+
right = mid;
17+
} else {
18+
left = mid + 1;
19+
}
20+
}
21+
return left;
22+
}
23+
};

Diff for: ‎solution/0800-0899/0875.Koko Eating Bananas/Solution.go

+27
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
func minEatingSpeed(piles []int, h int) int {
2+
mx := 0
3+
for _, pile := range piles {
4+
mx = max(mx, pile)
5+
}
6+
left, right := 1, mx
7+
for left < right {
8+
mid := (left + right) >> 1
9+
s := 0
10+
for _, pile := range piles {
11+
s += (pile + mid - 1) / mid
12+
}
13+
if s <= h {
14+
right = mid
15+
} else {
16+
left = mid + 1
17+
}
18+
}
19+
return left
20+
}
21+
22+
func max(a, b int) int {
23+
if a > b {
24+
return a
25+
}
26+
return b
27+
}

Diff for: ‎solution/0800-0899/0875.Koko Eating Bananas/Solution.java

+18-15
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,22 @@
11
class Solution {
2-
public int minEatingSpeed(int[] piles, int H) {
3-
int l = 1, r = 1000000000;
4-
while (l < r) {
5-
int mid = l + r >>> 1;
6-
if (check(piles, H, mid)) r = mid;
7-
else l = mid + 1;
8-
}
9-
return r;
10-
}
11-
12-
private boolean check(int[] piles, int h, int k) {
13-
int cnt = 0;
2+
public int minEatingSpeed(int[] piles, int h) {
3+
int mx = 0;
144
for (int pile : piles) {
15-
cnt += (pile - 1) / k + 1;
5+
mx = Math.max(mx, pile);
6+
}
7+
int left = 1, right = mx;
8+
while (left < right) {
9+
int mid = (left + right) >>> 1;
10+
int s = 0;
11+
for (int pile : piles) {
12+
s += (pile + mid - 1) / mid;
13+
}
14+
if (s <= h) {
15+
right = mid;
16+
} else {
17+
left = mid + 1;
18+
}
1619
}
17-
return cnt <= h;
20+
return left;
1821
}
19-
}
22+
}

Diff for: ‎solution/0800-0899/0875.Koko Eating Bananas/Solution.py

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
class Solution:
2+
def minEatingSpeed(self, piles: List[int], h: int) -> int:
3+
left, right = 1, sum(piles)
4+
while left < right:
5+
mid = (left + right) >> 1
6+
s = sum([(pile + mid - 1) // mid for pile in piles])
7+
if s <= h:
8+
right = mid
9+
else:
10+
left = mid + 1
11+
return left

Diff for: ‎solution/0800-0899/0876.Middle of the Linked List/README.md

+45
Original file line numberDiff line numberDiff line change
@@ -116,6 +116,51 @@ function middleNode(head: ListNode | null): ListNode | null {
116116
};
117117
```
118118

119+
### **C++**
120+
121+
```cpp
122+
/**
123+
* Definition for singly-linked list.
124+
* struct ListNode {
125+
* int val;
126+
* ListNode *next;
127+
* ListNode() : val(0), next(nullptr) {}
128+
* ListNode(int x) : val(x), next(nullptr) {}
129+
* ListNode(int x, ListNode *next) : val(x), next(next) {}
130+
* };
131+
*/
132+
class Solution {
133+
public:
134+
ListNode* middleNode(ListNode* head) {
135+
ListNode *slow = head, *fast = head;
136+
while (fast && fast->next) {
137+
slow = slow->next;
138+
fast = fast->next->next;
139+
}
140+
return slow;
141+
}
142+
};
143+
```
144+
145+
### **Go**
146+
147+
```go
148+
/**
149+
* Definition for singly-linked list.
150+
* type ListNode struct {
151+
* Val int
152+
* Next *ListNode
153+
* }
154+
*/
155+
func middleNode(head *ListNode) *ListNode {
156+
slow, fast := head, head
157+
for fast != nil && fast.Next != nil {
158+
slow, fast = slow.Next, fast.Next.Next
159+
}
160+
return slow
161+
}
162+
```
163+
119164
### **...**
120165

121166
```

0 commit comments

Comments
 (0)