21

संख्या n का एक भाजक कोई भी संख्या है जो समान रूप से n को विभाजित करता है , जिसमें 1 और n भी शामिल है। डिवेज़र्स की संख्या d (n) कितने डिवोर्स की संख्या है। यहाँ पहले जोड़े के लिए d (n) है :

n    divisors    d(n)
1    1           1
2    1, 2        2
3    1, 3        2
4    1, 2, 4     3
5    1, 5        2
6    1, 2, 3, 6  4

हम बार-बार एक नंबर से विभाजकों की संख्या घटा सकते हैं। उदाहरण के लिए:

16                  = 16
16 - d(16) = 16 - 5 = 11
11 - d(11) = 11 - 2 = 9
 9 - d( 9) =  9 - 3 = 6
 6 - d( 6) =  6 - 4 = 2
 2 - d( 2) =  2 - 2 = 0

इस मामले में 0 पर पहुंचने के लिए 5 कदम उठाए।

एक प्रोग्राम या फ़ंक्शन लिखिए जिसने एक नॉनजेगेटिव नंबर n दिया है और इसे कम करने के लिए चरणों की संख्या को घटाकर 0 की संख्या को बार-बार घटाना।

उदाहरण:

0, 0
1, 1
6, 2
16, 5
100, 19
100000, 7534

code-golf math integer

— orlp
स्रोत

5

अप्रचलित

— Sp3000

सम्बंधित।

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

1

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

डेनिस ♦ के लिए 1 बाइट धन्यवाद ।

पोर्ट ऑफ Pyth में मेरा उत्तर ।

ÆDLạµÐĿL’

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

परीक्षण सूट।

व्याख्या

_ÆDL$$ÐĿL’
      ÐĿ    Repeat the following until result no longer unique:
 ÆD             Yield the array of the divisors
   L            Yield the length of the array
_               Subtract that from the number
        L   Number of iterations
         ’  Minus one.

— लीक नन
स्रोत

6

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

f=lambda n:n and-~f(sum(n%~x<0for x in range(n)))

orlp ने एक बाइट को बचाने में मदद की! और Sp3000 ने दो और बचाए। धन्यवाद!

— लिन
स्रोत

1

ले जाकर चीजों को छोटा करने के लिए सक्षम होना चाहिए -~में n%-~k, और हटाने रेंज के लिए बाध्य कम है।

— orlp

5

सी, 52 बाइट्स

g,o;l(f){for(g=o=f;o;f%o--||--g);return f?1+l(g):0;}

— लिन
स्रोत

4

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

tl.ulf%NTS

परीक्षण सूट।

व्याख्या

tl.ulf%NTS
tl.ulf%NTSNQ  implicit variables at the end
           Q  obtain the input number
  .u      N   repeat the following until result no longer unique:
         S        generate range from 1 to N
     f            filter for:
      %NT             T in that range, which N%T is truthy (not zero)
    l             length of that list
                  that means, we found the number of "non-divisors" of N
tl            number of iterations, minus 1.

— लीक नन
स्रोत

3

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

f(n)=n<1?0:f(sum(n%(1:n).>0))+1

सीधा पुनरावर्ती कार्यान्वयन।

— Sp3000
स्रोत

2

MATL , 14 बाइट्स

`t~?x@q.]t:\zT

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

व्याख्या

`            T  % Infinite loop
 t~?    ]       % Duplicate number. Is it non-zero?
    x@q.        % If so: delete number, push iteration index minus 1, break loop
         t:\    % Duplicate, range, modulo (remainder). Divisors give a 0 remainder
            z   % Number of non-zero elements; that is, of non-divisors

— लुइस मेंडो
स्रोत

2

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

f=n=>n&&[...Array(m=n)].map((_,i)=>m-=n%++i<1)|f(m)+1

मुझसे मत पूछो कि मैं अनावश्यक रूप से पूंछ पुनरावृत्ति का उपयोग क्यों कर रहा था।

— नील
स्रोत

2

जावा, १४ ९ ३

a->{int k,i,n=new Integer(a),l=0;for(;n!=0;n-=k)for(l+=k=i=1;i<n;)if(n%i++==0)++k;return l;}

— HopefullyHelpful
स्रोत

3

n=new Integer(100000)इसके बजाय क्यों n=100000?

— user8397947

1

05AB1E, 12 10 बाइट्स

कोड:

[Ð>#Ñg-¼]¾

स्पष्टीकरण:

[           # start infinite loop
 Ð          # triplicate current number
  >#        # increase by 1 and break if true
    Ñg      # get number of divisors
      -     # subtract number of divisors from number
       ¼    # increase counter
        ]   # end loop
         ¾  # print counter

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

संपादित करें: 2 बाइट्स सहेजे गए हैं और इनपुट के साथ एक बग @ धन्यवाद के लिए निश्चित है

— Emigna
स्रोत

बहुत अच्छा! मैंने इसे थोड़ा सा गोल्फ करने की कोशिश की, और इसे 10 बाइट्स के लिए नीचे लाया [Ð>#Ñg-¼]¾:। हालांकि इसे छोटा करने का एक तरीका होना चाहिए ...

— अदनान

@LuisMendo हाँ, यह इसलिए है क्योंकि D0Q#भाग काउंटर की वृद्धि के बाद है। [Ð>#Ñg-¼]¾कोड के लिए काम करना चाहिए 0, हालांकि :)।

— अदनान

@ अदनान: मैंने एन तक सभी गणनाएँ बनाने और सूचकांक से मूल्य पर सूचकांक में जाने और गिनती के आधार पर एक संस्करण की कोशिश की, लेकिन इसे इस तरह से छोटा करने का प्रबंधन नहीं किया।

— एमिगा

1

आर, 50 बाइट्स

बहुत सरल कार्यान्वयन। इसे ऑनलाइन आज़माएं

z=scan();i=0;while(z>0){z=z-sum(z%%1:z<1);i=i+1};i

— उछलने वाली गेंद
स्रोत

1

मथकड, [tbd] बाइट्स

मथकड बाइट समतुल्यता योजना अभी तक निर्धारित नहीं की गई है। एक मोटे कीस्ट्रोक तुल्यता का उपयोग करते हुए, कार्यक्रम लगभग 39 "बाइट्स" का उपयोग करता है। ध्यान दें कि प्रोग्रामिंग ऑपरेटरों के लिए कुछ समय के लिए इनपुट (ctl-] और ctl-shft- #, क्रमशः) में से प्रत्येक के लिए केवल एक कीबोर्ड ऑपरेशन होता है - वास्तव में, वे केवल कीबोर्ड से इस तरह से प्रवेश कर सकते हैं।

आप जो देख रहे हैं, वह वही है जो एक मैथेक वर्कशीट पर रखा गया है। मठकाद समीकरणों / कार्यक्रमों का मूल्यांकन करता है और आउटपुट को एक ही शीट पर रखता है (उदाहरण के लिए, '=' मूल्यांकन ऑपरेटर या प्लॉट पर)।

— स्टुअर्ट ब्रुफ़
स्रोत

1

MATL, 13 बाइट्स

tX`t:\ztt]Nq&

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

स्पष्टीकरण:

t               % Duplicate input
 X`      ]      % while loop, consumes 1 input
   t:\z         % calculates n-d(n), by counting number non-divisors
       tt       % dupe twice, for while loop condition, next iteration and to keep in stack
          Nq&   % get stack size, decrement, display that value

— डेविड
स्रोत

1

मैथेमेटिका, 35 बाइट्स

If[#<1,0,#0[#-0~DivisorSigma~#]+1]&

अच्छे पुराने का उपयोग करना DivisorSigma। @ मार्टिनबरनर निम्नलिखित विकल्पों पर ध्यान देते हैं:

If[#<1,0,#0[#-DivisorSum[#,1&]]+1]&
f@0=0;f@n_:=f[n-DivisorSum[n,1&]]+1

— Sp3000
स्रोत

1

हून , 93 76 बाइट्स

|=
r/@
?~
r
0
+($(r (sub r (lent (skim (gulf 1^r) |=(@ =(0 (mod r +<))))))))

Ungolfed:

|=  r/@
?~  r
  0
=+  (skim (gulf 1^r) |=(@ =(0 (mod r +<))))
+($(r (sub r (lent -))))

एक फंक्शन लेता है जो एक परमाणु लेता है r,। एक मध्यवर्ती मान बनाएँ, जिसमें (सभी rसूची बनाएं (१. एन।]] के सभी अंश हैं, केवल उन तत्वों को रखें जहाँ (mod ri) == ०)। यदि rशून्य रिटर्न शून्य है, तो r बराबर r- (लंबाई विभाजक) के साथ पुनरावृत्ति का संवर्धित मूल्य लौटाएं।

कोड के रूप में n = 100.000 के लिए मूल्यांकन करने के लिए समय की एक मूर्ख राशि लेता है, पूरी तरह से क्योंकि बड़ी संख्या के लिए devisers खोजने के लिए एक विशाल सूची और उस पर नक्शे बनाता है। विभाजकों को याद करने से n = 10.000 के लिए सही आउटपुट मिलता है, लेकिन मैंने 100.000 के लिए प्रतीक्षा करने की जहमत नहीं उठाई

— RenderSettings
स्रोत

1

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

g 0=0;g n=1+g(sum$min 1.mod n<$>[1..n])

सरल पुनरावर्ती दृष्टिकोण। प्रयोग उदाहरण: g 16-> 5।

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

— nimi
स्रोत

कैसे के बारे में g(sum$signum.mod n<$>[1..n])?

— लिन

ओह, और min 1वास्तव में एक बाइट से signumभी छोटा है , यहां तक कि

— लिन

1

PowerShell v2 +, 74 67 बाइट्स

param($n)for($o=0;$n-gt0){$a=0;1..$n|%{$a+=!($n%$_)};$n-=$a;$o++}$o

कुछ अन्य उत्तर की तुलना में बहुत लंबा लगता है ...

इनपुट लेता है $n, forउस स्थिति के साथ एक लूप में प्रवेश करता है जो $nइससे अधिक है 0। प्रत्येक लूप पुनरावृत्ति हम सहायक सेट करते हैं $a, फिर 1ऊपर से हर संख्या के माध्यम से लूप $n। प्रत्येक आंतरिक लूप हम यह देखने के लिए कि क्या यह एक भाजक है, और यदि हम अपने सहायक $a(बूलियन नकार और अंतर्निहित का उपयोग करने के लिए अंतर) का उपयोग करते हैं, तो हर संख्या के खिलाफ जांच करते हैं । फिर, हम $n-=$aअपने काउंटर को कितने विभाजकों को मिला और घटाते हैं $o++। अंत में, हम उत्पादन करते हैं $o।

निष्पादित करने के लिए एक लंबा समय लगता है, क्योंकि यह एक महत्वपूर्ण लूप निर्माण है। उदाहरण के लिए, n = 10,000मेरी मशीन (1yr पुराना Core i5) पर चलने में लगभग 3 मिनट लगते हैं।

— AdmBorkBork
स्रोत

1

रैकेट - 126 बाइट्स डाउन टू 98 बाइट्स 91 बाइट्स

एक अत्यंत भोला समाधान - शायद एक सभ्य एल्गोरिथ्म और कुछ लिस्प चाल के साथ बहुत कम कटौती की जा सकती है जो मुझे नहीं पता है

~~(define(g x[c 0][d 0][i 2])(cond[(= x 0)c][(= i x)(g d(+ 1 c))][(=(modulo x i)0)(g x c d(+ 1 i))][else(g x c(+ 1 d)(+ 1 i))]))~~

संपादित करें: अनुरोध द्वारा स्पष्टीकरण। जैसा कि मैंने कहा, यह एक अत्यंत भोली पुनरावर्ती समाधान है और बहुत कम हो सकता है।

(define (g x [c 0] [d 0] [i 2]) ;g is the name of the function - arguments are x (input), c (counter for steps), d (non-divisor counter), i (iterator)
  (cond
    [(= x 0) c] ;once x gets to 0 c is outputted
    [(= i x) (g d (+ 1 c))] ;if iterator reaches x then we recurse with d as input and add 1 to c
    [(= (modulo x i) 0) (g x c d (+ 1 i))] ;checks if iterator is non divisor, then adds it to d and increments iterator
    [else(g x c (+ 1 d) (+ 1 i))])) ;otherwise just increments iterator

2 संपादित करें: एक कम गूंगा एल्गोरिथ्म के साथ 98 बाइट संस्करण (अभी भी बहुत गूंगा हालांकि और छोटा हो सकता है)

~~(define(g x)(if(< x 1)0(+ 1(g(length(filter(λ(y)(>(modulo x y)0))(cdr(build-list x values))))))))~~

स्पष्टीकरण:

(define (g x) ;function name g, input x
  (if (< x 1)
      0 ;returns 0 if x < 1 (base case)
      (+ 1 ;simple recursion - adds 1 to output for each time we're looping
         (g (length ;the input we're passing is the length of... 
              (filter (λ (y) (> (modulo x y) 0)) ;the list where all numbers which are 0 modulo x are 0 are filtered out from...
                             (cdr (build-list x values)))))))) ;the list of all integers up to x, not including 0

संपादित 3: 7 बाइट्स की जगह के (cdr(build-list x values))साथ सहेजा गया(build-list x add1)

(define(g x)(if(< x 1)0(+ 1(g(length(filter(λ(y)(>(modulo x y)0))(build-list x add1)))))))

— kronicmage
स्रोत

नमस्कार, और PPCG में आपका स्वागत है! महान पद! क्या आप अपना समाधान बता सकते हैं? (पीएस मैं लिस्प से प्यार करता हूं!)

— NoOneIsHere

@NoOneIsHere में संपादित किया गया

— क्रोनिकमेज

0

> <> , 52 + 2 = 54 बाइट्स

इनपुट नंबर को प्रोग्राम स्टार्ट पर स्टैक पर उपस्थित होने की आवश्यकता है, इसलिए +2 बाइट्स के लिए है -v ध्वज के । इसे ऑनलाइन आज़माएं!

:0)?v~ln;>~$-]
03[}\::
@@:$<    v?=0:-1}+{~$?@@01%@:

4 कष्टप्रद बाइट्स संरेखण मुद्दों पर बर्बाद हो गए। बाह।

यह एक से अनुक्रम का निर्माण करके काम करता है nके लिए 0ढेर पर। एक बार 0 तक पहुंचने के बाद, इसे पॉप करें और शेष स्टैक की लंबाई को हटा दें।

वैसे, यह O(n^2)समय में चलता है , इसलिए मैं कोशिश नहीं करूंगा n = 100000...

— सोक
स्रोत

-vएक बाइट है, दो नहीं।

— NoOneIsHere

0

> <> , 36 + 3 = 39 बाइट्स

:?v~ln; >~&
:}\0&
+&>1-:?!^:{:}$%0)&

कार्यान्वयन का अपेक्षाकृत सीधा, प्रत्येक पुनरावृत्ति के साथ sum(n%k>0 for k in range(1,n-1))। -vध्वज के लिए +3 बाइट्स , प्रति मेटा ।

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

— Sp3000
स्रोत

0

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

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

सबसे बड़े परीक्षण के मामले में एक स्टैक ओवरफ्लो त्रुटि है 100000, इसलिए यहां 49 बाइट्स के भीतर चलने का संस्करण है । हालांकि, O(N^2)जटिलता को देखते हुए कुछ समय लगता है।

->n{c=0;c+=1 while 0<n-=(1..n).count{|i|n%i<1};c}

— वैल्यू इंक
स्रोत

0

पर्ल 5, 40 बाइट्स

sub f{@_?(1,f((1)x grep@_%$_,1..@_)):()}

इनपुट और आउटपुट की प्रतियों की अपेक्षित संख्या की सूची के रूप में हैं 1।

— msh210
स्रोत

0

सी #, 63 बाइट्स

int F(int n)=>n<1?0:F(Enumerable.Range(1,n).Count(i=>n%i>0))+1;

— RedLaser
स्रोत

0

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

";╗R`╜%`░l;"£╬klD

इसे ऑनलाइन आज़माएं! (ध्यान दें: TIO पर अंतिम परीक्षा का समय)

स्पष्टीकरण:

";╗R`╜%`░l;"£╬klD
"          "£╬     while top of stack is truthy, call the function:
 ;╗                  push a copy of n to reg0
   R                 range(1,n+1) ([1,n])
    `  `░l             push the number of values where the following is truthy:
     ╜%                  k mod n
                       (this computes the number of non-divisors of n)
          ;            make a copy
              klD  push entire stack as list, count number of items, subtract 1
                   (the result is the number of times the function was called)

— मै जाऊं
स्रोत

भाजक घट

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

व्याख्या

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

सी, 52 बाइट्स

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

व्याख्या

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

MATL , 14 बाइट्स

व्याख्या

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

जावा, १४ ९ ३

05AB1E, 12 10 बाइट्स

आर, 50 बाइट्स

मथकड, [tbd] बाइट्स

MATL, 13 बाइट्स

मैथेमेटिका, 35 बाइट्स

हून , 93 76 बाइट्स

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

PowerShell v2 +, 74 67 बाइट्स

रैकेट - 126 बाइट्स डाउन टू 98 बाइट्स 91 बाइट्स

> <> , 52 + 2 = 54 बाइट्स

> <> , 36 + 3 = 39 बाइट्स

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

पर्ल 5, 40 बाइट्स

सी #, 63 बाइट्स

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