2011-03-08 10 views
27

में मैं सरणियों की एक सरणी इसलिए की तरह है,:सभी संभव संयोजनों में सरणी के सरणी कम्बाइन, आगे केवल, रूबी

[['1','2'],['a','b'],['x','y']] 

मैं एक स्ट्रिंग इन तीनों का सभी संभव संयोजनों से युक्त में उन सरणियों गठबंधन करने के लिए की जरूरत है सेट, केवल आगे। मैंने किसी भी क्रम में सेट के सभी संभावित संयोजनों के कई उदाहरण देखे हैं, जो मैं नहीं चाहता हूं। उदाहरण के लिए, मैं नहीं चाहता कि पहले सेट में से किसी भी तत्व को दूसरे सेट के बाद आना चाहिए, या तीसरे सेट में किसी भी पहले या दूसरे से पहले आने वाला है, और इसी तरह। तो, उपर्युक्त उदाहरण के लिए, आउटपुट होगा:

['1ax', '1ay', '1bx', '1by', '2ax', '2ay', '2bx', '2by'] 

सरणी की संख्या, और प्रत्येक सेट की लंबाई गतिशील है।

क्या कोई जानता है कि रूबी में इसे कैसे हल किया जाए?

+0

संभव डुप्लिकेट (http://stackoverflow.com/questions/5543896/multiple -इटरेशन) –

+0

यह भी देखें [बहु-आयामी सरणी से क्रमपरिवर्तन बनाना] (http://stackoverflow.com/questions/5582481/creating-permutations-from-a-multi-dimensional-array-in-ruby) – aidan

उत्तर

52

Know अपने Array#product:

a = [['1','2'],['a','b'],['x','y']] 
a.first.product(*a[1..-1]).map(&:join) 
+5

सेक्सीटाइम! बहुत बढ़िया। – Phrogz

+0

@Travis: यदि यह आपके प्रश्न का उत्तर देता है, तो आप प्रश्न के बगल में टिक/चेक मार्क पर निशान लगा सकते हैं। –

+0

यह मेरे लिए काम नहीं करता है: यह मुझे केवल '' ['1ax', '2by'] '':/ – bfontaine

6

एक पुनरावर्ती का उपयोग कर हल, तथाकथित "Dynamic Programming" दृष्टिकोण:

  • एन-सरणियों के लिए, पहली सरणी की प्रविष्टियों प्रत्येक परिणाम के साथ शेष (n-1) सरणियों पर
  • एक के लिए गठबंधन एकल सरणी, जवाब सिर्फ इतना है कि सरणी

है कोड में:

def variations(a) 
    first = a.first 
    if a.length==1 then 
    first 
    else 
    rest = variations(a[1..-1]) 
    first.map{ |x| rest.map{ |y| "#{x}#{y}" } }.flatten 
    end 
end 

p variations([['1','2'],['a','b'],['x','y']]) 
#=> ["1ax", "1ay", "1bx", "1by", "2ax", "2ay", "2bx", "2by"] 

puts variations([%w[a b],%w[M N],['-'],%w[x y z],%w[0 1 2]]).join(' ') 
#=> aM-x0 aM-x1 aM-x2 aM-y0 aM-y1 aM-y2 aM-z0 aM-z1 aM-z2 aN-x0 aN-x1 aN-x2 
#=> aN-y0 aN-y1 aN-y2 aN-z0 aN-z1 aN-z2 bM-x0 bM-x1 bM-x2 bM-y0 bM-y1 bM-y2 
#=> bM-z0 bM-z1 bM-z2 bN-x0 bN-x1 bN-x2 bN-y0 bN-y1 bN-y2 bN-z0 bN-z1 bN-z2 

आप तर्क को भी उलट सकते हैं, और देखभाल के साथ आप इस गैर-पुनरावर्ती रूप से लागू करने में सक्षम होना चाहिए। लेकिन पुनरावर्ती उत्तर बल्कि सरल है। :)

+1

अच्छी तरह से कोडित , नक्शे और रिकर्सन! – macarthy

3

शुद्ध, उत्पाद के साथ कम हो:

a = [['1','2'],['a','b'],['x','y']] 
a.reduce() { |acc, n| acc.product(n).map(&:flatten) }.map(&:join) 
# => ["1ax", "1ay", "1bx", "1by", "2ax", "2ay", "2bx", "2by"] 
की [एकाधिक पुनरावृत्तियों]

 संबंधित मुद्दे

  • कोई संबंधित समस्या नहीं^_^