বড় সংখ্যা: আল্ট্রাফ্যাক্টোরিয়ালস


25

এই প্রশ্নটি পুনরায় কাজ করা হয়েছিল, দয়া করে এটি পুনরায় পড়ুন।

Ultrafactorials

আল্ট্রাফ্যাকটোরিয়ালগুলি সংখ্যার ক্রম যা নিম্নলিখিত ফাংশনটি ব্যবহার করে তৈরি করা যেতে পারে:

a(n) = n! ^ n!

ফলস্বরূপ মানগুলি খুব দ্রুত বৃদ্ধি পায়। পার্শ্ব দ্রষ্টব্য: এটি OEIS এ A046882 এ প্রবেশ । হাইপোফ্যাক্টরিয়ালগুলি সম্পর্কিত, এটি এখনও বেশ বিশাল, তবে কিছুটা ছোট ক্রম: A002109

তোমার কাজ

আপনার কাজটি হ'ল এই সংখ্যাগুলি আপনার ভাষায় প্রয়োগ করা। আপনার প্রোগ্রামটি 0 থেকে সমস্ত সমেত আল্ট্রাফ্যাক্টরিয়ালগুলির যোগফল গণনা করবে n

ইনপুট

আপনার প্রোগ্রামটি কেবল একটি ইনপুট নিতে পারে: একটি সংখ্যা, যা যোগফলের জন্য শেষের (এন) আল্ট্রাফ্যাক্টোরিয়ালটির অনুরূপ। ইনপুটটি ইতিবাচক বা 0 হওয়ার আশ্বাস দেওয়া হয়েছে।

আউটপুট

আপনার আউটপুটটি সমস্ত আপনার উপর নির্ভর করে যতক্ষণ না কোথাও সংখ্যার দৃশ্যমান যোগ থাকে।

বিধি

  • আপনি সমস্ত পূর্ণসংখ্যার ধরে নিতে পারেন, অতএব পূর্ণসংখ্যার ইনপুট এবং কিছু ফলাফল তৈরি করতে পূর্ণসংখ্যার গণনা লুপগুলি ব্যবহার করে।

পরীক্ষার মামলা

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

চ্যালেঞ্জ

এটি , তাই বাইটস জিতে ন্যূনতম দৈর্ঘ্যের উত্তর!


2
আমাদের কি নির্বিচারে বড় পূর্ণসংখ্যার বিবেচনা করা দরকার? বা ভাষার ডিফল্ট ডেটা টাইপ (যেমন double) সমর্থন করে এমন বৃহত্তমটিকে পরিচালনা করার পক্ষে কি যথেষ্ট ?
লুইস মেন্ডো

1
কোড-এবং আউটপুট রূপান্তরটি আপনার উপর নির্ভর করে, ইনপুটটি যদিও পূর্ণসংখ্যা হবে। @ লুইসমেন্দো
ডিভ্রিচার

3
অনেক লোক উত্তর দেওয়ার পরেও নিয়ম পরিবর্তন করা খুব ভাল জিনিস নয়। আপনি যখনই কোনও চ্যালেঞ্জ জমা দিতে চান দয়া করে পরামর্শ হিসাবে স্যান্ডবক্সটি ব্যবহার করুন ।
flawr

উত্তর:


7

05 এ বি 1 ই , 5 বাইট

কোড:

Ý!DmO

ব্যাখ্যা:

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

সিপি -1222 এনকোডিং ব্যবহার করে । এটি অনলাইন চেষ্টা করুন!


L!DmOআপনি যদি "সিপি -১২২২ এনকোডিং" বিটটি বন্ধ করতে চান তবে এটিও কাজ করে।
যাদু অক্টোপাস উরন


8

জেলি, 6 বাইট

এটি অনলাইন চেষ্টা করুন!

‘Ḷ!*`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!*`S‘একটি বাইট সংরক্ষণ করুন (আমি গিয়েছিলাম ‘Ḷ!*`S)।
জোনাথন অ্যালান

1
আমি আপনার মন্তব্যটি দেখার আগে আমি সম্পাদনার মাঝখানে ছিলাম: পি
জ্যান্সারহাল

আমিও তা দেখেছি, ভাল কাজ।
জোনাথন অ্যালান

6

আর - 34 30 বাইট

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

ভেক্টরাইজিং দুর্দান্ত

সম্পাদনা: @ মিকিটি ধন্যবাদ 4 বাইট সংরক্ষিত


1
ফ্যাকটোরিয়ালটিতে স্ক্যান চালিয়ে আপনি এটিকে কিছুটা ছোট করতে পারেনx=factorial(0:scan());sum(x^x)
মিকিটি

4

জে, 15 12 বাইট

মাইল 3 বাইট সংরক্ষণ করা হয়েছে!

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

ব্যাখ্যা

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

পরীক্ষার মামলা

   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

1#.i.^~@!@,]আরও কয়েক বাইট বন্ধ শেভ
মাইল

@ মাইল ওহ, দুর্দান্ত আমি জানতাম না 1#.সংক্ষেপণ সম্পাদন। যদি এটি ইতিমধ্যে কোনও টিপ না হয় তবে আপনার অবশ্যই এটি যুক্ত করা উচিত!
কনর ও'ব্রায়েন

4

পার্ল 6 , 41 38 37 বাইট

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

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

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

( এটি অনলাইনে চেষ্টা করুন। )

ব্যাখ্যা:

  • for 0 .. $_: ইনপুট থেকে প্রতিটি পূর্ণসংখ্যার জন্য,
  • [*](1 .. $_) xx 2: ঘটনাচক্রে দুবার গণনা করুন,
  • [**] ...: এবং দুটি অভিন্ন ফ্যাক্টরিওলটি ব্যাখ্যা করুন।
  • [+] ...: তারপরে লুপের সমস্ত ফলাফলের যোগফল দিন।

1 বাইটের জন্য বি 2 গিলসকে ধন্যবাদ।


([*] …)[*](…)একটি বাইট সংরক্ষণ হিসাবে রচনা করা যেতে পারে
ব্র্যাড গিলবার্ট বি 2 গিল

3

চেডার , 44 37 বাইট

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

অপারেটর হ্রাস করার জন্য ছাগলকে ধন্যবাদ! আমি মনে করি ফ্যাকটোরিয়াল যুক্ত করা ভাল ধারণা ছিল

এটি অনলাইনে চেষ্টা করুন

Ungolfed

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

ব্যাখ্যা

দ্রষ্টব্য: কিছুটা পুরানো, ঠিক হয়ে যাবে

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

এখানে কি god শ্বরকে কিছুটা অহংকার করে বলা হয় না? : ডি
flawr

@ ফ্লোয়ার ঠিক আছে স্থির: পি
ডাউনগোট

2
হাহাহা, ভাল, সম্ভবত আমরা এখানে আশেপাশে দেখেছি ছাগলের কয়েকটি বৈধ ব্যবহারের মধ্যে একটি :)
flawr


3

পিএইচপি, 49 বাইট

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

INFজন্য n>564 বিট সিস্টেমে।

বড় সংখ্যা, 70 বাইট জন্য

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

পিএইচপি সঙ্গে সংকলন করা প্রয়োজন --with-gmp


3

রুবি, 64 66 বাইট

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

অফ-বাই-ওয়ান বাগফিক্সের জন্য দুটি অক্ষর যুক্ত হয়েছে (পরে ইনজেক্ট কলগুলি সংক্ষিপ্ত করে দেখবে)।


আমি রুবির সাথে ভাল না কিন্তু এর a=(0..i)পরিবর্তে আপনি কি এটি ঠিক করতে পারবেন না a=(1..i)?
টিমটেক

@ টিমটেক প্রত্যাশা শূন্যকে একটি গুণে ইনজেকশনের মাধ্যমে কারও মঙ্গল হয় না :(
হতাশ

ঠিক আছে, আমি অনুমান করি যোগ +1করা ভাল সমাধান।
টিমটেক

@ জিবি এন = 0 কেসের ক্ষেত্রে তুচ্ছ সমাধান প্রয়োগ করেছে।
ডিপ্রেশনডানিয়েল


2

হাস্কেল, 67 56 বাইট

নোট করুন যে বিল্টিনগুলি নিষিদ্ধ করা হয়েছে এমন নিয়মগুলি সরানোর আগে এই জমা দেওয়া হয়েছিল ।

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

উদাহরণ স্বরূপ:

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

2

পাইথন 2, 73 72 বাইট

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


2

আর, 42 35 বাইট

এখন যেহেতু আমি প্রশ্নটি সঠিকভাবে পড়েছি, আমি যোগফলটি রেখেছি।

এর জন্য জিএমপি (একাধিক নির্ভুল গণিত) লাইব্রেরি উপলব্ধ থাকতে হবে। এটি বিশাল সংখ্যককে পরিচালনা করার অনুমতি দেয়। অন্যথায় 5 টিরও বেশি কিছু ফেরত দেয় INF

এটি একটি নামবিহীন ফাংশন হিসাবে বাস্তবায়িত হয় যাতে এটিকে as.characterSTDOUT এ আউটপুট দেওয়ার প্রয়োজন হবেcat

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

উদাহরণ রান

> 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) বেশ ভাল চলবে তবে বেশ কয়েকটি পৃষ্ঠা পূরণ করে। কয়েকশত বা তার বেশি এবং 2,017,528 সংখ্যা। f (10) আমার মেশিনে সেশনটি মেরে ফেলেছে।


আমি মনে করি যে অন্যান্য উত্তরগুলির তুলনায় এর ভিন্ন কারণ কারণ আপনি 0 থেকে return 0 থেকে যোগফলটি প্রত্যাশিত! টু এন! ^ এন! তবে এটিকে পরিবর্তন করে সংশোধন করা সহজ factorialZ(0:x)base::factorial()ফাংশনটি ব্যবহার না করার কোনও নির্দিষ্ট কারণ আছে ?
জেএডি

1
@ জারকো ডাবডেলডাম ধরা পড়ার জন্য ধন্যবাদ প্রশ্নগুলি আরও ভাল পড়া দরকার :)। আমি gmp::factorialZবড় সংখ্যা হ্যান্ডেল করতে ব্যবহার করছি ।
মিকিটি

2

জাভাস্ক্রিপ্ট (ES7), 38 বাইট

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

@ fəˈnɛtɪk দুঃখিত, অভ্যাসের বল।
নীল

1

পাইকে, 11 বাইট

hFSBD]1*B)s

এখানে চেষ্টা করুন!

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

মজাদার ঘটনা: পাইকের কোনও অন্তর্নির্মিত ফ্যাক্টরিয়াল নেই কারণ SBএটি কেবলমাত্র 2 বাইট!


1

হাস্কেল, 43 বাইট

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

ব্যবহারের উদাহরণ: a 3-> 46662

bএকটি একক ultrafactorial হিসাব এবং aসকল ultrafactorials অঙ্কের 0করতে n


1

জাভাস্ক্রিপ্ট (ES7), 44 বাইট

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

1

পাইথন 2, 82 বাইট

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

আপনি কি একটি তালিকা বোঝার সংক্ষিপ্তসার চেষ্টা করেছেন?
Riking

1
আপনি শুধুমাত্র এক্স একবার ব্যবহার করেছি, যাতে আপনি ব্যবহার করতে পারে range(input())এটি কয়েক বাইট মুছে ফেলা হবে
জর্জ

1

আশ্চর্য , 33 বাইট

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

ব্যবহার:

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

ব্যাখ্যা

rng0+1#0

0 থেকে ইনপুট পর্যন্ত অন্তর্ভুক্তিমূলক সীমা তৈরি করুন।

->@^ f\prod rng1#0f

1) আইটেমের ফ্যাক্টরিয়াল গণনা করে, 2) ফলাফল সংরক্ষণ করে fএবং 3) গণনা করে এমন একটি ক্রিয়াকলাপের সাথে পরিসীমাটির উপরে মানচিত্র f^f

sum

সমষ্টি।


1

টিআই-বেসিক, 13 বাইট

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

পিএস আপনি নতুন অপারেটিং সিস্টেম (আকার পরিবর্তন না) থাকলে এর sum(seq(সাথে প্রতিস্থাপন করতে Σ(পারেন।


1

গেমমেকার ল্যাঙ্গুয়েজ, 97 বাইট

প্রধান ফাংশন (52 বাইট)

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

ফাংশন চ (45 বাইট)

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

1

রুবি 2, 41 বাইট

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

অসাধারণ! sএটি tহ্রাস / ইনজেকশন হিসাবে প্রাথমিক মান হিসাবে এটি পাস করার একই সময়ে এটি যেভাবে চালিত হয় খুব চালাক ।
ডিপ্রেশনডানিয়েল

আরও একটি চরিত্র golfed যাবে ->n{((t=s=1)..n).map{|i|t+=(s*=i)**s};t}বা->n{t=s=1;(1..n).map{|i|t+=(s*=i)**s};t}
DepressedDaniel

1

ডায়ালগ এপিএল, 10 বাইট

(+/!*!)0,⍳

কিভাবে?

ইনপুট পরিসীমা

0, 0 এর সাথে পূর্ববর্তী

!*! প্রয়োগ করা x! ^ x!

+/ সমষ্টি


*এবং !স্কেলার ফাংশন, তাই অ্যারে ব্যবহার করুন: +/*⍨!0,⍳⎕বা (+/!*!)0,⍳যদি আপনি সত্যিই কোনও ট্রেন চান।
অ্যাডম

0

গণিত, 19 বাইট

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

বেনামে ফাংশন। ইনপুট হিসাবে একটি সংখ্যা নেয় এবং আউটপুট হিসাবে একটি নম্বর প্রদান করে।


1
আমরা ফ্যাকটোরিয়াল বা ক্ষতিকারক অন্তর্নির্মিত ব্যবহার করতে পারি না।
ডাউনওয়েট


0

কনসোল আউটপুট সহ সি #, 79 বাইট

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

রিটার্ন হিসাবে সি #, 64 বাইট

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

0

আসলে 11 10 বাইট

1+r`!;ⁿ`MΣ

কিভাবে এটা কাজ করে

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

0

রেকেট 54 বাইট

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

পরীক্ষামূলক:

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

আউটপুট:

0
1
2
6
46662
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.