Skip to content

2729. Check if The Number is Fascinating

Description

You are given an integer n that consists of exactly 3 digits.

We call the number n fascinating if, after the following modification, the resulting number contains all the digits from 1 to 9 exactly once and does not contain any 0's:

  • Concatenate n with the numbers 2 * n and 3 * n.

Return true if n is fascinating, or false otherwise.

Concatenating two numbers means joining them together. For example, the concatenation of 121 and 371 is 121371.

 

Example 1:

Input: n = 192
Output: true
Explanation: We concatenate the numbers n = 192 and 2 * n = 384 and 3 * n = 576. The resulting number is 192384576. This number contains all the digits from 1 to 9 exactly once.

Example 2:

Input: n = 100
Output: false
Explanation: We concatenate the numbers n = 100 and 2 * n = 200 and 3 * n = 300. The resulting number is 100200300. This number does not satisfy any of the conditions.

 

Constraints:

  • 100 <= n <= 999

Solutions

Solution 1: Simulation

Thinking

Decide whether the concatenation of \(n\), \(2n\), and \(3n\) is a permutation of \(1\) through \(9\). \(n\) is a three-digit number, so the concatenation has fixed length and listing permutations is unnecessary.

Sort the concatenated digits and compare with \(123456789\), which rejects missing digits, duplicates, and any \(0\).

According to the problem description, we concatenate \(n\), \(2 \times n\), and \(3 \times n\) into a string \(s\), and then check whether \(s\) contains each digit from \(1\) to \(9\) exactly once and does not contain any \(0\).

The time complexity is \(O(\log n)\), and the space complexity is \(O(\log n)\). Here, \(n\) is the given integer.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
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;
    }
}

1
2
3
4
5
6
7
8
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";
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
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
}

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
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
    }
}

Comments