इसे फैक्टर करें! …बुरी तरह

Question

एक जिज्ञासु बच्चा एक प्रोग्राम का उपयोग करता है जो एक संख्या या अभिव्यक्ति को निम्न रूप में बदल सकता है p1^e1 * p2^e2 * ... * pn^en:। समान के बराबर व्यय करने वाले 1को छोड़ दिया जाता है360 = 2^3 * 3^2 * 5

बच्चा इस आउटपुट को नए इनपुट के रूप में प्रोग्राम में टाइप करता है, लेकिन वह ^साइन को समझ नहीं पाता है , इसलिए कभी-कभी वह संबंधित प्राइम-बेस और एक्सपोनेंट को समेटने वालों में से एक या अधिक को छोड़ देता है। उदाहरण के लिए(360 =) 2^3 * 3^2 * 5 => 2^3 * 32 * 5 (= 1280)

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

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो एक पूर्णांक दिया n( n>1) बढ़ते क्रम में सभी संभावित संख्याओं को आउटपुट करता है जिसका कारक वह हो सकता है जिसमें बच्चा (सहित n) समाप्त हो गया । इनपुट के 16लिए संभव अंतिम कारक हैं(16 =) 2^4, (24 =) 2^3 * 3, (23*3 =) 3 * 23

इनपुट विवरण:

• इनपुट एकल पूर्णांक से बड़ा है 1
• ऐसा कोई इनपुट नहीं दिया जाएगा जो आउटपुट संख्या से अधिक उत्पन्न करता है 2^31-1
• कोई इनपुट नहीं दिया जाएगा जो 1000आउटपुट संख्या से अधिक उत्पन्न करता है

आउटपुट विवरण:

• अपनी भाषा के लिए एक सुविधाजनक रूप में पूर्णांक की एक सूची

उदाहरण:

इनपुट => आउटपुट

11    => 11
16    => 16 24 69
360   => 140 360 770 1035 1219 1280 2875 3680
605   => 560 605 840 2415
2048  => 211 2048
58564 => 230 456 1311 2508 9975 12768 13794 20748 58564 114114 322102

यह कोड-गोल्फ है इसलिए सबसे कम कार्यक्रम जीतता है।

Comments

क्या हमारे पास पहले से ही इसका फैक्टराइजेशन नहीं है?

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र यह काफी अलग है।

— यादृच्छिक

360 के लिए अंतिम संख्या 3 6 80: 2 ^ 3 * 3 ^ 2 * 5 => 23 * 32 * 5 = 3680

— blutorange

@blutorange धन्यवाद, संपादित।

— बेतरतीब

Answer 1

CJam - 66

ria{_{:XmF{1=1>},La\{a1$\f++}/La-{XI{~#}%:*/I{si}%:**}fI}%|}1e3*$p

इसे http://cjam.aditsu.net/ पर आज़माएं

स्पष्टीकरण:

ria                       read token, convert to integer and wrap in array
{…}1e3*                   repeat 1000 times
    _                     duplicate array
    {…}%                  transform each array item (number) using the block
        :X                store the number in X
        mF                factorize with exponents
        {1=1>},           keep only the factors with exponent > 1
        La\{a1$\f++}/     get all the subsets (*)
        La-               remove the empty subset
        {…}fI             for I = each subset of prime factors with exponent > 1
            XI{~#}%:*/    divide X by all the factors in I
            I{si}%:**     multiply with the primes from I
                          concatenated with their exponents
    |                     add the new numbers to the array, removing duplicates
$                         sort
p                         print the final array

(*) धन्यवाद मार्टिन

Comments

cjam कोड से cjam भगवान

— kaine

किसी भी राशि को ^एक चरण में हटाया जा सकता है। तो 58564 = 2^2 * 11^4इसके लिए उत्पन्न करने में सक्षम होना चाहिए 2508 = 22 * 114।

— यादृच्छिक

@randomra आपको इस तरह की चीज़ के लिए एक उदाहरण जोड़ना चाहिए

— aditsu इसलिए छोड़ दिया क्योंकि SE EVIL

@randomra अब बेहतर होना चाहिए

— aditsu छोड़ दिया क्योंकि SE 20 सितंबर को EVIL

महान! उदाहरण जोड़ा। इसे स्किप करने के लिए क्षमा करें।

— 20

Answer 2

रूबी, 219

इसे शुरू करने के लिए:

s=->(x){A=[];def k(x)A<<x
y=Prime.prime_division x;n=0..y.size-1
n.each{|i|n.to_a.combination(i+1).each{|c|c.each{|z|v=y.dup
v[z][1]>1?v[z]=[v[z].join.to_i,1]:next
k v.inject(1){|s,b|s*b[0]**b[1]}}}}end;k x;A.uniq.sort}

एक फ़ंक्शन बनाता है जो संख्याओं का एक सरणी लौटाता है।

https://ideone.com/iOMGny

इसे इस तरह उपयोग करें:

#usage

#load from the standard library
require"prime"

#read from stdin and print to stdout
p s.call $<.read.to_i

मोबाइल फोन पर यह सब लिखने में इतना मजा ...

Answer 3

पर्ल, 193 बाइट्स

sub R{my($k,$v,@z)=@_;map{$k**$v*$_,$v>1?($k.$v)*$_:()}@z?R(@z):1}
@q=(0+<>);
while($x=pop@q){
my%f;@r=sort{$a<=>$b}@r,$x;
for(2..$x){$x/=$_,$f{$_}++while$x%$_<1}
$_~~@r||push@q,$_ for R%f
}
print"@r"

पठनीयता के लिए नई सूचियाँ जोड़ी जाती हैं।

लूप के लिए अगली संख्या ( $x) हैश %fऔर शक्तियों के हैश ( ) में होती है। पुनरावर्ती फ़ंक्शन ( R) इस हैश का उपयोग उन सभी संख्याओं को उत्पन्न करने के लिए करता है जिन्हें ^संकेतों को हटाकर प्राप्त किया जा सकता है । इन संख्याओं को एक कतार ( @q) में जोड़ा जाता है , और प्रक्रिया को लूप करते समय बाहरी द्वारा दोहराया जाता है। @rमुद्रण के लिए कतार से प्रत्येक संख्या को एक अद्वितीय, क्रमबद्ध सरणी ( ) में भी रखा गया है ।

Answer 4

पायथ, 46 45 44

Su{smmu*/N^T/PdTv+`T`/PdTkdyft/PdT{PdGU^T3]Q

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

कई ^बग तय किए । उदाहरण के लिए:

Input:  58564
Output: [230, 456, 1311, 2508, 9975, 12768, 13794, 20748, 58564, 114114, 322102]

ध्यान दें कि यह कोड आधिकारिक संकलक को बगफिक्स के एक जोड़े पर निर्भर करता है, जिसे प्रश्न पूछने के बाद धकेल दिया गया था। हालाँकि, यह किसी भी नई भाषा सुविधाओं का उपयोग नहीं करता है।

Comments

58564 के लिए क्या मिलता है?

— एडिट्स ने छोड़ दिया क्योंकि एसई

[230, 456, 1311, 58564, 322102], जो गलत है।

— isaacg

@aditsu ने इस मुद्दे को ठीक किया।

— isaacg

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

— यादृच्छिक

@randomra मैं इस उत्तर को स्वीकार न करने के आपके निर्णय को समझता हूँ। हालांकि, मैं सिर्फ यह बताना चाहूंगा कि बगफिक्स क्या था: एक uऔर कमी को कम करना ( ) का उपयोग करना असंभव था। मैंने उपयुक्त स्थान पर एक 2 से 3 को बदल दिया ताकि कम 3 के बजाय 3 इनपुट ले जाए।

— isaacg