Finden Sie für eine gegebene Liste der Nummern die letzte Ziffer von Beispiel: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   

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

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

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

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

Regeln:

Dies ist Codegolf, daher gewinnt die Antwort mit den wenigsten Bytes.

Wenn in Ihrer Sprache die Ganzzahlgröße begrenzt ist (z. B. $2^{32}-1$ ), ist n so klein, dass die Summe in die Ganzzahl passt.

Die Eingabe kann in jeder vernünftigen Form erfolgen (stdin, Datei, Befehlszeilenparameter, Ganzzahl, Zeichenfolge usw.).

Die Ausgabe kann in jeder vernünftigen Form erfolgen (Standardausgabe, Datei, grafisches Benutzerelement, in dem die Nummer angezeigt wird usw.).

Sah auf Code-Kriege.

JavaScript (ES7), 22 Byte

Beschränkt auf .$2^{53}-1$

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

Probieren Sie es online!

R , 25 Bytes

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

Probieren Sie es online!

Haskell, 19 Bytes

(`mod`10).foldr1(^)

Probieren Sie es online!

HP 49G RPL, 36,5 Byte

Führen Sie es im APPROX-Modus aus (aber geben Sie das Programm im EXAKT-Modus ein). Übernimmt Eingaben auf dem Stapel, wobei das erste Element am tiefsten im Stapel liegt, als ganze oder reelle Zahlen.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

Es exponentiiert direkt auf dem Stapel wie in Sophias Lösung, bis ein Wert übrig ist, und benötigt dann Mod 10, um die letzte Ziffer zu erhalten.

Der Grund, warum ich APPROX für die Berechnung verwende, ist, dass 0.0 ^ 0.0 = 1 (wenn beide Real sind), aber 0 ^ 0 =? (wenn beide ganze Zahlen sind). APPROX erzwingt alle Ganzzahlen in reelle Zahlen, daher ist die Eingabe mit beiden in Ordnung. Ich benutze jedoch EXACT, um das Programm aufzurufen, da 10 (Ganzzahl) ziffernweise und 6,5 Byte gespeichert sind, 10.0 (Real) jedoch als vollständige reelle Zahl gespeichert ist und 10,5 Byte beträgt. Ich vermeide auch die Verwendung von RPL's Reduce (STREAM genannt), da es ein zusätzliches Programmobjekt einführt, das 10 Byte Overhead bedeutet. Ich habe bereits eine und will keine andere.

Beschränkt auf die Genauigkeit eines HP 49G real (12 Dezimalstellen)

-10 Byte nach leerer Liste -> 1 Anforderung wurde entfernt.

-2 Bytes durch Eingabe im Stack.

Gleichstrom , 17-15 Bytes

1[^z1<M]dsMxzA%

Probieren Sie es online!

Nimmt Eingaben vom Stapel auf und gibt sie an den Stapel aus. Sehr einfache Implementierung - Exponentiert, bis nur noch ein Wert auf dem Stack und Mod für die letzte Ziffer übrig ist.

Danke an brhfl für das Speichern von zwei Bytes!

J , 5 Bytes

-3 bytes dank cole!

10|^/

Probieren Sie es online!

05AB1E , 4 Bytes

.«mθ

Probieren Sie es online!

Erläuterung

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

Pure Bash (nur integrierte - keine externen Dienstprogramme), 21

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

Die Eingabe wird in der Befehlszeile als durch Kommas getrennte Liste angegeben.

Bash-Ganzzahlen unterliegen für 64- und 32-Bit-Versionen den normalen Beschränkungen für Ganzzahlen mit Vorzeichen.

Probieren Sie es online!

Wolfram Language (Mathematica) , 16 Byte

Power@##~Mod~10&

Probieren Sie es online!

Python 2 und Python 3 , 30 Bytes

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

Probieren Sie es online!

Es Nwird erwartet, dass die Eingabe ein iterierbares Objekt über Zeichenfolgendarstellungen von Zahlenliteralen ist .

Ruby, 41 47 Bytes

Größenzunahme aufgrund der Behandlung von 0 im Eingabearray, die zusätzliche Berücksichtigung erfordert. Dank anrewritten

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

Dies wird gelöst, da ich glaube, dass die ursprüngliche Quelle beabsichtigt ist, dh für sehr große Potenzierungen, die nicht in sprachgebundene Ganzzahlen passen - die Einschränkung ist, dass das Array summiert wird 2**32-1und nicht, dass die Zwischenberechnungen auch garantiert passen. Tatsächlich scheint dies der Punkt der Herausforderung bei Code Wars zu sein. Rubys native Ganzzahlen können zwar ziemlich groß werden, mit% 10 am Ende können sie das folgende Beispiel jedoch nicht naiv verarbeiten

Z.B

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

Ausgabe: 9

05AB1E , 8 Bytes

`.gGm}T%

Probieren Sie es online!

Perl 6 , 14 Bytes

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

Probieren Sie es online!

Verwendet die Verkleinerungs-Meta-eckigen Klammern mit dem Operator **, modulo 10.

APL (Dyalog Unicode) , 5 Bytes

10|*⌿

Probieren Sie es 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;}

Probieren Sie es online!

• -7 Bytes dank @raznagul

C (gcc) , 56

• 4 Bytes dank @JonathanFrech gespeichert

Rekursive Funktion, r()die von Makro aufgerufen wird f- normale Stapelbegrenzungen gelten.

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

Eingabe als nullterminiertes int-Array. Dies unter der Annahme, dass keines der x _n Null ist.

Probieren Sie es online!

Julia 0,6 , 30 Bytes

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

Probieren Sie es online!

Dies ist eine anon Funktion function
ist der Kompositionsoperator.
Es sind mehrere Bytes

Japt -h , 7 Bytes

OvUqp)ì

Probieren Sie es online!

Erläuterung:

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

Wenn die Eingabe in umgekehrter Reihenfolge erfolgen kann, kann das erste Zeichen entfernt werden.

Beschränkt auf 2**53-1.

Ôr!p ì

Versuch es

Erläuterung

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

Gelee , 6 Bytes

U*@/DṪ

Probieren Sie es online!

Python 2 , 45 43 Bytes

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

Probieren Sie es online!

Excel VBA, 60 Bytes

Eine anonyme VBE-Direktfensterfunktion, die Eingaben aus dem Bereich entgegennimmt [A1:XFD1]

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

Stax , 7 Bytes

üT(Çó╖⌐

Führen Sie es aus, und debuggen Sie es

Algorithmus wie in meiner Python-Antwort

CJam , 14 Bytes

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

Sollte für jede Eingabe funktionieren, da CJam nicht auf 64-Bit-Ganzzahlen beschränkt ist

Probieren Sie es online!

Python 3 , 55 Bytes

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

ältere Versionen

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

Probieren Sie es online!

Brain-Flak , 161 Bytes

Beinhaltet +1 für -r

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

Probieren Sie es online!

Das Beispiel [3, 4, 2]dauert länger als 60 Sekunden, sodass die TIO-Verbindung verwendet wird [4, 3, 2].

Das -rkann entfernt werden, wenn die Eingabe für eine Byteanzahl von 160 in umgekehrter Reihenfolge erfolgen kann.

# 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

Probieren Sie es 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

Probieren Sie es online!

Brute-Force-Testgeschirr

Nimmt die Eingabe als Rohbytes. Beschränkt auf 2 ** 8-1.

Erläuterung

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}

Probieren Sie es online!