이 질문은 재 작업되었습니다. 다시 읽으십시오.

초 인성

초 인수는 다음 함수를 사용하여 생성 할 수있는 일련의 숫자입니다.

a(n) = n! ^ n!

결과 값이 매우 빠르게 상승합니다. 참고 : 이것은 OEIS의 항목 A046882 입니다. 또한 관련 hyperfactorials, 여전히 매우 큰,하지만 조금 작은 순서는 다음과 같습니다 A002109

당신의 작업

당신의 임무는이 숫자들을 당신의 언어로 구현하는 것입니다. 프로그램은 0에서 포괄적 인 모든 초 인수 의 합을 계산 합니다 n .

입력

프로그램은 하나의 입력 만 취할 수 있습니다. 숫자는 합계에 추가 할 마지막 a (n) 초 인수와 유사합니다. 입력은 양수 또는 0이어야합니다.

산출

어딘가에 보이는 숫자의 합계가있는 한 출력은 모두 당신에게 달려 있습니다.

규칙

• 모든 정수, 따라서 정수 입력을 가정하고 정수 계산 루프를 사용하여 결과를 생성 할 수 있습니다.

테스트 사례

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

도전

이것은 code-golf 이므로 바이트 단위의 최소 길이를 가진 답이 이깁니다!

05AB1E , 5 바이트

암호:

Ý!DmO

설명:

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

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

매스 매 티카, 19 바이트

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

매우 명확한 코드에 대한 사과;)

젤리, 6 바이트

온라인으로 사용해보십시오!

‘Ḷ!*`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 바이트

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

벡터화가 좋습니다

편집 : @MickyT 덕분에 4 바이트가 절약되었습니다.

J, 15 12 바이트

마일 덕분에 3 바이트를 절약했습니다!

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

설명

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

테스트 사례

   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

펄 6 , 41 38 37 바이트

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

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

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

( 온라인으로 시도하십시오. )

설명:

• for 0 .. $_: 0에서 입력까지의 각 정수에 대해
• [*](1 .. $_) xx 2: 계승을 두 번 계산합니다.
• [**] ...두 개의 동일한 계승을 지수화합니다.
• [+] ...: 그런 다음 루프의 모든 결과를 합산하십시오.

1 바이트에 대한 b2gills 덕분입니다.

체다 , 44 37 바이트

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

감소 연산자에 대한 염소 감사합니다! 계승을 추가하는 것이 좋은 생각이라고 생각합니다

온라인으로 사용해보십시오

언 골프

n -> ( 0|>n => (i, a=(1|>i) / (*)) -> a ** 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 바이트

Q:Ygt^s

온라인으로 사용해보십시오!

설명

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 바이트

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

INF위한 n>564 비트 시스템.

많은 수의 경우 70 바이트

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

PHP로 컴파일해야 함 --with-gmp

루비, 64 66 바이트

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

개별 버그 수정을 위해 두 문자를 추가했습니다 (나중에 인 젝트 호출을 줄이는 방법을 살펴볼 것입니다).

Pyth- 9 8 바이트

s^Rd.!Mh

테스트 스위트 .

하스켈, 67 56 바이트

이 제출은 내장을 금지하는 규칙이 제거 되기 전에 이루어졌습니다 .

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

예를 들면 다음과 같습니다.

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

파이썬 2, 73 72 바이트

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

PARI / GP , 19 바이트

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

R, 42 35 바이트

이제 질문을 제대로 읽었으므로 합계를 넣었습니다.

이를 위해서는 gmp (multiple precision arithmetic) 라이브러리를 사용할 수 있어야합니다. 이를 통해 많은 수를 처리 할 수 ​​있습니다. 그렇지 않으면 5를 초과하는 것은을 반환합니다 INF.

이것은 as.characterSTDOUT으로 출력하는 데 필요한 기능을 피하기 위해 명명되지 않은 함수로 구현됩니다.cat

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

예제 실행

> 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)는 꽤 잘 실행되지만 여러 페이지를 채 웁니다. 몇 백 정도, 2,017,528 자리 숫자입니다. f (10)은 내 컴퓨터에서 세션을 종료합니다.

자바 스크립트 (ES7), 38 바이트

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

파이크, 11 바이트

hFSBD]1*B)s

여기 사용해보십시오!

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

재미있는 사실 : Pyke에는 SB2 바이트 밖에 없기 때문에 팩토리가 내장되어 있지 않습니다 !

하스켈, 43 바이트

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

사용 예 : a 3-> 46662.

b하나의 ultrafactorial을 계산하고 a모든 ultrafactorials을 요약 0에 n.

자바 스크립트 (ES7), 44 바이트

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

파이썬 2, 82 바이트

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

Wonder , 33 바이트

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

용법:

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

설명

rng0+1#0

0에서 입력까지 포함 범위를 만듭니다.

->@^ f\prod rng1#0f

1) 항목의 계승을 계산하고, 2) 결과를에 저장하고 f, 3)을 계산 하는 함수를 사용하여 범위를 매핑합니다 f^f.

sum

합집합.

TI 기본, 13 바이트

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

PS 당신은 대체 할 수 sum(seq(와 함께 Σ(당신은 새로운 운영 체제 (아무 크기 변경)가있는 경우.

GameMaker 언어, 97 바이트

주요 기능 (52 바이트)

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

기능 f (45 바이트)

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

루비 2, 41 바이트

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

Dyalog APL, 10 바이트

(+/!*!)0,⍳

방법?

⍳ 입력 범위

0, 앞에 0

!*! 대다 x! ^ x!

+/ 합집합

매스 매 티카, 19 바이트

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

익명의 기능. 숫자를 입력으로 받아서 숫자를 출력으로 반환합니다.

Brachylog , 12 바이트

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

온라인으로 사용해보십시오!

설명

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 바이트

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

C #, 64 바이트 반환

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

실제로 11 10 바이트

1+r`!;ⁿ`MΣ

작동 원리

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

라켓 54 바이트

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

언 골프 드 :

#lang racket
(require math)

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

테스트 :

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

산출:

0
1
2
6
46662