Cette question a été retravaillée, veuillez la relire.

Ultrafactoriels

Les ultrafactoriels sont une séquence de nombres qui peuvent être générés à l'aide de la fonction suivante:

a(n) = n! ^ n!

Les valeurs résultantes augmentent extrêmement rapidement. Note latérale: Il s'agit de l'entrée A046882 dans l'OEIS. Les hyperfactoriels sont également liés, une séquence encore assez énorme, mais un peu plus petite: A002109

Ta tâche

Votre tâche consiste à implémenter ces numéros dans votre langue. Votre programme calculera la somme de tous les ultrafactoriels de 0 à inclus n .

Contribution

Votre programme ne peut prendre qu'une seule entrée: un nombre, qui ressemble au dernier a (n) ultrafactoriel à ajouter à la somme. L'entrée est assurée d'être positive ou 0.

Sortie

Votre sortie dépend de vous, tant qu'il y a la somme visible des nombres quelque part.

Règles

Vous pouvez supposer tous les nombres entiers, donc les entrées entières, et utiliser des boucles de comptage d'entiers pour produire des résultats.

Cas de 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

Défi

C'est le code-golf , donc la réponse avec le moins de longueur en octets l'emporte!

code-golf sequence factorial devRicher
la source

2

Faut-il considérer des entiers arbitrairement grands? Ou est-ce suffisant pour gérer le plus grand supporté par le type de données par défaut de la langue (tel que double)?

Luis Mendo

1

Le code de conversion et la sortie dépendent de vous, mais l'entrée sera un entier. @LuisMendo

devRicher

3

Changer les règles après que de nombreuses personnes aient répondu n'est pas une bonne chose non plus. Veuillez utiliser le bac à sable comme indiqué chaque fois que vous souhaitez soumettre un défi.

flawr

7

05AB1E , 5 octets

Code:

Ý!DmO

Explication:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Adnan
la source

L!DmOfonctionne également si vous souhaitez supprimer le bit "Codage CP-1252".

Magic Octopus Urn

16

Mathematica, 19 octets

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

Toutes mes excuses pour le code extrêmement clair;)

Greg Martin
la source

Utilisation de mathématique pour mathématique - dick move: D

Transcendental

8

Gelée, 6 octets

Essayez-le en ligne!

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

Xanderhall
la source

Il y a un atome d'incrémentation ‘, donc R!*`S‘enregistre un octet (j'y suis allé ‘Ḷ!*`S).

Jonathan Allan

1

En fait, j'étais au milieu du montage avant de voir votre commentaire: P

Xanderhall

J'ai vu ça aussi, bon travail.

Jonathan Allan

6

R - 34 30 octets

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

vectoriser c'est bien

edit: sauvé 4 octets grâce à @MickyT

balle rebondissante
la source

1

vous pouvez le raccourcir un peu en déplaçant votre scan dans le factorielx=factorial(0:scan());sum(x^x)

MickyT

4

J, 15 12 octets

Économisé 3 octets grâce aux miles!

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

Explication

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

Cas de 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

Conor O'Brien
la source

1#.i.^~@!@,]rase encore quelques octets.

miles

@miles Oh, cool. Je ne savais pas 1#.effectuer la sommation. Si ce n'est pas déjà une astuce, vous devez certainement l'ajouter!

Conor O'Brien

4

Perl 6 , 41 38 37 octets

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

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

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

( Essayez-le en ligne. )

Explication:

for 0 .. $_: Pour chaque entier de 0 à l'entrée,
[*](1 .. $_) xx 2: calculer la factorielle deux fois,
[**] ...: et exposer les deux factorielles identiques.
[+] ...: Additionnez ensuite tous les résultats de la boucle.

Merci à b2gills pour 1 octet.

smls
la source

([*] …)peut être écrit comme [*](…)enregistrant un octet

Brad Gilbert b2gills

3

Cheddar , 44 37 octets

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

Merci aux chèvres d'avoir réduit l'opérateur! Je pense que ça aurait été une bonne idée d'ajouter factorielle

Essayez-le en ligne

Non golfé

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

Explication

Remarque: Un peu obsolète, corrigera

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

Downgoat
la source

Dieu n'est-il pas un peu présomptueux ici? : D

flawr

@flawr ok. Correction: P

Downgoat

2

Haha, mieux, peut-être l'un des rares usages légitimes de la chèvre que nous avons vu récemment ici :)

flawr

3

MATL , 7 octets

Q:Ygt^s

Essayez-le en ligne!

Explication

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

Luis Mendo
la source

3

PHP, 49 octets

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

INFpour n>5sur un système 64 bits.

pour les grands nombres, 70 octets

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

nécessite que PHP soit compilé avec --with-gmp

Titus
la source

3

Rubis, 64 66 octets

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

Ajout de deux caractères pour le correctif de bug off-by-one (examinera la possibilité de raccourcir les appels d'injection plus tard).

DépriméDaniel
la source

Je ne suis pas bon avec Ruby, mais ne pouvez-vous pas résoudre ce problème avec a=(0..i)au lieu de a=(1..i)?

Timtech

@Timtech Attendez-vous à ce que l'injection de zéro dans une multiplication ne fasse de bien à personne :(

DepressedDaniel

Bon, je suppose que l'ajout +1est la meilleure solution.

Timtech

@GB Correction triviale appliquée pour n = 0 cas.

DepressedDaniel

2

Pyth - 9 8 octets

s^Rd.!Mh

Suite de tests .

Maltysen
la source

2

Haskell, 67 56 octets

Notez que cette soumission a été faite avant la suppression des règles interdisant les buildins.

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

Par exemple:

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

flawr
la source

2

Python 2, 73 72 octets

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

Nouilles9
la source

2

PARI / GP , 19 octets

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

Charles
la source

1

J'étais sur le point de publier ceci. Heureux d'avoir vérifié en premier.

primo

2

R, 42 35 octets

Maintenant que j'ai bien lu la question, j'ai mis la somme.

Cela nécessite que la bibliothèque gmp (arithmétique à précision multiple) soit disponible. Cela permet de traiter de grands nombres. Sinon, plus de 5 retours INF.

Ceci est implémenté comme une fonction sans nom pour éviter le as.characterqui serait nécessaire pour sortir vers STDOUT viacat

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

Exemple d'exécution

> 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) fonctionne plutôt bien, mais remplit un certain nombre de pages. Quelques centaines et 2 017 528 chiffres. f (10) tue la session sur ma machine.

MickyT
la source

Je pense que la raison pour laquelle elle est différente des autres réponses est parce que vous êtes censé renvoyer la somme de 0! ^ 0! à N! ^ N !. Mais cela est facile à modifier en passant à factorialZ(0:x). Y a-t-il une raison spécifique pour ne pas utiliser la base::factorial()fonction?

JAD

1

@JarkoDubbeldam Merci pour la capture. Besoin de mieux lire les questions :). J'utilise gmp::factorialZpour gérer les grands nombres.

MickyT

2

JavaScript (ES7), 38 octets

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

Neil
la source

@ fəˈnɛtɪk Désolé, force d'habitude.

Neil

1

Pyke, 11 octets

hFSBD]1*B)s

Essayez-le ici!

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

Fait amusant: Pyke n'a pas de facteur intégré car il SBne fait que 2 octets!

Bleu
la source

1

Haskell, 43 octets

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

Exemple d'utilisation: a 3-> 46662.

bcalcule un seul ultra-factoriel et aadditionne tous les ultra-factoriels de 0à n.

nimi
la source

1

JavaScript (ES7), 44 octets

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

Huntro
la source

1

Python 2, 82 octets

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

sonrad10
la source

Avez-vous essayé de résumer une liste de compréhension?

Riking

1

Vous n'avez utilisé x qu'une seule fois, vous pouvez donc utiliser range(input())cela pour supprimer quelques octets

george

1

Wonder , 33 octets

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

Usage:

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

Explication

rng0+1#0

Créez une plage inclusive de 0 à l'entrée.

->@^ f\prod rng1#0f

Carte sur la plage avec une fonction qui 1) calcule la factorielle de l'élément, 2) stocke le résultat fet 3) calcule f^f.

sum

Somme.

Mama Fun Roll
la source

1

TI-Basic, 13 octets

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

PS Vous pouvez remplacer sum(seq(par Σ(si vous avez un système d'exploitation plus récent (pas de changement de taille).

Timtech
la source

1

GameMaker Language, 97 octets

Fonction principale (52 octets)

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

Fonction f (45 octets)

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

Timtech
la source

1

Rubis 2, 41 octets

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

Lee W
la source

Impressionnant! Très intelligent la façon dont il s'initialise sen même temps qu'il le passe comme tvaleur initiale à réduire / injecter.

DepressedDaniel

Peut être joué au golf un personnage de plus ->n{((t=s=1)..n).map{|i|t+=(s*=i)**s};t}ou->n{t=s=1;(1..n).map{|i|t+=(s*=i)**s};t}

DepressedDaniel

1

Dyalog APL, 10 octets

(+/!*!)0,⍳

Comment?

⍳ plage d'entrée

0, précédé de 0

!*! appliquer x! ^ x!

+/ somme

Uriel
la source

*et !sont des fonctions scalaires, alors utilisez des tableaux: +/*⍨!0,⍳⎕ou (+/!*!)0,⍳si vous voulez vraiment un train.

Adám

0

Mathematica, 19 octets

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

Fonction anonyme. Prend un nombre en entrée et renvoie un nombre en sortie.

LegionMammal978
la source

1

Nous ne pouvons pas utiliser de facteur intégré ou d'exponentiation.

Downgoat

0

Brachylog , 12 octets

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

Essayez-le en ligne!

Explication

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

Fatalize
la source

0

C #, 79 octets avec sortie console

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

C #, 64 octets en retour

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

Alfie Goodacre
la source

0

En fait 11 10 octets

1+r`!;ⁿ`MΣ

Comment ça marche

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

Pélican bleu canard
la source

0

Raquette 54 octets

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

Non golfé:

#lang racket
(require math)

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

Essai:

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

Sortie:

rnso
la source

Grands nombres: Ultrafactoriels

Ultrafactoriels

Ta tâche

Contribution

Sortie

Règles

Cas de test

Défi

Réponses:

05AB1E , 5 octets

Mathematica, 19 octets

Gelée, 6 octets

R - 34 30 octets

J, 15 12 octets

Explication

Cas de test

Perl 6 , 41 38 37 octets

Explication:

Cheddar , 44 37 octets

Non golfé

Explication

MATL , 7 octets

Explication

PHP, 49 octets

Rubis, 64 66 octets

Pyth - 9 8 octets

Haskell, 67 56 octets

Python 2, 73 72 octets

PARI / GP , 19 octets

R, 42 35 octets

JavaScript (ES7), 38 octets

Pyke, 11 octets

Haskell, 43 octets

JavaScript (ES7), 44 octets

Python 2, 82 octets

Wonder , 33 octets

Explication

TI-Basic, 13 octets

GameMaker Language, 97 octets

Rubis 2, 41 octets

Dyalog APL, 10 octets

Mathematica, 19 octets

Brachylog , 12 octets

Explication

C #, 79 octets avec sortie console

C #, 64 octets en retour

En fait 11 10 octets

Raquette 54 octets