Does an algorithm exist that converts a (base 10) number to into another number for any base in constant time?

Question

I am solving a problem where I am given three integers (a,b,c), all three can be very large and (a>b>c)

I want to identify for which base between b and c, produces the smallest sum of digits, when we convert 'a' to that base.

For example a = 216, b=2, c=7 -> the output= 6, because: 216 base 2 = 11011000, and the sum of digits = 4, if we do the same for all bases between 2 and 7, we find that 216 base 6 produces the smallest sum of digits, because 216 base 6 = 1000, which has sum 1.

My question is, is there any function out there that can convert a number to any base in constant time faster than the below algorithm? Or any suggestions on how to optimise my algorithm?

from collections import defaultdict
n = int(input())
for _ in range(n):
    (N,X) = map(int,input().split())
    array = list(map(int,input().split()))
    my_dict = defaultdict(int)

    #original count of elements in array
    for i in range(len(array)):
        my_dict[array[i]] +=1

    #ensure array contains distinct elements
    array = set(array)
    count = max(my_dict.values())  #count= max of single value
    temp = count
    res = None
    XOR_count = float("inf")
    if X==0:
        print(count,0)
        break
    for j in array:
        if j^X in my_dict:
            curr = my_dict[j^X] + my_dict[j]
            if curr>=count:
                count = curr
                XOR_count = min(my_dict[j],XOR_count)
    if count ==temp:
        XOR_count = 0
    print(f"{count} {XOR_count}")

Here are some sample input and outputs:

Sample Input  
3
3 2
1 2 3
5 100
1 2 3 4 5
4 1
2 2 6 6

Sample Output  
2 1
1 0
2 0

Which for the problem I am solving runs into time limit exceeded error.

I found this link to be quite useful (https://www.purplemath.com/modules/logrules5.htm) in terms of converting log bases, which I can kind of see how it relates, but I couldn't use it to get a solution for my above problem.

Answer 1

You could separate the problem in smaller concerns by writing a function that returns the sum of digits in a given base and another one that returns a number expressed in a given base (base 2 to 36 in my example below):

def digitSum(N,b=10):
    return N if N<b else N%b+digitSum(N//b,b)

digits = "0123456789abcdefghijklmnopqrstuvwxyz"
def asBase(N,b):
    return "" if N==0 else asBase(N//b,b)+digits[N%b]

def lowestBase(N,a,b):
    return asBase(N, min(range(a,b+1),key=lambda c:digitSum(N,c)) )

output:

print(lowestBase(216,2,7))
1000     # base 6

print(lowestBase(216,2,5))
11011000 # base 2

Note that both digitSum and asBase could be written as iterative instead of recursive if you're manipulating numbers that are greater than base^1000 and don't want to deal with recursion depth limits

Here's a procedural version of digitSum (to avoid recursion limits):

def digitSum(N,b=10):
    result = 0
    while N:
        result += N%b
        N //=b
    return result

and returning only the base (not the encoded number):

def lowestBase(N,a,b):
    return min(range(a,b+1),key=lambda c:digitSum(N,c))

# in which case you don't need the asBase() function at all.

With those changes results for a range of bases from 2 to 1000 are returned in less than 60 milliseconds:

lowestBase(10**250+1,2,1000)  --> 10 in 57 ms

lowestBase(10**1000-1,2,1000) --> 3 in 47 ms

I don't know how large is "very large" but it is still sub-second for millions of bases (yet for a relatively smaller number):

lowestBase(10**10-1,2,1000000) --> 99999 in 0.47 second

lowestBase(10**25-7,2,1000000) --> 2 in 0.85 second

[EDIT] optimization

By providing a maximum sum to the digitSum() function, you can make it stop counting as soon as it goes beyond that maximum. This will allow the lowestBase() function to obtain potential improvements more efficiently based on its current best (minimal sum so far). Going through the bases backwards also gives a better chance of hitting small digit sums faster (thus leveraging the maxSum parameter of digitSum()):

def digitSum(N,b=10,maxSum=None):
    result = 0
    while N:
        result += N%b
        if maxSum and result>=maxSum:break
        N //= b
    return result

def lowestBase(N,a,b):
    minBase = a
    minSum  = digitSum(N,a)
    for base in range(b,a,-1):
        if N%base >= minSum: continue # last digit already too large
        baseSum = digitSum(N,base,minSum)
        if baseSum < minSum:
            minBase,minSum = base,baseSum
            if minSum == 1: break
    return minBase

This should yield a significant performance improvement in most cases.