दिलचस्प पोस्ट
। सीपीपी फ़ाइल में सी + + इनलाइन सदस्य फ़ंक्शन जावा में तरीके बनाम कन्स्ट्रक्टर्स क्या Node.js के लिए एक टेम्पलेट इंजन है? वेबपैक "ओटीएस पार्सिंग त्रुटि" लोडिंग फोंट जावा में एक सूची को कैसे सीरियल करना है? वस्तु का संदर्भ वस्तु की आवृत्ति अनुसार सेट नहीं. है। क्या कोई विवरण है कि कैसे __cmp__ पायथन 2 में डिक् ऑब्जेक्ट्स के लिए काम करता है? निरंतर भाषण मान्यता एंड्रॉइड फेसबुक से लाइव लाइव टोकन प्राप्त करें डापर के साथ रेपॉजिटरी डिजाइन पैटर्न अपाचे बिलाव ग्रहण सर्वर रनटाइम वातावरण में नहीं दिखा रहा है निर्दिष्ट स्थिति पर तत्व प्राप्त करें – जावास्क्रिप्ट XmlReader में सी # के साथ पढ़ना एक्सएमएल क्यों typeid.name () जीसीसी का इस्तेमाल करते हुए अजीब अक्षर को बदलता है और इसे बिना नाम वाले नामों को कैसे प्रिंट किया जाता है? एजेक्स पोस्ट से फाइल डाउनलोड करें

कश्मीर बीट सेट के साथ लम्बाई के सभी द्विआधारी स्ट्रिंग उत्पन्न करें

कश्मीर बीट सेट वाले लम्बाई के सभी बाइनरी स्ट्रिंग्स को खोजने के लिए सबसे अच्छा एल्गोरिथ्म क्या है? उदाहरण के लिए, यदि n = 4 और k = 3, तो …

0111 1011 1101 1110 

मुझे ये किसी भी एन और किसी भी कश्मीर को उत्पन्न करने का एक अच्छा तरीका चाहिए ताकि मैं इसे तार के साथ करना चाहता हूं।

वेब के समाधान से एकत्रित समाधान "कश्मीर बीट सेट के साथ लम्बाई के सभी द्विआधारी स्ट्रिंग उत्पन्न करें"

यह विधि बिल्कुल एन '1' बिट्स के साथ सभी पूर्णांक उत्पन्न करेगी।

https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation से

लेक्सिकोग्राफी के अगले बिट क्रमचय को गणना करें

मान लीजिए कि हमारे पास एक पूर्णांक में 1 से निर्धारित एन बीट्स का एक पैटर्न है और हम एन 1 बिट के अगले क्रम को एक शब्दकोषीय अर्थ में चाहते हैं। उदाहरण के लिए, यदि एन 3 है और बिट पैटर्न 00010011 , तो अगले पैटर्न 00010101 , 00010110 , 00011001 , 00011100 , 00100011 , 00100011 और इतने आगे होंगे। निम्नलिखित क्रमचय को गणना करने का एक तेज़ तरीका है

 unsigned int v; // current permutation of bits unsigned int w; // next permutation of bits unsigned int t = v | (v - 1); // t gets v's least significant 0 bits set to 1 // Next set to 1 the most significant bit to change, // set to 0 the least significant ones, and add the necessary 1 bits. w = (t + 1) | (((~t & -~t) - 1) >> (__builtin_ctz(v) + 1)); 

__builtin_ctz(v) x86 CPU के लिए जीएनयू सी कंपाइलर आंतरिक पीछे वाले शून्य की संख्या देता है। यदि आप x86 के लिए माइक्रोसॉफ्ट कंपाइलर्स का उपयोग कर रहे हैं, तो आंतरिक है _BitScanForward ये दोनों एक bsf निर्देश bsf , लेकिन अन्य आर्किटेक्चर के लिए समकक्ष उपलब्ध हो सकते हैं। यदि नहीं, तो पहले उल्लेख किए गए लगातार शून्य बिट्स की गणना के तरीकों में से एक का उपयोग करने पर विचार करें। यहां एक और संस्करण है जो इसके डिवाइजन ऑपरेटर की वजह से धीमे हो जाता है, लेकिन यह अनुक्रमित शून्य को गिनने की आवश्यकता नहीं है।

 unsigned int t = (v | (v - 1)) + 1; w = t | ((((t & -t) / (v & -v)) >> 1) - 1); 

अर्जेंटीना के डायरियो Sneidermanis के लिए धन्यवाद, जिन्होंने 28 नवंबर 200 9 को यह प्रदान किया।

अजगर

 import itertools def kbits(n, k): result = [] for bits in itertools.combinations(range(n), k): s = ['0'] * n for bit in bits: s[bit] = '1' result.append(''.join(s)) return result print kbits(4, 3) Output: ['1110', '1101', '1011', '0111'] 

स्पष्टीकरण:

मूलतः हमें 1 बिट्स के पदों को चुनना होगा। N कुल बिट्स के बीच के बी बिट्स को चुनने के कश्मीर तरीकों को चुनना है। इटेरोलॉल्स एक अच्छा मॉड्यूल है जो हमारे लिए यह करता है। itertools.combinations (श्रेणी (एन), कश्मीर) [0, 1, 2 … n-1] से कश्मीर बिट्स का चयन करेंगे और फिर यह उन बिट अनुक्रमित दिए गए स्ट्रिंग को बनाने का एक मामला है

चूंकि आप पायथन का उपयोग नहीं कर रहे हैं, यहां पर itertools.com के लिए छद्म कोड देखें:

http://docs.python.org/library/itertools.html#itertools.combinations

किसी भी भाषा में लागू करना आसान होना चाहिए।

यहां एक जावा संयोजन जनरेटर है:

http://www.merriampark.com/comb.htm

कार्यान्वयन के बारे में भूल जाओ ("यह तार के साथ किया जाता है" जाहिर है एक क्रियान्वयन का मुद्दा!) – पीट के लिए एल्गोरिथ्म के बारे में सोचें … जैसे ही आपका पहला टैग, आदमी!

आप जो देख रहे हैं वह कश्मीर के सभी संयोजनों को एन के एक सेट (सूचकांक, 0 से N-1, सेट बिट्स के) से बाहर कर रहे हैं। यह पुनरावर्ती रूप से व्यक्त करने के लिए स्पष्ट रूप से सरल है, जैसे, स्यूडोकोड:

 combinations(K, setN): if k > length(setN): return "no combinations possible" if k == 0: return "empty combination" # combinations INcluding the first item: return (first-item-of setN) combined combinations(K-1, all-but-first-of setN) union combinations(K-1, all-but-first-of setN) 

यानी, पहला आइटम या तो मौजूद है या अनुपस्थित है: यदि मौजूद है, तो आपके पास K-1 छोड़ दिया गया है (पूंछ उर्फ ​​सभी-पर-एफआईआर), यदि अनुपस्थित है, अभी भी कश्मीर छोड़ दिया जाता है।

पैटर्न-मिलान करने वाली कार्यात्मक भाषाओं जैसे एसएमएल या हास्केल, इस छद्मकोण को व्यक्त करने के लिए सबसे अच्छा हो सकता है (प्रक्रियात्मक लोग, जैसे मेरी बड़ी प्रेम पायथन, वास्तव में बहुत अधिक समृद्ध कार्यक्षमता, जैसे itertools.combinations भी शामिल करके वास्तव में समस्या को गहरा कर itertools.combinations , जो सभी आपके लिए कड़ी मेहनत है और इसलिए आप इसे छिपाते हैं!)।

इस उद्देश्य के लिए आप सबसे अधिक परिचित हैं – योजना, एसएमएल, हास्केल, …? मुझे आपके लिए उपर्युक्त स्यूडोकोड का अनुवाद करने में खुशी होगी। मैं इसे पाइथन जैसे भाषाओं में भी कर सकता हूं – लेकिन जब से आपको इस होमवर्क के काम के लिए यांत्रिकी को समझने के लिए मिल रहा है, तो मैं बहुत अधिक समृद्ध कार्यक्षमता का उपयोग नहीं करूँगा जैसे कि itertools.combinations , बल्कि recursion ( और अधिक स्पष्ट primitives (जैसे सिर, पूंछ, और concatenation) पर पुनरोद्धन उन्मूलन, यदि आवश्यक हो)। लेकिन कृपया हमें बताएं कि स्यूडोकोड जैसी भाषा आप सबसे परिचित हैं! (आप समझते हैं कि आपके द्वारा बताई गई समस्या "समानता के सभी संयोजनों या सीमा (एन)" के बराबर है, ठीक है?)।

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

यह पहला संस्करण है जिसके साथ मैं आया था। यह स्टैक स्पेस द्वारा लगभग 2700 की लंबाई तक सीमित है:

 static IEnumerable<string> BinStrings(int length, int bits) { if (length == 1) { yield return bits.ToString(); } else { if (length > bits) { foreach (string s in BinStrings(length - 1, bits)) { yield return "0" + s; } } if (bits > 0) { foreach (string s in BinStrings(length - 1, bits - 1)) { yield return "1" + s; } } } } 

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

 static IEnumerable<string> BinStrings(int length, int bits) { if (length == 1) { yield return bits.ToString(); } else { int first = length / 2; int last = length - first; int low = Math.Max(0, bits - last); int high = Math.Min(bits, first); for (int i = low; i <= high; i++) { foreach (string f in BinStrings(first, i)) { foreach (string l in BinStrings(last, bits - i)) { yield return f + l; } } } } } 

इस समस्या के कई मानक समाधानों के साथ एक समस्या ये है कि स्ट्रिंग का पूरा सेट उत्पन्न होता है और फिर उन के माध्यम से चलने लगता है, जो स्टैक को निकाला जा सकता है। यह किसी भी छोटे से छोटे सेटों के लिए जल्द ही बोझिल हो जाता है। इसके अलावा, कई उदाहरणों में, केवल एक आंशिक नमूनाकरण की आवश्यकता होती है, लेकिन मानक (पुनरावर्ती) समाधान आम तौर पर समस्याओं को ऐसे टुकड़ों में तोड़ते हैं जो एक दिशा में भारी पक्षपातपूर्ण होते हैं (उदा। शून्य के प्रारंभ होने वाले सभी समाधानों पर विचार करें, और फिर एक शुरुआत बिट के साथ समाधान)

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

डोनाल्ड नुथ अपने फस्किकल 3 ए में, खंड 7.2.1.3 में सभी के लिए एल्गोरिदम की मेजबानी कर रहे हैं।

टिप्पणी में सूचीबद्ध अंतिम PHP कोड के लिंक के साथ http://answers.yahoo.com/question/index?qid=20081208224633AA0gdMl पर k तत्वों को चुनने के सभी तरीकों के लिए पुनरावृत्त ग्रे कोड एल्गोरिथ्म से निपटने के लिए एक दृष्टिकोण है ( इसे विस्तृत करने के लिए क्लिक करें) पृष्ठ के नीचे।

एक एल्गोरिथम जो काम करना चाहिए:

 generate-strings(prefix, len, numBits) -> String: if (len == 0): print prefix return if (len == numBits): print prefix + (len x "1") generate-strings(prefix + "0", len-1, numBits) generate-strings(prefix + "1", len-1, numBits) 

सौभाग्य!

अधिक सामान्य तरीके से, नीचे फ़ंक्शन आपको सभी संभावित सूचकांक संयोजनों को एन के लिए चुन लेगा जो कि कश्मीर समस्या का चयन करती है, जिसे आप स्ट्रिंग या अन्य किसी भी चीज़ पर लागू कर सकते हैं:

 def generate_index_combinations(n, k): possible_combinations = [] def walk(current_index, indexes_so_far=None): indexes_so_far = indexes_so_far or [] if len(indexes_so_far) == k: indexes_so_far = tuple(indexes_so_far) possible_combinations.append(indexes_so_far) return if current_index == n: return walk(current_index + 1, indexes_so_far + [current_index]) walk(current_index + 1, indexes_so_far) if k == 0: return [] walk(0) return possible_combinations 

एक संभव 1.5-लाइनर:

 $ python -c 'import itertools; \ print set([ n for n in itertools.permutations("0111", 4)])' set([('1', '1', '1', '0'), ('0', '1', '1', '1'), ..., ('1', '0', '1', '1')]) 

.. जहां k 1 की संख्या "0111"

आईटेरटोल्स मॉड्यूल इसके तरीकों के लिए समतुल्य बताते हैं; क्रमचय विधि के बराबर देखें

मैं पुनरावर्तन की कोशिश करूँगा

उनमें से क 1 के साथ n अंक हैं इसे देखने का एक अन्य तरीका उनके बीच वितरित nk 0s के साथ कश्मीर + 1 स्लॉट का क्रम है। यही है, (0 के बाद एक रन 1 के बाद एक) कश्मीर समय, फिर 0s के एक और रन के बाद इनमें से कोई भी रन लंबाई शून्य हो सकता है, लेकिन कुल लंबाई nk होना चाहिए।

इसे कश्मीर + 1 के पूर्णांक के रूप में दर्शाएं रिकर्सन के तल पर एक स्ट्रिंग में कनवर्ट करें।

फिर से गहराई एनके पर कॉल करें, एक विधि जो पुनरावर्ती कॉल से पहले सरणी के एक तत्व को बढ़ाता है और फिर इसे घटाता है, कश्मीर + 1 बार।

एनके की गहराई पर, स्ट्रिंग आउटपुट।

 int[] run = new int[k+1]; void recur(int depth) { if(depth == 0){ output(); return; } for(int i = 0; i < k + 1; ++i){ ++run[i]; recur(depth - 1); --run[i]; } public static void main(string[] arrrgghhs) { recur(n - k); } 

जब से मैंने जावा किया है तब से कुछ समय हो गया है, इसलिए शायद इस कोड में कुछ त्रुटियां हैं, लेकिन विचार को काम करना चाहिए।

तारों की एक सरणी से तेज तार हैं? स्ट्रिंग के लिए तैयार होने वाले सभी समाधानों के परिणामस्वरूप प्रत्येक पुनरावर्ती पर स्ट्रिंग की प्रतिलिपि होती है।

तो शायद सबसे प्रभावी तरीके से आप के लिए संलग्न एआर या एआर होगा। जावा कुशल growable कंटेनर, सही है? इसका प्रयोग करें, अगर यह स्ट्रिंग से तेज़ है या अगर बिगइंटेगर कुशल है, तो यह निश्चित रूप से कॉम्पैक्ट है, क्योंकि प्रत्येक बिट में थोड़ा सा लगता है, पूरे बाइट या इंट नहीं। लेकिन फिर बिट्स को फिर से दोहराने के लिए जिसे आपको थोड़ा और मुखौटा करना चाहिए, और अगले बिट स्थिति में मुखौटा बिछाएं। तो शायद धीमी, जब तक कि जेआईटी कम्पाइलर इन दिनों अच्छे न हों।

मैं मूल प्रश्न पर यह ए टिप्पणी पोस्ट करूँगा, लेकिन मेरा कर्म पर्याप्त नहीं है। माफ़ कीजिये।

पायथन (कार्यात्मक शैली)

python के itertools.combinations का उपयोग करके आप सभी के सभी विकल्पों को itertools.combinations कर सकते हैं और इन विकल्पों को एक द्विआधारी सरणी में reduce साथ मैप कर सकते हैं।

 from itertools import combinations from functools import reduce # not necessary in python 2.x def k_bits_on(k,n): one_at = lambda v,i:v[:i]+[1]+v[i+1:] return [tuple(reduce(one_at,c,[0]*n)) for c in combinations(range(n),k)] 

उदाहरण उपयोग:

 In [4]: k_bits_on(2,5) Out[4]: [(0, 0, 0, 1, 1), (0, 0, 1, 0, 1), (0, 0, 1, 1, 0), (0, 1, 0, 0, 1), (0, 1, 0, 1, 0), (0, 1, 1, 0, 0), (1, 0, 0, 0, 1), (1, 0, 0, 1, 0), (1, 0, 1, 0, 0), (1, 1, 0, 0, 0)]