विभाज्यता संबंध में अधिकतम मिलान का पता लगाएं

Question

आपको सकारात्मक पूर्णांक का एक सेट दिया जाता है। आपको उन्हें ऐसे जोड़े में व्यवस्थित करना होगा:

• प्रत्येक जोड़ी में 2 नंबर होते हैं, जिनमें से एक दूसरे का गुणक होता है। उदाहरण के लिए, 8 4 का गुणक है, और 9 का गुणक 9 है।
• यदि प्रारंभिक सेट में एक ही संख्या कई बार होती है, तो इसका उपयोग जोड़े में कई बार किया जा सकता है; एक संख्या को समान संख्या की दूसरी घटना के साथ जोड़ा जा सकता है
• जोड़े की अधिकतम संभव संख्या प्राप्त की जाती है।

आउटपुट जोड़े की संख्या होनी चाहिए। सबसे छोटा कोड जीतता है।

नमूना डेटा

2,3,4,8,9,18 -> 3

7,14,28,42,56 -> 2

7,1,9,9,4,9,9,1,3,9,8,5 -> 6

8,88,888,8888,88888,888888 -> 3

2,6,7,17,16,35,15,9,83,7 -> 2

Comments

किसी को पता है कि क्या यह समस्या एनपी-पूर्ण है? मुझे लगता है कि सबसे छोटा "कठिन" सेट है 2,3,4,8,9,18। (उस सूची में प्रत्येक संख्या सूची में कम से कम दो अन्य संख्याओं का एक कारक और / या एकाधिक है, लेकिन इसका केवल एक ही समाधान है।)

— नील

Answer 1

हास्केल, 109 107 76 70 बाइट्स

33 बाइट बचाने और मुझे कुछ और हास्केल सिखाने के लिए नीमी का धन्यवाद। :)
एक और 6 बाइट बचाने के लिए xnor के लिए धन्यवाद।

import Data.List
f l=maximum$0:[1+f t|a:b:t<-permutations l,a`mod`b<1]

याय, मेरा पहला हास्केल गोल्फ। यह अब तक के सभी उत्तरों के समान ही काम करता है (ठीक है, काफी नहीं: यह केवल प्रत्येक क्रमपरिवर्तन में वैध जोड़े के सबसे लंबे उपसर्ग की लंबाई को गिनता है, लेकिन यह समकक्ष है और वास्तव में मेरे मूल CJam कोड ने क्या किया है)।

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

Comments

है f=आवश्यक?

— एलेक्स ए।

@AlexA। मुझे यकीन नहीं है कि हास्केल में अनाम कार्यों के लिए पीपीसीजी पर मानक नीति क्या है, लेकिन मैंने कुछ अन्य हास्केल उत्तरों की जांच की है और उन्होंने नामित कार्यों का उपयोग किया है। साथ ही, आपको तकनीकी रूप से फ़ंक्शन के आसपास कोष्ठक का उपयोग करना होगा यदि आप इसे एक अनाम फ़ंक्शन के रूप में उपयोग करना चाहते हैं, तो यह वैसे ही बाइट काउंट होगा जो मुझे लगता है।

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

@nimi मुझे बताने के लिए धन्यवाद। :) क्या आपको कुछ और दिखाई देता है जिसे छोटा किया जा सकता है? के लिए आयात chunksOfदर्दनाक है। मैं वास्तव में हास्केल के मानक पुस्तकालय को नहीं जानता कि यह बताने में सक्षम है कि क्या कोई छोटा समकक्ष कार्य है। मैंने खुद इसे लागू करने की कोशिश की, लेकिन यह आयात की तुलना में दो या तीन बाइट्स से अधिक लंबा निकला।

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

ओह्ह, दोनों को पकड़ना []और [_]एक ही समय में g x=[]दूसरा डालना वास्तव में चतुर है। मैं कोशिश करूँगा। धन्यवाद :)

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

पूरे फ़ंक्शन को पुनरावर्ती रूप से परिभाषित करने के लिए थोड़ा छोटा लगता है f l=maximum$0:[1+f t|(a:b:t)<-permutations l,a`mod`b<1]:।

— xnor

Answer 2

सीजाम, 22 18 बाइट्स

q~e!{2/::%0e=}%:e>

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

CJam- शैली सूची के रूप में इनपुट की अपेक्षा करता है।

यह बड़ी सूचियों के लिए थोड़ा अक्षम है (और जावा संभवतः मेमोरी से बाहर चलेगा जब तक कि आप इसे अधिक नहीं देते)।

व्याख्या

q~     e# Read and evaluate input.
e!     e# Get all distinct permutations.
{      e# Map this block onto each permutation...
  2/   e#   Split the list into (consecutive) pairs. There may be a single element at the
       e#   end, which doesn't participate in any pair.
  ::%  e#   Fold modulo onto each chunk. If it's a pair, this computes the modulo, which
       e#   yields 0 if the first element is a multiple of the second. If the list has only
       e#   one element, it will simply return that element, which we know is positive.
  0e=  e#   Count the number of zeroes (valid pairs).
}%
:e>    e# Find the maximum of the list by folding max() onto it.

Comments

यह उत्पादन नहीं देता है के लिए [1 2 3 4 5 6 7 8 9 10]हालांकि [7 1 9 9 4 9 9 1 3 9 8 1]जो एक लंबी सूची है, ठीक से काम करता है। ऐसा क्यों है?

— भूत_न_थे_कोडे २५'१५

@ghosts_in_the_code क्योंकि पूर्व में अधिक विशिष्ट क्रमपरिवर्तन हैं। 10! = 3628800, लेकिन 12! / 5! / 3! = 665280। तो यह पहले मामले के लिए स्मृति से बाहर चलाता है। यदि आप इसे जावा दुभाषिया के साथ कंसोल से चलाते हैं, तो आप जावा को अधिक मेमोरी का उपयोग करने के लिए कह सकते हैं और पहला मामला भी काम करेगा (हालांकि इसमें कुछ समय लग सकता है, पता नहीं)।

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

Answer 3

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

eSm/%Mcd2Z.pQ

समय और भंडारण की जटिलता वास्तव में भयानक है। पहली बात यह है कि मूल रूप से सूची के सभी क्रमपरिवर्तन के साथ एक सूची बनाना है। यह n*n!भंडारण लेता है। लंबाई 9 के साथ इनपुट सूची पहले से ही काफी लंबा समय लेती है।

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

eSm/%Mcd2Z.pQ
            Q   read the list of integer
          .p    create the list of all permutations
  m             map each permutation d to:
      cd2          split d into lists of length 2
    %M             apply modulo to each of this lists
   /     Z         count the zeros (=number of pairs with the first 
                   item divisible by the second)
 S              sort these values
e               and print the last one (=maximum)

Answer 4

मैथेमेटिका, 95 93 87 83 79 60 58 बाइट्स

Max[Count[#~Partition~2,{a_,b_}/;a∣b]&/@Permutations@#]&

बड़े उदाहरणों के लिए कुछ सेकंड लेता है।

Answer 5

मतलाब (120 + 114 = 234)

  function w=t(y,z),w=0;for i=1:size(z,1),w=max(w,1+t([y,z(i,:)],feval(@(d)z(d(:,1)&d(:,2),:),~ismember(z,z(i,:)))));end

मुख्य:

  a=input('');h=bsxfun(@mod,a,a');v=[];for i=1:size(h,1) b=find(~h(i,:));v=[v;[(2:nnz(b))*0+i;b(b~=i)]'];end;t([],v)

---

• टॉपर फ़ंक्शन को मुख्य भाग कहा जाता है।

• इनपुट फॉर्म में है [. . .]

Answer 6

मैटलैब (365)

  j=@(e,x)['b(:,' num2str(e(x)) ')'];r=@(e,y)arrayfun(@(t)['((mod(' j(e,1) ',' j(e,t) ')==0|mod(' j(e,t) ',' j(e,1) ')==0)&',(y<4)*49,[cell2mat(strcat(r(e(setdiff(2:y,t)),y-2),'|')) '0'],')'],2:y,'UniformOutput',0);a=input('');i=nnz(a);i=i-mod(i,2);q=0;while(~q)b=nchoosek(a,i);q=[cell2mat(strcat((r(1:i,i)),'|')) '0'];q=nnz(b(eval(q(q~=0)),:));i=i-2;end;fix((i+2)/2)

---

• यह स्पष्ट रूप से लंबा है, लेकिन ऑनलाइनर और कार्यकारी, और मैं भागने में कामयाब रहा perms फ़ंक्शन क्योंकि यह हमेशा के लिए लेता है।

• यह फ़ंक्शन गुमनाम कार्यों के कारण चुपचाप चलाने के लिए कई पुनरावृत्तियां लेता है, मैं यहां सुझावों के लिए खुला हूं :)