Per una data lista di numero trova l'ultima cifra di x x x … x n 3 2 1 Esempio:$[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   

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

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

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

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

Regole:

Questo è il codice golf, quindi vince la risposta con il minor numero di byte.

Se la tua lingua ha dei limiti sulla dimensione dei numeri interi (es. ) n sarà abbastanza piccolo da contenere la somma nell'intero.$2^{32}-1$

L'input può essere qualsiasi forma ragionevole (stdin, file, parametro della riga di comando, numero intero, stringa, ecc.).

L'output può essere qualsiasi forma ragionevole (stdout, file, elemento utente grafico che visualizza il numero, ecc.).

Ho visto guerre di codice.

JavaScript (ES7), 22 byte

Limitato a .$2^{53}-1$

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

Provalo online!

R , 25 byte

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

Provalo online!

Haskell, 19 byte

(`mod`10).foldr1(^)

Provalo online!

HP 49G RPL, 36,5 byte

Eseguilo in modalità APPROX (ma inserisci il programma in modalità EXACT). Prende input sullo stack con il primo elemento più profondo nello stack, come numeri interi o reali.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

Espone direttamente nello stack come nella soluzione di Sophia fino a quando rimane un valore, quindi prende la mod 10 per ottenere l'ultima cifra.

Il motivo per cui utilizzo APPROX per il calcolo è perché 0,0 ^ 0,0 = 1 (quando sono entrambi reali), ma 0 ^ 0 =? (quando sono entrambi numeri interi). APPROX costringe tutti i numeri interi a reali, quindi l'input va bene con entrambi. Tuttavia, utilizzo EXACT per accedere al programma perché 10 (numero intero) viene memorizzato cifra per cifra ed è 6,5 byte, ma 10,0 (reale) viene memorizzato come numero reale completo ed è 10,5 byte. Inoltre evito di utilizzare la riduzione di RPL (chiamata STREAM) perché introduce un oggetto programma aggiuntivo, che è 10 byte di sovraccarico. Ne ho già uno e non ne voglio un altro.

Limitato alla precisione di un HP 49G reale (12 cifre decimali)

-10 byte dopo elenco vuoto -> 1 requisito è stato rimosso.

-2 byte prendendo input in pila.

dc , 17 15 byte

1[^z1<M]dsMxzA%

Provalo online!

Prende input dallo stack, output allo stack. Implementazione molto semplice: esponenzia fino a quando non rimane un solo valore nello stack e mod per l'ultima cifra.

Grazie a brhfl per aver salvato due byte!

J , 5 byte

-3 byte grazie a Cole!

10|^/

Provalo online!

05AB1E , 4 byte

.«mθ

Provalo online!

Spiegazione

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

Pure Bash (solo builtin - nessuna utility esterna), 21

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

L'input viene fornito sulla riga di comando come un elenco separato da virgole.

I numeri interi di Bash sono soggetti ai normali limiti di numeri interi con segno per le versioni a 64 e 32 bit.

Provalo online!

Wolfram Language (Mathematica) , 16 byte

Power@##~Mod~10&

Provalo online!

Python 2 e Python 3 , 30 byte

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

Provalo online!

Si Nprevede che l'input sia un oggetto iterabile su rappresentazioni di stringhe di letterali numerici .

Rubino, 41 47 byte

Aumento delle dimensioni dovuto alla gestione di qualsiasi 0 nell'array di input, che necessita di ulteriore considerazione. Grazie arewritten

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

Ciò è stato risolto poiché credo che l'origine originale intendesse, vale a dire esponenziazioni molto grandi che non rientrano negli interi nativi della lingua - la restrizione è che l'array si sommerà 2**32-1, non che anche i calcoli provvisori si adattino. In effetti, questo sembrerebbe essere il punto della sfida su Code Wars. Sebbene gli interi nativi di Ruby possano diventare piuttosto grandi, non possono far fronte all'esempio seguente elaborato ingenuamente con un% 10 alla fine

Per esempio

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

Produzione: 9

05AB1E , 8 byte

`.gGm}T%

Provalo online!

Perl 6 , 14 byte

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

Provalo online!

Utilizza le parentesi quadre di riduzione con l'operatore **, modulo 10.

APL (Dyalog Unicode) , 5 byte

10|*⌿

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

Provalo online!

• -7 byte grazie a @raznagul

C (gcc) , 56

• Salvato 4 byte grazie a @JonathanFrech

Funzione ricorsiva r()chiamata da macro f- si applicano i limiti di stack normali.

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

Input fornito come array int con terminazione zero. Questo presuppone che nessuno degli x _n sia zero.

Provalo online!

Julia 0.6 , 30 byte

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

Provalo online!

Questa è una funzione anon
∘ è l'operatore composizione.
Sono più byte

Japt -h , 7 byte

OvUqp)ì

Provalo online!

Spiegazione:

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

Se l'input può essere preso in ordine inverso, il primo carattere può essere rimosso.

Limitato a 2**53-1.

Ôr!p ì

Provalo

Spiegazione

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

Gelatina , 6 byte

U*@/DṪ

Provalo online!

Python 2 , 45 43 byte

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

Provalo online!

Excel VBA, 60 byte

Una funzione finestra immediata VBE anonima che accetta input dall'intervallo [A1:XFD1]

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

Stax , 7 byte

üT(Çó╖⌐

Esegui ed esegui il debug

Algoritmo come nella mia risposta Python

CJam , 14 byte

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

Dovrebbe funzionare per qualsiasi input, poiché CJam non è limitato a numeri interi a 64 bit

Provalo online!

Python 3 , 55 byte

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

Versioni precedenti

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

Provalo online!

Brain-Flak , 161 byte

Include +1 per -r

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

Provalo online!

L'esempio [3, 4, 2]richiede più di 60 secondi, quindi utilizza il collegamento TIO [4, 3, 2].

La -rpuò essere rimosso se ingresso può essere presa in senso inverso per un conteggio di byte di 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

Provalo 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

Provalo online!

Cablaggio di prova a forza bruta

Accetta input come byte non elaborati. Limitato a 2 ** 8-1.

Spiegazione

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

Rubino , 24 20 byte

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

Provalo online!