Question

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$ 为题目给定的整数。

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

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;
  }
}

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";
  }
};

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
}

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

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
  }
}

方法二

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)
  }
}