チャレンジ

実装テトレーション文字量が最も少ない（別名パワータワーや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の1つは乗算演算子です（運動：どれですか？）ので、5文字のボーナスの資格はありません。それでも、Peterのソリューションよりもわずかに短いだけです。

この以前の15文字バージョンは同じですが、2番目の引数が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つの項目の長さのsの4 $ 2リストを提供するのと同等です。22 2 2 2

ここで、リストに1を追加してから1,~、同じことを再度実行します。リスト内のアイテムの各ペアの間に/動詞を挿入*/@$~します。この動詞は同じ方法で始まります$~が、今回は新しく生成されたリストの各項目の間に/挿入し*ます。@念ことになり*/@$~1つの動詞の代わりに、2のように動作します。これは2、と同等になるのに十分な回数だけ乗算されます2^4。

Jのボキャブラリーページ-Jの問題を解決するのは、それが時々物事を行う方法が異なるからです。

さらに1つの反復を追加して*演算子を削除すると、2つの問題が発生します

• 17文字（+/@$~/,@$~/1,~$~/）で出てきますが、これは-5ボーナスでも長すぎます
• 数値が大きくなりすぎて計算できないという要件を満たさない場合、メモリが不足します 4 3

GolfScript（24文字-5 = 19ポイント）

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

非常に遅いです。

（または20文字）

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

はるかに高速です。

Python、70

これはネストされたeval呼び出しを使用し、最終的"a*a*a*a...*a"に評価される文字列を生成します。スコアのほぼ半分が引数の取得に無駄になっています...他のいくつかの解決策がそれを気にしないことに気づきましたが。

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

Scala：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

plus、mul、high（：= pow）、tetrationはすべて同じ方法で機能します。共通パターンは、2つの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(_,_, (_+_))))

下線は、このシーケンスで呼び出されるもののプレースホルダーです。たとえば、pluss（a、b）=（a + b）; したがって、（+）は2つの引数を取り、それらを追加する関数です（a + b）。

残念ながら、スタックサイズに問題があります。4（たとえば：2）の小さな値、または1ステップの深さを減らす場合に機能します。

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

末尾再帰呼び出しは元のメソッドよりも長くなりますが、長いバージョンではスタックオーバーフローは発生しませんでしたが、妥当な時間で結果が得られません。t（2,4）は問題ありませんが、t（3,3）は5分後に既に停止されました。しかし、非常にエレガントですよね？

// 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 chars :)

// 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、終了せずに数時間実行しました（私のJava実装では-おそらく最適ではありません）（編集：@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)

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)

Mathematica、40 33

これはルールに完全には準拠していませんが、とにかく最短のコードをめぐって競合しているわけではなく、誰かの興味を引くことを願っています。

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

m[m@Sum]

これにより、実行時に「tetration」関数が構築されますが、引数は逆の順序で指定する必要があります。例：

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

より短い定義は、「バンプ」をインライン化し、「反復」のカスタムバージョンを定義することから得られます。残念ながら、結果は信じられないほど非効率的ですが、（+）の代わりに（*）で開始すると、適切な速度が得られます。で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

Python、112文字

番号は、1番目と2番目の引数である必要があります。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文字

EDIT：二つの機能を合併pしてr一つに、いくつかの文字を保存します。
99文字のうち、52文字が実際の計算を行います（変数定義を含む）。他の47は入力と出力を処理するためのものです。
バグ：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 .

このプログラムのスコアは低く^なりますが、べき乗演算子は規則に違反します。ルールには「（＃of characters）+（10 *（＃of 'power' operator））」と書かれているため、+ 10ペナルティを適用しました。ただし、ルールには「 'power'演算子を使用しないでください」と書かれているため、このペナルティをとるプログラムはルールを破ります。したがって、この134文字のプログラムは正解ではなく、187文字の長いプログラムを回答として提示する必要があります。

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

ルビー、47 46 45

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

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

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。

Perl 6、32バイト

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

オンラインでお試しください！

(1, { [*] a xx $_ } ... *)は、パワータワーを生成するレイジーシーケンスです。各要素は、前の要素（）と同じ回数だけa複製された最初の入力パラメーター（xx）で構成されるリストであり$_、そのリストは乗算（[*]）で縮小されます。そのシーケンスから、b-th要素を単純に抜き取ります。

ラムダ計算、10-5

（教会のエンコーディングと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関数のイタレーションを示す場所を定義します。

これが許可されcaているa^cかどうかはわかりませんが、これは実際には組み込みではなく、ラムダ計算で整数がエンコードされる方法の副作用に過ぎないため、技術的に同等です。

Javascript：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

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

そして最後に、無制限のプログラム：

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

Common Lisp、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))))))

Python 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を回避するため*、これは予想よりも困難でした。それは本当に速く爆発し、（より多くのメモリがない限り）動作しませんが、すべての必要な基準を満たします。