मान लीजिए हमारे पास तीन पूर्णांक 'a' और 'b' और 'limit' हैं। कार्य [a, limit] रेंज में संख्याओं को प्रिंट करना है। इन संख्याओं की सूची को पावरफुल इंटीजर्स कहा जाता है और इसे इस प्रकार दर्शाया जाता है,
a^i + b^j जैसे कि i >= 0 और j >= 0
उदाहरण के लिए
इनपुट-1:
a = 2 b = 5 limit = 10
आउटपुट:
[2, 3, 4, 5, 6, 7, 9]
व्याख्या: प्रत्येक i और j के लिए,
2^0 + 5^0 = 2 , 2^0 + 5^1= 6
2^1 + 5^0 = 3 , 2^1 + 5^1= 7
2^2 + 5^0 =5 , 2^3 + 5^0= 9
इस समस्या को हल करने का दृष्टिकोण
इस विशेष समस्या को हल करने का ब्रूट फोर्स दृष्टिकोण यह है कि हम दो नेस्टेड लूप लेंगे और लिमिट तक पुनरावृति करेंगे। फिर हम ऊपरी सीमा में प्रत्येक एक्सपोनेंट के लिए दो संख्याओं का योग ढूंढेंगे और परिणामी संख्या को लिस्ट में डालेंगे।
- तीन संख्याएं 'a', 'b' और 'limit' लें।
- एक फ़ंक्शन powerfulnumbers(int a, int b, int limit) संख्याओं 'a', 'b' और 'limit' को इनपुट के रूप में लेता है। फ़ंक्शन उन सभी पावरफुल नंबरों की सूची लौटाता है जैसे कि a^i + b^j जहां i >= 0 और j >= 0।
- लिमिट तक दो नेस्टेड लूप लें और हर बार, अपने इंडेक्स के साथ गुणा करके पावरफुल नंबर ढूंढें।
- यदि संख्या [a, limit] रेंज के बीच है, तो संख्या को एक सेट में स्टोर करें (संख्याओं के डुप्लिकेट से बचने के लिए)।
- सेट पर पुनरावृति करें और आउटपुट प्रिंट करें।
उदाहरण
#include <bits/stdc++.h>
using namespace std;
void powerfulNum(int a, int b, int limit) {
set < int > s;
for (int i = 1; i < limit; i *= a) {
for (int j = 1; j < limit; j *= b) {
if (i + j <= limit) {
s.insert(i + j);
} else break;
if (b == 1) break;
}
if (a == 1) break;
}
for (auto it: s) {
cout << it << " ";
}
}
int main() {
int a = 2;
int b = 5;
int limit = 10;
powerfulNum(a, b, limit);
return 0;
}
उपरोक्त कोड चलाने से आउटपुट इस प्रकार उत्पन्न होगा,
आउटपुट
2 3 5 6 7 9
यहां, 2 से 10 की रेंज में सभी पावरफुल नंबर [2, 3, 4, 6, 7, 9] हैं।
