Câu hỏi này đã được làm lại, xin vui lòng đọc lại nó.

Siêu mịn

Các siêu sóng là một chuỗi các số có thể được tạo bằng hàm sau:

a(n) = n! ^ n!

Các giá trị kết quả tăng lên cực kỳ nhanh chóng. Lưu ý bên lề: Đây là mục A046882 trong OEIS. Cũng liên quan là các hyperfactorials, một chuỗi vẫn còn khá lớn, nhưng nhỏ hơn một chút: A002109

Nhiệm vụ của bạn

Nhiệm vụ của bạn là triển khai những con số này vào ngôn ngữ của bạn. Chương trình của bạn sẽ tính tổng của tất cả các siêu sóng từ 0 đến bao gồm n .

Đầu vào

Chương trình của bạn chỉ có thể nhận một đầu vào: một số, tương tự như siêu (a) cuối cùng được thêm vào tổng. Đầu vào được đảm bảo là dương hoặc 0.

Đầu ra

Đầu ra của bạn hoàn toàn phụ thuộc vào bạn, miễn là có tổng số có thể nhìn thấy ở đâu đó.

Quy tắc

• Bạn có thể giả sử tất cả các số nguyên, do đó nhập số nguyên và sử dụng các vòng đếm số nguyên để tạo ra một số kết quả.

Các trường hợp thử nghiệm

Input: -1
Output: Any kind of error (because -1! is undefined), or no handling at all

Input: 0
Output: 1

Input: 1
Output: 2

Input: 2
Output: 6

Input: 3
Output: 46662

Thử thách

Đây là môn đánh gôn , vì vậy câu trả lời có độ dài ít nhất là byte sẽ thắng!

05AB1E , 5 byte

Mã số:

Ý!DmO

Giải trình:

Ý       # Take the range [0, ..., input]
 !      # Map factorial over each element
  Dm    # Exponentiate each element to itself
    O   # Take the sum

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Toán học, 19 byte

Sum[n!^n!,{n,0,#}]&

Xin lỗi về mã cực kỳ rõ ràng;)

Thạch, 6 byte

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

‘Ḷ!*`S // Main link: Argument n (integer)
‘      // Take n, increment by 1
 Ḷ     // Range from [0..n]
  !    // Calculates factorial for each [0..n]
   *`  // Raises each [0!..n!] to the power of itself
     S // Sum the resulting array

R - 34 30 byte

x=factorial(0:scan());sum(x^x)

vectorizing là tốt đẹp

chỉnh sửa: đã lưu 4 byte nhờ @MickyT

J, 15 12 byte

Saved 3 byte nhờ dặm!

1#.i.^~@!@,]

Giải trình

1#.i.^~@!@,]  input: y
          ,]  append y to list...
   i.         [0, y)
        !@    factorial each member
     ^~@      raise each to itself
1#.           perform summation

Các trường hợp thử nghiệm

   f =: 1#.i.^~@!@,]
   (,. f"0) i.4
0     1
1     2
2     6
3 46662
   (,. f"0) i.6
0           1
1           2
2           6
3       46662
4  1.33374e33
5 3.17504e249

   echo"1] _90]\":f 6x
190281878633201797429473437859705759836595323046380462211756876146775419721154680216391116
383660154937824558291984804764687140715927099993629348072943551413397410741069111169123658
220861477766905534108349401724389611558474171816216027733366046875815097164882588181826712
426524007417126023680300953790645455254723360874298622143752208989152655091222094594342956
890526202094068774356589887610542642450567071133028553816930267473112879050178461179814798
008667622200592591542432361632955904924276854403585221477449385731481108378608652069211835
448555831555820393949831627809528917004144455150642180845929102272754394116905511650997561
389917179995442329297103257850695109383021080317204810134810158543814178231002423431556657
737982683316707709406053569620116083909440177269311235173671447595521339849978144493268530
780365729831790064477684808893338190825461650933123545889305523546630119181308584140916288
912561260392366609493077363059677222110731132927863243720195975705161197786520981159422881
575250362836779593393897664990291828935858671453835924398316498051705698128484688847592380
831018330553151156822298060174230201841578757499203145955456593022852288527824268115043999
037373974753999860179933517198889966353093307592136928730661270863274130109304971274296438
682725017433937245229524959283895094220677649257613358344409711070780405579776000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000003175042373780336892901667920556557182493442088021222004926225128381629943118937129
098831435345716937405655305190657814877412786176000000000000000000000000000000000000000000
000000000000000000000000000000000000000000001333735776850284124449081472890438

Perl 6 , 41 38 37 byte

{[+] ([**] [*](1..$_)xx 2 for 0..$_)}

{[+] ([**] ([*] 1..$_)xx 2 for 0..$_)}

{sum (($_**$_ with [*] 1..$_) for 0..$_)}

( Dùng thử trực tuyến. )

Giải trình:

• for 0 .. $_: Đối với mỗi số nguyên từ 0 đến đầu vào,
• [*](1 .. $_) xx 2: tính giai thừa hai lần,
• [**] ...: và lũy thừa hai yếu tố giống hệt nhau.
• [+] ...: Sau đó tổng hợp tất cả các kết quả của vòng lặp.

Cảm ơn b2gills cho 1 byte.

Cheddar , 44 37 byte

n->(0|>n=>(i,a=(1|>i)/(*))->a**a)/(+)

Cảm ơn dê đã giảm toán tử! Tôi nghĩ rằng đó là ý tưởng tốt để thêm giai thừa

Dùng thử trực tuyến

Bị đánh cắp

n -> ( 0|>n => (i, a=(1|>i) / (*)) -> a ** a) / (+)

Giải trình

Lưu ý: Một chút lỗi thời, sẽ sửa chữa

n ->           // Input
( 0 |> n) =>   // Run below for each of [0, n]
    (              
      i,           // Input
      a =          // Let's keep n! in this variable `a`
         (1 |> i)  // Range from [1, n]
         / (*)     // Multiply all the items of that range
                   // `/` is reduce `(*)` is multiplication function
    ) ->
    a ** a         // A to the power of A
) / (+)        // Sum all results

MATL , 7 byte

Q:Ygt^s

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

Giải trình

Q         % Take input n implicitly. Add 1
 :        % Range [1 2 ... n+1]
  Yg      % Gamma function, element-wise. This gives [0! 1! ... n!]
    t^    % Rise result to itself, element-wise
      s   % Sum all values. Implicitly display

PHP, 49 byte

for($f=1;$i<=$argv[1];$f*=++$i)$s+=$f**$f;echo$s;

INFcho n>5hệ thống 64 bit.

cho số lượng lớn, 70 byte

while($i<=$argv[1])$s=gmp_add($s,gmp_pow($f=gmp_fac($i++),$f));echo$s;

yêu cầu PHP phải được biên dịch với --with-gmp

Hồng ngọc 64 66 byte

->n{(o=(1..n).map{|i|a=(1..i).inject(:*);a**a}.inject(:+))?o+1:1}

Đã thêm hai ký tự cho lỗi sửa lỗi (sẽ xem xét rút ngắn các lệnh gọi sau).

Pyth - 9 8 byte

s^Rd.!Mh

Phòng thử nghiệm .

Haskell, 67 56 byte

Lưu ý rằng đệ trình này đã được thực hiện trước khi các quy tắc cấm xây dựng bị loại bỏ.

p=product
a n=sum[p[x|x<-[p[1..i]],_<-[1..x]]|i<-[0..n]]

Ví dụ:

*Main> a 0
1
*Main> a 1
2
*Main> a 2
6
*Main> a 3
46662
*Main> a 4
1333735776850284124449081472890438
*Main> a 5
3175042373780336892901667920556557182493442088021222004926225128381629943118937129098831435345716937405655305190657814877412786176000000000000000000000000000000000000000000000000000000000000000000000000000000000000001333735776850284124449081472890438

Python 2, 73 72 byte

import math
lambda n,f=math.factorial:sum(f(i)**f(i)for i in range(n+1))

PARI / GP , 19 byte

n->sum(k=0,n,k!^k!)

R, 42 35 byte

Bây giờ tôi đã đọc đúng câu hỏi, tôi đã đặt số tiền vào.

Điều này đòi hỏi phải có thư viện gmp (nhiều số học chính xác). Điều này cho phép số lượng lớn được xử lý. Nếu không, bất cứ điều gì hơn 5 trả lại INF.

Điều này được thực hiện như là một chức năng chưa được đặt tên để tránh as.characterđiều đó sẽ được yêu cầu để xuất ra STDOUT thông quacat

function(x)sum((i=gmp::factorialZ(0:x))^i)

Chạy ví dụ

> f <- function(x)sum((i=gmp::factorialZ(0:x))^i)
> f(5)
Big Integer ('bigz') :
[1] 3175042373780336892901667920556557182493442088021222004926225128381629943118937129098831435345716937405655305190657814877412786176000000000000000000000000000000000000000000000000000000000000000000000000000000000000001333735776850284124449081472890438
> f(6)
Big Integer ('bigz') :
[1] 190281878633201797429473437859705759836595323046380462211756876146775419721154680216391116383660154937824558291984804764687140715927099993629348072943551413397410741069111169123658220861477766905534108349401724389611558474171816216027733366046875815097164882588181826712426524007417126023680300953790645455254723360874298622143752208989152655091222094594342956890526202094068774356589887610542642450567071133028553816930267473112879050178461179814798008667622200592591542432361632955904924276854403585221477449385731481108378608652069211835448555831555820393949831627809528917004144455150642180845929102272754394116905511650997561389917179995442329297103257850695109383021080317204810134810158543814178231002423431556657737982683316707709406053569620116083909440177269311235173671447595521339849978144493268530780365729831790064477684808893338190825461650933123545889305523546630119181308584140916288912561260392366609493077363059677222110731132927863243720195975705161197786520981159422881575250362836779593393897664990291828935858671453835924398316498051705698128484688847592380831018330553151156822298060174230201841578757499203145955456593022852288527824268115043999037373974753999860179933517198889966353093307592136928730661270863274130109304971274296438682725017433937245229524959283895094220677649257613358344409711070780405579776000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003175042373780336892901667920556557182493442088021222004926225128381629943118937129098831435345716937405655305190657814877412786176000000000000000000000000000000000000000000000000000000000000000000000000000000000000001333735776850284124449081472890438

f (9) sẽ chạy khá tốt, nhưng lấp đầy một số trang. Một vài trăm hoặc hơn và 2.017.528 chữ số. f (10) giết phiên trên máy của tôi.

JavaScript (ES7), 38 byte

f=(n,a=1,i=0)=>i>n?0:a**a+f(n,a*++i,i)

Pyke, 11 byte

hFSBD]1*B)s

Hãy thử nó ở đây!

hF          -  for i in range (0, input+1)
  SB        -     product(range(1, i+1)
    D]1*    -    [^]*^
        B   -   product(^)
          s - sum(^)

Sự thật thú vị: Pyke không tích hợp sẵn giai thừa vì SBchỉ có 2 byte!

Haskell, 43 byte

b n|f<-product[1..n]=f^f
a n=sum$b<$>[0..n]

Ví dụ sử dụng: a 3-> 46662.

btính toán một siêu sóng đơn và tính atổng tất cả các siêu sóng từ 0đến n.

JavaScript (ES7), 44 byte

g=n=>n?(f=a=>a?a*f(a-1):1)(n)**f(n)+g(n-1):1

Python 2, 82 byte

x=input()
s=0
for z in range(x):
 t=1
 for i in range(z+1):t*=i+1
 s+=t**t
print s

Kỳ quan , 33 byte

@sum(->@^ f\prod rng1#0f)rng0+1#0

Sử dụng:

(@sum(->@^ f\prod rng1#0f)rng0+1#0)3

Giải trình

rng0+1#0

Tạo phạm vi bao gồm từ 0 đến đầu vào.

->@^ f\prod rng1#0f

Ánh xạ qua phạm vi với chức năng 1) tính giai thừa của vật phẩm, 2) lưu kết quả vào fvà 3) tính toán f^f.

sum

Tổng.

TI-Basic, 13 byte

sum(seq(A!^A!,A,0,Ans

PS Bạn có thể thay thế sum(seq(bằng Σ(nếu bạn có một hệ điều hành mới hơn (không thay đổi kích thước).

Ngôn ngữ GameMaker, 97 byte

Hàm chính (52 byte)

for(a=0;a<=argument0;a++)b+=power(f(a),f(a))return b

Hàm f (45 byte)

a=argument0 if!a return 1else return a*f(a--)

Ruby 2, 41 byte

->n{(1..n).reduce(s=1){|t,i|t+(s*=i)**s}}

APL Dyalog, 10 byte

(+/!*!)0,⍳

Làm sao?

⍳ phạm vi đầu vào

0, trước 0

!*! ứng dụng x! ^ x!

+/ tổng

Toán học, 19 byte

Sum[a!^a!,{a,0,#}]&

Chức năng ẩn danh. Lấy một số làm đầu vào và trả về một số làm đầu ra.

Brachylog , 12 byte

y:{$!F:F^}a+

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

Giải trình

y                 The list [0, ..., Input]
 :{      }a       Apply the predicate below to each element of that list
           +      The output is the sum of the results

   $!F              F is the factorial of the input
      :F^           Output = F^F

C #, 79 byte với đầu ra giao diện điều khiển

n=>{int i=1,j=1;for(;i<=n;i++)j*=i;System.Console.Write(System.Math.Pow(j,j));}

Trả về C #, 64 byte

n=>{int i=1,j=1;for(;i<=n;i++)j*=i;return System.Math.Pow(j,j);}

Trên thực tế 11 10 byte

1+r`!;ⁿ`MΣ

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

Program takes implicit input, implicit print at EOF
1+          Add one to the input n+1
  r         Create a range (0,1,..,n)
   `   `    Create a function between the two `
    !       Factorialize the current stack item
     ;      Duplicate the current stack item
      ⁿ     Power a,b from the current stack item
         M  Map the function across the stack top item
          Σ Sum the stack together

Vợt 54 byte

(for/sum((i(+ 1 n)))(let((t(factorial i)))(expt t t)))

Ung dung:

#lang racket
(require math)

(define (f n)
  (for/sum ((i (+ 1 n)))
    (let ((t (factorial i)))
      (expt t t))))

Kiểm tra:

(f -1)
(f 0)
(f 1)
(f 2)
(f 3)

Đầu ra:

0
1
2
6
46662