Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit ae1ca48

Browse files
feat: add solutions to lc problem: No.1521 (#1767)
1 parent a18ee09 commit ae1ca48

File tree

7 files changed

+323
-2
lines changed

7 files changed

+323
-2
lines changed

‎solution/1500-1599/1521.Find a Value of a Mysterious Function Closest to Target/README.md‎

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

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

53+
**方法一:哈希表 + 枚举**
54+
55+
根据题目描述,我们知道,函数 $func(arr, l, r)$ 实际上就是数组 $arr$ 下标 $l$ 到 $r$ 的元素的按位与运算的结果,即 $arr[l] \& arr[l + 1] \& \cdots \& arr[r]$。
56+
57+
如果我们每次固定右端点 $r,ドル那么左端点 $l$ 的范围是 $[0, r]$。由于按位与之和随着 $l$ 的减小而单调递减,并且 $arr[i]$ 的值不超过 10ドル^6,ドル因此区间 $[0, r]$ 最多只有 20ドル$ 种不同的值。因此,我们可以用一个集合来维护所有的 $arr[l] \& arr[l + 1] \& \cdots \& arr[r]$ 的值。当我们从 $r$ 遍历到 $r+1$ 时,以 $r+1$ 为右端点的值,就是集合中每个值与 $arr[r + 1]$ 进行按位与运算得到的值,再加上 $arr[r + 1]$ 本身。因此,我们只需要枚举集合中的每个值,与 $arr[r]$ 进行按位与运算,就可以得到以 $r$ 为右端点的所有值,将每个值与 $target$ 相减后取绝对值,就可以得到以 $r$ 为右端点的所有值与 $target$ 的差的绝对值,其中的最小值就是答案。
58+
59+
时间复杂度 $O(n \times \log M),ドル空间复杂度 $O(\log M)$。其中 $n$ 和 $M$ 分别是数组 $arr$ 的长度和数组 $arr$ 中的最大值。
60+
5361
<!-- tabs:start -->
5462

5563
### **Python3**
5664

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

5967
```python
60-
68+
class Solution:
69+
def closestToTarget(self, arr: List[int], target: int) -> int:
70+
ans = abs(arr[0] - target)
71+
s = {arr[0]}
72+
for x in arr:
73+
s = {x & y for y in s} | {x}
74+
ans = min(ans, min(abs(y - target) for y in s))
75+
return ans
6176
```
6277

6378
### **Java**
6479

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

6782
```java
83+
class Solution {
84+
public int closestToTarget(int[] arr, int target) {
85+
int ans = Math.abs(arr[0] - target);
86+
Set<Integer> pre = new HashSet<>();
87+
pre.add(arr[0]);
88+
for (int x : arr) {
89+
Set<Integer> cur = new HashSet<>();
90+
for (int y : pre) {
91+
cur.add(x & y);
92+
}
93+
cur.add(x);
94+
for (int y : cur) {
95+
ans = Math.min(ans, Math.abs(y - target));
96+
}
97+
pre = cur;
98+
}
99+
return ans;
100+
}
101+
}
102+
```
103+
104+
### **C++**
105+
106+
```cpp
107+
class Solution {
108+
public:
109+
int closestToTarget(vector<int>& arr, int target) {
110+
int ans = abs(arr[0] - target);
111+
unordered_set<int> pre;
112+
pre.insert(arr[0]);
113+
for (int x : arr) {
114+
unordered_set<int> cur;
115+
cur.insert(x);
116+
for (int y : pre) {
117+
cur.insert(x & y);
118+
}
119+
for (int y : cur) {
120+
ans = min(ans, abs(y - target));
121+
}
122+
pre = move(cur);
123+
}
124+
return ans;
125+
}
126+
};
127+
```
128+
129+
### **Go**
130+
131+
```go
132+
func closestToTarget(arr []int, target int) int {
133+
ans := abs(arr[0] - target)
134+
pre := map[int]bool{arr[0]: true}
135+
for _, x := range arr {
136+
cur := map[int]bool{x: true}
137+
for y := range pre {
138+
cur[x&y] = true
139+
}
140+
for y := range cur {
141+
ans = min(ans, abs(y-target))
142+
}
143+
pre = cur
144+
}
145+
return ans
146+
}
147+
148+
func min(a, b int) int {
149+
if a < b {
150+
return a
151+
}
152+
return b
153+
}
154+
155+
func abs(x int) int {
156+
if x < 0 {
157+
return -x
158+
}
159+
return x
160+
}
161+
```
68162

163+
### **TypeScript**
164+
165+
```ts
166+
function closestToTarget(arr: number[], target: number): number {
167+
let ans = Math.abs(arr[0] - target);
168+
let pre = new Set<number>();
169+
pre.add(arr[0]);
170+
for (const x of arr) {
171+
const cur = new Set<number>();
172+
cur.add(x);
173+
for (const y of pre) {
174+
cur.add(x & y);
175+
}
176+
for (const y of cur) {
177+
ans = Math.min(ans, Math.abs(y - target));
178+
}
179+
pre = cur;
180+
}
181+
return ans;
182+
}
69183
```
70184

71185
### **...**

‎solution/1500-1599/1521.Find a Value of a Mysterious Function Closest to Target/README_EN.md‎

Lines changed: 115 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -47,18 +47,132 @@
4747

4848
## Solutions
4949

50+
**Solution 1: Hash Table + Enumeration**
51+
52+
According to the problem description, we know that the function $func(arr, l, r)$ is actually the bitwise AND result of the elements in the array $arr$ from index $l$ to $r,ドル i.e., $arr[l] \& arr[l + 1] \& \cdots \& arr[r]$.
53+
54+
If we fix the right endpoint $r$ each time, then the range of the left endpoint $l$ is $[0, r]$. Since the sum of bitwise ANDs decreases monotonically with decreasing $l,ドル and the value of $arr[i]$ does not exceed 10ドル^6,ドル there are at most 20ドル$ different values in the interval $[0, r]$. Therefore, we can use a set to maintain all the values of $arr[l] \& arr[l + 1] \& \cdots \& arr[r]$. When we traverse from $r$ to $r+1,ドル the value with $r+1$ as the right endpoint is the value obtained by performing bitwise AND with each value in the set and $arr[r + 1],ドル plus $arr[r + 1]$ itself. Therefore, we only need to enumerate each value in the set, perform bitwise AND with $arr[r],ドル to obtain all the values with $r$ as the right endpoint. Then we subtract each value from $target$ and take the absolute value to obtain the absolute difference between each value and $target$. The minimum value among them is the answer.
55+
56+
The time complexity is $O(n \times \log M),ドル and the space complexity is $O(\log M)$. Here, $n$ and $M$ are the length of the array $arr$ and the maximum value in the array $arr,ドル respectively.
57+
5058
<!-- tabs:start -->
5159

5260
### **Python3**
5361

5462
```python
55-
63+
class Solution:
64+
def closestToTarget(self, arr: List[int], target: int) -> int:
65+
ans = abs(arr[0] - target)
66+
s = {arr[0]}
67+
for x in arr:
68+
s = {x & y for y in s} | {x}
69+
ans = min(ans, min(abs(y - target) for y in s))
70+
return ans
5671
```
5772

5873
### **Java**
5974

6075
```java
76+
class Solution {
77+
public int closestToTarget(int[] arr, int target) {
78+
int ans = Math.abs(arr[0] - target);
79+
Set<Integer> pre = new HashSet<>();
80+
pre.add(arr[0]);
81+
for (int x : arr) {
82+
Set<Integer> cur = new HashSet<>();
83+
for (int y : pre) {
84+
cur.add(x & y);
85+
}
86+
cur.add(x);
87+
for (int y : cur) {
88+
ans = Math.min(ans, Math.abs(y - target));
89+
}
90+
pre = cur;
91+
}
92+
return ans;
93+
}
94+
}
95+
```
96+
97+
### **C++**
98+
99+
```cpp
100+
class Solution {
101+
public:
102+
int closestToTarget(vector<int>& arr, int target) {
103+
int ans = abs(arr[0] - target);
104+
unordered_set<int> pre;
105+
pre.insert(arr[0]);
106+
for (int x : arr) {
107+
unordered_set<int> cur;
108+
cur.insert(x);
109+
for (int y : pre) {
110+
cur.insert(x & y);
111+
}
112+
for (int y : cur) {
113+
ans = min(ans, abs(y - target));
114+
}
115+
pre = move(cur);
116+
}
117+
return ans;
118+
}
119+
};
120+
```
121+
122+
### **Go**
123+
124+
```go
125+
func closestToTarget(arr []int, target int) int {
126+
ans := abs(arr[0] - target)
127+
pre := map[int]bool{arr[0]: true}
128+
for _, x := range arr {
129+
cur := map[int]bool{x: true}
130+
for y := range pre {
131+
cur[x&y] = true
132+
}
133+
for y := range cur {
134+
ans = min(ans, abs(y-target))
135+
}
136+
pre = cur
137+
}
138+
return ans
139+
}
140+
141+
func min(a, b int) int {
142+
if a < b {
143+
return a
144+
}
145+
return b
146+
}
147+
148+
func abs(x int) int {
149+
if x < 0 {
150+
return -x
151+
}
152+
return x
153+
}
154+
```
61155

156+
### **TypeScript**
157+
158+
```ts
159+
function closestToTarget(arr: number[], target: number): number {
160+
let ans = Math.abs(arr[0] - target);
161+
let pre = new Set<number>();
162+
pre.add(arr[0]);
163+
for (const x of arr) {
164+
const cur = new Set<number>();
165+
cur.add(x);
166+
for (const y of pre) {
167+
cur.add(x & y);
168+
}
169+
for (const y of cur) {
170+
ans = Math.min(ans, Math.abs(y - target));
171+
}
172+
pre = cur;
173+
}
174+
return ans;
175+
}
62176
```
63177

64178
### **...**
Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
class Solution {
2+
public:
3+
int closestToTarget(vector<int>& arr, int target) {
4+
int ans = abs(arr[0] - target);
5+
unordered_set<int> pre;
6+
pre.insert(arr[0]);
7+
for (int x : arr) {
8+
unordered_set<int> cur;
9+
cur.insert(x);
10+
for (int y : pre) {
11+
cur.insert(x & y);
12+
}
13+
for (int y : cur) {
14+
ans = min(ans, abs(y - target));
15+
}
16+
pre = move(cur);
17+
}
18+
return ans;
19+
}
20+
};
Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
func closestToTarget(arr []int, target int) int {
2+
ans := abs(arr[0] - target)
3+
pre := map[int]bool{arr[0]: true}
4+
for _, x := range arr {
5+
cur := map[int]bool{x: true}
6+
for y := range pre {
7+
cur[x&y] = true
8+
}
9+
for y := range cur {
10+
ans = min(ans, abs(y-target))
11+
}
12+
pre = cur
13+
}
14+
return ans
15+
}
16+
17+
func min(a, b int) int {
18+
if a < b {
19+
return a
20+
}
21+
return b
22+
}
23+
24+
func abs(x int) int {
25+
if x < 0 {
26+
return -x
27+
}
28+
return x
29+
}
Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
class Solution {
2+
public int closestToTarget(int[] arr, int target) {
3+
int ans = Math.abs(arr[0] - target);
4+
Set<Integer> pre = new HashSet<>();
5+
pre.add(arr[0]);
6+
for (int x : arr) {
7+
Set<Integer> cur = new HashSet<>();
8+
for (int y : pre) {
9+
cur.add(x & y);
10+
}
11+
cur.add(x);
12+
for (int y : cur) {
13+
ans = Math.min(ans, Math.abs(y - target));
14+
}
15+
pre = cur;
16+
}
17+
return ans;
18+
}
19+
}
Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
class Solution:
2+
def closestToTarget(self, arr: List[int], target: int) -> int:
3+
ans = abs(arr[0] - target)
4+
s = {arr[0]}
5+
for x in arr:
6+
s = {x & y for y in s} | {x}
7+
ans = min(ans, min(abs(y - target) for y in s))
8+
return ans
Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
function closestToTarget(arr: number[], target: number): number {
2+
let ans = Math.abs(arr[0] - target);
3+
let pre = new Set<number>();
4+
pre.add(arr[0]);
5+
for (const x of arr) {
6+
const cur = new Set<number>();
7+
cur.add(x);
8+
for (const y of pre) {
9+
cur.add(x & y);
10+
}
11+
for (const y of cur) {
12+
ans = Math.min(ans, Math.abs(y - target));
13+
}
14+
pre = cur;
15+
}
16+
return ans;
17+
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /