对于给定的数字找到的最后一位 示例：x x x … x n 3 2$[x_1, x_2, x_3, ..., x_n]$$x_1 ^{x_2 ^ {x_3 ^ {\dots ^ {x_n}}}}$

[3, 4, 2] == 1
[4, 3, 2] == 4
[4, 3, 1] == 4
[5, 3, 2] == 5   

因为。$3 ^ {(4 ^ 2)} = 3 ^ {16} = 43046721$

因为。$4 ^ {(3 ^ 2)} = 4 ^ {9} = 262144$

因为。$4 ^ {(3 ^ 1)} = 4 ^ {3} = 64$

因为。$5 ^ {(3 ^ 2)} = 5 ^ {9} = 1953125$

规则：

这是代码高尔夫球，因此字节最少的答案会获胜。

如果您的语言对整数大小有限制（例如），则n将足够小以使总和适合整数。$2^{32}-1$

输入可以是任何合理的形式（stdin，文件，命令行参数，整数，字符串等）。

输出可以是任何合理的形式（标准输出，文件，显示数字的图形用户元素等）。

看到了代码大战。

JavaScript（ES7），22个字节

限于。$2^{53}-1$

a=>eval(a.join`**`)%10

在线尝试！

R，25个字节

Reduce(`^`,scan(),,T)%%10

在线尝试！

Haskell，19个字节

(`mod`10).foldr1(^)

在线尝试！

HP 49G RPL，36.5字节

在APPROX模式下运行它（但在EXACT模式下输入程序）。接受堆栈中第一个元素最深的堆栈中的输入，为整数或实数。

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

它像在Sophia的解决方案中那样直接在堆栈上求幂，直到剩下一个值为止，然后将其取值为mod 10以获得最后一位。

我使用APPROX进行计算的原因是因为0.0 ^ 0.0 = 1（当它们都是实数时），但是0 ^ 0 =？（当它们都是整数时）。APPROX将所有整数都强制转换为实数，因此使用任一输入都可以。但是，我使用EXACT进入程序是因为10（整数）是逐位存储的，是6.5个字节，而10.0（实数）是作为一个完整的实数存储的，是10.5个字节。我还避免使用RPL的reduce（称为STREAM），因为它引入了额外的程序对象，这是10字节的开销。我已经有一个，不想再有一个。

仅限于HP 49G实数的精度（12个十进制数字）

空列表后的-10个字节-> 1个要求已删除。

通过在堆栈上输入-2个字节。

dc，17 15字节

1[^z1<M]dsMxzA%

在线尝试！

从堆栈中获取输入，然后输出到堆栈。非常简单的实现-取幂，直到堆栈上只剩下一个值，最后一位取mod。

感谢brhfl节省了两个字节！

J，5个字节

-3个字节，感谢科尔！

10|^/

在线尝试！

05AB1E，4个字节

.«mθ

在线尝试！

说明

.«     # fold
  m    # power
   θ   # take the last digit

Pure Bash（仅内置工具-无外部实用程序），21

echo $[${1//,/**}%10]

输入在命令行中以逗号分隔的列表形式给出。

对于64位和32位版本，Bash整数受常规有符号整数限制。

在线尝试！

Wolfram语言（Mathematica），16字节

Power@##~Mod~10&

在线尝试！

Python 2和Python 3，30个字节

lambda N:eval('**'.join(N))%10

在线尝试！

输入应该N是数字文字的字符串表示形式上的可迭代对象。

Ruby，41个 47字节

由于处理输入数组中的任何0导致大小增加，这需要额外考虑。谢谢rewritten

->a{a.reverse.inject{|t,n|n<2?n:n**(t%4+4)}%10}

我认为这是解决问题的原因，因为我相信原始来源的意图是，即对于不适合语言本机整数的非常大的幂运算-限制是数组将求和2**32-1，而不是也不能保证临时计算适合。实际上，这似乎是《代码大战》面临挑战的重点。尽管Ruby的本机整数可能会变得很大，但它们无法处理下面的示例，该示例天真地以％10结尾

例如

输入： [999999,213412499,34532597,4125159,53539,54256439,353259,4314319,5325329,1242149,142219,1243219,14149,1242149,124419,999999999]

输出： 9

05AB1E，8个字节

`.gGm}T%

在线尝试！

Perl 6、14个字节

{([**] $_)%10}

在线尝试！

与运算符**一起使用归约方括号，取模10。

APL（Dyalog Unicode），5 个字节

10|*⌿

在线尝试！

C＃（.NET Core），84字节

a=>{int i=a.Length-1,j=a[i];for(;i-->0;)j=(int)System.Math.Pow(a[i],j);return j%10;}

在线尝试！

• -7个字节，感谢@raznagul

C（gcc），56

• @JonathanFrech节省了4个字节

r()从宏调用的递归函数f-正常的堆栈限制适用。

R;r(int*n){R=pow(*n,n[1]?r(n+1):1);}
#define f(n)r(n)%10

输入以零终止的int数组形式给出。这是基于x _n都不为零的假设。

在线尝试！

朱莉娅0.6，30字节

first∘digits∘x->foldl(^,x)

在线尝试！

这是一个匿名函数
∘是合成算符。
它是多个字节

Japt -h，7个字节

OvUqp)ì

在线尝试！

说明：

OvUqp)ì
Ov   )    // Japt eval:
   q      //   Join
  U       //   Input with
    p     //   Power method
      ì   // Split into an array of numbers
-h        // Return the last number

Japt -h，7 6字节

如果可以按相反的顺序输入，则可以删除第一个字符。

仅限于2**53-1。

Ôr!p ì

尝试一下

说明

Ô          :Reverse the array
 r         :Reduce by
  !p       :  Raising the current element to the power of the current total, initially the first element
     ì     :Split to an array of digits
           :Implicitly output the last element

果冻，6个字节

U*@/DṪ

在线尝试！

Python 2中，45 43个字节

lambda x:reduce(lambda b,a:a**b,x[::-1])%10

在线尝试！

Excel VBA，60字节

匿名VBE立即窗口函数，可接收范围内的输入 [A1:XFD1]

s=1:For i=-[Count(1:1)]To-1:s=Cells(1,-i)^s:Next:?Right(s,1)

Stax，7 个字节

üT(Çó╖⌐

运行并调试

像我的Python答案中的算法

CJam，14个字节

q~_,({~#]}*~A%

应该适用于任何输入，因为CJam不限于64位整数

在线尝试！

Python 3，55个字节

p=lambda l,i=-1:not l or f'{l[0]**int(p(l[1:],0))}'[i:] 

旧版本

p=lambda l,i=-1:len(l)and f'{l[0]**int(p(l[1:],0))}'[i:]or 1    (60 bytes)

Python 3，47个字节

f=lambda x,y=1:f(x[:-1],x[-1]**y)if x else y%10

在线尝试！

Brain-Flak，161字节

包括+1的 -r

([][()]){({}[()]<({}<(({}))>[()]){({}<(({})<({}<>)({<({}[()])><>({})<>}{}<><{}>)>)>[()])}{}{}>)}{}({}((()()()()()){})(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

在线尝试！

该示例[3, 4, 2]花费的时间超过60秒，因此TIO链接使用[4, 3, 2]。

-r如果可以按相反的顺序进行输入（字节数为160），则可以删除。

# Push stack size -1
([][()])

# While there are 2 numbers on the stack
{({}[()]<

    # Duplicate the second number on the stack (we're multiplying this number by itself)
    ({}<(({}))>[()])

    # For 0 .. TOS
    {({}<

        # Copy TOS
        (({})<

        # Multiple Top 2 numbers
        ({}<>)({<({}[()])><>({})<>}{}<><{}>)

        # Paste the old TOS
        >)

    # End for (and clean up a little)
    >[()])}{}{}

# End While (and clean up)
>)}{}

# Mod 10
({}((()()()()()){})(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

Pari / GP，32字节

a->fold((x,y)->y^x,Vecrev(a))%10

在线尝试！

Z80Golf，36个字节

00000000: cd03 80f5 30fa f1f1 57f1 280d 4f41 15af  ....0...W.(.OA..
00000010: 8110 fd47 1520 f818 ef7a d60a 30fc c60a  ...G. ...z..0...
00000020: cd00 8076                                ...v

在线尝试！

蛮力测试线束

将输入作为原始字节。限于2 ** 8-1。

说明

input:
    call $8003    ;      the input bytes
    push af       ; push                 on the stack
    jr nc, input  ;                                   until EOF
    pop af        ; the last byte is going to be pushed twice
    pop af
outer:
    ld d, a       ; d = exponentiation loop counter, aka the exponent
    pop af        ; pop the new base off the stack
    jr z, output  ; The flags are being pushed and popped together with the
                  ; accumulator. Since the Z flag starts as unset and no
                  ; instruction in the input loop modifies it, the Z flag is
                  ; going to be unset as long as there is input, so the jump
                  ; won't be taken. After input is depleted, a controlled stack
                  ; underflow will occur. Since SP starts at 0, the flags
                  ; register will be set to the $cd byte from the very beginning
                  ; of the program. The bit corresponding to the Z flag happens
                  ; to be set in that byte, so the main loop will stop executing
    ld c, a       ; C = current base
    ld b, c       ; B = partial product of the exponentiation loop
    dec d         ; if the exponent is 2, the loop should only execute once, so
                  ; decrement it to adjust that
pow:
    xor a         ; the multiplication loop sets A to B*C and zeroes B in the
mul:              ; process, since it's used as the loop counter
    add c         ; it's definitely not the fastest multiplication algorithm,
    djnz mul      ; but it is the smallest
    ld b, a       ; save the multiplication result as the partial product
    dec d         ; jump back to make the next iteration of either
    jr nz, pow    ; the exponentiation loop or the main loop, adjusting the
    jr outer      ; loop counter in the process
output:           ; after all input is processed, we jump here. We've prepared
    ld a, d       ; to use the result as the next exponent, so copy it back to A
mod:              ; simple modulo algorithm:
    sub 10        ;            subtract ten
    jr nc, mod    ; repeatedly              until you underflow,
    add 10        ; then undo the last subtraction by adding ten
    call $8000    ; output the result
    halt          ; and exit

红宝石，24 20字节

->a{eval(a*'**')%10}

在线尝试！