Nth Magical Number

Nth Magical Number - Problem

A positive integer is magical if it is divisible by either a or b.

Given the three integers n, a, and b, return the n-th magical number. Since the answer may be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: n = 1, a = 2, b = 3

› Output: 2

💡 Note: The first magical number is 2, since 2 % 2 == 0

Example 2 — Multiple Numbers

$ Input: n = 4, a = 2, b = 3

› Output: 6

💡 Note: Magical numbers are 2, 3, 4, 6. The 4th is 6 (divisible by both 2 and 3)

Example 3 — Larger Case

$ Input: n = 3, a = 6, b = 4

› Output: 8

💡 Note: Magical numbers are 4, 6, 8. The 3rd magical number is 8

Constraints

1 ≤ n ≤ 10⁹
2 ≤ a, b ≤ 4 × 10⁴

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use binary search on the answer space combined with inclusion-exclusion principle for counting. Instead of checking each number, we can mathematically count magical numbers ≤ x using the formula: x/a + x/b - x/lcm(a,b). Best approach is Binary Search with Time: O(log(n×min(a,b))), Space: O(1)

Common Approaches

✓ Binary Search on Answer Space

⏱️ Time: O(log(n × min(a,b))) Space: O(1)

Instead of checking each number, we binary search on the answer range. For any number x, we can count how many magical numbers exist ≤ x using inclusion-exclusion principle: count = x/a + x/b - x/lcm(a,b). We search for the smallest x where count ≥ n.

Brute Force - Check Every Number

⏱️ Time: O(n × min(a,b)) Space: O(1)

Start from 1 and check each number to see if it's divisible by a or b. Count magical numbers until we reach the nth one. This approach is straightforward but very slow for large n.

Binary Search on Answer Space — Algorithm Steps

Calculate LCM of a and b for inclusion-exclusion
Binary search on range [1, n * min(a,b)]
For each mid, count magical numbers ≤ mid
Adjust search range based on count vs n

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Range

Binary search from 1 to n×min(a,b)

Count Formula

Use x/a + x/b - x/lcm(a,b)

Narrow Range

Adjust left/right based on count

Code -

solution.c — C

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

long long gcd(long long x, long long y) {
    while (y != 0) {
        long long temp = y;
        y = x % y;
        x = temp;
    }
    return x;
}

long long lcm(long long x, long long y) {
    return x * y / gcd(x, y);
}

int min(int a, int b) {
    return a < b ? a : b;
}

long long solution(int n, int a, int b) {
    const long long MOD = 1000000007LL;
    
    long long lcmAB = lcm(a, b);
    
    long long left = 1, right = (long long)n * min(a, b);
    
    while (left < right) {
        long long mid = left + (right - left) / 2;
        long long count = mid / a + mid / b - mid / lcmAB;
        if (count < n) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    
    return left % MOD;
}

int main() {
    int n, a, b;
    scanf("%d", &n);
    scanf("%d", &a);
    scanf("%d", &b);
    
    long long result = solution(n, a, b);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log(n × min(a,b)))

Binary search over range up to n × min(a,b), each iteration takes O(1)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for binary search bounds

✓ Linear Space

28.5K Views

Medium Frequency

~35 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

Binary Search on Answer Space — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler