हमें एक JavaScript फ़ंक्शन लिखना है जो एक संख्या लेता है। फ़ंक्शन को निम्नलिखित नियमों के अनुसार संख्या को खंडों में विभाजित करना चाहिए -
खंडों की संख्या 2 की घात होनी चाहिए,
प्रत्येक खंड में भी 2 की घात की संख्या में आइटम होने चाहिए (जहां आकार अधिकतम 2 की घात तक जाता है, इसलिए 1, 2, 4, 8, 16, 32, 32 अधिकतम है)
इसलिए, उदाहरण के लिए, 8 को 1 बकेट में विभाजित किया जा सकता है -
[8]
9 हो सकता है -
[8, 1]
यह काम करता है क्योंकि दोनों संख्याएं 2 की घात हैं, और सरणी का आकार 2 है (भी 2 की घात)।
आइए 11 आज़माएं -
[8, 2, 1]
नहीं, यह काम नहीं करता।
क्योंकि सरणी का आकार 3 है जो 2 की घात नहीं है, भले ही यह 11 तक जुड़ता है।
[4, 4, 2, 1]
यह काम करता है! यह 4 तत्व हैं जो 2 की घात है।
उदाहरण
इसके लिए कोड होगा -
function permuteCombinations(n, maximum){
const maxPowerOf2 = 1 << maximum;
const m = ~~(n / maxPowerOf2);
const A = new Array(maximum + 1).fill(0);
A[maximum] = m;
let num = n - m * maxPowerOf2;
let p = 0;
let bitCount = 0;
while (num){
if (num & 1){
bitCount += 1;
A[p] = 1;
}
num >>= 1;
p += 1;
}
const min = m + bitCount;
let target = 1;
while (target < min)
target *= 2;
if (target > n)
return -1;
if (target == min)
return A.map((c, p) => [1 << Number(p), c]);
if (target == n)
return [n];
target = target - min;
let i = m ? maximum : p;
while (target && i > 0){
if (!A[i]){
i -= 1;
continue;
}
const max = Math.min(target, A[i]);
A[i] -= max;
A[i-1] += 2*max;
target -= max;
i -= 1;
}
return target ? -1 : A.map((c, p) => [1 << Number(p), c]);
};
console.log(permuteCombinations(11, 5));
आउटपुट
कंसोल में आउटपुट होगा -
[ [ 1, 1 ], [ 2, 1 ], [ 4, 2 ], [ 8, 0 ], [ 16, 0 ], [ 32, 0 ] ]
