Pour une liste donnée de nombres trouvez le dernier chiffre de Exemple: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   

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

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

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

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

Règles:

C'est le golf de code, donc la réponse avec le moins d'octets gagne.

Si votre langue a des limites sur la taille entière (ex. ) n sera suffisamment petit pour que la somme tienne dans l'entier.$2^{32}-1$

L'entrée peut être de n'importe quelle forme raisonnable (stdin, fichier, paramètre de ligne de commande, entier, chaîne, etc.).

La sortie peut être de n'importe quelle forme raisonnable (stdout, fichier, élément utilisateur graphique qui affiche le nombre, etc.).

Vu sur les guerres de code.

JavaScript (ES7), 22 octets

Limité à .$2^{53}-1$

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

Essayez-le en ligne!

R , 25 octets

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

Essayez-le en ligne!

Haskell, 19 octets

(`mod`10).foldr1(^)

Essayez-le en ligne!

HP 49G RPL, 36,5 octets

Exécutez-le en mode APPROX (mais entrez le programme en mode EXACT). Prend des entrées sur la pile avec le premier élément le plus profond de la pile, sous forme d'entiers ou de réels.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

Il expose simplement sur la pile comme dans la solution de Sophia jusqu'à ce qu'il reste une valeur, puis prend le mod 10 pour obtenir le dernier chiffre.

La raison pour laquelle j'utilise APPROX pour le calcul est parce que 0,0 ^ 0,0 = 1 (quand ils sont tous les deux réels), mais 0 ^ 0 =? (quand ils sont tous les deux des entiers). APPROX contraint tous les entiers en réels, donc l'entrée est correcte avec l'un ou l'autre. Cependant, j'utilise EXACT pour entrer dans le programme parce que 10 (entier) est stocké chiffre par chiffre, et est de 6,5 octets, mais 10,0 (réel) est stocké en tant que nombre réel complet et est de 10,5 octets. J'évite également d'utiliser la réduction de RPL (appelée STREAM) car elle introduit un objet programme supplémentaire, qui représente 10 octets de surcharge. J'en ai déjà un et je n'en veux pas d'autre.

Limité à la précision d'un HP 49G réel (12 chiffres décimaux)

-10 octets après la liste vide -> 1 exigence a été supprimée.

-2 octets en prenant l'entrée sur la pile.

dc , 17 15 octets

1[^z1<M]dsMxzA%

Essayez-le en ligne!

Prend des entrées de la pile, des sorties vers la pile. Implémentation très simple - exponentiates jusqu'à ce qu'il ne reste qu'une valeur sur la pile et mod pour le dernier chiffre.

Merci à brhfl pour avoir économisé deux octets!

J , 5 octets

-3 octets grâce à Cole!

10|^/

Essayez-le en ligne!

05AB1E , 4 octets

.«mθ

Essayez-le en ligne!

Explication

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

Pure Bash (intégrés uniquement - pas d'utilitaires externes), 21

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

L'entrée est donnée sur la ligne de commande sous la forme d'une liste séparée par des virgules.

Les entiers bash sont soumis à des limites entières signées normales pour les versions 64 et 32 ​​bits.

Essayez-le en ligne!

Wolfram Language (Mathematica) , 16 octets

Power@##~Mod~10&

Essayez-le en ligne!

Python 2 et Python 3 , 30 octets

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

Essayez-le en ligne!

L'entrée Ndevrait être un objet itérable sur des représentations de chaînes de littéraux numériques .

Rubis, 41 47 octets

Augmentation de la taille en raison de la gestion de tout 0 dans le tableau d'entrée, ce qui nécessite une attention supplémentaire. Grâce àrewritten

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

Cela est résolu car je pense que la source d'origine était destinée, c'est-à-dire pour les très grandes exponentiations qui ne rentreront pas dans les entiers natifs de la langue - la restriction est que le tableau résumera 2**32-1, et non que les calculs intermédiaires sont également garantis. En fait, cela semble être le but du défi sur Code Wars. Bien que les entiers natifs de Ruby puissent devenir assez gros, ils ne peuvent pas faire face à l'exemple ci-dessous traité naïvement avec un% 10 à la fin

Par exemple

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

Production: 9

05AB1E , 8 octets

`.gGm}T%

Essayez-le en ligne!

Perl 6 , 14 octets

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

Essayez-le en ligne!

Utilise les méta crochets de réduction avec l'opérateur **, modulo 10.

APL (Dyalog Unicode) , 5 octets

10|*⌿

Essayez-le en ligne!

C # (.NET Core) , 84 octets

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

Essayez-le en ligne!

• -7 octets grâce à @raznagul

C (gcc) , 56

• 4 octets enregistrés grâce à @JonathanFrech

Fonction récursive r()appelée depuis la macro f- les limites de pile normales s'appliquent.

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

Entrée donnée sous la forme d'un tableau int à terminaison zéro. Ceci sous l'hypothèse qu'aucun des x _n n'est nul.

Essayez-le en ligne!

Julia 0,6 , 30 octets

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

Essayez-le en ligne!

Il s'agit d'une fonction anon
∘ est l'opérateur de composition.
Il s'agit de plusieurs octets

Japt -h , 7 octets

OvUqp)ì

Essayez-le en ligne!

Explication:

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 octets

Si l'entrée peut être prise dans l'ordre inverse, le premier caractère peut être supprimé.

Limité à 2**53-1.

Ôr!p ì

Essayez-le

Explication

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

Gelée , 6 octets

U*@/DṪ

Essayez-le en ligne!

Python 2 , 45 43 octets

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

Essayez-le en ligne!

Excel VBA, 60 octets

Une fonction de fenêtre immédiate VBE anonyme qui prend l'entrée de la plage [A1:XFD1]

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

Stax , 7 octets

üT(Çó╖⌐

Exécuter et déboguer

Algorithme comme dans ma réponse Python

CJam , 14 octets

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

Devrait fonctionner pour n'importe quelle entrée, car CJam n'est pas limité aux entiers 64 bits

Essayez-le en ligne!

Python 3 , 55 octets

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

Versions plus anciennes

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

Python 3 , 47 octets

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

Essayez-le en ligne!

Brain-Flak , 161 octets

Comprend +1 pour -r

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

Essayez-le en ligne!

L'exemple [3, 4, 2]prend plus de 60 secondes, donc la liaison TIO utilise [4, 3, 2].

Le -rpeut être supprimé si l'entrée peut être prise dans l'ordre inverse pour un nombre d'octets 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 octets

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

Essayez-le en ligne!

Z80Golf , 36 octets

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

Essayez-le en ligne!

Harnais de test de force brute

Prend l'entrée en octets bruts. Limité à 2 ** 8-1.

Explication

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

Rubis , 24 20 octets

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

Essayez-le en ligne!