2025-12-05：检查元素频次是否为质数。用go语言，给定一个整数数组 nums，判断数组中是否存在某个数，它在数组中出现的次数是质数。若至少有一个元素的出现次数为质数则返回 true，否则返回 false。说明：质数指大于1且只有1和自身两个正因数的整数。

1 <= nums.length <= 100。

0 <= nums[i] <= 100。

输入： nums = [1,2,3,4,5,4]。

输出： true。

解释：

数字 4 的频次是 2，而 2 是质数。

题目来自力扣3591。

自然智慧即可。

📝 步骤详解

1. 统计元素频率
   程序首先创建一个空的映射（map）cnt，用于记录每个整数在数组 nums 中出现的次数。接着，遍历整个 nums 数组。对于数组中的每一个元素 x，都在映射 cnt 中将其对应的计数值加 1。遍历结束后，映射 cnt 中就存储了每个不同数字在数组中出现的频次 。

2. 检查频次是否为质数
   获得频率统计后，程序开始遍历映射 cnt 中的所有值，即每个数字的出现频次 c。对于每一个频次 c，程序使用 Go 标准库 math/big 中的 ProbablyPrime(0) 方法来判断其是否为质数 。这个方法对质数的判断是确定性的（当入参为 0 时），能够准确判断 c 是否是质数。

3. 返回判断结果
   在遍历频次的过程中，只要发现任何一个频次 c 被确认为质数，函数会立即返回 true，表示数组中存在出现次数为质数的元素。如果遍历完所有的频次后，都没有发现质数频次，函数则返回 false 。

⏱️ 复杂度分析

• 总的时间复杂度：O(N + K * M)。

  • N 是数组 nums 的长度。第一步统计频率需要遍历整个数组，时间复杂度为 O(N)。
  • K 是数组中不同数字的个数（即映射 cnt 的大小）。在最坏情况下，所有数字都不同，K 等于 N。
  • M 是判断一个最大为 N 的数是否为质数所需的时间复杂度。ProbablyPrime(0) 方法对于 N 的最大值 100 来说是非常高效的。
  • 因此，总体时间复杂度是线性的 O(N)。

• 总的额外空间复杂度：O(N)。

  • 主要的空间开销来自于存储频率统计的映射 cnt。在最坏情况下（所有元素都不同），该映射需要存储 N 个键值对，因此空间复杂度为 O(N) 。

Go完整代码如下：

package main

import (
	"fmt"
	"math/big"
)

func checkPrimeFrequency(nums []int) bool {
	cnt := map[int]int{}
	for _, x := range nums {
		cnt[x]++
	}
	for _, c := range cnt {
		if big.NewInt(int64(c)).ProbablyPrime(0) {
			return true
		}
	}
	return false
}

func main() {
	nums := []int{1, 2, 3, 4, 5, 4}
	result := checkPrimeFrequency(nums)
	fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

from collections import Counter
import sympy

def check_prime_frequency(nums):
    """
    检查数组中是否有数字的出现频率是质数
    
    参数:
        nums: 整数列表
        
    返回:
        bool: 如果存在出现频率为质数的数字则返回True，否则返回False
    """
    # 统计每个数字出现的频率
    freq = Counter(nums)
    
    # 检查每个频率值是否为质数
    for count in freq.values():
        # 使用sympy的isprime函数检查质数
        # 注意：sympy.isprime对小于2的数返回False
        if sympy.isprime(count):
            return True
    
    return False

# 测试样例
if __name__ == "__main__":
    nums = [1, 2, 3, 4, 5, 4]
    result = check_prime_frequency(nums)
    print(result)  # 输出: True
    
    # 更多测试用例
    test_cases = [
        [1, 1, 2, 2, 3],  # 频率: 1(2次), 2(2次), 3(1次) - 质数频率2
        [1, 1, 1],        # 频率: 1(3次) - 质数频率3
        [1, 2, 3],        # 频率: 1(1次), 2(1次), 3(1次) - 没有质数频率
        [],               # 空数组 - 没有质数频率
        [5, 5, 5, 5],     # 频率: 5(4次) - 4不是质数
    ]
    
    for i, test in enumerate(test_cases, 1):
        print(f"测试用例{i}: {test} -> {check_prime_frequency(test)}")

C++完整代码如下：

#include <iostream>
#include <unordered_map>
#include <vector>
#include <cmath>

// 判断一个数是否为质数
bool isPrime(int n) {
    if (n <= 1) return false;      // 1及以下的数不是质数
    if (n <= 3) return true;       // 2和3是质数
    if (n % 2 == 0 || n % 3 == 0) return false;  // 能被2或3整除的不是质数

    // 检查6k±1形式的因子
    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) {
            return false;
        }
    }
    return true;
}

// 检查数组中是否有数字的出现频率是质数
bool checkPrimeFrequency(const std::vector<int>& nums) {
    // 使用哈希表统计每个数字的出现频率
    std::unordered_map<int, int> frequency;

    // 统计频率
    for (int num : nums) {
        frequency[num]++;
    }

    // 检查每个频率值是否为质数
    for (const auto& pair : frequency) {
        if (isPrime(pair.second)) {
            return true;
        }
    }

    return false;
}

int main() {
    // 测试用例
    std::vector<int> nums = {1, 2, 3, 4, 5, 4};

    // 调用函数并输出结果
    bool result = checkPrimeFrequency(nums);
    std::cout << result << std::endl;  // 输出: true

    // 更多测试用例
    std::vector<std::vector<int>> testCases = {
        {1, 1, 2, 2, 3},        // 频率: 1(2次), 2(2次), 3(1次) - 质数频率2
        {1, 1, 1},              // 频率: 1(3次) - 质数频率3
        {1, 2, 3},              // 频率: 1(1次), 2(1次), 3(1次) - 没有质数频率
        {},                     // 空数组 - 没有质数频率
        {5, 5, 5, 5},           // 频率: 5(4次) - 4不是质数
        {7, 7, 7, 7, 7, 7, 7},  // 频率: 7(7次) - 7是质数
    };

    std::cout << "\n更多测试用例：" << std::endl;
    for (size_t i = 0; i < testCases.size(); ++i) {
        std::cout << "测试用例 " << i + 1 << ": ";
        for (int num : testCases[i]) {
            std::cout << num << " ";
        }
        std::cout << "-> "  << checkPrimeFrequency(testCases[i]) << std::endl;
    }

    return 0;
}