ফ্যাক্টরিয়াল ডিজিটের যোগফল


25

চ্যালেঞ্জটি হ'ল সংখ্যার ফ্যাকটোরিয়ালটির অঙ্কের অঙ্ক গণনা করা।


উদাহরণ

Input: 10
Output: 27

10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800, এবং 10 সংখ্যাতে অঙ্কগুলির যোগফল! 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27

আপনি ইনপুটটি 0 এর উপরে একটি পূর্ণসংখ্যা হিসাবে আশা করতে পারেন আউটপুট কোনও প্রকারের হতে পারে, তবে উত্তর কোডিং ভাষার মান ভিত্তিতে হওয়া উচিত।


পরীক্ষার কেস:

10    27
19    45
469   4140
985   10053

এনবি কিছু ভাষা 32-বিট পূর্ণসংখ্যার উপরে বৃহত সংখ্যক সমর্থন করতে পারে না; এই ভাষাগুলির জন্য আপনার কাছে বড় ফ্যাকটোরিয়াল গণনা করা হবে না।

ওইআইএস লিঙ্কটি এখানে মার্টিন ইন্ডারকে ধন্যবাদ জানায়


এটি , তাই অক্ষরগুলির মধ্যে সংক্ষিপ্ততম কোডটি জয়ী!


প্রত্যাশায় সর্বাধিক ইনপুট নম্বরটি কী? আর-তে 32-বিট সংখ্যার পূর্ণসংখ্যার সাহায্যে এই চ্যালেঞ্জটি সঠিকভাবে অতীত সমাধান করা যায় নাn>21
বিলিউব

1
@Billywob জন্য R তারপর আপনি শুধুমাত্র 20 যেতে আমি এই প্রতিফলিত করার প্রশ্নটিকে সম্পাদনা হইবে প্রয়োজন হবে
জর্জ

উত্তর:




8

গণিত, 21 বাইট

Tr@IntegerDigits[#!]&

4
এই সঠিক অক্ষর টাইপ করতে এখানে এসেছেন।
মাইকেল স্টারন

কেন [#!]এবং না @#!? (গণিত
নুব

1
@ কোয়েসের @চেয়ে এর চেয়ে বেশি অগ্রাধিকার রয়েছে !
মার্টিন ইন্ডার

7

সি ++ 11, 58 বাইট

নামবিহীন ল্যাম্বদা হিসাবে এর ইনপুটটি সংশোধন করছে:

[](int&n){int i=n;while(--n)i*=n;do n+=i%10;while(i/=10);}

বিরল ক্ষেত্রে এক যখন আমার সি ++ কোড চেয়ে খাটো সি কোড

আপনি যদি বড় আকারের কেস সাপোর্ট করতে চান তবে সি ++ 14 এ স্যুইচ করুন এবং ব্যবহার করুন:

[](auto&n){auto i=n;while(--n)i*=n;do n+=i%10;while(i/=10);}

এবং ullপ্রত্যয় দিয়ে কলিং যুক্তি সরবরাহ করে supply

ব্যবহার:

auto f=
[](int&n){int i=n;while(--n)i*=n;do n+=i%10;while(i/=10);}
;

main() {
  int n=10;
  f(n);
  printf("%d\n",n);
}

7

রুবি, 63 61 53 38 বাইট

মানচিত্রের জন্য নতুন পদ্ধতির ধন্যবাদ:

->n{eval"#{(1..n).reduce:*}".chars*?+}

পুরানো:

->n{(1..n).reduce(:*).to_s.chars.map(&:hex).reduce:+}
  • -3 বাইটস মার্টিন ইন্ডারকে ধন্যবাদ
  • জিবি -5 বাইট ধন্যবাদ

1
পুরাতন বিরক্তিকর evalপথ: ->n{eval"#{(1..n).reduce:*}".chars*?+}
manatwork

6

পাইথ, 7 6 বাইট

আমাকে বাইট বাঁচানোর জন্য @ কেডকে ধন্যবাদ

sj.!QT

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

পাইথ ব্যবহারের এটি আমার প্রথমবার, তাই আমি নিশ্চিত যে আমার উত্তরটি বেশ খানিকটা গল্ফ হতে পারে।

ব্যাখ্যা:

s Sum
  j the digits of
    .! the factorial of
      Q the input
    T in base 10

1
10একটি পরিবর্তনশীল হিসাবে বরাদ্দ করা হয়েছে T, যাতে আপনি এটি তৈরি করতে পারেন sj.!QT:)
কেড

ঠিক আছে ধন্যবাদ! আমি এটি যুক্ত করব
BookOwl

নিস! ssM`.!কাজটিও 6 বাইটে করে।
hakr14

5

হাস্কেল, 41 40 বাইট

f x=sum$read.pure<$>(show$product[1..x])

ব্যবহারের উদাহরণ: f 985-> 10053

থেকে একটি তালিকা তৈরি করুন 1থেকে xতালিকা উপাদানের পণ্য নিরূপণ, এটা তার স্ট্রিং উপস্থাপনা পরিণত হচ্ছে, একটি সংখ্যা মধ্যে প্রতিটি অক্ষর চালু এবং তাদের যোগফল।

সম্পাদনা করুন: @ অংগুলি একটি বাইট সংরক্ষণ করেছে। ধন্যবাদ!


f x=sum$read.pure<$>(show$product[1..x])একটি বাইট সংরক্ষণ করুন
অ্যাঙ্গস

5

পাইথন, 54 বাইট

f=lambda n,r=1:n and f(n-1,r*n)or sum(map(int,str(r)))

repl.it


আমি ঠিক যে দেখায় এই সামান্য খারাপ সংস্করণ নিয়ে এসেছেন পথ খুব অনুরূপ এটি একটি পৃথক উত্তর হতে পারে। ব্র্যাভো
ওসুকা_

5

আর, 58 53 বাইট

সম্পাদনা: @ জোনাথন ক্যারল এবং একক দম্পতি @ মিকি টি কে ধন্যবাদ একটি বাইট সংরক্ষিত

sum(as.double(el(strsplit(c(prod(1:scan()),""),""))))

দুর্ভাগ্যক্রমে, 32-বিট পূর্ণসংখ্যার সাথে, এটি কেবল এর জন্য কাজ করে n < 22। স্টিডিন এবং আউটপুট থেকে স্টডআউটে ইনপুট নেয়।

যদি কেউ উচ্চ স্তরের যথাযথতা চান তবে একটিকে কিছু বাহ্যিক গ্রন্থাগার ব্যবহার করতে হবে যেমন Rmpfr:

sum(as.numeric(el(strsplit(paste(factorial(Rmpfr::mpfr(scan()))),""))))

1
আপনার ঠিক মতো উত্তরটি আমি পৌঁছেছি, তারপরে c(x,"")বনাম paste(x): এ 1-বাইট লাভ পেয়েছি sum(as.integer(el(strsplit(c(factorial(scan()),""),""))))। বর্ণনামূলক ফলাফলকে চরিত্রের দিকে নিয়ে যায় এবং strsplitএটি দ্বিতীয় তালিকার হিসাবে ফেরত দেয়, তাই elএখনও কাজ করে এবং প্রথম তালিকার উপাদানগুলি বের করে।
জোনাথন ক্যারল

2
কীভাবে prod(1:scan())?
মিকিটি

1
এছাড়াও as.double যথেষ্ট হবে
মিকিটি

@ মিকিটি ধন্যবাদ! আপডেট করা হয়েছে।
বিলিউব

strtoiএকটি ছোট প্রতিস্থাপন হিসাবে কাজ করে as.double, আমি মনে করি।
জিউসেপে

4

পিপ , 8 বাইট

$+$*++,a

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

ব্যাখ্যা

      ,a    # range
    ++      # increment
  $*        # fold multiplication
$+          # fold sum

দুঃখিত, আমি আসলে আপনার আগে একটি 05AB1E উত্তর পোস্ট করতে পেরেছি;)।
ম্যাজিক অক্টোপাস উরান

2
@ কারাসোকম্পুটিং: হিহে। আমাকে একটি নতুন ভাষায় দেখার সুযোগ পেয়েছে :)
এমিগানা

1
আমি মনে করি যে আপনি ছাড়া আমি প্রথম একজন নন-বহুভক্ত কোড গল্ফ উত্তরের জন্য পাইপ ব্যবহার করবেন। : ডি
ডিএলকস



3

জাভা 7, 148 বাইট

int s=1,ret=0;while(i>1){s=s*i; i--;}String y=String.valueOf(s);for(int j=0;j<y.length();j++){ret+=Integer.parseInt(y.substring(j,j+1));}return ret;

@ আইয়াললাইভ প্রশ্নের কোন সীমা নির্দিষ্ট করা নেই। 9,223,372,036,854,775,807 এর চেয়ে বড় একটি ফ্যাক্টরিয়াল পরিচালনা করার জন্য আপনি কীভাবে প্রত্যাশা করছেন?
জ্যাকসোনাক

3

রুবি, 63 60 53 51 বাইট

->n{a=0;f=(1..n).reduce:*;f.times{a+=f%10;f/=10};a}

গল্ফ সাহায্যের জন্য মার্টিনকে ধন্যবাদ।


3

পুশি , 4 বাইট

fsS#

কমান্ড লাইন ইনপুট দিন: $ pushy facsum.pshy 5। এখানে ভাঙ্গন:

f      % Factorial of input
 s     % Split into digits
  S    % Push sum of stack
   #   % Output

3

অক্টোটা, 30 বাইট

@(n)sum(num2str(prod(1:n))-48)

তালিকার পণ্যটি গ্রহণ করে ফ্যাক্টরিয়াল গণনা করে [1 2 ... n]। এটিকে একটি স্ট্রিংয়ে রূপান্তর করে এবং 48সমস্ত উপাদান থেকে বিয়োগ করে (এর জন্য ASCII কোড 0)। শেষ পর্যন্ত এটির যোগফল :)


3

বাশ (সিক, বিসি, ভাঁজ, জেকিউ), 34 33 বাইট

অবশ্যই সবচেয়ে মার্জিত নয় তবে চ্যালেঞ্জের জন্য

seq -s\* $1|bc|fold -1|jq -s add

fold -1একটি বাইট সংরক্ষণ করে।
ডিজিটাল ট্রমা

@ ডিজিটালট্রামা সংশোধন! ধন্যবাদ
আদম

3

সি, 58 বাইট

এটি নিখুঁত নয়। কেবলমাত্র কাজ করে কারণ শুরুতে -1 হতে হবে। ধারণাটি হ'ল এক ফাংশনে দুটি পুনরাবৃত্তি ফাংশন ব্যবহার করা। আমি প্রথম চিন্তা হিসাবে এটি সহজ ছিল না।

a=-1;k(i){a=a<0?i-1:a;return a?k(i*a--):i?i%10+k(i/10):0;}

ব্যবহার এবং বোধগম্য বিন্যাস:

a = -1;
k(i){
   a = a<0 ? i-1 : a;
   return a ? k(i*a--) : i? i%10+k(i/10) :0;
}

main() {
   printf("%d\n",k(10));
}

সম্পাদনা: আমি এমন মেঠোড পেয়েছি যা এই ফাংশনটিকে একাধিক সময় ব্যবহার করতে দেয় তবে তার দৈর্ঘ্য 62 বাইট।

a,b;k(i){a=b?a:i+(--b);return a?k(i*a--):i?i%10+k(i/10):++b;}

ভাল ধারণা, তবে আমি কেন পুরোপুরি বুঝতে পারছি না যে কোনও ফাংশনটি ফ্যাক্টরিয়াল ফিরিয়ে দেওয়ার জন্য এবং অন্যটি (বি (10)) এর মতো অঙ্কের যোগফল গণনা করার জন্য কেন কম হবে না। "রিটার্ন" শব্দটির কাজটি কি খুব দীর্ঘ?
জলি জোকার

রিটার্ন অনেক খায়। আমি অবশ্যই চেষ্টা করি। হয়তো কেউ এটি করতে পারে কমপক্ষে আমি সেই কাজটি পেতে পারি নি
টেকস্টুরি

1
কয়েকটি বাইট সংরক্ষণ করতে আপনি দুটি আর্গুমেন্ট গ্রহণ করতে পারেন: কোডগল্ফ.সটাকেক্সচেঞ্জ.com
153132

3

পার্ল 6 , 21 বাইট

{[+] [*](2..$_).comb}

সম্প্রসারিত:

{  # bare block lambda with implicit parameter 「$_」

  [+]           # reduce the following with 「&infix:<+>」

    [*](        # reduce with 「&infix:<*>」
      2 .. $_   # a Range that include the numbers from 2 to the input (inclusive)
    ).comb      # split the product into digits
}

অভিনন্দন, আপনি উত্তর পেয়েছেন। 101010!
রুডলফ জেলিন

@ রুডলফএল.জেলেনেক স্ট্যাকওভারফ্লো এবং মেটা.স্ট্যাক এক্সচেঞ্জ এ কিছুই নয়, আমি ব্যবহারকারী সংখ্যা
১৩3737

3

কিউবিক্স, 33 32 বাইট

u*.$s.!(.01I^<W%NW!;<,;;q+p@Opus

নেট ফর্ম:

      u * .
      $ s .
      ! ( .
0 1 I ^ < W % N W ! ; <
, ; ; q + p @ O p u s .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

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

নোট

  • ১ 170০ পর্যন্ত ইনপুট সহ এবং আরও বেশি ইনপুট সহ কাজ করে, ফলে অসীম লুপ তৈরি হয় কারণ তাদের ফ্যাক্টরিয়াল Infinityসংখ্যাটি দেয় (প্রযুক্তিগতভাবে বলতে গেলে এটি উইন্ডো অবজেক্টের একটি অ-রচনীয়, অ-গণনাযোগ্য এবং কনফিগারযোগ্য সম্পত্তি নয়)।
  • যথাযথতা ইনপুট 19 এবং ততোধিকের জন্য হারিয়ে গেছে, কারণ 2 53 53 (= 9 007 199 254 740 992) এর বেশি সংখ্যক সঠিকভাবে জাভাস্ক্রিপ্টে সংরক্ষণ করা যায় না।

ব্যাখ্যা

এই প্রোগ্রাম দুটি লুপ নিয়ে গঠিত। প্রথমটি ইনপুটটির ফ্যাক্টরিয়াল গণনা করে, অন্যটি ফলাফলটিকে তার অঙ্কগুলিতে বিভক্ত করে এবং সেগুলি একসাথে যুক্ত করে। তারপরে যোগফলটি মুদ্রিত হয় এবং প্রোগ্রামটি শেষ হয়।

শুরু

প্রথমত, আমাদের স্ট্যাক প্রস্তুত করা দরকার। এই অংশের জন্য, আমরা প্রথম তিনটি নির্দেশাবলী ব্যবহার করি। পূর্ব দিকে নির্দেশ করে চতুর্থ লাইনে আইপি শুরু হয়। স্ট্যাক খালি।

      . . .
      . . .
      . . .
0 1 I . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

আমরা যোগফলটিকে স্ট্যাকের একেবারে নীচে রেখে দেব, সুতরাং আমাদের স্ট্যাকের নীচে রেখে স্টোর 0করে যোগফলটি দিয়ে শুরু করা দরকার । তারপরে আমাদের একটি ধাক্কা দেওয়া দরকার 1, কারণ ইনপুটটি প্রথমে এর আগে সংখ্যাটি দিয়ে গুন করা হবে। এটি যদি শূন্য হয়, তবে ঘটনাবহুল সর্বদা শূন্যের ফলাফল দেয়। শেষ পর্যন্ত আমরা পূর্ণসংখ্যা হিসাবে ইনপুটটি পড়ি।

এখন, স্ট্যাকটি রয়েছে [0, 1, input]এবং আইপিটি পূর্বদিকে নির্দেশ করে চতুর্থ লাইনে, চতুর্থ কলামে রয়েছে।

কারখানা লুপ

এই সহজ লুপ যে তা বৃদ্ধি পায় শীর্ষ স্ট্যাক (পূর্ববর্তী লুপ এবং ইনপুট ফল দুই উপাদান - এন, এবং তারপর ইনপুট decrements তা ভঙ্গ যখন ইনপুট ছুঁয়েছে 0.। $নির্দেশ এড়িয়ে যেতে আইপি ঘটায় u- লুপটি কিউবের নীচের অংশ The আইপি চতুর্থ লাইনে, চতুর্থ কলামে শুরু হয়।

      u * .
      $ s .
      ! ( .
. . . ^ < . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

^চরিত্রের কারণে, আইপি তত্ক্ষণাত উত্তর দিকে যেতে শুরু করে। তারপরে uআইপিটি ঘুরিয়ে দেয় এবং এটিকে ডান দিকে সরায়। নীচে, আরও একটি তীর রয়েছে: <আইপিটিকে পিছনে চিহ্নিত করে ^। স্ট্যাকটি শুরু হয় [previousresult, input-n]যেখানে nপুনরাবৃত্তির সংখ্যা। নিম্নলিখিত অক্ষরগুলি লুপে সম্পাদিত হয়:

*s(
*   # Multiply the top two items
    #   Stack: [previousresult, input-n, newresult]
 s  # Swap the top two items
    #   Stack: [previousresult, newresult, input-n]
  ( # Decrement the top item
    #   Stack: [previousresult, newresult, input-n-1]

তারপরে স্ট্যাকের শীর্ষটি (হ্রাস করা ইনপুট) নির্দেশের বিরুদ্ধে পরীক্ষা 0করা হয় !, এবং যদি তা হয় 0তবে uঅক্ষরটি এড়িয়ে যায়।

অঙ্কগুলি যোগ করুন

আইপি ঘনক্ষেতের চারপাশে মোড়ানো, চতুর্থ লাইনের একেবারে শেষ চরিত্রের শেষে শেষ দিকে পশ্চিম দিকে নির্দেশ করছে। নিম্নলিখিত লুপটিতে প্রায় সমস্ত অক্ষর রয়েছে:

      . . .
      . . .
      . . .
. . . . . W % N W ! ; <
, ; ; q + p @ O p u s .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

লুপটি প্রথমে স্ট্যাক থেকে শীর্ষ আইটেমটি মুছে ফেলে (যা হয় হয় 10বা হয় 0) এবং তারপরে ফ্যাক্টরিয়ালটির ফলাফলের মধ্যে কী রয়েছে তা পরীক্ষা করে। যদি এটি হ্রাস পেয়ে থাকে 0তবে স্ট্যাকের নীচে (যোগফল) মুদ্রণ করা হয় এবং প্রোগ্রামটি বন্ধ হয়ে যায়। অন্যথায়, নিম্নলিখিত নির্দেশাবলী কার্যকর করা হয় (স্ট্যাক হিসাবে শুরু হয় [oldsum, ..., factorial]):

N%p+q;;,s;
N          # Push 10
           #   Stack: [oldsum, ..., factorial, 10]
 %         # Push factorial % 10
           #   Stack: [oldsum, ..., factorial, 10, factorial % 10]
  p        # Take the sum to the top
           #   Stack: [..., factorial, 10, factorial % 10, oldsum]
   +       # Add top items together
           #   Stack: [..., factorial, 10, factorial % 10, oldsum, newsum]
    q      # Send that to the bottom
           #   Stack: [newsum, ..., factorial, 10, factorial % 10, oldsum]
     ;;    # Delete top two items
           #   Stack: [newsum, ..., factorial, 10]
       ,   # Integer divide top two items
           #   Stack: [newsum, ..., factorial, 10, factorial/10]
        s; # Delete the second item
           #   Stack: [newsum, ..., factorial, factorial/10]

factorial/100 এর সমান হওয়া পর্যন্ত লুপটি আবার শুরু হয় ।


3

সি, 47 বাইট

f(n,a){return n?f(n-1,a*n):a?a%10+f(0,a/10):0;}

ব্যবহার:

f(n,a){return n?f(n-1,a*n):a?a%10+f(0,a/10):0;}
main() {
  printf("answer: %d\n",f(10,1));
}

2

পাইথন, 57 বাইট

import math
lambda n:sum(map(int,str(math.factorial(n))))

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


আপনি str এর পরিবর্তে পিছনে টিক্স ব্যবহার করতে পারেন?
nedla2004

2
@ nedla2004 এটি Lএকবারে যুক্ত হবে যখন ফ্যাটোরিয়ালটি দীর্ঘ হয়ে যাওয়ার পক্ষে যথেষ্ট বড় হয়।
কেডে

2

ব্যাচ, 112 বাইট

@set/af=1,t=0
@for /l %%i in (1,1,%1)do @set/af*=%%i
:g
@set/at+=f%%10,f/=10
@if %f% gtr 0 goto g
@echo %t%

সুবিধামত set/aএকটি ভেরিয়েবলের বর্তমান মানের উপর কাজ করে, তাই এটি একটি লুপের ভিতরে সাধারণত কাজ করে। ব্যাচের পূর্ণসংখ্যার ধরণের সীমাবদ্ধতার কারণে কেবল 12 পর্যন্ত কাজ করে, সুতরাং তত্ত্বের মধ্যে আমি ধরে নিয়ে একটি বাইট সংরক্ষণ করতে পারি f<1e9:

@set/af=1,t=0
@for /l %%i in (1,1,%1)do @set/af*=%%i
@for /l %%i in (1,1,9)do @set/at+=f%%10,f/=10
@echo %t%

তবে এইভাবে উন্মাদনা রয়েছে ... আমি সেই ক্ষেত্রে হার্ড-কোডের তালিকাটি (97 বাইট) করতে পারি:

@call:l %1 1 1 2 6 6 3 9 9 9 27 27 36 27
@exit/b
:l
@for /l %%i in (1,1,%1)do @shift
@echo %2

2

জাভাস্ক্রিপ্ট (ES6), 50 বাইট

f=(n,m=1,t=0)=>n?f(n-1,n*m):m?f(n,m/10|0,t+m%10):t

শুধুমাত্র n=22ভাসমান-পয়েন্ট নির্ভুলতার সীমাবদ্ধতার কারণে কাজ করে ।


2

বেফঞ্জ 93 , 56 54 বাইট

উদ্ধৃতি পরিবর্তে get ব্যবহার করে 2 বাইট সংরক্ষণ করা হয়েছে। এটি আমাকে অপ্রয়োজনীয় সাদা স্থান হ্রাস করে শীর্ষ 2 লাইন 1 এর উপরে স্থানান্তরিত করতে দিন।

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

&#:<_v#:-1
: \*$<:_^#
g::v>91+%+00
_v#<^p00</+19
@>$$.

ব্যাখ্যা:

&#:<                Gets an integer input (n), and reverses flow direction
&#:< _v#:-1         Pushes n through 0 onto the stack (descending order)

:  \*$<:_^#         Throws the 0 away and multiplies all the remaining numbers together

(reorganized to better show program flow):
vp00< /+19 _v#<    Stores the factorial at cell (0, 0). Pushes 3 of whatever's in
> 91+%+ 00g ::^    cell (0, 0). Pops a, and stores a / 10 at (0, 0),
                   and adds a % 10 to the sum.

@>$$.              Simply discards 2 unneeded 0s and prints the sum.

আপনি সঠিক. আমি একটি নতুন সংস্করণে কাজ করছি। এফওয়াইআই, আমি কুইকসিটার ডট কম ব্যবহার করছি, কারণ স্ট্যাকের মধ্যে যখন কেবল একটি # ছিল তখন আমি অন্যরা খুঁজে পেয়েছি যে `` সঠিকভাবে আচরণ করে না।
মাইল্ডলি মিল্কয়েটওস্ট

ধন্যবাদ! দেখে মনে হচ্ছে এই কোডটি কেবলমাত্র বেফঞ্জ -৮৮ সংস্করণে সঠিকভাবে কাজ করে , সম্ভবত এটি মেথ পদ্ধতির কারণে।
মাইল্ডলি মিল্কিটোস্ট

48 বাইট যা 0 টিও সঠিকভাবে পরিচালনা করে
জো কিং

2

জাভাস্ক্রিপ্ট ES6 - 61 54 বাইট

n=>eval(`for(j of''+(a=_=>!_||_*a(~-_))(n,t=0))t-=-j`)

সম্পাদনা: 7 বাইট বন্ধ শেভ করার জন্য আপনাকে হেডি এবং ইটিএইচ প্রডাকশনসকে ধন্যবাদ। আমাকে সেই টি - = - জ ট্রিক মনে রাখতে হবে।


1
চমৎকার উত্তর! আপনি বিভিন্ন উপায়ে একটি দম্পতি বাইট সংরক্ষণ করতে পারেন:n=>{a=_=>!_||_*a(~-_);t=0;for(j of''+a(n))t-=-j;return t}
ETH প্রোডাকশন

: @ETHproductions আরো কিছু বাইট Eval সঙ্গে সংরক্ষণ করা যাবেn=>eval(`for(j of''+(a=_=>!_||_*a(~-_))(n,t=0))t-=-j`)
Hedi

@ হেডি আমি জানি, আমি একবারে এটির এক পদক্ষেপ
নিচ্ছিলাম

2

এএইচকে , 60 বাইট

a=1
Loop,%1%
a*=A_Index
Loop,Parse,a
b+=A_LoopField
Send,%b%

অটোহটকির কোনও বিল্ট-ইন ফ্যাক্টরিয়াল ফাংশন নেই এবং লুপ ফাংশনগুলির বিল্ট-ইন ভেরিয়েবলগুলির দীর্ঘ নাম রয়েছে। প্রথম লুপটি ফ্যাক্টরিয়াল এবং দ্বিতীয়টি ডিজিটগুলি একসাথে যুক্ত করছে।


2

জে, 12 11 বাইট

কোলে ধন্যবাদ 1 বাইট সংরক্ষিত!

1#.10#.inv!

এটি আর্গুমেন্টের ফ্যাকটোরিয়াল ( ) এর 1#.অঙ্কগুলিতে ( একটি বেসের সাথে invবেস রূপান্তরটির বিপরীতমুখী ব্যবহার করে) অঙ্কগুলিতে সহজেই যোগফল প্রয়োগ করে ।#.10!

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

দ্রষ্টব্য: শেষ দুটি পরীক্ষার কেস হ'ল বিগলাইনগুলি, যেমন একটি ট্রেলিং দ্বারা চিহ্নিত x

   f=:10#.inv!
   (,. f"0) 10 19 469x 985x
 10    27
 19    45
469  4140
985 10053

আপনি "."0":অঙ্কগুলি পেতে ব্যবহার করতে পারেন
বোলস বুসিয়ের

11 বাইট: 1#.,.&.":@!যার জন্য ছোট ক্ষেত্রেও বর্ধিত নির্ভুলতা প্রয়োজন (কেন তা নিশ্চিত নয়)। 11 বাইট: 1#.10#.inv!
কোল


1

সি, 63 60 বাইট

do...whileলুপের জন্য -3 বাইট ।

i;f(n){i=n;while(--n)i*=n;do n+=i%10;while(i/=10);return n;}

অবহেলিত এবং ব্যবহার:

i;
f(n){
 i=n;
 while(--n)
  i*=n;
 do
  n+=i%10;
 while(i/=10);
 return n;
}

main() {
 printf("%d\n",f(10));
}

আমরা কি ডি (ডি) intডিফল্ট হিসাবে সংজ্ঞায়িত করব ?
মুকুল কুমার

@ মুকুলকুমার এটি সি তে প্রমিত, যদি কোনও প্রকার না থাকে তবে intধরে নেওয়া হয়।
কার্ল ন্যাপফ
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.