递归计算 x 是否为 b 的幂

Question

任务是编写一个递归函数，它接收两个整数非负数b, x，如果有自然整数n，则返回True，如果没有自然整数b**n=x，则返回False。 我不能使用任何数学运算符或循环，除了 % 来确定一个数字是偶数还是奇数。 但我确实有可以使用的外部功能。它可以添加 2 个数字，乘以 2 个数字，并将一个数字除以 2。我还可以编写可以在 main 函数中使用的辅助函数。

这是我目前得到的，但它仅在b 的形式为2^y（2、4、8、16 等）时才有效

def is_power(b, x):
    if b == x:
        return True
    if b > x:
        return False
    return is_power(add(b, b), x)  # the func 'add' just adds 2 numbers

此外，复杂度需要为O(logb * logx) 谢谢。

Answer 1

您基本上可以继续将b 乘以b，直到达到或超过n。

使用辅助函数的递归实现可能如下所示：

def is_power(b, x):
    if b == 1:          # Check special case
        return x == 1
    return helper(1, b, x)

def helper(counter, b, x):
    if counter == x:
        return True
    elif counter > x:
        return False
    else:
        return helper(mul(counter, b), b, x) # mul is our special multiplication function

Answer 2

使用您所说的可以用来将 2 个数字相乘的函数，例如：

power = False
result = b
while result < x:
    result = yourMultiplyFunction(b,b)
    if result == x:
        power = True
        break
print(power)

问题已编辑（无法使用循环）：

def powerOf(x, b, b1=-1):
    if b1 == -1:
        b1 = b
    if (b == 1) and (x == 1):
        return True
    elif ( b==1 ) or (x == 1):
        return False
    if b*b1 < x:
        return powerOf(x, b*b1, b1)
    elif b*b1 > x:
        return False
    return True

print(powerOf(625, 25))

Answer 3

O(logb * logx) 的解决方案比简单的顺序搜索要慢

你可以通过简单的操作得到 O(logx / logb)：

def is_power(b,x,bn=1):
    if bn == x: return True
    if bn > x: return False
    return is_power(b,x,bn*b)

我怀疑目标是比 O(logx/logb) 更快，并且复杂性要求应该类似于 O(log(logx/logb)^2) ，相当于 O(log(n)*日志（n））。

要获得 O(log(n)*log(n)) 解决方案，您可以通过实现一个辅助函数将一个数字提高到 O(log(n)) 中的给定幂来将问题转换为二进制搜索时间并在 O(log(n)) 搜索逻辑中使用它。

def raise_power(b,n):                       # recursive b^n O(logN)
    if not n: return 1                      # b^0 = 1
    if n%2: return b*raise_power(b*b,n//2)  # binary decomposition
    return raise_power(b*b,n//2)            # of power over base

def find_power(b,x,minp,maxp):               # binary search
    if minp>maxp: return False               # no matching power 
    n = (minp+maxp)//2                       # middle of exponent range
    bp = raise_power(b,n)                    # compute power
    if bp == x: return True                  # match found
    if bp > x: return find_power(b,x,minp,n-1) # look in lower sub-range
    return find_power(b,x,n+1,maxp)            # look in upper sub-range

def max_power(b,x):
    return 2*max_power(b*b,x) if b<x else 1  # double n until b^n > x
    
def is_power(b,x):
    maxp = max_power(b,x)                    # determine upper bound
    return find_power(b,x,0,maxp)            # use binary search

    

请注意，您需要将 *、+ 和 //2 操作转换为等效的外部函数，以满足您的作业要求