Angka besar: Ultrafactorials

25

Pertanyaan ini dikerjakan ulang, harap baca kembali.

Ultrafactorials

Ultrafactorials adalah urutan angka yang dapat dihasilkan menggunakan fungsi berikut:

a(n) = n! ^ n!

Nilai yang dihasilkan naik sangat cepat. Catatan: Ini adalah entri A046882 di OEIS. Juga terkait adalah hyperfactorials, yang masih cukup besar, tetapi urutan yang sedikit lebih kecil: A002109

Tugas Anda

Tugas Anda adalah mengimplementasikan angka-angka ini ke dalam bahasa Anda. Program Anda akan menghitung jumlah semua ultrafactorial mulai dari 0 hingga inklusif n .

Memasukkan

Program Anda hanya dapat mengambil satu input: angka, yang menyerupai terakhir (n) ultrafactorial yang akan ditambahkan ke penjumlahan. Input dipastikan positif atau 0.

Keluaran

Output Anda terserah Anda, selama ada jumlah angka yang terlihat di suatu tempat.

Aturan

  • Anda dapat mengasumsikan semua bilangan bulat, oleh karena itu input bilangan bulat, dan menggunakan loop penghitungan bilangan bulat untuk menghasilkan beberapa hasil.

Uji kasus

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

Tantangan

Ini adalah , jadi jawabannya dengan panjang byte terkecil menang!

lebih kaya
sumber
2
Apakah kita perlu mempertimbangkan bilangan bulat besar yang sewenang-wenang? Atau apakah cukup untuk menangani yang terbesar yang doubledidukung oleh tipe data default bahasa (seperti )?
Luis Mendo
1
Konversi dalam-kode dan output terserah Anda, Input akan menjadi bilangan bulat. @LuisMendo
devRicher
3
Mengubah aturan setelah banyak orang menjawab juga bukan hal yang baik untuk dilakukan. Silakan gunakan Sandbox seperti yang disarankan setiap kali Anda ingin mengirimkan tantangan.
flawr

Jawaban:

7

05AB1E , 5 byte

Kode:

Ý!DmO

Penjelasan:

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

Menggunakan pengkodean CP-1252 . Cobalah online!

Adnan
sumber
L!DmOjuga berfungsi jika Anda ingin melepas bit "CP-1252 encoding".
Magic Gurita Guci
16

Mathematica, 19 byte

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

Permintaan maaf untuk kode yang sangat jelas;)

Greg Martin
sumber
Menggunakan Mathematica untuk Mathematica - dick move: D
Transcendental
8

Jelly, 6 byte

Cobalah 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
sumber
Ada atom kenaikan ,, jadi R!*`S‘simpan satu byte (saya memilih ‘Ḷ!*`S).
Jonathan Allan
1
Saya sebenarnya sedang mengedit sebelum saya melihat komentar Anda: P
Xanderhall
Saya juga melihat itu, kerja bagus.
Jonathan Allan
6

R - 34 30 byte

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

membuat vektorisasi itu bagus

sunting: disimpan 4 byte berkat @MickyT

bouncyball
sumber
1
Anda dapat mempersingkatnya sedikit dengan menggerakkan Anda memindai ke faktorialx=factorial(0:scan());sum(x^x)
MickyT
4

J, 15 12 byte

Disimpan 3 byte berkat mil!

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

Penjelasan

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

Uji kasus

   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
sumber
1#.i.^~@!@,]memotong beberapa byte lagi.
mil
@miles Oh, keren. Saya tidak tahu 1#.melakukan penjumlahan. Jika itu bukan tip, Anda harus menambahkannya!
Conor O'Brien
4

Perl 6 , 41 38 37 byte

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

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

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

( Cobalah online. )

Penjelasan:

  • for 0 .. $_: Untuk setiap integer dari 0 hingga input,
  • [*](1 .. $_) xx 2: hitung faktorial dua kali,
  • [**] ...: dan eksponensial dua faktorial yang identik.
  • [+] ...: Lalu jumlah semua hasil dari loop.

Berkat b2gills untuk 1 byte.

seseorang
sumber
([*] …)dapat ditulis sebagai [*](…)tabungan byte
Brad Gilbert b2gills
3

Cheddar , 44 37 byte

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

Terima kasih kambing untuk operator yang berkurang! Saya pikir akan lebih baik untuk menambahkan faktorial

Cobalah online

Tidak disatukan

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

Penjelasan

Catatan: Sedikit ketinggalan jaman, akan diperbaiki

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
sumber
Bukankah terima kasih tuhan sedikit sombong di sini? : D
flawr
@ flawr ok. Diperbaiki: P
Downgoat
2
Haha, lebih baik, mungkin salah satu dari beberapa penggunaan kambing yang sah yang pernah kita lihat di sini baru-baru ini :)
flawr
3

MATL , 7 byte

Q:Ygt^s

Cobalah online!

Penjelasan

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

PHP, 49 byte

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

INFuntuk n>5pada sistem 64 bit.

untuk jumlah besar, 70 byte

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

membutuhkan PHP untuk dikompilasi --with-gmp

Titus
sumber
3

Rubi, 64 66 byte

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

Menambahkan dua karakter untuk perbaikan bug off-by-one (akan mencari cara memperpendek panggilan injeksi nanti).

DepresiDaniel
sumber
Aku tidak baik dengan Ruby tapi tidak bisa Anda memperbaiki ini dengan a=(0..i)bukan a=(1..i)?
Timtech
@Timtech Harapkan menyuntikkan nol ke dalam perkalian tidak ada gunanya bagi siapa pun :(
DepressedDaniel
Benar, saya kira menambahkan +1adalah solusi terbaik.
Timtech
@GB Perbaikan sepele yang diterapkan untuk n = 0 case.
DepressedDaniel
2

Haskell, 67 56 byte

Perhatikan bahwa pengajuan ini dibuat sebelum aturan yang melarang builtin dihapus.

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

Sebagai contoh:

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

Python 2, 73 72 byte

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

PARI / GP , 19 byte

n->sum(k=0,n,k!^k!)
Charles
sumber
1
Baru saja memposting ini. Senang saya periksa dulu.
primo
2

R, 42 35 byte

Sekarang saya sudah membaca pertanyaan dengan benar, saya telah memasukkan jumlahnya.

Ini membutuhkan pustaka gmp (multiple precision arithmetic) untuk tersedia. Ini memungkinkan penanganan sejumlah besar. Jika tidak, apapun yang melebihi 5 pengembalian INF.

Ini diimplementasikan sebagai fungsi yang tidak disebutkan namanya untuk menghindari as.characteryang akan diperlukan untuk output ke STDOUT melaluicat

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

Contoh dijalankan

> 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) akan berjalan cukup baik, tetapi mengisi sejumlah halaman. Beberapa ratus atau lebih dan 2.017.528 digit. f (10) membunuh sesi di mesin saya.

MickyT
sumber
Saya pikir alasannya berbeda dari jawaban lain adalah karena Anda seharusnya mengembalikan jumlah dari 0! ^ 0! ke N! ^ N !. Tapi ini mudah diubah dengan mengubah ke factorialZ(0:x). Apakah ada alasan khusus untuk tidak menggunakan base::factorial()fungsi ini?
JAD
1
@JarkoDubbeldam Terima kasih atas tangkapannya. Perlu membaca pertanyaan dengan lebih baik :). Saya menggunakan gmp::factorialZuntuk menangani angka-angka besar.
MickyT
2

JavaScript (ES7), 38 byte

f=(n,a=1,i=0)=>i>n?0:a**a+f(n,a*++i,i)
Neil
sumber
@ fəˈnɛtɪk Maaf, kekuatan kebiasaan.
Neil
1

Pyke, 11 byte

hFSBD]1*B)s

Coba di sini!

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

Fakta menyenangkan: Pyke tidak memiliki faktorial bawaan karena SBhanya 2 byte!

Biru
sumber
1

Haskell, 43 byte

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

Contoh penggunaan: a 3-> 46662.

bmenghitung satu ultrafactorial dan amenjumlahkan semua ultrafactorial dari 0ke n.

nimi
sumber
1

JavaScript (ES7), 44 byte

g=n=>n?(f=a=>a?a*f(a-1):1)(n)**f(n)+g(n-1):1
Huntro
sumber
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
sumber
Sudahkah Anda mencoba menjumlahkan pemahaman daftar?
Bersepeda
1
Anda hanya menggunakan x satu kali, jadi Anda bisa menggunakan range(input())ini akan menghapus beberapa byte
george
1

Bertanya-tanya , 33 byte

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

Pemakaian:

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

Penjelasan

rng0+1#0

Buat rentang inklusif dari 0 hingga input.

->@^ f\prod rng1#0f

Peta pada rentang dengan fungsi yang 1) menghitung faktorial item, 2) menyimpan hasilnya f, dan 3) menghitung f^f.

sum

Jumlah.

Mama Fun Roll
sumber
1

TI-Basic, 13 byte

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

PS Anda dapat mengganti sum(seq(dengan Σ(jika Anda memiliki sistem operasi yang lebih baru (tidak ada perubahan ukuran).

Timtech
sumber
1

Bahasa GameMaker, 97 byte

Fungsi utama (52 byte)

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

Fungsi f (45 byte)

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

Ruby 2, 41 byte

->n{(1..n).reduce(s=1){|t,i|t+(s*=i)**s}}
Lee W
sumber
Luar biasa! Sangat pintar cara menginisialisasi spada saat yang sama dengan melewatkannya sebagai nilai awal tuntuk mengurangi / menyuntikkan.
DepressedDaniel
Dapat bermain golf satu karakter lagi ke ->n{((t=s=1)..n).map{|i|t+=(s*=i)**s};t}atau->n{t=s=1;(1..n).map{|i|t+=(s*=i)**s};t}
DepressedDaniel
1

Dyalog APL, 10 byte

(+/!*!)0,⍳

Bagaimana?

rentang input

0, didahului dengan 0

!*! menerapkan x! ^ x!

+/ jumlah

Uriel
sumber
*dan !merupakan fungsi skalar, jadi gunakan array: +/*⍨!0,⍳⎕atau (+/!*!)0,⍳jika Anda benar-benar menginginkan kereta.
Adám
0

Mathematica, 19 byte

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

Fungsi anonim. Mengambil nomor sebagai input, dan mengembalikan nomor sebagai output.

LegionMammal978
sumber
1
Kita tidak dapat menggunakan built-in faktorial atau eksponensial.
Downgoat
0

Brachylog , 12 byte

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

Cobalah online!

Penjelasan

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
Fatalisasi
sumber
0

C #, 79 byte dengan output konsol

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

C #, 64 byte sebagai pengembalian

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

Sebenarnya 11 10 byte

1+r`!;ⁿ`MΣ

Bagaimana itu bekerja

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
Pelican teal
sumber
0

Racket 54 byte

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

Tidak Disatukan:

#lang racket
(require math)

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

Pengujian:

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

Keluaran:

0
1
2
6
46662
juga
sumber