番号の指定されたリストは、x x x … x n 3 2 1の最後の桁を見つける 例：$[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、ファイル、コマンドラインパラメーター、整数、文字列など）にすることができます。

出力は、合理的な形式（stdout、ファイル、数字を表示するグラフィカルユーザー要素など）にすることができます。

コード戦争を見ました。

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のソリューションのように、1つの値が残るまでスタック上で簡単に累乗し、10を法として最後の桁を取得します。

計算にAPPROXを使用する理由は、0.0 ^ 0.0 = 1（両方が実数である場合）であるが、0 ^ 0 =？（両方が整数の場合）。APPROXはすべての整数を実数に強制するため、どちらでも問題ありません。ただし、10（整数）は1桁ずつ格納され、6.5バイトですが、10.0（実数）は完全な実数として格納され、10.5バイトであるため、EXACTを使用してプログラムに入ります。また、RPLのreduce（STREAMと呼ばれる）を使用することは避けます。これは、10バイトのオーバーヘッドである余分なプログラムオブジェクトを導入するためです。私はすでに持っていますが、もう必要ありません。

HP 49G実数（12桁の12桁）の精度に制限されています

空のリストの後-10バイト-> 1つの要件が削除されました。

スタックで入力を取得して-2バイト。

dc、17 15バイト

1[^z1<M]dsMxzA%

オンラインでお試しください！

スタックから入力を受け取り、スタックに出力します。非常に簡単な実装-スタックに1つの値だけが残り、最後の桁のmodになるまで累乗します。

2バイトを節約してくれたbrhflに感謝します！

J、5バイト

コールのおかげで-3バイト！

10|^/

オンラインでお試しください！

05AB1E、4バイト

.«mθ

オンラインでお試しください！

説明

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

Pure Bash（組み込みのみ-外部ユーティリティなし）、21

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

入力は、コンマで区切られたリストとしてコマンドラインで与えられます。

bash整数は、64ビットおよび32ビットバージョンの通常の符号付き整数の制限に従います。

オンラインでお試しください！

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;}

オンラインでお試しください！

• @raznagulのおかげで-7バイト

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)ì

オンラインでお試しください！

Explanation:

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

ジャプト -h、7 6 bytes

入力を逆順で取得できる場合は、最初の文字を削除できます。

に限定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

Jelly, 6 bytes

U*@/DṪ

Try it online!

Python 2, 45 43 bytes

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

Try it online!

Excel VBA, 60 bytes

An anonymous VBE immediate window function that takes input from range [A1:XFD1]

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

Stax, 7 bytes

üT(Çó╖⌐

Run and debug it

Algorithm like in my Python answer

CJam, 14 bytes

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

Should work for any input, since CJam isn't limited to 64 bit integers

Try it online!

Python 3, 55 bytes

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

Older versions

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

Python 3, 47 bytes

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

Try it online!

Brain-Flak, 161 bytes

Includes +1 for -r

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

Try it online!

The example [3, 4, 2] takes longer than 60 seconds, so the TIO link uses [4, 3, 2].

The -r can be removed if input can be taken in reverse order for a byte count of 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 bytes

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

Try it online!

Z80Golf, 36 bytes

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

Try it online!

Brute-force test harness

Takes input as raw bytes. Limited to 2**8-1.

Explanation

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

Ruby, 24 20 bytes

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

Try it online!