सभी डिस्टिंक्ट गोजिंता चेन को खोजें

Question

गोजिंता चेन

( प्रोजेक्ट ईयूलर # 606 से प्रेरित )

N के लिए एक gozinta श्रृंखला एक अनुक्रम है {1,a,b,...,n}जहां प्रत्येक तत्व ठीक से अगले को विभाजित करता है। उदाहरण के लिए, 12 के लिए आठ अलग-अलग gozinta चेन हैं:

{1,12}, {1,2,12}, {1,2,4,12}, {1,2,6,12}, {1,3,12}, {1,3,6,12}, {1,4,12} and {1,6,12}.

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक ( n > 1) को स्वीकार करता है और दिए गए नंबर के लिए सभी अलग-अलग gozinta चेन को आउटपुट या रिटर्न करता है।

1. श्रृंखला के मामलों में क्रम (आरोही), श्रृंखलाओं का क्रम नहीं होता है।
2. बंद-अवसर पर यह मौजूद है, आप चुनौती का हल करने वाले बिल्डिन का उपयोग नहीं कर सकते।
3. यह कोड-गोल्फ है ।

संपादित करें: 1एक संभावित इनपुट के रूप में निकालना ।

Comments

PPCG में आपका स्वागत है। अच्छा पहला सवाल!

— AdmBorkBork

"ऑफ-चांस पर यह मौजूद है [(आपकी ओर देखते हुए, गणितज्ञ!)]"

— आउटगॉल्फ

जैसा कि AdmBorkBork ने कहा, आम तौर पर किनारे-मामलों को केवल तभी जोड़ा जाता है, जब वे चुनौती के मूल में महत्वपूर्ण हों - यदि आप केवल एक कारण [[1]]चाहते हैं तो मैं कहूंगा कि यदि [1,1]कोई गोलगप्पा है, 1तो [1,1,12]जैसा 12कि [1,1,1,12]हम कर सकते हैं और अब हम कर सकते हैं अब "सभी वापस ..."

— जोनाथन एलन

आपको उन लोगों के लिए प्रश्न में वाक्य को स्पष्ट करना चाहिए जो इसे नहीं जानते हैं। 2|4पढ़ा है "दो चार" उर्फ ​​"दो gozinta चार" में चला जाता है।

— mbomb007

सैंडबॉक्स के काम करने के लिए ढाई घंटे पर्याप्त समय नहीं है। सैंडबॉक्स FAQ देखें ।

— पीटर टेलर

Answer 1

पायथन 3 , 68 65 बाइट्स

संपादित करें: -3 बाइट्स @ नोटजागन को धन्यवाद

f=lambda x:[y+[x]for k in range(1,x)if x%k<1for y in f(k)]or[[x]]

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

व्याख्या

से प्रत्येक गोज़िंटा श्रृंखला में श्रृंखलाx के अंत में संख्या होती है, जिसके बाईं ओर कम से कम एक विभाजक होता है। जंजीरों के प्रत्येक भाजक kके xलिए [1,...,k,x]अलग हैं। इसलिए हम प्रत्येक विभाजक kको अपनी सभी अलग-अलग Gozinta चेन ढूंढ सकते हैं और xउनके अंत में जोड़ सकते हैं, सीधे सभी बाईं ओर के साथ सभी विशिष्ट gozinta चेन प्राप्त करने के लिए । यह पुनरावर्ती रूप से तब तक किया जाता है जब तक कि लौटा नहीं जाता है, क्योंकि सभी गोज़िंटा श्रृंखला 1 से शुरू होती है, जिसका अर्थ है कि पुनरावृत्ति नीचे आ गई है।kxx = 1[[1]]

पायथन सूची की वजह से कोड इतना छोटा हो जाता है कि डबल पुनरावृत्ति की अनुमति देता है। इसका मतलब यह है कि इसमें पाए जाने वाले मूल्य f(k)सभी अलग-अलग विभाजक के लिए एक ही सूची में जोड़े जा सकते हैं k।

Comments

ऐसा करने की कोशिश कर रहा था, बहुत देर हो चुकी है = /

— रॉड

यह उत्तर अन्य लोगों की तुलना में अविश्वसनीय रूप से तेज़ है।

— ajc2000

-3 बाइट्स अनावश्यक सूची को हटाकर अनपैकिंग।

— नजगन

Answer 2

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

ufo=ḣ⁰…ġ¦ΣṖḣ⁰

H.PWiz के एक अलग दृष्टिकोण , हालांकि अभी भी जानवर बल द्वारा। इसे ऑनलाइन आज़माएं!

व्याख्या

मूल विचार यह है कि सभी बाद के [1,...,n]परिणामों को अलग-अलग किया जाए और परिणाम को उदात्त में विभाजित किया जाए जहां प्रत्येक तत्व अगले भाग को विभाजित करता है। इनमें से, हम उन चीजों को रखते हैं जो शुरू करते हैं 1, समाप्त nहोते हैं और कोई डुप्लिकेट नहीं होते हैं। यह "रंगीन" बिल्ट-इन के साथ किया जाता है …। फिर यह डुप्लिकेट को त्यागने के लिए रहता है।

ufo=ḣ⁰…ġ¦ΣṖḣ⁰  Input is n=12.
           ḣ⁰  Range from 1: [1,2,..,12]
          Ṗ    Powerset: [[],[1],[2],[1,2],[3],..,[1,2,..,12]]
         Σ     Concatenate: [1,2,1,2,3,..,1,2,..,12]
       ġ¦      Split into slices where each number divides next: [[1,2],[1,2],[3],..,[12]]
 fo            Filter by
      …        rangified
   =ḣ⁰         equals [1,...,n].
u              Remove duplicates.

Comments

मैं अनुमान लगा रहा हूं कि यह किसी भी शक्तियां को सरणियों में फ़िल्टर करने के लिए कम नहीं है जहां प्रत्येक संख्या अगले भाग को विभाजित करती है?

— ETHproductions

@ETHproductions नहीं, यह एक बाइट लंबी है ।

— ज़गर्ब

Answer 3

जेली , ९ by बाइट्स

ÆḌ߀Ẏ;€ȯ

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

मेरे लिए एक समान तकनीक का उपयोग करता है जाप उत्तर के , और इसलिए बड़े परीक्षण मामलों पर बहुत जल्दी चलता है।

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

ÆḌ߀Ẏ;€ȯ    Main link. Argument: n (integer)
ÆḌ          Yield the proper divisors of n.
       ȯ    If there are no divisors, return n. Only happens when n is 1.
  ߀        Otherwise, run each divisor through this link again. Yields
            a list of lists of Gozinta chains.
    Ẏ       Tighten; bring each chain into the main list.
     ;€     Append n to each chain.

Answer 4

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

FindPath[Graph@Cases[Divisors@#~Subsets~{2},{m_,n_}/;m∣n:>m->n],1,#,#,All]&

प्रपत्र Graphजहां कोने Divisorsइनपुट के होते हैं #, और किनारों को उचित विभाजन का प्रतिनिधित्व करते हैं, फिर Allशीर्ष 1से शिखर तक के मार्ग का पता लगाते हैं #।

Comments

वाह, यह बहुत चालाक है!

— जुंगह्वान मिन

Answer 5

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

ŒPµḍ2\×ISµÐṀ

एक मोनडिक लिंक एक पूर्णांक को स्वीकार करता है और पूर्णांक की सूचियों की सूची लौटाता है।

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

कैसे?

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

ŒPµḍ2\×ISµÐṀ - Link: number N
ŒP           - power-set (implicit range of input) = [[1],[2],...,[N],[1,2],[1,3],...,[1,N],[1,2,3],...]
          ÐṀ - filter keep those for which the result of the link to the left is maximal:
  µ      µ   - (a monadic chain)
    2\       -   pairwise overlapping reduce with:
   ḍ         -     divides? (1 if so, 0 otherwise)
       I     -   increments  e.g. for [1,2,4,12] -> [2-1,4-2,12-4] = [1,2,8]
      ×      -   multiply (vectorises) (no effect if all divide,
             -                          otherwise at least one gets set to 0)
        S    -   sum         e.g. for [1,2,4,12] -> 1+2+8 = 11 (=12-1)

Comments

प्रतीक्षा करें n- वार अतिव्यापी कम है? : o मैंने यह कैसे नहीं देखा कि: PI उपयोग कर रहा था <slice>2<divisible>\<each>: P

— HyperNeutrino

जेली के तेवर में सबसे नए बदलाव का उपयोग करते हुए, आप 11 बाइट्स केƝ लिए `2` के बजाय उपयोग कर सकते हैं ।

— श्री एक्सकोडर

Answer 6

जाप , 17 बाइट्स

⬣ßX m+S+UR÷ª'1

इसे ऑनलाइन टेस्ट करें!

अजीब तरह से, एक स्ट्रिंग के रूप में आउटपुट उत्पन्न करना इसे एरेज के एक सरणी के रूप में उत्पन्न करने की तुलना में आसान था ...

व्याख्या

 ⬠£  ßX m+S+URà ·  ª '1
Uâq mX{ßX m+S+UR} qR ||'1   Ungolfed
                            Implicit: U = input number, R = newline, S = space
Uâ                          Find all divisors of U,
  q                           leaving out U itself.
    mX{         }           Map each divisor X to
       ßX                     The divisor chains of X (literally "run the program on X")
          m    R              with each chain mapped to
           +S+U                 the chain, plus a space, plus U.
                  qR        Join on newlines.
                     ||     If the result is empty (only happens when there are no factors, i.e. U == 1)
                       '1     return the string "1".
                            Otherwise, return the generated string.
                            Implicit: output result of last expression

Comments

तो फिर क्या आपका दृष्टिकोण अमान्य श्रृंखला उत्पन्न करने से बचता है, फिर उन्हें छानना, जैसा कि अन्य दृष्टिकोण करते हैं?

— छाता

@Umbrella Nope, यह एक समय में केवल वैध, एक भाजक बनाता है, इसलिए यह 12000 :-) जैसे मामलों पर भी बिजली की तेजी से काम करता है :-)

— ETHproductions

पुनरावृत्ति का बहुत अच्छा उपयोग :) और मैं उस ¬चाल को छोड़ रहा हूँ ! : p

— शैगी

@ शिग्गी ¬एक कारण है कि मैंने उन कार्यों का एक गुच्छा लागू किया है जो मूल रूप से हैं "एक्स ने कोई तर्क नहीं दिया है, या वाई ने एक

— सत्य

Answer 7

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

Cases[Subsets@Divisors@#,x:{1,___,#}/;Divisible@@Reverse@{x}]&

उपयोग की गैर-दस्तावेजी बहु आर्ग प्रपत्र Divisible, जहां Divisible[n1,n2,...]रिटर्न Trueअगर n2∣n1, n3∣n2, और इतने पर, और Falseनहीं तो। हम सब ले Subsetsकी सूची के Divisorsइनपुट के #लिए, तो वापस जाने के Casesफार्म की {1,___,#}ऐसी है कि Divisibleदेता है Trueके लिए Reversedivisors के घ अनुक्रम।

Comments

तो, Divisibleमूल रूप से एक gozinta श्रृंखला को सत्यापित करने के लिए एक अंतर्निहित है?

— छाता

@Umbrella यह उचित विभाजन के लिए जाँच नहीं करता है।

— नगीनिस

Answer 8

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

f 1=[[1]]
f n=[g++[n]|k<-[1..n-1],n`mod`k<1,g<-f k]

उचित divenders और परिशिष्ट की फिर से खोज जाओ gozinta चेन n।

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

Comments

मुझे लगता है कि ठीक से निपटने के लिए अतिरिक्त क्रेडिट होना चाहिए 1। चूंकि हम सामूहिक रूप से छूट के लिए निष्कर्ष निकालते हैं 1, क्या आप उस मामले को हटाकर 10 बाइट बचा सकते हैं?

— छाता

@Umbrella 1इस एल्गोरिथ्म के लिए एक विशेष मामला नहीं है, इसे पुनरावृत्ति के लिए आधार मामले के रूप में आवश्यक है। अपने आप पर, दूसरा परिभाषित समीकरण केवल खाली सूची वापस कर सकता है।

— क्रिश्चियन सेवर्स

समझा। मेरा समाधान (अभी तक अप्रकाशित) [[1]]एक आधार के रूप में भी उपयोग करता है ।

— छाता

Answer 9

हास्केल (लैंबडॉट), 92 85 बाइट्स

x#y|x==y=[[x]]|1>0=(guard(mod x y<1)>>(y:).map(y*)<$>div x y#2)++x#(y+1)
map(1:).(#2)

आयात करने की guardआवश्यकता के बाद से लैंबडबॉट हास्केल की आवश्यकता Control.Monadहै। मुख्य कार्य एक अनाम फ़ंक्शन है, जो मुझे बताया गया है कि इसकी अनुमति है और यह बाइट्स के एक जोड़े को बंद कर देता है।

सात बाइट बचाने के लिए लाइकोनी के लिए धन्यवाद।

स्पष्टीकरण:

मोनाड बहुत आसान हैं।

x # y

यह हमारा पुनरावर्ती कार्य है जो सभी वास्तविक कार्य करता है। xवह संख्या है जिस पर हम जमा हो रहे हैं (विभाजकों का वह उत्पाद जो मूल्य में रहता है), और yअगला नंबर है जिसे हमें उसमें विभाजित करने का प्रयास करना चाहिए।

 | x == y = [[x]]

यदि xबराबरी है yतो हम पुनरावृत्ति कर रहे हैं। बस xवर्तमान gozinta श्रृंखला के अंत के रूप में उपयोग करें और इसे वापस करें।

 | 1 > 0 =

"ट्रू" के लिए हास्केल गोल्फ-इस्म। यही है, यह डिफ़ॉल्ट मामला है।

(guard (mod x y < 1) >>

अब हम सूची के अंदर काम कर रहे हैं। सूची के भीतर, हमारे पास एक ही समय में कई विकल्प बनाने की क्षमता है। थकावट द्वारा किसी चीज का "सभी संभव" खोजने पर यह बहुत मददगार होता है। guardबयान "केवल निम्न विकल्प पर विचार करता है, तो एक शर्त सच है" कहते हैं। इस मामले में, केवल निम्न विकल्प पर विचार करें यदि yविभाजित करता है x।

(y:) . map (y *) <$> div x y#2)

यदि yविभाजित होता है x, तो हमारे पास yगोज़िंटा श्रृंखला में जोड़ने का विकल्प है । इस मामले में, पुनरावर्ती कॉल (#), बराबर के y = 2साथ शुरू हो रहा xहै x / y, क्योंकि हम "फैक्टर आउट" करना चाहते हैं जो yहमने सिर्फ श्रृंखला में जोड़ा है। फिर, इस पुनरावर्ती कॉल से जो भी परिणाम होता है, yहम द्वारा इसके कई मूल्यों yको वास्तव में सचित्र कर दिया जाता है और आधिकारिक रूप से gozinta श्रृंखला में जोड़ दिया जाता है।

++

निम्नलिखित विकल्प पर भी विचार करें। यह बस दो सूचियों को एक साथ जोड़ता है, लेकिन हम इसे "इस चीज को करने या इस अन्य चीज के बीच चयन करने" के रूप में कह सकते हैं।

x # (y + 1)

अन्य विकल्प केवल पुनरावृत्ति जारी रखना है और मूल्य का उपयोग नहीं करना है y। अगर yनहीं बंटता है xतो यह एकमात्र विकल्प है। यदि yविभाजित होता है xतो इस विकल्प को अन्य विकल्प के रूप में भी लिया जाएगा, और परिणाम संयुक्त होंगे।

map (1 :) . (# 2)

यह मुख्य gozinta फ़ंक्शन है। यह (#)अपने तर्क के साथ कॉल करके पुनरावृत्ति शुरू करता है। ए 1को हर गोज़िंटा श्रृंखला से पहले रखा जाता है, क्योंकि (#)फ़ंक्शन कभी भी चेन में नहीं डालता है।

Comments

महान व्याख्या! आप सभी पैटर्न को एक पंक्ति में रखकर कुछ बाइट्स बचा सकते हैं। mod x y==0को छोटा किया जा सकता है mod x y<1। क्योंकि अनाम फ़ंक्शंस की अनुमति है, आपके मुख्य फ़ंक्शन को पॉइंटफ्री लिखा जा सकता है map(1:).(#2)।

— लकोनी

Answer 10

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

f n=until(all(<2).map head)(>>=h)[[n]]
h l@(x:_)|x<2=[l]|1<2=map(:l)$filter((<1).mod x)[1..x-1]

शायद एक बेहतर समाप्ति की स्थिति है (कुछ ऐसा करने की कोशिश की)

f n=i[[n]]
i x|g x==x=x|1<2=i$g x
g=(>>=h)

लेकिन यह लंबा है)। के लिए जाँच के 1रूप में विवेकपूर्ण लगता है के रूप में रगड़ दोहराने 1एस या डुप्लिकेट (में nubनहीं Prelude) अधिक बाइट्स है।

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

Comments

(>>=h)के लिए(concatMap h)

— माइकल क्लेन

95 बाइट्स

— क्रिस्टियान लुपस्कू

पवित्र बकवास मैं बेवकूफ हूँ u...

— Leif Willerts

Answer 11

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 73 बाइट्स

f=n=>n>1?[for(i of Array(n).keys())if(n%i<1)for(j of f(i))[...j,n]]:[[1]]

आसानी n%0<1से झूठा है।

Answer 12

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

ḊṖŒP1ppWF€ḍ2\Ạ$Ðf

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

Comments

जो कि प्रभावशाली था। आपका परिणाम 1अप्रत्याशित है, यद्यपि। मैं के लिए एक निश्चित परिणाम खोजने में कामयाब नहीं हुआ है 1, लेकिन मुझे लगा कि यह था [[1]]। मैं यह सुनिश्चित करने के लिए नहीं कह सकता कि [1,1]गलत है सिवाय इसके कि अन्य सभी परिणाम अनुक्रम बढ़ा रहे हैं। विचार?

— अम्ब्रेला

@Umbrella आप उत्तर के लिए कुछ भी करने देना चाहते हो सकता है

— श्री Xcoder

@Umbrella अगर यह एक समस्या है तो मैं इसे +2 ( ;€साथ बदलें ;Q¥€) के लिए ठीक कर सकता हूं ।

— एलिग आउटफर

Answer 13

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

(S=Select)[Rest@S[Subsets@Divisors[t=#],FreeQ[#∣#2&@@@Partition[#,2,1],1>2]&],First@#==1&&Last@#==t&]&

Comments

FreeQ[...]बन सकते हैंAnd@@BlockMap[#∣#2&@@#&,#,2,1]

— जुंगह्वान न्यूनतम

बहुत अच्छा! लेकिन मुझे एक अतिरिक्त संदेश मिला है Developerविभाजन :: nlen: - संदेश पाठ नहीं मिला - >> `वह क्यों है?

— J42161217

BlockMapDeveloper`PartitionMapआंतरिक रूप से फ़ंक्शन का उपयोग करता है , लेकिन चूंकि यह एक डेवलपर फ़ंक्शन है, इसलिए इसमें कोई त्रुटि संदेश नहीं है। त्रुटि उन सूचियों के कारण होती है जिनमें 1 या 0 तत्व होते हैं, जिनके साथ आप 2-विभाजन नहीं कर सकते हैं।

— जंगहवान मिन

Answer 14

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

Cases[Subsets@Divisors@#,{1,___,#}?(And@@BlockMap[#∣#2&@@#&,#,2,1]&)]&

व्याख्या

Divisors@#

इनपुट के सभी विभाजक प्राप्त करें।

Subsets@ ...

उस सूची के सभी सबसेट उत्पन्न करें।

Cases[ ... ]

पैटर्न से मेल खाने वाले सभी मामलों को चुनें ...

{1,___,#}

1 से शुरू होकर <input>...

?( ... )

और स्थिति को संतुष्ट करता है ...

And@@BlockMap[#∣#2&@@#&,#,2,1]&

बाएं तत्व सूची के सभी 2-विभाजन के लिए दाएं तत्व को विभाजित करता है, ऑफसेट 1।

Answer 15

टीआई-बेसिक, 76 बाइट्स

Input N
1→L1(1
Repeat Ans=2
While Ans<N
2Ans→L1(1+dim(L1
End
If Ans=N:Disp L1
dim(L1)-1→dim(L1
L1(Ans)+L1(Ans-(Ans>1→L1(Ans
End

व्याख्या

Input N                       Prompt user for N.
1→L1(1                        Initialize L1 to {1}, and also set Ans to 1.

Repeat Ans=2                  Loop until Ans is 2.
                              At this point in the loop, Ans holds the
                              last element of L1.

While Ans<N                   While the last element is less than N,
2Ans→L1(1+dim(L1              extend the list with twice that value.
End

If Ans=N:Disp L1              If the last element is N, display the list.

dim(L1)-1→dim(L1              Remove the last element, and place the new
                              list size in Ans.

L1(Ans)+L1(Ans-(Ans>1→L1(Ans  Add the second-to-last element to the last
                              element, thereby advancing to the next
                              multiple of the second-to-last element.
                              Avoid erroring when only one element remains
                              by adding the last element to itself.

End                           When the 1 is added to itself, stop looping.

मैं एक और 5 बाइट्स बचा सकता हूं अगर इसे Ans> 1 चेक और लूप कंडीशन को हटाकर, इनायत के बजाय एक त्रुटि के साथ बाहर निकलने की अनुमति है। लेकिन मुझे विश्वास नहीं है कि इसकी अनुमति है।

Comments

क्या आपने इसे अपने कैलकुलेटर में टाइप किया? क्योंकि यह अप्रत्याशित और कुछ प्रभावशाली है।

— छाता

हां! TI-BASIC के बारे में मुश्किल बात यह है कि इसमें केवल वैश्विक चर हैं, इसलिए मुझे सूची को अपने पुनरावर्ती स्टैक के रूप में प्रभावी रूप से उपयोग करना पड़ा।

— कैल्कॉमानियाक

Answer 16

गणितज्ञ 86 77 बाइट्स

Select[Subsets@Divisors@#~Cases~{1,___,#},And@@BlockMap[#∣#2&@@#&,#,2,1]&]&

बल द्वारा क्रूर बल।

कामना करते हैं कि किसी सूची की जोड़ीदार अनुक्रमिक तत्व की तुलना में एक छोटा तरीका हो।

9 बाइट बचाने वाले सुझावों के लिए @ जेनी_माथी और @ जुंगहवनमाइन का धन्यवाद

Comments

आप FreeQ[#∣#2&@@@Partition[#,2,1],1>2]&]82 बाइट्स पर जाने के लिए (दूसरे तर्क के रूप में) का उपयोग कर सकते हैं

— J42161217

@ जेनी_मथी या बेहतर,And@@BlockMap[#∣#2&@@#&,#,2,1]

— जुंगहवान न्यूनतम

Answer 17

भूसी , १ , 16 बाइट्स

-1 बाइट, जरगब को धन्यवाद

foEẊ¦m`Je1⁰Ṗthḣ⁰

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

Comments

छोटा, लेकिन धीमा। मैंने 50इनपुट में डाला और यह समय समाप्त हो गया। आपके दृष्टिकोण का सार क्या है?

— छाता

यह अनिवार्य रूप से सभी संभव श्रृंखलाओं की कोशिश करता है और उन लोगों को चुनता है जो कल्पना से मेल खाते हैं

— H.PWiz

@Umbrella TIO में 60 सेकंड का टाइमआउट है, यह प्रोग्राम की गलती नहीं है।

— आउटगोल्फर

o`:⁰:1हो सकता है`Je1⁰

— Zgarb

@Zgarb एक बार फिर ...

— H.PWiz

Answer 18

PHP 147 141

एक निरर्थक परीक्षण को हटाने के लिए संपादित

function g($i){$r=[[1]];for($j=2;$j<=$i;$j++)foreach($r as$c)if($j%end($c)<1&&$c[]=$j)$r[]=$c;foreach($r as$c)end($c)<$i?0:$R[]=$c;return$R;}

व्याख्या की:

function g($i) {

बॉयलरप्लेट के 15 वर्ण :(

    $r = [[1]];

परिणाम [[1]]प्रत्येक श्रृंखला के रूप में सेट के साथ शुरू होता है 1. यह भी इनपुट के रूप में 1 के लिए समर्थन की ओर जाता है।

    for ($j = 2; $j <= $i; $j++) {
        foreach ($r as $c) {
            if ($j % end($c) < 1) {
                $c[] = $j;
                $r[] = $c;
            }
        }
    }

2 से प्रत्येक संख्या के लिए $i, हम अपने सेट में प्रत्येक श्रृंखला को वर्तमान संख्या से बढ़ाने जा रहे हैं यदि यह gozinta है , तो, विस्तारित श्रृंखला को हमारे परिणाम सेट में जोड़ें।

    foreach ($r as $c) {
        end($c) < $i ? 0 : $R[] = $c;
    }

हमारी मध्यवर्ती श्रृंखलाओं को फ़िल्टर करें जिन्होंने इसे नहीं बनाया $i

    return $R;
}

बॉयलरप्लेट के 10 चार्ट :(

Answer 19

मेथेमेटिका

f[1] = {{1}};
f[n_] := f[n] = Append[n] /@ Apply[Join, Map[f, Most@Divisors@n]]

अतिरिक्त कॉल के लिए उत्तर को कैश किया गया है।

Comments

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

— गेहूं जादूगर