Easy

题目描述

给定一个整数 n，找到在其十进制表示中出现频率最少的数字。如果多个数字具有相同的频率，选择最小的数字。

将选择的数字作为整数返回。

数字 x 的频率是它在 n 的十进制表示中出现的次数。

示例 1：

输入：n = 1553322
输出：1
解释：n 中出现频率最少的数字是 1，它只出现一次。其他所有数字都出现两次。

示例 2：

输入：n = 723344511
输出：2
解释：n 中出现频率最少的数字是 7、2 和 5，每个都只出现一次。

约束条件：

  • 1 <= n <= 2³¹ - 1

提示：

  • 按描述模拟即可

解题思路

这是一个简单的计数问题，需要统计每个数字的出现频率，然后找到频率最小的数字。

解题思路：

  1. 数字提取：逐位提取整数 n 中的每个数字，可以通过不断取模 10 和整除 10 来实现。

  2. 频率统计：使用数组或哈希表统计每个数字（0-9）的出现频率。由于数字只有 0-9 共 10 个，使用长度为 10 的数组更高效。

  3. 找最小频率：遍历所有出现过的数字，找到出现频率最小的那个。如果有多个数字频率相同，题目要求选择数字值最小的。

  4. 边界处理：注意数字 0 可能不会出现在某些数中，但我们只需要考虑实际出现的数字。

算法步骤：

  • 初始化一个长度为 10 的频率数组
  • 通过取模运算逐位提取数字并统计频率
  • 遍历数字 0-9，找到频率最小且数字最小的结果

时间复杂度为 O(log n)，其中 log n 是数字的位数。空间复杂度为 O(1)，因为只需要固定大小的数组。

代码实现

class Solution {
public:
    int getLeastFrequentDigit(int n) {
        vector<int> freq(10, 0);
        
        // 统计每个数字的频率
        while (n > 0) {
            freq[n % 10]++;
            n /= 10;
        }
        
        // 找到最小频率
        int minFreq = INT_MAX;
        for (int i = 0; i < 10; i++) {
            if (freq[i] > 0) {
                minFreq = min(minFreq, freq[i]);
            }
        }
        
        // 找到频率最小且数字最小的数字
        for (int i = 0; i < 10; i++) {
            if (freq[i] == minFreq) {
                return i;
            }
        }
        
        return 0;
    }
};

class Solution:
    def getLeastFrequentDigit(self, n: int) -> int:
        freq = [0] * 10
        
        # 统计每个数字的频率
        while n > 0:
            freq[n % 10] += 1
            n //= 10
        
        # 找到最小频率
        min_freq = min(f for f in freq if f > 0)
        
        # 找到频率最小且数字最小的数字
        for i in range(10):
            if freq[i] == min_freq:
                return i
        
        return 0

public class Solution {
    public int GetLeastFrequentDigit(int n) {
        int[] freq = new int[10];
        
        // 统计每个数字的频率
        while (n > 0) {
            freq[n % 10]++;
            n /= 10;
        }
        
        // 找到最小频率
        int minFreq = int.MaxValue;
        for (int i = 0; i < 10; i++) {
            if (freq[i] > 0) {
                minFreq = Math.Min(minFreq, freq[i]);
            }
        }
        
        // 找到频率最小且数字最小的数字
        for (int i = 0; i < 10; i++) {
            if (freq[i] == minFreq) {
                return i;
            }
        }
        
        return 0;
    }
}

var getLeastFrequentDigit = function(n) {
    const freq = new Array(10).fill(0);
    
    // 统计每个数字的频率
    while (n > 0) {
        freq[n % 10]++;
        n = Math.floor(n / 10);
    }
    
    // 找到最小频率
    let minFreq = Math.min(...freq.filter(f => f > 0));
    
    // 找到频率最小且数字最小的数字
    for (let i = 0; i < 10; i++) {
        if (freq[i]
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度类型分析
时间复杂度O(log n)，其中 log n 是数字 n 的位数，需要遍历每一位进行统计
空间复杂度O(1)，只使用了固定大小的频率数组（长度为 10）