C++ में N को विभाजित करने पर भागफल से अधिक सेट बिट्स वाले भाजक की संख्या

हमें एक पूर्णांक संख्या के साथ दिया गया है, मान लीजिए, N जिसे भाजक माना जाता है और इसे 1 - N से शुरू होने वाली संख्याओं से विभाजित किया जाएगा और कार्य उन भाजक की गिनती की गणना करना है जिनके पास सेट बिट्स की संख्या से अधिक है भागफल को दी गई संख्या N से विभाजित करने पर।

उदाहरण के लिए

इनपुट - इंट एन =6

आउटपुट - N को विभाजित करने पर भागफल से अधिक सेट बिट्स वाले भाजक की संख्या हैं:5

स्पष्टीकरण - सबसे पहले, हम संख्या N को 1 - N से शुरू होने वाली संख्याओं से विभाजित करेंगे और भाजक और भागफल के सेट बिट्स की गणना करेंगे अर्थात

1-> N =6 /1(1) =6(2) =1 <2 =नहीं माना गया

2-> N =6 /2(1) =3(2) =2 =2 =माना जाता है

3-> एन =6/3(2) =2(1) =2> 1 =माना जाता है

4-> एन =6 /4(1) =1(1) =1 =1 =माना जाता है

5-> एन =6/5(2) =1(1) =2> 1 =माना जाता है

6-> एन =6/6(2) =1(1) =2>1 =माना जाता है

जैसा कि हम देख सकते हैं, हम विचार किए गए मामलों को लेंगे और आउटपुट 5 होगा।

इनपुट - इंट एन =10

आउटपुट - N को विभाजित करने पर भागफल से अधिक सेट बिट्स वाले भाजक की संख्या हैं:8

स्पष्टीकरण - सबसे पहले, हम संख्या N को 1 - N से शुरू होने वाली संख्याओं से विभाजित करेंगे और भाजक और भागफल के सेट बिट्स की गणना करेंगे अर्थात

1-> एन =10 /1(1) =10(2) =1 <2 =विचार नहीं किया गया

2-> एन =10 /2(1) =5(2) =2 =2 =माना जाता है

3-> N =10 /3(2) =3(2) =2 =2 =माना जाता है

4-> एन =10 /4(1) =2(1) =1 <2 =नहीं माना गया

5-> एन =10 /5(2) =2(1) =2> 2 =माना जाता है

6-> एन =10 /6(2) =1(1) =2>1 =माना जाता है

7-> एन =10 /7(3) =1(1) =3>1 =माना जाता है

8-> एन =10 /8(1) =1(1) =1 =1 =माना जाता है

9-> एन =10 /9(2) =1(1) =2> 2 =माना जाता है

10-> एन =10 10(2) =1(1) =2> 1 =माना जाता है

जैसा कि हम देख सकते हैं, हम विचार किए गए मामलों को लेंगे और आउटपुट 8 होगा।

नीचे दिए गए प्रोग्राम में इस्तेमाल किया गया तरीका इस प्रकार है

• एक धनात्मक पूर्णांक संख्या N इनपुट करें और इसे एक तर्क के रूप में फ़ंक्शन divisors_quotient() में पास करें।
• फ़ंक्शन के अंदर divisors_quotient()
  • एन - कॉल को फ़ंक्शन set_quo(N) + 1 पर वापस करें और फ़ंक्शन set_quo() पर जाएं
• समारोह के अंदर set_quo()
  • प्रारंभ और अंत के रूप में एक अस्थायी चर बनाएं और प्रारंभ को 1 से प्रारंभ करें और sqrt(N) के साथ समाप्त करें।
  • आरंभ होने तक लूप प्रारंभ करें <अंत और अस्थायी चर को अस्थायी के रूप में बनाएं और इसे (प्रारंभ + अंत) / 2
  पर सेट करें
  • IF जांचें (फ़ंक्शन को कॉल करें सत्यापित करें() और अस्थायी और N को तर्क के रूप में पास करें) फिर अंत को temp के रूप में सेट करें
  • ELSE, प्रारंभ को temp + 1 के रूप में सेट करें
  • IF(! फंक्शन को कॉल करें सत्यापित करें() और अस्थायी और N को तर्क के रूप में पास करें) फिर प्रारंभ + 1 पर लौटें।
  • ELSE, वापसी प्रारंभ
• फ़ंक्शन के अंदर सत्यापित करें ()
  • जांचें IF(फ़ंक्शन पर कॉल val_bit(temp/val) फ़ंक्शन val_bit(val) पर कॉल से कम है) फिर सही लौटें अन्यथा गलत लौटें
• समारोह के अंदर val_bit()
  • परिणाम संग्रहीत करने के लिए एक अस्थायी चर गणना घोषित करें।
  • प्रारंभ लूप जबकि वैल का मान है। लूप के अंदर, वैल को वैल / 2 के रूप में सेट करें और गिनती को 1 से बढ़ाएं।
  • वापसी की संख्या।

उदाहरण

#include <bits/stdc++.h>
using namespace std;

int val_bit(int val) {
   int count = 0;
   while (val) {
      val = val / 2;
      count++;
   }
   return count;
}
bool verify(int val, int temp) {
   if (val_bit(temp / val) <= val_bit(val)) {
      return true;
   }
   return false;
}
int set_quo(int N) {
   int start = 1;
   int end = sqrt(N);
   while (start < end) {
      int temp = (start + end) / 2;
      if (verify(temp, N)) {
         end = temp;
      } else {
         start = temp + 1;
      }
   }
   if (!verify(start, N)) {
      return start + 1;
   } else {
      return start;
   }
}

int divisors_quotient(int N) {
   return N - set_quo(N) + 1;
}
int main() {
   int N = 10;
   cout << "Count of divisors having more set bits than quotient on dividing N are: " << divisors_quotient(N);
   return 0;
}

यदि हम उपरोक्त कोड चलाते हैं तो यह निम्न आउटपुट उत्पन्न करेगा -

आउटपुट

Count of divisors having more set bits than quotient on dividing N are: 8