주어진 숫자 목록에서 의 마지막 숫자를 찾으십시오 예 :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   

왜냐하면 .$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, file, command line parameter, integer, string 등)이 될 수 있습니다.

출력은 합리적인 형식 (stdout, 파일, 숫자를 표시하는 그래픽 사용자 요소 등) 일 수 있습니다.

코드 전쟁을 보았다.

자바 스크립트 (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 모드에서 실행하십시오 (그러나 EXACT 모드에서는 프로그램을 입력하십시오). 스택에서 가장 깊은 첫 번째 요소를 정수 또는 실수로 스택에 입력합니다.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

하나의 값이 남을 때까지 소피아의 솔루션에서와 같이 스택에서 직접 지수화 한 다음 마지막 숫자를 얻기 위해 mod 10을 취합니다.

내가 계산에 APPROX를 사용하는 이유는 0.0 ^ 0.0 = 1 (둘 다 실수 일 때)이지만 0 ^ 0 =? (둘 다 정수인 경우). APPROX는 모든 정수를 실수로 강제 변환하므로 입력에 문제가 없습니다. 그러나 10 (정수)은 자릿수로 저장되고 6.5 바이트이지만 10.0 (실수)은 전체 실수로 저장되며 10.5 바이트이므로 EXACT를 사용하여 프로그램을 시작합니다. 또한 RPL의 Reduce (STREAM이라고 함)를 사용하지 마십시오. 이는 10 바이트의 오버 헤드 인 추가 프로그램 개체를 도입하기 때문입니다. 나는 이미 하나 있고 다른 것을 원하지 않습니다.

HP 49G 실수 (십진수 12 자리)의 정밀도로 제한

비어있는 목록 후 -10 바이트-> 1 요구 사항이 제거되었습니다.

스택에 입력하여 -2 바이트

dc , 17 15 바이트

1[^z1<M]dsMxzA%

온라인으로 사용해보십시오!

스택에서 입력을 가져 와서 스택으로 출력합니다. 매우 간단한 구현-스택에 하나의 값만 남고 마지막 숫자에 대해 수정 될 때까지 지수화합니다.

2 바이트 절약을위한 brhfl에 감사합니다!

J , 5 바이트

콜 덕분에 -3 바이트!

10|^/

온라인으로 사용해보십시오!

05AB1E , 4 바이트

.«mθ

온라인으로 사용해보십시오!

설명

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

퓨어 배쉬 (내장 전용-외부 유틸리티 없음), 21

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

입력은 명령 행에 쉼표로 구분 된 목록으로 제공됩니다.

배쉬 정수는 64- 비트 및 32- 비트 버전에 대해 정상적인 부호있는 정수 제한을 따릅니다.

온라인으로 사용해보십시오!

Wolfram Language (Mathematica) , 16 바이트

Power@##~Mod~10&

온라인으로 사용해보십시오!

파이썬 2 와 파이썬 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중간 계산도 맞지 않는다는 것이 아니라 배열이 합산되는 것 입니다. 실제로 그것은 코드 전쟁에 대한 도전의 포인트 인 것 같습니다. Ruby의 기본 정수는 꽤 커질 수 있지만 끝에 % 10으로 순진하게 처리 된 아래 예제에 대처할 수 없습니다.

예 :

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

산출: 9

05AB1E , 8 바이트

`.gGm}T%

온라인으로 사용해보십시오!

펄 6 , 14 바이트

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

온라인으로 사용해보십시오!

연산자 **, 모듈로 10과 함께 축소 메타 대괄호를 사용합니다.

APL (Dyalog Unicode) , 5 바이트

10|*⌿

온라인으로 사용해보십시오!

C # (. NET 코어) , 84 바이트

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

온라인으로 사용해보십시오!

• @raznagul 덕분에 -7 바이트

C (gcc) , 56

• @JonathanFrech 덕분에 4 바이트 절약

r()매크로에서 호출 된 재귀 함수 f-일반 스택 제한이 적용됩니다.

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

입력은 0으로 끝나는 int 배열로 제공됩니다. 이것은 x _n 중 어느 것도 0이 아니라는 가정하에 있습니다.

온라인으로 사용해보십시오!

Julia 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Ṫ

온라인으로 사용해보십시오!

파이썬 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)

Stax , 7 바이트

üT(Çó╖⌐

실행 및 디버깅

내 파이썬 답변 과 같은 알고리즘

CJam , 14 바이트

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

CJam은 64 비트 정수로 제한되지 않으므로 모든 입력에 작동해야합니다.

온라인으로 사용해보십시오!

파이썬 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)

파이썬 3 , 47 바이트

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

온라인으로 사용해보십시오!

Brain-Flak , 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
({}((()()()()()){})(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

Pari / 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}

온라인으로 사용해보십시오!