दिलचस्प पोस्ट
सूची <टी> या आईआईएलआईटी <टी> जब उपयोगकर्ता इसके बाहर क्लिक करता है तो एक DIV छिपाने के लिए jQuery का उपयोग करें एक यूआईएलबल के पाठ रंग की संपत्ति को कैसे सजीव करना है? कैसे HTTPS के साथ काम करने के लिए file_get_contents () प्राप्त करें? जावा में एक स्ट्रिंग दोहराते हुए आसान तरीका साझा किए गए लाइब्रेरी में वैश्विक और स्थिर चर का क्या होता है, जब यह गतिशील रूप से जुड़ा होता है? मैं भेंडी का उपयोग कर व्युत्पन्न कैसे गणना करूं? एंड्रॉइड से शैल कमांड निष्पादित करें एक सेटटाइमेट को रीसेट करना पेंट कम्पेनेंट () बनाम पेंट () और जेपीएनएल बनाम कैनवास एक पेंटब्रश-टाइप जीयूआई में Asp.NET MVC 3 में JSON.NET डिफ़ॉल्ट JSON सीरियललाइज़ के रूप में उपयोग करना – क्या यह संभव है? सफ़ारी, क्रोम, आईई, फ़ायरफ़ॉक्स और ओपेरा ब्राउज़र का पता कैसे लगाया जाता है? मैं एक एंड्रॉइड डिवाइस को प्रोग्रामैटिक रूप से सोने से कैसे रोकूं? यह जांचने का सर्वोत्तम तरीका है कि क्या यूआईटीबल वीक्सेल पूरी तरह से दृश्यमान है स्विफ्ट 2 – असुरक्षित पॉइंटर <शून्य> ऑब्जेक्ट के लिए

सी ++ में उत्पन्न संयोजन

मैं c ++ का उपयोग करके संयोजन पैदा करने के लिए एक स्रोत कोड खोज रहा हूं मुझे इसके लिए कुछ उन्नत कोड मिले, लेकिन यह केवल विशिष्ट संख्या पूर्वनिर्धारित डेटा के लिए अच्छा है। कोई मुझे कुछ संकेत दे सकता है, या शायद, संयोजन उत्पन्न करने के लिए कुछ विचार एक उदाहरण के रूप में, लगता है कि सेट S = {1, 2, 3, …., n} और हम इसे से r = 2 लेते हैं। इनपुट n और r । इस मामले में, प्रोग्राम लंबाई 2 की सरणी उत्पन्न करेगा, जैसे कि 5 2 आउटपुट 1 2, 1 3, आदि। मुझे एल्गोरिथ्म के निर्माण में कठिनाई थी मुझे इसके बारे में एक महीने लग गया।

वेब के समाधान से एकत्रित समाधान "सी ++ में उत्पन्न संयोजन"

std::next_permutation का उपयोग करने का एक आसान तरीका:

 #include <iostream> #include <algorithm> #include <vector> int main() { int n, r; std::cin >> n; std::cin >> r; std::vector<bool> v(n); std::fill(v.end() - r, v.end(), true); do { for (int i = 0; i < n; ++i) { if (v[i]) { std::cout << (i + 1) << " "; } } std::cout << "\n"; } while (std::next_permutation(v.begin(), v.end())); return 0; } 

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

 #include <iostream> #include <algorithm> #include <vector> int main() { int n, r; std::cin >> n; std::cin >> r; std::vector<bool> v(n); std::fill(v.begin(), v.begin() + r, true); do { for (int i = 0; i < n; ++i) { if (v[i]) { std::cout << (i + 1) << " "; } } std::cout << "\n"; } while (std::prev_permutation(v.begin(), v.end())); return 0; } 

स्पष्टीकरण का एक छोटा सा:

यह "चयन सरणी" ( v ) बनाकर काम करता है, जहां हम r चयनकर्ताओं को स्थान देते हैं, फिर हम इन चयनकर्ताओं के सभी क्रमरेखाएं बनाते हैं, और संबंधित सेट सदस्य को मुद्रित करते हैं यदि यह v के वर्तमान क्रमचय में चयनित होता है। उम्मीद है की यह मदद करेगा।

आप इसे लागू कर सकते हैं यदि आप ध्यान दें कि प्रत्येक स्तर के लिए आप संख्या 1 से n का चयन करें।

सी ++ में, हमें 'मैनुअली' को कॉल के बीच राज्य को रखने की ज़रूरत होती है, जो परिणाम (एक संयोजन) उत्पन्न करती है: इसलिए, हम उस श्रेणी का निर्माण करते हैं जो निर्माण पर राज्य को आरंभ करते हैं, और एक सदस्य होता है कि प्रत्येक कॉल पर संयोजन होता है, जबकि समाधान होते हैं : उदाहरण के लिए

 #include <iostream> #include <iterator> #include <vector> #include <cstdlib> using namespace std; struct combinations { typedef vector<int> combination_t; // initialize status combinations(int N, int R) : completed(N < 1 || R > N), generated(0), N(N), R(R) { for (int c = 1; c <= R; ++c) curr.push_back(c); } // true while there are more solutions bool completed; // count how many generated int generated; // get current and compute next combination combination_t next() { combination_t ret = curr; // find what to increment completed = true; for (int i = R - 1; i >= 0; --i) if (curr[i] < N - R + i + 1) { int j = curr[i] + 1; while (i <= R-1) curr[i++] = j++; completed = false; ++generated; break; } return ret; } private: int N, R; combination_t curr; }; int main(int argc, char **argv) { int N = argc >= 2 ? atoi(argv[1]) : 5; int R = argc >= 3 ? atoi(argv[2]) : 2; combinations cs(N, R); while (!cs.completed) { combinations::combination_t c = cs.next(); copy(c.begin(), c.end(), ostream_iterator<int>(cout, ",")); cout << endl; } return cs.generated; } 

परीक्षण आउटपुट:

 1,2, 1,3, 1,4, 1,5, 2,3, 2,4, 2,5, 3,4, 3,5, 4,5, 
  #include<iostream> using namespace std; for(int i=1;i<=5;i++) for (int j=2;j<=5;j++) if (i!=j) cout<<i<<","<<j<<","<<endl; //or instead of cout... you can put them in a matrix nx 2 and use the solution 

मुझे यह पता लगाना था कि आप इसे कागज पर कैसे कर सकते हैं और उस से छद्मुकोड अनुमान लगा सकते हैं उसके बाद, आपको हेरफेर किए गए डेटा को सांकेतिकृत करने और संग्रहीत करने का तरीका तय करना होगा।

पूर्व के लिए:

 For each result item in result array // 0, 1, ... r For each item possible // 0, 1, 2, ... n if current item does not exist in the result array place item in result array exit the inner for end if end for end for 

आप पुनरावर्ती का उपयोग कर सकते हैं जिससे आप एन संयोजन को चुन सकते हैं, तो आप एन संयोजन चुनते हैं और फिर इसमें 1 जोड़ें। 1 जो आप जोड़ते हैं, वह हमेशा अपने एन के अंतिम एक के बाद होना चाहिए, इसलिए यदि आपके एन में अंतिम तत्व शामिल है तो इसके साथ जुड़े कोई एन + 1 संयोजन नहीं है।

शायद सबसे ज्यादा कुशल समाधान नहीं है लेकिन यह काम करना चाहिए।

बेस केस 0 या 1 चुनना होगा। आप 0 चुन सकते हैं और खाली सेट प्राप्त कर सकते हैं। एक खाली सेट से आप मान सकते हैं कि इटेरेटर्स तत्वों के बीच काम करते हैं और उनपर नहीं।

कोड द्विआधारी अंक पैदा करने के समान है। एक अतिरिक्त डेटा संरचना रखें, एक सरणी perm [], जिसका सूचकांक में मैं बताता हूँ अगर ith सरणी तत्व शामिल है या नहीं और एक गिनती चर भी रखें जब भी संयोजन की लंबाई ==, perm पर आधारित प्रिंट तत्वों []

 #include<stdio.h> // a[] : given array of chars // perm[] : perm[i] is 1 if a[i] is considered, else 0 // index : subscript of perm which is to be 0ed and 1ed // n : length of the given input array // k : length of the permuted string void combinate(char a[], int perm[],int index, int n, int k) { static int count = 0; if( count == k ) { for(int i=0; i<n; i++) if( perm[i]==1) printf("%c",a[i]); printf("\n"); } else if( (n-index)>= (k-count) ){ perm[index]=1; count++; combinate(a,perm,index+1,n,k); perm[index]=0; count--; combinate(a,perm,index+1,n,k); } } int main() { char a[] ={'a','b','c','d'}; int perm[4] = {0}; combinate(a,perm,0,4,3); return 0; } 

यह एक रिकर्सिव विधि है, जिसका उपयोग आप किसी भी प्रकार पर कर सकते हैं। आप संयोजन वर्ग (उदाहरण के लिए या सभी) संयोजनों के साथ वेक्टर () प्राप्त कर सकते हैं, प्रत्येक संयोजन ऑब्जेक्ट के वेक्टर है। यह सी ++ 11 में लिखा गया है।

 //combinations.hpp #include <vector> template<typename T> class Combinations { // Combinations(std::vector<T> s, int m) iterate all Combinations without repetition // from set s of size ms = {0,1,2,3,4,5} all permuations are: {0, 1, 2}, {0, 1,3}, // {0, 1, 4}, {0, 1, 5}, {0, 2, 3}, {0, 2, 4}, {0, 2, 5}, {0, 3, 4}, {0, 3, 5}, // {0, 4, 5}, {1, 2, 3}, {1, 2, 4}, {1, 2, 5}, {1, 3, 4}, {1, 3, 5}, {1, 4, 5}, // {2, 3, 4}, {2, 3, 5}, {2, 4, 5}, {3, 4, 5} public: Combinations(std::vector<T> s, int m) : M(m), set(s), partial(std::vector<T>(M)) { N = s.size(); // unsigned long can't be casted to int in initialization out = std::vector<std::vector<T>>(comb(N,M), std::vector<T>(M)); // allocate space generate(0, N-1, M-1); }; typedef typename std::vector<std::vector<T>>::const_iterator const_iterator; typedef typename std::vector<std::vector<T>>::iterator iterator; iterator begin() { return out.begin(); } iterator end() { return out.end(); } std::vector<std::vector<T>> get() { return out; } private: void generate(int i, int j, int m); unsigned long long comb(unsigned long long n, unsigned long long k); // C(n, k) = n! / (nk)! int N; int M; std::vector<T> set; std::vector<T> partial; std::vector<std::vector<T>> out; int count (0); }; template<typename T> void Combinations<T>::generate(int i, int j, int m) { // combination of size m (number of slots) out of set[i..j] if (m > 0) { for (int z=i; z<j-m+1; z++) { partial[Mm-1]=set[z]; // add element to permutation generate(z+1, j, m-1); } } else { // last position for (int z=i; z<j-m+1; z++) { partial[Mm-1] = set[z]; out[count++] = std::vector<T>(partial); // add to output vector } } } template<typename T> unsigned long long Combinations<T>::comb(unsigned long long n, unsigned long long k) { // this is from Knuth vol 3 if (k > n) { return 0; } unsigned long long r = 1; for (unsigned long long d = 1; d <= k; ++d) { r *= n--; r /= d; } return r; } 

टेस्ट फ़ाइल:

 // test.cpp // compile with: gcc -O3 -Wall -std=c++11 -lstdc++ -o test test.cpp #include <iostream> #include "combinations.hpp" struct Bla{ float x, y, z; }; int main() { std::vector<int> s{0,1,2,3,4,5}; std::vector<Bla> ss{{1, .4, 5.0},{2, .7, 5.0},{3, .1, 2.0},{4, .66, 99.0}}; Combinations<int> c(s,3); // iterate over all combinations for (auto x : c) { for (auto ii : x) std::cout << ii << ", "; std::cout << "\n"; } // or get a vector back std::vector<std::vector<int>> z = c.get(); std::cout << "\n\n"; Combinations<Bla> cc(ss, 2); // combinations of arbitrary objects for (auto x : cc) { for (auto b : x) std::cout << "(" << bx << ", " << by << ", " << bz << "), "; std::cout << "\n"; } } 

आउटपुट है:

0, 1, 2, 0, 1, 3, 0, 1, 4, 0, 1, 5, 0, 2, 3, 0, 2, 4, 0, 2, 5, 0, 3, 4, 0, 3, 5, 0, 4, 5, 1, 2, 3, 1, 2, 4, 1, 2, 5, 1, 3, 4, 1, 3, 5, 1, 4, 5, 2, 3, 4, 2, 3, 5, 2, 4, 5, 3, 4, 5,

(1, 0.4, 5), (2, 0.7, 5), (1, 0.4, 5), (3, 0.1, 2), (1, 0.4, 5), (4, 0.66, 99), (2 , 0, 5,), (3, 0.1, 2), (2, 0.7, 5), (4, 0.66, 99), (3, 0.1, 2), (4, 0.66, 99)

 void print(int *a, int* s, int ls) { for(int i = 0; i < ls; i++) { cout << a[s[i]] << " "; } cout << endl; } void PrintCombinations(int *a, int l, int k, int *s, int ls, int sp) { if(k == 0) { print(a,s,ls); return; } for(int i = sp; i < l; i++) { s[k-1] = i; PrintCombinations(a,l,k-1,s,ls,i+1); s[k-1] = -1; } } int main() { int e[] = {1,2,3,4,5,6,7,8,9}; int s[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}; PrintCombinations(e,9,6,s,6,0); } 

के विशेष मामले के लिए (n चुनें आर) , जहां r एक स्थिर स्थिरांक है, हम स्थिति में आने के लिए आर नेस्टेड लूप लिख सकते हैं। कभी-कभी जब आर तय नहीं होता है, तो हमारे पास एक और विशेष मामला हो सकता है (n चुनना nr) , जहां आर फिर से एक स्थिर स्थिरांक है विचार यह है कि प्रत्येक इस तरह के संयोजन संयोजन के व्युत्क्रम (n चुनें आर) है। तो हम फिर से नेस्टेड लूप का उपयोग कर सकते हैं, लेकिन समाधान उलटा कर सकते हैं:

 // example 1: choose each 2 from given vector and apply 'doSomething' void doOnCombinationsOfTwo(const std::vector<T> vector) { for (int i1 = 0; i1 < vector.size() - 1; i1++) { for (int i2 = i1 + 1; i2 < vector.size(); i2++) { doSomething( { vector[i1], vector[i2] }); } } } // example 2: choose each n-2 from given vector and apply 'doSomethingElse' void doOnCombinationsOfNMinusTwo(const std::vector<T> vector) { std::vector<T> combination(vector.size() - 2); // let's reuse our combination vector for (int i1 = 0; i1 < vector.size() - 1; i1++) { for (int i2 = i1 + 1; i2 < vector.size(); i2++) { auto combinationEntry = combination.begin(); // use iterator to fill combination for (int i = 0; i < vector.size(); i++) { if (i != i1 && i != i2) { *combinationEntry++ = i; } } doSomethingElse(combinationVector); } } } 

प्रोफेसर नाथन वोडर्स के एल्गोरिदम पर आधारित मेरे सरल और कुशल समाधान:

 // n choose r combination #include <vector> #include <iostream> #include <algorithm> struct c_unique { int current; c_unique() {current=0;} int operator()() {return ++current;} } UniqueNumber; void myfunction (int i) { std::cout << i << ' '; } int main() { int n=5; int r=3; std::vector<int> myints(r); std::vector<int>::iterator first = myints.begin(), last = myints.end(); std::generate(first, last, UniqueNumber); std::for_each(first, last, myfunction); std::cout << std::endl; while((*first) != n-r+1){ std::vector<int>::iterator mt = last; while (*(--mt) == n-(last-mt)+1); (*mt)++; while (++mt != last) *mt = *(mt-1)+1; std::for_each(first, last, myfunction); std::cout << std::endl; } } 

तो आउटपुट है:
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5

 public static class CombinationGenerator { int n; int k; Integer[] input; List<List<Integer>> output; public CombinationGenerator(int n, int k) { this.n = n; this.k = k; input = new Integer[n]; for (int i = 1; i <= n; i++) { input[i-1] = i; } } public List<List<Integer>> generate(){ if(k>n){ throw new RuntimeErrorException(null, "K should be less than N"); } output = generate(0, k); printOutput(); return output; } private List<List<Integer>> generate(int cur, int k) { List<List<Integer>> output = new ArrayList<List<Integer>>(); int length = input.length - cur; if(length == k){ List<Integer> result = new ArrayList<Integer>(); for (int i = cur; i < input.length; i++) { result.add(input[i]); } output.add(result); } else if( k == 1){ for (int i = cur; i < input.length; i++) { List<Integer> result = new ArrayList<Integer>(); result.add(input[i]); output.add(result); } } else{ for (int i = cur; i < input.length; i++) { List<List<Integer>> partialResult = generate(i+1, k-1); for (Iterator<List<Integer>> iterator = partialResult.iterator(); iterator .hasNext();) { List<Integer> list = (List<Integer>) iterator.next(); list.add(input[i]); } output.addAll(partialResult); } } return output; } private void printOutput(){ for (Iterator<List<Integer>> iterator = output.iterator(); iterator .hasNext();) { printList((List<Integer>) iterator.next()); } } private void printList(List<Integer> next) { for (Iterator<Integer> iterator = next.iterator(); iterator.hasNext();) { Integer integer = (Integer) iterator.next(); System.out.print(integer.intValue()); } System.out.print("\n"); } }