Cho một danh sách số đã cho tìm chữ số cuối cùng của x x x ... x n 3 2 1 Ví dụ:$[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   

Vì .$3 ^ {(4 ^ 2)} = 3 ^ {16} = 43046721$

Vì .$4 ^ {(3 ^ 2)} = 4 ^ {9} = 262144$

Vì .$4 ^ {(3 ^ 1)} = 4 ^ {3} = 64$

Vì .$5 ^ {(3 ^ 2)} = 5 ^ {9} = 1953125$

Quy tắc:

Đây là mã golf, vì vậy câu trả lời có ít byte nhất sẽ thắng.

Nếu ngôn ngữ của bạn có giới hạn về kích thước số nguyên (ví dụ ) n sẽ đủ nhỏ để tổng sẽ khớp với số nguyên.$2^{32}-1$

Đầu vào có thể là bất kỳ dạng hợp lý nào (stdin, tệp, tham số dòng lệnh, số nguyên, chuỗi, v.v.).

Đầu ra có thể là bất kỳ hình thức hợp lý nào (thiết bị xuất chuẩn, tệp, phần tử người dùng đồ họa hiển thị số, v.v.).

Cưa về cuộc chiến mã.

JavaScript (ES7), 22 byte

Giới hạn ở .$2^{53}-1$

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

Hãy thử trực tuyến!

R , 25 byte

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

Hãy thử trực tuyến!

Haskell, 19 byte

(`mod`10).foldr1(^)

Hãy thử trực tuyến!

HP 49G RPL, 36,5 byte

Chạy nó ở chế độ APPROX (nhưng nhập chương trình ở chế độ CHÍNH XÁC). Đưa đầu vào vào ngăn xếp với phần tử đầu tiên sâu nhất trong ngăn xếp, dưới dạng số nguyên hoặc số thực.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

Nó đơn giản lũy thừa theo cấp số nhân như trong giải pháp của Sophia cho đến khi còn một giá trị, sau đó lấy mod 10 để lấy chữ số cuối cùng.

Lý do tôi sử dụng APPROX để tính toán là vì 0,0 ^ 0,0 = 1 (khi cả hai đều là số thực), nhưng 0 ^ 0 =? (khi cả hai đều là số nguyên). APPROX ép buộc tất cả các số nguyên thành số thực, do đó, đầu vào cũng ổn với một trong hai. Tuy nhiên, tôi sử dụng EXACT để vào chương trình vì 10 (số nguyên) được lưu trữ theo từng chữ số và là 6,5 byte, nhưng 10.0 (thực) được lưu trữ dưới dạng một số thực đầy đủ và là 10,5 byte. Tôi cũng tránh sử dụng giảm RPL (được gọi là STREAM) vì nó giới thiệu một đối tượng chương trình bổ sung, có 10 byte trên không. Tôi đã có một cái và không muốn cái khác.

Giới hạn ở độ chính xác của HP 49G thực (12 chữ số thập phân)

-10 byte sau khi danh sách trống -> 1 yêu cầu đã bị xóa.

-2 byte bằng cách lấy đầu vào trên ngăn xếp.

dc , 17 15 byte

1[^z1<M]dsMxzA%

Hãy thử trực tuyến!

Lấy đầu vào từ ngăn xếp, đầu ra cho ngăn xếp. Việc thực hiện rất đơn giản - lũy thừa cho đến khi chỉ còn một giá trị trên ngăn xếp và mod cho chữ số cuối cùng.

Cảm ơn brhfl đã lưu hai byte!

J , 5 byte

-3 byte nhờ cole!

10|^/

Hãy thử trực tuyến!

05AB1E , 4 byte

.«mθ

Hãy thử trực tuyến!

Giải trình

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

Pure Bash (chỉ tích hợp - không có tiện ích bên ngoài), 21

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

Đầu vào được đưa ra trên dòng lệnh dưới dạng danh sách được phân tách bằng dấu phẩy.

Số nguyên Bash phải tuân theo giới hạn số nguyên được ký bình thường cho các phiên bản 64 và 32 bit.

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 16 byte

Power@##~Mod~10&

Hãy thử trực tuyến!

Python 2 và Python 3 , 30 byte

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

Hãy thử trực tuyến!

Đầu vào Ndự kiến ​​là một đối tượng có thể lặp lại trên các biểu diễn chuỗi của số chữ .

Ruby, 41 47 byte

Kích thước tăng do xử lý bất kỳ 0 nào trong mảng đầu vào, cần xem xét thêm. Nhờ vàorewritten

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

This is solved as I believe the original source intended, i.e. for very large exponentiations that will not fit into language native integers - the restriction is that the array will sum into 2**32-1, not that the interim calculations are also guaranteed to fit. In fact that would seem to be the point of the challenge on Code Wars. Although Ruby's native integers can get pretty big, they cannot cope with the example below processed naively with a %10 at the end

E.g.

Input: [999999,213412499,34532597,4125159,53539,54256439,353259,4314319,5325329,1242149,142219,1243219,14149,1242149,124419,999999999]

Output: 9

05AB1E, 8 bytes

`.gGm}T%

Try it online!

Perl 6, 14 bytes

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

Try it online!

Uses the reduction meta square brackets with the operator **, modulo 10.

APL (Dyalog Unicode), 5 bytes

10|*⌿

Try it online!

C# (.NET Core), 84 bytes

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

Try it online!

• -7 bytes thanks to @raznagul

C (gcc), 56

• Saved 4 bytes thanks to @JonathanFrech

Recursive function r() called from macro f - normal stack limits apply.

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

Input given as a zero-terminated int array. This is under the assumption that none of the x_n are zero.

Try it online!

Julia 0.6, 30 bytes

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

Try it online!

This is an anon function
∘ is the composition operator.
It is multiple bytes

Japt -h, 7 bytes

OvUqp)ì

Try it online!

Explanation:

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 bytes

If input can be taken in reverse order then the first character can be removed.

Limited to 2**53-1.

Ôr!p ì

Try it

Explanation

Ô          :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

Bao gồm +1 cho -r

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

Hãy thử trực tuyến!

Ví dụ [3, 4, 2]này dài hơn 60 giây, vì vậy liên kết TIO sử dụng[4, 3, 2].

Có -rthể loại bỏ nếu đầu vào có thể được thực hiện theo thứ tự ngược lại cho số byte là 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 byte

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

Hãy thử trực tuyến!

Z80Golf , 36 byte

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

Hãy thử trực tuyến!

Khai thác kiểm tra lực lượng Brute

Lấy đầu vào dưới dạng byte thô. Giới hạn ở 2 ** 8-1.

Giải trình

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 byte

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

Hãy thử trực tuyến!