# Solving Leetcode Interviews in Seconds with AI: Smallest Good Base


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "483" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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.   Example 1:  Input: n = "13" Output: "3" Explanation: 13 base 3 is 111.  Example 2:  Input: n = "4681" Output: "8" Explanation: 4681 base 8 is 11111.  Example 3:  Input: n = "1000000000000000000" Output: "999999999999999999" Explanation: 1000000000000000000 base 999999999999999999 is 11.    Constraints:  n is an integer in the range [3, 1018]. n does not contain any leading zeros.  

	# Explanation
	Here's the solution to find the smallest good base of a given integer `n`:

*   **Binary Search for Base:** Iterate through possible lengths of the base-k representation (from maximum possible length down to 2). For each length, use binary search to find a potential base `k`.

*   **Check if Base is Good:** For a given base `k` and length `m`, check if the representation of `n` in base `k` consists only of ones. This can be done by calculating the sum `k^0 + k^1 + ... + k^(m-1)` and comparing it to `n`.

*   **Return Smallest Good Base:** Return the smallest good base found during the iteration. If no good base is found, return `n - 1`.

*   **Complexity:**
    *   Runtime: O(log(n)^2)
    *   Storage: O(1)

	
	# Code
	```python
	def smallestGoodBase(n: str) -> str:
    n_int = int(n)
    max_m = int((n_int - 1)).bit_length()

    for m in range(max_m, 1, -1):
        low = 2
        high = n_int - 1
        while low <= high:
            k = (low + high) // 2
            sum_val = 0
            power = 1
            for _ in range(m):
                if sum_val > n_int // k:  # Optimization to avoid overflow
                    sum_val = n_int + 1  # Ensure sum_val > n_int to trigger high adjustment
                    break
                sum_val += power
                if power > n_int // k:
                   sum_val = n_int+1
                   break
                power *= k

            if sum_val == n_int:
                return str(k)
            elif sum_val < n_int:
                low = k + 1
            else:
                high = k - 1

    return str(n_int - 1)
	```