सी++ में बिटवाइज़ और एन बाइनरी स्ट्रिंग्स

इस समस्या में, हमें बाइनरी स्ट्रिंग्स के आकार n का एक सरणी बिन [] दिया जाता है। हमारा काम एन बाइनरी स्ट्रिंग्स के बिटवाइज़ और (&) को खोजने के लिए एक प्रोग्राम बनाना है।

यहां, हम सभी नंबर लेंगे और बिटवाइज और उनमें से यानी बिन [0] और बिन [1] और... बिन [एन -2] और बिन [एन]

समस्या को समझने के लिए एक उदाहरण लेते हैं,

इनपुट -

bin[] = {“1001”, “11001”, “010101”}

आउटपुट -

000001

स्पष्टीकरण − बिटवाइज़ और सभी बाइनरी स्ट्रिंग के −

(1001) & (11001) & (010101) = 000001

इस समस्या को हल करने के लिए, एक सीधा और सरल तरीका यह है कि बिटवाइज़ और दो बाइनरी स्ट्रिंग्स का पता लगाया जाए और फिर अगले के साथ बिटवाइज़ और परिणाम का पता लगाया जाए और एरे के अंतिम स्ट्रिंग तक जारी रखा जाए।

मूल एल्गोरिथम होगा -

शुरू में → परिणाम =बिन[0] और मैं =1

चरण 1 - चरण 2 और 3 को तब तक दोहराएं जब तक कि सरणी समाप्त न हो जाए।

चरण 2 - परिणाम =परिणाम और बिन[i]

चरण 3 - मैं++;

चरण 4 - परिणाम प्रिंट करें।

अब, इस दृष्टिकोण की सहायता से उदाहरण को हल करते हैं -

bin[] = {“1001”, “11001”, “010101”}
result = bin[0] = 1001, i = 1

पुनरावृत्ति 1 -

result = 1001 & 11001 = 01001
i = 2

पुनरावृत्ति 2 -

result = 01001 & 010101 = 000001
i = 3. END

उदाहरण

उपरोक्त समाधान को स्पष्ट करने के लिए कार्यक्रम,

#include <iostream>
using namespace std;
int changeLength(string &a, string &b){
   int lengtha = a.length();
   int lengthb = b.length();
   int zeros = abs(lengtha-lengthb);
   if (lengtha<lengthb) {
      for (int i = 0 ; i<zeros; i++)
      a = '0' + a;
      return lengthb;
   }
   else {
      for (int i = 0 ; i<zeros; i++)
      b = '0' + b;
   }
   return lengtha;
}
string bitwiseAND(string binary1, string binary2){
   int length = changeLength(binary1,binary2);
   string result = "";
   for (int i = 0 ; i<length; i++){
      result = result+(char)((binary1[i] - '0' & binary2[i]-'0')+'0');
   }
   return result;
}
int main(){
   string bin[] = {"1001", "11001", "010101"};
   int n = sizeof(bin)/sizeof(bin[0]);
   string result;
   if (n<2){
      cout<<bin[n-1]<<endl;
   }
   else{
      result = bin[0];
      for (int i = 1; i<n; i++)
      result = bitwiseAND(result, bin[i]);
      cout <<result<<endl;
   }
}

आउटपुट

000001

यह दृष्टिकोण आसान है लेकिन सबसे प्रभावी नहीं है क्योंकि इसे स्ट्रिंग को पार करने की आवश्यकता है।

आइए अधिक प्रभावी समाधान पर चर्चा करें,

यहां, हम बाइनरी नंबर के सबसे छोटे और सबसे बड़े बिट्स का आकार पाएंगे। फिर हम बिटवाइज़ और संख्या के प्रत्येक बिट का पता लगाएंगे और अंत में हम पूर्ववर्ती 0 जोड़ देंगे (शून्य की संख्या सबसे बड़ी - सबसे छोटी होगी)।

आइए समाधान को स्पष्ट करने के लिए एक नमूना उदाहरण लें,

bin[] = {"1001", "11001", "010101"}
Largest = 010101 smallest = 1001
010101 & 1001 = 00001

उदाहरण

उपरोक्त दृष्टिकोण के कार्यान्वयन को दिखाने के लिए कार्यक्रम -

#include <bits/stdc++.h>
using namespace std;
string bitwiseANDarray(string* bin, int n){
   string result;
   int minSize = INT_MAX;
   int maxSize = INT_MIN;
   for (int i = 0; i < n; i++) {
      reverse(bin[i].begin(), bin[i].end());
      minSize = min(minSize, (int)bin[i].size());
      maxSize = max(maxSize, (int)bin[i].size());
   }
   for (int i = 0; i < minSize; i++) {
      bool setBit = true;
      for (int j = 0; j < n; j++) {
         if (bin[j][i] == '0') {
            setBit = false;
            break;
         }
      }
      result += (setBit ? '1' : '0');
   }
   for (int i = 0; i<abs(maxSize-minSize); i++)
   result += '0';
   reverse(result.begin(), result.end());
   return result;
}
int main(){
   string arr[] = {"1001", "11001", "010101"};
   int n = sizeof(arr) / sizeof(arr[0]);
   cout<<bitwiseANDarray(arr, n);
   return 0;
}

आउटपुट

000001