Große Zahlen: Ultrafactorials

25

Diese Frage wurde überarbeitet, bitte lesen Sie sie noch einmal.

Ultrafactorials

Die Ultrafactorials sind eine Folge von Zahlen, die mit folgender Funktion erzeugt werden können:

a(n) = n! ^ n!

Die resultierenden Werte steigen extrem schnell an. Randnotiz: Dies ist der Eintrag A046882 im OEIS. Ebenfalls verwandt sind die Hyperfactorials, eine noch recht große, aber etwas kleinere Sequenz: A002109

Deine Aufgabe

Ihre Aufgabe ist es, diese Zahlen in Ihre Sprache umzusetzen. Ihr Programm berechnet die Summe aller Ultrafactorials von 0 bis einschließlich n .

Eingang

Ihr Programm kann nur eine Eingabe annehmen: eine Zahl, die dem letzten a (n) Ultrafaktor entspricht, der zur Summe hinzugefügt wird. Der Eingang ist positiv oder 0.

Ausgabe

Ihre Ausgabe liegt ganz bei Ihnen, solange es irgendwo die sichtbare Summe der Zahlen gibt.

Regeln

  • Sie können alle Ganzzahlen annehmen, also Integer-Eingaben, und Integer-Zählschleifen verwenden, um einige Ergebnisse zu erzielen.

Testfälle

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

Herausforderung

Das ist Code-Golf , also gewinnt die Antwort mit der geringsten Länge in Bytes!

code-golf sequence factorial devRicher
quelle
2
Müssen wir beliebig große ganze Zahlen berücksichtigen? Oder reicht es aus, den größten zu verarbeiten, den der Standarddatentyp der Sprache (wie z. B. double) unterstützt?
Luis Mendo
1
Die Konvertierung von In-Code und Ausgabe liegt bei Ihnen, die Eingabe ist jedoch eine Ganzzahl. @ LuisMendo
devRicher
3
Die Regeln zu ändern, nachdem viele Leute geantwortet haben, ist auch keine gute Sache. Bitte benutzen Sie die Sandbox wie empfohlen, wenn Sie eine Herausforderung einreichen möchten.
Fehler

Antworten:

7

05AB1E , 5 Bytes

Code:

Ý!DmO

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Adnan
quelle
L!DmOfunktioniert auch, wenn Sie das Bit "CP-1252-Codierung" entfernen möchten.
Magic Octopus Urn
16

Mathematica, 19 Bytes

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

Entschuldigung für den extrem übersichtlichen Code;)

Greg Martin
quelle
Verwenden von Mathematica für Mathematica - Dick Move: D
Transcendental
8

Gelee, 6 Bytes

Probieren Sie es 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
Xanderhall
quelle
Es gibt ein inkrementelles Atom, ‘also R!*`S‘spart es ein Byte (ich habe mich entschieden ‘Ḷ!*`S).
Jonathan Allan
1
Ich war tatsächlich mitten in der Bearbeitung, bevor ich Ihren Kommentar sah: P
Xanderhall
Das habe ich auch gesehen, gute Arbeit.
Jonathan Allan
6

R - 34 30 Bytes

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

vektorisieren ist schön

Bearbeiten: 4 Bytes dank @MickyT gespeichert

Bouncyball
quelle
1
Sie können es ein wenig verkürzen, indem Sie in die Fakultät scannenx=factorial(0:scan());sum(x^x)
MickyT
4

J, 15 12 Bytes

Dank Meilen 3 Bytes gespart!

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

Erläuterung

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

Testfälle

   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
quelle
1#.i.^~@!@,]rasiert ein paar Bytes mehr aus.
Meilen
@ Meilen Oh, cool. Ich wusste nicht, 1#.ob Summation durchgeführt wird. Wenn das noch kein Tipp ist, solltest du ihn unbedingt hinzufügen!
Conor O'Brien
4

Perl 6 , 41 38 37 Bytes

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


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


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

( Probieren Sie es online. )

Erläuterung:

  • for 0 .. $_: Für jede ganze Zahl von 0 bis zur Eingabe
  • [*](1 .. $_) xx 2: berechne die Fakultät zweimal,
  • [**] ...: und potenzieren die beiden identischen Fakultäten.
  • [+] ...: Summieren Sie dann alle Ergebnisse der Schleife.

Danke an b2gills für 1 Byte.

smls
quelle
([*] …)kann als [*](…)Speichern eines Bytes geschrieben werden
Brad Gilbert b2gills
3

Cheddar , 44 37 Bytes

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

Vielen Ziegen für die Reduzierung der Betreiber! Ich denke, es wäre eine gute Idee gewesen, Fakultät hinzuzufügen

Probieren Sie es online aus

Ungolfed

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

Erläuterung

Hinweis: Ein wenig veraltet, wird behoben

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
quelle
Ist Gott sei Dank hier nicht ein bisschen anmaßend? : D
flawr
@flawr ok.
Behoben
2
Haha, besser, vielleicht eine der wenigen legitimen Verwendungen von Ziegen, die wir hier kürzlich gesehen haben :)
Fehler
3

MATL , 7 Bytes

Q:Ygt^s

Probieren Sie es online!

Erläuterung

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
quelle
3

PHP, 49 Bytes

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

INF zum n>5 auf einem 64-Bit-System.

für große Zahlen 70 Bytes

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

erfordert, dass PHP kompiliert wird --with-gmp

Titus
quelle
3

Rubin, 64 66 Bytes

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

Es wurden zwei Zeichen für den Bugfix "Off-by-One" hinzugefügt (wird später die Verkürzung der Inject-Aufrufe untersuchen).

DepressedDaniel
quelle
Ich bin nicht gut mit Rubin aber könnten Sie nicht dieses Problem beheben mit a=(0..i)statt a=(1..i)?
Timtech
@ Timtech Expect Einspritzen von Null in eine Multiplikation tut niemandem gut :(
DepressedDaniel
Richtig, ich denke das Hinzufügen +1ist die beste Lösung.
Timtech
@DE Angewandter trivialer Fix für den Fall n = 0.
DepressedDaniel
2

Haskell, 67 56 Bytes

Beachten Sie, dass diese Übermittlung erfolgte, bevor die Regeln zum Verbot von Buildins entfernt wurden.

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

Beispielsweise:

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

Python 2, 73 72 Bytes

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

PARI / GP , 19 Bytes

n->sum(k=0,n,k!^k!)
Charles
quelle
1
War gerade dabei, dies zu posten. Ich bin froh, dass ich zuerst nachgesehen habe.
Primo
2

R, 42 35 Bytes

Nachdem ich die Frage richtig gelesen habe, habe ich die Summe eingegeben.

Dazu muss die gmp- Bibliothek (Multiple Precision Arithmetic) verfügbar sein. Dadurch können große Zahlen verarbeitet werden. Ansonsten kehrt alles über 5 zurück INF.

Dies wird als unbenannte Funktion implementiert, um zu vermeiden as.character, dass eine Ausgabe an STDOUT über erforderlich istcat

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

Beispiellauf

> 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) läuft ziemlich gut, füllt aber eine Reihe von Seiten aus. Ein paar hundert oder so und 2.017.528 Stellen. f (10) beendet die Sitzung auf meinem Computer.

MickyT
quelle
Ich denke, der Grund, warum es anders ist als die anderen Antworten, ist, dass Sie die Summe von 0 zurückgeben sollen! ^ 0! zu N! ^ N !. Dies lässt sich jedoch leicht ändern, indem auf geändert wird factorialZ(0:x). Gibt es einen bestimmten Grund, die base::factorial()Funktion nicht zu verwenden ?
JAD
1
@ JarkoDubbeldam Danke für den Fang. Müssen die Fragen besser lesen :). Ich benutze gmp::factorialZ, um mit den großen Zahlen umzugehen.
MickyT
2

JavaScript (ES7), 38 Byte

f=(n,a=1,i=0)=>i>n?0:a**a+f(n,a*++i,i)
Neil
quelle
@ fəˈnəˈtɪk Entschuldigung, Kraft der Gewohnheit.
Neil
1

Pyke, 11 Bytes

hFSBD]1*B)s

Probieren Sie es hier aus!

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

Lustige Tatsache: Pyke hat keine Fakultät eingebaut, weil SBes nur 2 Bytes sind!

Blau
quelle
1

Haskell, 43 Bytes

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

Anwendungsbeispiel: a 3-> 46662.

bBerechnet ein einzelnes Ultrafaktorielles und asummiert alle Ultrafaktoriellen von 0bis n.

nimi
quelle
1

JavaScript (ES7), 44 Byte

g=n=>n?(f=a=>a?a*f(a-1):1)(n)**f(n)+g(n-1):1
Huntro
quelle
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
sonrad10
quelle
Haben Sie versucht, ein Listenverständnis zusammenzufassen?
Riking
1
Sie haben x nur einmal verwendet, so dass Sie dies verwenden könnten, range(input())um ein paar Bytes zu entfernen
George
1

Wunder , 33 Bytes

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

Verwendung:

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

Erläuterung

rng0+1#0

Inklusivbereich von 0 bis Eingabe erstellen.

->@^ f\prod rng1#0f

Ordnen Sie den Bereich mit einer Funktion zu, die 1) die Fakultät des Elements berechnet, 2) das Ergebnis speichert fund 3) berechnet f^f.

sum

Summe.

Mama Fun Roll
quelle
1

TI-Basic, 13 Bytes

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

PS Sie können ersetzen sum(seq(mit , Σ(wenn Sie ein neueres Betriebssystem haben (keine Größenänderung).

Timtech
quelle
1

GameMaker-Sprache, 97 Byte

Hauptfunktion (52 Bytes)

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

Funktion f (45 Bytes)

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

Ruby 2, 41 Bytes

->n{(1..n).reduce(s=1){|t,i|t+(s*=i)**s}}
Lee W
quelle
Genial! Sehr geschickt in der Art und Weise, wie es gleichzeitig initialisiert wird sund als Anfangswert tzum Reduzieren / Injizieren übergeben wird.
DepressedDaniel
Kann ein weiterer Charakter zum Golfspielen ->n{((t=s=1)..n).map{|i|t+=(s*=i)**s};t}oder->n{t=s=1;(1..n).map{|i|t+=(s*=i)**s};t}
DepressedDaniel
1

Dyalog APL, 10 Bytes

(+/!*!)0,⍳

Wie?

⍳ Eingabebereich

0, vorangestellt mit 0

!*! sich bewerben x! ^ x!

+/ Summe

Uriel
quelle
*und !sind skalare Funktionen, verwenden Sie also Arrays: +/*⍨!0,⍳⎕oder (+/!*!)0,⍳wenn Sie wirklich einen Zug wollen.
Adám
0

Mathematica, 19 Bytes

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

Anonyme Funktion. Nimmt eine Zahl als Eingabe und gibt eine Zahl als Ausgabe zurück.

LegionMammal978
quelle
1
Wir können keine eingebauten Fakultäten oder Potenzierungen verwenden.
Downgoat
0

Brachylog , 12 Bytes

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

Probieren Sie es online!

Erläuterung

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
Tödlich
quelle
0

79 Bytes mit Konsolenausgabe

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

64 Bytes als Rückgabe

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

Eigentlich 11 10 Bytes

1+r`!;ⁿ`MΣ

Wie es funktioniert

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
Blaugrüner Pelikan
quelle
0

Schläger 54 Bytes

(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))))

Testen: 

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

Ausgabe: 

0
1
2
6
46662
rnso
quelle