प्रधान कारक मूल

Question

डिजिटल जड़ों से प्रेरित, एक संख्या का मुख्य कारक मूल वह संख्या है जो तब उभरती है जब आप किसी संख्या के प्रमुख कारकों को लेते हैं, उन्हें एक साथ जोड़ते हैं, और परिणामी संख्या पर प्रक्रिया को दोहराते हैं, जब तक आप एक अभाज्य संख्या के साथ समाप्त नहीं होते ( जिसके पास स्वयं इसका एकमात्र मुख्य कारक है, और इस प्रकार इसका अपना प्रधान कारक है)। 4 का प्रधान कारक मूल 4 है, जैसा कि 2 * 2 = 2 + 2 है, और यह पूर्णांक का एकमात्र गैर-प्रधान प्रधान कारक है जो 1 से अधिक पूर्णांक है (जो कि एक और विशेष मामला है, क्योंकि इसमें कोई प्रधान कारक नहीं है)। प्राइम फैक्टरल रूट्स द्वारा गठित OEIS अनुक्रम A029908 है ।

उदाहरण के लिए, 24 का मुख्य कारक है:

24=2*2*2*3

2+2+2+3=9=3*3

3+3=6=2*3

2+3=5, and the only prime factor of 5 is 5.  Therefore, the prime factoral root of 24 is 5.  

आपका कार्य:

एक प्रोग्राम या फ़ंक्शन लिखें जो एक इनपुट पूर्णांक का मुख्य कारक मूल पाता है।

इनपुट:

पूर्णांक, किसी भी उचित विधि से इनपुट, 2 और सबसे बड़ा पूर्णांक आपकी भाषा का समर्थन करेगा (समावेशी)। विशेष रूप से ऐसी भाषा का चयन करना जिसमें अनुचित रूप से कम अधिकतम पूर्णांक आकार की अनुमति नहीं है (और यह मानक खामियों का भी उल्लंघन करता है )

आउटपुट:

एक पूर्णांक, इनपुट का मुख्य कारक मूल।

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

4   -> 4
24  -> 5
11  -> 11
250 -> 17

स्कोरिंग:

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

Comments

क्या आप 4परीक्षण के मामलों में जोड़ सकते हैं , क्योंकि यह एक अपवाद है और उत्तर का परीक्षण करते समय इसके बारे में भूलना आसान है?

— स्कोटिनैट

क्या हमें 1 के लिए 1 आउटपुट देना होगा?

— मेरा सर्वनाम

लिंक किए गए OEIS अनुक्रम के अनुसार @someone, यह 1 के लिए 0 का उत्पादन करना चाहिए

— स्कूटिनैट

@someone चुनौती बताती है कि इनपुट कम से कम 2 होगा

— मार्टिन एंडर

@someone थोड़ी देर के लिए बंद होने के लिए क्षमा करें। जैसा कि मार्टिन ने कहा, चुनौती विशेष रूप से कहती है कि इनपुट एक से अधिक होगा, और इसलिए जब इनपुट 1 अपरिभाषित हो तो व्यवहार।

— ग्रिएफॉन

Answer 1

05AB1E , 3 बाइट्स

FÒO

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

स्पष्टीकरण:

FÒO   
F    Loops <input> times + 1
 Ò   List of prime factors w/ duplicates
  O  Total sum of the list
     -- implicit output

Comments

इसके लिए असफल होना प्रतीत होता है 4।

— झबरा

@ बग्गी 2 बाइट्स बचाते हुए तय की गई

— स्कूटिनैट

क्या यह किसी को भी FÒO-fighter को हराने की कोशिश करता है?

— १४:०४

कम से कम यह FOObar नहीं था।

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

Answer 2

हास्केल , 61 बाइट्स

import Data.Numbers.Primes
until=<<((==)=<<)$sum.primeFactors

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

व्याख्या

until=<<((==)=<<)एक फ़ंक्शन लेता है fऔर इसे इनपुट पर लागू करता है xजब तक कि एक फिक्स पॉइंट तक नहीं पहुंच जाता है, जो कि f xबराबर है x। primeFactorsकिसी संख्या के प्रमुख कारकों की sumसूची देता है, संख्याओं की सूची का योग देता है।

लेकिन रुकिए, काम और अजीब क्यों until=<<((==)=<<) दिखता है?

यदि हम मानते हैं f=sum.primeFactors, एक अधिक प्राकृतिक परिभाषा होगी until(\x->f x==x)f, क्योंकि untilएक विधेय (एक फ़ंक्शन जो एक बूलियन लौटाता है) लेता है, एक फ़ंक्शन जिसमें एक ही इनपुट और रिटर्न प्रकार (जैसे Int -> Int) और इस प्रकार का मान होता है, और फिर फ़ंक्शन पर लागू होता है मूल्य जब तक विधेय पूरा नहीं हो जाता।

until(\x->f x==x)fजैसा है, वैसा ही है until(\x->(==)(f x)x)fऔर जैसा g (h x) xहै, वैसा ही है (g=<<h)x, जैसा हम पाते हैं until(\x->((==)=<<f)x)f। एटा रूपांतरण के बाद , यह बन जाता है until((==)=<<f)f। लेकिन अगर हम अब (==)=<<एक फ़ंक्शन के रूप में व्यवहार करते हैं जिसे लागू किया जाता है f, तो हम देख सकते हैं कि until(((==)=<<)f)fयह फिर से फॉर्म g (h x) xके साथ है g=until, h=((==)=<<)और x=f, इसलिए इसे फिर से लिखा जा सकता है (until=<<((==)=<<))f। $बाहरी कोष्ठक से छुटकारा पाने के लिए ऑपरेटर का उपयोग करना और ऊपर से समाधान पैदावार के fसाथ प्रतिस्थापित करना sum.primeFactors।

Comments

=<<((==)=<<)$Whaaaaaat।

— 4

@icrieverytim मैंने एक स्पष्टीकरण जोड़ा। हास्केल चैट रूम में बेझिझक पूछें कि क्या आपके पास इस बारे में कोई और सवाल है कि यह टोना कैसे काम करता है।

— लैकोनी

Answer 3

भूसी , 4 बाइट्स

ω(Σp

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

स्पष्टीकरण:

ω(   -- apply the following function until the result no longer changes (fixpoint)
  Σ  -- sum
   p -- the list of primefactors

Answer 4

अजगर , 3 बाइट्स

usP

इसे यहाँ आज़माएँ।

स्पष्टीकरण:

usPGQ The trailing GQ is implicit
  PG  Get prime factors
 s    Sum
u   Q Repeat until returned value no longer unique starting with the input

Comments

क्या आप अपना स्पष्टीकरण अपडेट करना भूल गए?

— एमसीमास्टरी

@MCMastery नहीं, कोड और स्पष्टीकरण समान हैं। The trailing GQ is implicit

— पूरी तरह से

@MCMastery मैंने क्या कहा, यह कहा जाता है

— एरिक आउटगोल्फर

Answer 5

पायथन 2 , 84 बाइट्स

f=lambda n,d=2:n>1and(n%d and f(n,d+1)or d+f(n/d))
i=input()
exec'i=f(i);'*i
print i

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

Comments

यह एक बहुत गूंगा सवाल हो सकता है, लेकिन यह कैसे f=lambda n,d=2:n>1and(n%d and f(n,d+1)or d+f(n/d))काम करता है ? मैंने कभी पायथन (मुख्य रूप से जावा और सी #) में प्रोग्राम नहीं किया है, इसलिए मैं अनिश्चित हूं कि इस फ़ंक्शन का परिणाम क्या है। क्या यह फ़ंक्शन इनपुट को संशोधित करता है nऔर बाद में इसे वापस करता है, या क्या यह एक बूलियन के समान है जहां n>1and(n%d and f(n,d+1)or d+f(n/d))या तो 0 या 1, या 0 या n, या कुछ और है? मैं यह कल्पना करने की कोशिश कर रहा हूं कि जावा / सी # में इसका एक पोर्ट कैसा दिखेगा, लेकिन मैं इसलिए असमर्थ हूं क्योंकि मैं वास्तव में इस तरह से पायथन लैम्ब्डा को नहीं समझता हूं।

— केविन क्रूज़सेन

@ केविनक्रूजसेन इसके बराबर है n>1 ? (n%d!=0 ? f(n, d+1) : d+f(n/d)) : n>1। सामान्य शब्दों x and yमें इसके बराबर है x ? y : x। ज्यादातर मामलों में x and y or zबराबर है x ? y : z।

— 15

@KevinCruijssen एक जावा पोर्ट कुछ इस तरह होगा f=(n,d=2)->n>1?n%d>0?f(n,d+1):d+f(n/d):0।

— 15

आह अच्छा। स्पष्टीकरण के लिए धन्यवाद, अब यह बहुत अधिक समझ में आता है। और मुझे याद है x and yकि x ? y : xजावास्क्रिप्ट से भी। धन्यवाद!

— केविन क्रूजसेन

Answer 6

जावा 8, 175 144 142 141 बाइट्स

n->{for(int i,t=n,x;;n=t){for(i=2;i<t;t=t%i++<1?0:t);if(t>1|n<5)return n;for(t=0,i=1;i++<n;)for(;n%i<1;n/=i,t+=x)for(x=i;x>9;x/=10)t+=x%10;}}

-1 बाइट थैंक्स टू @ नवे ।

गोल्फ की कुछ भाषाओं में सिंगल बाइट्स के विपरीत, जावा प्राइम-चेक, प्राइम-फैक्टर्स, डिजिट-सोम्स, और इस तरह के लिए बहुत अच्छी क्रिया है, इसलिए मुझे लगता है कि 200 से कम होना बहुत जर्जर नहीं है।
सबसे अधिक संभावना है कि अभी भी छोरों के संयोजन से गोल्फ हो सकता है और अंक राशि के लिए एक अलग पुनरावर्ती विधि का उपयोग नहीं कर सकता है ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

n->{                // Method with integer as both parameter and return-type
  for(int i,        //  Index-integer `i`
          t=n,      //  Temp integer `t`, starting at the input `n`
          x;        //  Temp integer `x`
      ;             //  Loop (1) indefinitely
      n=t){         //    After every iteration, replace `n` with the value `t`
    for(i=2;        //   Reset `i` to 2
        i<t;        //   Inner loop (2) from 2 to `t` (exclusive)
        t=t%i++<1?  //    If `t` is divisible by `i`:
           0        //     Set `t` to 0
          :         //    Else:
           t        //     Leave `t` the same
    );              //   End of inner loop (2)
    if(t>1          //   If `t` is not 0 (it means it's a prime),
       |n<5)        //   or if `n` is below 5 (for edge-cases `4` and 'prime' `1`)
      return n;     //    Return `n` as result
    for(t=0,        //   Reset `t` to 0
        i=1;        //   Reset `i` to 1
        i++<n;)     //   Inner loop (3) from 2 to `n` (inclusive)
      for(;n%i<1;   //    Inner loop (4) as long as `n` is divisible by `i`
          n/=i,     //      After every iteration: Divide `n` by `i`,
          t+=x)     //      and increase `t` by `x`
        for(x=i;    //     Reset `x` to `i`
            x>9;    //     Inner loop (5) as long as `x` contains more than 1 digit
            x/=10)  //       After every iteration, remove the trailing digit
          t+=n%10;  //      Increase `t` with the trailing digit of `n`
                    //     End of inner loop (5) (implicit / single-line body)
                    //    End of inner loop (4) (implicit / single-line body)
                    //   End of inner loop (3) (implicit / single-line body)
  }                 //  End of loop (1)
}                   // End of method

Comments

+1 क्रिया के रूप में एक व्याख्या लिखने के लिए परेशान करने के लिए जैसे कि यह एक गोल्फ भाषा थी।

— मेरा सर्वनाम

@someone धन्यवाद! चूँकि किसी ने मुझसे अतीत में एक बार जावा के उत्तर के बारे में पूछा था, इसलिए मैं उन्हें अपने सभी उत्तरों में जोड़ रहा हूँ। :)

— केविन क्रूज़सेन

i,t=n,xऐसा लगता है जैसे यह पायथन में है, हाहा

— ETHproductions

@ETHproductions हे, बहुत बुरा मुझे अभी भी अग्रणी int (पायथन के विपरीत) जोड़ना है । ;)

— केविन क्रूज़सेन

आप उपयोग कर सकते हैं i++<nके बजाय ++i<=n।

— नेवय

Answer 7

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

ÆfS$¡

स्पष्टीकरण:

Æf    list of prime factors
  S   sum
   $¡ repeat n times

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

Comments

5 बाइट्स

— caird coinheringaahing 11

Answer 8

रेटिना , 30 बाइट्स

{+`(\1|\b11+?\B)+$
$1;$#1$*
;

इनपुट और आउटपुट unary में ।

इसे ऑनलाइन आज़माएं! (सुविधा के लिए दशमलव / एकात्मक रूपांतरण करता है।)

व्याख्या

{+`(\1|\b11+?\B)+$
$1;$#1$*

{रेटिना को पूरे कार्यक्रम को एक लूप में चलाने का निर्देश देता है जब तक कि एक पूर्ण पास स्ट्रिंग को संशोधित करने में विफल नहीं होता है, अर्थात जब तक कि एक निश्चित बिंदु तक नहीं पहुंचता है। नतीजतन, कार्यक्रम खुद वर्तमान मूल्य के प्रमुख कारकों को संक्षेप में रखने के एक चरण की गणना करता है।

यह चरण इनपुट के मुख्य गुणनखंड की गणना करता है। के +समान है, {लेकिन केवल इस चरण को लूप करता है जब तक यह स्ट्रिंग को बदलना बंद नहीं करता है। रेगेक्स 1एस के अंतिम रन को एक ही सबस्ट्रिंग (यानी कारक) से मेल करके मैच करने की कोशिश करता है । जिस तरह से यह किया गया है वह आगे के संदर्भ के कारण थोड़ा सा दृढ़ है \1। पहले पुनरावृति पर, समूह 1ने अभी तक कुछ भी कैप्चर नहीं किया है, इसलिए \1बिना शर्त विफल हो जाता है। इसके बजाय, हमें मैच करना होगा \b11+?\Bजो रन की शुरुआत में सबसे छोटा संभव विकल्प है, जिसमें कम से कम दो 1एस शामिल हैं और पूरे रन को कवर नहीं करता है। इसके बाद पुनरावृत्तियों इस विकल्प का उपयोग करने में सक्षम नहीं होगा, के कारण \b। इसलिए आगे के पुनरावृत्तियों पर, हम मिलान कर रहे हैं\1, यानी बार-बार एक ही स्थानापन्न। इस प्रक्रिया को स्ट्रिंग के अंत में हिट करना होगा ( $) यह सुनिश्चित करने के लिए कि हमने कब्जा कर लिया है और वास्तविक भाजक। यह कुछ हद तक मुश्किल दृष्टिकोण का उपयोग करने का लाभ यह है कि समूह 1का उपयोग n / d बार किया जाएगा, अर्थात जो दिव्य d को विभाजित करने के बाद रहता है ।

हम इस मैच को d ( $1), एक अलग ;और n / d ( $#1$*, जो की $#1प्रतियां सम्मिलित करता है 1, जहां $#1समूह द्वारा बनाए गए कैप्चर की संख्या है 1) से बदल देते हैं।

एक बार स्ट्रिंग में अंतिम रन होने के बाद यह प्रक्रिया बंद हो जाती है, क्योंकि तब regex अब मेल नहीं खाता है।

;

सभी विभाजकों को हटाने के लिए हमें केवल योगों को योग करने की आवश्यकता है।

Answer 9

ओम v2 , 4 बाइट्स

·ΘoΣ

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

स्पष्टीकरण:

·Θ    evaluate the block until the result returned has already been seen
   Σ  sum
  o   the full prime factorization

Answer 10

दरअसल , 7 बाइट्स

⌠w♂πΣ⌡Y

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

स्पष्टीकरण:

⌠w♂πΣ⌡Y
⌠    ⌡Y  do this until output stops changing (fixed-point combinator)
 w         factor into [prime, exponent] pairs
  ♂π       product of each pair
    Σ      sum of products

Answer 11

आर + प्रकर्मा , 53 बाइट्स

function(n){for(i in 1:n)n=sum(pracma::factors(n))
n}

इसे ऑनलाइन आज़माएं! (आर-बेला)

आर निर्मित एक प्रमुख कारक है, लेकिन कई पैकेज (नहीं है pracma, numbersतो मैं एक सुविधा कम एक उठाया, आदि) है।

Answer 12

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

यह उत्तर जेली के कई प्रमुख कारक निर्माण में से एक का उपयोग करता है, और इसके लिए त्वरित है repeat until the results are no longer unique।

ÆfSµÐL

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

Comments

मुझे लगता है कि आप आउटगोल्फ हो गए हैं, लेकिन अपना दृष्टिकोण देखते हुए, मैं अनिश्चित हूं कि क्या जवाब काम करता है

— caird coinheringaahing

@cairdcoinheringaahing मैंने अभी 1 से 100000 तक उसका जवाब (या बल्कि, पायथन समतुल्य) चेक किया है और यह काम करता है। मुझे लगता 1है कि एकमात्र ऐसा मामला है जहां आवश्यक कदमों की संख्या बराबर है n(जो ठीक है; 1हमारे पास इसे केवल एक बार चलाने की आवश्यकता है), और ऐसा कोई भी मामला नहीं लगता जहां कदमों की संख्या n(यानी) से अधिक हो वहाँ किसी भी counterexamples होना प्रतीत नहीं होता है)। आह ठीक है, मैं आउटगोल्फ हो गया हूं: डी

— शेरलाक

खैर, ऐसा होता है। हालांकि +1 के समान सटीक कोड होने के कारण मैंने सोचा था कि जब मैंने इस चुनौती को देखा था

— caird coinheringaahing

N के प्रमुख कारकों का योग हमेशा n के बराबर या उससे कम होता है, जो यह साबित करना बहुत आसान बनाता है कि n हमेशा पर्याप्त से अधिक है।

— क्रिस

Answer 13

MATL , 6 बाइट्स

जरूरत से ज्यादा बार लूपिंग के स्कॉचनेट के विचार का उपयोग करता है । शुगी को एक गलती की ओर इशारा करने के लिए भी धन्यवाद , अब सही किया गया।

t:"Yfs

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

व्याख्या

t       % Take input (implicit). Duplicate
:"      % Do the following that many times
  Yf    %   Array of prime factors
  s     %   Sum of array
        % End (implicit). Display (implicit)

Comments

इसके लिए असफल होना प्रतीत होता है 4।

— झबरा

@ शगुन थैंक्स! उस पर काम कर रहे हैं

— लुइस मेंडो

@ शैगी ने अब हल किया

— लुइस

Answer 14

पॉवरशेल , 124 बाइट्स

function f($a){for($i=2;$a-gt1){if(!($a%$i)){$i;$a/=$i}else{$i++}}}
for($x=$args[0];$l-ne$x){$l=$x;$x=(f($x))-join'+'|iex}$x

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

पावरशेल में कोई भी मुख्य कारक नहीं है, इसलिए यह कारक की गणना करने के लिए प्राइम फैक्टर्स फ्रेंड्स (टॉप लाइन) पर मेरे उत्तर के कोड का उपयोग करता है ।

दूसरी पंक्ति इस कार्यक्रम का मांस है। हम से इनपुट लेने $argsमें $x, तो forपाश जब तक $lहै -nOT equal के लिए $x। (पहली यात्रा, $lहै $nullऔर $xकम से कम एक बार एक पूर्णांक है, पाश तो हम करेंगे)।

लूप के अंदर, हम यह निर्धारित करने के $l = $xलिए सेट करते हैं कि हमने लूप के अंत को हिट किया है या नहीं। फिर हम कारकों में से प्राप्त $xके साथ f($x), -joinउन के साथ मिलकर +और |iex(के लिए कम उन्हें Invoke-Expressionऔर के समान eval)। वह वापस संग्रहीत है $x। इस प्रकार, हमने "अंत" पर प्रहार किया है, जहां एक साथ अभिव्यक्त किए गए अभाज्य गुणनखंडन स्वयं पर वापस आ गए हैं। फिर, हम बस $xपाइपलाइन पर जगह और उत्पादन निहित है।

Answer 15

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

#//.x_:>Tr[1##&@@@FactorInteger@x]&

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

(गणित समर्थन नहीं करता है Tr। मुझे इसे मैन्युअल रूप से लागू करना होगा)

Comments

1##&के लिए कम है Timesऔर FixedPointलगभग हमेशा के साथ छोटा किया जा सकता है //.:#//.x_:>Tr[1##&@@@FactorInteger@x]&

— मार्टिन एंडर

@MartinEnder धन्यवाद! मुझे पहले से ही पता होना चाहिए था Times, लेकिन मैं इस FixedPointट्रिक के बारे में नहीं जानता ।

— user202729

आपका कोड Mathematica में लिखा गया है। यह मैथिक्स फंक्शन नहीं है। आपको या तो गणित का नाम बदलकर Mathematica या Tr to Total

— J42161217

@ {कोई नहीं} क्षमा करें, भाषा का नाम (गणित) एक गलती थी। {{cri evritime} तय किया कि।

— user202729

FYI करें, मैंने Trथोड़ी देर पहले Mathics को जोड़ने के लिए PR खोला ।

— Mego

Answer 16

रूबी , 63 बाइट्स

->n{n.times{n=n.prime_division.map{|x|x.reduce:*}.sum};n}

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

प्राइम # प्राइमविजन-rprime का उपयोग करने के लिए +6 बाइट्स के लिए ध्वज का उपयोग करता है ।

prime_divisionके जोड़े [prime, exponent](उदाहरण के लिए, 24 के लिए हमारे पास कारक हैं [2, 2, 2, 3]इसलिए यह देता है [[2, 3], [3, 1]]) इसलिए प्रत्येक चरण में हम बस उन जोड़ियों के सदस्यों को एक साथ गुणा करते हैं और परिणाम जोड़ते हैं।

Answer 17

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

f=n=>(q=(p=(m,x)=>m<x?0:m%x?p(m,x+1):x+p(m/x,x))(n,2))^n?f(q):q

<input id=i type=number min=0 value=0 oninput="o.innerText=f(i.value)">
<p id=o></p>

Ungolfed:

f=n=>(                  // Recursive function `f`
    p=(m,x=2)=>(        //   Recursive function `p`, used to sum prime factors
        m<x?            //     If m (the number to be factored) is less than x (the current
            0           //     iteration), return 0
        :m%x?           //     Else if m doesn't divide x
            p(m,x+1)    //     run the next iteration
        :               //     Else (if m divides x)
            x+p(m/x,x)  //     Divide m by x and repeat the current iteration
    ),
    q=p(n),             //   Set q to the sum of the prime factors of n
    q^n?                //   If q != n then
        f(q)            //     repeat f with q
    :                   //   else
        q               //     return q
)

Answer 18

जावा 8, 101 बाइट्स

n->{for(int i=n;i-->0;n=f(n,2));return n;}int f(int n,int d){return n>1?n%d>0?f(n,d+1):d+f(n/d,2):0;}

पोर्ट ऑफ @ovs का अद्भुत पायथन 2 उत्तर ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

n->{                  // Method with integer as both parameter and return-type
  for(int i=n;i-->0;  //  Loop the input amount of times
    n=f(n,2)          //   And change `n` that many times with a separate method call
  );                  //  End of loop
  return n;           //  Then return the integer `n` as result
}                     // End of method

int f(int n,int d){   // Separated method with 2 integer parameters and integer return-type
                      // (`d` is 2 when we initially call this recursive-method)
  return n>1?         //  If input `n` is larger than 1:
    n%d>0?            //   And it's not divisible by `d`:
     f(n,d+1)         //    Do a recursive-call with `n, d+1`
    :                 //   Else:
     d                //    Sum `d` with
      +f(n/d,2)       //    a recursive call with `n/d, 2`
   :                  //  Else:
    0;                //   Simply return 0
}                     // End of separated method