Questa domanda è stata rielaborata, per favore rileggila.

Ultrafactorials

Gli ultrafattoriali sono una sequenza di numeri che possono essere generati utilizzando la seguente funzione:

a(n) = n! ^ n!

I valori risultanti aumentano molto rapidamente. Nota a margine : questa è la voce A046882 nell'OEIS. Correlati sono anche gli iperfattoriali, una sequenza ancora piuttosto grande, ma un po 'più piccola: A002109

Il tuo compito

Il tuo compito è implementare questi numeri nella tua lingua. Il programma calcolerà la somma di tutti gli ultrafattoriali da 0 fino a inclusivo n .

Ingresso

Il tuo programma può accettare solo un input: un numero, che ricorda l'ultimo a (n) ultrafattoriale da aggiungere alla somma. L'ingresso è garantito per essere positivo o 0.

Produzione

L'output dipende tutto da te, a condizione che ci sia la somma visibile dei numeri da qualche parte.

Regole

• Puoi assumere tutti i numeri interi, quindi l'input intero e l'utilizzo di cicli di conteggio dei numeri interi per produrre alcuni risultati.

Casi test

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

Sfida

Questo è code-golf , quindi vince la risposta con la minima lunghezza in byte!

05AB1E , 5 byte

Codice:

Ý!DmO

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online!

Mathematica, 19 byte

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

Ci scusiamo per il codice estremamente chiaro;)

Gelatina, 6 byte

Provalo online!

‘Ḷ!*`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)

vettorializzare è carino

modifica: salvato 4 byte grazie a @MickyT

J, 15 12 byte

Salvato 3 byte grazie alle miglia!

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

Spiegazione

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

Casi test

   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..$_)}

( Provalo online. )

Spiegazione:

• for 0 .. $_: Per ogni numero intero compreso tra 0 e l'ingresso,
• [*](1 .. $_) xx 2: calcola il fattoriale due volte,
• [**] ...: ed esponenziale i due fattoriali identici.
• [+] ...: Quindi sommare tutti i risultati del loop.

Grazie a b2gills per 1 byte.

Cheddar , 44 37 byte

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

Grazie alle capre per ridurre l'operatore! Penso che sarebbe stata una buona idea aggiungere fattoriale

Provalo online

Ungolfed

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

Spiegazione

Nota: un po 'obsoleto, risolverà

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

Provalo online!

Spiegazione

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;

INFper n>5un sistema a 64 bit.

per grandi numeri, 70 byte

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

richiede compilazione di PHP --with-gmp

Rubino, 64 66 byte

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

Aggiunti due caratteri per il bug-off-by-one (esaminerà in seguito l'accorciamento delle chiamate iniettate).

Pyth - 9 8 byte

s^Rd.!Mh

Test Suite .

Haskell, 67 56 byte

Si noti che questa presentazione è stata effettuata prima che le regole che vietavano gli builtin fossero rimosse.

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

Per esempio:

*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

Ora che ho letto correttamente la domanda, ho inserito la somma.

Ciò richiede la disponibilità della libreria gmp (multiple precision arithmetic). Ciò consente di gestire numeri grandi. Altrimenti, qualsiasi cosa oltre 5 ritorni INF.

Questo è implementato come una funzione senza nome per evitare as.characterciò che sarebbe necessario per l'output su STDOUTcat

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

Esempio di esecuzione

> 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) funzionerà abbastanza bene, ma riempirà un numero di pagine. Qualche centinaio e circa 2.017.528 cifre. f (10) uccide la sessione sulla mia macchina.

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

Provalo qui!

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

Curiosità: Pyke non ha un fattoriale incorporato perché ha SBsolo 2 byte!

Haskell, 43 byte

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

Esempio di utilizzo: a 3-> 46662.

bcalcola un singolo ultrafattoriale e asomma tutti gli ultrafattoriali da 0a 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

Meraviglia , 33 byte

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

Uso:

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

Spiegazione

rng0+1#0

Crea un intervallo inclusivo da 0 a input.

->@^ f\prod rng1#0f

Mappa sull'intervallo con una funzione che 1) calcola il fattoriale dell'elemento, 2) memorizza il risultato fe 3) calcola f^f.

sum

Somma.

TI-Basic, 13 byte

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

PS È possibile sostituire sum(seq(con Σ(se si dispone di un sistema operativo più recente (nessuna modifica delle dimensioni).

Lingua GameMaker, 97 byte

Funzione principale (52 byte)

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

Funzione 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}}

Dyalog APL, 10 byte

(+/!*!)0,⍳

Come?

⍳ gamma di input

0, preceduto da 0

!*! applicare x! ^ x!

+/ somma

Mathematica, 19 byte

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

Funzione anonima. Accetta un numero come input e restituisce un numero come output.

Brachylog , 12 byte

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

Provalo online!

Spiegazione

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 con uscita console

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

C #, 64 byte come ritorno

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

In realtà 11 10 byte

1+r`!;ⁿ`MΣ

Come funziona

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

Racchetta 54 byte

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

Ungolfed:

#lang racket
(require math)

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

test:

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

Produzione:

0
1
2
6
46662