Skip to content

Latest commit

 

History

History
212 lines (156 loc) · 4.77 KB

README.md

File metadata and controls

212 lines (156 loc) · 4.77 KB
Raw
comments difficulty edit_url rating source tags
true
简单
1227
第 106 场双周赛 Q1
哈希表
数学

2729. 判断一个数是否迷人

English Version

题目描述

给你一个三位数整数 n 。

如果经过以下修改得到的数字 恰好 包含数字 1 到 9 各一次且不包含任何 0 ，那么我们称数字 n 是 迷人的 ：

  • 将 n 与数字 2 * n 和 3 * n 连接 。

如果 n 是迷人的，返回 true，否则返回 false 。

连接 两个数字表示把它们首尾相接连在一起。比方说 121 和 371 连接得到 121371 。

 

示例 1：

输入：n = 192
输出：true
解释：我们将数字 n = 192 ，2 * n = 384 和 3 * n = 576 连接，得到 192384576 。这个数字包含 1 到 9 恰好各一次。

示例 2：

输入：n = 100
输出：false
解释：我们将数字 n = 100 ，2 * n = 200 和 3 * n = 300 连接，得到 100200300 。这个数字不符合上述条件。

 

提示：

  • 100 <= n <= 999

解法

方法一：模拟

我们根据题目描述，将数字 $n$ 与 $2 \times n$ 和 $3 \times n$ 连接，得到字符串 $s$，然后判断 $s$ 是否包含数字 $1$ 到 $9$ 各一次且不包含任何 $0$ 即可。

时间复杂度 $O(\log n)$，空间复杂度 $O(\log n)$。其中 $n$ 为题目给定的整数。

Python3

class Solution:
    def isFascinating(self, n: int) -> bool:
        s = str(n) + str(2 * n) + str(3 * n)
        return "".join(sorted(s)) == "123456789"

Java

class Solution {
    public boolean isFascinating(int n) {
        String s = "" + n + (2 * n) + (3 * n);
        int[] cnt = new int[10];
        for (char c : s.toCharArray()) {
            if (++cnt[c - '0'] > 1) {
                return false;
            }
        }
        return cnt[0] == 0 && s.length() == 9;
    }
}

C++

class Solution {
public:
    bool isFascinating(int n) {
        string s = to_string(n) + to_string(n * 2) + to_string(n * 3);
        sort(s.begin(), s.end());
        return s == "123456789";
    }
};

Go

func isFascinating(n int) bool {
	s := strconv.Itoa(n) + strconv.Itoa(n*2) + strconv.Itoa(n*3)
	cnt := [10]int{}
	for _, c := range s {
		cnt[c-'0']++
		if cnt[c-'0'] > 1 {
			return false
		}
	}
	return cnt[0] == 0 && len(s) == 9
}

TypeScript

function isFascinating(n: number): boolean {
    const s = `${n}${n * 2}${n * 3}`;
    return s.split('').sort().join('') === '123456789';
}

Rust

impl Solution {
    pub fn is_fascinating(n: i32) -> bool {
        let s = format!("{}{}{}", n, n * 2, n * 3);

        let mut cnt = vec![0; 10];
        for c in s.chars() {
            let t = (c as usize) - ('0' as usize);
            cnt[t] += 1;
            if cnt[t] > 1 {
                return false;
            }
        }

        cnt[0] == 0 && s.len() == 9
    }
}

方法二

Rust

use std::collections::HashMap;

impl Solution {
    pub fn is_fascinating(mut n: i32) -> bool {
        let mut i = n * 2;
        let mut j = n * 3;

        let mut hash = HashMap::new();

        while n != 0 {
            let cnt = hash.entry(n % 10).or_insert(0);
            *cnt += 1;
            n /= 10;
        }

        while i != 0 {
            let cnt = hash.entry(i % 10).or_insert(0);
            *cnt += 1;
            i /= 10;
        }

        while j != 0 {
            let cnt = hash.entry(j % 10).or_insert(0);
            *cnt += 1;
            j /= 10;
        }

        for k in 1..=9 {
            if !hash.contains_key(&k) || hash[&k] > 1 {
                return false;
            }
        }

        !hash.contains_key(&0)
    }
}