Các thách thức

Khá đơn giản, được cung cấp một đầu vào x, tính toán tháp năng lượng vô hạn của nó!

x^x^x^x^x^x...

Đối với bạn toán học người yêu trên mạng, đây là x's vô hạn tetration .

Hãy ghi nhớ những điều sau:

x^x^x^x^x^x... = x^(x^(x^(x^(x...)))) != (((((x)^x)^x)^x)^x...)

Ngạc nhiên là chúng tôi chưa có một thử thách toán học "đơn giản" nào liên quan đến việc này! *

Giả định

• xsẽ luôn hội tụ.
• Số âm và số phức có thể được xử lý
• Đây là mã golf , vì vậy byte thấp nhất sẽ thắng!
• Câu trả lời của bạn phải chính xác đến ít nhất 5 chữ số thập phân

Ví dụ

Input >> Output

1.4 >> 1.8866633062463325
1.414 >> 1.9980364085457847
[Square root of 2] >> 2
-1 >> -1
i >> 0.4382829367270323 + 0.3605924718713857i
1 >> 1
0.5 >> 0.641185744504986
0.333... >> 0.5478086216540975
1 + i >> 0.6410264788204891 + 0.5236284612571633i
-i >> 0.4382829367270323 -0.3605924718713857i
[4th root of 2] >> 1.239627729522762

* (Khác với một thử thách phức tạp hơn ở đây )

APL (Dyalog) , 4 byte

*⍣≡⍨

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

* quyền lực

⍣ cho đến khi

≡ ổn định

⍨ Chụp ảnh tự sướng

Bình thường,  4  3 byte

^{gạch bỏ 4 vẫn là 4 thông thường;}

u^Q

Dùng thử trực tuyến

Làm thế nào nó hoạt động

u       first repeated value under repeated application of G ↦
 ^QG        input ** G
    Q   starting at input

Haskell , 100 63 byte

Đối với các đầu vào không hội tụ (ví dụ. -2), Điều này sẽ không chấm dứt:

import Data.Complex
f x=until(\a->magnitude(a-x**a)<1e-6)(x**)x

Cảm ơn rất nhiều @ janrjanJohansen đã dạy tôi untilvà tiết kiệm cho tôi 37byte!

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

Python 3 , 40 39 35 byte

• Cảm ơn @ rjan Johansen cho một byte: d>99thay vì d==99: 1 lần lặp nữa cho số byte ít hơn
• Cảm ơn @Uriel cho 4 byte: sử dụng khôn ngoan thực tế x**Trueđánh giá x trong x**(d>99or g(x,d+1)). Biểu thức trong thuật ngữ đánh giá là True cho độ sâu lớn hơn 99 và do đó trả về giá trị được truyền.

Lambda đệ quy với độ sâu tối đa 100 tức là cho độ sâu 100 trả về cùng một giá trị. Trên thực tế là hội tụ - bất khả tri, vì vậy mong đợi những điều bất ngờ đối với các số có giá trị không hội tụ cho hàm.

g=lambda x,d=0:x**(d>99or g(x,d+1))

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

Python 3, 37 30 27 byte

-7 byte từ @FelipeNardiBatista.
-3 byte từ @xnor

Tôi không còn nhớ nhiều về Python nữa, nhưng tôi đã xoay sở để trả lời câu trả lời Ruby của mình và đánh bại câu trả lời Python 3 khác: D

lambda x:eval('x**'*99+'1')

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

Toán học, 12 byte

#//.x_:>#^x&

Lấy số floating điểm nổi làm đầu vào.

J , 5 byte

^^:_~

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

Giải trình

Đầu tiên, tôi sẽ chỉ ra lệnh nào đang được thực thi sau khi phân tích cú pháp ~ở cuối và phần tiếp theo sẽ dành cho động từ mới.

(^^:_~) x = ((x&^)^:_) x

((x&^)^:_) x  |  Input: x
      ^:_     |  Execute starting with y = x until the result converges
  x&^         |    Compute y = x^y

C # (.NET Core) , 79 78 byte

x=>{var a=x;for(int i=0;i++<999;)a=System.Numerics.Complex.Pow(x,a);return a;}

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

Tôi đã chọn lặp lại cho đến khi i= 999 vì nếu tôi lặp lại cho đến 99, một số ví dụ không đạt được độ chính xác cần thiết. Thí dụ:

Input:                      (0, 1)
Expected output:            (0.4382829367270323, 0.3605924718713857)
Output after 99 iterations: (0.438288569331222,  0.360588154553794)
Output after 999 iter.:     (0.438282936727032,  0.360592471871385)

Như bạn có thể thấy, sau 99 lần lặp, phần tưởng tượng đã thất bại ở vị trí thập phân thứ 5.

Input:                      (1, 1)
Expected output:            (0.6410264788204891, 0.5236284612571633)
Output after 99 iterations: (0.64102647882049,   0.523628461257164)
Output after 999 iter.:     (0.641026478820489,  0.523628461257163)

Trong trường hợp này sau 99 lần lặp, chúng ta có được độ chính xác như mong đợi. Trên thực tế, tôi có thể lặp lại cho đến i= 1e9 với cùng số byte, nhưng điều đó sẽ làm cho mã chậm hơn đáng kể

• Lưu 1 byte nhờ một người dùng ẩn danh.

Thạch , 5 byte

³*$ÐL

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

Ruby, 21 20 byte

->n{eval'n**'*99+?1}

Tuyên bố miễn trừ trách nhiệm : Có vẻ như Ruby trả về một số giá trị kỳ lạ khi tăng một số phức lên một sức mạnh. Tôi cho rằng vượt quá phạm vi cho thử thách này để sửa toàn bộ mô-đun toán học của Ruby, nhưng nếu không thì kết quả của hàm này phải chính xác. Chỉnh sửa : Áp dụng các thay đổi mới nhất từ câu trả lời Python 3 của tôivà đột nhiên nó bằng cách nào đó cho kết quả như mong đợi :)

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

TI-BASIC, 16 byte

Đầu vào và đầu ra được lưu trữ trong Ans.

Ans→X
While Ans≠X^Ans
X^Ans
End

R , 36 33 byte

- 3 byte nhờ Jarko Dubbeldam

Reduce(`^`,rep(scan(,1i),999),,T)

Đọc từ stdin. Reduces từ bên phải để có được số mũ được áp dụng theo đúng thứ tự.

Hãy thử nó (chức năng)

Hãy thử nó (stdin)

Javascript, 33 byte

f=(x,y=x)=>(x**y===y)?y:f(x,x**y)

MATL , 20 10 byte

giảm xuống còn một nửa nhờ @LuisMendo

t^`Gw^t5M-

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

Đây là môn đánh gôn mã đầu tiên của tôi và là lần đầu tiên tôi sử dụng MATL nên tôi chắc chắn rằng nó có thể dễ dàng vượt qua.

Perl 6 , 17 byte

{[R**] $_ xx 999}

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

R**là toán tử lũy thừa ngược; x R** ybằng y ** x. [R**]giảm danh sách 999 bản sao của đối số đầu vào với lũy thừa ngược.