Iterated Divisor Twist

Question

परिभाषाएं

आज्ञा देना mऔर nसकारात्मक पूर्णांक हो। हम कहते हैं कि mएक है भाजक मोड़ के nपूर्णांक वहां मौजूद है, तो 1 < a ≤ bऐसा है कि n = a*bऔर m = (a - 1)*(b + 1) + 1। यदि mइसे nशून्य या अधिक विभाजक ट्विस्ट लगाकर प्राप्त किया जा सकता है, तो mइसका एक वंशज है n। ध्यान दें कि हर नंबर का अपना वंशज है।

उदाहरण के लिए, विचार करें n = 16। हम चुन सकते हैं a = 2और b = 8, तब से 2*8 = 16। फिर

(a - 1)*(b + 1) + 1 = 1*9 + 1 = 10

जो दिखाता है कि 10एक भाजक मोड़ है 16। साथ a = 2और b = 5, हम तो देखते हैं कि 7का एक भाजक मोड़ है 10। इस प्रकार 7का वंशज है 16।

काम

एक सकारात्मक पूर्णांक को देखते हुए , डुप्लिकेट के बिना, बढ़ते क्रम में सूचीबद्ध nके वंशज की गणना करें n।

नियम

आपको अंतर्निहित ऑपरेशन का उपयोग करने की अनुमति नहीं है जो किसी संख्या के विभाजकों की गणना करते हैं।

पूर्ण कार्यक्रमों और कार्यों दोनों को स्वीकार किया जाता है, और एक संग्रह डेटाटाइप (जैसे किसी प्रकार का एक सेट) को वापस करने की अनुमति दी जाती है, जब तक कि इसे क्रमबद्ध और डुप्लिकेट-मुक्त नहीं किया जाता है। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

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

1 ->  [1]
2 ->  [2] (any prime number returns just itself)
4 ->  [4]
16 -> [7, 10, 16]
28 -> [7, 10, 16, 25, 28]
51 -> [37, 51]
60 -> [7, 10, 11, 13, 15, 16, 17, 18, 23, 25, 28, 29, 30, 32, 43, 46, 49, 53, 55, 56, 60]

Comments

@ ज़र्गर यदि आप 0 डिविज़र ट्विस्ट की श्रृंखला के लिए अनुमति देते हैं, तो हर नंबर किसी अन्य नंबर का वंशज कैसे नहीं है?

— रोरलर्क

@ आर्कम मेरे लिए, शून्य संचालन की एक श्रृंखला का मतलब पहचान ऑपरेशन है। इसलिए शून्य विभाजक की अनुमति देने से केवल यह पता चलता है कि प्रत्येक संख्या स्वयं का वंशज है।

— ज़गरब

@Zgarb ठीक है, इसलिए इसे व्यक्त करने के लिए परिभाषा बदल दी जानी चाहिए, क्योंकि यदि नहीं, तो जहाँ तक मैं बता सकता हूँ, किसी भी संख्या को हर दूसरी संख्या का वंशज माना जाता है। मुझे नहीं पता कि इसकी संवेदनशीलता की आवश्यकता क्यों है। क्या आप समझाना चाहेंगे?

— रोरलर्क

@ चापलूसी से मैंने शब्दांकन को थोड़ा बदल दिया, क्या यह अब स्पष्ट है?

— जगरब

@Zgarb क्षमा करें, लेकिन नहीं, यह एक ऑपरेशन नहीं है, आप संख्याओं के बीच संबंध को परिभाषित कर रहे हैं। यदि आप <प्राकृतिक संख्याओं के लिए संबंध को परिभाषित करते हैं , तो प्रत्येक n के लिए आप हर संख्या को इससे छोटा पाते हैं, लेकिन स्वयं नहीं। मुझे लगता है कि यह कुछ इसी तरह का होना चाहिए। इस तरह मुझे लगता है कि केवल 4 ही इसका वंशज होगा (इस बारे में निश्चित नहीं है, हालांकि)।

— रोरलर्क

Answer 1

पायथन 2, 109 98 85 82 बाइट्स

f=lambda n:sorted(set(sum(map(f,{n-x+n/x for x in range(2,n)if(n<x*x)>n%x}),[n])))

के बाद से (a-1)*(b+1)+1 == a*b-(b-a)और b >= a, वंश हमेशा की तुलना में कम कर रहे हैं या मूल संख्या के बराबर। इसलिए हम सिर्फ शुरुआती संख्या से शुरुआत कर सकते हैं और तब तक सख्ती से छोटे वंशज पैदा कर सकते हैं जब तक कि कोई बचा नहीं है।

हालत (n<x*x)>n%xएक में दो चीजों की जांच करती है - वह n<x*xऔर n%x == 0।

(बेस केस से 3 बाइट लेने के लिए @xnor को धन्यवाद)

पायथ, 32 बाइट्स

LS{s+]]bmydm+-bk/bkf><b*TT%bTr2b

उपरोक्त का सीधा अनुवाद, इस तथ्य को छोड़कर कि sखाली सूची पर योग ( ) की कोशिश करते समय पायथ को घुटना लगता है ।

यह एक फ़ंक्शन को परिभाषित करता yहै जिसे y<number>अंत में जोड़कर बुलाया जा सकता है , जैसे कि ( इसे ऑनलाइन आज़माएं ):

LS{s+]]bmydm+-bk/bkf><b*TT%bTr2by60

सीजेएम, 47 45 बाइट्स

{{:X_,2>{__*X>X@%>},{_X\/\-X+}%{F}%~}:F~]_&$}

कुछ संशोधनों के साथ, एक ही विधि का उपयोग करना। मैं तुलना के लिए सीजेएम की कोशिश करना चाहता था, लेकिन दुर्भाग्य से मैं सीजेएम में पाइथ / पाइथन की तुलना में बहुत खराब हूं, इसलिए शायद सुधार के लिए बहुत जगह है।

उपरोक्त एक ब्लॉक (मूल रूप से सीजेएम के अनाम कार्यों का संस्करण) है जो एक इंट में लेता है और एक सूची देता है। आप इसका परीक्षण इस तरह कर सकते हैं ( इसे ऑनलाइन आज़माएं ):

{{:X_,2>{__*X>X@%>},{_X\/\-X+}%{F}%~}:F~]_&$}:G; 60 Gp

Comments

मैं कोई पायथन विशेषज्ञ नहीं हूं, लेकिन क्या आप set()में वहां की जरूरत है एक कारण है ? क्या आप केवल क्रमबद्ध सूची नहीं लौटा सकते?

— एलेक्स ए।

@ एलेक्स set()डुप्लिकेट को हटाने के लिए है :)

— Sp3000

ओह ठीक है। साफ। अच्छा काम!

— एलेक्स ए।

आप शायद कर सकते हैं [n]+sum(...,[])के रूप में sum(...,[n])?

— xnor

@xnor आह हाँ, मैं कर सकता हूँ। मैंने कभी भी कुछ भी उपयोग नहीं किया है, लेकिन []सारांश सूचियों के लिए आधार मामले के रूप में, इसलिए मैं पूरी तरह से भूल गया!

— Sp3000

Answer 2

जावा, 148 146 104 बाइट्स

गोल्फ संस्करण:

import java.util.*;Set s=new TreeSet();void f(int n){s.add(n);for(int a=1;++a*a<n;)if(n%a<1)f(n+a-n/a);}

दीर्घ संस्करण:

import java.util.*;
Set s = new TreeSet();
void f(int n) {
    s.add(n);
    for (int a = 1; ++a*a < n;)
        if (n%a < 1)
            f(n + a - n/a);
}

इसलिए मैं इस कार्यक्रम के साथ PPCG पर अपनी शुरुआत कर रहा हूं, जो कि TreeSet(जो स्वतः संख्याओं को, धन्यवाद के साथ क्रमबद्ध करता है ) और जियोबिट्स प्रोग्राम के समान पुनरावृत्ति का उपयोग करता है , लेकिन एक अलग तरीके से, n के गुणकों के लिए जाँच कर रहा है और फिर उनका उपयोग कर रहा है। अगला कार्य। मैं कहूंगा कि यह एक फर्स्ट-टाइमर (विशेष रूप से जावा के साथ, जो इस तरह की चीज़ के लिए सबसे आदर्श भाषा नहीं लगती है, और जियोबिट्स की मदद) है।

Comments

PPCG में आपका स्वागत है! आप को बदलने के द्वारा एक जोड़े को बचा सकते हैं a*bकरने के लिए nलाइन 9. पर

— Geobits

स्वागत और सुझाव के लिए धन्यवाद! हाँ, मुझे इन छोटी चीज़ों को देखने में थोड़ा समय लगेगा। हर बाइट मायने रखती है! एक बार फिर धन्यवाद!

— टीएनटी

आप c=n+a-bअंदर डालकर दो और बचा सकते हैं add()। वैकल्पिक रूप से, आप cपूरी तरह से छुटकारा पा सकते हैं और बस n+a-bउन दो बाइट्स के लिए दोनों स्थानों में उपयोग कर सकते हैं ।

— जियोबिट्स

जिसमें से बोलते हुए, मुझे नहीं लगता कि मुझे addदो बार उपयोग करने की आवश्यकता है । एक पल रुको ...

— टीएनटी

लेकिन पूरे पर दूसरे लूप की जरूरत नहीं है। यदि आपके पास एक ऐसा है aजिसे आप nसाफ-साफ विभाजित करते हैं , तो आपको खोजने के लिए लूप नहीं करना चाहिए b, यह सिर्फ है n/a। उस समय यह करीब और मेरा करीब होने लगता है;)

— 20

Answer 3

जावा, 157 121

यहां एक पुनरावर्ती कार्य है जो प्रत्येक वंशज के वंशज हैं n। यह एक रिटर्न देता है TreeSet, जिसे डिफ़ॉल्ट रूप से क्रमबद्ध किया जाता है।

import java.util.*;Set t(int n){Set o=new TreeSet();for(int i=1;++i*i<n;)o.addAll(n%i<1?t(n+i-n/i):o);o.add(n);return o;}

कुछ लाइन टूटने के साथ:

import java.util.*;
Set t(int n){
    Set o=new TreeSet();
    for(int i=1;++i*i<n;)
        o.addAll(n%i<1?t(n+i-n/i):o);
    o.add(n);
    return o;
}

Answer 4

ऑक्टेव, 107 96

function r=d(n)r=[n];a=find(!mod(n,2:sqrt(n-1)))+1;for(m=(a+n-n./a))r=unique([d(m) r]);end;end

सुंदर प्रिंट:

function r=d(n)
  r=[n];                          # include N in our list
  a=find(!mod(n,2:sqrt(n-1)))+1;  # gets a list of factors of a, up to (not including) sqrt(N)
  for(m=(a+n-n./a))               # each element of m is a twist
    r=unique([d(m) r]);           # recurse, sort, and find unique values
  end;
end

Comments

यह मेरी समझ है कि ऑक्टेव केवल और के endबजाय ब्लॉकों को समाप्त कर सकता है । इससे आपकी 11 बाइट बच जाएंगी। endforendfunction

— एलेक्स ए।

अरे, आप सही हैं! न कि मैंने कैसे भाषा सीखी और कभी महसूस नहीं किया कि यह किया जा सकता है। जब आप इसके साथ कई गोल्फ कर चुके हैं, तो आप इसे इंगित करने वाले पहले व्यक्ति क्यों हैं?

— dcsohl

मुझे केवल इतना ही पता था क्योंकि मैंने हाल ही में इसे किसी और के सवाल पर किसी और के गोल्फ में देखने के बाद देखा। मैंने कभी भी ऑक्टेव का उपयोग नहीं किया है और जब से मैंने मतलाब का उपयोग किया है, यह साल रहा है। मेरा अनुमान है कि PPCG पर कई सक्रिय ऑक्टेव उपयोगकर्ता नहीं हैं, लेकिन मैं गलत हो सकता हूं।

— एलेक्स ए।

खैर, इसे इंगित करने के लिए धन्यवाद।

— dcsohl

मेरी खुशी, खुशी है कि मैं मदद कर सकता था। अच्छा समाधान है।

— एलेक्स ए।

Answer 5

हास्केल, 102 100 बाइट्स

import Data.List
d[]=[]
d(h:t)=h:d(t++[a*b-b+a|b<-[2..h],a<-[2..b],a*b==h])
p n=sort$nub$take n$d[n]

उपयोग: p 16जो आउटपुट[7,10,16]

फ़ंक्शन dपुनरावर्ती रूप से सभी वंशों की गणना करता है, लेकिन डुप्लिकेट की जांच नहीं करता है, इसलिए कई एक से अधिक बार दिखाई देते हैं, उदाहरण d [4]के लिए 4एस की एक अनंत सूची देता है । फ़ंक्शन इस सूची से pपहला nतत्व लेता है , डुप्लिकेट को हटाता है और सूची को सॉर्ट करता है। Voilà।

Answer 6

CJam - 36

ri_a\{_{:N,2>{NNImd!\I-z*-}fI}%|}*$p

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

या, अलग विधि:

ri_a\{_{_,2f#_2$4*f-&:mq:if-~}%|}*$p

मैंने उन्हें लगभग 2 दिन पहले लिखा था, 36 पर अटक गया, निराश हो गया और बिना पोस्ट किए सो गया।