我需要从作为列表传递给函数的整数中找到x1 ^ (x2 ^ (x3 ^ (... ^ xn)))的单位数字。
例如，输入[3, 4, 2]将返回1，因为3 ^ (4 ^ 2) = 3 ^ 16 = 43046721的最后一位为1。
该函数需要尽可能高效，因为显然尝试计算767456 ^ 981242并不是很快。
我尝试了几种方法，但我认为解决此问题的最佳方法是使用序列。例如，以1结尾的任何数字在加幂时将始终以1结尾。对于2，结果数字将以2, 4, 6 or 8结尾。
如果将数字加到幂，则结果数字的最后一位将遵循基于指数最后一位的模式：
1：序列为1
2：序列为2、4、8、6
3：顺序为3、9、7、1
4：序列为4、6
5：序列为5
6：序列为6
7：序列为7、9、3、1
8：序列为8、4、2、6
9：序列为9、1
0：序列为0
我认为计算总的最后一位数字的最简单方法是向后浏览列表，一次计算一次计算的最后一位数字，直到回到起点为止，但是我不确定该怎么做？ 如果有人可以帮助或建议另一种等效或比之有效的方法，将不胜感激。
到目前为止，我已经有了这段代码，但不适用于很大的数字
def last_digit(lst):
if lst == []:
return 1
total = lst[len(lst)-2] ** lst[len(lst)-1]
for n in reversed(range(len(lst)-2)):
total = pow(lst[n], total)
return total%10
编辑：0 ^ 0应该假定为1
答案 0 :(得分：2)
这比编程要多。请注意，您列出的所有序列的长度都为1、2或4。更准确地说，x^4总是以0, 1, 5, 6结尾，x^(4k)也是如此。因此，如果您知道x^(m mod 4) mod 10，就知道x^m mod 10。
现在，要计算x2^(x3^(...^xn)) mod 4。这个故事非常相似，如果x^2 mod 4，0是以太x=2k，如果1，则是x=2k+1（为什么？）。所以
如果x2是偶数，则它是2或0，其中2仅在x2 mod 4 == 2 and (x3==1 or (any x4,...xn == 0) )时出现。
如果x2为奇数，则为x2^2 mod 4 == 1，因此如果1为x3则为x2 mod 4。
数学足够多了，让我们谈谈编码。可能有一些我没有讲过的极端情况，但是在大多数情况下都应该适用。
def last_digit(lst):
if len(lst) == 0:
return 1
x = lst[0] % 10
if len(lst) == 1:
return x
# these number never change
if x in [0,1,5,6]:
return x
# now we care for x[1] ^ 4:
x1 = x[1] % 4
# only x[0] and x[1]
if len(lst) == 2 or x1==0:
return x[0] ** x1 % 10
# now that x[2] comes to the picture
if x1 % 2: # == 1
x1_pow_x2 = x1 if (x[2]%2) else 1
else:
x1_pow_x2 = 2 if (x1==2 and x[2]%2 == 1) else 0
# we almost done:
ret = x ** x1_pow_x2 % 10
# now, there's a catch here, if x[1]^(x[2]^...^x[n-1]) >= 4,
# we need to multiply ret with the last digit of x ** 4
if x[1] >=4 or (x[1] > 1 and x[2] > 1):
ret = (ret * x**4) % 10
return ret
答案 1 :(得分：2)
x ^ n = x ^（n％4），因为最后一位数字的周期始终为4。
x ^2 ^3 ^4 ^5
1 1 1 1 1
2 4 8 6 2
3 9 7 1 3
4 6 4 6 4
5 5 5 5 5
6 6 6 6 6
7 9 3 1 7
8 4 2 6 8
9 1 9 1 9
如您所见，所有9位数字的周期均为4，因此我们可以使用％4简化计算。
如果我们执行％4，则还有一个模式。
x ^0 ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9
1 1 1 1 1 1 1 1 1 1 1
2 1 2 0 0 0 0 0 0 0 0
3 1 3 1 3 1 3 1 3 1 3
4 1 0 0 0 0 0 0 0 0 0
5 1 1 1 1 1 1 1 1 1 1 (all %4)
6 1 2 0 0 0 0 0 0 0 0
7 1 3 1 3 1 3 1 3 1 3
8 1 0 0 0 0 0 0 0 0 0
9 1 1 1 1 1 1 1 1 1 1
如图所示，当n> 1时，每个x都有一个模式。因此，当n> 1时，可以看到（x ^ n）％4 =（x ^（n + 4k））％4。然后，可以通过将n加4来防止n = 0和n = 1引起的问题。这是因为，如果（x ^ n）％4 =（x ^（n + 4k））％4，那么（x ^ n）％4 =（x ^（n％4 + 4））％4。
powers = [3, 9, 7, 1]
lastDigit = 1
for i in range(len(powers) - 1, -1, -1):
if lastDigit == 0:
lastDigit = 1
elif lastDigit == 1:
lastDigit = powers[i]
else:
lastDigit = powers[i]**(lastDigit%4+4)
print(lastDigit%10)
答案 2 :(得分：0)
要解决序列概念并充实它，您想要创建一个可以映射所有相关序列的字典。
mapping = {}
for i in range(1, 10):
mapping[i] = [i]
last_digit = i
while True:
last_digit *= i
last_digit = last_digit%10
if last_digit in mapping[i]:
break
else:
mapping[i].append(last_digit)
print(mapping)
这将产生输出：映射
{1: [1],
2: [2, 4, 8, 6],
3: [3, 9, 7, 1],
4: [4, 6],
5: [5],
6: [6],
7: [7, 9, 3, 1],
8: [8, 4, 2, 6],
9: [9, 1]}
现在真正的逻辑可以开始了。关键要点是，序列完成后，模式会自行重复。因此，幂的大小无关紧要，如果您只是使用模数并弄清楚它应该占据序列的哪个位置就没有关系。
def last_digit_func(lst, mapping):
if lst == []: #taken from OP
return 1
last_digit = lst[0] % 10
if 0 in lst[1:]: #edge case 0 as a power
return 1
if last_digit == 0: #edge case 0 at start
return last_digit
for current_power in lst[1:]:
if len(mapping[last_digit]) == 1:
return last_digit
ind = current_power % len(mapping[last_digit])
ind -= 1 #zero indexing, but powers start from 1.
last_digit = mapping[last_digit][ind]
return last_digit
test1 = [3, 4, 2]
print(last_digit_func(test1, mapping)) #prints 1
我通过计算python的功效验证了这一点。
test2 = [767456 , 981242]
print(last_digit_func(test2, mapping)) #prints 6
我试图通过在python中运行它来验证这一点。...我现在立即感到遗憾，我的程序仍在尝试解决它。哦，好吧：）