Para uma lista específica de número encontre o último dígito de Exemplo: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   

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

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

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

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

Regras:

Isso é código de golfe, então a resposta com o menor número de bytes vence.

Se o seu idioma tiver limites para o tamanho inteiro (ex. ) n será pequeno o suficiente para que a soma caiba no número inteiro.$2^{32}-1$

A entrada pode ser de qualquer forma razoável (stdin, arquivo, parâmetro de linha de comando, número inteiro, string, etc.).

A saída pode ser de qualquer forma razoável (stdout, arquivo, elemento gráfico do usuário que exibe o número, etc.).

Vi em guerras de código.

JavaScript (ES7), 22 bytes

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

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

Experimente online!

R , 25 bytes

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

Experimente online!

Haskell, 19 bytes

(`mod`10).foldr1(^)

Experimente online!

HP 49G RPL, 36,5 bytes

Execute-o no modo APPROX (mas insira o programa no modo EXATO). Recebe entrada na pilha com o primeiro elemento mais profundo da pilha, como números inteiros ou reais.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

Ele exponencia diretamente a pilha como na solução de Sophia até que exista um valor restante e, em seguida, é necessário o mod 10 para obter o último dígito.

A razão pela qual eu uso o APPROX para computação é porque 0,0 ^ 0,0 = 1 (quando ambos são reais), mas 0 ^ 0 =? (quando ambos são inteiros). APPROX coage todos os números inteiros em reais, portanto a entrada é adequada para qualquer um. No entanto, eu uso EXACT para entrar no programa porque 10 (inteiro) é armazenado dígito por dígito e tem 6,5 bytes, mas 10,0 (real) é armazenado como um número real completo e tem 10,5 bytes. Também evito usar a redução de RPL (chamada STREAM) porque ela introduz um objeto de programa extra, que tem 10 bytes de sobrecarga. Eu já tenho um e não quero outro.

Limitado à precisão de um HP 49G real (12 dígitos decimais)

-10 bytes após a lista vazia -> 1 requisito foi removido.

-2 bytes, tendo entrada na pilha.

dc , 17 15 bytes

1[^z1<M]dsMxzA%

Experimente online!

Pega a entrada da pilha, sai para a pilha. Implementação simples - exponencia até que apenas um valor seja deixado na pilha e mod para o último dígito.

Obrigado ao brhfl por salvar dois bytes!

J , 5 bytes

-3 bytes graças a cole!

10|^/

Experimente online!

05AB1E , 4 bytes

.«mθ

Experimente online!

Explicação

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

Pure Bash (somente interno - sem utilitários externos), 21

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

A entrada é fornecida na linha de comando como uma lista separada por vírgula.

Os números inteiros do Bash estão sujeitos a limites inteiros assinados normais para as versões de 64 e 32 bits.

Experimente online!

Wolfram Language (Mathematica) , 16 bytes

Power@##~Mod~10&

Experimente online!

Python 2 e Python 3 , 30 bytes

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

Experimente online!

NEspera-se que a entrada seja um objeto iterável sobre representações de seqüência de caracteres de números literais .

Ruby, 41 47 bytes

Aumento do tamanho devido à manipulação de qualquer 0 na matriz de entrada, o que precisa de consideração extra. Graças arewritten

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

Isso é resolvido como eu acredito que a fonte original pretendia, ou seja, para exponenciações muito grandes que não se encaixam em números inteiros nativos da linguagem - a restrição é que a matriz será agregada 2**32-1, não que os cálculos provisórios também sejam garantidos. De fato, isso parece ser o ponto do desafio em Code Wars. Embora os números inteiros nativos do Ruby possam ficar muito grandes, eles não podem lidar com o exemplo abaixo processado ingenuamente com um% 10 no final

Por exemplo

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

Resultado: 9

05AB1E , 8 bytes

`.gGm}T%

Experimente online!

Perl 6 , 14 bytes

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

Experimente online!

Utiliza os meta-colchetes de redução com o operador **, módulo 10.

APL (Dyalog Unicode) , 5 bytes

10|*⌿

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

Experimente online!

• -7 bytes graças a @raznagul

C (gcc) , 56

• Guardado 4 bytes graças a @JonathanFrech

A função recursiva r()chamada de flimites de pilha macro -normais se aplica.

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

Entrada fornecida como uma matriz int terminada em zero. Isso está no pressuposto de que nenhum dos x _n é zero.

Experimente online!

Julia 0.6 , 30 bytes

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

Experimente online!

Esta é uma função anon
∘ é o operador de composição.
É vários bytes

Japonês -h , 7 bytes

OvUqp)ì

Experimente online!

Explicação:

OvUqp)ì
Ov   )    // Japt eval:
   q      //   Join
  U       //   Input with
    p     //   Power method
      ì   // Split into an array of numbers
-h        // Return the last number

Japonês -h , 7 6 bytes

Se a entrada puder ser obtida na ordem inversa, o primeiro caractere poderá ser removido.

Limitado a 2**53-1.

Ôr!p ì

Tente

Explicação

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

U*@/DṪ

Experimente online!

Python 2 , 45 43 bytes

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

Experimente online!

Excel VBA, 60 bytes

Uma função de janela imediata anônima do VBE que recebe entrada do intervalo [A1:XFD1]

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

Stax , 7 bytes

üT(Çó╖⌐

Execute e depure

Algoritmo como na minha resposta Python

CJam , 14 bytes

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

Deve funcionar para qualquer entrada, pois o CJam não está limitado a números inteiros de 64 bits.

Experimente online!

Python 3 , 55 bytes

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

versões mais antigas

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

Experimente online!

Flak cerebral , 161 bytes

Inclui +1 para -r

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

Experimente online!

O exemplo [3, 4, 2]leva mais de 60 segundos, portanto, o link TIO é usado [4, 3, 2].

A -rpode ser removido se a entrada pode ser feita na ordem inversa para uma contagem de bytes de 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 bytes

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

Experimente 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

Experimente online!

Arnês de teste de força bruta

Recebe entrada como bytes brutos. Limitado a 2 ** 8-1.

Explicação

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}

Experimente online!