Для заданого списку числа знайдіть останню цифру x x x … x n 3 2 1 Приклад:$[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   

Тому що .$3 ^ {(4 ^ 2)} = 3 ^ {16} = 43046721$

Тому що .$4 ^ {(3 ^ 2)} = 4 ^ {9} = 262144$

Тому що .$4 ^ {(3 ^ 1)} = 4 ^ {3} = 64$

Тому що .$5 ^ {(3 ^ 2)} = 5 ^ {9} = 1953125$

Правила:

Це кодовий гольф, тому відповідь з найменшими байтами виграє.

Якщо у вашій мові є обмеження на цілий розмір (напр., ) n буде досить малим, щоб сума вмістилася в ціле число.$2^{32}-1$

Введення може бути будь-якою розумною формою (stdin, файл, параметр командного рядка, ціле число, рядок тощо).

Вихід може бути будь-якої розумної форми (stdout, файл, графічний елемент користувача, який відображає число тощо).

Бачив на кодових війнах.

JavaScript (ES7), 22 байти

Обмежено .$2^{53}-1$

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

Спробуйте в Інтернеті!

R , 25 байт

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

Спробуйте в Інтернеті!

Хаскелл, 19 байт

(`mod`10).foldr1(^)

Спробуйте в Інтернеті!

HP 49G RPL, 36,5 байт

Запустіть його в режимі APPROX (але введіть програму в точному режимі). Здійснює введення в стек з першим елементом, найглибшим у стеку, у вигляді цілих чи реальних цифр.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

Він прямо експонується на стек, як у рішенні Софії, поки не залишиться одне значення, а потім приймає mod 10, щоб отримати останню цифру.

Причиною, що я використовую APPROX для обчислення, є те, що 0,0 ^ 0,0 = 1 (коли вони обидва реальні), але 0 ^ 0 =? (коли вони обидва цілих числа). APPROX примушує всі цілі числа до дійсних цифр, тому введення даних добре з будь-яким. Однак я використовую EXACT для вступу в програму, оскільки 10 (ціле число) зберігається з цифр у цифру і становить 6,5 байт, але 10,0 (справжнє) зберігається як повне дійсне число і становить 10,5 байт. Я також уникаю використання скорочення RPL (званого STREAM), оскільки він вводить додатковий об'єкт програми, який становить 10 байт накладних витрат. У мене вже є одне, а іншого не хочу.

Обмежено точністю реального HP 49G (12 десяткових цифр)

-10 байт після порожнього списку -> 1 вимога була видалена.

-2 байти, взявши вхід на стек.

постійного струму , 17 15 байт

1[^z1<M]dsMxzA%

Спробуйте в Інтернеті!

Бере вхід зі стека, виводить у стек. Дуже відверта реалізація - експонується до тих пір, поки на стеку не залишиться лише одне значення та мод для останньої цифри.

Дякуємо brhfl за збереження двох байтів!

J , 5 байт

-3 байти завдяки Коулу!

10|^/

Спробуйте в Інтернеті!

05AB1E , 4 байти

.«mθ

Спробуйте в Інтернеті!

Пояснення

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

Pure Bash (лише вбудовані - без зовнішніх утиліт), 21

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

Введення подано у командному рядку у вигляді списку, розділеного комами.

Цілі числа Bash підлягають нормальним підписаним цілим обмеженням для 64- та 32-розрядних версій.

Спробуйте в Інтернеті!

Мова Вольфрама (Mathematica) , 16 байт

Power@##~Mod~10&

Спробуйте в Інтернеті!

Python 2 і Python 3 , 30 байт

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

Спробуйте в Інтернеті!

Очікується, що вхід Nстане ітерабельним об'єктом над рядковими поданнями літеральних чисел .

Рубі, 41 47 байт

Збільшення розміру за рахунок обробки будь-якого 0 у вхідному масиві, що потребує додаткового врахування. Завдякиrewritten

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

Це вирішується так, як я вважаю, оригінальне джерело призначене, тобто для дуже великих експоненцій, які не впишуться в цілі цілі мови мови - обмеження полягає в тому, що масив підведе підсумки 2**32-1, а не тим, що тимчасові обчислення також гарантовано підходять. Насправді, це, здається, було б суперечливим завданням у боротьбі з кодовами. Хоча вихідні цілі числа Рубі можуть отримати досить великі розміри, вони не впораються із наведеним нижче прикладом, наївно обробленим% 10

Напр

Вхід: [999999,213412499,34532597,4125159,53539,54256439,353259,4314319,5325329,1242149,142219,1243219,14149,1242149,124419,999999999]

Вихід: 9

05AB1E , 8 байт

`.gGm}T%

Спробуйте в Інтернеті!

Perl 6 , 14 байт

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

Спробуйте в Інтернеті!

Використовує мета квадратні дужки скорочення разом із оператором **, модуль 10.

APL (Dyalog Unicode) , 5 байт

10|*⌿

Спробуйте в Інтернеті!

C # (.NET Core) , 84 байти

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

Спробуйте в Інтернеті!

• -7 байт завдяки @raznagul

C (gcc) , 56

• Збережено 4 байти завдяки @JonathanFrech

Застосовується рекурсивна функція, r()викликана з макро f- нормальних обмежень стека.

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

Вхідний дані задаються як нульовий завершений масив int. Це під припущенням, що жоден з x _n не дорівнює нулю.

Спробуйте в Інтернеті!

Джулія 0,6 , 30 байт

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

Спробуйте в Інтернеті!

Це анонна функція
∘ - оператор композиції.
Це кілька байтів

Japt -h , 7 байт

OvUqp)ì

Спробуйте в Інтернеті!

Пояснення:

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 байт

Якщо введення можна приймати у зворотному порядку, то перший символ можна видалити.

Обмежено до 2**53-1.

Ôr!p ì

Спробуй це

Пояснення

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

Желе , 6 байт

U*@/DṪ

Спробуйте в Інтернеті!

Python 2 , 45 43 байт

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

Спробуйте в Інтернеті!

Excel VBA, 60 байт

Анонімна функція негайного вікна VBE, яка приймає дані з діапазону [A1:XFD1]

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

Стакс , 7 байт

üT(Çó╖⌐

Запустіть і налагоджуйте його

Алгоритм, як у моїй відповіді Python

CJam , 14 байт

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

Має працювати на будь-який вхід, оскільки CJam не обмежений 64-бітовими цілими числами

Спробуйте в Інтернеті!

Python 3 , 55 байт

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

Старіші версії

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

Python 3 , 47 байт

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

Спробуйте в Інтернеті!

Мозок-Флак , 161 байт

Включає +1 для -r

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

Спробуйте в Інтернеті!

Приклад [3, 4, 2]займає більше 60 секунд, тому використовується посилання TIO [4, 3, 2].

-rМоже бути вилучений , якщо вхідні дані можуть бути прийняті в зворотному порядку для підрахунку байтів 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
({}((()()()()()){})(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

Парі / GP , 32 байти

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

Спробуйте в Інтернеті!

Z80Golf , 36 байт

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

Спробуйте в Інтернеті!

Випробувальний джгут з грубою силою

Вводиться як вихідні байти. Обмежено 2 ** 8-1.

Пояснення

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

Рубін , 24 20 байт

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

Спробуйте в Інтернеті!