ग्रोवी

Question

में वास्तविक संयोजन क्या कोई तरीका या कुछ स्मार्ट तरीका है जो ग्रोवी में तत्वों के combination बनाने के लिए आसान है? मुझे Iterable#combinations या GroovyCollections#combinations से अवगत है, लेकिन यह पुनरावृत्ति के साथ आंशिक क्रमपरिवर्तन बनाता है क्योंकि मैं इसे अब तक समझता हूं। उदाहरण देखें।

// Groovy combinations result 
def e = ['a', 'b', 'c'] 
def result = [e, e].combinations() 
assert [['a', 'a'], ['b', 'a'], ['c', 'a'], ['a', 'b'], ['b', 'b'], ['c', 'b'], ['a','c'], ['b', 'c'], ['c', 'c']] == result 

// What I'm looking for 
def e = ['a', 'b', 'c'] 
def result = ??? 
assert [['a', 'b'], ['a', 'c'], ['b', 'c']] == result 

वैकल्पिक समाधान पोस्ट करने के लिए स्वतंत्र महसूस। मैं अभी भी बेहतर पठनीयता की तलाश में हूं (यह गैर-डेवलपर्स के लिए स्क्रिप्ट में उपयोग किया जाता है) और प्रदर्शन (w/o अनावश्यक पुनरावृत्तियों)।

Answer 1

मुझे पठनीयता के बारे में इतना यकीन नहीं है, लेकिन यह चाल चलनी चाहिए।

def e = ['a', 'b', 'c'] 
def result = [e, e].combinations().findAll { a, b -> 
    a < b 
} 

assert [['a', 'b'], ['a', 'c'], ['b', 'c']] == result 

ध्यान दें कि यदि कोई तत्व सूची में दो बार होता है तो इसके संयोजन दो बार भी होंगे। अंत में एक '.unique()' जोड़ें यदि वे अवांछित हैं

Answer 2

यहां एक और सामान्यीकृत दृष्टिकोण है जो आपको अपने एनसीआर संयोजनों के लिए "आर" मान निर्दिष्ट करने की अनुमति देता है। यह सेट्स में क्रमपरिवर्तन संग्रहित करता है, जिसमें विशिष्टता प्रदान करने वाले सेट होते हैं:

// returns combinations of the input list of the provided size, r 
List combinationsOf(List list, int r) { 
    assert (0..<list.size()).contains(r) // validate input 
    def combs = [] as Set 
    list.eachPermutation { 
     combs << it.subList(0, r).sort { a, b -> a <=> b } 
    } 
    combs as List 
} 

// the test scenario... 
def e = ['a', 'b', 'c'] 
def result = combinationsOf(e, 2) 
assert [['a', 'b'], ['a', 'c'], ['b', 'c']] == result