चुनौती एक संख्या के भाज्य की अंक राशि की गणना करना है।

उदाहरण

Input: 10
Output: 27

10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800, और संख्या 10 में अंकों का योग! ३ + ६ + २ + 8 + 0 + ० + ० = २ 2 है

आप इनपुट को एक पूर्णांक से ऊपर होने की उम्मीद कर सकते हैं। आउटपुट किसी भी प्रकार का हो सकता है, लेकिन जवाब कोडिंग भाषा के मानक आधार में होना चाहिए।

परीक्षण के मामलों:

10    27
19    45
469   4140
985   10053

एनबी कुछ भाषाएँ 32-बिट पूर्णांक से ऊपर बड़ी संख्या का समर्थन नहीं कर सकती हैं; उन भाषाओं के लिए आपसे बड़े तथ्यात्मक गणना की उम्मीद नहीं की जाएगी।

मार्टिन एंडर को धन्यवाद यहाँ OEIS लिंक

यह कोड-गोल्फ है , इसलिए पात्रों में सबसे छोटा कोड जीतता है!

— जॉर्ज
स्रोत

उम्मीद करने के लिए अधिकतम इनपुट संख्या क्या है? आर में 32-बिट पूर्णांक के साथ इस चुनौती को सही ढंग से हल नहीं किया जा सकता हैn>21

— बिलीवॉब

1

@ बिलीवॉब फॉर आर तो आपको केवल 20 पर जाने की आवश्यकता होगी। मैं इसे प्रतिबिंबित करने के लिए प्रश्न संपादित करूंगा

— जॉर्ज

13

05AB1E , 3 बाइट्स

!SO

इसे ऑनलाइन आज़माएं!

!   Factorial.
 S  Push characters separately.
  O Sum.

— जादू ऑक्टोपस Urn
स्रोत

11

जेली , 3 बाइट्स

!DS

इसे ऑनलाइन आज़माएं!

क्या आप उम्मीद करते हैं:

!    Factorial.
 D   Decimal digits.
  S  Sum.

— मार्टिन एंडर
स्रोत

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);}

दुर्लभ मामलों में से एक जब मेरा सी ++ कोड सी कोड से छोटा होता है ।

यदि आप बड़े मामलों को दबाना चाहते हैं, तो C ++ 14 पर स्विच करें और उपयोग करें:

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

और ullप्रत्यय के साथ कॉलिंग तर्क की आपूर्ति ।

उपयोग:

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

रूबी, ६३ ६१ ५३ 38 बाइट्स

नए दृष्टिकोण के लिए धन्यवाद

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

पुराना:

->n{(1..n).reduce(:*).to_s.chars.map(&:hex).reduce:+}

मार्टिन बायर को -3 बाइट्स धन्यवाद
-5 बाइट्स जीबी के लिए धन्यवाद

— TuxCrafting
स्रोत

1

पुराना उबाऊ evalतरीका ->n{eval"#{(1..n).reduce:*}".chars*?+}:।

— manatwork

6

पायथ, 7 6 बाइट्स

मुझे बाइट बचाने के लिए @Kade का धन्यवाद

sj.!QT

इसे ऑनलाइन आज़माएं!

यह पाइथ का उपयोग करने का मेरा पहला मौका है, इसलिए मुझे यकीन है कि मेरा जवाब थोड़ा सा गोल्फ हो सकता है।

स्पष्टीकरण:

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

— BookOwl
स्रोत

1

10एक चर को सौंपा गया है T, इसलिए आप इसे बना सकते हैं sj.!QT:)

— केड

ठीक है धन्यवाद! मैं इसे

— जोड़ूंगा

अच्छा! ssM`.!नौकरी भी करता है, 6 बाइट्स में भी।

— hakr14

5

हास्केल, 41 40 बाइट्स

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

प्रयोग उदाहरण: f 985-> 10053।

से एक सूची बनाएँ 1करने के लिएx , सूची तत्वों के उत्पाद की गणना, यह अपने स्ट्रिंग प्रतिनिधित्व में बदल जाते हैं, एक संख्या में हर किरदार देते हैं और उन्हें योग।

संपादित करें: @Angs ने एक बाइट को बचाया। धन्यवाद!

— nimi
स्रोत

f x=sum$read.pure<$>(show$product[1..x])एक बाइट बचाता है

— 14

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 बाइट्स

संपादित करें: @Jonathan कैरोल को एक बाइट धन्यवाद और @Micky T को एक युगल धन्यवाद

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

दुर्भाग्य से, 32-बिट पूर्णांक के साथ, यह केवल काम करता है n < 22। स्टड से इनपुट लेता है और स्टडआउट को आउटपुट देता है।

यदि कोई उच्च स्तर की सटीकता चाहता है, तो किसी को कुछ बाहरी पुस्तकालय जैसे Rmpfr:

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

— Billywob
स्रोत

1

मैं ठीक उसी उत्तर पर पहुंचा, जैसा आपने किया था, फिर c(x,"")बनाम paste(x): पर 1-बाइट हासिल किया sum(as.integer(el(strsplit(c(factorial(scan()),""),""))))। गुणात्मक परिणाम को चरित्र में जोड़ता है और strsplitइसे दूसरी सूची के रूप में लौटाता है, इसलिए elअभी भी काम करता है और पहली सूची तत्वों को निकालता है।

— जोनाथन कैरोल

2

कैसे के बारे में prod(1:scan())?

— मिकटी

1

यह भी as.double पर्याप्त होना चाहिए

— मिकी

@ मिक्की धन्यवाद! अपडेट किया गया।

— बिलीवोब

strtoias.doubleमुझे लगता है कि कम प्रतिस्थापन के रूप में काम करता है।

— Giuseppe

4

पिप , 8 बाइट्स

$+$*++,a

इसे ऑनलाइन आज़माएं!

व्याख्या

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

— Emigna
स्रोत

क्षमा करें, मैं वास्तव में आपके सामने 05AB1E उत्तर पोस्ट करने में कामयाब रहा;)।

— मैजिक ऑक्टोपस Urn

2

@ कोरसोकोम्पुटिंग: हेहे। मुझे एक नई भाषा देखने का मौका मिला :)

— एमिगा

1

मुझे लगता है कि आप एक गैर-बहुभाषाविद कोड गोल्फ उत्तर के लिए पिप का उपयोग करने वाले मेरे अलावा पहले व्यक्ति हैं। : डी

— DLosc

4

CJam , 8 बाइट्स

rim!Ab:+

इसे ऑनलाइन आज़माएं!

व्याख्या

r   e# Read input.
i   e# Convert to integer.
m!  e# Take factorial.
Ab  e# Get decimal digits.
:+  e# Sum.

— मार्टिन एंडर
स्रोत

3

ब्रेकीलॉग , 5 बाइट्स

$!@e+

इसे ऑनलाइन आज़माएं!

व्याख्या

मूल रूप से वर्णित एल्गोरिथ्म:

$!       Take the factorial of the Input
  @e     Take the elements of this factorial (i.e. its digits)
    +    Output is the sum of those elements

— Fatalize
स्रोत

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;

— jacksonecac
स्रोत

@ ईयालव प्रश्न में कोई सीमा नहीं है। आप एक फैक्टरियल को संभालने की लंबे समय से अपेक्षा कैसे कर रहे हैं जो 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

— FlipTack
स्रोत

3

ऑक्टेव, 30 बाइट्स

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

सूची के उत्पाद को ले कर फैक्टरियल की गणना करता है [1 2 ... n]। इसे एक स्ट्रिंग में परिवर्तित करता है और 48सभी तत्वों (ASCII कोड के लिए 0) से घटाता है । अंत में यह इसे बोता है :)

— स्टीवी ग्रिफिन
स्रोत

3

बैश (seq, bc, fold, jq), 34 33 बाइट्स

निश्चित रूप से सबसे सुरुचिपूर्ण नहीं बल्कि चुनौती के लिए

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

— एडम
स्रोत

fold -1एक बाइट बचाता है।

— डिजिटल ट्रॉमा

@DigitalTrauma ने सही किया! धन्यवाद

— एडम

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;}

— teksturi
स्रोत

अच्छा विचार है, लेकिन मुझे यह समझ में नहीं आता है कि फैक्टरियल को वापस करने के लिए एक फ़ंक्शन का उपयोग करने के लिए यह छोटा क्यों नहीं होगा और दूसरा अंक की गणना करने के लिए, जैसे (बी (10))। क्या शब्द "वापसी" काम करने के लिए बहुत लंबा है?

— जॉलीजॉकर

बहुत खाता है। मैं कोशिश करता हूं कि निश्चित रूप से। शायद कोई ऐसा कर सकता है कम से कम मुझे वह काम नहीं मिल सकता है

— टेकस्टुरी

1

कुछ बाइट्स बचाने के लिए आप दो तर्क स्वीकार कर सकते हैं: codegolf.stackexchange.com/a/153132/77415

— user84207

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
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

बधाई हो, आपको जवाब नहीं मिला। 101010!

— रुडोल्फजेलिन

@ RudolfL.Jelínek यह कुछ भी नहीं है, StackOverflow पर , और Meta.StackExchange मैं उपयोगकर्ता संख्या 1337

— ब्रैड गिल्बर्ट b2gills

3

Cubix, 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 संख्या (तकनीकी रूप से बोलना, इसकी गैर-लेखन योग्य, गैर-enumerable और गैर-कॉन्फ़िगर करने योग्य संपत्ति विंडो ऑब्जेक्ट) होती है।
सटीकता 19 और ऊपर के इनपुट के लिए खो गई है, क्योंकि संख्या 2 ⁵³ से अधिक है (= 9 007 199 254 740 992) को जावास्क्रिप्ट में सही ढंग से संग्रहीत नहीं किया जा सकता है।

व्याख्या

इस कार्यक्रम में दो लूप शामिल हैं। पहला इनपुट के भाज्य की गणना करता है, दूसरा परिणाम को उसके अंकों में विभाजित करता है और उन्हें एक साथ जोड़ता है। फिर योग छपा है, और कार्यक्रम समाप्त हो गया है।

प्रारंभ

सबसे पहले, हमें स्टैक तैयार करने की आवश्यकता है। उस भाग के लिए, हम पहले तीन निर्देशों का उपयोग करते हैं। आईपी पूर्व की ओर इशारा करते हुए चौथी लाइन पर शुरू होता है। ढेर खाली है।

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

हम योग को स्टैक के बहुत नीचे रखेंगे, इसलिए हमें स्टैक 0के निचले भाग पर जमा करके योग होने की आवश्यकता है । तो फिर हम एक धक्का की जरूरत है1 , क्योंकि इनपुट शुरू में संख्या से गुणा किया जाएगा। यदि यह शून्य होता, तो फैक्टरियल हमेशा शून्य का उत्पादन करता। अंत में हम एक पूर्णांक के रूप में इनपुट पढ़ते हैं।

अब, स्टैक है [0, 1, input]और आईपी चौथी रेखा पर है, चौथा स्तंभ, पूर्व की ओर इशारा करता है।

फैक्टर लूप

यह एक सरल लूप है जो स्टैक के शीर्ष दो तत्वों को गुणा करता है (पिछले लूप और इनपुट के परिणाम - n, और फिर इनपुट को घटाता है। यह तब टूट जाता है जब इनपुट 0. तक पहुंच जाता है। $अनुदेश आईपी को छोड़ने का कारण बनता है u- टर्न। लूप घन का निम्नलिखित भाग है। IP चौथी लाइन, चौथे कॉलम पर शुरू होता है।

      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));
}

— user84207
स्रोत

2

पायथन, 57 बाइट्स

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

इसे ऑनलाइन आज़माएं

— mbomb007
स्रोत

क्या आप 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

जावास्क्रिप्ट (ईएस 6), 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

Befunge 93 , 56 54 बाइट्स

सहेजे गए 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.

— MildlyMilquetoast
स्रोत

तुम सही हो। मैं एक नए संस्करण पर काम कर रहा हूं। FYI करें, मैं quickster.com का उपयोग कर रहा हूं, क्योंकि दूसरों को जो मैंने पाया था `` सही ढंग से इलाज नहीं किया था जब स्टैक में केवल एक # था।

— MildlyMilquetoast

धन्यवाद! ऐसा लगता है कि यह कोड केवल Befunge-98 संस्करण में ठीक से काम करता है , शायद पुट विधि के कारण।

— माइल्डलीवेटोकास्ट

48 बाइट्स जो 0 को भी सही तरीके से हैंडल करता है

— जो किंग

2

जावास्क्रिप्ट ईएस 6 - 61 54 बाइट्स

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

संपादित करें: 7 बाइट्स को शेविंग करने के लिए हेडी और ईटीप्रोडक्शन का धन्यवाद। मुझे याद रखना होगा कि t - = - j trick।

— माक्र्स डायर
स्रोत

1

अच्छा जवाब! आप एक युगल बाइट्स को विभिन्न तरीकों से बचा सकते हैं:n=>{a=_=>!_||_*a(~-_);t=0;for(j of''+a(n))t-=-j;return t}

— ETHproductions

@ETHproductions कुछ और बाइट्स को eval के साथ बचाया जा सकता है:n=>eval(`for(j of''+(a=_=>!_||_*a(~-_))(n,t=0))t-=-j`)

— Hedi

@ हेदी मुझे पता है, मैं इसे एक बार में एक कदम ले रहा था :-)

— ETHproductions

2

एएचके , 60 बाइट्स

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

AutoHotkey में बिल्ट-इन फैक्टरियल फंक्शन नहीं है और लूप फ़ंक्शंस में उनके बिल्ट-इन वेरिएबल्स के लिए लंबे नाम हैं। पहला लूप फैक्टरियल है और दूसरा डिजिट को जोड़ रहा है।

— इंजीनियर टोस्ट
स्रोत

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":अंक प्राप्त करने के लिए उपयोग कर सकते हैं

— Bolce Bussiere

11 बाइट्स: 1#.,.&.":@!जिन्हें छोटे मामलों के लिए विस्तारित सटीकता की आवश्यकता होती है (अनिश्चित क्यों)। इसके अलावा 11 बाइट्स 1#.10#.inv!:।

— कोल

2

ब्रेकीलॉग (v2), 3 बाइट्स

ḟẹ+

इसे ऑनलाइन आज़माएं!

" बेहतर" एन्कोडिंग के साथ @Fatalize द्वारा v1 उत्तर के रूप में समान "एल्गोरिथ्म" ।

— sundar - मोनिका को बहाल करना
स्रोत

1

सी, 63 60 बाइट्स

-3 do...whileलूप के लिए बाइट ।

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));
}

— कार्ल नेफ
स्रोत

क्या हम f (n) को intडिफ़ॉल्ट रूप से परिभाषित करते हैं ?

— मुकुल कुमार

@ मुकुलकुमार यह C में मानक है, यदि कोई प्रकार नहीं है तो intमान लिया गया है।

— कार्ल नैप

कारक अंक योग

चुनौती एक संख्या के भाज्य की अंक राशि की गणना करना है।

05AB1E , 3 बाइट्स

जेली , 3 बाइट्स

गणितज्ञ, 21 बाइट्स

सी ++ 11, 58 बाइट्स

रूबी, ६३ ६१ ५३ 38 बाइट्स

पायथ, 7 6 बाइट्स

हास्केल, 41 40 बाइट्स

पायथन, 54 बाइट्स

आर, 58 53 बाइट्स

पिप , 8 बाइट्स

CJam , 8 बाइट्स

व्याख्या

ब्रेकीलॉग , 5 बाइट्स

व्याख्या

जावा 7, 148 बाइट्स

रूबी, 63 60 53 51 बाइट्स

पुष्य , 4 बाइट्स

ऑक्टेव, 30 बाइट्स

बैश (seq, bc, fold, jq), 34 33 बाइट्स

सी, 58 बाइट्स

पर्ल 6 , 21 बाइट्स

विस्तारित:

Cubix, 33 32 बाइट्स

टिप्पणियाँ

व्याख्या

प्रारंभ

फैक्टर लूप

अंकों को योग करें

सी, 47 बाइट्स

पायथन, 57 बाइट्स

बैच, 112 बाइट्स

जावास्क्रिप्ट (ईएस 6), 50 बाइट्स

Befunge 93 , 56 54 बाइट्स

जावास्क्रिप्ट ईएस 6 - 61 54 बाइट्स

एएचके , 60 बाइट्स

जम्मू, 12 11 बाइट्स

परीक्षण के मामलों

ब्रेकीलॉग (v2), 3 बाइट्स

सी, 63 60 बाइट्स