Dla danej listy liczb znajdź ostatnią cyfrę Przykład:$[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   

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

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

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

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

Zasady:

To jest golf golfowy, więc wygrywa odpowiedź z najmniejszą liczbą bajtów.

Jeśli twój język ma ograniczenia wielkości całkowitych (np. $2^{32}-1$ ) n będzie wystarczająco małe, aby suma zmieściła się w liczbie całkowitej.

Dane wejściowe mogą mieć dowolną rozsądną formę (standardowe wejście, plik, parametr wiersza poleceń, liczba całkowita, ciąg itp.).

Dane wyjściowe mogą mieć dowolną rozsądną formę (standardowe wyjście, plik, graficzny element użytkownika, który wyświetla liczbę itp.).

Widziałem wojny wojenne.

JavaScript (ES7), 22 bajty

Ograniczony do .$2^{53}-1$

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

Wypróbuj online!

R , 25 bajtów

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

Wypróbuj online!

Haskell, 19 bajtów

(`mod`10).foldr1(^)

Wypróbuj online!

HP 49G RPL, 36,5 bajtów

Uruchom go w trybie APPROX (ale wejdź do programu w trybie DOKŁADNY). Pobiera dane wejściowe na stosie z pierwszym elementem najgłębiej na stosie, jako liczby całkowite lub rzeczywiste.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

Prosto wykładniczy na stosie, jak w rozwiązaniu Sophii, aż pozostała jedna wartość, a następnie bierze mod 10, aby uzyskać ostatnią cyfrę.

Powodem, dla którego używam APPROX do obliczeń jest to, że 0,0 ^ 0,0 = 1 (gdy oba są rzeczywiste), ale 0 ^ 0 =? (gdy oba są liczbami całkowitymi). APPROX zmusza wszystkie liczby całkowite do wartości rzeczywistych, więc wejście jest w porządku z jednym z nich. Jednak używam EXACT, aby wejść do programu, ponieważ 10 (liczba całkowita) jest przechowywana cyfra po cyfrze i ma 6,5 ​​bajta, ale 10,0 (rzeczywista) jest przechowywana jako pełna liczba rzeczywista i ma 10,5 bajtów. Unikam także używania funkcji RPL zmniejszającej (zwanej STREAM), ponieważ wprowadza ona dodatkowy obiekt programu, który ma 10 bajtów narzutu. Mam już jeden i nie chcę drugiego.

Ograniczona do dokładności rzeczywistego HP 49G (12 cyfr dziesiętnych)

-10 bajtów po pustej liście -> 1 wymaganie zostało usunięte.

-2 bajty, przyjmując dane wejściowe na stosie.

dc , 17 15 bajtów

1[^z1<M]dsMxzA%

Wypróbuj online!

Pobiera dane wejściowe ze stosu, dane wyjściowe do stosu. Bardzo prosta implementacja - potęguje, aż na stosie pozostanie tylko jedna wartość i mod dla ostatniej cyfry.

Dzięki brhfl za oszczędność dwóch bajtów!

J , 5 bajtów

-3 bajty dzięki Cole!

10|^/

Wypróbuj online!

05AB1E , 4 bajty

.«mθ

Wypróbuj online!

Wyjaśnienie

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

Pure Bash (tylko wbudowane - bez zewnętrznych narzędzi), 21

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

Dane wejściowe są podawane w wierszu poleceń jako lista oddzielona przecinkami.

Liczby całkowite Bash podlegają normalnym limitom liczb całkowitych ze znakiem dla wersji 64- i 32-bitowych.

Wypróbuj online!

Wolfram Language (Mathematica) , 16 bajtów

Power@##~Mod~10&

Wypróbuj online!

Python 2 i Python 3 , 30 bajtów

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

Wypróbuj online!

NOczekuje się, że dane wejściowe będą iterowalnymi obiektami nad ciągami znaków reprezentującymi literały liczbowe .

Rubin, 41 47 bajtów

Zwiększenie rozmiaru ze względu na obsługę dowolnych 0 w tablicy wejściowej, co wymaga dodatkowej uwagi. Dziękirewritten

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

Zostało to rozwiązane, jak sądzę, pierwotne zamierzone źródło, tj. Dla bardzo dużych potęgowań, które nie będą pasować do natywnych liczb całkowitych języka - ograniczenie polega na tym, że tablica będzie sumować 2**32-1, a nie że obliczenia przejściowe również są gwarantowane. Wydaje się, że to właśnie stanowi wyzwanie dla Code Wars. Chociaż natywne liczby całkowite Ruby mogą być dość duże, nie mogą sobie poradzić z poniższym przykładem przetworzonym naiwnie za pomocą% 10 na końcu

Na przykład

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

Wynik: 9

05AB1E , 8 bajtów

`.gGm}T%

Wypróbuj online!

Perl 6 , 14 bajtów

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

Wypróbuj online!

Wykorzystuje nawias kwadratowy redukcji z operatorem **, modulo 10.

APL (Dyalog Unicode) , 5 bajtów

10|*⌿

Wypróbuj online!

C # (.NET Core) , 84 bajtów

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

Wypróbuj online!

• -7 bajtów dzięki @raznagul

C (gcc) , 56

• Zaoszczędź 4 bajty dzięki @JonathanFrech

Funkcja rekurencyjna r()wywoływana z makra f- obowiązują normalne limity stosu.

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

Dane wejściowe podane jako tablica int zakończona zerem. Zakłada się, że żaden z x _{n nie} jest równy zero.

Wypróbuj online!

Julia 0.6 , 30 bajtów

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

Wypróbuj online!

Jest to funkcja
anonowa ∘ to operator kompozycji.
Jest to wiele bajtów

Japt -h , 7 bajtów

OvUqp)ì

Wypróbuj online!

Wyjaśnienie:

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 bajtów

Jeśli dane wejściowe można pobrać w odwrotnej kolejności, pierwszy znak można usunąć.

Ograniczony do 2**53-1.

Ôr!p ì

Spróbuj

Wyjaśnienie

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

Galaretka , 6 bajtów

U*@/DṪ

Wypróbuj online!

Python 2 , 45 43 bajtów

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

Wypróbuj online!

Excel VBA, 60 bajtów

Anonimowa funkcja bezpośredniego okna VBE, która pobiera dane wejściowe z zakresu [A1:XFD1]

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

Stax , 7 bajtów

üT(Çó╖⌐

Uruchom i debuguj

Algorytm jak w mojej odpowiedzi w języku Python

CJam , 14 bajtów

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

Powinien działać dla każdego wejścia, ponieważ CJam nie jest ograniczony do 64-bitowych liczb całkowitych

Wypróbuj online!

Python 3 , 55 bajtów

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

starsza wersja

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

Python 3 , 47 bajtów

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

Wypróbuj online!

Brain-Flak , 161 bajtów

Obejmuje +1 dla -r

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

Wypróbuj online!

Przykład [3, 4, 2]trwa dłużej niż 60 sekund, więc wykorzystuje łącze TIO [4, 3, 2].

-rMoże zostać usunięty, jeśli wejściowy może być wykonane w odwrotnej kolejności licząc od 160 bajtów.

# 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 bajty

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

Wypróbuj online!

Z80Golf , 36 bajtów

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

Wypróbuj online!

Uprząż testowa do pomiaru siły brutalnej

Pobiera dane wejściowe jako surowe bajty. Ograniczone do 2 ** 8-1.

Wyjaśnienie

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

Rubin , 24 20 bajtów

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

Wypróbuj online!