दिलचस्प पोस्ट
क्या मुझे डेटाबेस या फ़ोल्डर में मेरी छवियों को संग्रहित करना चाहिए? त्रिज्या और किनारों के आसपास के बिंदु के साथ एक चक्र बनाएं जावास्क्रिप्ट में पाठ फ़ाइल कैसे पढ़ा जाए ASP.NET में HTTP रेफरर प्राप्त करना जावास्क्रिप्ट में सरणी तत्वों को हटाया जा रहा है – विचलित करें विष्ठापन कैसे यूआईएलबल में छोटा आइकन एम्बेड करें मैं कैसे PHP सूची में पाश के साथ एक ही आईडी डेटा की सूची कर सकते हैं? पायथन में AJAX के लिए न्यूनतम सर्वर कैसे कार्यान्वित करें? क्या इंटरफेस बिल्डर से UIView सीमा गुण सेट करना संभव है? H.264 स्ट्रीम के लिए अनुक्रम / चित्र पैरामीटर सेट (एस) के लिए संभावित स्थान मेरे टंकिनर विगेट्स को कोई भी क्यों नहीं मिला? Numpy.array आकार (R, 1) और (आर,) में अंतर क्या है ((संरचना का नाम *) शून्य -> ​​ख) सी 11 में अपरिभाषित व्यवहार का कारण बनता है? कुछ फ़ंक्शंस को फ़ंक्शन नाम से पहले और बाद में "__" को क्यों रेखांकित किया जाता है? कैमरा रोल तक पहुंचने की अनुमति से पूछें

बीटवाइसेवा ऑपरेटर के वास्तविक दुनिया का उपयोग करें

निम्नलिखित बिटवाइ ऑपरेटरों के वास्तविक दुनिया उपयोग के कुछ मामले क्या हैं?

  • तथा
  • XOR
  • नहीं
  • या

वेब के समाधान से एकत्रित समाधान "बीटवाइसेवा ऑपरेटर के वास्तविक दुनिया का उपयोग करें"

  • बिट फ़ील्ड (झंडे)
    वे कुछ का प्रतिनिधित्व करने का सबसे कारगर तरीका है जिनके राज्य को कई "हां या नहीं" गुणों द्वारा परिभाषित किया गया है एसीएल एक अच्छा उदाहरण है; अगर आपने कहा है कि 4 असतत अनुमतियां (पढ़ें, लिखना, निष्पादित करना, परिवर्तन नीति) है, तो इसे कचरे के बजाए 1 बाइट में संग्रहीत करना बेहतर है। अतिरिक्त सुविधा के लिए ये कई भाषाओं में गणण प्रकारों के साथ मैप किए जा सकते हैं।

  • बंदरगाहों / कुर्सियां ​​पर संचार
    हमेशा चेकसम, समता, स्टॉप बिट, फ्लो कंट्रोल एल्गोरिदम, और इसी तरह शामिल होता है, जो आम तौर पर संख्यात्मक मानों के विरोध में व्यक्तिगत बाइट्स के लॉजिक वैल्यू पर निर्भर करता है, क्योंकि माध्यम केवल एक समय में एक बिट प्रेषण करने में सक्षम हो सकता है।

  • संपीड़न, एन्क्रिप्शन
    इनमें से दोनों बिटवर्ड एल्गोरिदम पर भारी निर्भर हैं। एक उदाहरण के लिए deflate एल्गोरिथ्म को देखो- सब कुछ बिट्स में है, बाइट्स नहीं।

  • परिमित राज्य मशीनें
    मैं मुख्य रूप से हार्डवेयर के कुछ हिस्सों में एम्बेडेड प्रकार की बात करता हूं, हालांकि उन्हें सॉफ्टवेयर में भी पाया जा सकता है यह संयोगिक प्रकृति में हैं – वे सचमुच तर्कसंगत फाटकों के एक समूह में "संकलित" हो सकते हैं, इसलिए उन्हें AND , OR , NOT , आदि के रूप में व्यक्त किया जाना चाहिए।

  • ग्राफिक्स हर क्षेत्र में प्रवेश करने के लिए यहां पर्याप्त जगह नहीं है, जहां ये ऑपरेटर्स ग्राफिक्स प्रोग्रामिंग में उपयोग किए जाते हैं। XOR (या ^ ) विशेष रूप से दिलचस्प है क्योंकि एक ही इनपुट को दूसरे बार लागू करने से पहले को दोबारा हटा दिया जाएगा। पुरानी जीयूआई इस पर चयन हाइलाइटिंग और अन्य ओवरले के लिए भरोसा करती थी, ताकि लागत में कमी लाने की आवश्यकता को खत्म कर सके। वे अभी भी धीमा ग्राफिक्स प्रोटोकॉल (यानी दूरस्थ डेस्कटॉप) में उपयोगी हैं।

ये सिर्फ कुछ पहले उदाहरण हैं जिनके साथ मैं आया था – यह शायद एक संपूर्ण सूची है

क्या यह अजीब है?

 (value & 0x1) > 0 

क्या यह दो (भी) से विभाज्य है?

 (value & 0x1) == 0 

निम्न-स्तरीय प्रोग्रामिंग एक अच्छा उदाहरण है। उदाहरण के लिए, आप कुछ मेमोरी-मैप किए गए रजिस्टर में विशिष्ट बिट को लिख सकते हैं ताकि आप कुछ हार्डवेयर बना सकें जो आप चाहते हैं:

 volatile uint32_t *register = (volatile uint32_t *)0x87000000; uint32_t value; uint32_t set_bit = 0x00010000; uint32_t clear_bit = 0x00001000; value = *register; // get current value from the register value = value & ~clear_bit; // clear a bit value = value | set_bit; // set a bit *register = value; // write it back to the register 

साथ ही, htonl() और htons() को & | ऑपरेटर्स (जिन मशीनों के अंत्यवाद (बाइट ऑर्डर) नेटवर्क ऑर्डर से मेल नहीं खातीं):

 #define htons(a) ((((a) & 0xff00) >> 8) | \ (((a) & 0x00ff) << 8)) #define htonl(a) ((((a) & 0xff000000) >> 24) | \ (((a) & 0x00ff0000) >> 8) | \ (((a) & 0x0000ff00) << 8) | \ (((a) & 0x000000ff) << 24)) 

मैं उन्हें आरजीबी (ए) मानों को पैक रंग के गुणों से प्राप्त करने के लिए उपयोग करता हूं, उदाहरण के लिए

व्यक्तिगत बिट्स के रूप में संग्रहीत झंडे से संबंधित कुछ सामान्य मुहावरे हैं

 enum CDRIndicators { Local = 1 << 0, External = 1 << 1, CallerIDMissing = 1 << 2, Chargeable = 1 << 3 }; unsigned int flags = 0; 

प्रभाज़ ध्वज सेट करें:

 flags |= Chargeable; 

कॉलर आईडी साफ़ करें ध्वज साफ़ करें:

 flags &= ~CallerIDMissing; 

जांचें कि CallerIDMissing और चार्ज करने योग्य सेट हैं:

 if((flags & (CallerIDMissing | Chargeable )) == (CallerIDMissing | Chargeable)) { } 

मैंने एक सीएमएस के लिए एक सुरक्षा मॉडल को लागू करने में बिटवार ऑपरेशन का उपयोग किया है इसमें वे पृष्ठों थे जो उपयोगकर्ताओं द्वारा उपयोग किए जा सकते हैं यदि वे उपयुक्त समूह में थे। एक उपयोगकर्ता कई समूहों में हो सकता है, इसलिए हमें यह जांचना आवश्यक है कि प्रयोक्ता समूह और पृष्ठ समूह के बीच एक चौराह था या नहीं। इसलिए हमने प्रत्येक समूह को एक अद्वितीय शक्ति-के -2 पहचानकर्ता सौंपा, जैसे:

 Group A = 1 --> 00000001 Group B = 2 --> 00000010 Group C = 3 --> 00000100 

हम या इन मूल्यों को एक साथ मिलते हैं, और पृष्ठ के साथ मूल्य (एकल पूर्णांक के रूप में) को स्टोर करते हैं। अगर एक पेज ए और बी समूह द्वारा एक्सेस किया जा सकता है, तो हम मान 3 (जो बाइनरी में है 00000011) को पन्नों तक पहुँच नियंत्रण के रूप में संग्रहीत करता है। उसी तरह, हम एक संगठन के साथ ऑर्ड ग्रुप आइडेंटिफ़ार्स के मान को संग्रहित करते हैं जिसमें वे प्रतिनिधित्व करते हैं कि वे कौन से समूह में हैं

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

जब मेरे पास बूलियन झंडे का एक गुच्छा होता है, तो मुझे उन सभी को एक int में संग्रहीत करना पसंद है

मैं उन्हें बिटवा-एंड-एंड का उपयोग करके निकाल लेता हूं। उदाहरण के लिए:

 int flags; if (flags & 0x10) { // Turn this feature on. } if (flags & 0x08) { // Turn a second feature on. } 

आदि।

मैं बस पीटीसी के साथ धारावाहिक संचार के लिए चेकसम की गणना करने के लिए लगभग तीन मिनट पहले bitwise-XOR ( ^ ) का उपयोग किया था …

आप उन्हें हैश डेटा के लिए त्वरित और गंदे तरीके के रूप में उपयोग कर सकते हैं।

 int a = 1230123; int b = 1234555; int c = 5865683; int hash = a ^ b ^ c; 

एन्क्रिप्शन सभी बिटवर्ड ऑपरेशन है

& = AND:
विशिष्ट बिट्स को बाहर निकालें
आप विशिष्ट बिट्स को परिभाषित कर रहे हैं जिन्हें प्रदर्शित किया जाना चाहिए या प्रदर्शित नहीं किया जाना चाहिए। 0x0 और x सभी बिट्स को एक बाइट में साफ़ करेंगे जबकि 0xFF x बदल नहीं पाएंगे। 0x0F निचले चोंच में बिट प्रदर्शित करेगा

रूपांतरण:
बिट वैरिएबल को थोड़ी पहचान के साथ लंबे समय तक रखने के लिए बिट्स को एडजस्ट करने के लिए आवश्यक है क्योंकि -1 में एक इंट 0xFFFFFFFF है जबकि -1 में लंबा 0xFFFFFFFFFFFFFFFF है। पहचान को संरक्षित करने के लिए आप रूपांतरण के बाद मुखौटा लागू करते हैं।

| = या
सेट बिट्स यदि वे पहले ही सेट कर चुके हैं तो बीट्स को बेतरतीब ढंग से सेट किया जाएगा। कई डिटेस्ट्रक्चर (बिटफ़ील्ड) के झंडे आईएस_एचएसईटी = 0, आईएस_ वीएएसटी = 1 हैं, जो मज़बूती से सेट हो सकते हैं झंडे सेट करने के लिए, आप IS_HSET | IS_VSET (सी और विधानसभा में पढ़ने के लिए यह बहुत सुविधाजनक है)

^ = XOR
उन बिट्स का पता लगाएं जो समान या अलग हैं

~ = NOT
फ्लिप बिट्स

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

कुछ अद्भुत हैक्स:

http://www.ugcs.caltech.edu/~wnoise/base2.html
http://www.jjj.de/bitwizardry/bitwizardrypage.html

बिटवेट और इसका प्रयोग एक बाइट के एक निश्चित भाग को मुखौटा / निकालने के लिए किया जाता है।

1 बाइट चर

  01110010 &00001111 Bitmask of 0x0F to find out the lower nibble -------- 00000010 

विशेष रूप से शिफ्ट ऑपरेटर (<< >>) अक्सर गणना के लिए उपयोग किया जाता है

बाइट प्रारूप में बिटमैप चित्र से रंग पढ़ने के लिए यह एक उदाहरण है

 byte imagePixel = 0xCCDDEE; /* Image in RRGGBB format R=Red, G=Green, B=Blue */ //To only have red byte redColour = imagePixel & 0xFF0000; /*Bitmasking with AND operator */ //Now, we only want red colour redColour = (redColour >> 24) & 0xFF; /* This now returns a red colour between 0x00 and 0xFF. 

मुझे उम्मीद है कि यह छोटा उदाहरण मदद करता है ….

बेस 64 एन्कोडिंग एक उदाहरण है। बेस 64 एन्कोडिंग को ईमेल सिस्टम (और अन्य उद्देश्यों) को भेजने के लिए प्रिंट करने योग्य वर्णों के रूप में द्विआधारी डेटा का प्रतिनिधित्व करने के लिए उपयोग किया जाता है। बेस 64 एन्कोडिंग 8 बिट बाइट्स की श्रृंखला को 6 बिट वर्ण लुकअप इंडेक्स में कनवर्ट करता है। बेस 64 एन्कोडिंग और डिकोडिंग के लिए आवश्यक बिट ऑपरेशन को कार्यान्वित करने के लिए बिट ऑपरेशन, स्थानांतरण, और 'ऑरिंग, या', नॉटिंग बहुत उपयोगी हैं।

यह बिल्कुल अनगिनत उदाहरणों में से केवल 1 का है

मुझे आश्चर्य है कि किसी ने इंटरनेट युग के लिए स्पष्ट उत्तर नहीं दिया। एक सबनेट के लिए वैध नेटवर्क पते की गणना करना

http://www.topwebhosts.org/tools/netmask.php

आज की आधुनिक भाषा की सारभूत दुनिया में, बहुत ज्यादा नहीं फ़ाइल IO एक आसान तरीका है जो दिमाग में आता है, हालांकि यह कुछ पहले से लागू किया गया है और कुछ ऐसे क्रियान्वयन नहीं कर रहा है जो बिटवार्ड ऑपरेशन का उपयोग करता है। फिर भी, एक आसान उदाहरण के रूप में, यह कोड फ़ाइल पर केवल पढ़ने के लिए विशेषता को हटाने का प्रदर्शन करता है (ताकि इसे नए FileStream के साथ FileMode.Create निर्दिष्ट किया जा सकता है) सी #: में।

 //Hidden files posses some extra attibutes that make the FileStream throw an exception //even with FileMode.Create (if exists -> overwrite) so delete it and don't worry about it! if(File.Exists(targetName)) { FileAttributes attributes = File.GetAttributes(targetName); if ((attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) File.SetAttributes(targetName, attributes & (~FileAttributes.ReadOnly)); File.Delete(targetName); } 

जहां तक ​​कस्टम कार्यान्वयन है, यहाँ एक हालिया उदाहरण है: मैंने हमारे वितरित एप्लिकेशन की एक स्थापना से दूसरे को सुरक्षित संदेश भेजने के लिए एक "संदेश केंद्र" बनाया है। मूल रूप से, यह ईमेल के अनुरूप है, इनबॉक्स, आउटबॉक्स, सेंटेड आदि के साथ पूरा होता है, लेकिन इसमें पढ़ने की रसीदों के साथ भी डिलीवरी की गारंटी होती है, इसलिए "इनबॉक्स" से परे अतिरिक्त उपफ़ोल्डर हैं और "भेजे"। यह मेरे लिए "इनबॉक्स में क्या है" या "भेजा गया फ़ोल्डर में" क्या सामान्य रूप से परिभाषित करने की आवश्यकता है। भेजे गए फ़ोल्डर में, मुझे यह जानने की आवश्यकता है कि क्या पढ़ा गया और क्या न पढ़े। जो अपठित है, मुझे पता होना चाहिए कि क्या प्राप्त किया गया है और जो प्राप्त नहीं हुआ है। मैं इस जानकारी को गतिशील बनाने के लिए उपयोग करता हूं जहां एक स्थानीय डेटा स्रोत फ़िल्टर करता है और उपयुक्त जानकारी प्रदर्शित करता है।

यहां बताया गया है कि कैसे enum एक साथ रखा है:

  public enum MemoView :int { InboundMemos = 1, // 0000 0001 InboundMemosForMyOrders = 3, // 0000 0011 SentMemosAll = 16, // 0001 0000 SentMemosNotReceived = 48, // 0011 SentMemosReceivedNotRead = 80, // 0101 SentMemosRead = 144, // 1001 Outbox = 272, //0001 0001 0000 OutBoxErrors = 784 //0011 0001 0000 } 

क्या आप देखते हैं कि यह क्या होता है? Inbox "enum मूल्य" के साथ (और), InboundMemos, मुझे पता है कि InboundMemosForMyOrders इनबॉक्स में है

यहां विधि का एक उबला हुआ संस्करण है जो वर्तमान में चयनित फ़ोल्डर के लिए दृश्य को परिभाषित करता है और फ़िल्टर देता है:

  private string GetFilterForView(MemoView view, DefaultableBoolean readOnly) { string filter = string.Empty; if((view & MemoView.InboundMemos) == MemoView.InboundMemos) { filter = "<inbox filter conditions>"; if((view & MemoView.InboundMemosForMyOrders) == MemoView.InboundMemosForMyOrders) { filter += "<my memo filter conditions>"; } } else if((view & MemoView.SentMemosAll) == MemoView.SentMemosAll) { //all sent items have originating system = to local filter = "<memos leaving current system>"; if((view & MemoView.Outbox) == MemoView.Outbox) { ... } else { //sent sub folders filter += "<all sent items>"; if((view & MemoView.SentMemosNotReceived) == MemoView.SentMemosNotReceived) { if((view & MemoView.SentMemosReceivedNotRead) == MemoView.SentMemosReceivedNotRead) { filter += "<not received and not read conditions>"; } else filter += "<received and not read conditions>"; } } } return filter; } 

बेहद आसान है, लेकिन अमूर्त के स्तर पर एक सुव्यवस्थित कार्यान्वयन जिसे आमतौर पर बिटवाः कार्यों की आवश्यकता नहीं होती है

किसी ने निश्चित बिंदु गणित का उल्लेख नहीं किया है

(हाँ, मैं बूढ़ा हूँ, ठीक है?)

यह एसक्यूएल रिलेशनल मॉडल में भी आसान हो सकता है, मान लें कि आपके पास निम्न तालियां हैं: BlogEntry, BlogCategory

परंपरागत रूप से आप एक BlogEntryCategory तालिका का उपयोग करके उनके बीच एक एनएनएन रिश्ते बना सकते हैं या जब आप ब्लॉगएन्ट्री में एक मूल्य का उपयोग कर सकते हैं, तो आप ब्लॉगएन्टीरी में एक वैल्यू का उपयोग कर सकते हैं, जैसे कि आप कई ब्लॉगकैचर रिकॉर्ड्स से लिंक करते हैं, जैसे कि आप फ्लैग किए गए एनमॉम्स के साथ करते हैं, अधिकांश RDBMS में भी उस 'ध्वजांकित' कॉलम पर चयन करने के लिए एक बहुत तेज़ ऑपरेटरों …

क्या संख्या x 2 की शक्ति है? (उदाहरण के लिए एल्गोरिदम में उपयोगी है जहां एक काउंटर बढ़ता है, और केवल लॉगरिदमिक संख्या के लिए कार्रवाई की जानी चाहिए)

 (x & (x - 1)) == 0 

कौन से पूर्णांक x का सबसे ऊँचा बिट है? (उदाहरण के लिए यह x तुलना में बड़ा 2 की न्यूनतम पावर खोजने के लिए इस्तेमाल किया जा सकता है)

 x |= (x >> 1); x |= (x >> 2); x |= (x >> 4); x |= (x >> 8); x |= (x >> 16); return x - (x >>> 1); // ">>>" is unsigned right shift 

एक पूर्णांक x का सबसे कम 1 बिट क्या है? (2 से विभाजित होने वाले समय की संख्या में सहायता करता है।)

 x & -x 

आम तौर पर गुणा / विभाजित करने से बीटावर्ड ऑपरेशन तेजी से होते हैं। इसलिए यदि आपको 9 कहते हुए एक चर एक्स को गुणा करना है, तो आप x<<3 + x करेंगे जो x<<3 + x से अधिक कुछ चक्र होगा x*9 यदि यह कोड एक आईएसआर के अंदर है, तो आप प्रतिक्रिया समय पर बचा लेंगे।

इसी प्रकार यदि आप एक सरणी को एक परिपत्र कतार के रूप में इस्तेमाल करना चाहते हैं, तो यह बिट वार ऑपरेशंस के साथ चेक के आसपास लपेटो करने के लिए तेज़ (और अधिक सुरुचिपूर्ण) होगा। (आपके सरणी का आकार 2 की शक्ति होना चाहिए) उदाहरण:, tail = ((tail +1) < size) ? tail+1 : 0 बजाय tail = ((tail & MASK) + 1) उपयोग कर सकते हैं tail = ((tail +1) < size) ? tail+1 : 0 tail = ((tail +1) < size) ? tail+1 : 0 , यदि आप सम्मिलित / हटाना चाहते हैं

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

इसके अलावा एक एन-बिट बिटमैप वास्तव में एक शांत और कॉम्पैक्ट डेटा संरचना हो सकता है। यदि आप आकार n के संसाधन पूल को आवंटित करना चाहते हैं, तो हम वर्तमान स्थिति को दर्शाने के लिए एन-बिट का उपयोग कर सकते हैं।

मैंने देखा है कि उन्हें भूमिका आधारित एक्सेस कंट्रोल सिस्टम में इस्तेमाल किया गया है

मेरे प्रश्न में यहाँ वास्तविक दुनिया का उपयोग होता है –
केवल पहली WM_KEYDOWN अधिसूचना का उत्तर दें?

विंडो में एक WM_KEYDOWN संदेश का उपयोग करते समय सीपी बीपी 30 पिछले कुंजी स्थिति को निर्दिष्ट करता है। मान 1 है यदि कुंजी नीचे संदेश भेजने से पहले है, या शून्य है अगर कुंजी ऊपर है

वे ज्यादातर बिटवायर ऑपरेशन (आश्चर्य) के लिए उपयोग किए जाते हैं यहां कुछ वास्तविक दुनिया उदाहरण हैं जो PHP कोडेबेस में मिले हैं।

अक्षरों को सांकेतिक अक्षरों में बदलना:

 if (s <= 0 && (c & ~MBFL_WCSPLANE_MASK) == MBFL_WCSPLANE_KOI8R) { 

डेटा संरचनाएं:

 ar_flags = other->ar_flags & ~SPL_ARRAY_INT_MASK; 

डाटाबेस ड्राइवर:

 dbh->transaction_flags &= ~(PDO_TRANS_ACCESS_MODE^PDO_TRANS_READONLY); 

कंपाइलर कार्यान्वयन:

 opline->extended_value = (opline->extended_value & ~ZEND_FETCH_CLASS_MASK) | ZEND_FETCH_CLASS_INTERFACE; 

जब भी मैंने पहली बार सी प्रोग्रामिंग शुरू की, मैं सच्चाई तालिकाओं को समझता हूं, और सब कुछ, लेकिन यह वास्तव में इसका उपयोग करने के साथ ही नहीं किया गया जब तक कि मैं इस लेख http://www.gamedev.net/reference/articles/article1563.asp को पढ़ नहीं पाता । (जो वास्तविक जीवन उदाहरण देता है)

मुझे नहीं लगता कि यह मायने में बिटवर्ड है, लेकिन रूबी के अर्रे सामान्य पूर्णांक बिटwise ऑपरेटर के माध्यम से सेट ऑपरेशन को परिभाषित करता है। तो [1,2,4] & [1,2,3] # => [1,2] इसी तरह a ^ b #=> set difference और a | b #=> union a | b #=> union

जब आप केवल एक माइक्रोकंट्रोलर के आउटपुट के कुछ बिट्स को बदलना चाहते हैं, लेकिन लिखने के लिए एक बाइट है, तो आप ऐसा कुछ करते हैं (स्यूडोकोड):

 char newOut = OutRegister & 0b00011111 //clear 3 msb's newOut = newOut | 0b10100000 //write '101' to the 3 msb's OutRegister = newOut //Update Outputs 

बेशक, कई माइक्रोकंट्रोलर आपको अलग-अलग प्रत्येक बिट को बदलने की अनुमति देते हैं …

यदि आप कभी भी अपना नंबर yourNumber & 2^N-1 (%) 2 की एक निश्चित शक्ति की गणना करना चाहते हैं, तो आप अपने नंबर yourNumber & 2^N-1 उपयोग कर सकते हैं, जो इस मामले में yourNumber % 2^N

 number % 16 = number & 15; number % 128 = number & 127; 

यह संभवतः केवल 2 ^ एन के बहुत बड़े लाभांश के साथ मॉड्यूलस ऑपरेशन के लिए उपयोगी है … लेकिन फिर भी मॉड्यूलस ऑपरेशन पर इसकी गति को बढ़ावा देने के लिए मेरे परीक्षण में .NET 2.0 पर नगण्य है। मुझे संदेह है कि आधुनिक कम्पाइलर पहले से ही इस तरह ऑप्टिमाइज़ेशन कर रहे हैं। क्या किसी को भी इस बारे में अधिक पता है?

हनोई रैखिक समाधान के टॉवर समस्या को हल करने के लिए बिटवायर ऑपरेशन का उपयोग करता है।

 public static void linear(char start, char temp, char end, int discs) { int from,to; for (int i = 1; i < (1 << discs); i++) { from = (i & i-1) % 3; to = ((i | i-1) + 1) % 3; System.out.println(from+" => "+to); } } 

इस समाधान के लिए स्पष्टीकरण यहां पाया जा सकता है

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

 int[] arr = new int[8]; int i = 0; while (true) { print(arr[i]); i = i + 1; if (i >= arr.length) i = 0; } 

यह सबसे आसान तरीका है, यदि आप अगर बयान से बचना चाहते हैं, तो आप ऐसे मॉड्यूलस दृष्टिकोण का उपयोग कर सकते हैं:

 int[] arr = new int[8]; int i = 0; while (true) { print(arr[i]); i = i + 1; i = i % arr.length; } 

इन दोनों विधियों के नीचे की ओर यह है कि मॉड्यूलस ऑपरेटर महंगा है, क्योंकि यह पूर्णांक डिवीजन के बाद शेष के लिए दिखता है। और पहली विधि प्रत्येक पुनरावृत्ति पर अगर एक बयान चलाती है। बिटवर्ड ऑपरेटर के साथ, हालांकि यदि आपकी सरणी की लंबाई 2 की शक्ति है, तो आप आसानी से 0 .. length - 1 जैसे अनुक्रम उत्पन्न कर सकते हैं 0 .. length - 1 का प्रयोग करके & (bitwise और) ऑपरेटर की तरह i & length तो यह जानकर, ऊपर से कोड हो जाता है

 int[] arr = new int[8]; int i = 0; while (true){ print(arr[i]); i = i + 1; i = i & (arr.length - 1); } 

यहाँ दिया गया है कि यह कैसे काम करता है। बाइनरी प्रारूप में प्रत्येक संख्या जो 1 की घटाकर 2 की शक्ति होती है वह केवल लोगों के साथ व्यक्त की जाती है उदाहरण के लिए बाइनरी में 11 , 11 , 7 111 , 15 है 1111 और इसी तरह, आपको यह विचार मिलता है। अब, क्या होता है अगर आप & कोई भी नंबर बाइनरी में वाले लोगों की संख्या के साथ? मान लें कि हम ऐसा करते हैं:

 num & 7; 

यदि num छोटा या 7 के बराबर होती है तो परिणाम का num हो सकता है क्योंकि प्रत्येक बिट & 1 के साथ-साथ ही स्वयं होता है यदि num 7 से बड़ा है, तो ऑपरेशन कंप्यूटर के दौरान & 7 के अग्रणी शून्य पर विचार किया जाएगा, जो निश्चित रूप से शून्य & शून्य के रूप में रहेगा, केवल बाद वाले भाग ही रहेगा। 9 & 7 मामले में बाइनरी में ऐसा दिखेगा

 1001 & 0111 

नतीजा होगा 0001 जो 1 दशमलव में है और सरणी में दूसरे तत्व को संबोधित करता है।

मैं उन्हें एकाधिक चयन विकल्पों के लिए उपयोग करता हूं, इस तरह मैं केवल 10 या अधिक के बजाय एक मान को संग्रहित करता हूं