Last digit large number

Question

For a given list of number \$[x_1, x_2, x_3, ..., x_n]\$ find the last digit of \$x_1 ^{x_2 ^ {x_3 ^ {\dots ^ {x_n}}}}\$ Example:

[3, 4, 2] == 1
[4, 3, 2] == 4
[4, 3, 1] == 4
[5, 3, 2] == 5   

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

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

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

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

Rules:

This is code golf, so the answer with the fewest bytes wins.

If your language has limits on integer size (ex. \$2^{32}-1\$) n will be small enough that the sum will fit in the integer.

Input can be any reasonable form (stdin, file, command line parameter, integer, string, etc).

Output can be any reasonable form (stdout, file, graphical user element that displays the number, etc).

Saw on code wars.

Answer 1

JavaScript (ES7), 22 bytes

Limited to \$2^{53}-1\$.

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

Try it online!

Answer 2

R, 25 bytes

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

Try it online!

Answer 3

Haskell, 19 bytes

(`mod`10).foldr1(^)

Try it online!

Answer 4

HP 49G RPL, 36.5 bytes

Run it in APPROX mode (but enter the program in EXACT mode). Takes input on the stack with the first element deepest in the stack, as integers or reals.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

It straightforwardly exponentiates on the stack as in Sophia's solution until there is one value left, then takes it mod 10 to get the last digit.

The reason I use APPROX for computation is because 0.0^0.0 = 1 (when they are both reals), but 0^0 = ? (when they are both integers). APPROX coerces all integers to reals, so the input is fine with either. However, I use EXACT to enter the program because 10 (integer) is stored digit-by-digit, and is 6.5 bytes, but 10.0 (real) is stored as a full real number, and is 10.5 bytes. I also avoid using RPL's reduce (called STREAM) because it introduces an extra program object, which is 10 bytes of overhead. I already have one and don't want another.

Limited to the precision of an HP 49G real (12 decimal digits)

-10 bytes after empty list -> 1 requirement was removed.

-2 bytes by taking input on stack.

Answer 5

dc, 17 15 bytes

1[^z1<M]dsMxzA%

Try it online!

Takes input from the stack, outputs to the stack. Very straightforward implementation - exponentiates until only one value is left on the stack and mod for the last digit.

Thanks to brhfl for saving two bytes!

Answer 6

J, 5 bytes

-3 bytes thanks to cole!

10|^/

Try it online!

Answer 7

05AB1E, 4 bytes

.«mθ

Try it online!

Explanation

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

Answer 8

Pure Bash (builtins only - no external utilities), 21

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

Input is given on the command line as a comma-separated list.

Bash integers are subject to normal signed integer limits for 64- and 32-bit versions.

Try it online!

Answer 9

Wolfram Language (Mathematica), 16 bytes

Power@##~Mod~10&

Try it online!

Answer 10

Perl 6, 14 bytes

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

Try it online!

Uses the reduction meta square brackets with the operator **, modulo 10.

Answer 11

Python 2 and Python 3, 30 bytes

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

Try it online!

The input N is expected to be an iterable object over string representations of number literals.

Answer 12

Julia 0.6, 30 bytes

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

Try it online!

This is an anon function
∘ is the composition operator.
It is multiple bytes

Answer 13

Ruby, 41 47 bytes

Size increase due to handling of any 0 in the input array, which needs extra consideration. Thanks to rewritten

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

This is solved as I believe the original source intended, i.e. for very large exponentiations that will not fit into language native integers - the restriction is that the array will sum into 2**32-1, not that the interim calculations are also guaranteed to fit. In fact that would seem to be the point of the challenge on Code Wars. Although Ruby's native integers can get pretty big, they cannot cope with the example below processed naively with a %10 at the end

E.g.

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

Output: 9

Answer 14

05AB1E, 8 bytes

`.gGm}T%

Try it online!

Answer 15

APL (Dyalog Unicode), 5 bytes

10|*⌿

Try it online!

Answer 16

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

Try it online!

• -7 bytes thanks to @raznagul

Answer 17

C (gcc), 56

• Saved 4 bytes thanks to @JonathanFrech

Recursive function r() called from macro f - normal stack limits apply.

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

Input given as a zero-terminated int array. This is under the assumption that none of the x_n are zero.

Try it online!

Answer 18

PHP, 50 44 bytes

-6 bytes from @Shaggy

<?=eval("return ".join('**',$argv).";")%10?>

Try it online!

Answer 19

Japt -h, 7 bytes

OvUqp)ì

Try it online!

Explanation:

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

Answer 20

Japt -h, 7 6 bytes

If input can be taken in reverse order then the first character can be removed.

Limited to 2**53-1.

Ôr!p ì

Try it

---

Explanation

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

Answer 21

Jelly, 6 bytes

U*@/DṪ

Try it online!

Answer 22

Python 2, 45 43 bytes

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

Try it online!

Answer 23

Excel VBA, 60 bytes

An anonymous VBE immediate window function that takes input from range [A1:XFD1]

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

Answer 24

Stax, 7 bytes

üT(Çó╖⌐

Run and debug it

Algorithm like in my Python answer

Answer 25

CJam, 14 bytes

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

Should work for any input, since CJam isn't limited to 64 bit integers

Try it online!

Answer 26

Python 3, 55 bytes

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

Older versions

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

Answer 27

Python 3, 47 bytes

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

Try it online!

Answer 28

Brain-Flak, 161 bytes

Includes +1 for -r

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

Try it online!

The example [3, 4, 2] takes longer than 60 seconds, so the TIO link uses [4, 3, 2].

The -r can be removed if input can be taken in reverse order for a byte count of 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
({}((()()()()()){})(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

Answer 29

Pari/GP, 32 bytes

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

Try it online!

Answer 30

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

Try it online!

Brute-force test harness

Takes input as raw bytes. Limited to 2**8-1.

Explanation

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