अद्वितीय अपराधों के संयुक्त उत्पाद

Question

समस्या का बयान

अनूठे, लगातार प्राइम्स (जरूरी नहीं कि 2 सहित) के एक सेट को देखते हुए, इन प्राइम्स की पहली शक्तियों के सभी संयोजनों के उत्पाद उत्पन्न करें - जैसे, कोई दोहराता नहीं - और भी 1. उदाहरण के लिए, सेट {2, 3, 5, 7}, आप {1, 2, 3, 5, 6, 7, 10, 14, 15, 21, 30, 35, 42, 70, 105, 210} का उत्पादन करते हैं क्योंकि:

  1  =  1
  2  =  2
  3  =  3
  5  =  5
  6  =  2 x 3
  7  =  7
 10  =  2 x 5
 14  =  2 x 7
 15  =  3 x 5
 21  =  3 x 7
 30  =  2 x 3 x 5
 35  =  5 x 7
 42  =  2 x 3 x 7
 70  =  2 x 5 x 7
105  =  3 x 5 x 7
210  =  2 x 3 x 5 x 7

ध्यान दें कि यदि आपके इनपुट सेट की कार्डिनैलिटी k है, तो इससे आपको आउटपुट सेट में 2 ^ k सदस्य मिलेंगे।

नियमों / स्थितियां

1. आप किसी भी भाषा का उपयोग कर सकते हैं। स्रोत कोड की सबसे छोटी वर्ण गणना के लिए लक्ष्य।
2. आपका समाधान या तो एक पूर्ण कार्यक्रम या पूर्ण कार्य होना चाहिए। फ़ंक्शन अनाम हो सकता है (यदि आपकी भाषा अनाम कार्यों का समर्थन करती है)।
3. आपका समाधान कम से कम 2 ^ 31 तक उत्पादों का समर्थन करने में सक्षम होना चाहिए। यदि आप उन संख्याओं से गुजरते हैं, जिनके उत्पाद का प्रतिनिधित्व करना बहुत अच्छा है, तो पूर्णांक अतिप्रवाह का पता लगाने या संभालने के बारे में चिंता न करें। हालाँकि, कृपया अपनी गणना की सीमा बताएं।
4. आप सूची या सेट को स्वीकार कर सकते हैं या सूची या सेट का उत्पादन कर सकते हैं। आप मान सकते हैं कि इनपुट सॉर्ट किया गया है लेकिन आपको सॉर्ट किए गए आउटपुट का उत्पादन करने की आवश्यकता नहीं है।

पृष्ठभूमि

यह कब या क्यों उपयोगी है? एक जगह यह बहुत उपयोगी है कि एक वर्ग फैक्टरिंग एल्गोरिथ्म में समानांतर में दौड़ने के लिए गुणक की एक तालिका उत्पन्न करने में स्क्वायर फॉर्म फैक्टराइजेशन के रूप में जाना जाता है।। वहां, प्रत्येक विषम गुणक जो आप आजमाते हैं, एल्गोरिथम की विफलता की संभावना कम हो जाती है (एक कारक खोजने के लिए) कठिन अर्धवृत्तों पर लगभग 50%। इसलिए {3, 5, 7, 11} उत्पन्न करने वाले सेटों के साथ, जो समानांतर में दौड़ के लिए 16 ट्रायल मल्टीप्लायरों के सेट का निर्माण करता है, एल्गोरिथ्म कठिन अर्ध-काल पर लगभग 2 ^ -16 विफल रहता है। 13 को प्राइम लिस्ट में शामिल करने से 32 ट्रायल मल्टीप्लायर का एक सेट तैयार होता है, जिससे विफलता की संभावना लगभग 2 ^ -32 तक कम हो जाती है, जिसके परिणामस्वरूप अतिरिक्त कम्प्यूटेशनल खर्च पर परिणाम में भारी सुधार होता है (क्योंकि समानांतर में दो बार कई मल्टीप्लायरों के साथ रेसिंग भी होती है। औसत यह अभी भी चरणों की कुल संख्या में उत्तर पाता है)।

Answer 1

शुद्ध बैश, 32 बाइट्स

eval echo \$[{1,${1// /\}*{1,}}]

इनपुट सूची (एकल स्थान अलग) को कमांड-लाइन आर्ग के रूप में पारित किया जाता है।

तीन अलग-अलग शेल विस्तार का उपयोग किया जाता है:

1. ${1// /\}*{1,}एक पैरामीटर विस्तार है जो रिक्त स्थान को बदलने 2 3 5 7के }*{1,लिए देता है 2}*{1,3}*{1,5}*{1,7। \$[{1,और }]देने के लिए क्रमशः शुरू और अंत में जोड़ा जाता है \$[{1,2}*{1,3}*{1,5}*{1,7}]। \$[बैकस्लैश-एस्केप्ड इस स्तर पर गणित विस्तार करने के लिए प्रयासों को रोकने के लिए है।
2. \$[{1,2}*{1,3}*{1,5}*{1,7}]एक ब्रेस विस्तार है । क्योंकि ब्रेस विस्तार आम तौर पर पैरामीटर विस्तार से पहले होता है , हम उपयोग करने के लिए evalपैरामीटर विस्तार को पहले होने के लिए मजबूर करने के लिए उपयोग करते हैं । ब्रेस विस्तार का परिणाम है $[1*1*1*1] $[1*1*1*7] $[1*1*5*1] ... $[2*3*5*7]।
3. $[1*1*1*1] $[1*1*1*7] $[1*1*5*1] ... $[2*3*5*7]अंकगणितीय विस्तार की एक सूची है , जो तब आवश्यक संख्याओं की सूची देने के लिए मूल्यांकन किया जाता है।

आउटपुट:

$ ./comboprime.sh "2 3 5 7"
1 7 5 35 3 21 15 105 2 14 10 70 6 42 30 210
$

Comments

मन ... उड़ा ... वाह!

— टॉड लेहमन

Wtf ... मुझे मिलता है1 0

— username.ak

@ username.ak आपका इनपुट क्या है? आप इसे कैसे इनपुट कर रहे हैं (कमांड-लाइन आर्ग्स?)। आप किस संस्करण का बैश चला रहे हैं? bash --version

— डिजिटल ट्रामा

Answer 2

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

1aq~{1$f*+}/p

[2 3 5 7]STDIN से एक सरणी (जैसे ) पढ़ता है । इसे ऑनलाइन आज़माएं।

एक अनाम फ़ंक्शन में एक ही बाइट काउंट होगा:

{1a\{1$f*+}/}

उदाहरण चलाते हैं

$ cjam <(echo '1aq~{1$f*+}/p') <<< '[]'
[1]
$ cjam <(echo '1aq~{1$f*+}/p') <<< '[2 3 5 7]'
[1 2 3 6 5 10 15 30 7 14 21 42 35 70 105 210]

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

1a               " Push R := [1].              ";
  q~             " Read an array A from STDIN. ";
    {     }/     " For each a ∊ A:             ";
     1$f*+       "     R += { ra : r ∊ R }     ";
            p    " Print.                      ";

Comments

वाह, यह एक चतुर तरीका है कि सभी सबसेट के माध्यम से पुनरावृति।

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

Answer 3

हास्केल, २२

समाधान एक अनाम फ़ंक्शन है:

map product.mapM(:[1])

उदाहरण का उपयोग:

*Main> map product.mapM(:[1]) $ [2,3,5]
[30,6,10,2,15,3,5,1]

स्पष्टीकरण:
(:[1]) एक फ़ंक्शन है जो एक संख्या दी गई xसूची को लौटाता है [x,1]।
mapM(:[1])एक फ़ंक्शन है जो संख्याओं की एक सूची (:[1])देता है उन पर फ़ंक्शन को मैप करता है, और हर सूची से एक तत्व चुनने के लिए हर संभव तरीका देता है। उदाहरण के लिए, mapM(:[1]) $ [3,4]पहले फ़ंक्शन को प्राप्त करने के लिए मैप करता है [[3,1] , [4,1]]। फिर संभावित विकल्प हैं [3,4](दोनों की पहली संख्या को चुनना) [3,1] [1,4]और [1,1]इसलिए यह वापस आ जाता है [[3,4],[3,1],[1,4],[1,1]]।

फिर map productसभी विकल्पों पर मैप करता है और अपने उत्पादों को लौटाता है, जो वांछित आउटपुट हैं।

यह फ़ंक्शन अपने प्रकार में बहुरूपी है जिसका अर्थ है कि यह सभी प्रकार की संख्याओं पर काम कर सकता है। आप इसकी सूची बना सकते हैं Intऔर परिणाम की एक सूची होगी, Intलेकिन प्रकार की सूची पर भी लागू किया जा सकता हैIntegerऔर की एक सूची प्रदान Integer। इसका मतलब यह है कि अतिप्रवाह व्यवहार इस फ़ंक्शन द्वारा निर्दिष्ट नहीं है, लेकिन इनपुट के प्रकार (yay Haskell के अभिव्यंजक प्रकार सिस्टम :)) द्वारा

Comments

अच्छा! क्या संख्या आकार की कोई सीमा है?

— टॉड लेहमन

@ टॉडलमैन नोप। डिफ़ॉल्ट संख्यात्मक प्रकार है Integer, जो एक असीमित पूर्णांक प्रकार है। भी नहीं है Int, एक 32-बिट पूर्णांक है, लेकिन यह ज्यादातर सिर्फ एक विरासत बात है।

— जॉन डेवोरक

व्यवहार में @JDDvorak हाँ, लेकिन मुझे यह उल्लेख नहीं करने के लिए टाइप सिस्टम बहुत पसंद है :)। दूसरी बात यह है कि क्योंकि यह अनाम है यह मायने रखता है कि आप इसका उपयोग कैसे करते हैं क्योंकि कुछ मामलों में मोनोमोर्फिस्म प्रतिबंध लागू हो सकता है।

— घमंडी हैस्केलर

Answer 4

गणितज्ञ, १ by १tes बाइट्स

1##&@@@Subsets@#&

यह एक अनाम कार्य है। जैसे बुलाओ

1##&@@@Subsets@#&[{2,3,5,7}]

Comments

और मार्टिन ने सुंदर उत्तर के साथ झपट्टा मारा!

— टॉड लेहमन

@ToddLehman अब J के उत्तर की प्रतीक्षा करते हैं जो कि इसको हराता है। ;)

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

यदि मैथेमेटिका स्रोत बंद नहीं था, तो कोई एक गोल्फ संस्करण लिख सकता था। ×@@@𝒫@#अपराजेय होना चाहिए।

— डेनिस

@ डेनिस वुल्फ्राम लैंग्वेज स्पेसिफिकेशन मैथमैटिक के स्वतंत्र रूप से उपलब्ध है और मुझे लगता है कि एक या दो (अधूरे) ओपन सोर्स कार्यान्वयन हैं। Mathematica का यूनिकोड-अलियासड संस्करण बनाने का सुझाव कुछ समय दिया गया है, लेकिन मुझे नहीं लगता कि यह PPCG पर बहुत अच्छी तरह से प्राप्त होगा। ^ ^

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

@ मार्टिनबटनर आपको प्रतीक्षा करने के लिए क्षमा याचना: (*/@#~2#:@i.@^#)जे में 16 वर्ण;)

— एल्गोरिथमशार्क

Answer 5

अपडेट: सी (फ़ंक्शन एफ), 92

एक समारोह के रूप में भी, यह अभी भी यहां सबसे लंबी प्रविष्टि है। यह पहली बार है जब मैंने सी में फ़ंक्शन तर्क के रूप में अज्ञात लंबाई की एक सरणी पारित की है, और जाहिर तौर पर सी फ़ंक्शन के लिए यह पता करने का कोई तरीका नहीं है कि इसे पास किया गया है, क्योंकि तर्क को सूचक के रूप में पारित किया गया है ( उपयोग किए गए वाक्यविन्यास की परवाह किए बिना)। इसलिए लंबाई को इंगित करने के लिए एक दूसरे तर्क की आवश्यकता है।

मैंने आउटपुट को स्टडआउट करने के लिए रखा, क्योंकि एक पूर्णांक सरणी की स्थापना और इसे वापस करना लगभग निश्चित रूप से लंबा होगा।

टिप्स के लिए डेनिस को धन्यवाद।

fनीचे दिए गए परीक्षण कार्यक्रमों में फ़ंक्शन (अनावश्यक व्हाट्सएप को छोड़कर 92 वर्ण) देखें।

प्रिंटफ के माध्यम से आउटपुट

j;

f(int c,int*x){
  int p=1,i;
  for(i=c<<c;i--;p=i%c?p:!!printf("%d ",p))p*=(i/c>>i%c)&1?1:x[i%c];
}

main(int d,char**v){
  d--;
  int y[d];
  for(j=d;j--;)y[j]=atoi(v[j+1]);
  f(d,y);
}

सरणी पॉइंटर के माध्यम से आउटपुट

j,q[512];

f(int c,int*x,int*p){
    for(int i=-1;++i-(c<<c);p[i/c]*=(i/c>>i%c)&1?1:x[i%c])i%c||(p[i/c]=1);
}

main(int d,char**v){
  d--;
  int y[d];
  for(j=d;j--;)y[j]=atoi(v[j+1]);
  f(d,y,q);
  for(j=1<<d;j--;)printf("%d ",q[j]);
}

सी (कार्यक्रम), 108

अनावश्यक व्हाट्सएप को छोड़कर।

p=1,i;
main(int c,char**v){
  c-=1;
  for(i=c<<c;i--;i%c||(printf("%d ",p),p=1))(i/c>>i%c)&1||(p*=atoi(v[i%c+1]));
}

कमांडलाइन से इनपुट, आउटपुट से स्टडआउट। सी यहाँ जीतने के लिए नहीं जा रहा है, लेकिन शायद मैं कल एक समारोह में परिवर्तित करने की कोशिश करूंगा।

मूल रूप से हम 1<<cप्राइम के सभी संयोजनों के माध्यम से पुनरावृत्ति करते हैं , प्रत्येक i/cउत्पाद में किसी विशेष प्राइम की उपस्थिति या अनुपस्थिति के साथ जुड़ा हुआ है। "इनर लूप" i%cप्राइम्स के माध्यम से चलता है, i/c.जब i%c0 तक पहुंचता है, के मूल्य के अनुसार उन्हें गुणा करना , उत्पाद आउटपुट है, फिर अगले "बाहरी" पुनरावृत्ति के लिए 1 पर सेट करें।

उत्सुकता से, printf("%d ",p,p=1)काम नहीं करता है (यह हमेशा 1 प्रिंट करता है।) यह पहली बार नहीं है जब मैंने अजीब व्यवहार देखा है जब एक मूल्य का उपयोग किया जाता है printfऔर बाद में उसी ब्रैकेट में सौंपा जाता है । इस मामले में यह संभव है कि दूसरे अल्पविराम को एक तर्क विभाजक के रूप में नहीं माना जा रहा है, बल्कि एक ऑपरेटर के रूप में माना जा रहा है।

प्रयोग

$ ./a 2 3 5 7
1 2 3 6 5 10 15 30 7 14 21 42 35 70 105 210

Comments

C उस तर्क को सख्ती से परिभाषित नहीं करता है जिसमें तर्कों का मूल्यांकन किया जाता है। विशेष रूप से, कई C फ़ंक्शन कॉल में दलीलों का मूल्यांकन दाईं से बाईं ओर किया जाता है।

— सीओटीओ

की धारा 6.5.2.2 से TC3: आईएसओ / आईईसी 9899 : समारोह डेसिग्नेटर, वास्तविक बहस के मूल्यांकन के आदेश, और subexpressions वास्तविक बहस के भीतर अनिर्दिष्ट है [।] इसलिए, यह संकलक, जिसमें एक समारोह के आदेश पर निर्भर है तर्कों का मूल्यांकन किया जाता है। साथ -Wsequence-pointया -Wall, जीसीसी में शिकायत करेंगे।

— डेनिस

1. आप बदल सकते हैं c-=1करने के लिए c--या यहां तक कि का उपयोग i=--c<<cकरता है, तो आप यूबी कोई आपत्ति नहीं है (यह जीसीसी के साथ काम करने लगता है)। 2. दोनों उपयोगों को ||टर्नरी ऑपरेटरों के साथ बदला जा सकता है: p=i%c?p:!!printf("%d ",p)औरp*=(i/c>>i%c)&1?1:atoi(v[i%c+1])

— डेनिस

@ डेनिस टिप्स के लिए धन्यवाद! मैंने बिस्तर से ठीक पहले पोस्ट किया था, इसलिए मुझे बस प्रोग्राम चलाना था। c-=1इस तरह की बुनियादी गोल्फिंग मैं इसे याद नहीं करना चाहिए था, लेकिन यह एक त्वरित बग फिक्स था क्योंकि मैं भूल गया था कि argv (प्रोग्राम नाम) में एक अतिरिक्त स्ट्रिंग है i=..c<<cGCC / cygwin पर काम करता है, लेकिन मैंने अपना मूल छोड़ दिया है। कार्यक्रम जैसा कि यह है और एक समारोह में ले जाया गया। इसलिए मैंने सिर्फ सीखा है कि sizeofफ़ंक्शन तर्कों के रूप में पारित सरणियों पर काम नहीं करता है। मैंने समारोह में टर्नरी ऑपरेटरों के लिए आपके सुझाव शामिल किए हैं। मैं आउटपुट के साथ अटका हुआ हूं क्योंकि मुझे किसी सरणी को वापस करने का कोई छोटा रास्ता नहीं दिख रहा है।

— लेवल रिवर सेंट

हाँ, सरणियाँ फ़ंक्शन तर्कों के रूप में पारित होती हैं जो संकेत देती हैं। - सी में एक सूचक को सरणी में पास करने के लिए यह असामान्य नहीं है कि इसमें फ़ंक्शन पैरामीटर के रूप में परिणाम शामिल होना चाहिए। प्रश्न कहता है कि आप मान सकते हैं कि उत्पाद 2 ^ 31 से छोटे हैं, इसलिए आप केवल आकार 512 की श्रेणी पास कर सकते हैं।

— डेनिस

Answer 6

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

यह एक गुमनाम फ़ंक्शन के रूप में @ sudo के CJam उत्तर का एक हास्केल कार्यान्वयन है। यह @proud हैस्केलर के भयानक हास्केल समाधान को नहीं हराएगा, लेकिन मैं इसे वैसे भी यहाँ छोड़ दूँगा।

foldr((=<<)(++).map.(*))[1]

स्पष्टीकरण: foldr एक बाइनरी फ़ंक्शन, एक मान और एक सूची में लेता है। फिर यह फ़ंक्शन के एक अनुप्रयोग द्वारा सूची में प्रत्येक कॉन्स सेल को प्रतिस्थापित करता है, और इस तरह से मूल्य द्वारा सूची के अंत foldr f v [a,b,c] == f a (f b (f c v)):। हमारा मान एक-तत्व वाली सूची है 1, और बाइनरी फ़ंक्शन है f = (=<<)(++).map.(*)। अब, fएक संख्या लेता है n, एक फ़ंक्शन बनाता है (n*)जो गुणा करता है, इससे एक फ़ंक्शन nबनाता है g = map(n*)जो उस फ़ंक्शन को किसी सूची के सभी तत्वों पर लागू करता है, और उस फ़ंक्शन को फ़ीड करता है (=<<)(++)। इधर, (++)संयोजन समारोह है, और (=<<)है monadic बाँध , जो इस मामले में में ले जाता है (++)और gलागू होता है, और एक समारोह है कि एक सूची में ले जाता है देता है,g इसकी एक प्रति, और दोनों को मिलाता है।

संक्षेप में: इनपुट सूची में [1]प्रत्येक संख्या के साथ शुरू करें , और nवर्तमान सूची की एक प्रति लें, सब कुछ को गुणा करें n, और इसे वर्तमान सूची में जोड़ें।

Answer 7

पायथन: 55 वर्ण

f=lambda l:l and[x*l[0]for x in f(l[1:])]+f(l[1:])or[1]

बारी-बारी से प्रत्येक नंबर को शामिल करने या बाहर करने के लिए चुनकर उत्पादों को पुन: बनाता है।

Comments

पुनरावर्ती समाधान! ठंडा!

— टॉड लेहमन

मुझे लगता है कि andयदि आप राशि को दूसरे तरीके से लिखते हैं तो आप अंतरिक्ष को छोड़ सकते हैं ?

— गणितमण्डल

@mathmandan यप, यह काम करता है, धन्यवाद।

— xnor

Answer 8

PARI / GP , 26 बाइट्स

v->divisors(factorback(v))

लंबे संस्करणों में शामिल हैं

v->divisors(prod(i=1,#v,v[i]))

(30 बाइट्स) और

v->divisors(fold((x,y)->x*y,v))

(31 बाइट्स)।

ध्यान दें कि यदि इनपुट सेट के बजाय एक गुणन मैट्रिक्स था , तो 18 बाइट्स को divisorsअकेले उपयोग करके बचाया जा सकता है । लेकिन एक सेट को एक फैक्टराइज़ेशन मैट्रिक्स में परिवर्तित करना 18 बाइट्स से अधिक लगता है। (मैं इसे 39 बाइट्स में सीधे v->concat(Mat(v~),Mat(vectorv(#v,i,1)))या 24 बाइट्स को गुणा करके और फिर से फैक्टरिंग करके v->factor(factorback(v))कर सकता हूं, क्या कोई बेहतर कर सकता है?)

Answer 9

ऋषि - ३६ ३४

अनिवार्य रूप से, मार्टिन ब्यूटनर के समाधान के समान , अगर मैं इसे सही ढंग से समझता हूं। जैसा कि मैंने एक टिप्पणी में इसका उल्लेख किया है, मैं इसे उत्तर के रूप में भी पोस्ट कर सकता हूं।

lambda A:map(prod,Combinations(A))

यह एक अनाम फ़ंक्शन है, जिसे उदाहरण के लिए इस प्रकार कहा जा सकता है:

(lambda A:map(prod,Combinations(A)))([2,3,5,7])

Comments

आप इसे एक अनाम फ़ंक्शन बनाकर 2 बाइट्स दाढ़ी कर सकते हैं (यह प्रश्न द्वारा अनुमति दी गई है)

— गर्व हैकर सेप

Answer 10

जे (20)

मुझे उम्मीद या अपेक्षा से अधिक समय हो गया।

*/@:^"1#:@i.@(2&^)@#

उपयोग:

    f=:*/@:^"1#:@i.@(2&^)@#
    f 2 3 5 7
1 7 5 35 3 21 15 105 2 14 10 70 6 42 30 210

यह किसी भी संख्या के लिए काम करता है, न कि केवल primes। इसके अलावा, प्राइम्स असीमित आकार के हो सकते हैं, जब तक कि सरणी में उपसर्ग होता है x:2 3 5 7x

Comments

*/@#~2#:@i.@^#14 बाइट्स के लिए एक विकल्प है।

— मीलों

Answer 11

05AB1E , 2 बाइट्स

æP

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

व्याख्या

æ   # powerset
 P  # product

Answer 12

आर, 56 बाइट्स

r=1;for(i in 1:length(s))r=c(r,apply(combn(s,i),2,prod))

मैं यहाँ पर विचार कर रहा हूँ कि सेट (और एक सूची) है। मुझे यकीन है कि इसे और भी छोटा बनाया जा सकता है। मैं देखूंगा।

Answer 13

PHP, 97 बाइट्स

<?for(;$i++<array_product($a=$_GET[a]);){$t=$i;foreach($a as$d)$t%$d?:$t/=$d;if($t<2)echo"$i\n";}