1 बिट पर सेट बिट्स की जोड़ी के लिए सभी संयोजन उत्पन्न करें?

Question

मैं दी गई चौड़ाई के भीतर 1 की जोड़ी के लिए सभी संभावित संयोजन उत्पन्न करने की कोशिश कर रहा हूं।

000000 
000011 
000110 
001100 
001111 
011000 
011011 
011110 
110000 
110011 
110110 
111100 
111111 

अगर मैं चर है:

मान लीजिए कि बिट चौड़ाई 6 दो, यानी संख्या 32. यह मैं उत्पन्न करने के लिए चाहते हैं क्या है

var a = 1, 
    b = 2; 
    num = a | b; 

और एक पाश बनाने कि मैं width - 1 बार लूप होगा, और जहां मैं a << 1 और b << 1 दोनों को स्थानांतरित करता हूं, मुझे एक जोड़ी के लिए सभी संयोजन मिलेंगे। उसके बाद, मैं बहुत ज्यादा अटक गया हूँ।

कोई, कृपया कुछ मदद प्रदान कर सकता है।

अद्यतन: काम कर रहे उदाहरण
Barmar के गणितीय दृष्टिकोण के आधार पर, यह है कि क्या मैं JSFiddle पर

var arr = [], 
    arrBits = []; 

function getCombs(pairs, startIdx) { 
    var i, j, val = 0, tmpVal, idx; 

    if (startIdx + 2 < pairs) { 
     startIdx = arr.length - 1; 
     pairs -= 1; 
    } 

    if (pairs < 2) { 
     return; 
    } 

    for (i = 0; i < pairs-1; i++) { 
     idx = startIdx - (i * 2); 
     val += arr[idx]; 

    } 

    for (j = 0; j < idx - 1; j++) { 
     arrBits.push((val + arr[j]).toString(2)); 
    } 

    getCombs(pairs, startIdx-1); 
} 

(function initArr(bits) { 
    var i, val, pairs, startIdx; 

    for (i = 1; i < bits; i++) { 
     val = i == 1 ? 3 : val * 2; 
     arr.push(val); 
     arrBits.push(val.toString(2)); 
    } 

    pairs = Math.floor(bits/2); 
    startIdx = arr.length - 1; 

    getCombs(pairs, startIdx); 
    console.log(arrBits); 

}(9)); 

कार्य उदाहरण लागू करने के लिए
http://jsfiddle.net/zywc5/

Answer 1

1 की एक जोड़ी वाली संख्या अनुक्रम 3, 6, 12, 24, 48, ... है; वे 3 से शुरू होते हैं और हर बार बस डबल करते हैं।

1 के दो जोड़े वाले नंबर 12 + 3, 24 + 3, 24 + 6, 48 + 3, 48 + 6, 48 + 12, ... हैं; ये उपर्युक्त अनुक्रम 12 + मूल अनुक्रम एन/4 तक शुरू हो रहे हैं। 48

1 के के तीन जोड़े के साथ नंबर दिए गए हैं + 12 + 3, 96 + 12 + 3, 96 + 24 + 3, 96 + 24 + 6, ...

इन पता चलता है में से प्रत्येक के बीच के रिश्ते एक रिकर्सिव एल्गोरिदम मूल दोगुनी अनुक्रम का उपयोग कर रहा है। मेरे पास अभी लिखने के लिए समय नहीं है, लेकिन मुझे लगता है कि यह आपको जा रहा है।

Answer 2

अगर बिट चौड़ाई isn में कामयाब रहे है यह बड़ा नहीं है तो आप एक लूप में 0 से 31 तक सभी संख्याओं के लिए थोड़ा प्रतिनिधित्व बनाने से बेहतर तरीके से बेहतर होंगे और केवल वें अनदेखा करेंगे ई जिनके पास थोड़ा प्रतिनिधित्व में "एक" की विषम संख्या है।

Answer 3

शायद बाइनरी में सामान्य रूप से गिनती शुरू करने और 11 इस तरह के साथ सभी 1 के बदल देते हैं:

n = 5 
n = n.toString(2)   //= "101" 
n = n.replace(/1/g, "11") //= "11011" 
n = parseInt(n, 2)   //= 27 

तो आप प्राप्त करेंगे:

0 -> 0 
1 -> 11 
10 -> 110 
11 -> 1111 
100 -> 1100 
101 -> 11011 
110 -> 11110 
111 -> 111111 

और इतने पर। आपको बाएं तरफ 31 या उससे अधिक तक गिनना होगा, और दाईं ओर 6 बिट्स से अधिक लोगों को अस्वीकार कर देना होगा।

Answer 4

http://jsfiddle.net/SBH6R/

var len=6, 
    arr=['']; 
for(var i=0;i<len;i++){ 
    for(var j=0;j<arr.length;j++){ 
     var k=j; 
     if(getNum1(arr[j])%2===1){ 
      arr[j]+=1; 
     }else{ 
      if(i<len-1){ 
       arr.splice(j+1,0,arr[j]+1); 
       j++; 
      } 
      arr[k]+=0; 
     }  
    } 
} 
function getNum1(str){ 
    var n=0; 
    for(var i=str.length-1;i>=0;i--){ 
     if(str.substr(i,1)==='1'){n++;} 
     else{break;} 
    } 
    return n; 
} 
document.write(arr.join('<br />')); 

देखें या शायद आप http://jsfiddle.net/SBH6R/1/ का चुनाव करेगा। यह आसान है, लेकिन फिर आप sort() को सरणी होगा:

var len=6, 
    arr=['']; 
for(var i=0;i<len;i++){ 
    for(var k=0,l=arr.length;k<l;k++){ 
     if(getNum1(arr[k])%2===1){ 
      arr[k]+=1; 
     }else{ 
      if(i<len-1){ 
       arr.push(arr[k]+1); 
      } 
      arr[k]+=0; 
     }  
    } 
} 
function getNum1(str){ 
    var n=0; 
    for(var i=str.length-1;i>=0;i--){ 
     if(str.substr(i,1)==='1'){n++;} 
     else{break;} 
    } 
    return n; 
} 
document.write(arr.sort().join('<br />')); 

देखें http://jsperf.com/generate-all-combinations-for-pair-of-bits-set-to-1 यदि आप प्रदर्शन की तुलना करना चाहते हैं।ऐसा लगता है कि सबसे तेज़ कोड क्रोम पर पहला है लेकिन दूसरा फ़ायरफ़ॉक्स पर है।

Answer 5

आप इसे थोड़ा सा झुकाव के साथ भी कर सकते हैं। यदि निम्नतम दो बिट शून्य हैं, तो हमें उन्हें सेट करने की आवश्यकता है, जो कि 3 जोड़ने के बराबर है। अन्यथा, हमें सबसे कम ब्लॉक को अपने शीर्ष बिट और 1-बिट के बाईं ओर प्रतिस्थापित करने की आवश्यकता है। यह निम्नानुसार किया जा सकता है, जहां x वर्तमान संयोजन है:

x3 = x + 3; 
return (((x^x3) - 2) >> 2) + x3;