Esta pregunta fue modificada, vuelva a leerla.

Ultrafactoriales

Los ultrafactoriales son una secuencia de números que se pueden generar utilizando la siguiente función:

a(n) = n! ^ n!

Los valores resultantes aumentan extremadamente rápido. Nota al margen : Esta es la entrada A046882 en el OEIS. También se relacionan los hiperfactoriales, una secuencia todavía bastante grande, pero un poco más pequeña: A002109

Tu tarea

Su tarea es implementar estos números en su idioma. Su programa calculará la suma de todos los ultrafactoriales desde 0 hasta inclusive n .

Entrada

Su programa solo puede tomar una entrada: un número, que se asemeja al último a (n) ultrafactorial que se agregará a la suma. Se asegura que la entrada sea positiva o 0.

Salida

Su salida depende de usted, siempre y cuando exista la suma visible de los números en alguna parte.

Reglas

• Puede asumir todos los enteros, por lo tanto, la entrada de enteros y el uso de bucles de conteo de enteros para producir algunos resultados.

Casos de prueba

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

Reto

Este es el código de golf , por lo que gana la respuesta con la menor longitud en bytes.

05AB1E , 5 bytes

Código:

Ý!DmO

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

Mathematica, 19 bytes

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

Disculpas por el código extremadamente claro;)

Jalea, 6 bytes

Pruébalo en línea!

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

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

vectorizar es bueno

editar: guardado 4 bytes gracias a @MickyT

J 15 12 bytes

¡Guardado 3 bytes gracias a millas!

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

Explicación

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

Casos de prueba

   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 bytes

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

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

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

( Pruébelo en línea )

Explicación:

• for 0 .. $_: Para cada entero desde 0 hasta la entrada,
• [*](1 .. $_) xx 2: calcular el factorial dos veces,
• [**] ...: y exponga los dos factoriales idénticos.
• [+] ...: Luego suma todos los resultados del ciclo.

Gracias a b2gills por 1 byte.

Cheddar , 44 37 bytes

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

¡Gracias a las cabras por reducir el operador! Creo que hubiera sido una buena idea agregar factorial

Pruébalo en línea

Sin golf

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

Explicación

Nota: Un poco desactualizado, arreglará

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 bytes

Q:Ygt^s

Pruébalo en línea!

Explicación

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 bytes

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

INFpara n>5en un sistema de 64 bits.

para grandes números, 70 bytes

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

requiere que PHP se compile con --with-gmp

Rubí, 64 66 bytes

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

Se agregaron dos caracteres para la corrección de errores off-by-one (buscará acortar las llamadas de inyección más tarde).

Pyth - 9 8 bytes

s^Rd.!Mh

Test Suite .

Haskell, 67 56 bytes

Tenga en cuenta que esta presentación se realizó antes de que se eliminaran las reglas que prohibían las construcciones incorporadas.

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

Por ejemplo:

*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 bytes

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

PARI / GP , 19 bytes

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

R, 42 35 bytes

Ahora que leí la pregunta correctamente, puse la suma.

Esto requiere que la biblioteca gmp (aritmética de precisión múltiple) esté disponible. Esto permite manejar grandes cantidades. De lo contrario, algo más de 5 vuelve INF.

Esto se implementa como una función sin nombre para evitar lo as.characterque se requeriría para enviar a STDOUT a través decat

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

Ejecución de ejemplo

> 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) funcionará bastante bien, pero llena varias páginas. Unos cientos más o menos y 2.017.528 dígitos. f (10) mata la sesión en mi máquina.

JavaScript (ES7), 38 bytes

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

Pyke, 11 bytes

hFSBD]1*B)s

Pruébalo aquí!

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

Dato curioso: ¡Pyke no tiene un factorial incorporado porque SBsolo tiene 2 bytes!

Haskell, 43 bytes

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

Ejemplo de uso: a 3-> 46662.

bcalcula un solo ultrafactorial y asuma todos los ultrafactoriales de 0a n.

JavaScript (ES7), 44 bytes

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

Python 2, 82 bytes

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

Maravilla , 33 bytes

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

Uso:

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

Explicación

rng0+1#0

Crea un rango inclusivo de 0 a entrada.

->@^ f\prod rng1#0f

Asigne el rango con una función que 1) calcula el factorial del elemento, 2) almacena el resultado fy 3) calcula f^f.

sum

Suma.

TI-Basic, 13 bytes

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

PS Se puede reemplazar sum(seq(con Σ(si usted tiene un sistema operativo más reciente (sin cambio de tamaño).

Lenguaje GameMaker, 97 bytes

Función principal (52 bytes)

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

Función f (45 bytes)

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

Ruby 2, 41 bytes

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

Dyalog APL, 10 bytes

(+/!*!)0,⍳

¿Cómo?

⍳ rango de entrada

0, precedido por 0

!*! aplicar x! ^ x!

+/ suma

Mathematica, 19 bytes

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

Función anónima. Toma un número como entrada y devuelve un número como salida.

Brachylog , 12 bytes

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

Pruébalo en línea!

Explicación

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 bytes con salida de consola

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

C #, 64 bytes como retorno

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

En realidad 11 10 bytes

1+r`!;ⁿ`MΣ

Cómo funciona

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

Raqueta 54 bytes

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

Sin golf:

#lang racket
(require math)

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

Pruebas:

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

Salida:

0
1
2
6
46662