Smallest Good Base

Smallest Good Base - Problem

Given an integer n represented as a string, return the smallest good base of n.

We call k >= 2 a good base of n, if all digits of n base k are 1's.

In other words, n represented in base k should be 111...1 (all ones).

Input & Output

Example 1 — Basic Case

$ Input: n = "13"

› Output: "3"

💡 Note: 13 in base 3 is 111: 1×3² + 1×3¹ + 1×3⁰ = 9 + 3 + 1 = 13. Base 2 gives 1101 (not all 1s), so 3 is the smallest good base.

Example 2 — Small Number

$ Input: n = "4"

› Output: "3"

💡 Note: 4 in base 3 is 11: 1×3¹ + 1×3⁰ = 3 + 1 = 4. Base 2 gives 100 (not all 1s), so 3 is the smallest good base.

Example 3 — Edge Case

$ Input: n = "3"

› Output: "2"

💡 Note: 3 in base 2 is 11: 1×2¹ + 1×2⁰ = 2 + 1 = 3. This is the smallest base where 3 consists of all 1's.

Constraints

n is represented as a string
3 ≤ n ≤ 10¹⁸
n does not have leading zeros

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is using the geometric series formula: for m digits of all 1's, n = (k^m - 1)/(k - 1). Best approach is mathematical formula with binary search on digit count. Time: O(log n), Space: O(1)

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(log² n) Space: O(1)

Instead of trying every base, we binary search on the number of digits m. For m digits of all 1's, we have n = 1 + k + k² + ... + k^(m-1). We can solve this equation to find k and check if it's an integer.

Brute Force

⏱️ Time: O(n log n) Space: O(log n)

For each potential base k from 2 to n-1, convert n to base k and check if all digits are 1. This is straightforward but very slow for large numbers.

Mathematical Formula

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

Leverage the fact that n = (k^m - 1)/(k - 1) for m digits of 1's. We can solve this equation directly using the geometric series formula and Newton's method for finding roots.

Binary Search on Answer — Algorithm Steps

Binary search on number of digits m from 2 to 64
For each m, solve n = (k^m - 1)/(k - 1) for k
Use binary search or Newton's method to find k
Check if k is integer and n = k^(m-1) + ... + k + 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Digits

Try m=3 digits: need k where 1+k+k²=13

Binary Search

Search for k: try k=3, check 1+3+9=13 ✓

Found

Base 3 works: 13 = 111₃

Code -

solution.c — C

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

typedef unsigned long long ull;

// Efficient binary search nth root
ull nthRoot(ull num, int n) {
    if (n == 1) return num;
    if (num == 1) return 1;
    
    ull left = 1, right = num;
    ull result = 1;
    
    // Optimize right bound
    if (n >= 60) right = 2;
    else if (n >= 30) right = 1000;
    else if (n >= 20) right = 100000;
    else if (n >= 10) right = 1000000000ULL;
    
    while (left <= right) {
        ull mid = left + (right - left) / 2;
        
        // Calculate mid^n with overflow check
        ull power = 1;
        int overflow = 0;
        
        for (int i = 0; i < n; i++) {
            if (power > num / mid) {
                overflow = 1;
                break;
            }
            power *= mid;
        }
        
        if (overflow || power > num) {
            right = mid - 1;
        } else {
            result = mid;
            left = mid + 1;
        }
    }
    
    return result + 2;
}

char* solution(char* n) {
    ull num = strtoull(n, NULL, 10);
    static char result[32];
    
    // Try different number of digits m from large to small
    for (int m = 60; m > 1; m--) {
        // Binary search for base k
        ull left = 2;
        ull right = nthRoot(num, m - 1);
        
        while (left <= right) {
            ull mid = left + (right - left) / 2;
            
            // Calculate sum with overflow check
            ull total = 0;
            ull power = 1;
            int overflow = 0;
            
            for (int i = 0; i < m; i++) {
                if (total > num) {
                    overflow = 1;
                    break;
                }
                total += power;
                if (i < m - 1) {
                    if (power > num / mid) {  // Check for overflow
                        overflow = 1;
                        break;
                    }
                    power *= mid;
                }
            }
            
            if (overflow || total > num) {
                right = mid - 1;
            } else if (total == num) {
                sprintf(result, "%llu", mid);
                return result;
            } else {
                left = mid + 1;
            }
        }
    }
    
    sprintf(result, "%llu", num - 1);
    return result;
}

int main() {
    char n[32];
    fgets(n, sizeof(n), stdin);
    n[strcspn(n, "\n")] = 0;
    char* result = solution(n);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log² n)

Binary search on digits O(log n) × binary search for base O(log n)

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra variables

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler