N के सभी गुणक विभाजनों को सूचीबद्ध करें

Question

एक सकारात्मक संख्या n को देखते हुए , किसी भी सुविधाजनक प्रारूप में n के सभी अलग-अलग गुणात्मक विभाजन को आउटपुट करें ।

N का एक गुणक विभाजन पूर्णांकों का एक समूह है, सभी एक से अधिक हैं, जैसे कि उनका उत्पाद n है । उदाहरण के लिए, 20 में निम्नलिखित भिन्न गुणक विभाजन हैं:

2 * 2 * 5
2 * 10
4 * 5
20

ऑर्डर मायने नहीं रखता है, इसलिए 2 * 2 * 5जैसा है वैसा ही विभाजन है 2 * 5 * 2।

---

उदाहरण:

1 -> {}
2 -> {2}
4 -> {2, 2}, {4}
20 -> {2, 2, 5}, {2, 10}, {4, 5}, {20}
84 -> {2, 2, 3, 7}, {2, 2, 21}, {2, 14, 3}, {2, 6, 7}, {2, 42}, {4, 3, 7}, {28, 3}, {4, 21}, {6, 14}, {12, 7}, {84}

Comments

संबंधित OEIS अनुक्रम।

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

संबंधित

— मील

Answer 1

ब्रेकीलॉग , 16 बाइट्स

>~l:{1<}a.*?,.=o

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

इसे ऑनलाइन आज़माएं! (इसे फुल प्रोग्राम में बनाने के लिए फंक्शन के चारों ओर एक्स्ट्रा कोड जोड़ा गया है; यदि आप सीधे TIO को दिखाए गए फंक्शन प्रदान करते हैं, तो यह फंक्शन को रन करेगा, लेकिन इसके आउटपुट को कहीं भी प्रिंट नहीं करेगा, जो प्रदर्शन के रूप में बेकार है। ।)

यह कार्यक्रम वास्तव में मुझे निराश करता है, क्योंकि इसमें से अधिकांश ब्रेजलॉग दुभाषिया में कीड़े के आसपास काम कर रहे हैं और इसके विनिर्देश में कमियां हैं, बजाय वास्तव में समस्या को हल करने के; लेकिन दुभाषिया यह क्या है। (इस तरह के कार्यक्रम के साथ भी, दुभाषिया तार्किक रूप से इसकी तुलना में अधिक मेमोरी का उपयोग करता है, और मेमोरी थकावट के कारण दुर्घटनाग्रस्त हो जाता है, लेकिन सौभाग्य से यह छोटी समस्याओं पर पहले वांछित उत्पादन का प्रबंधन करता है।) एक काल्पनिक "Brachylog का सही संस्करण" में। आप बस लिख सकते हैं ~*.o.:{>1}a,, जो 4 बाइट्स छोटा होगा, लेकिन मुझे दुभाषिया की मदद करने के लिए अतिरिक्त बाधाओं को जोड़ने की जरूरत है। (मैं वास्तव में बहुत ज्यादा Brachylog पसंद नहीं करता, और बल्कि Prolog से चिपके रहते हैं, लेकिन यह कार्यक्रम काम करने के लिए समान संकेत की जरूरत है और वे लिखने के लिए बहुत लंबे समय तक कर रहे हैं। इसलिए Brachylog यह है।)

स्पष्टीकरण:

हमेशा की तरह, एक ब्रैचीलॉग कार्यक्रम बाधाओं का एक सेट है; डिफ़ॉल्ट रूप से, पहले बाधा constrains इनपुट एक अज्ञात के खिलाफ (जो मैं फोन करता हूँ एक ), दूसरे बाधा constrains एक एक दूसरे अज्ञात के खिलाफ बी , और इतने पर जब तक हम उत्पादन तक पहुँचते हैं। कुछ वर्ण, जैसे {}, इस सामान्य प्रवाह को बदल सकते हैं, इसलिए मैं नेस्टेड पेडिकेट्स में अज्ञात का प्रतिनिधित्व करने के लिए अक्षरों के एक अलग सेट (जैसे एक्स / वाई ) का उपयोग करता हूं ।

>       A is smaller than the input
~l      B has length A
  1<    X is 1, Y is larger
:{1<}a  For each element X of B, it corresponds to an element Y of C
.       C, the output, and D are all identical
*       E is the product of D's elements
?       E, the input, and F are all identical
,       There's no constraint between F and G
.       G, the output, and H are all identical
=       H and I are identical, and need to be evaluated early
o       The output can be produced by sorting I

यह अभी भी स्पष्ट नहीं है कि कार्यक्रम कैसे काम करता है, इसलिए आइए बाधाओं को थोड़ा सरल करने का प्रयास करें। सी , डी , जी , एच , और मैं सभी (और आउटपुट के बराबर) समान हैं। ई और एफ भी समान हैं (और इनपुट के बराबर)। तो हमारी अड़चनें इसको उबालती हैं:

• A , B की लंबाई और आउटपुट का है, और इनपुट से छोटा है।
• B में सभी 1s शामिल हैं, और यह विशेष रूप से उपयोगी नहीं है (यह कार्यक्रम का हिस्सा है क्योंकि मौजूदा Brachylog दुभाषिया में, :{1<}aइसके बायाँ तर्क के लिए विवश लंबाई की आवश्यकता है, अन्यथा दुभाषिया एक अनंत लूप में चला जाता है)।
• आउटपुट में पूरी तरह से संख्या 1 से अधिक होती है (यानी बी के संबंधित तत्व से अधिक )।
• आउटपुट के तत्वों का उत्पाद इनपुट के बराबर है।
• आउटपुट इसे सॉर्ट करने से अपरिवर्तित है (यानी क्रमबद्ध क्रम में)।

संयोग से, मैंने स्पष्ट रूप से निर्दिष्ट नहीं किया कि आउटपुट के सभी तत्व पूर्णांक हैं, कुछ ऐसा जो आवश्यक प्रतीत हो सकता है; हालाँकि, Brachylog का अड़चन समाधान गैर-पूर्णांकों को संभाल नहीं सकता है, इसलिए यह आसानी से केवल उन समाधानों का उत्पादन करेगा जिनमें पूर्णांक शामिल हैं।

स्पष्ट रूप से, "आउटपुट की लंबाई इनपुट से छोटी होती है" जब भी आउटपुट इनपुट का गुणक विभाजन होता है, तो यह सही साबित होने वाला है (क्योंकि 2 ^x > x सभी nonnegative x अर्थात सकारात्मक 2 ^{x के लिए} )। तो हम उस अड़चन की अवहेलना कर सकते हैं; यह केवल वहाँ है Brachylog दुभाषिया कार्यक्रम के मूल्यांकन के लिए एक कार्य रणनीति देने के लिए। अन्य बाधाओं (कि आउटपुट को सॉर्ट किया जाता है, कि इसका उत्पाद इनपुट है, और यह कि इसके तत्व 1 से अधिक हैं) एक गुणक विभाजन की परिभाषा है, और इसलिए यह फ़ंक्शन मूल रूप से प्रश्न का प्रत्यक्ष कार्यान्वयन है।

Answer 2

ब्रेकीलॉग 1, 14 बाइट्स

:{$pp~c:*ao}fd

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

ब्रेकीलॉग 2, 11 10 बाइट्स, भाषा चुनौती देती है

{ḋp~c×ᵐo}ᵘ

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

माल्टीसेन ने 17 वें बाइट्स में इस सवाल का जवाब दिया, इसलिए मैं 16-बाइट वाले ब्रिचलॉग समाधान के साथ आया, जिसने ब्रेशलॉग को प्रश्न के विनिर्देश का अनुवाद करके काम किया। जब मैं ऐसा कर रहा था, डेनिस ने एक 15-बाइट जेली समाधान लिखा था। इसलिए मुझे 14 बाइट्स के लिए नीचे जाना पड़ा। यह एक फ़ंक्शन है जो इनपुट को एक तर्क के रूप में लेता है, और सभी विभाजनों की एक सूची देता है (एक जनरेटर के बजाय, मेरे अन्य समाधान के साथ)।

इस उत्तर को लिखने के कुछ समय बाद, डेनिस और मैं सहकारी रूप से 11 बाइट्स तक जेली समाधान प्राप्त करने में सफल रहे। यह पता चला है कि एक terser सिंटैक्स के साथ Brachylog का नया संस्करण है; यह चुनौती पोस्ट करता है, इसलिए वास्तव में गिनती नहीं करता है, लेकिन यह 11-बाइट कुल प्रबंधन कर सकता है जैसे ही यह जारी किया गया; बाद में भाषा के संशोधन (अन्य चुनौतियों से प्रेरित) 10 तक कम हो सकते हैं, जैसा कि यहां देखा गया है। दो कार्यक्रम समान हैं, एकमात्र अंतर सिंटैक्स है।

मेरे अन्य समाधान के विपरीत, जिसने "गोल्फिंग प्राइमेटीज़" का ज्यादा उपयोग नहीं किया, बल्कि समस्या को सीधे-सीधे कहा, यह एक बहुत ही Brachylog बाधाओं की सारी शक्ति की उपेक्षा करता है और इसके बजाय अपनी सर्वश्रेष्ठ जेली छाप करता है, जिसके कारण बाधाओं की एक श्रृंखला लिखी है। बाएं तर्क को पहले से ही जाना जाता है (और इस प्रकार बाधाएं पूरी तरह से विकसित बाधाओं की बजाय जेली मोनड्स की तरह काम करती हैं)। इसलिए यह @ Maltysen's Pyth समाधान के रूप में एक ही एल्गोरिथ्म का उपयोग करता है, जो कि संभवत: विशिष्ट गोल्फिंग प्राइमेटिव्स का उपयोग करके इसे हल करने का सबसे आसान तरीका है। (दिलचस्प बात यह है कि, मेरे अन्य उत्तर में "प्रॉब्लम द स्टेट्स" सॉल्यूशन कम होगा, यदि ब्रेकीलॉग दुभाषिया में बग्स / कमियों के लिए नहीं, तो गोल्फिंग प्राइमेटिव्स के उपयोग में कमी के बावजूद। किसी दिन मुझे "बेहतर एचीलॉग" लिखने की आवश्यकता है। इस तरह की समस्या के लिए एक अच्छा समाधान पाने के लिए; गोल्फ की भाषा के रूप में, Brachylog वास्तव में क्रिया है।)

कार्यक्रम में एक जनरेटर और उसके चारों ओर एक आवरण होता है। सबसे पहले, यहाँ जनरेटर की व्याख्या है:

$pp~c:*ao  ḋp~c×ᵐo
$p         ḋ        Prime factor decomposition of the input
  p         p       Generate all permutations
   ~c        ~c     Generate all inverse concatenations (i.e. partitions)
     :*a       ×ᵐ   Take the product of each list element in each partition
        o        o  Sort each partition

यह लगभग समस्या को हल करता है, लेकिन हम प्रत्येक में कई बार कई विभाजन उत्पन्न करते हैं। तो हमें समाधानों को कम करने के लिए एक आवरण की आवश्यकता है:

:{…}fd
:{…}f     Convert generator to list
     d    Remove duplicate elements

{…}ᵘ      Convert generator to list of unique elements

Comments

अपने उत्कट उत्तर को संपादित क्यों न करें?

— डाउनगेट 5

@Downgoat: दो उत्तर पूरी तरह से अलग दृष्टिकोण का उपयोग करते हैं; एल्गोरिदम अलग-अलग हैं, जिन भाषा विशेषताओं का उपयोग किया जाता है वे ज्यादातर स्वतंत्र हैं, और जैसे हैं। यह पुराने को नए के साथ बदलने के लिए कोई मतलब नहीं होगा (और मैं अच्छी तरह से नया पोस्ट कर सकता हूं भले ही यह लंबा हो)। यह मेटा पोस्ट बताता है कि इस तरह की स्थिति में अलग-अलग उत्तर पोस्ट करना बेहतर होता है।

मुझे नहीं पता कि आप यह जानते हैं लेकिन आप TIO पर एक चर (यानी एक बड़ा अक्षर) होने का तर्क देकर आउटपुट प्राप्त कर सकते हैं। उदाहरण के लिए ।

— घातक

Answer 3

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

±1={{}}
±n_:=Union@@(Sort/@Append[n/#]/@±#&/@Most@Divisors@n)

एक (पुनरावर्ती) एकरी ऑपरेटर को परिभाषित करता है ±जो विभाजन की सूची लौटाता है।

Comments

क्या गणितज्ञ को अर्धविराम की आवश्यकता नहीं है?

— पावेल

@Pavel नहीं, अर्धविराम सिर्फ इंटरैक्टिव नोटबुक में आउटपुट को दबाता है। यह इंगित करने के लिए धन्यवाद, btw, मैंने गलती से अंत में एक अर्धविराम छोड़ दिया।

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

Answer 4

पायथ - 17 बाइट्स

अभाज्य गुणनखंड के सभी क्रमपरिवर्तन लेता है, फिर हर एक का विभाजन करता है और फिर सभी विभाजनों का निर्माण करता है, उसके बाद ही अलग-अलग विभाजनों को बनाए रखता है।

{mS-*Md1s./M.p+1P

टेस्ट सूट ।

Answer 5

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

f=lambda n,k=2,l=[]:n/k and(n%k<1)*f(n/k,k,l+[k])+f(n,k+1,l)or 1/n*[l]

क्रमबद्ध सूचियों की सूची को आउटपुट करता है। उदाहरण के लिए f(20)है [[2, 2, 5], [2, 10], [4, 5], [20]]।

Comments

चूंकि पायथन के बिल्ट-इन पूर्णांक प्रकार की कोई सीमा नहीं है, इसलिए फ्लोटिंग पॉइंट स्वीकार्य समाधान नहीं है क्योंकि गलतियाँ बहुत बड़े इनपुट के लिए उत्तर को तोड़ देंगी।

— orlp

@orlp ओके, फिर पायथन 2 तक।

— xnor

TL; DR मुझे लगता है कि 998 बहुत बड़ा इनपुट नहीं है; ;-) IMO एक वास्तविक कूल कोड, लेटेंसी की तरह अधिक O(n)और पायथन 2 प्रतियोगी की तुलना में अधिक O(n^4)स्टाइल हो सकता है - जबकि f (998) मेमोरी या हार्डवेयर को उड़ा सकता है। अन्य एल्गोरिदम के साथ 80 दिनों का समय परिणाम प्राप्त करने के लिए मेरी मशीन पर 7 मिली सेकेंड [[2, 499], [998]]। IMO की समस्या यह हो सकती है कि उपरोक्त पायथन 3 कोड N > 998के RecursionError: maximum recursion depth exceeded in comparisonस्टॉप के लिए ... हैप्पी गोल्फिंग :-)

— Dilettant

@Dilettant सुनिश्चित नहीं है कि O(n^4)मेरे पाइथन 2 सबमिशन के लिए भी पर्याप्त है: परीक्षण केस 998 को ध्यान में रखते हुए, मेरा कोड 9 बार चलेगा, और (n+r-1)! / r! / (n-1)!प्रत्येक बार टुपल्स की मात्रा की गणना करेगा, जहां r2 से रैखिक रूप से बढ़ रहा है, और n है 9 - 2। लेकिन हे, कम से कम आपको पुनरावृत्ति सीमा को

— मोड़ने की

@TuukkaX कैविएट: मैंने कोड का विश्लेषण नहीं किया, बस स्किम्ड ओवर किया और कुछ एन के लिए 41 तक के दो उम्मीदवारों के बीच रन टाइम के विकास की तुलना की, तो मुझे लगा कि मैं सिर्फ टिप्पणी कर सकता हूं; ;-) ढेर और पुनरावृत्ति अक्सर मांस आसान होता है, लेकिन फिर अप्रिय स्थितियों में गहरे प्रकार के प्रश्नों के लिए कॉल करें ... आशा है कि मैंने इसे शोध की मात्रा के लिए पर्याप्त रूप से फजी बनाया था

— दिलेटेंट

Answer 6

जेली , 14 13 11 बाइट्स

Ḋx³ŒPQP=¥Ðf

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

मुझे पूरा यकीन था कि @ डेनिस के जेली समाधान में सुधार किया जा सकता है। दुर्भाग्य से, मैंने ब्रेकीलॉग रिकॉर्ड को हरा देने का प्रबंधन नहीं किया, लेकिन मैंने इसे टाई करने का प्रबंधन किया। अपडेट : @ डेनिस की मदद से, अब इसमें सुधार हुआ है; मुझे लगता है कि जेली ताज वापस लेती है।

यह कार्यक्रम अविश्वसनीय रूप से अक्षम है, जिसमें ओ (2 ^{एन 2} ) का प्रदर्शन है (यही कारण है कि ऊपर का परीक्षण मामला इसे इनपुट 4 के लिए दिखाता है)। यह 4 पर जल्दी से पूरा होता है, 5 पर बहुत धीरे-धीरे, और बड़ी संख्या के लिए चलाने के लिए व्यावहारिक रूप से संभव नहीं हो सकता है।

दिलचस्प बात यह है कि एक समाधान से ब्रैकलॉग में सुधार किया गया था जिसमें समस्या का वर्णन किया गया था (जो कि ब्रिग्लॉग अच्छा है) एक समाधान के लिए जो इनपुट को फैक्टर करने के आधार पर एक एल्गोरिथ्म का उपयोग करता था (जो कि जेली अच्छा है); इस बीच, जेली समाधान को अपनी ताकत से दूर जाकर सुधार किया गया था , और एक समाधान पर वापस जा रहा था जो समस्या का वर्णन करता है।

स्पष्टीकरण:

Ḋx³ŒPQP=¥Ðf
Ḋ              List of integers from 2 to the input (apparently undocumented)
 x³            Make a number of copies of each that's equal to the input
   ŒP          Take all (possibly noncontiguous) subsequences of that list (!)
     Q         Remove duplicates
         Ðf    Filter, keeping elements where:
      P=         their product is equal to {the original input, by default}
        ¥      Parse preceding two links as a unit

क्योंकि आउटपुट Ḋxको क्रमबद्ध किया गया है, प्रत्येक क्रम को भी क्रमबद्ध किया जाना चाहिए, और इस प्रकार हमें उन्हें व्यक्तिगत रूप से सॉर्ट करने की आवश्यकता नहीं है। तो "अलग-अलग आदेशों में समान आउटपुट एक डुप्लिकेट है" समस्या का हिस्सा है, और "आउटपुट में सभी मान> 1" समस्या का हिस्सा हैं, पीढ़ी द्वारा हल किया जाता है। इसके अलावा, जो हम मूल रूप से यहां कर रहे हैं वह है "सभी सूचियों को खोजें जिनके लिए P=³", जो हम करते हैं (एक अविश्वसनीय रूप से अक्षम तरीके से) सभी सूचियों को प्रश्न में उत्पन्न करके और फिर गलत लोगों को फ़िल्टर करके।

(स्पष्ट रूप से, किसी को जेली और ब्रेकीलॉग के एक हाइब्रिड का आविष्कार करने की आवश्यकता है, साथ ही एक बहुत अच्छा बाधा सॉल्वर भी है, ताकि हम {P=³}~प्लस के कुछ डुप्लीकेशन कोड के साथ कुछ लिख सकें , और कार्यक्रम को बहुत कम लंबाई में हल कर सकें। कुछ दूर, हालांकि)

Comments

कृपया, कोई व्यक्ति यहां बचत का पात्र ढूंढता है। मुझे एक "बाइट वॉर" पसंद है जिसमें प्रविष्टियां हर बार एक बाइट को छोटा करती रहती हैं। यहां कार्यक्रम के संरचनात्मक भागों पर पर्याप्त बाइट्स बर्बाद हैं जो ऐसा लगता है कि यह कामचलाऊ हो सकता है।

हे, मैं बस कुछ हड़ताली समान पोस्ट करने के बारे में था। (अधिक बार ताज़ा करना चाहिए।) 2rबन सकता है Ḋ, और P=³$$बन सकता है P=¥।

— डेनिस

P=¥जब मैं दुभाषिया में कोशिश करता हूं तो यह काम नहीं करता है, हालांकि मुझे पूरी तरह से यकीन नहीं है कि (तार्किक रूप से, यह काम करना चाहिए , और यह उन चीजों में से एक है जो मैंने पोस्ट लिखते समय कोशिश की थी; मैंने सिर्फ यह सुनिश्चित करने के लिए फिर से कोशिश की थी; यह निश्चित रूप से वह नहीं करता है जिसकी मुझे उम्मीद थी)। Ḋहालाँकि, मुझे लगता है कि वहाँ हमारी एक-बाइट की बचत है :-)

एक और विस्तार पर ध्यान नहीं दिया। आप के µसाथ के ¹रूप में अच्छी तरह से प्रतिस्थापित करना होगा , µदोहराया सीमा नए बाएँ तर्क बनाता है।

— डेनिस

ओह बेशक। इसलिए अब हम 11 से नीचे हैं, बहुत कम पात्रों के साथ, जो मुझे बहुत बेहतर महसूस करा रहा है। (मैं प्रयोग किया जाता ³के बजाय ¹सिर्फ किस्म के लिए।)

Answer 7

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

f=(n,m=2,a=[])=>n>1?m>n?[]:f(n,m+1,a).concat(f(n/m,m,[...a,m])):[a]

for (var i = 1; i < 31; i++) console.log(JSON.stringify(f(i)));

सीधे समस्या का हल रिकर्सिवली: प्रत्येक पूर्णांक के लिए मीटर से 2 के लिए n , हम के विभाजन के प्रत्येक ले n / मीटर की एक न्यूनतम तत्व के साथ मीटर और संलग्न (डुप्लिकेट विभाजन से बचने के लिए) मीटर । (किसी भी मीटर के लिए जो n को विभाजित नहीं करता है , यह खाली सरणी देता है, क्योंकि पूर्णांकों की कोई व्यवस्था दशमलव में गुणा नहीं करती है।) हम 1 के लिए खाली सरणी के आधार मामले को परिभाषित करते हैं ताकि अनंत पुनरावृत्ति से बचा जा सके।

Answer 8

पायथन 2, 198 191 172 180 बाइट्स

from itertools import*
n=input()
for i in range(2,len(bin(n))):
 for P in combinations_with_replacement(range(2,n),i):
  if reduce(lambda a,b:a*b,P)==n:print(P)
print[(n,),()][n<2]

एक पूरा कार्यक्रम। इसमें बहुत सुधार किया जा सकता है, इसलिए सुझावों का गहराई से स्वागत है!

• @FlipTack ने बचाए 9 बाइट!
• @orlp ने 19 बाइट्स बचाए!

श्रेणी 1 से 31 तक आउटपुट (समावेशी):

(1,)
(2,)
(3,)
(2, 2), (4,)
(5,)
(2, 3), (6,)
(7,)
(2, 4), (2, 2, 2), (8,)
(3, 3), (9,)
(2, 5), (10,)
(11,)
(2, 6), (3, 4), (2, 2, 3), (12,)
(13,)
(2, 7), (14,)
(3, 5), (15,)
(2, 8), (4, 4), (2, 2, 4), (2, 2, 2, 2), (16,)
(17,)
(2, 9), (3, 6), (2, 3, 3), (18,)
(19,)
(2, 10), (4, 5), (2, 2, 5), (20,)
(3, 7), (21,)
(2, 11), (22,)
(23,)
(2, 12), (3, 8), (4, 6), (2, 2, 6), (2, 3, 4), (2, 2, 2, 3), (24,)
(5, 5), (25,)
(2, 13), (26,)
(3, 9), (3, 3, 3), (27,)
(2, 14), (4, 7), (2, 2, 7), (28,)
(29,)
(2, 15), (3, 10), (5, 6), (2, 3, 5), (30,)
(31,)

Comments

क्या यह भी काम करता है? 4 -> {2, 2}, {4}प्रश्न में परीक्षण का मामला है, मुझे आपके लॉग में ऐसा आउटपुट दिखाई नहीं देता है।

— बोरसुन्हो

@ बोरसोनो जैसा कि मैंने पुराने संस्करण को वापस ले लिया है, मैं +1 जोड़ना भूल गया int(math.log(n,2)), जिससे यह हुआ। +2 बाइट्स और यह काम करेगा। धन्यवाद!

— यति

आपने आयात नहीं किया है mathलेकिन उपयोग कर रहे हैं math.log।

— orlp

@orlp मेरे पास है ...? तीसरी लाइन पर।

— यति

@TuukkaX बहाना, मुझे, मैं केवल आयात के लिए सबसे ऊपर की रेखाओं को देखता था, क्योंकि वे लगभग हमेशा वहाँ रहे हैं ... कहा जा रहा है, len(bin(n))-2की तुलना में कम है int(math.log(n,2))।

— orlp

Answer 9

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

ÆfŒ!ŒṖ€;/P€€Ṣ€Q

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

Comments

यह उत्तर समृद्ध है!

— लुइस मेंडू

Answer 10

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

(defn f[n](conj(set(for[i(range 2 n):when(=(mod n i)0)j(f(/ n i))](sort(flatten[i j]))))n))

उदाहरण चलता है:

(map f [20 84])
(#{20 (2 2 5) (4 5) (2 10)} #{(7 12) (2 2 3 7) (2 3 14) (2 2 21) (2 6 7) (6 14) (3 4 7) (3 28) (4 21) (2 42) 84})

मान ही एकल संख्या (नहीं list) के रूप में लौटाया जाता है , अन्य सूची के रूप में सामने आते हैं। nअंत में द्वारा प्रतिस्थापित किया जा सकता है [n]यह एक दृश्य के रूप में अच्छी तरह से बनाने के लिए, या (list n)यह एक सूची बनाने के लिए।

Answer 11

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 58 56 52 बाइट्स

If[#>1,##&@@#0[#/i,##2,i]~Table~{i,2,Min@##},{##2}]&

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

मेरे गणितज्ञ समाधान से विभाजित विभाजनकारी विभाजकों के लिए अनुकूल । Sequenceविभाजन की एक वापसी ।

Answer 12

जे, 35 बाइट्स

([:~.]<@/:~@(*//.)"$~#\#:i.@!@#)@q:

समय-विवश कारक चुनौती के समाधान के आधार पर ।

यह संस्करण अधिक अकुशल है और मुख्य कारकों की संख्या के आधार पर तथ्यात्मक समय में चलता है। फैक्टरैडिक संख्या उत्पन्न करके विभाजन बनाता है।

इसे ऑनलाइन आज़माएं! (ऑनलाइन बड़े मूल्यों की कोशिश मत करो!)

व्याख्या

([:~.]<@/:~@(*//.)"$~#\#:i.@!@#)@q:  Input: integer n
                                 q:  Prime factorization
(                              )@    Operate on them
                              #        Length
                            !@         Factorial
                         i.@           Range [0, i)
                     #\                Range [1, i]
                       #:              Mixed based conversion - Creates factoradic values
     ]                                 Get factors
            (    )"$~                  For each factoradic value
               /.                        Partition the factors based on equal
                                         digits in the factoradic value
             */                          Get the product of each block
        /:~@                             Sort it
      <@                                 Box it
 [:~.                                  Deduplicate

Answer 13

डी, 95 बाइट्स

void g(int n,int[]r){for(int i=r[0];i*i<=n;i++)(n%i)?0:g(n/i,i~r);r.back=n;r.writeln;}g(n,[2]);

बस एक पुनरावर्ती समाधान। में g(n,r), rअब तक का विभाजन है, और nक्या कारकों में टूटने के लिए अभी भी मूल्य बचा है। प्रत्येक अनियंत्रित विभाजन को केवल एक बार प्राप्त करने के लिए, हम कारकों rको गैर-बढ़ते क्रम में क्रमबद्ध करते हैं । अंतिम तत्व कम से कम संभव कारक के रूप में rशुरू होता 2है, और nप्रत्येक आउटपुट ऑपरेशन से ठीक पहले प्रत्येक प्रतिलिपि में अधिलेखित हो जाता है ।

n = 60उत्पादन के लिए , निम्नानुसार है:

[3, 2, 2, 5]
[2, 2, 15]
[3, 2, 10]
[5, 2, 6]
[2, 30]
[4, 3, 5]
[3, 20]
[4, 15]
[5, 12]
[6, 10]
[60]

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

Comments

टेम्प्लेट, void g(T)(T n,T[]r){for(T i=r[0];i*i<=n;i++)n%i0:r;r.back=n;r.writeln;}g(n,[2])

— गस्सा का

वैसे भी, यह भी एक वैध जवाब नहीं है, जैसा कि आपको आयात करने की आवश्यकता है std.stdioऔर std.range, इनपुट 1को कुछ भी नहीं प्रिंट करना चाहिए, नहीं [1]।

— Zacharý

Answer 14

डी, 109 बाइट्स

import std.stdio;void g(T)(T n,T[]r=[2]){if(n-1){for(T i=r[0];i*i<=n;i++)n%i?0:g(n/i,i~r);r[$-1]=n;r.write;}}

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