दूसरों ने सही विचार दिया है। यहां bitsarr, या बिट्स की 'सरणी' का अपना कार्यान्वयन है। एक हस्ताक्षरित चार एक बाइट है, इसलिए यह अनिवार्य रूप से हस्ताक्षरित वर्णों की एक सरणी है जो व्यक्तिगत बिट्स में जानकारी संग्रहीत करता है। मैंने एक बिट मान के अलावा दो या चार बिट मानों को संग्रहीत करने का विकल्प जोड़ा, क्योंकि वे दोनों 8 (बाइट का आकार) विभाजित करते हैं, और उपयोगी होंगे यदि आप बड़ी संख्या में पूर्णांक स्टोर करना चाहते हैं जो 0 से लेकर होंगे -3 या 0-15।
सेटिंग और प्राप्त करते समय, गणित कार्यों में किया जाता है, इसलिए आप इसे एक इंडेक्स दे सकते हैं जैसे कि यह एक सामान्य सरणी था - यह जानता है कि कहां देखना है।
इसके अलावा, यह उपयोगकर्ता की ज़िम्मेदारी है कि यह निर्धारित करने के लिए मूल्य पास न करें, या यह अन्य मूल्यों को खराब कर देगा। इसे संशोधित किया जा सकता है ताकि ओवरफ्लो 0 पर वापस आ जाए, लेकिन इससे इसे और अधिक गड़बड़ कर दिया जाएगा, इसलिए मैंने खुद पर भरोसा करने का फैसला किया।
#include<stdio.h>
#include <stdlib.h>
#define BYTE 8
typedef enum {ONE=1, TWO=2, FOUR=4} numbits;
typedef struct bitsarr{
unsigned char* buckets;
numbits n;
} bitsarr;
bitsarr new_bitsarr(int size, numbits n)
{
int b = sizeof(unsigned char)*BYTE;
int numbuckets = (size*n + b - 1)/b;
bitsarr ret;
ret.buckets = malloc(sizeof(ret.buckets)*numbuckets);
ret.n = n;
return ret;
}
void bitsarr_delete(bitsarr xp)
{
free(xp.buckets);
}
void bitsarr_set(bitsarr *xp, int index, int value)
{
int buckdex, innerdex;
buckdex = index/(BYTE/xp->n);
innerdex = index%(BYTE/xp->n);
xp->buckets[buckdex] = (value << innerdex*xp->n) | ((~(((1 << xp->n) - 1) << innerdex*xp->n)) & xp->buckets[buckdex]);
//longer version
/*unsigned int width, width_in_place, zeros, old, newbits, new;
width = (1 << xp->n) - 1;
width_in_place = width << innerdex*xp->n;
zeros = ~width_in_place;
old = xp->buckets[buckdex];
old = old & zeros;
newbits = value << innerdex*xp->n;
new = newbits | old;
xp->buckets[buckdex] = new; */
}
int bitsarr_get(bitsarr *xp, int index)
{
int buckdex, innerdex;
buckdex = index/(BYTE/xp->n);
innerdex = index%(BYTE/xp->n);
return ((((1 << xp->n) - 1) << innerdex*xp->n) & (xp->buckets[buckdex])) >> innerdex*xp->n;
//longer version
/*unsigned int width = (1 << xp->n) - 1;
unsigned int width_in_place = width << innerdex*xp->n;
unsigned int val = xp->buckets[buckdex];
unsigned int retshifted = width_in_place & val;
unsigned int ret = retshifted >> innerdex*xp->n;
return ret; */
}
int main()
{
bitsarr x = new_bitsarr(100, FOUR);
for(int i = 0; i<16; i++)
bitsarr_set(&x, i, i);
for(int i = 0; i<16; i++)
printf("%d\n", bitsarr_get(&x, i));
for(int i = 0; i<16; i++)
bitsarr_set(&x, i, 15-i);
for(int i = 0; i<16; i++)
printf("%d\n", bitsarr_get(&x, i));
bitsarr_delete(x);
}
यदि आपको केवल '67600' तत्वों की आवश्यकता है तो आपको किसी भी चाल का उपयोग नहीं करना चाहिए। यह इतना याद नहीं है। – cnicutar
मुझे न्यूनतम संभव स्मृति उपयोग चाहिए। –
'std :: वेक्टर' या 'std :: बिटसेट 'का उपयोग करें। मैं उन्हें "हैक्स" नहीं कहूंगा, हालांकि –