Description
Given an integer array nums, return the most frequent even element.
If there is a tie, return the smallest one. If there is no such element, return -1.
Example 1:
Input: nums = [0,1,2,2,4,4,1]
Output: 2
Explanation:
The even elements are 0, 2, and 4. Of these, 2 and 4 appear the most.
We return the smallest one, which is 2.
Example 2:
Input: nums = [4,4,4,9,2,4]
Output: 4
Explanation: 4 is the even element appears the most.
Example 3:
Input: nums = [29,47,21,41,13,37,25,7]
Output: -1
Explanation: There is no even element.
Constraints:
1 <= nums.length <= 20000 <= nums[i] <= 105
Solutions
Solution 1: Hash Table
We use a hash table cnt to count the occurrence of all even elements, and then find the even element with the highest occurrence and the smallest value.
The time complexity is O(n), and the space complexity is O(n). Here, n is the length of the array.
PythonJavaC++GoTypeScriptRustPHP
class Solution:
def mostFrequentEven(self, nums: List[int]) -> int:
cnt = Counter(x for x in nums if x % 2 == 0)
ans, mx = -1, 0
for x, v in cnt.items():
if v > mx or (v == mx and ans > x):
ans, mx = x, v
return ans(code-box)
class Solution {
public int mostFrequentEven(int[] nums) {
Map<Integer, Integer> cnt = new HashMap<>();
for (int x : nums) {
if (x % 2 == 0) {
cnt.merge(x, 1, Integer::sum);
}
}
int ans = -1, mx = 0;
for (var e : cnt.entrySet()) {
int x = e.getKey(), v = e.getValue();
if (mx < v || (mx == v && ans > x)) {
ans = x;
mx = v;
}
}
return ans;
}
}(code-box)
class Solution {
public:
int mostFrequentEven(vector<int>& nums) {
unordered_map<int, int> cnt;
for (int x : nums) {
if (x % 2 == 0) {
++cnt[x];
}
}
int ans = -1, mx = 0;
for (auto& [x, v] : cnt) {
if (mx < v || (mx == v && ans > x)) {
ans = x;
mx = v;
}
}
return ans;
}
};(code-box)
func mostFrequentEven(nums []int) int {
cnt := map[int]int{}
for _, x := range nums {
if x%2 == 0 {
cnt[x]++
}
}
ans, mx := -1, 0
for x, v := range cnt {
if mx < v || (mx == v && x < ans) {
ans, mx = x, v
}
}
return ans
}(code-box)
function mostFrequentEven(nums: number[]): number {
const cnt: Map<number, number> = new Map();
for (const x of nums) {
if (x % 2 === 0) {
cnt.set(x, (cnt.get(x) ?? 0) + 1);
}
}
let ans = -1;
let mx = 0;
for (const [x, v] of cnt) {
if (mx < v || (mx === v && ans > x)) {
ans = x;
mx = v;
}
}
return ans;
}(code-box)
use std::collections::HashMap;
impl Solution {
pub fn most_frequent_even(nums: Vec<i32>) -> i32 {
let mut cnt = HashMap::new();
for &x in nums.iter() {
if x % 2 == 0 {
*cnt.entry(x).or_insert(0) += 1;
}
}
let mut ans = -1;
let mut mx = 0;
for (&x, &v) in cnt.iter() {
if mx < v || (mx == v && ans > x) {
ans = x;
mx = v;
}
}
ans
}
}(code-box)
class Solution {
/**
* @param Integer[] $nums
* @return Integer
*/
function mostFrequentEven($nums) {
$max = $rs = -1;
for ($i = 0; $i < count($nums); $i++) {
if ($nums[$i] % 2 == 0) {
$hashtable[$nums[$i]] += 1;
if (
$hashtable[$nums[$i]] > $max ||
($hashtable[$nums[$i]] == $max && $rs > $nums[$i])
) {
$max = $hashtable[$nums[$i]];
$rs = $nums[$i];
}
}
}
return $rs;
}
}(code-box)
