feat: add solutions for lc No.2032 (#5175)

Author: yanglbme

solution/2000-2099/2032.Two Out of Three/README.md

@@ -159,54 +159,49 @@ func twoOutOfThree(nums1 []int, nums2 []int, nums3 []int) (ans []int) {
 
 ```ts
 function twoOutOfThree(nums1: number[], nums2: number[], nums3: number[]): number[] {
-    const count = new Array(101).fill(0);
-    new Set(nums1).forEach(v => count[v]++);
-    new Set(nums2).forEach(v => count[v]++);
-    new Set(nums3).forEach(v => count[v]++);
-    const ans = [];
-    count.forEach((v, i) => {
-        if (v >= 2) {
+    const get = (nums: number[]): number[] => {
+        const s = new Array(101).fill(0);
+        for (const v of nums) {
+            s[v] = 1;
+        }
+        return s;
+    };
+
+    const s1 = get(nums1), s2 = get(nums2), s3 = get(nums3);
+    const ans: number[] = [];
+
+    for (let i = 1; i <= 100; i++) {
+        if (s1[i] + s2[i] + s3[i] > 1) {
             ans.push(i);
         }
-    });
+    }
     return ans;
-}
+};
 ```
 
 #### Rust
 
 ```rust
-use std::collections::HashSet;
 impl Solution {
     pub fn two_out_of_three(nums1: Vec<i32>, nums2: Vec<i32>, nums3: Vec<i32>) -> Vec<i32> {
-        let mut count = vec![0; 101];
-        nums1
-            .into_iter()
-            .collect::<HashSet<i32>>()
-            .iter()
-            .for_each(|&v| {
-                count[v as usize] += 1;
-            });
-        nums2
-            .into_iter()
-            .collect::<HashSet<i32>>()
-            .iter()
-            .for_each(|&v| {
-                count[v as usize] += 1;
-            });
-        nums3
-            .into_iter()
-            .collect::<HashSet<i32>>()
-            .iter()
-            .for_each(|&v| {
-                count[v as usize] += 1;
-            });
+        let get = |nums: Vec<i32>| -> [i32; 101] {
+            let mut s = [0; 101];
+            for v in nums {
+                s[v as usize] = 1;
+            }
+            s
+        };
+
+        let s1 = get(nums1);
+        let s2 = get(nums2);
+        let s3 = get(nums3);
         let mut ans = Vec::new();
-        count.iter().enumerate().for_each(|(i, v)| {
-            if *v >= 2 {
+
+        for i in 1..=100 {
+            if s1[i] + s2[i] + s3[i] > 1 {
                 ans.push(i as i32);
             }
-        });
+        }
         ans
     }
 }
@@ -216,4 +211,145 @@ impl Solution {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### 方法二：哈希表 + 位运算
+
+我们可以用一个哈希表 $\textit{mask}$ 来记录每个数在哪些数组中出现过。对于每个数组，我们将其中的元素加入哈希表中，并将对应的位设置为 $1$。例如，如果是第一个数组，则将对应的位设置为 $1$；如果是第二个数组，则将对应的位设置为 $2$；如果是第三个数组，则将对应的位设置为 $4$。
+
+最后，我们枚举哈希表中的每个数，判断其对应的值对应的二进制位中是否至少有两位为 $1$，如果是，则将该数加入答案数组中。
+
+时间复杂度 $O(n_1 + n_2 + n_3)$，空间复杂度 $O(n_1 + n_2 + n_3)$。其中 $n_1, n_2, n_3$ 分别为数组 $\textit{nums1}$, $\textit{nums2}$ 和 $\textit{nums3}$ 的长度。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def twoOutOfThree(
+        self, nums1: List[int], nums2: List[int], nums3: List[int]
+    ) -> List[int]:
+        mask = defaultdict(int)
+        for i, nums in enumerate((nums1, nums2, nums3)):
+            for x in nums:
+                mask[x] |= 1 << i
+        return [x for x, v in mask.items() if v & (v - 1)]
+```
+
+#### Java
+
+```java
+class Solution {
+    public List<Integer> twoOutOfThree(int[] nums1, int[] nums2, int[] nums3) {
+        Map<Integer, Integer> mask = new HashMap<>();
+        int[][] nums = {nums1, nums2, nums3};
+        for (int i = 0; i < 3; i++) {
+            for (int x : nums[i]) {
+                mask.merge(x, 1 << i, (oldVal, newVal) -> oldVal | newVal);
+            }
+        }
+        List<Integer> ans = new ArrayList<>();
+        for (var e : mask.entrySet()) {
+            if ((e.getValue() & (e.getValue() - 1)) != 0) {
+                ans.add(e.getKey());
+            }
+        }
+        return ans;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    vector<int> twoOutOfThree(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3) {
+        unordered_map<int, int> mask;
+        vector<vector<int>*> all = {&nums1, &nums2, &nums3};
+
+        for (int i = 0; i < 3; ++i) {
+            for (int x : *all[i]) {
+                mask[x] |= (1 << i);
+            }
+        }
+
+        vector<int> ans;
+        for (auto& [x, m] : mask) {
+            if (m & (m - 1)) {
+                ans.push_back(x);
+            }
+        }
+        return ans;
+    }
+};
+```
+
+#### Go
+
+```go
+func twoOutOfThree(nums1 []int, nums2 []int, nums3 []int) (ans []int) {
+	mask := make(map[int]int)
+	for i, nums := range [][]int{nums1, nums2, nums3} {
+		for _, x := range nums {
+			mask[x] |= 1 << i
+		}
+	}
+	for x, m := range mask {
+		if m&(m-1) != 0 {
+			ans = append(ans, x)
+		}
+	}
+	return
+}
+```
+
+#### TypeScript
+
+```ts
+function twoOutOfThree(nums1: number[], nums2: number[], nums3: number[]): number[] {
+    const mask = new Map<number, number>();
+    const all = [nums1, nums2, nums3];
+
+    all.forEach((nums, i) => {
+        for (const x of nums) {
+            mask.set(x, (mask.get(x) || 0) | (1 << i));
+        }
+    });
+
+    return Array.from(mask.entries())
+        .filter(([_, m]) => (m & (m - 1)) !== 0)
+        .map(([x, _]) => x);
+};
+```
+
+#### Rust
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn two_out_of_three(nums1: Vec<i32>, nums2: Vec<i32>, nums3: Vec<i32>) -> Vec<i32> {
+        let mut mask = HashMap::new();
+        let all = vec![nums1, nums2, nums3];
+
+        for (i, nums) in all.into_iter().enumerate() {
+            for x in nums {
+                *mask.entry(x).or_insert(0) |= 1 << i;
+            }
+        }
+
+        mask.into_iter()
+            .filter(|&(_, m)| m & (m - 1) != 0)
+            .map(|(x, _)| x)
+            .collect()
+    }
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->