Question

我想找到小于或等于n的第k个根的最大整数。我试过了

int(n**(1/k))

但是对于n = 125，k = 3，这给出了错误的答案！我碰巧知道5立方是125。

>>> int(125**(1/3))
4

什么是更好的算法？

背景：2011年，这次失误让我击败了Google Code Jam。 https://code.google.com/codejam/contest/dashboard?c=1150486#s=p2

Answer 1

怎么样：

def nth_root(val, n):
    ret = int(val**(1./n))
    return ret + 1 if (ret + 1) ** n == val else ret

print nth_root(124, 3)
print nth_root(125, 3)
print nth_root(126, 3)
print nth_root(1, 100)

此处，val和n都应为整数且为正数。这使得return表达式完全依赖于整数运算，消除了舍入错误的任何可能性。

请注意，只有当val**(1./n)相当小时才能保证准确性。一旦该表达式的结果偏离真实答案超过1，该方法将不再给出正确答案（它将给出与原始版本相同的近似答案）。

我仍然想知道为什么int(125**(1/3))是4

In [1]: '%.20f' % 125**(1./3)
Out[1]: '4.99999999999999911182'

int()将其截断为4。

Answer 2

一个解决方案首先将lo和hi之间的答案括起来，重复乘以2直到n在lo和hi之间，然后使用二进制搜索来计算确切的答案：

def iroot(k, n):
    hi = 1
    while pow(hi, k) < n:
        hi *= 2
    lo = hi / 2
    while hi - lo > 1:
        mid = (lo + hi) // 2
        midToK = pow(mid, k)
        if midToK < n:
            lo = mid
        elif n < midToK:
            hi = mid
        else:
            return mid
    if pow(hi, k) == n:
        return hi
    else:
        return lo

另一种解决方案使用牛顿方法，它在整数上运行得非常好：

def iroot(k, n):
    u, s = n, n+1
    while u < s:
        s = u
        t = (k-1) * s + n // pow(s, k-1)
        u = t // k
    return s

Answer 3

我被严重烧伤后的谨慎解决方案：

def nth_root(N,k):
    """Return greatest integer x such that x**k <= N"""
    x = int(N**(1/k))      
    while (x+1)**k <= N:
        x += 1
    while x**k > N:
        x -= 1
    return x

Answer 4

为什么不尝试这个：

125 ** (1 / float(3))

或

pow(125, 1 / float(3))

它返回5.0，因此您可以使用int（）转换为int。

Answer 5

这是Lua使用Newton-Raphson方法

> function nthroot (x, n) local r = 1; for i = 1, 16 do r = (((n - 1) * r) + x / (r ^ (n -   1))) / n end return r end
> return nthroot(125,3)
5
>

Python版

>>> def nthroot (x, n):
...     r = 1
...     for i in range(16):
...             r = (((n - 1) * r) + x / (r ** (n - 1))) / n
...     return r
... 
>>> nthroot(125,3)
5
>>>

Answer 6

我想知道如果从基于对数的方法开始，可以帮助确定舍入误差的来源。例如：

import math
def power_floor(n, k):
    return int(math.exp(1.0 / k * math.log(n)))

def nth_root(val, n):
    ret = int(val**(1./n))
    return ret + 1 if (ret + 1) ** n == val else ret

cases = [
    (124, 3),
    (125, 3),
    (126, 3),
    (1, 100),
    ]


for n, k in cases:
    print "{0:d} vs {1:d}".format(nth_root(n, k), power_floor(n, k))

打印出来

4 vs 4
5 vs 5
5 vs 5
1 vs 1

Answer 7

def nth_root(n, k):
    x = n**(1./k)
    y = int(x)
    return y + 1 if y != x else y

Answer 8

int(125**(1/3))应该清楚地是5，即正确的答案，所以这必须是标准的计算机舍入错误，即内部结果是4.9999999999，它会向下舍入到4.无论你使用什么算法都会存在这个问题。一个简单的临时解决方案是添加一个小数字，例如int((125**(1/3)) + 0.00000001)

Answer 9

你可以舍入到最接近的整数而不是向下舍入/到零（我不知道Python指定了什么）：

def rtn (x):
    return int (x + 0.5)

>>> rtn (125 ** (1/3))
5

Answer 10

在所有事情之前执行此操作：

from __future__ import division

然后运行上述任何技术以获得结果。

Answer 11

def nthrootofm(a,n):
    a= pow(a,(1/n))
    return 'rounded:{},'.format(round(a))
a=125
n=3
q=nthrootofm(a,n)
print(q)

只使用了格式字符串，也许会有帮助。

如何找到整数第n个根？

11 个答案: