表示为的滴定a^^b重复进行幂运算。例如，2^^3is 2^2^2，即16。

给定两个数字a和b，请打印a^^b。

测试用例

1 2 -> 1
2 2 -> 4
5 2 -> 3125
3 3 -> 7625597484987
etc.

^{科学记数法是可以接受的。}

请记住，这是code-golf，所以字节数最少的代码将获胜。

Dyalog APL，3个字节

*/⍴

TryAPL。

说明

*/⍴  Input: b (LHS), a (RHS)
  ⍴  Create b copies of a
*/   Reduce from right-to-left using exponentation

J，5 4个字节

^/@#

从字面上看，这是四级键的定义。

用法

   f =: ^/@#
   3 f 2
16
   2 f 1
1
   2 f 2
4
   2 f 5
3125
   4 f 2
65536

说明

^/@#  Input: b (LHS), a (RHS)
   #  Make b copies of a
^/@   Reduce from right-to-left using exponentation

Haskell，19个字节

a%b=iterate(a^)1!!b

从开始迭代取幂1以生成列表[1,a,a^a,a^a^a,...]，然后采用b'th元素。

直接相同长度：

a%0=1;a%b=a^a%(b-1)

免积分时间更长：

(!!).(`iterate`1).(^)

Mathematica，16个字节

Power@@Table@##&

说明

Table@##

制作a的b份。

Power@@...

求幂。

Python，30个字节

f=lambda a,b:b<1or a**f(a,b-1)

使用递归定义。

Python，33个字节

lambda a,b:eval('**'.join([a]*b))

这将得出一个未命名的函数，该函数采用数字和数字的字符串表示形式。例如：

>>> f=lambda a,b:eval('**'.join([a]*b))
>>> f('5',2)
3125
>>>

如果混合这样的输入格式不算在内，则还有以下38字节版本：

lambda a,b:eval('**'.join([str(a)]*b))

果冻，4 字节

x*@/

在线尝试！或验证所有测试用例。

怎么运行的

x*@/  Main link. Arguments: a, b

x     Repeat [a] b times.
 *@/  Reduce the resulting array by exponentation with swapped arguments.

Perl，19个字节

包括+1的 -p

在STDIN的不同行上给数字

tetration.pl
2
3
^D

tetration.pl

#!/usr/bin/perl -p
$_=eval"$_**"x<>.1

R，39个字节

递归函数：

f=function(a,b)ifelse(b>0,a^f(a,b-1),1)

元素，11个字节

__2:':1[^]`

在线尝试！

这只是一个循环中的“直接”取幂。

__2:':1[^]`
__              take two values as input (x and y)
  2:'           duplicate y and send one copy to the control stack
     :          make y copies of x
      1         push 1 as the initial value
       [ ]      loop y times
        ^       exponentiate
          `     print result

JavaScript（ES7），24个字节

f=(a,b)=>b?a**f(a,b-1):1

ES6版本为33个字节：

f=(a,b)=>b?Math.pow(a,f(a,b-1)):1

dc，35 29字节：

?dsdsa?[ldla^sa1-d1<b]dsbxlap

这是我在中完成的第一个完整程序dc。

Perl，40个字节

map{$a=$ARGV[0]**$a}0..$ARGV[1];print$a;

接受两个整数作为函数的输入并输出结果

实际上，6个字节

n`ⁿ)`Y

在线尝试！

输入取为b\na（\n是换行符）

说明：

n`ⁿ)`Y
n       a copies of b
 `ⁿ)`Y  while stack changes between each call (fixed-point combinator):
  ⁿ       pow
   )      move top of stack to bottom (for right-associativity)

CJam，9个字节

q~)*{\#}*

在线尝试！

说明

q~          e# Take input (array) and evaluate
  )         e# Pull off last element
   *        e# Array with the first element repeated as many times as the second
    {  }*   e# Reduce array by this function
     \#     e# Swap, power

PHP，51字节

for($b=$p=$argv[1];++$i<$argv[2];)$p=$b**$p;echo$p;

GameMaker语言，52 50字节

d=a=argument0;for(c=1;c<b;c++)d=power(a,d)return d

Pyth，6个字节

u^QGE1

在线尝试。

说明

          (implicit: input a to Q)
     1    Start from 1.
u   E     b times,
 ^GQ      raise the previous number to power a.

Minkolang 0.15，12 11个字节

nnDI1-[;]N.

在这里尝试！

说明

nn             Read two integers from input
  D            Pop top of stack and duplicate next element that many times
   I1-         Push length of stack, minus 1
      [        Pop top of stack and repeat for loop that many times
       ;       Pop b, a and push a^b
        ]      Close for loop
         N.    Output as number and stop.

拍子51字节

(define ans 1)(for((i b))(set! ans(expt a ans)))ans

取消高尔夫：

(define (f a b)
  (define ans 1)
  (for((i b))
    (set! ans
          (expt a ans)))
  ans)

测试：

(f 1 2)
(f 2 2)
(f 5 2)
(f 3 3)

输出：

1
4
3125
7625597484987

Scala，45个字节

Seq.fill(_:Int)(_:Double)reduceRight math.pow

取消高尔夫：

(a:Int,b:Double)=>Seq.fill(a)(b).reduceRight(math.pow)

a用b元素构建一个序列，然后math.pow从右到左应用。

TI基本（19字节）

Prompt A,B
A
For(C,2,B
A^Ans
End

Java 7，71 57字节

double c(int a,int b){return b>0?Math.pow(a,c(a,b-1)):1;}

取消测试代码：

在这里尝试。

class M{
  static double c(int a, int b){
    return b > 0
            ? Math.pow(a, c(a, b-1))
            :1;
  }

  public static void main(String[] a){
    System.out.println(c(1, 2));
    System.out.println(c(2, 2));
    System.out.println(c(5, 2));
    System.out.println(c(3, 3));
  }
}

输出：

1.0
4.0
3125.0
7.625597484987E12

C，50个字节

double t(int x,int n){return n?pow(x,t(x,n-1)):1;}

从Tetration的定义出发。

05AB1E，4个字节

sF¹m

在线尝试！

s     # Swap input arguments.
 F    # N times...
  ¹m  # Top of the stack ^ the first argument.

如果可以交换参数，则为3个字节：

F¹m

Bash，50个字节

（在bash整数数据类型的范围内）

打高尔夫球

E() { echo $(($(printf "$1**%.0s" `seq 1 $2`)1));}

说明

用printf构建表达式，例如E 2 5：

  2**2**2**2**2**1

然后使用bash内置的算术扩展来计算结果

测试

E 1 2
1

E 2 2
4

E 5 2
3125

E 3 3
7625597484987

Powershell，68字节

filter p ($a){[math]::Pow($a,$_)};iex (,$args[0]*$args[1]-join"|p ")

这是我尝试过的三种方法中最短的一种，但是总体上来说并不是那么好。我100％确信有一种更短的方法，但是我尝试过的几件事最终以稍微多一些的字节结尾。

PS C:\++\golf> (1,2),(2,2),(5,2),(3,3) | % {.\sqsq $_[0] $_[1]}
1
4
3125
7625597484987

遗憾的是，Powershell没有内置^或**运算符，否则它将是一个干净的32/33字节答案，即

iex (,$args[0]*$args[1]-join"^")

公理70字节

l(a,b)==(local i;i:=1;r:=a;repeat(if i>=b then break;r:=a^r;i:=i+1);r)

少打高尔夫球

l(a,b)==
  local i
  i:=1;r:=a;repeat(if i>=b then break;r:=a^r;i:=i+1)
  r


(3) ->  [l(1,2),l(2,2),l(5,2),l(3,3),l(4,3)]

     (3)
     [1, 4, 3125, 7625597484987,
      13407807929942597099574024998205846127479365820592393377723561443721764030_
       0735469768018742981669034276900318581864860508537538828119465699464336490_
       06084096
       ]
                                                   Type: List PositiveInteger

不可思议，21个字节

f\@@[#0?^#1f#1-#0 1?1

使用递归方法。用法：

f\@@[#0?^#1f#1-#0 1?1];f 2 3

奖励解决方案，22字节

@@:^ -#0 1(genc ^#1)#1

一种稍微非常规的方法。用法：

t\@@+>#[^;#1]tk -#0 1rpt#1;t 2 3

更具可读性：

@@
  iget
    - #0 1
    (genc ^#1) #1

假设 a^^b：

生成无限个四分之一列表a；因为a=2，这个清单看起来像[2 4 16 65536...]。然后在索引，b-1因为Wonder是零索引的。

Clojure，56个字节

(fn[a b](last(take a(iterate #(apply *(repeat % b))b))))

也许有更短的途径apply comp吗？