Untuk daftar nomor tertentu temukan digit terakhir dari Contoh: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   

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

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

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

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

Aturan:

Ini adalah kode golf, jadi jawabannya dengan byte paling sedikit menang.

Jika bahasa Anda memiliki batasan ukuran bilangan bulat (mis. ) n akan cukup kecil sehingga jumlahnya akan cocok dengan bilangan bulat.$2^{32}-1$

Input dapat berupa bentuk yang wajar (stdin, file, parameter baris perintah, integer, string, dll).

Output dapat berupa bentuk yang masuk akal (stdout, file, elemen pengguna grafis yang menampilkan nomor, dll).

Melihat perang kode.

JavaScript (ES7), 22 byte

Terbatas untuk .$2^{53}-1$

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

Cobalah online!

R , 25 byte

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

Cobalah online!

Haskell, 19 byte

(`mod`10).foldr1(^)

Cobalah online!

HP 49G RPL, 36,5 byte

Jalankan dalam mode APPROX (tetapi masukkan program dalam mode EXACT). Mengambil input pada stack dengan elemen pertama terdalam di stack, sebagai integer atau real.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

Ini langsung eksponensial pada stack seperti dalam solusi Sophia sampai ada satu nilai yang tersisa, lalu bawa mod 10 untuk mendapatkan digit terakhir.

Alasan saya menggunakan APPROX untuk perhitungan adalah karena 0,0 ^ 0,0 = 1 (ketika keduanya adalah real), tetapi 0 ^ 0 =? (ketika keduanya bilangan bulat). APPROX memaksa semua bilangan bulat ke real, jadi inputnya boleh saja. Namun, saya menggunakan EXACT untuk masuk ke program karena 10 (integer) disimpan digit-demi-digit, dan 6,5 byte, tetapi 10,0 (nyata) disimpan sebagai bilangan real penuh, dan 10,5 byte. Saya juga menghindari penggunaan pengurangan RPL (disebut STREAM) karena memperkenalkan objek program tambahan, yaitu 10 byte overhead. Saya sudah punya satu dan tidak mau yang lain.

Terbatas pada presisi HP 49G nyata (12 angka desimal)

-10 byte setelah daftar kosong -> 1 persyaratan telah dihapus.

-2 byte dengan mengambil input pada stack.

dc , 17 15 byte

1[^z1<M]dsMxzA%

Cobalah online!

Mengambil input dari stack, output ke stack. Implementasi yang sangat mudah - eksponensial hingga hanya satu nilai yang tersisa di stack dan mod untuk digit terakhir.

Terima kasih kepada brhfl untuk menghemat dua byte!

J , 5 byte

-3 byte terima kasih kepada cole!

10|^/

Cobalah online!

05AB1E , 4 byte

.«mθ

Cobalah online!

Penjelasan

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

Pure Bash (hanya builtin - tidak ada utilitas eksternal), 21

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

Input diberikan pada baris perintah sebagai daftar yang dipisahkan koma.

Bash integer tunduk pada batas bilangan bulat yang ditandatangani normal untuk versi 64-dan 32-bit.

Cobalah online!

Bahasa Wolfram (Mathematica) , 16 byte

Power@##~Mod~10&

Cobalah online!

Python 2 dan Python 3 , 30 byte

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

Cobalah online!

Input Ndiharapkan menjadi objek yang dapat diulang lebih dari representasi string dari literal angka .

Ruby, 41 47 byte

Peningkatan ukuran karena penanganan 0 dalam array input, yang perlu pertimbangan ekstra. Terimakasih untukrewritten

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

Ini diselesaikan karena saya percaya sumber asli yang dimaksudkan, yaitu untuk eksponensial yang sangat besar yang tidak akan cocok dengan bilangan bulat asli bahasa - batasannya adalah array akan dijumlahkan 2**32-1, bukan karena perhitungan sementara juga dijamin sesuai. Bahkan itu tampaknya akan menjadi titik tantangan pada Perang Kode Meskipun bilangan bulat asli Ruby bisa menjadi sangat besar, mereka tidak dapat mengatasi contoh di bawah ini yang diproses secara naif dengan% 10 di akhir

Misalnya

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

Keluaran: 9

05AB1E , 8 byte

`.gGm}T%

Cobalah online!

Perl 6 , 14 byte

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

Cobalah online!

Menggunakan kurung meta pengurangan dengan operator **, modulo 10.

APL (Dyalog Unicode) , 5 byte

10|*⌿

Cobalah online!

C # (.NET Core) , 84 byte

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

Cobalah online!

• -7 byte terima kasih kepada @raznagul

C (gcc) , 56

• Disimpan 4 byte berkat @JonathanFrech

Fungsi rekursif r()dipanggil dari makro f- batas stack normal berlaku.

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

Input diberikan sebagai array int nol-dihentikan. Ini dengan asumsi bahwa tidak ada x _n yang nol.

Cobalah online!

Julia 0,6 , 30 byte

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

Cobalah online!

Ini adalah fungsi anon
∘ adalah operator komposisi.
Ini adalah beberapa byte

Japt -h , 7 byte

OvUqp)ì

Cobalah online!

Penjelasan:

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 byte

Jika input dapat diambil dalam urutan terbalik maka karakter pertama dapat dihapus.

Terbatas untuk 2**53-1.

Ôr!p ì

Cobalah

Penjelasan

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

U*@/DṪ

Cobalah online!

Python 2 , 45 43 byte

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

Cobalah online!

Excel VBA, 60 byte

Fungsi jendela langsung VBE anonim yang mengambil input dari jangkauan [A1:XFD1]

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

Stax , 7 byte

üT(Çó╖⌐

Jalankan dan debug itu

Algoritma seperti pada jawaban Python saya

CJam , 14 byte

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

Harus bekerja untuk input apa pun, karena CJam tidak terbatas pada integer 64 bit

Cobalah online!

Python 3 , 55 byte

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

Versi yang lebih lama

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

Python 3 , 47 byte

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

Cobalah online!

Brain-Flak , 161 byte

Termasuk +1 untuk -r

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

Cobalah online!

Contohnya [3, 4, 2]membutuhkan waktu lebih dari 60 detik, sehingga tautan TIO digunakan [4, 3, 2].

The -rdapat dihapus jika input dapat diambil dalam urutan terbalik untuk menghitung byte dari 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

Cobalah online!

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

Cobalah online!

Harness uji brute-force

Mengambil input sebagai byte mentah. Terbatas untuk 2 ** 8-1.

Penjelasan

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}

Cobalah online!