आइए पहले बिट्स और बिटवाइज ऑपरेटर के बारे में संक्षेप में याद करें।
बिट एक बाइनरी अंक है। यह डेटा की सबसे छोटी इकाई है जो कंप्यूटर द्वारा समझी जा सकती है। इसके केवल दो मान हो सकते हैं 0 (OFF दर्शाता है) और 1 (ON दर्शाता है)।
बिटवाइज ऑपरेटर वे ऑपरेटर हैं जो प्रोग्राम में बिट स्तर पर काम करते हैं। इन ऑपरेटर्स का उपयोग प्रोग्राम में बिट्स को मैनिपुलेट करने के लिए किया जाता है।
C में, हमारे पास 6 बिटवाइज ऑपरेटर हैं -
- बिटवाइज AND (&)
- बिटवाइज OR (|)
- बिटवाइज XOR (^)
- बिटवाइज लेफ्ट शिफ्ट (<<)
- बिटवाइज राइट शिफ्ट (>>)
- बिटवाइज NOT (~)
https://www.tutorialspoint.com/cprogramming/c_bitwise_operators.htm
अब, आइए कुछ महत्वपूर्ण रणनीतियाँ सीखें यानी वे चीजें जो मददगार हो सकती हैं यदि आप बिट्स के साथ काम करते हैं।
दो संख्याओं को स्वैप करना (बिटवाइज XOR का उपयोग करके)
हम बिटवाइज XOR ऑपरेटर का उपयोग करके दो मानों को स्वैप कर सकते हैं। कार्यान्वयन है -
कार्यक्रम उदाहरण
#include <stdio.h>
int main(){
int x = 41;
int y = 90;
printf("स्वैपिंग से पहले मान! \n");
printf("x = %d \t", x);
printf("y = %d \n", y);
x = x ^ y;
y = y ^ x;
x = x ^ y;
printf("स्वैपिंग के बाद मान! \n");
printf("x = %d \t", x);
printf("y = %d \n", y);
return 0;
}
आउटपुट
स्वैपिंग से पहले मान! x = 41 y = 90 स्वैपिंग के बाद मान! x = 90 y = 41
MSB (मोस्ट सिग्निफिकेंट बिट) खोजने का कुशल तरीका
किसी भी पूर्णांक मान के लिए, हम मोस्ट सिग्निफिकेंट बिट को कुशल तरीके से ढूंढ सकते हैं। यह OR ऑपरेटर के साथ बिटवाइज शिफ्ट ऑपरेटर का उपयोग करके किया जाता है। यह विधि MSB को O(1) समय जटिलता में ढूंढ सकती है।
प्रोग्राम बनाने के लिए पूर्णांक का आकार पूर्वनिर्धारित होना चाहिए।
कार्यक्रम उदाहरण
32-बिट पूर्णांक का MSB खोजने के लिए प्रोग्राम -
#include <stdio.h>
int findMSB(int x){
x |= x>>1;
x |= x>>2;
x |= x>>4;
x |= x>>8;
x |= x>>16;
x = x+1;
return(x >> 1);
}
int main(){
int x = 49;
printf("संख्या %d है\n", x);
int msb = findMSB(x);
printf("संख्या का MSB %d है\n", msb);
}
आउटपुट
संख्या 49 है संख्या का MSB 32 है
1 से n तक सभी संख्याओं का XOR सीधे गणना करना
यदि हम 0 से n तक के XOR को ध्यान से देखें तो हम एक सामान्य पैटर्न प्राप्त कर सकते हैं। जिसे यहां दर्शाया गया है -
कार्यक्रम उदाहरण
#include <stdio.h>
// 1 से n तक सभी संख्याओं का सीधा XOR
int findXORuptoN(int n){
switch( n%4){
case 0: return n;
case 1: return 1;
break;
case 2: return n+1;
break;
case 3: return 0;
break;
default: break;
}
}
int main(){
int n = 9870;
int xorupton = findXORuptoN(n);
printf("%d तक सभी संख्याओं का XOR %d है\n", n, xorupton);
}
आउटपुट
9870 तक सभी संख्याओं का XOR 9871 है
एक संख्या के साथ जिनका योग और XOR बराबर हैं, उन संख्याओं के संयोजनों की कुल संख्या सीधे गणना करना
बिटवाइज शिफ्ट ऑपरेटर्स का उपयोग करके, हम आसानी से काम कर सकते हैं और इसमें कम समय लगेगा।
कार्यक्रम उदाहरण
#include <stdio.h>
int countValues(int n){
int unset=0;
while (n){
if ((n & 1) == 0)
unset++;
n=n>>1;
}
return (1<<unset);
}
int main(){
int n = 32;
printf("%d", countValues(n));
}
आउटपुट
32
पूर्णांक में अग्रणी और अनुगामी 0 की संख्या ढूंढना
बिट मैनिपुलेशन की बदौलत एक पूर्णांक के अग्रणी और अनुगामी शून्य की संख्या ढूंढने के लिए अंतर्निहित विधियाँ हैं।
* यह एक GCC अंतर्निहित फ़ंक्शन है
कार्यक्रम उदाहरण
#include <stdio.h>
int main(){
int n = 32;
printf("पूर्णांक मान %d है\n", n);
printf("अग्रणी शून्य की संख्या %d है\n", __builtin_clz(n));
printf("अनुगामी शून्य की संख्या %d है\n", __builtin_ctz(n));
}
आउटपुट
पूर्णांक मान 32 है अग्रणी शून्य की संख्या 26 है अनुगामी शून्य की संख्या 5 है
जांचें कि क्या संख्या 2 की घात है?
जांचने के लिए, यदि कोई संख्या 2 की घात है, तो बिटवाइज ऑपरेटर का उपयोग करके इसे आसान बनाया जाता है।
कार्यक्रम उदाहरण
#include <stdio.h>
int isPowerof2(int n){
return n && (!(n&(n-1)));
}
int main(){
int n = 22;
if(isPowerof2(n))
printf("%d 2 की घात है", n);
else
printf("%d 2 की घात नहीं है", n);
}
आउटपुट
22 2 की घात नहीं है
एक समुच्चय के सभी उपसमुच्चयों का XOR ढूंढना
यह इस तथ्य का उपयोग करके किया जा सकता है कि यदि 1 से अधिक तत्व हैं तो सभी उपसमुच्चयों का XOR हमेशा 0 होता है और अन्यथा संख्या होती है।
कार्यक्रम उदाहरण
#include <stdio.h>
int findsubsetXOR (int set[], int size){
if (size == 1){
return set[size - 1];
}
else
return 0;
}
int main (){
int set[] = { 45, 12 };
int size = sizeof (set) / sizeof (set[0]);
printf ("आकार %d के समुच्चय के सभी उपसमुच्चयों का XOR %d है\n", size, findsubsetXOR (set, size));
int set2[] = { 65 };
size = sizeof (set2) / sizeof (set2[0]);
printf ("आकार %d के समुच्चय के सभी उपसमुच्चयों का XOR %d है\n", size, findsubsetXOR (set2, size));
}
आउटपुट
आकार 2 के समुच्चय के सभी उपसमुच्चयों का XOR 0 है आकार 1 के समुच्चय के सभी उपसमुच्चयों का XOR 65 है
दिए गए बाइनरी नंबर को पूर्णांक में बदलना
C में auto कीवर्ड का उपयोग कार्य करने के लिए किया जाता है।
कार्यक्रम उदाहरण
#include <stdio.h>
int main (){
auto integer = 0b0110110;
printf("बाइनरी नंबर '0110110' का पूर्णांक रूपांतरण %d है", integer);
}
आउटपुट
बाइनरी नंबर '0110110' का पूर्णांक रूपांतरण 54 है
एक संख्या के सभी बिट्स को फ्लिप करना
हम एक संख्या के सभी बिट्स को उस संख्या से घटाकर फ्लिप कर सकते हैं जिसके सभी बिट्स सेट हैं।
संख्या = 0110100 सभी बिट्स सेट वाली संख्या = 1111111 घटाव -> 1111111 - 0110100 = 1001011 (फ्लिप बिट्स वाली संख्या)
कार्यक्रम उदाहरण
#include <stdio.h>
int main (){
int number = 23;
int n = number;
n |= n>>1;
n |= n>>2;
n |= n>>4;
n |= n>>8;
n |= n>>16;
printf("संख्या %d है\n", number);
printf("उल्टे बिट्स वाली संख्या %d\n", n-number);
}
आउटपुट
संख्या 23 है उल्टे बिट्स वाली संख्या 8 है
जांचें कि क्या बिट्स में वैकल्पिक पैटर्न है
बिटवाइज XOR ऑपरेशन का उपयोग करके, हम पता लगा सकते हैं कि किसी संख्या के बिट्स वैकल्पिक पैटर्न में हैं या नहीं। नीचे दिया गया कोड दिखाता है कि कैसे -
कार्यक्रम उदाहरण
#include <stdio.h>
int checkbitpattern(int n){
int result = n^(n>>1);
if(((n+1)&n) == 0)
return 1;
else
return 0;
}
int main (){
int number = 4;
if(checkbitpattern == 1){
printf("%d के बिट्स वैकल्पिक पैटर्न में हैं", number);
}
else
printf("%d के बिट्स वैकल्पिक पैटर्न में नहीं हैं", number);
}
आउटपुट
4 के बिट्स वैकल्पिक पैटर्न में नहीं हैं
