C/C++ में लूप या कंडीशनल के बिना 1 से 1000 प्रिंट करना

समस्या

यहां हम देखेंगे कि लूप या किसी कंडीशनल स्टेटमेंट के बिना 1 से 1000 कैसे प्रिंट करें। चूंकि लूप्स का उपयोग नहीं किया जा सकता, इसलिए हम रिकर्सन आज़मा सकते हैं, लेकिन यहां एक और बाधा है कि हम कंडीशन्स का भी उपयोग नहीं कर सकते। इसलिए रिकर्सन का बेस केस उपयोग नहीं किया जा सकता।

समाधान: स्टेटिक मेंबर और कंस्ट्रक्टर

यहां हम इस समस्या को स्टेटिक मेंबर्स का उपयोग करके हल कर रहे हैं। सबसे पहले हम स्टेटिक मेंबर को 1 से इनिशियलाइज़ करते हैं, फिर कंस्ट्रक्टर में हम मान प्रिंट करते हैं और इसका मान बढ़ाते हैं। अब उस क्लास के 1000 ऑब्जेक्ट्स का ऐरे बनाएं, इसलिए 1000 अलग-अलग ऑब्जेक्ट्स बनते हैं, इसलिए कंस्ट्रक्टर 1000 बार कॉल होता है। इस प्रकार हम 1 से 1000 प्रिंट कर सकते हैं।

उदाहरण

#include <iostream>
using namespace std;

class PrintN {
public:
    static int value;
    
    PrintN() {
        cout << value++ << ", ";
    }
};

int PrintN::value = 1;  // 1 से इनिशियलाइज़ करें

int main() {
    int N = 1000;
    PrintN obj[N];  // 1000 ऑब्जेक्ट्स बनाने के लिए साइज़ 1000 का ऐरे बनाएं
    return 0;
}

आउटपुट

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, .... 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000,

वैकल्पिक समाधान

1. टेम्पलेट मेटाप्रोग्रामिंग (कंपाइल-टाइम)

template <int N>
struct Print {
    static void print() {
        Print<N-1>::print();
        std::cout << N << ", ";
    }
};

template <>
struct Print<1> {
    static void print() {
        std::cout << "1, ";
    }
};

int main() {
    Print<1000>::print();
    return 0;
}

2. std::iota और एल्गोरिदम (C++11) - लूप लेकिन कोई एक्सप्लिसिट लूप नहीं

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <iterator>

int main() {
    std::vector v(1000);
    std::iota(v.begin(), v.end(), 1);  // 1 से भरें
    std::copy(v.begin(), v.end(), 
              std::ostream_iterator(std::cout, ", "));
    return 0;
}

3. रिकर्सन (यदि कंडीशनल्स अनुमत थे)

void printRec(int n) {
    if (n > 1000) return;  // बेस केस - कंडीशनल!
    std::cout << n << ", ";
    printRec(n + 1);
}

4. शॉर्ट-सर्किट ऑपरेटर्स (तकनीकी रूप से कंडीशनल)

void printSC(int n) {
    (n <= 1000) && (std::cout << n << ", ", printSC(n + 1), true);
}

तुलना

नोट

स्टेटिक मेंबर समाधान स्टैक पर 1000 ऑब्जेक्ट्स बनाता है - बड़े N के लिए स्टैक ओवरफ्लो का कारण बन सकता है। उत्पादन कोड के लिए, std::iota या लूप का उपयोग करें।