Question

在Codewars上找到了这个。它假设接受两个数字a和b并返回^ b的最后一个十进制数字。前两个测试用例通过，但下一个测试用例不会通过。

def last_digit(n1, n2):
    number = n1**n2
    if number % 2 == 0:
        return number % 10
    elif number % 2 != 0:
        return number % 10

Test.it("Example tests")
Test.assert_equals(last_digit(4, 1), 4)
Test.assert_equals(last_digit(4, 2), 6)
Test.assert_equals(last_digit(9, 7), 9)
Test.assert_equals(last_digit(10, 10 ** 10), 0)

Answer 1

不要计算n1**n2。当您尝试计算时出现问题：

10**(10**10)

这是1，然后是100亿个零。

使用pow(n1, n2, 10)这会使问题（更多）易于处理，因为它计算取幂模10。然后，当数字已经以模10减少时，该函数可以重写为：

def last_digit(n1, n2):
    return pow(n1, n2, 10)

Answer 2

一旦你意识到权力的最后几位形成一个循环，问题就很容易解决。例如：

2: 2, 4, 8, 6, 2, 4
3: 3, 9, 7, 1, 3, 9

考虑到这一点，您可以先创建循环，然后使用n2的模数对其进行索引：

def last_digit(n1, n2):
    if n2 == 0:
        return 1

    cycle = [n1 % 10]
    while True:
        nxt = (cycle[-1] * n1) % 10
        if nxt == cycle[0]:
            break
        cycle.append(nxt)
    return cycle[(n2 - 1) % len(cycle)]

这比使用pow：

更快

def last_digit_pow(n1, n2):
    return pow(n1, n2, 10)

if __name__ == '__main__':
    import timeit
    print(timeit.timeit("last_digit(10, 10 ** 10)", setup="from __main__ import last_digit"))
    print(timeit.timeit("last_digit_pow(10, 10 ** 10)", setup="from __main__ import last_digit_pow"))

输出（Windows 8＆amp; Python 2.7）：

0.832171277335
4.08073167307

输出（Windows 8＆amp; Python 3.5）：

0.6951034093766606
1.9045515428013722

使用10**100输出（Windows 8＆amp; Python 3.5）：

0.8367381690724996
10.928452962508006

Answer 3

我知道这篇文章很老，但是也许有人会发现这种基于字典的方法也很有用。

import { createStore, applyMiddleware, compose } from 'redux'
import thunk from 'redux-thunk'

import rootReducer from './reducers'

const store = createStore(
  reducers, // your reducers
  compose(
    applyMiddleware(thunk)
  )
)

大数（幂）python的最后一位数

3 个答案: