Check if The Number is Fascinating - Practice Coding Problems

Check if The Number is Fascinating - Problem

The Fascinating Number Challenge

Have you ever wondered if a number has a magical property? In this problem, we explore the concept of fascinating numbers!

You are given a 3-digit integer n. A number is considered fascinating if, when you concatenate it with its double (2 × n) and triple (3 × n), the resulting string contains all digits from 1 to 9 exactly once and no zeros.

Example: If n = 192:
• n = 192
• 2 × n = 384
• 3 × n = 576
• Concatenated: "192384576"
• Contains digits 1,2,3,4,5,6,7,8,9 exactly once ✓

Goal: Return true if the number is fascinating, false otherwise.

Input & Output

example_1.py — Basic Fascinating Number

$ Input: n = 192

› Output: true

💡 Note: 192 → "192" + "384" + "576" = "192384576". This contains digits 1,2,3,4,5,6,7,8,9 exactly once each with no zeros, so it's fascinating.

example_2.py — Not Fascinating (Contains Zero)

$ Input: n = 100

› Output: false

💡 Note: 100 → "100" + "200" + "300" = "100200300". This contains zeros and repeated digits, so it's not fascinating.

example_3.py — Not Fascinating (Missing Digits)

$ Input: n = 183

› Output: false

💡 Note: 183 → "183" + "366" + "549" = "183366549". This contains repeated digit 3 and 6, missing digit 7, so it's not fascinating.

Constraints

100 ≤ n ≤ 999
n consists of exactly 3 digits
The concatenated result should be checked for digits 1 to 9 only

Visualization

Tap to expand

Understanding the Visualization

Prepare Ingredients

Calculate n, 2×n, 3×n and combine them

Quality Check

Ensure no forbidden ingredients (zeros) and no duplicates

Final Verification

Confirm we have exactly 9 unique ingredients (digits 1-9)

Key Takeaway

🎯 Key Insight: A fascinating number creates a perfect permutation of digits 1-9 when combined with its double and triple. Using a hash set allows us to validate this property efficiently in a single pass!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 10

The optimal approach uses a hash set to validate the fascinating number property in O(1) time. We concatenate n, 2n, and 3n, then in a single pass check for zeros, duplicates, and ensure we have exactly 9 unique digits from 1-9. The key insight is that we can validate all conditions simultaneously while building our set.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(1)	O(1)	Use a set to track digits and validate in a single pass
Brute Force (Digit by Digit Check)	O(9 × k) where k is string length	O(1)	Manually count each digit 1-9 in the concatenated string

One-Pass Hash Set (Optimal) — Algorithm Steps

Calculate 2*n and 3*n, then concatenate all three numbers
Check if the concatenated string has exactly 9 characters
Initialize an empty set to track seen digits
Iterate through each character in the string once
For each character, check if it's '0' (invalid) or already seen (duplicate)
Add valid digits to the set
After the loop, check if set size equals 9 and contains only digits 1-9

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create empty set, concatenate string

Single Pass

Check each character: no zeros, no duplicates

Final Check

Verify set contains exactly 9 unique digits

Code -

solution.c — C

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

bool isFascinating(int n) {
    char concatenated[20];
    sprintf(concatenated, "%d%d%d", n, 2 * n, 3 * n);
    
    // Must be exactly 9 digits
    if (strlen(concatenated) != 9) {
        return false;
    }
    
    // Track seen digits using boolean array (digits 0-9)
    bool seen[10] = {false};
    int uniqueCount = 0;
    
    // Single pass validation
    for (int i = 0; concatenated[i]; i++) {
        int digit = concatenated[i] - '0';
        
        // Check for zero (invalid)
        if (digit == 0) {
            return false;
        }
        
        // Check for duplicate
        if (seen[digit]) {
            return false;
        }
        
        seen[digit] = true;
        uniqueCount++;
    }
    
    // Must have all digits 1-9
    return uniqueCount == 9;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(1)

The concatenated string always has at most 9 characters, so we iterate through a constant-size string

✓ Linear Growth

Space Complexity

O(1)

The set can contain at most 9 elements (digits 1-9), which is constant space

✓ Linear Space

18.5K Views

Medium Frequency

~12 min Avg. Time

892 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

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler