C# में वर्णों को सही तरीके से दोहराना: सामान्य कोड से अनुकूलन तक

परिचय: वर्ण दोहराने का प्रश्न प्रतिष्ठित क्यों हो गया

यदि आपने कभी C# में कोड लिखा है, तो आपने निश्चित रूप से इस कार्य का सामना किया होगा: "मुझे N समान वर्णों से बनी एक स्ट्रिंग बनानी है।" यह कितना आसान लगता है? लेकिन यही प्रश्न Stack Overflow पर हजारों बार देखा गया और दर्जनों उत्तर प्राप्त हुए। क्यों? क्योंकि इस सरलता के पीछे प्रदर्शन अनुकूलन और छिपी समस्याओं की एक पूरी दुनिया है।

इस लेख में हम केवल यह नहीं दिखाएंगे कि C# में वर्ण को कैसे दोहराया जाए। हम सामान्य समाधान से लेकर पेशेवर तकनीकों तक का सफर तय करेंगे, जिनका उपयोग उच्च-लोड सिस्टम में किया जाता है। आप जानेंगे कि विभिन्न परिदृश्यों में वर्ण दोहराने के लिए कौन सी विधि सबसे उपयुक्त है, और क्यों कुछ लोकप्रिय सुझाव वास्तव में हानिकारक हैं।

यह लेख किसके लिए उपयोगी होगा?

\n
• शुरुआती C# डेवलपर्स जो केवल काम करने वाला कोड नहीं, बल्कि कुशल कोड लिखना चाहते हैं
\n
• अनुभवी प्रोग्रामर जो स्ट्रिंग संचालन को अनुकूलित करने के तरीके खोज रहे हैं
\n
• वे सभी जो तकनीकी साक्षात्कार की तैयारी कर रहे हैं और .NET की आंतरिक संरचना के ज्ञान से प्रभावित करना चाहते हैं
\n

समस्या: for लूप क्यों नहीं लिखना चाहिए

जब कोई नौसिखिया "वर्ण को N बार दोहराएँ" सुनता है, तो सबसे पहले दिमाग में for लूप आता है:

string RepeatChar(char c, int count)\n{\n    string result = "";\n    for (int i = 0; i < count; i++)\n        result += c;\n    return result;\n}\n

यह समाधान काम करता है, लेकिन यह बेहद धीमा है। क्यों? क्योंकि C# में स्ट्रिंग्स अपरिवर्तनीय (immutable) होती हैं। प्रत्येक += ऑपरेशन एक नई स्ट्रिंग बनाता है, जिसमें पुरानी सामग्री और एक वर्ण कॉपी होता है। परिणामस्वरूप, इस एल्गोरिदम की जटिलता O(n²) है। 10 वर्णों के लिए यह ध्यान देने योग्य नहीं है, लेकिन 100,000 के लिए यह अनंत काल जैसा लगता है।

आइए वास्तविक आंकड़े देखें। इस विधि को count = 100,000 के साथ परीक्षण करें। आधुनिक प्रोसेसर पर इसमें कुछ सेकंड लगेंगे। और यदि वर्ण को दस लाख बार दोहराना हो? प्रोग्राम बस "हैंग" हो जाएगा।

निष्कर्ष: कॉन्केटनेशन वाला लूप हानिकारक है। लेकिन इसके अलावा और भी अधिक कुशल तरीके हैं।

C# में वर्ण दोहराने के मुख्य तरीके

आइए उन सभी लोकप्रिय विधियों पर विचार करें जिन पर Stack Overflow और वास्तविक परियोजनाओं में चर्चा होती है। हम प्रत्येक का प्रदर्शन परीक्षण करेंगे और बताएंगे कि कब किसका उपयोग करना चाहिए।

1. क्लासिक StringBuilder

अनुकूलन की दिशा में पहला कदम StringBuilder का उपयोग है। यह प्रत्येक जोड़ पर नई स्ट्रिंग नहीं बनाता, बल्कि बफर के साथ काम करता है:

string RepeatWithStringBuilder(char c, int count)\n{\n    StringBuilder sb = new StringBuilder(count);\n    for (int i = 0; i < count; i++)\n        sb.Append(c);\n    return sb.ToString();\n}\n

ध्यान दें: हमने तुरंत प्रारंभिक क्षमता count निर्धारित की है। यह महत्वपूर्ण है! यदि क्षमता निर्दिष्ट नहीं की गई, तो StringBuilder को कई बार मेमोरी पुनः आवंटित करनी पड़ेगी, जिससे प्रदर्शन कम हो जाएगा।

प्रदर्शन: O(n)। 100,000 वर्णों के लिए यह विधि ~1-2 मिलीसेकंड में काम करती है।

2. वर्णों की सरणी + new string

यह .NET में सबसे तेज़ तरीकों में से एक है। आवश्यक लंबाई की एक सरणी बनाएँ, इसे वर्ण से भरें और स्ट्रिंग कंस्ट्रक्टर को दें:

string RepeatWithArray(char c, int count)\n{\n    char[] chars = new char[count];\n    Array.Fill(chars, c);\n    return new string(chars);\n}\n

यह तेज़ क्यों है? क्योंकि हम सीधे मेमोरी के साथ काम करते हैं: सरणी एक बार में भर जाती है, और new string(char[]) कंस्ट्रक्टर केवल डेटा को स्ट्रिंग के आंतरिक बफर में कॉपी करता है। कोई अतिरिक्त संचालन नहीं।

प्रदर्शन: