Check if The Number is Fascinating

Check if The Number is Fascinating - Problem

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.

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

Input & Output

Example 1 — Fascinating Number

$ Input: n = 192

› Output: true

💡 Note: Concatenating 192 with 2×192=384 and 3×192=576 gives us 192384576. This contains all digits 1-9 exactly once with no zeros, making it fascinating.

Example 2 — Contains Zero

$ Input: n = 100

› Output: false

💡 Note: Concatenating 100 with 2×100=200 and 3×100=300 gives us 100200300. This contains zeros, which violates the fascinating number rule.

Example 3 — Duplicate Digits

$ Input: n = 111

› Output: false

💡 Note: Concatenating 111 with 2×111=222 and 3×111=333 gives us 111222333. This has duplicate digits (1 appears 3 times, 2 appears 3 times, 3 appears 3 times) instead of each digit 1-9 appearing exactly once.

Constraints

100 ≤ n ≤ 999
n consists of exactly 3 digits

Visualization

Tap to expand

Asked in

G Google 8 a Amazon 5 M Microsoft 3

The key insight is that we need to check if concatenating n, 2×n, and 3×n produces exactly the digits 1-9 with no zeros or duplicates. Best approach uses frequency counting with either arrays or hash maps. Time: O(1), Space: O(1).

Common Approaches

✓ Brute Force - String Concatenation

⏱️ Time: O(1) Space: O(1)

Create the concatenated string by joining n, 2*n, and 3*n, then iterate through each character to count digit frequencies and verify the fascinating property.

Hash Map - Frequency Counter

⏱️ Time: O(1) Space: O(1)

Process each digit of the concatenated number directly using a hash map to track frequencies, enabling early termination when invalid conditions are detected.

Optimized - Direct Digit Processing

⏱️ Time: O(1) Space: O(1)

Extract digits mathematically using modulo and division operations, avoiding string operations entirely while maintaining the same validation logic.

Brute Force - String Concatenation — Algorithm Steps

Convert n, 2*n, 3*n to strings and concatenate
Count frequency of each digit
Check if digits 1-9 appear exactly once and no 0s exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Concatenate

Join n, 2*n, 3*n into single string

Count Digits

Count frequency of each digit 0-9

Validate

Check if digits 1-9 appear exactly once, no 0s

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int n) {
    // Create concatenated string of n, 2*n, 3*n
    char concatStr[20];
    sprintf(concatStr, "%d%d%d", n, 2 * n, 3 * n);
    
    // Count frequency of each digit
    int digitCount[10] = {0};
    for (int i = 0; concatStr[i] != '\0'; i++) {
        digitCount[concatStr[i] - '0']++;
    }
    
    // Check if 0 appears (not allowed)
    if (digitCount[0] > 0) {
        return 0;
    }
    
    // Check if digits 1-9 appear exactly once
    for (int i = 1; i <= 9; i++) {
        if (digitCount[i] != 1) {
            return 0;
        }
    }
    
    return 1;
}

int main() {
    int n;
    scanf("%d", &n);
    int result = solution(n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Always processes exactly 9 digits (3 + 3 + 3) regardless of input value

✓ Linear Growth

Space Complexity

O(1)

Uses fixed-size string of length 9 and constant space for digit counting

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

247 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - String Concatenation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler