महानतम भाजक को घटाकर n से 1 तक कितने चरण होते हैं?

Question

गणित पर इस सवाल से प्रेरित ।

---

समस्या

आज्ञा nदेना एक प्राकृतिक संख्या है ≥ 2। का सबसे बड़ा भाजक लें n- जो nखुद से अलग है - और इससे घटाएं n। जब तक आप नहीं मिलते तब तक दोहराएं 1।

प्रश्न

1किसी दिए गए नंबर तक पहुंचने के लिए कितने कदम हैं n ≥ 2।

विस्तृत उदाहरण

चलो n = 30।

का सबसे बड़ा भाजक:

1.   30 is 15  -->  30 - 15 = 15
2.   15 is  5  -->  15 -  5 = 10
3.   10 is  5  -->  10 -  5 =  5
4.    5 is  1  -->   5 -  1 =  4
5.    4 is  2  -->   4 -  2 =  2
6.    2 is  1  -->   2 -  1 =  1

यह लेता है 6 चरणों तक पहुँचने के लिए 1।

इनपुट

• इनपुट एक पूर्णांक है n, जहां n ≥ 2।
• आपके प्रोग्राम को भाषा के अधिकतम पूर्णांक मान तक इनपुट का समर्थन करना चाहिए।

उत्पादन

• बस चरणों की संख्या, जैसे आउटपुट 6।
• व्हाट्सएप के लीडिंग / ट्रेलिंग या न्यूलाइन्स ठीक हैं।

उदाहरण

f(5)        --> 3
f(30)       --> 6
f(31)       --> 7
f(32)       --> 5
f(100)      --> 8
f(200)      --> 9
f(2016^155) --> 2015

आवश्यकताएँ

• आप STDINफ़ंक्शन पैरामीटर्स से फ़ंक्शन पैरामीटर के रूप में या निकटतम समकक्ष से इनपुट प्राप्त कर सकते हैं ।
• आप एक कार्यक्रम या एक समारोह लिख सकते हैं। यदि यह एक अनाम फ़ंक्शन है, तो कृपया इसे कैसे लागू करें, इसका एक उदाहरण शामिल करें।
• यह कोड-गोल्फ है इसलिए बाइट्स में सबसे कम जवाब जीतता है।
• मानक खामियों को अस्वीकार कर दिया जाता है।

---

इस श्रृंखला को OEIS पर भी पाया जा सकता है: A064097

एक अर्ध लघुगणक द्वारा उपपादन द्वारा परिभाषित a(1) = 0और a(p) = 1 + a(p-1)अगर pप्रधानमंत्री और है a(n*m) = a(n) + a(m)यदि m,n > 1।

Comments

देशी मनमानी परिशुद्धता पूर्णांक के साथ भाषाओं में इनपुट आवश्यकता को स्पष्ट करें?

— Sparr

@ मैं कहूंगा, आपको कम से कम समर्थन करना चाहिए 2^32 - 1। बाकी आप और आपके सिस्टम पर निर्भर है। आशा है, यह वही है जो आपके प्रश्न के साथ था।

— इन्सर्टसर्नमीयर

मुझे यह पसंद आया कि यह शीर्षक कैसे

— गाया जाता है

Answer 1

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

ÆṪÐĿÆFL€S

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

अनुक्रम A064097 की परिभाषा का अर्थ है कि

द्वारा यूलर उत्पाद सूत्र

जहां φ यूलर के क्षणिक कार्य को दर्शाता है और p केवल अभाज्य संख्याओं पर भिन्न होता है।

दोनों को मिलाकर, हम संपत्ति में कटौती करते हैं

जहां ω n के विभिन्न प्रमुख कारकों की संख्या को दर्शाता है ।

जिसके परिणामस्वरूप सूत्र लागू k + 1 बार है, जहां कश्मीर काफी बड़ी है ताकि φ ^{k + 1} (एन) = 1 पर हम पाते हैं

इस संपत्ति से, हम सूत्र प्राप्त करते हैं

जहां अंतिम समानता रखती है क्योंकि ω (1) = 0 ।

यह काम किस प्रकार करता है

ÆṪÐĿÆFL€S  Main link. Argument: n

  ÐĿ       Repeatedly apply the link to the left until the results are no longer
           unique, and return the list of unique results.
ÆṪ           Apply Euler's totient function.
           Since φ(1) = 1, This computes φ-towers until 1 is reached.
    ÆF     Break each resulting integer into [prime, exponent] pairs.
      L€   Compute the length of each list.
           This counts the number of distinct prime factors.
        S  Add the results.

Comments

अब यह एक सुपर चालाक दृष्टिकोण है!

— अबराम

Answer 2

05AB1E , 13 11 बाइट्स

कोड:

[DÒ¦P-¼D#]¾

स्पष्टीकरण:

[        ]   # An infinite loop and...
       D#        break out of the loop when the value is equal to 1.
 D           # Duplicate top of the stack (or in the beginning: duplicate input).
  Ò          # Get the prime factors, in the form [2, 3, 5]
   ¦         # Remove the first prime factor (the smallest one), in order to get 
               the largest product.
    P        # Take the product, [3, 5] -> 15, [] -> 1.
     -       # Substract from the current value.
      ¼      # Add one to the counting variable.
          ¾  # Push the counting variable and implicitly print that value.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

Comments

सबसे बड़ा उत्पाद प्राप्त करने के लिए पहला प्रमुख कारक (सबसे छोटा एक) निकालें, कितना चतुर! :-)

— लुइस मेंडू

मैं देखता हूं, आप भाषा के विकासकर्ता हैं

— सर्ज बोर्स्च

@ सर्जबॉर्श हां, यह सही है :)

— अदनान

[¼Ñü-¤ÄD#]¾- मैं जोड़ीदार के साथ एक बाइट को बंद करने के करीब था, ओह अच्छी तरह से ...

— मैजिक ऑक्टोपस उर्न

-1 बाइट [Ð#Ò¦P-¼]¾:। Ðसे बेहतर है DD।

— ग्रैमी

Answer 3

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

fq1=-Q/QhPQ

परीक्षण सूट

एक सीधा-सा दोहराव-जब तक-सही लूप।

स्पष्टीकरण:

fq1=-Q/QhPQ
               Implicit: Q = eval(input())
f              Apply the following function until it is truthy,
               incrementing T each time starting at 1:
         PQ    Take the prime factorization of Q
        h      Take its first element, the smallest factor of Q
      /Q       Divide Q by that, giving Q's largest factor
    -Q         Subtract the result from Q
   =           Assign Q to that value
 q1            Check if Q is now 1.

Comments

कि filter के साथ एक बहुत अच्छी चाल है ।

— माल्टीसेन

मुझे समझ में नहीं आता है कि यह फ़ंक्शन चलने की संख्या को क्यों आउटपुट करता है। क्या यह एक अनिर्दिष्ट सुविधा है f?

— corsiKa

fदूसरे तर्क के बिना @corsiKa सभी सकारात्मक पूर्णांकों से शुरू होता है 1और आंतरिक विवरण पर सही होने वाला पहला मान लौटाता है। यह मान इस कार्यक्रम में अप्रयुक्त होने के लिए होता है, इसलिए यह उस समय की संख्या लौटाता है जो इसे चलाया गया था। forfor(int i=1; some_condition_unrelated_to_i; i++) { change_stuff_that_affects_condition_but_not_i;}

— अकारण

@corsiKa यह ऑनलाइन दुभाषिया के दाईं ओर चरित्र संदर्भ में प्रलेखित है। केवल एक ही तर्क (साथ f <l:T> <none>), fहै सबसे पहले इनपुट जहां A(_)अधिक truthy है[1, 2, 3, 4...] ।

— डेनिस

आह मैं अब समझ गया। यह उस इनपुट का उपयोग करता है लेकिन गणना में इनपुट का उपयोग कभी नहीं करता है । यह बताता है कि @Maltysen की टिप्पणी "यह एक बहुत अच्छी चाल है" क्योंकि आप केवल अपने फ़िल्टर में कहीं भी उस गणना का उपयोग नहीं करने के लिए पुनरावृत्ति गिनती के बारे में परवाह करते हैं। मैं उन आह-हा पलों से प्यार करता हूं !

— :)

Answer 4

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

f=lambda n,k=1:2/n or n%(n-k)and f(n,k+1)or-~f(k)

यह है कि पिछले परीक्षण के मामले को किसी भी समय जल्द ही खत्म नहीं होने जा रहा है ...

वैकल्पिक रूप से, यहां एक 48-बाइट जो रिटर्न है Trueके बजाय 1के लिए n=2:

f=lambda n,k=1:n<3or n%(n-k)and f(n,k+1)or-~f(k)

Answer 5

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

ÆfḊPạµÐĿi2

इसे ऑनलाइन आज़माएं! या अधिकांश परीक्षण मामलों को सत्यापित करें । अंतिम परीक्षण के मामले स्थानीय स्तर पर जल्दी खत्म हो जाते हैं।

यह काम किस प्रकार करता है

ÆfḊPạµÐĿi2  Main link. Argument: n (integer)

Æf          Factorize n, yielding a list of primes, [] for 1, or [0] for 0.
  Ḋ         Dequeue; remove the first (smallest) element.
   P        Take the product.
            This yields the largest proper divisor if n > 1, 1 if n < 2.
    ạ       Yield the abs. value of the difference of the divisor (or 1) and n.
     µ      Convert the chain to the left into a link.
      ÐĿ    Repeatedly execute the link until the results are no longer unique.
            Collect all intermediate results in a list.
            For each starting value of n, the last results are 2 -> 1 -> 0 (-> 1).
        i2  Compute the 1-based index of 2.

Answer 6

रेटिना , १२

• 14 बाइट्स ने @ मार्टिनबटनर को धन्यवाद दिया

(1 +) (? = \ 1 + $)

यह दशमलव में दिए गए असमान और आउटपुट में दिए गए इनपुट को मानता है । यदि यह स्वीकार्य नहीं है तो हम इसे 6 बाइट्स के लिए और अधिक कर सकते हैं:

रेटिना , 18

• 8 बाइट्स ने @ मार्टिनबटनर को धन्यवाद दिया

। +
$ *
(1 +) (? = \ 1 + $)

इसे ऑनलाइन आज़माएँ - सभी लाइन को एक बार में चलाने के लिए पहली पंक्ति जोड़ी गई।

अफसोस की बात है कि यह गणना के लिए एकात्मक का उपयोग करता है, इसलिए 2016 ¹⁵⁵ का इनपुट व्यावहारिक नहीं है।

• पहला चरण (2 लाइन) बस दशमलव इनपुट को 1एस के एक स्ट्रिंग के रूप में यूरीरी में परिवर्तित करता है
• दूसरा चरण (1 लाइन) regex मिलान समूहों का उपयोग करके n के सबसे बड़े कारक की गणना करता है और इसे n से प्रभावी रूप से घटाता है। यह रेगेक्स जितनी बार संभव हो, संख्या को कम करने के लिए आवश्यक है। रेगेक्स मैचों की संख्या चरणों की संख्या होगी, और इस चरण द्वारा आउटपुट है।

Comments

मुझे नहीं लगता कि आपको इसकी आवश्यकता है \b।

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

आप एक बहुत अधिक बचा सकता है हालांकि इस तरह और तकनीकी रूप से आप पहले चरण या तो ज़रूरत नहीं है ।

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

@ मार्टिनबटनर शानदार! बहुत सुंदर - धन्यवाद!

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

Answer 7

पायथ - 15 14 13 बाइट्स

विशेष आवरण 1वास्तव में मुझे मार रहा है।

tl.u-N/Nh+PN2

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

tl                One minus the length of
 .u               Cumulative fixed point operator implicitly on input
  -N              N -
   /N             N /
    h             Smallest prime factor
     +PN2         Prime factorization of lambda var, with two added to work with 1

Comments

एक बात जो मैं हमेशा भूल जाता हूं .... जानवर बल अक्सर गोल्फ का दृष्टिकोण होता है

— लीक नून

विशेष आवरण के साथ आपका क्या मतलब है 1?

— अदनान

@ का मुख्य कारक 1है [], जो पहले तत्व को लेते समय एक त्रुटि का कारण बनता है। मुझे इसे 1फिर से वापस करने के लिए विशेष मामला करना होगा ताकि .uफिक्स्ड-पॉइंट समाप्त हो। मैंने .xकोशिश करने के अलावा एक बेहतर तरीका खोजा -सिवाय इसके कि मुझे उन 2 बाइट्स से क्या बचा।

— माल्टसेन

इसे केवल संख्याएँ = = 2 (> 1) स्वीकार करने की आवश्यकता है।

— सोलोमन उको

@SolomonUcko आप गलत समझ रहे हैं, .uनिश्चित-बिंदु अंततः 1सभी इनपुट के लिए पहुंच जाएगा , जिस बिंदु पर उसे विशेष आवरण बनाना होगा।

— माल्टेन

Answer 8

जावास्क्रिप्ट (ईएस 6), * 44 38

6 बाइट्स संपादित करें धन्यवाद @ l4m2

(* 4 धारीदार अभी भी 4 है)

पुनरावर्ती कार्य

f=(n,d=n)=>n>1?n%--d?f(n,d):f(n-d)+1:0

कम गोल्फ वाला

f=(n, d=n-1)=>{
  if (n>1)
    if(n % d != 0)
      return f(n, d-1) // same number, try a smaller divisor
    else
      return f(n-d)+1  // reduce number, increment step, repeat
  else
    return 0
}

परीक्षा

f=(n,d=n)=>n>1?n%--d?f(n,d):f(n-d)+1:0

console.log=x=>O.textContent+=x+'\n';

[5,30,31,32,100,200].forEach(x=>console.log(x+' -> '+f(x)))

<pre id=O></pre>

Comments

अच्छा है, लेकिन मुझे लगता है कि आपको एफ (1) == 0. बनाने के लिए आवश्यक दो बाइट खर्च करनी चाहिए

— नील

@ नई सोच फिर से: नहीं। "एन नेचुरल नंबर ... 2 ..."

— edc65

मुझे नए चश्मे चाहिए।

— नील

क्यों नहीं f=(n,d=n)=>n>1?n%--d?f(n,d):f(n-d)+1:0?

— l4m2

@ l4m2 सही है, क्यों नहीं? धन्यवाद

— edc65

Answer 9

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

f@1=0;f@n_:=f[n-Divisors[n][[-2]]]+1

एक अनाम फ़ंक्शन समान बाइट्स लेता है:

If[#<2,0,#0[#-Divisors[#][[-2]]]+1]&

यह एक पुनरावर्ती कार्य के रूप में परिभाषा का बहुत सीधा कार्यान्वयन है।

Answer 10

ऑक्टेव, 59 58 55 बाइट्स

function r=f(x)r=0;while(x-=x/factor(x)(1));r++;end;end

1 बाइट की बचत, स्ट्यू ग्रिफिन को धन्यवाद

आगे की जाँच करें, जबकि समय-जाँच में गुणन के परिणाम का उपयोग करके तीन और बाइट्स की बचत।

नमूना चलता है:

octave:41> f(5)
ans =  3
octave:42> f(30)
ans =  6
octave:43> f(31)
ans =  7
octave:44> f(32)
ans =  5
octave:45> f(100)
ans =  8
octave:46> f(200)
ans =  9

Comments

endऑक्टेव में अंतिम आवश्यक है?

— अब्राहम

यह है। मैंने देखा कि यह आपके उत्तरों से मतलाब में नहीं था, लेकिन ऑक्टेव को उम्मीद है (जैसा कि मैंने ओक्टेव में आपका प्रयास करने से सीखा था)।

— dcsohl

Answer 11

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

f 1=0;f n=1+(f$n-(last$filter(\x->n`mod`x==0)[1..n`div`2]))

उपयोग:

Prelude> f 30
Prelude> 6

सूची बनाने के कारण बड़ी संख्या के लिए यह थोड़ा अक्षम हो सकता है।

Comments

समझ की सूची और <1इसके बजाय ==0कुछ बाइट्स बचाता है: f 1=0;f n=1+f(n-last[a|a<-[1..ndiv2],mod n a<1])

— Angs

Answer 12

जूलिया, 56 50 45 39 बाइट्स

f(n)=n>1&&f(n-n÷first(factor(n))[1])+1

यह एक पुनरावर्ती कार्य है जो पूर्णांक को स्वीकार करता है और पूर्णांक देता है।

Ungolfed:

function f(n)
    if n < 2
        # No decrementing necessary
        return 0
    else
        # As Dennis showed in his Jelly answer, we don't need to
        # divide by the smallest prime factor; any prime factor
        # will do. Since `factor` returns a `Dict` which isn't
        # sorted, `first` doesn't always get the smallest, and
        # that's okay.
        return f(n - n ÷ first(factor(n))[1]) + 1
    end
end

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामले शामिल हैं)

मार्टिन बंटनर के लिए 6 बाइट और डेनिस के लिए 11 धन्यवाद बचे!

Answer 13

PowerShell v2 +, 81 बाइट्स

param($a)for(;$a-gt1){for($i=$a-1;$i-gt0;$i--){if(!($a%$i)){$j++;$a-=$i;$i=0}}}$j

क्रूर बल का सबसे क्रूर।

इनपुट लेता है $a, एक forलूप में प्रवेश करता है जब तक $aकि उससे कम या उसके बराबर नहीं होता है 1। प्रत्येक लूप हम एक और forलूप के माध्यम से जाते हैं जो $aतब तक नीचे गिना जाता है जब तक हम एक भाजक ( !($a%$i) नहीं ढूंढते । सबसे कम, हम $i=1एक भाजक के रूप में पाएंगे । जब हम करते हैं, हमारे काउंटर को बढ़ाते हैं, $jहमारे विभाजक को घटाते हैं $a-=$iऔर $i=0आंतरिक लूप से बाहर निकलने के लिए सेट होते हैं। आखिरकार, हम एक ऐसी स्थिति में पहुंच जाएंगे, जहां बाहरी लूप गलत है (यानी, $aपहुंच गया है 1), इसलिए आउटपुट $jऔर निकास।

सावधानी : यह बड़ी संख्या में लंबे समय लेगा , विशेष रूप से primes। मेरे कोर आई 5 लैपटॉप पर 100,000,000 का इनपुट ~ 35 सेकंड लेता है। संपादित करें - बस [int]::MaxValue(2 ^ 32-1) के साथ परीक्षण किया गया , और इसमें ~ 27 मिनट लगे। बहुत बुरा नहीं है , मुझे लगता है।

Answer 14

मतलाब, 58 बाइट्स

function p=l(a),p=0;if(a-1),p=1+l(a-a/min(factor(a)));end

Answer 15

Japt , 12 बाइट्स (गैर-प्रतिस्पर्धात्मक)

@!(UµUk Å×}a

इसे ऑनलाइन टेस्ट करें! गैर-प्रतिस्पर्धात्मक क्योंकि यह उन विशेषताओं का एक गुच्छा उपयोग करता है जिन्हें चुनौती पोस्ट किए जाने के बाद जोड़ा गया था।

यह काम किस प्रकार करता है

@   !(Uµ Uk Å  ×   }a
XYZ{!(U-=Uk s1 r*1 }a
                       // Implicit: U = input integer
XYZ{               }a  // Return the smallest non-negative integer X which returns
                       // a truthy value when run through this function:
         Uk            //   Take the prime factorization of U.
            s1         //   Slice off the first item.
                       //   Now we have all but the smallest prime factor of U.
               r*1     //   Reduce the result by multiplication, starting at 1.
                       //   This takes the product of the array, which is the
                       //   largest divisor of U.
      U-=              //   Subtract the result from U.
    !(                 //   Return !U (which is basically U == 0).
                       //   Since we started at 0, U == 1 after 1 less iteration than
                       //   the desired result. U == 0 works because the smallest
                       //   divisor of 1 is 1, so the next term after 1 is 0.
                       // Implicit: output result of last expression

यह तकनीक 05AB1E उत्तर से प्रेरित थी । पिछले संस्करण का उपयोग किया गया ²¤(एक 2 पुश करें, पहले दो आइटम बंद करें) के स्थान पर Åक्योंकि यह एक बाइट से कम है s1 (नोट ट्रैसर स्पेस); मुझे केवल इस तथ्य के बाद एहसास हुआ कि क्योंकि यह शुरुआत से सरणी और स्लाइस के अंत में एक 2 को जोड़ता है , यह वास्तव में किसी भी विषम संयुक्त संख्या पर विफल रहता है, हालांकि यह सभी दिए गए परीक्षण मामलों पर काम करता है।

Answer 16

पायथन 3, 75, 70 , 67 बाइट्स।

g=lambda x,y=0:y*(x<2)or[g(x-z,y+1)for z in range(1,x)if x%z<1][-1]

यह एक बहुत सीधे आगे पुनरावर्ती समाधान है। यह उच्च संख्या परीक्षण मामलों के लिए बहुत लंबा समय लेता है।

Answer 17

> <>, 32 बाइट्स

<\?=2:-$@:$/:
1-$:@@:@%?!\
;/ln

nस्टैक पर इनपुट नंबर की अपेक्षा करता है ।

यह प्रोग्राम स्टैक पर पूर्ण अनुक्रम बनाता है। केवल संख्या है कि करने के लिए नेतृत्व कर सकते हैं के रूप में 1है 2, अनुक्रम का निर्माण जब बंद हो जाता है 2पहुँच जाता है। यह स्टैक का आकार भी चरणों की संख्या के बराबर चरणों की संख्या का कारण बनता है, बजाय चरण +1 की संख्या के।

Answer 18

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

f=->x{x<2?0:1+f[(1..x).find{|i|x%(x-i)<1}]}

सबसे छोटी संख्या का पता लगाएं, iजो तब तक xविभाजित x-iऔर पुनरावृत्ति करता है जब तक हम नहीं पहुंचते 1।

Answer 19

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

यहाँ कोड है:

a&b|b<2=0|a==b=1+2&(b-1)|mod b a<1=1+2&(b-div b a)|1<2=(a+1)&b
(2&)

और यहाँ एक कारण हास्केल का कमाल है:

f = (2&)

(-->) :: Eq a => a -> a -> Bool
(-->) = (==)

h=[f(5)        --> 3
  ,f(30)       --> 6
  ,f(31)       --> 7
  ,f(32)       --> 5
  ,f(100)      --> 8
  ,f(200)      --> 9
  ,f(2016^155) --> 2015
  ]

हाँ, हास्केल में आप इसके -->समकक्ष परिभाषित कर सकते हैं ==।

Answer 20

मतलाब, 107 बाइट्स

a=input('');b=factor(a-isprime(a));c=log2(a);while(max(b)>1),b=max(factor(max(b)-1));c=c+1;end,disp(fix(c))

• गैर-प्रतिस्पर्धात्मक, यह मेरे पिछले सबमिशन का पुनरावृत्तीय अनुवाद नहीं है, बस एक और प्रत्यक्ष बीजगणितीय विधि है, यह सभी प्रमुख कारकों के सभी बाइनरी-लॉग्स को प्रस्तुत करता है, उदाहरण के लिए अस्पष्ट।
• मेरे पास समय होने पर मैं इसे और अधिक गोल्फ करूंगा।

Answer 21

MATL, 17 16 बाइट्स

`tttYfl)/-tq]vnq

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

व्याख्या

        % Implicitly grab input
`       % Do while loop
    ttt % Make three copies of top stack element
    Yf  % Compute all prime factors
    l)  % Grab the smallest one
    /   % Divide by this to get the biggest divisor
    -   % Subtract the biggest divisor
    t   % Duplicate the result
    q   % Subtract one (causes loop to terminate when the value is 1). This
        % is functionally equivalent to doing 1> (since the input will always be positive) 
        % with fewer bytes
]       % End do...while loop
v       % Vertically concatenate stack contents (consumes entire stack)
n       % Determine length of the result
q       % Subtract 1 from the length
        % Implicitly display result

Answer 22

C99, 62 61 बाइट्स

1 बाइट @ एच्माइस्ट द्वारा बंद की गई।

f(a,c,b)long*c,a,b;{for(*c=0,b=a;a^1;a%--b||(++*c,b=a-=b));}  

F (x, & y) के रूप में कॉल करें, जहां x इनपुट है और y आउटपुट है।

Comments

यदि आप% - b का परीक्षण करते हैं तो आप अंत में b-- से बच सकते हैं। एक पूरे एक बाइट की बचत।

— अल्काइमर

Answer 23

जूलिया, 39 36 बाइट्स

\(n,k=2)=n%k>0?n>1&&n\-~k:\(n-n/k)+1

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

Answer 24

क्लोजर, 116 104 बाइट्स

(fn[n](loop[m n t 1](let[s(- m(last(filter #(=(rem m %)0)(range 1 m))))](if(< s 2)t(recur s (inc t))))))

-12 बाइट्स गुणकों को खोजने के लिए एक सीमा को फ़िल्टर करके, फिर lastसबसे बड़ी एक प्राप्त करने के लिए एक का उपयोग करके

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

पूर्वनिर्मित और परीक्षण:

(defn great-divider [n]
  ; Filter a range to find multiples, then take the last one to get the largest
  (last
     (filter #(= (rem n %) 0)
             (range 1 n))))

(defn sub-great-divide [n]
  (loop [m n
         step 1]
    (let [g-d (great-divider m) ; Find greatest divisor of m
          diff (- m g-d)] ; Find the difference
      (println m " is " g-d " --> " m " - " g-d " = " diff)
      (if (< diff 2)
        step
        (recur diff (inc step))))))

(sub-great-divide 30)

30  is  15  -->  30  -  15  =  15
15  is  5  -->  15  -  5  =  10
10  is  5  -->  10  -  5  =  5
5  is  1  -->  5  -  1  =  4
4  is  2  -->  4  -  2  =  2
2  is  1  -->  2  -  1  =  1
6

Comments

@insertusernamehere नहीं, दुर्भाग्य से, क्योंकि वे सभी मान्य पहचानकर्ता हैं। मैंने सभी संभावित व्हाट्सएप को हटा दिया है। अगर मैं इसे आगे बढ़ाना चाहता हूं, तो मुझे एल्गोरिथ्म को फिर से तैयार करना होगा।

— कारिन्जिनेट

Answer 25

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

{+({$_ -first $_%%*,[R,] ^$_}...1)}

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

यह काम किस प्रकार करता है

{                                 }   # A bare block lambda.
                    [R,] ^$_          # Construct range from arg minus 1, down to 0.
        first $_%%*,                  # Get first element that is a divisor of the arg.
    $_ -                              # Subtract it from the arg.
   {                        }...1     # Do this iteratively, until 1 is reached.
 +(                              )    # Return the number of values generated this way.

Answer 26

पायथ, 17 16 बाइट्स

L?tbhy-b*F+1tPb0

इसे ऑनलाइन आज़माएं! ( y.vअंत में फ़ंक्शन कॉलिंग के लिए है)

---

मूल 17 बाइट्स:

L?tb+1y-b*F+1tPb0

इसे ऑनलाइन आज़माएं! ( y.vअंत में फ़ंक्शन कॉलिंग के लिए है)

(मैंने वास्तव में इस प्रश्न का उत्तर इस पायथ कार्यक्रम के साथ दिया है।)

Comments

मैं वास्तव में आपके कार्यक्रम के माध्यम से जाने से परेशान नहीं था, लेकिन यदि आप ओपी में पुनरावर्ती परिभाषा का उपयोग कर रहे हैं, uतो शायद वास्तविक पुनरावृत्ति से कम है।

— माल्टेन

Answer 27

Pyke, 11 बाइट्स (नॉनकमेटिंग)

D3Phf-oRr;o

यह एक नए व्यवहार का उपयोग करता है जहां अगर किसी गोटो के बाद कोई अपवाद उठाया जाता है, तो यह गोटो (वैरिएबल परिभाषाओं को छोड़कर) से पहले की स्थिति को पुनर्स्थापित करता है और जारी रखता है। इस मामले में यह निम्नलिखित अजगर कोड के बराबर है:

# Implicit input and variable setup
inp = input()
o = 0
# End implicit
try:
    while 1:
        inp -= factors(inp)[0] # If factors is called on the value 1, it returns an empty
                               # list which when the first element tries to be accessed
                               # raises an exception
        o += 1 # Using `o` returns the current value of `o` and increments it
except:
    print o # This in effect gets the number of times the loop went

यह कुछ समय के लूप निर्माण के बिना Pyke का उपयोग करके संभव है - yay गोटो!

यहाँ यह कोशिश करो!

Answer 28

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

f=(n,i=2)=>n<i?0:n%i?f(n,i+1):n>i?f(i)+f(n/i):1+f(n-1)

प्रदान किए गए पुनरावर्ती सूत्र का कार्यान्वयन, लेकिन अब भाजक को खोजने के लिए भी पुनरावर्तन का उपयोग करने के लिए अद्यतन किया गया है।

Answer 29

पर्ल, 57 + 1 ( -pध्वज) = 58 बाइट्स

$n=$_;$n-=$n/(grep!($n%$_),2..$n/2,$n)[0],$\++while$n>1}{

उपयोग:

> echo 31 | perl -pe '$n=$_;$n-=$n/(grep!($n%$_),2..$n/2,$n)[0],$\++while$n>1}{'

Ungolfed:

while (<>) {
# code above added by -p
    # $_ has input value
    # $\ has undef (or 0)
    my $n = $_;
    while ($n > 1) {
        my $d = 1;
        for (2 .. ($n / 2)) {
            if ($n % $_ == 0) {
                $d = $n / $_;
                last;
            }
        }
        $n -= $d;
        $\++;
    }
} {
# code below added by -p
    print;  # prints $_ (undef here) and $\
}

Answer 30

क्लोजर, 98 96 बाइट्स

#(loop[n % i -1](if n(recur(first(for[j(range(dec n)0 -1):when(=(mod n j)0)](- n j)))(inc i))i))

for :whenसबसे बड़ा विभाजक खोजने के लिए उपयोग करता है, जब तक कि ऐसा कोई भी बड़ा मूल्य नहीं मिल जाता है।