도전

구현 테트 레이션 문자의 최소 금액 (일명 파워 타워 또는 Hyperexponentiation을).

조항들

• '전력'운영자 또는 그 등가물 (예를 사용하지 않는 pow(x,y), x^y, x**y등)
• 다음과 같이 입력 : x y(공백으로 구분)
• x자체적으로 y시간 이 지수화됩니다 .
• 귀하의 분석법은 최소한 계산할 수 있어야합니다 4 3(4 스스로 3 회 지수화)

득점

• 최저 점수 당첨 : (문자 수)
• 곱셈 연산자를 사용하지 않는 경우 보너스 공제 (-5 포인트).
• 속도 / 메모리 요구 사항 없음. 당신이 원하는만큼 오래 걸릴.

예

x, 0 -> 1

2, 2 -> 2^2 = 4

2, 4 -> 2^(2^(2^2)) = 65536

4, 3 -> 4^(4^4) = 4^256 = 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096

제안 / 변경 / 질문에 개방

J, 점수는 7 점 (12 자-곱셈을 피하기 위해 5 점)

+/@$/@$~/@$~

용법:

   4 +/@$/@$~/@$~ 3
1.34078e154
t=.+/@$/@$~/@$~  NB. define a function
   4 t 3
1.34078e154
   2 t 2
4

중첩 된 주름이 거의 없습니다.

• 곱셈을 사용하면 */@$~/@$~
• 전원을 사용 하면 배열을 생성하는 ^/@$~위치 $~가 /폴드 기능입니다.

하스켈, 87 85-5 == 80 82

import Data.List
t x=genericLength.(iterate(sequence.map(const$replicate x[]))[[]]!!)

지수화, 곱셈 또는 덧셈 (!)을 사용하지 않고 목록 작업 만 수행합니다. 데모:

Prelude> :m +Data.List
Prelude Data.List> let t x=genericLength.(iterate(sequence.map(const$replicate x[]))[[]]!!)
Prelude Data.List> t 2 2
4
Prelude Data.List> t 2 4
65536
Prelude Data.List> t 4 3

... 음
... 당신은 성능이나 메모리에 대해 아무 말도하지 않았습니까? 그러나 충분한 수십억 년과 몇 페타 바이트의 RAM이 주어지면 여전히 올바른 결과를 얻을 수 있습니다 (genericLength는 목록의 길이를 계산하기 위해 bigInt를 사용할 수 있습니다).

GolfScript, 15 18 자

~])*1\+{[]+*{*}*}*

예, *s 중 하나는 곱셈 연산자 (운동 : 어느 것입니까?)이므로 5 문자 보너스를받을 수 없습니다. 여전히 Peter의 솔루션 보다 조금 짧습니다 .

이 초기 15 문자 버전은 달리 동일하지만 두 번째 인수가 0 일 때 출력을 생성하지 않습니다. 버그를 발견 한 res 덕분입니다.

~])*{[]+*{*}*}*

J, 16 19 12 자

*/@$~/1,~$~/

또는 동사 (17 자)로 :

h=:[:*/@$~/1,~$~/

용법:

   h 2 4
65536

또는 키보드에서 입력 ( 24 27 20 자) :

*/@$~/1,~$~/".1!:1]1

바보 를 지적 해 준 FUZxxl 에게 감사드립니다 . :-)

설명:

J는 오른쪽에서 왼쪽으로 읽으므로 다음을 사용하십시오 2 4.

/$~목록의 각 항목 쌍 사이 에 동사를 삽입하는 데 사용됩니다 . $~왼쪽 항목을 가져 와서 $오른쪽 항목을 사용하여 모양을 지정합니다 ( ~역 인수를 반대로 함)-이것은 4 개의 항목 4 $ 2인 2s 목록을 제공하는 것과 같습니다 2 2 2 2.

이제리스트에 1을 추가 1,~한 다음 같은 일을 다시 수행합니다. 목록의 각 항목 쌍 사이 /에 동사 */@$~를 삽입 하십시오. 이 동사는 같은 방식으로 시작 $~하지만 이번에 는 새로 생성 된 목록의 각 항목 사이 /에을 삽입 *합니다. 은 @단지 확인합니다 그 */@$~하나의 동사 대신에이 같은 작품. 이것에 2만큼 충분한 시간을 곱할 수 있습니다 2^4.

J의 어휘 페이지 -때로는 재미있는 일이 있기 때문에 J 재미 문제를 해결하는 것을 발견했습니다.

*연산자 를 제거하기 위해 반복을 하나 더 추가하면 두 가지 문제가 있습니다.

• +/@$~/,@$~/1,~$~/-5 보너스로도 너무 긴 17 자 ( )로 나옵니다.
• 숫자가 너무 커지면 메모리가 부족하여 계산할 수없는 요구 사항을 충족하지 못합니다 4 3

GolfScript (24 자-5 = 19 점)

~\1{1{0{+}?}?}{@\+@*}:?~

엄청 느립니다.

(또는 20 자)

~\1{1{*}?}{@\+@*}:?~

훨씬 빠릅니다.

파이썬, 70

이것은 중첩 된 eval호출을 사용하여 결국 "a*a*a*a...*a"평가 되는 문자열 을 생성합니다 . 점수의 거의 절반은 인수를 얻는 데 낭비됩니다 ...하지만 다른 몇 가지 솔루션은 그 점을 귀찮게하지 않습니다.

a,b=map(int,raw_input().split())
exec"eval('*'.join('a'*"*b+'1'+'))'*b

스칼라 : 110

type B=BigInt
def r(a:B,b:B,f:(B,B)=>B):B=if(b>1)f(a,r(a,b-1,f))else a
def h(a:B,b:B)=r(a,b,r(_,_,r(_,_,(_+_))))

언 골프 :

type B=BigInt
def recursive (a:B, b:B, f:(B,B)=>B): B = 
  if (b>1) f (a, recursive (a, b-1, f)) 
  else a
recursive (2, 3, recursive (_, _, recursive (_, _, (_ + _))))

설명:

type B=BigInt
def p (a:B, b:B):B = a+b
def m (a:B, b:B):B = if (b>1) p (a, m (a, b-1)) else a
def h (a:B, b:B):B = if (b>1) m (a, h (a, b-1)) else a
def t (a:B, b:B):B = if (b>1) h (a, t (a, b-1)) else a

더하기, mul, high (: = pow), tetration은 모두 같은 방식으로 작동합니다. 공통 패턴은 재귀 적 방법으로 추출 될 수 있으며 두 가지 BigInts와 기본 기능이 필요합니다.

def r (a:B, b:B, f:(B,B)=>B):B = 
  if (b>1) f(a, r(a, b-1, f)) else a
r (4, 3, r (_,_, r(_,_, (_+_))))

밑줄은이 순서에서 호출되는 항목의 자리 표시 자입니다 (예 : 더하기 plus (a, b) = (a + b); 따라서 ( + )는 두 개의 인수를 사용하여 추가하는 함수입니다 (a + b).

불행히도 스택 크기에 문제가 있습니다. 4의 작은 값 (예 : 2) 또는 한 단계의 깊이를 줄이면 작동합니다.

def h(a:B,b:B)=r(a,b,r(_,_,(_*_))) // size -7, penalty + 5
def h(a:B,b:B)=r(a,b,r(_,_,r(_,_,(_+_)))) 

원래 코드는 112 자이며 유효한 경우 점수가 107입니다. 스택을 늘리는 방법을 찾을 수 있습니다.

확장 된 알고리즘은 tailrecursive 호출로 변환 될 수 있습니다.

type B=BigInt
def p(a:B,b:B):B=a+b
import annotation._
@tailrec
def m(a:B,b:B,c:B=0):B=if(b>0)m(a,b-1,p(a,c))else c
@tailrec
def h(a:B,b:B,c:B=1):B=if(b>0)h(a,b-1,m(a,c))else c
@tailrec
def t(a:B,b:B,c:B=1):B=if(b>0)t(a,b-1,h(a,c))else c

tailrecursive 호출은 원래 방법보다 길지만 긴 버전에서는 스택 오버플로를 발생시키지 않았지만 적절한 시간 내에 결과를 얻지 못합니다. t (2,4)는 괜찮지 만 5 분 후에 이미 t (3,3)이 중지되었습니다. 그러나 매우 우아하지 않습니까?

// 124 = 119-5 bonus
type B=BigInt
def r(a:B,b:B,c:B,f:(B,B)=>B):B=if(b>0)r(a,b-1,f(a,c),f)else c
def t(a:B,b:B)=r(a,b,1,r(_,_,1,r(_,_,0,(_+_))))

그리고 이제는 위와 동일합니다 : 냄새 나는 곱셈을 사용하십시오 (우리는 7 개의 문자를 저장하기 때문에 5의 보너스를 거부하면서도 이익을 얻습니다 : win = 4 문자 :)

// 115 without bonus
type B=BigInt
def r(a:B,b:B,c:B,f:(B,B)=>B):B=if(b>0)r(a,b-1,f(a,c),f)else c
def t(a:B,b:B)=r(a,b,1,r(_,_,1,(_*_)))

기도:

timed ("t(4,3)")(t(4,3)) 
t(4,3): 1
scala> t(4,3)
res89: B = 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096

런타임 : 1ms

Br ** nfuck, 128-5 = 123 바이트

+<<+<<,<,[>[>+>>+<<<-]>[<+>-]>[>[>>+>+<<<-]>>>[<<<+>>>-]<<[>[>+>+<<-]>>[<<+>>-]<<<-]>[-]>[<<+>>-]<<<<-]>>[<<+>>-]+<[-]<<<<-]>>>.

입력은 입력으로 원하는 숫자의 코드 포인트가있는 문자 형식입니다. 출력은 동일합니다.

아래 시간이 있으면 설명이옵니다 . 지수, 곱셈 또는 덧셈을 사용하지 않으면 보너스 포인트를받을 수 있습니까?

Cell 3 (0-indexed) is the running total x.
This calculates the nth tetration of a.

+<<+<<,<,                                       Initialize tape with [n, a, 0, 1, 0, 1]
[                                               While n:
  >[>+>>+<<<-]>[<+>-]                             Copy a 3 cells to right: [n, a, 0, x, a, 1]
  >[                                              While x:
    >[>>+>+<<<-]>>>[<<<+>>>-]                       Copy a 2 cells to right: [n, a, 0, x, a, 1, a, 0]
    <<[>[>+>+<<-]>>[<<+>>-]<<<-]                    Cell 7 = prod(cell 5, cell 6)
    >[-]>[<<+>>-]<<<<-]                             Move this value to cell 5. End while.
  >>[<<+>>-]+<[-]<<<<-]                           Update x to result of exponentiation. End while.
>>>.                                            Print the result!

대한 (테스트)이 작품 x 0, 0 x, x 1, 1 x, x 2, 2 3,와 2 4. 나는 시도 3 3했지만 끝내지 않고 몇 시간 동안 (내 자바 구현에서-아마 최적은 아님) 편집했다 (편집 : @Timwi의 EsotericIDE에서 [그것은 훌륭합니다! 모두 시도해야합니다]. 운이 없습니다.) 이론적으로 이것은 특정 구현의 셀 크기까지 작동합니다.

Python, 161-5 (* 연산자 없음) = 156

r=xrange
def m(x,y):
 i=0
 for n in r(y):i+=x
 return i
def e(x,y):
 i=1
 for n in r(1,y+1):i=m(i,x)
 return i
def t(x,y):
 i=1
 for n in r(y):i=e(x,i)
 return i

호출 :

t(2, 4)

펄, 61 자

여기 기괴한 것이있다

sub t
{
  ($x,$y,$z)=@_;
  $y>1&&t($x,$y-1,eval$x."*$x"x($z-1||1))||$z
}

용법:

print t(2,4,1)

매스 매 티카 , 40 33

이것은 규칙을 따르지 않지만 어쨌든 가장 짧은 코드에 대한 논쟁이 아니며 누군가에게 관심이 있기를 바랍니다.

m@f_:=Fold[f,1,#2~Table~{#}]&;

m[m@Sum]

이렇게하면 "tettet"함수가 실행되지만 인수는 역순으로 제공되어야합니다. 예:

m[m@Sum][3, 4]

1340780792994259709957402499820584612747936582059239337772356144372176 4030073546976801874298166903427690031858186486050853753882811946569946 433649006084096

하스켈 :  58  곱셈 유무에 관계없이 51 개의 문자.

i f x 1=x;i f x n=f$i f x$n-1
t=i(\o n->i(o n)n)(+)4

언 골프 드 :

bump op n a = iterate (op n) n !! (fromIntegral $ a-1)
tetrate = iterate bump (+) !! 3

더 짧은 정의는“범프”를 인라인하고“iterate”의 사용자 정의 버전을 정의하는 데 있습니다. 불행히도 결과는 비효율적이지만 (+) 대신 (*)로 시작하면 적절한 속도를 얻을 수 있습니다. 에서 ghci:

Prelude> let i f x 1=x;i f x n=f$i f x$n-1
(0.00 secs, 1564024 bytes)
Prelude> let t=i(\o n->i(o n)n)(*)3
(0.00 secs, 1076200 bytes)
Prelude> t 4 3
13407807929942597099574024998205846127479365820592393377723561443721764030073546
976801874298166903427690031858186486050853753882811946569946433649006084096
(0.01 secs, 1081720 bytes)

루비 66 59 자

def e(x,y)
r=1
(1..y).each{t=x
(2..r).each{t*=x}
r=t}
r
end

파이썬, 112 자

숫자는 첫 번째 및 두 번째 인수 여야합니다. python this.py 4 3
**연산자는 사용되지 않습니다.
*익숙한. 을 정확히 구현하는 것은 쉽지 **않지만 5 자 이상입니다.

import sys
p=lambda y:y and x*p(y-1)or 1
t=lambda y:y>1 and p(t(y-1))or x
x,y=map(long,sys.argv[1:])
print t(y)

C, 117 개 (105) 99 문자

편집 : 두 기능 합병 p및 r일부 문자를 저장, 하나에 있습니다.
99 개의 문자 중 52 개가 실제 계산을 수행합니다 (변수 정의 포함). 다른 47은 입력 및 출력을 처리하기위한 것입니다.
BUG : 0의 거듭 제곱을 잘못 처리합니다 (예 :) 0 2. 최소 비용으로 수정해야합니다. 이것은 버그가 아니며 0 2정의되지 않은 것을 잊었습니다 .

를 성공적으로 처리 4 3하고 정확한 결과를 제공합니다. 그러나 일부 작은 숫자는 정확하지 않을 수 있습니다.
후행으로 숫자를 인쇄합니다 .000000.

x,y,z;
double R(){return--y?!z?y=R(),R(z=1):x*R():x;}
main(){
    scanf("%d%d",&x,&y);
    printf("%f\n",R());
}

인자, 187 자

USING: eval io kernel locals math prettyprint sequences ;
IN: g
:: c ( y x o! -- v )
o 0 = [ x y * ] [ o 1 - o!
y x <repetition> 1 [ o c ] reduce ] if ;
contents eval( -- x y ) swap 2 c .

골프 전 :

USING: eval io kernel locals math prettyprint sequences ;
IN: script

! Calculate by opcode:
!   0 => x * y, multiplication
!   1 => x ^ y, exponentiation
!   2 => x ^^ y, tetration
:: calculate ( y x opcode! -- value )
    opcode 0 = [
        x y *
    ] [
        ! Decrement the opcode. Tetration is repeated exponentiation,
        ! and exponentiation is repeated multiplication.
        opcode 1 - opcode!

        ! Do right-associative reduction. The pattern is
        !   seq reverse 1 [ swap ^ ] reduce
        ! but a repetition equals its own reverse, and 'calculate'
        ! already swaps its inputs.
        y x <repetition> 1 [ opcode calculate ] reduce
    ] if ;

contents eval( -- x y )         ! Read input.
swap 2 calculate .              ! Calculate tetration. Print result.

곱셈 연산자를 제거하지 않았습니다 *. 만약 그렇게한다면, 빈 시퀀스의 합이 1이 아니라 0이라는 것을 나타내는 논리를 추가해야 할 것입니다.이 추가 논리는 -5 보너스보다 더 비쌉니다.

규칙 차단기, 124 + 10 = 134 자

USING: eval kernel math.functions prettyprint sequences ;
contents eval( -- x y ) swap <repetition> 1 [ swap ^ ] reduce .

이 프로그램의 점수는 낮지 만 지수 연산자 ^는 규칙을 위반합니다. 규칙에 "(문자 수) + (10 * (# of 'power'연산자))"가 표시되므로 +10 페널티를 적용했습니다. 그러나 규칙에는 " '파워'연산자를 사용하지 마십시오"라고 표시되어 있으므로 이러한 처벌을받는 모든 프로그램은 규칙을 위반합니다. 따라서이 134 자 프로그램은 정답이 아니므로 더 긴 187 자 프로그램을 답으로 제시해야합니다.

하스켈 110-5 = 105

테아 레이션 피아노 스타일. 이것은 가능한 한 가장 느린 해결책이며 경고 일뿐 아니라 추가조차도 피합니다.

data N=Z|S N
a&+Z=a
a&+S b=S$a&+b
_&*Z=Z
a&*S b=a&+(a&*b)
_&^Z=S Z
a&^S b=a&*(a&^b)
_&>Z=S Z
a&>S b=a&^(a&>b)

이것은 Peano 번호를 입력하는 인내심에 달려 있습니다 (답을 표시하지는 않습니다. 실제로 실행하려면 다음 몇 줄 (90 자)을 추가하십시오.

f 0=Z
f a=S$f$a-1
t Z=0
t(S a)=1+t a
main=interact$show.f.(\[x,y]->x&>y).map(f.read).words

루비, 47 46 45

t=->x,n{r=x;2.upto(n){r=([x]*r).inject :*};r}

루아 : 133 자, 곱셈

a,b=io.read():match"(%d+) (%d+)"a,b,ba=a+0,b+0,a for i=1,b-1 do o=1 for i=1,a do o=o+o for i=1,ba-b do o=o+o end end a=o end print(o)

원래 문자열 반복 해킹을 사용하여 가짜 곱셈을 수행하려고했지만 큰 값에서 실패하는 것을 좋아합니다. 동적 컴파일과 loadstring을 사용하여 더 작게 만들 수는 있지만 여기서 늦어지고 있습니다 ... 잠이 필요합니다.

stdin 출력에 "4 3"입력 :

1.3407807929943e+154

VBA, 90 자

* 아마도 곱셈 보너스가 충분하지 않을 수 있습니다. 나는 곱셈의 대답이 훨씬 흥미롭지 않다고 생각하지만 이것이 코드 골프이기 때문에 최선이 아닙니다. 이없는 답변 *과 더 나은 (짧고 더 나은 점수) 답변이 있습니다.

90 자, 전력 연산자 없음, 곱셈 = 90

Sub c(x,y)
f=IIf(y,x,1):For l=2 To y:b=x:For j=2 To f:b=b*x:Next:f=b:Next:MsgBox f
End Sub

116 자, 전력 연산자 없음, 곱셈 보너스 없음 (-5) = 111

Sub c(x,y)
f=IIf(y,x,1):For l=2 To y:b=x:For j=2 To f:For i=1 To x:a=a+b:Next:b=a:a=0:Next:f=b:Next:MsgBox f
End Sub

참고 : VBA에는 결과가 매우 클 때 (예 :) 숫자를 인쇄하는 데 문제가 4, 3있지만 올바르게 계산되므로 예를 들어 해당 숫자를 사용하려는 경우 이동하는 것이 좋습니다. 또한 BIGGER 숫자도 넘칩니다 (예 :) 3, 4.

펄 6 , 32 바이트

->\a,\b{(1,{[*] a xx$_}...*)[b]}

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

(1, { [*] a xx $_ } ... *)는 전력 타워를 생성하는 게으른 시퀀스이며, 각 요소 는 이전 요소와 동일한 횟수만큼 a복제 된 첫 번째 입력 매개 변수 ( xx)로 구성된 $_목록이며 그 목록은 곱셈 ( [*]) 으로 줄어 듭니다 . 그 순서에서 우리는 단순히 -th b요소 를 뽑아냅니다 .

람다 미적분학, 10-5

( 교회 인코딩 및 De Bruijn indeces 사용 )
λλ(1λ13)λ1

설명

De Bruijn indeces가 없으면 : λa,b.(b λc.ca)λc.c:

λa,b.                                                 define the anonymous function f(a,b)=
     (b                                                apply the following function b times
        λc.                                                    the anonymous function g(c)=
           ca)                 apply c to a because of church encoding this is equal to a^c
              λc.c                              the identity function, 1 in church encoding

exp_a(x)=a^x이 프로그램 을 정의 하면 함수 종료를 나타내는 a↑↑b=exp_a^b(1)위치 를 정의 합니다 ^b.

이것이 실제로 내장되어 있지 않고 정수가 람다 미적분으로 인코딩되는 방식의 부작용 만 ca기술적으로 동일하기 때문에 이것이 허용되는지 확실 a^c하지 않습니다.

자바 스크립트 : 116 자

function t(i){y=i.split(' ');a=y[0];b=y[1];return+b&&p(a,t(a+' '+(b-1)))||1}function p(a,b){return+b&&a*p(a,b-1)||1}

t ( '4 3') 출력 :

1.3407807929942597e+154

파이썬 (111) (113) 아니오 *

r=lambda x,y:(x for _ in range(y));t=lambda x,y:reduce(lambda y,x:reduce(lambda x,y:sum(r(x,y)),r(x,y)),r(x,y),1)

6 *** 3-36k 자리))

Upd : t (X, 0) = 1에 맞게 초기 값을 추가해야합니다.

Haskell : 곱셈이없는 88-5 자, 곱셈이있는 59 자

곱셈없이 :

h x y=foldr(\x y->foldl(\x y->foldl(+)0(replicate x y))1(replicate y x))1(replicate y x)

제가 골프를 조금 할 수있는 방법이있을 것입니다.

곱셈으로 :

h x y=foldr(\x y->foldl(*)1(replicate y x))1(replicate y x)

마지막으로 ungolfed 프로그램은 다음과 같습니다.

mult x y = foldl (+) 0 (replicate x y)
expo x y = foldl (mult) 1 (replicate y x)
h x y = foldr (expo) 1 (replicate y x)

이것은 아마도이 문제를 수행하는 가장 간단한 방법 일 것입니다. 곱셈을 반복 가산으로 반복, 지수를 반복 곱셈으로, 정션을 반복 지수로 정의하는 것입니다.

라켓 58 (* 없음)

(define(t x y)(if(= y 0)1(for/product([i(t x(- y 1))])x)))

일반 리스프, 85 자

(lambda(b c)(let((r b)u)(dotimes(c c r)(setf u 1 r(dotimes(c b u)(setf u(* u r)))))))

반복 덧셈을 통해 곱셈을 시도했지만 5 자 이상이었습니다. 매크로 렛의 경우와 마찬가지로 선언은 가치가 없습니다.

boothby의 python 솔루션에서 영감을 얻은 또 다른 솔루션. 위의 솔루션보다 1 문자가 적습니다.

(lambda(a b)(eval`(*,@(loop for x below b nconc(loop for x below a nconc`(,a,a))))))

파이썬 3 – 68

(파워 오퍼레이터의 10 점 벌금 포함)

a,b=input().split()
r=1
exec("r=%s**r;"%a*int(b))
print(r)

Yabasic , 71 바이트

입력을 취하는 함수 a및 b공간과 같은 문자열을 구분.

Input""a,b
d=a^(b>0)
For i=2To b
c=a
For j=2To d
c=c*a
Next
d=c
Next
?d

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

R , 71-5 = 66 바이트

function(x,y,b=x){for(i in 2:y)b=cumprod(z<-rep(x,b))[sum(z|1)];cat(b)}

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

-5를 피하기 위해 -5, 예상보다 어려웠습니다. 실제로 빠르게 폭발하고 메모리가 부족하지 않으면 작동하지 않지만 필요한 모든 기준을 충족시킵니다.