Các thách thức

Thực hiện tetration (còn gọi là Power Tower hoặc Hyperexponentiation) với số lượng ký tự ít nhất.

Điều kiện

• Không sử dụng 'sức mạnh' nhà điều hành hoặc tương đương của nó (ví dụ như pow(x,y), x^y, x**y, vv)
• Đầu vào được cho là: x y(cách nhau bởi khoảng trắng)
• xđược lũy thừa theo ythời gian của chính nó .
• Phương pháp của bạn phải có khả năng tính toán ít nhất 4 3(4 cấp số nhân 3 lần)

Chấm điểm

• Điểm số thấp nhất sẽ thắng: (# ký tự)
• Khấu trừ tiền thưởng nếu bạn không sử dụng toán tử nhân (-5 điểm).
• Không yêu cầu tốc độ / bộ nhớ. Mất bao lâu bạn muốn.

Ví dụ

x, 0 -> 1

2, 2 -> 2^2 = 4

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

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

Mở để đề xuất / thay đổi / câu hỏi

J, điểm là 7 (12 ký tự - 5 điểm để tránh nhân)

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

sử dụng:

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

Chỉ vài nếp gấp lồng nhau:

• Sử dụng phép nhân nó sẽ là */@$~/@$~
• Sử dụng năng lượng nó sẽ là ^/@$~nơi $~tạo ra mảng, /là một hàm gấp.

Haskell, 87 85 - 5 == 80 82

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

Không sử dụng lũy ​​thừa, nhân hoặc cộng (!), Chỉ liệt kê các thao tác. Trình diễn:

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

...
ahm ... bạn đã không nói gì về hiệu suất hoặc bộ nhớ, phải không? Nhưng được cung cấp đủ hàng tỷ năm và một số petabyte RAM, điều này vẫn mang lại kết quả chính xác (genericLpm có thể sử dụng bigInt để đếm độ dài của danh sách).

GolfScript, 15 18 ký tự

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

Có, một trong số *đó là toán tử nhân (bài tập: cái nào?) Vì vậy tôi không đủ điều kiện nhận phần thưởng 5 char. Tuy nhiên, nó chỉ ngắn hơn giải pháp của Peter .

Phiên bản 15-char trước đó là như nhau, nhưng không tạo ra kết quả khi đối số thứ hai là 0. Nhờ res để phát hiện lỗi.

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

J, 16 19 12 ký tự

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

hoặc như một động từ (17 ký tự):

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

sử dụng:

   h 2 4
65536

hoặc lấy đầu vào từ bàn phím ( 24 27 20 ký tự):

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

cảm ơn FUZxxl vì đã chỉ ra sự ngu ngốc của tôi. :-)

Giải trình:

J được đọc từ phải sang trái, vì vậy sử dụng 2 4:

/được sử dụng để chèn động từ $~giữa mỗi cặp mục trong danh sách. $~lấy mục bên trái và định hình nó $bằng cách sử dụng mục bên phải ( ~đảo ngược các đối số) - vì vậy điều này sẽ tương đương với việc 4 $ 2cung cấp cho bạn một danh sách gồm 2bốn mục dài 2 2 2 2.

Bây giờ chúng tôi nối 1 vào danh sách 1,~và sau đó làm lại điều tương tự; /chèn một động từ */@$~giữa mỗi cặp mục trong danh sách. Động từ này bắt đầu theo cùng một cách $~nhưng lần này nó /chèn một *giữa mỗi mục của danh sách mới được tạo. Chỉ @cần chắc chắn rằng các */@$~hoạt động như một động từ thay vì hai. Điều này cho 2phép nhân với số lần đủ để tương đương với 2^4.

Trang từ vựng của J - Tôi thấy việc giải quyết các vấn đề với J vui chỉ vì cách khác nhau đôi khi nó làm mọi việc.

Thêm một lần lặp nữa để loại bỏ *toán tử có 2 vấn đề

• Nó xuất hiện ở 17 ký tự ( +/@$~/,@$~/1,~$~/), ngay cả với phần thưởng -5, quá dài
• Nó hết bộ nhớ nếu số quá lớn nên không đáp ứng yêu cầu có thể tính toán 4 3

GolfScript (24 ký tự - 5 = 19 điểm)

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

là cực kỳ chậm.

(hoặc 20 ký tự)

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

nhanh hơn nhiều

Con trăn, 70

Điều này sử dụng các evalcuộc gọi lồng nhau , cuối cùng tạo ra một chuỗi "a*a*a*a...*a"được đánh giá. Gần một nửa số điểm bị lãng phí khi nhận được các cuộc tranh luận ... mặc dù tôi đã nhận thấy rằng một vài giải pháp khác không bận tâm với điều đó.

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(_,_,(_+_))))

vô dụng:

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 (_, _, (_ + _))))

giải trình:

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

cộng, mul, cao (: = pow), tetination đều hoạt động theo cùng một cách. Mẫu chung có thể được trích xuất dưới dạng phương thức đệ quy, có hai hàm BigInt và một hàm cơ bản:

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(_,_, (_+_))))

Phần gạch chân là giữ chỗ cho một cái gì đó được gọi trong chuỗi này, ví dụ: phép cộng cộng (a, b) = (a + b); do đó ( + ) là một hàm có hai đối số và thêm chúng (a + b).

Thật không may, tôi gặp vấn đề với kích thước ngăn xếp. Nó hoạt động cho các giá trị nhỏ cho 4 (ví dụ: 2) hoặc nếu tôi giảm độ sâu cho một bước:

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(_,_,(_+_)))) 

Mã ban đầu là 112 ký tự và sẽ ghi điểm, nếu hợp lệ, 107. Có lẽ tôi tìm ra cách tăng ngăn xếp.

Thuật toán mở rộng có thể được chuyển đổi thành các cuộc gọi thích hợp:

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

Cuộc gọi thích hợp dài hơn phương thức ban đầu, nhưng không tăng luồng stackover trong phiên bản dài - tuy nhiên nó không mang lại kết quả trong thời gian hợp lý. t (2,4) vẫn ổn, nhưng t (3,3) đã bị tôi dừng lại sau 5 phút. Tuy nhiên, nó rất thanh lịch, phải không?

// 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,(_+_))))

Và bây giờ cũng giống như trên: sử dụng phép nhân hôi thối (chúng tôi thậm chí có lãi trong khi từ chối phần thưởng là 5, vì chúng tôi lưu được 7 ký tự: win = 4 ký tự :)

// 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,(_*_)))

cầu nguyện:

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

thời gian chạy: 1ms.

Br ** nfuck, 128-5 = 123 byte

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

Đầu vào ở dạng ký tự với các điểm mã của các số mong muốn làm đầu vào. Đầu ra là như nhau.

Một lời giải thích đang đến khi tôi có thời gian dưới đây. Tôi có nhận được điểm thưởng khi không sử dụng lũy ​​thừa, nhân, HOẶC thậm chí không?

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!

Công trình này (thử nghiệm) cho x 0, 0 x, x 1, 1 x, x 2, 2 3, và 2 4. Tôi đã thử 3 3, nhưng nó đã chạy được vài giờ mà không hoàn thành (trong quá trình triển khai Java của tôi có lẽ không tối ưu) (EDIT: trong @ Timwi's EsotericIDE [Thật tuyệt! Bạn cũng nên thử nó]. Không may mắn.). Về lý thuyết, điều này hoạt động đến kích thước tế bào của việc thực hiện cụ thể.

Python, 161 - 5 (toán tử không *) = 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

gọi:

t(2, 4)

Perl, 61 ký tự

đây là một thứ kỳ quái

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

sử dụng:

print t(2,4,1)

Toán học , 40 33

Điều này không hoàn toàn tuân thủ các quy tắc nhưng dù sao nó cũng không gây tranh cãi cho mã ngắn nhất và tôi hy vọng rằng nó sẽ được ai đó quan tâm.

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

m[m@Sum]

Điều này xây dựng hàm "tetration" khi nó được chạy, nhưng các đối số phải được đưa ra theo thứ tự ngược lại. Thí dụ:

m[m@Sum][3, 4]

1340780792994259709957402499820584612747936582059239337772356144372176 4030073546976801874298166903427690031858186486050853753882811946569946 43364900

Haskell:  58  51 ký tự, có hoặc không nhân.

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

Ung dung:

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

Định nghĩa ngắn hơn xuất phát từ nội tuyến của ốp lưng, và định nghĩa một phiên bản tùy chỉnh của Wikipedia iterate. Thật không may, kết quả là không hiệu quả, nhưng bắt đầu bằng (*) thay vì (+) cho tốc độ khá. Trong 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)

Ruby 66 59 ký tự

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

Python, 112 ký tự

Các số phải là đối số thứ 1 và thứ 2: python this.py 4 3
**toán tử không được sử dụng.
*đã sử dụng. Nó khá đơn giản để thực hiện, chính xác như thế **, nhưng chi phí hơn 5 ký tự.

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 ký tự

EDIT: Hợp nhất hai chức năng pvà rthành một, lưu một số ký tự.
Trong số 99 ký tự, 52 thực hiện tính toán thực tế (bao gồm cả định nghĩa biến). 47 cái còn lại để xử lý đầu vào và đầu ra.
LGI: Xử lý không tốt các quyền hạn bằng 0 (ví dụ 0 2). Nên tìm một sửa chữa chi phí tối thiểu. Đây không phải là một lỗi, tôi quên rằng 0 2không xác định được.

Xử lý thành công 4 3, và thậm chí cho một kết quả chính xác. Tuy nhiên, có thể không chính xác cho một số số nhỏ hơn.
In số với một dấu .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());
}

Yếu tố, 187 ký tự

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 .

Trước khi chơi gôn:

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.

Tôi đã không loại bỏ toán tử nhân *. Nếu tôi đã làm như vậy, thì tôi sẽ cần thêm một số logic biểu thị rằng tổng của một chuỗi trống là 0, không phải 1. Logic bổ sung này sẽ có giá cao hơn phần thưởng -5.

Bộ ngắt quy tắc, 124 + 10 = 134 ký tự

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

Chương trình này có điểm thấp hơn, nhưng toán tử lũy thừa ^phá vỡ các quy tắc. Các quy tắc nói "(# ký tự) + (10 * (# của toán tử 'sức mạnh))", vì vậy tôi đã áp dụng hình phạt +10. Tuy nhiên, các quy tắc cũng nói "Không sử dụng toán tử 'sức mạnh', vì vậy bất kỳ chương trình nào thực hiện hình phạt này đều vi phạm các quy tắc. Do đó, chương trình gồm 134 ký tự này không phải là một câu trả lời đúng và tôi phải trình bày chương trình dài hơn gồm 187 ký tự như câu trả lời của mình.

Haskell 110 - 5 = 105

Tết kiểu Peano. Đây là giải pháp cực kỳ chậm nhất có thể, chỉ là một cảnh báo, nhưng cũng tránh được sự bổ sung.

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)

Điều này phụ thuộc vào việc bạn có đủ kiên nhẫn để gõ số Peano (và sẽ không hiển thị câu trả lời, Nếu bạn thực sự muốn chạy nó, hãy thêm vài dòng này (90 ký tự):

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

Ruby, 47 46 45

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

Lua: 133 ký tự, nhân ít

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)

Ban đầu tôi sẽ sử dụng các bản hack lặp lại chuỗi để thực hiện phép nhân giả, nhưng nó thích thất bại trên các giá trị lớn. Tôi có thể có thể sử dụng biên dịch động và chuỗi tải để làm cho nó nhỏ hơn, nhưng nó bị trễ ở đây ... Tôi cần ngủ.

Nhập "4 3" vào đầu ra stdin:

1.3407807929943e+154

VBA, 90 ký tự

* Có lẽ phần thưởng không nhân không đủ tốt. Tôi nghĩ rằng câu trả lời không nhân sẽ thú vị hơn nhiều, nhưng đây là mã golf, vì vậy nó không phải là tốt nhất. Đây là một câu trả lời không có *, và một câu trả lời tốt hơn (ngắn hơn và ghi điểm tốt hơn) với nó:

90 ký tự, không có toán tử công suất, sử dụng phép nhân = 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 ký tự, không có toán tử công suất, không có phần thưởng nhân (-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

LƯU Ý: VBA có vấn đề in số khi kết quả rất lớn (nghĩa là 4, 3), nhưng nó tính toán chính xác, vì vậy, ví dụ, nếu bạn muốn sử dụng số đó, bạn sẽ ổn. Ngoài ra, thậm chí số lượng BIGGER tràn (tức là 3, 4).

Perl 6 , 32 byte

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

Hãy thử trực tuyến!

(1, { [*] a xx $_ } ... *)là một chuỗi lười biếng tạo ra tháp năng lượng, mỗi phần tử là một danh sách bao gồm tham số đầu vào đầu tiên được asao chép ( xx) một số lần bằng với phần tử trước đó ( $_), danh sách đó sau đó được giảm với phép nhân ( [*]). Từ chuỗi đó, chúng tôi chỉ đơn giản rút ra bphần tử -th.

Phép tính Lambda, 10-5

(sử dụng mã hóa Church và phân De Bruijn )
λλ(1λ13)λ1

Giải trình

Không có phân 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

Nếu bạn xác định exp_a(x)=a^xchương trình này xác định a↑↑b=exp_a^b(1)nơi ^bbiểu thị chức năng lặp.

Tôi không chắc liệu điều này có được phép hay không vì cavề mặt kỹ thuật tương đương với a^cviệc nó không phải là một tích hợp thực sự và chỉ có tác dụng phụ của cách các số nguyên được mã hóa trong phép tính lambda.

Javascript: 116 ký tự

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') Đầu ra:

1.3407807929942597e+154

Con trăn (111) (113) không *

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 chữ số))

Trình cập nhật: Phải thêm giá trị ban đầu, để phù hợp với t (X, 0) = 1

Haskell: 88-5 ký tự không nhân, 59 ký tự với phép nhân

Không nhân

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

Có lẽ có nhiều cách mà tôi có thể đánh golf xuống một chút.

Với phép nhân:

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

Và cuối cùng, chương trình vô chủ:

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)

Đây có lẽ là cách đơn giản nhất để thực hiện vấn đề này, đó là xác định phép nhân là phép cộng lặp lại, phép lũy thừa là phép nhân lặp lại và phép nhân như phép lũy thừa lặp lại.

Vợt 58 (không *)

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

Lisp thường gặp, 85 ký tự

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

Tôi đã thử thực hiện phép nhân thông qua phép cộng lặp lại, nhưng đó là cách hơn 5 ký tự. Điều tương tự với macrolets, các tuyên bố không đáng để đạt được.

Một giải pháp khác, lấy cảm hứng từ giải pháp trăn của boothby. Đó là ít hơn 1 ký tự so với giải pháp trên.

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

Con trăn 3 - 68

(bao gồm hình phạt 10 điểm cho nhà điều hành điện)

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

Yabasic , 71 byte

Một hàm lấy đầu vào avà bnhư một chuỗi phân tách không gian.

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

Hãy thử trực tuyến!

R , 71 - 5 = 66 byte

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

Hãy thử trực tuyến!

-5 để tránh *, khó hơn tôi tưởng. Nó phát nổ rất nhanh và sẽ không hoạt động (trừ khi nó có nhiều bộ nhớ hơn) nhưng nó đáp ứng tất cả các tiêu chí cần thiết.