在不使用'^'的情况下实现超指数运算


28

挑战

用最少的字符实现四边形(又名Power Tower或Hyperexponentiation)。

条件

  • 不要使用“功率”操作符或它的等价物(如pow(x,y)x^yx**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

接受建议/改变/问题


4
我认为相当重要的一种更改是将“ *运算符”替换为“乘法运算符”。在GolfScript *中,在某些情况下是乘法,但它也是简单的循环运算符:{block}N*等效于C-style for(i=0;i<N;i++){block}。棘手的情况是字符串/数组乘法('a'3*给出'aaa'),但是鉴于4***3元素数组将溢出RAM ,这不太可能成为问题。
彼得·泰勒

3
还值得为边缘情况添加测试x 0=>1。我原来的解决方案无法处理这种情况。
彼得·泰勒

3
使用乘法的代价太低了。(:=不使用它的奖励)。我提出了一个不使用它的解决方案,必须更换它以避免堆栈溢出,并获得了7个字符的胜利,但损失了5个字符。
用户未知

2
@EngineerToast我在您所链接的高尔夫之前4年发布了这款高尔夫……
MrZander

2
条件和得分有点奇怪。您不允许使用电源操作吗?还是您允许他们使用,但它们却是+10分的奖励?
Simply Beautiful Art

Answers:


16

J,分数为7(12个字符-5分,避免乘法)

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

用法:

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

仅有几个嵌套折痕:

  • 使用乘法将是 */@$~/@$~
  • 使用功率将是^/@$~其中$~创建阵列,/为折叠功能。

做得很好。(pad)
Gareth 2012年

@Gareth谢谢,但这是pad什么意思?抱歉,英语不是我的母语。
解压缩

5
我的讯息太短,因此我需要将其填满。:-)
Gareth

您能否仅通过@$~在连词中再提供一个而获得pentation ?
乔纳

@Jonah您需要/,但可以。您可以根据需要折叠嵌套嵌套功能的次数。
HyperNeutrino

15

哈斯克尔, 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

……
嗯……您什么也没说关于性能或内存,对吗?但是,如果有足够的数十亿年的时间和一些PB的RAM,这仍然会产生正确的结果(genericLength可以使用bigInt来计算列表的长度)。


1
我相信到3012年您会为我找到答案吗?;)
MrZander

6
我需要摩尔定律的帮助,但可能的话。
于2012年

12

GolfScript,15个 18个字符

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

是的,*s中的一个是乘法运算符(练习:哪个?),所以我没有资格获得5个字符的奖金。但是,它仅比Peter的解决方案短一点。

否则,这个早期的15字符版本相同,但是当第二个参数为0时不产生任何输出。感谢res发现该错误。

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

这会产生致命错误,例如使用"2 3" ~])*{[]+*{*}*}*
2012年

@res,它为我产生正确的答案。
彼得·泰勒

@res:假定除了输入外,栈上没有其他内容。如果要像示例中那样提供内联输入,请首先使用;来删除启动时解释器放入堆栈的实际输入字符串。或者只是在前面加上[的代码:既;"2 3" ~])*{[]+*{*}*}*"2 3" [~])*{[]+*{*}*}*工作对我罚款。
Ilmari Karonen 2012年

(+1)谢谢!这些变化为我解决了一个谜。该教程说:“您不必管道输入,但如果不需要,则不会提示输入,而是假定没有输入。” 因此,我一直ruby golfscript.rb my_script.gs在命令行上使用它,而在脚本运行之前,它不知道会导致某些东西(显然是“”)在堆栈上-有时会起作用,有时却不会。(此外,使用echo 2 3 | ruby golfscript.rb my_script.gs,您的程序确实可以正常运行。)
2012年


10

J,16 19 12个字符

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

或作为动词(17个字符):

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

用法:

   h 2 4
65536

或从键盘输入(24 27 20个字符):

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

感谢FUZxxl指出我的愚蠢。:-)

说明:

从右到左读取J,因此使用2 4

/用于将动词插入$~列表中的每对项目之间。$~接受左边的项目并$使用右边的项目对它进行成形(~将参数反转)-因此,这等效于4 $ 2为您提供2s 的列表,该列表的长度为4 2 2 2 2

现在我们将1附加到列表中1,~,然后再次执行相同的操作;在列表中的每对项目之间/插入动词*/@$~。这个动词以相同的方式开头,$~但是这次它在新生成的列表的每个项目之间/插入一个*。在@刚刚可以确保*/@$~工程作为一个动词,而不是两个。这2本身乘以足够的时间等于2^4

J的词汇页 -我发现用J有趣的方式解决问题只是因为它有时做事的方式不同。

再增加一次迭代以删除*运算符有2个问题

  • 它以17个字符(+/@$~/,@$~/1,~$~/)开头,即使有-5奖金也太长了
  • 如果数量太大,它将耗尽内存,因此不符合能够计算的要求 4 3

您能提供一个解释吗?这看起来很有趣。
MrZander

@MrZander我已经编辑了答案以添加说明。
Gareth 2012年

不知道我是否有更好的理解或更多的困惑,但是谢谢哈哈。
MrZander

这种解释意味着整个过程正在做幂运算而不是四次运算。我们中哪一个缺少什么?
彼得·泰勒

@PeterTaylor我怀疑我的解释不是很清楚。如果正在执行四次运算,我将使用^/]$[它创建列表2 2 2 2,并将指数运算符粘贴在它们之间。这正在做的又一步,并通过重复乘法进行求幂。
Gareth 2012年

8

GolfScript(24个字符-5 = 19分)

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

疯狂地慢。

(或20个字符)

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

快得多。


2
由于GolfScript是Ruby程序,因此我们可以在ideone :) ideone.com/GTIfP上进行测试。我也给ideone发了电子邮件,建议他们增加对GolfScript的支持。
mellamokb

@mellamokb,如果他们确实添加它会很好,但是我不太乐观,因为他们声明的策略是添加发行版支持的语言。
彼得·泰勒

我也读过...但是因为它们支持Ruby,并且GolfScript只是一个Ruby程序,所以应该很容易:)只需创建一个传递参数的bash脚本即可。
mellamokb '04 -4-19


6

Python,70岁

这将使用嵌套eval调用,最终生成一个要"a*a*a*a...*a"评估的字符串。几乎一半的分数都浪费在了争吵上……尽管我注意到其他一些解决方案对此也没有影响。

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

如果我们假设参数以逗号分隔,则可以使用input()或使用eval(raw_input())Cheers
st0le 2012年

1
@ st0le,请阅读问题
12

好东西。第二线可以打更多的exec"eval('a*'*"*b+'1'+"+'1')"*b
高尔夫球

@flornquake好收获!谢谢!
2013年

4

斯卡拉: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),四边形都以相同的方式工作。可以将公共模式提取为递归方法,该方法需要两个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。也许我知道如何增加堆栈。

扩展的算法可以转换为尾递归调用:

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调用的时间比原始方法长,但在长版本中并未引发stackoverflow-但是,它在合理的时间内没有产生结果。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,(_+_))))

现在与上面相同:使用臭味乘法(我们甚至在拒绝5的红利的同时获利,因为我们节省了7个字符: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。


4

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 00 xx 11 xx 22 3,和2 4。我尝试了一下3 3,但是它运行了好几个小时却没有完成(在我的Java实现中,可能不是最佳选择)(编辑:在@Timwi的EsotericIDE中 [太好了!大家都应该尝试一下。)没有运气。)从理论上讲,这取决于特定实现的像元大小。


1
“ Br ** nfuck”是的“大脑”是一个非常令人反感的单词xD。抱歉,我需要
FireCubez

3

Python,161.5-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)

1
迭代加法的乘积真的足够快地求值4***3吗?!
彼得·泰勒

2
@PeterTaylor是吗?对我来说,它完成的时间不到一秒钟
Blazer

哇。等效的GolfScript版本需要aaaaaaaages。
彼得·泰勒

就像这样,我已经让它运行了一整夜,但它仍然没有完成。
彼得·泰勒

1
六年后,您还可以通过将m功能替换为m=lambda x,y:sum(x for _ in r(y))
Jack Brounstein,

3

Perl,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)

4
不正确的一个太
ardnew

3

Mathematica40岁 33

这并不完全符合规则,但无论如何都不能争夺最短的代码,我希望它对某人感兴趣。

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

m[m@Sum]

在运行时,这将构建一个“ fourtion”函数,但必须以相反的顺序给出参数。例:

m[m@Sum][3, 4]

1340780792994259709957402499820584612747936582059239337772356144372176 4030073546976801874298166903427690031858186486050853753882811946569946 433649006084096


您能解释一下代码吗?还是在符号而不是数字上显示结果?我注意到这Fold[g, 1, #2~Table~{#}] &[3, 4]会产生g[g[g[1, 4], 4], 4]例如。
DavidC,2012年

@David m[Times]产生Fold[Times, 1, Table[#2, {#1}]] &,这是一个幂函数: m[Times][5, x]---> x^5; 此新幂函数使用相同的方法来产生四方函数。逻辑上可以从此开始,Plus但几乎立即失败。
威兹德先生2012年

要消除Times,请尝试以下操作:t[h_, n_] := Sum[h, {i, n}]。然后运行m[m@t][3, 4]
DavidC 2012年

@David,是的,这应该起作用,但不适用于Code-Golf。Sum[h, n];
威兹德先生2012年

查看评分规则。通过不使用Times,您可以节省9点。总成绩仍不比您高,但越来越接近。
DavidC 2012年

3

Haskell:  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)


2

Python,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)

如何使用代码计算4 3?而且,出于好奇:您是否尝试过以这种方式实施*,然后计算4 3?
用户未知

@userunknown,通过参数输入。我在答案中添加了解释。我没有尝试添加*实现,我相信递归深度对于来说太大4 3
ugoren

2

C,117 105 99个字符

编辑:合并了两个功能pr为一体,节省一些字符。
在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());
}

对我来说看起来像118个字符:ideone.com/9D5SU
mellamokb

用4 3进行测试只能精确到18个位置,而double的精度几乎不足以支持精确的表示。
Sir_Lagsalot

@ Sir_Lagsalot,double的精度足以满足4 ^ 256的要求。它只有一位有效数字。
ugoren

很好,我不是在想二进制。它实际上为您打印出确切的值吗?它在我的机器上的前18个十进制数字后会被截断,但是我愿意接受特定于系统的信息。
Sir_Lagsalot

@Sir_Lagsalot:请参阅我提供的ideone链接。它打印出整个数字。
mellamokb '04

2

因子,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.

我没有删除乘法运算符*。如果这样做了,那么我将需要添加一些逻辑,以表示空序列的总和为0,而不是1。这种额外的逻辑要比-5加分花费更多。


规则破坏者124 + 10 = 134个字符

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

该程序的分数较低,但是求幂运算符^违反了规则。规则说“(字符数)+(10 *('power'运算符的数量))”,因此我应用了+10罚分。但是,规则还说“不要使用'power'运算符”,因此任何受到这种惩罚的程序都会违反规则。因此,这个134个字符的程序不是正确的答案,我必须出示更长的187个字符的程序作为答案。


2

Haskell 110-5 = 105

Tetration Peano风格。这是可能的最疯狂的缓慢解决方案,仅是警告,而且避免甚至添加。

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

2

红宝石,47 46 45

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


2

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

2

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

注意:当结果很大(例如4, 3)时,VBA会出现打印数字的问题,但是它可以正确计算,因此,例如,如果您要使用该数字,那将是很好的选择。同样,甚至更大的数字也会溢出(例如3, 4)。


2

Perl 6,32个字节

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

在线尝试!

(1, { [*] a xx $_ } ... *)是一个生成功率塔的惰性序列,每个元素都是一个列表,该列表由a复制的第一个输入参数(xx)等于前一个元素($_)的次数组成,然后将该列表乘以乘法([*])。从该序列中,我们仅选择了b-th元素。


2

λ演算,10-5

(使用Church编码De Bruijn indeces
λλ(1λ13)λ1

说明

没有De Bruijn表示λ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表示功能触发。

I'm not sure if this is allowed because ca is technically equivalent to a^c how ever it is not a real built-in and only a side effect of the way integers are encoded in lambda calculus.


Hm, is there an interpreter so that I can try this? If there's no implementation of a language, then you can't use it to solve challenges here. Languages are based on their implementations here.
Erik the Outgolfer

1

Javascript: 116 chars

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') Outputs:

1.3407807929942597e+154

1

Python (111) (113) no *

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 digits))

Upd: Have to add initial value, to fit t(X,0)=1


Impressive, how long did the 36k take?
MrZander

1
9.375 seconds including print.
Ev_genus

1

Haskell: 88-5 chars without multiplication, 59 chars with multiplication

Without multiplication:

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

There are probably ways that I could golf that down a little.

With multiplication:

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

And finally, the ungolfed program:

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)

This is probably the simplest way to do this problem, which is defining multiplication as repeated addition, exponentiation as repeated multiplication, and tetration as repeated exponentiation.


1

Racket 58 (no *)

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

for/product is walking a fine line on the "no multiplication" rule, haha.
MrZander

1

Common Lisp, 85 chars

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

I tried doing the multiplications through repeated addition, but it was way more than 5 characters. Same thing with macrolets, the declarations were not worth the gains.

Another solution, inspired by boothby's python solution. It's 1 character less than the above solution.

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

1

Python 3 – 68

(including the 10-point penalty for the power operator)

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


1

R, 71 - 5 = 66 bytes

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

Try it online!

-5 for avoiding *, which was harder than I expected. It explodes really fast and won't work (unless it had more memory) but it satisfies all necessary criteria.

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.