c# - Need an algorithm to calculate all variations (Combination Calculation) -

इस सवाल का पहले से ही एक उत्तर है: < / P>

• 63 जवाब

  मेरे पास सूची है

  उदाहरण के लिए यदि आइटम की गणना 4 है, तो आउटपुट होगा;

  < मजबूत> आइटम:

  {1, 2, 3, 4}

  ResulSet:

  {12} , {34}

  {13}, {24}

  {14}, {23}

  आदेश कोई फर्क नहीं पड़ता, {12} को कवर करता है {21 }। आइटम गणना 6 के लिए, आउटपुट होगा;

  आइटम:

  {1, 2, 3, 4, 5, 6}

  ResulSet:

  12 34 56

  12 35 46

  12 36 45

  13 25 46

  13 26 45

  14 23 56

  14 25 36

  15 23 46

  15 24 36

  15 26 34

  16 23 45

  16 24 35

  16 25 34

  सह कृपया मुझे एक रास्ता दिखाओ?

  धन्यवाद।

  संपादित करें:

  सवाल वास्तव में पढ़ने के लिए कम है, और यदि आप प्रश्न पढ़ने के लिए 1 मिनट लेते हैं आप देख सकते हैं कि अधिकांश लोगों की तरह डुप्लिकेट नहीं है (शायद वे अर्द्ध-अशिक्षित हैं)

  संयोजन {1, 2, 3, 4, 5, 6} है

  123456 और जैसा कि आप शीर्ष पर देखते हैं, यह ऐसा नहीं है जो मैं देख रहा हूं। प्रश्न पढ़ें अगर आप मदद करना चाहते हैं या बस बंद हो जाएं।

  एक अच्छा दिन हो।

  क्योंकि आपके पास हमेशा आपके संयोजन में दो सदस्य हैं, पाश के लिए एक साधारण नेस्टेड काम करना चाहिए:

    के लिए (int i = 0; i & lt; data.Length - 1; i ++) के लिए (Int j = i + 1; j & lt; data.length; j ++ कंसोल.प्रकाशलाइन ({0} {1}, i, j);   
   हम प्रत्येक आइटम पर पुनरावृति सूची, पिछले एक के बगल में (क्योंकि हमारे पास 1 नंबर कोम्बो नहीं हो सकता है)। इनमें से प्रत्येक पुनरावृत्त में, हम बाहरी पुनरावृत्ति चर और 1 (कोई डुप्लिकेटिंग तत्व) से सूची के अंत तक पुनरावृत्त करते हैं। / P> 
   यह सभी अनूठे संयोजन उत्पन्न करेगा। दो या तीन से अधिक सदस्य आउटपुट करने के लिए, आप पुनरावर्ती को देखना चाहते हैं। मैं पाठक को एक अभ्यास के रूप में अपने प्रश्न से मेल खाने के लिए आउटपुट स्वरूपण छोड़ दूँगा :)।  
   6 तत्व संयोजनों के लिए, हमें पुनरावृत्ति की जंगली दुनिया में तल्लीन करना होगा। पुनरावर्तन वास्तव में आपके सिर से गड़बड़ कर सकता है, इसलिए कृपया पूछें कि क्या आपको कुछ समझ नहीं आ रहा है। पुनरावर्ती के सामान्य सिद्धांत यह है: "पहले तत्व के साथ कुछ करो, अपने आप को बुलाओ और बाकी को पास करें"। इस स्थिति में, कोड कुछ ऐसा दिखेगा:  
    सार्वजनिक सूची & lt; सूची & lt; int & gt; & gt; GetAllCombos (int [] मान) {// इसे 0 इंडेक्स रिटर्न के साथ किक करना GetCombos (मान, 0); } निजी सूची & lt; सूची & lt; int & gt; & gt; GetCombos (int [] मान, int myIndex) {// इस सूचकांक से संयोजन के लिए एक धारक सूची & lt; सूची & lt; int & gt; & gt; Combos = नई सूची & lt; सूची & lt; int & gt; & gt; (); {कॉमबो (मूल्य, मेरी इंडेक्स + 1)) {combo.Add (i (मान [myIndex] [मैं]); combos.Add (कॉम्बो); }} और {सूची & lt; int & gt; NewCombination = नई सूची & lt; int & gt; () {मूल्य [myIndex] [i]}; combos.Add (newCombination); }} वापसी कॉम्बोस; }   
   दोबारा, कृपया सुनिश्चित करें कि आपसे पूछें कि क्या आपको कुछ समझ में नहीं आ रहा है Recursion समझने के लिए एक बहुत मुश्किल अवधारणा हो सकती है!