Skip to content

Commit ed90078

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1058
No.1058.Minimize Rounding Error to Meet Target
1 parent af34ba2 commit ed90078

File tree

6 files changed

+319
-2
lines changed

6 files changed

+319
-2
lines changed

‎solution/1000-1099/1058.Minimize Rounding Error to Meet Target/README.md

Lines changed: 116 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -50,22 +50,137 @@
5050

5151
<!-- 这里可写通用的实现逻辑 -->
5252

53+
**方法一：贪心 + 排序**
54+
55+
遍历价格数组 `prices`，先将每个价格 $p$ 向下舍入，累加到 `mi` 中，同时将每个价格的小数点部分添加到数组 `arr` 中。
56+
57+
遍历结束后，判断 `target` 是否在 `mi` 和 `mi + arr.length` 之间，如果不在，直接返回 `"-1"`。
58+
59+
接下来，我们计算 `target - mi`，即需要向上入的价格个数，然后将 `arr` 从大到小排序，从前往后遍历，将前 `target - mi` 个价格向上入，其余价格向下舍入，累计到 `ans` 中。
60+
61+
时间复杂度 $O(n\log n)$。其中 $n$ 为 `prices` 的长度。
62+
5363
<!-- tabs:start -->
5464

5565
### **Python3**
5666

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

5969
```python
60-
70+
class Solution:
71+
def minimizeError(self, prices: List[str], target: int) -> str:
72+
mi = 0
73+
arr = []
74+
for p in prices:
75+
p = float(p)
76+
mi += int(p)
77+
if d := p - int(p):
78+
arr.append(d)
79+
if not mi <= target <= mi + len(arr):
80+
return "-1"
81+
d = target - mi
82+
arr.sort(reverse=True)
83+
ans = d - sum(arr[:d]) + sum(arr[d:])
84+
return f'{ans:.3f}'
6185
```
6286

6387
### **Java**
6488

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

6791
```java
92+
class Solution {
93+
public String minimizeError(String[] prices, int target) {
94+
int mi = 0;
95+
List<Double> arr = new ArrayList<>();
96+
for (String p : prices) {
97+
double price = Double.valueOf(p);
98+
mi += (int) price;
99+
double d = price - (int) price;
100+
if (d > 0) {
101+
arr.add(d);
102+
}
103+
}
104+
if (target < mi || target > mi + arr.size()) {
105+
return "-1";
106+
}
107+
int d = target - mi;
108+
arr.sort(Collections.reverseOrder());
109+
double ans = d;
110+
for (int i = 0; i < d; ++i) {
111+
ans -= arr.get(i);
112+
}
113+
for (int i = d; i < arr.size(); ++i) {
114+
ans += arr.get(i);
115+
}
116+
DecimalFormat df = new DecimalFormat("#0.000");
117+
return df.format(ans);
118+
}
119+
}
120+
```
121+
122+
### **C++**
123+
124+
```cpp
125+
class Solution {
126+
public:
127+
string minimizeError(vector<string>& prices, int target) {
128+
int mi = 0;
129+
vector<double> arr;
130+
for (auto& p : prices) {
131+
double price = stod(p);
132+
mi += (int) price;
133+
double d = price - (int) price;
134+
if (d > 0) {
135+
arr.push_back(d);
136+
}
137+
}
138+
if (target < mi || target > mi + arr.size()) {
139+
return "-1";
140+
}
141+
int d = target - mi;
142+
sort(arr.rbegin(), arr.rend());
143+
double ans = d;
144+
for (int i = 0; i < d; ++i) {
145+
ans -= arr[i];
146+
}
147+
for (int i = d; i < arr.size(); ++i) {
148+
ans += arr[i];
149+
}
150+
string s = to_string(ans);
151+
return s.substr(0, s.find('.') + 4);
152+
}
153+
};
154+
```
68155
156+
### **Go**
157+
158+
```go
159+
func minimizeError(prices []string, target int) string {
160+
arr := []float64{}
161+
mi := 0
162+
for _, p := range prices {
163+
price, _ := strconv.ParseFloat(p, 64)
164+
mi += int(math.Floor(price))
165+
d := price - float64(math.Floor(price))
166+
if d > 0 {
167+
arr = append(arr, d)
168+
}
169+
}
170+
if target < mi || target > mi+len(arr) {
171+
return "-1"
172+
}
173+
d := target - mi
174+
sort.Float64s(arr)
175+
ans := float64(d)
176+
for i := 0; i < d; i++ {
177+
ans -= arr[len(arr)-i-1]
178+
}
179+
for i := d; i < len(arr); i++ {
180+
ans += arr[len(arr)-i-1]
181+
}
182+
return fmt.Sprintf("%.3f", ans)
183+
}
69184
```
70185

71186
### **...**

‎solution/1000-1099/1058.Minimize Rounding Error to Meet Target/README_EN.md

Lines changed: 106 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,13 +49,118 @@ Use Floor, Ceil and Ceil operations to get (0.7 - 0) + (3 - 2.8) + (5 - 4.9) = 0
4949
### **Python3**
5050

5151
```python
52-
52+
class Solution:
53+
def minimizeError(self, prices: List[str], target: int) -> str:
54+
mi = 0
55+
arr = []
56+
for p in prices:
57+
p = float(p)
58+
mi += int(p)
59+
if d := p - int(p):
60+
arr.append(d)
61+
if not mi <= target <= mi + len(arr):
62+
return "-1"
63+
d = target - mi
64+
arr.sort(reverse=True)
65+
ans = d - sum(arr[:d]) + sum(arr[d:])
66+
return f'{ans:.3f}'
5367
```
5468

5569
### **Java**
5670

5771
```java
72+
class Solution {
73+
public String minimizeError(String[] prices, int target) {
74+
int mi = 0;
75+
List<Double> arr = new ArrayList<>();
76+
for (String p : prices) {
77+
double price = Double.valueOf(p);
78+
mi += (int) price;
79+
double d = price - (int) price;
80+
if (d > 0) {
81+
arr.add(d);
82+
}
83+
}
84+
if (target < mi || target > mi + arr.size()) {
85+
return "-1";
86+
}
87+
int d = target - mi;
88+
arr.sort(Collections.reverseOrder());
89+
double ans = d;
90+
for (int i = 0; i < d; ++i) {
91+
ans -= arr.get(i);
92+
}
93+
for (int i = d; i < arr.size(); ++i) {
94+
ans += arr.get(i);
95+
}
96+
DecimalFormat df = new DecimalFormat("#0.000");
97+
return df.format(ans);
98+
}
99+
}
100+
```
101+
102+
### **C++**
103+
104+
```cpp
105+
class Solution {
106+
public:
107+
string minimizeError(vector<string>& prices, int target) {
108+
int mi = 0;
109+
vector<double> arr;
110+
for (auto& p : prices) {
111+
double price = stod(p);
112+
mi += (int) price;
113+
double d = price - (int) price;
114+
if (d > 0) {
115+
arr.push_back(d);
116+
}
117+
}
118+
if (target < mi || target > mi + arr.size()) {
119+
return "-1";
120+
}
121+
int d = target - mi;
122+
sort(arr.rbegin(), arr.rend());
123+
double ans = d;
124+
for (int i = 0; i < d; ++i) {
125+
ans -= arr[i];
126+
}
127+
for (int i = d; i < arr.size(); ++i) {
128+
ans += arr[i];
129+
}
130+
string s = to_string(ans);
131+
return s.substr(0, s.find('.') + 4);
132+
}
133+
};
134+
```
58135
136+
### **Go**
137+
138+
```go
139+
func minimizeError(prices []string, target int) string {
140+
arr := []float64{}
141+
mi := 0
142+
for _, p := range prices {
143+
price, _ := strconv.ParseFloat(p, 64)
144+
mi += int(math.Floor(price))
145+
d := price - float64(math.Floor(price))
146+
if d > 0 {
147+
arr = append(arr, d)
148+
}
149+
}
150+
if target < mi || target > mi+len(arr) {
151+
return "-1"
152+
}
153+
d := target - mi
154+
sort.Float64s(arr)
155+
ans := float64(d)
156+
for i := 0; i < d; i++ {
157+
ans -= arr[len(arr)-i-1]
158+
}
159+
for i := d; i < len(arr); i++ {
160+
ans += arr[len(arr)-i-1]
161+
}
162+
return fmt.Sprintf("%.3f", ans)
163+
}
59164
```
60165

61166
### **...**

‎solution/1000-1099/1058.Minimize Rounding Error to Meet Target/Solution.cpp

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
class Solution {
2+
public:
3+
string minimizeError(vector<string>& prices, int target) {
4+
int mi = 0;
5+
vector<double> arr;
6+
for (auto& p : prices) {
7+
double price = stod(p);
8+
mi += (int) price;
9+
double d = price - (int) price;
10+
if (d > 0) {
11+
arr.push_back(d);
12+
}
13+
}
14+
if (target < mi || target > mi + arr.size()) {
15+
return "-1";
16+
}
17+
int d = target - mi;
18+
sort(arr.rbegin(), arr.rend());
19+
double ans = d;
20+
for (int i = 0; i < d; ++i) {
21+
ans -= arr[i];
22+
}
23+
for (int i = d; i < arr.size(); ++i) {
24+
ans += arr[i];
25+
}
26+
string s = to_string(ans);
27+
return s.substr(0, s.find('.') + 4);
28+
}
29+
};

‎solution/1000-1099/1058.Minimize Rounding Error to Meet Target/Solution.go

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
func minimizeError(prices []string, target int) string {
2+
arr := []float64{}
3+
mi := 0
4+
for _, p := range prices {
5+
price, _ := strconv.ParseFloat(p, 64)
6+
mi += int(math.Floor(price))
7+
d := price - float64(math.Floor(price))
8+
if d > 0 {
9+
arr = append(arr, d)
10+
}
11+
}
12+
if target < mi || target > mi+len(arr) {
13+
return "-1"
14+
}
15+
d := target - mi
16+
sort.Float64s(arr)
17+
ans := float64(d)
18+
for i := 0; i < d; i++ {
19+
ans -= arr[len(arr)-i-1]
20+
}
21+
for i := d; i < len(arr); i++ {
22+
ans += arr[len(arr)-i-1]
23+
}
24+
return fmt.Sprintf("%.3f", ans)
25+
}

‎solution/1000-1099/1058.Minimize Rounding Error to Meet Target/Solution.java

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
public String minimizeError(String[] prices, int target) {
3+
int mi = 0;
4+
List<Double> arr = new ArrayList<>();
5+
for (String p : prices) {
6+
double price = Double.valueOf(p);
7+
mi += (int) price;
8+
double d = price - (int) price;
9+
if (d > 0) {
10+
arr.add(d);
11+
}
12+
}
13+
if (target < mi || target > mi + arr.size()) {
14+
return "-1";
15+
}
16+
int d = target - mi;
17+
arr.sort(Collections.reverseOrder());
18+
double ans = d;
19+
for (int i = 0; i < d; ++i) {
20+
ans -= arr.get(i);
21+
}
22+
for (int i = d; i < arr.size(); ++i) {
23+
ans += arr.get(i);
24+
}
25+
DecimalFormat df = new DecimalFormat("#0.000");
26+
return df.format(ans);
27+
}
28+
}

‎solution/1000-1099/1058.Minimize Rounding Error to Meet Target/Solution.py

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
class Solution:
2+
def minimizeError(self, prices: List[str], target: int) -> str:
3+
mi = 0
4+
arr = []
5+
for p in prices:
6+
p = float(p)
7+
mi += int(p)
8+
if d := p - int(p):
9+
arr.append(d)
10+
if not mi <= target <= mi + len(arr):
11+
return "-1"
12+
d = target - mi
13+
arr.sort(reverse=True)
14+
ans = d - sum(arr[:d]) + sum(arr[d:])
15+
return f'{ans:.3f}'

0 commit comments

Comments
 (0)