Belirli bir sayı listesi için ın son basamağını bulun Örnek: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   

Çünkü .$3 ^ {(4 ^ 2)} = 3 ^ {16} = 43046721$

Çünkü .$4 ^ {(3 ^ 2)} = 4 ^ {9} = 262144$

Çünkü .$4 ^ {(3 ^ 1)} = 4 ^ {3} = 64$

Çünkü .$5 ^ {(3 ^ 2)} = 5 ^ {9} = 1953125$

Kurallar:

Bu kod golf, bu yüzden en az bayt ile cevap kazanır.

Dilinizde tamsayı boyutu için sınırlar varsa (ör. ) n, toplamın tamsayıya sığacak kadar küçük olacaktır.$2^{32}-1$

Giriş herhangi bir makul formda olabilir (stdin, dosya, komut satırı parametresi, tamsayı, dize, vb.).

Çıktı herhangi bir makul formda olabilir (stdout, dosya, sayıyı gösteren grafik kullanıcı öğesi, vb.).

Kod savaşlarında gördüm.

JavaScript (ES7), 22 bayt

sınırlıdır .$2^{53}-1$

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

Çevrimiçi deneyin!

R , 25 bayt

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

Çevrimiçi deneyin!

Haskell, 19 bayt

(`mod`10).foldr1(^)

Çevrimiçi deneyin!

HP 49G RPL, 36,5 bayt

APPROX modunda çalıştırın (ancak programa EXACT modunda girin). İlk öğe, tamsayı veya gerçekler olarak yığının en derinindeki yığına girer.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

Sophia'nın çözümünde olduğu gibi bir değer kalana kadar yığın üzerinde açıkça üstlenir, daha sonra son basamağı almak için mod 10 alır.

Hesaplama için APPROX kullanmamın nedeni, 0.0 ^ 0.0 = 1 (her ikisi de real olduğunda), ancak 0 ^ 0 =? (her ikisi de tamsayı olduğunda). APPROX tüm tamsayıları realere zorlar, böylece girdi ikisiyle de iyi olur. Ancak, 10 (tamsayı) basamaklı depolanır ve 6.5 bayt, ancak 10.0 (gerçek) tam gerçek sayı olarak depolanır ve 10.5 bayt olduğundan, programa girmek için EXACT kullanın. Ayrıca 10 bayt ek yükü olan ekstra bir program nesnesi sunduğu için RPL indirgeme (STREAM adı verilir) kullanmaktan kaçının. Zaten bir tane var ve başka bir tane istemiyorum.

HP 49G gerçek (12 ondalık basamak) hassasiyetiyle sınırlıdır

Boş listeden sonra -10 bayt -> 1 gereksinimi kaldırıldı.

Yığına girdi alarak -2 bayt.

dc , 17 15 bayt

1[^z1<M]dsMxzA%

Çevrimiçi deneyin!

Yığından girdi alır, yığına çıkar. Çok basit uygulama - yığın üzerinde yalnızca bir değer ve son basamak için mod kalıncaya kadar üssel olur.

İki bayt tasarrufu için brhfl'e teşekkürler!

J , 5 bayt

Cole sayesinde -3 bayt!

10|^/

Çevrimiçi deneyin!

05AB1E , 4 bayt

.«mθ

Çevrimiçi deneyin!

açıklama

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

Pure Bash (yalnızca yerleşikler - harici yardımcı programlar yok), 21

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

Giriş, komut satırında virgülle ayrılmış bir liste olarak verilir.

Bash tamsayıları 64 ve 32 bit sürümleri için normal imzalı tamsayı sınırlarına tabidir.

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 16 bayt

Power@##~Mod~10&

Çevrimiçi deneyin!

Python 2 ve Python 3 , 30 bayt

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

Çevrimiçi deneyin!

Giriş Nüzerinde bir iterable nesne olması bekleniyor sayı değişmezleri dize temsilleri .

Yakut, 41 47 bayt

Giriş dizisinde herhangi bir 0'ın işlenmesi nedeniyle boyut artışı, bu da ekstra dikkat gerektirir. Sayesinderewritten

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

Bu, orijinal kaynağın, dil yerel tamsayılarına sığmayacak çok büyük üsler için tasarlandığına inandığım için çözüldü - kısıtlama, 2**32-1ara hesaplamaların da sığacağı garanti edilmediğinden dizinin toplamıdır . Aslında bu Kod Savaşları'ndaki zorluğun noktası gibi görünüyor. Ruby'nin yerel tam sayıları oldukça büyüyebilse de, sonunda% 10 ile saf olarak işlenen aşağıdaki örnekle baş edemezler

Örneğin

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

Çıktı: 9

05AB1E , 8 bayt

`.gGm}T%

Çevrimiçi deneyin!

Perl 6 , 14 bayt

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

Çevrimiçi deneyin!

Redüksiyon metali köşeli parantezleri operatör **, modulo 10 ile kullanır.

APL (Dyalog Unicode) , 5 bayt

10|*⌿

Çevrimiçi deneyin!

C # (.NET Core) , 84 bayt

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

Çevrimiçi deneyin!

• @Raznagul sayesinde -7 bayt

C (gcc) , 56

• @JonathanFrech sayesinde 4 bayt kaydedildi

Makrodan r()çağrılan özyinelemeli işlev f- normal yığın sınırları geçerlidir.

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

Sıfır sonlu int dizisi olarak verilen girdi. Bu, x _n'den hiçbirinin sıfır olmadığı varsayımı altındadır .

Çevrimiçi deneyin!

Julia 0.6 , 30 bayt

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

Çevrimiçi deneyin!

Bu bir anon fonksiyonudur
∘ kompozisyon operatörüdür.
Birden çok bayttır

Japt -h , 7 bayt

OvUqp)ì

Çevrimiçi deneyin!

Açıklama:

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 bayt

Giriş ters sırada alınabiliyorsa, ilk karakter kaldırılabilir.

İle sınırlıdır 2**53-1.

Ôr!p ì

Dene

açıklama

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

Jöle , 6 bayt

U*@/DṪ

Çevrimiçi deneyin!

Python 2 , 45 43 bayt

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

Çevrimiçi deneyin!

Excel VBA, 60 bayt

Aralıktan girdi alan anonim bir VBE anında pencere işlevi [A1:XFD1]

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

Stax , 7 bayt

üT(Çó╖⌐

Çalıştır ve hata ayıkla

Python cevabımdaki gibi algoritma

CJam , 14 bayt

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

CJam 64 bit tamsayılarla sınırlı olmadığından herhangi bir giriş için çalışmalıdır

Çevrimiçi deneyin!

Python 3 , 55 bayt

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

eski versiyonlar

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

Python 3 , 47 bayt

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

Çevrimiçi deneyin!

Brain-Flak , 161 bayt

İçin +1 içerir -r

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

Çevrimiçi deneyin!

Örnek [3, 4, 2]60 saniyeden uzun sürüyor, bu nedenle TIO bağlantısı kullanılıyor [4, 3, 2].

-rGiriş 160 bir bayt sayısı için tersten alınabilir halinde çıkarılabilir.

# 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 bayt

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

Çevrimiçi deneyin!

Z80Golf , 36 bayt

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

Çevrimiçi deneyin!

Brute-force test koşum takımı

Ham bayt olarak girdi alır. 2 ** 8-1 ile sınırlıdır.

açıklama

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

Yakut , 24 20 bayt

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

Çevrimiçi deneyin!