चक्र। पैरामीटर के साथ लूप (के लिए)


आइए एक ऐसी स्थिति की कल्पना करें जहां हमें स्क्रीन पर एक ही शब्द प्रदर्शित करने की आवश्यकता है, आइए शब्द कहें "नमस्ते" ;, 10 बार। हमें क्या करना चाहिए?
आप 10 बारConsole.WriteLine("HELLO");
कमांड ले और लिख सकते हैं
लेकिन क्या होगा अगर आपको 10 बार नहीं, बल्कि 20, 30, 40 बार की जरूरत है? और अगर 200 बार? ऐसे में नकल में काफी समय लगेगा। और यदि यह आवश्यक है कि उपयोगकर्ता स्क्रीन पर जानकारी प्रदर्शित करने के लिए कितनी बार चुनता है? 

इस कार्य से निपटने के लिए, हम लूप नामक एक विशेष निर्माण का उपयोग कर सकते हैं।

लूप एक एल्गोरिथम निर्माण है जिसमें कमांड का एक निश्चित क्रम कई बार दोहराया जाता है।

C# प्रोग्रामिंग लैंग्वेज में, दो प्रकार के लूप होते हैं: एक वेरिएबल लूप (के लिए) और एक सशर्त लूप (जबकि और डू...जबकि एम>)

चलिए पहले प्रकार से साइकिल से परिचित होना शुरू करते हैं।

एक चर के साथ एक लूप या चरणों की एक ज्ञात संख्या के साथ (के लिए)।

अक्सर ऐसा होता है कि हम किसी क्रिया की पुनरावृत्ति की संख्या जानते हैं, या हम गणना कर सकते हैं हमारे द्वारा ज्ञात डेटा का उपयोग करके दोहराव की संख्या। कुछ प्रोग्रामिंग भाषाओं में एक आदेश होता है जो रूसी में दोहराना (बार की संख्या) जैसा लगता है - यानी, हम दोहराव की सटीक संख्या निर्दिष्ट कर सकते हैं। 

यह देखना दिलचस्प है कि यह चक्र मशीन स्तर पर कैसे काम करता है:
1. एक निश्चित मेमोरी सेल को मेमोरी में आवंटित किया जाता है और इसमें दोहराव की संख्या लिखी जाती है।
2. जब प्रोग्राम लूप की बॉडी को एक बार निष्पादित करता है, तो इस सेल (काउंटर) की सामग्री में एक की कमी हो जाती है।
3. यह सेल शून्य होने पर लूप समाप्त हो जाता है।

C# प्रोग्रामिंग लैंग्वेज में, ऐसा कोई कंस्ट्रक्शन नहीं है, बल्कि for कंस्ट्रक्शन है।  

के लिए लूप ऑपरेटर का सामान्य रूप इस प्रकार है: <पूर्व> for (/*expression1*/; /*expression2*/; /*expression3 */) { /*एक स्टेटमेंट या स्टेटमेंट का ब्लॉक - लूप बॉडी*/; } इस निर्माण के लिए हमें चाहिए:
1. स्पष्ट रूप से एक मेमोरी सेल आवंटित करें जो एक काउंटर होगा, और इसका प्रारंभिक मान सेट करें।
2. हमने एक कंडीशन लिखी है जिसके तहत लूप बॉडी को एक्जीक्यूट किया जाएगा।
3. निर्दिष्ट करें कि इस सेल में मान कैसे बदलेगा।

व्यावहारिक भाग में, हम "हैलो" शब्द को 10 बार प्रदर्शित करने का प्रयास करेंगे, और आगे के कार्यों में हम इस निर्माण का अधिक विस्तार से विश्लेषण करेंगे।

Training problem

प्रोग्रामिंग में लूप्स

for
लूप
for लूप बार-बार की जाने वाली कार्रवाइयों के माध्यम से आगे बढ़ने का एक साधन है। आइए करीब से देखें कि यह कैसे काम करता है।

आमतौर पर, for लूप के हिस्से निम्नलिखित कदम उठाते हैं: 
1. प्रारंभिक मान सेट करना। 
2. लूप जारी रखने के लिए स्थिति परीक्षण करना। 
3. लूप क्रियाएँ निष्पादित करें। 
4. परीक्षण में उपयोग किए गए मान अपडेट करें। 
और फिर शर्त पूरी होने तक चरण 2-4 दोहराए जाते हैं। जैसे ही कंडीशन झूठी हो जाती है, लूप समाप्त हो जाता है और फॉर लूप स्टेटमेंट के बाद का स्टेटमेंट निष्पादित हो जाता है।
 
<दिव>
लूप का सामान्य रूप  के लिए (/* अभिव्यक्ति 1*/; /* अभिव्यक्ति 2*/; /* अभिव्यक्ति 3*/ ) {       /* एक स्टेटमेंट या स्टेटमेंट का ब्लॉक - लूप बॉडी */; }

अभिव्यक्ति 1 लूप चर (काउंटर) के प्रारंभिक मान को सेट करने के लिए जिम्मेदार, अर्धविराम के साथ समाप्त होता है।
उदाहरण के लिए : <उल>
  • i=0; // लूप वेरिएबल i प्रारंभिक मान शून्य के बराबर सेट करें - i पहले घोषित किया जाना चाहिए पाश
  • int i=0; // i चर को तुरंत लूप हेडर में घोषित किया जा सकता है, लेकिन इस मामले में, इसे बाद में मेमोरी से मिटा दिया जाएगा लूप चलता है
  • ;  // चक्र चर का कोई आरंभीकरण और घोषणा बिल्कुल नहीं है, इस मामले में, इसे चक्र से पहले घोषित किया जा सकता है
    • अभिव्यक्ति 2 - लूप के लिए जारी रखने की यह शर्त है, इसकी सत्यता के लिए जांच की जाती है। उदाहरण के लिए,

    मैं <= 10  // लूप तब तक चलेगा जब तक वेरिएबल i 10 से कम या उसके बराबर है।
    शर्त कुछ भी हो सकती है।

    अभिव्यक्ति 3 काउंटर चर का मान बदल देता है। इस मान के बिना, लूप को अनंत माना जाएगा। उदाहरण के लिए,

    i++;  // हर बार लूप बॉडी पूरी होने पर, i 1 से बढ़ जाता है।

     

    Training problem

    लूप के लिए सुविधाएँ

    अल्पविराम द्वारा अलग किए गए प्रत्येक शीर्ष भाग में एकाधिक ऑपरेटर हो सकते हैं।< /span>
    शीर्षक उदाहरण:

    for (int i = 0; i < 10; i + + ) { ... } - मानक शीर्षक

    for (int i = 0, x = 1; i < 10; i += 2, x *= 2 ){ ...}  
             // इस मामले में, हम दो वेरिएबल्स का उपयोग करते हैं जो लूप बॉडी के निष्पादन के बाद बदल जाएंगे - ये वेरिएबल्स हैं i और x
             // चर i 2 की वृद्धि में परिवर्तन - i+=2 - i=i+2
    के लिए संक्षिप्त          // चर x प्रत्येक चरण के साथ 0.1 गुना बढ़ जाता है x=x*2 - संक्षिप्त х*=2    < /अवधि>

    Training problem

    लूप हेडर के लिए - विशेषताएं

    एन बार दोहराएं

    for लूप वाले सभी प्रोग्राम जिन्हें हमने अब तक लिखा है, उन्हें यूनिवर्सल नहीं कहा जा सकता है। क्योंकि हम खुद को लूप बॉडी के दोहराव की संख्या निर्धारित करते हैं। लेकिन क्या होगा अगर दोहराव की संख्या किसी अन्य मूल्य पर निर्भर करती है? उदाहरण के लिए, उपयोगकर्ता स्वयं चक्र के दोहराव की संख्या निर्धारित करना चाहता है।
    इस मामले में क्या करें? सब कुछ बहुत आसान है। संख्यात्मक प्रारंभ और समाप्ति मानों के बजाय, हम ऐसे किसी भी चर का उपयोग कर सकते हैं जिसकी गणना या उपयोगकर्ता द्वारा सेट की जा सकती है।

    उदाहरण के लिए, हमें 1 से N तक की संख्याओं के वर्ग प्रदर्शित करने की आवश्यकता है, जहां वेरिएबल N का मान कीबोर्ड से दर्ज किया जाता है उपयोगकर्ता।
    कार्यक्रम कुछ इस तरह दिखेगा:
      #शामिल <iostream> नेमस्पेस एसटीडी का उपयोग करना; मुख्य() { इंट आई, एन; // बुंदाबांदी में; पाश चर, एन - अधिकतम संख्या जिसके लिए हम वर्ग की गणना करते हैं सिने>> एन; for (i = 1; i <= N; i++) // लूप: for all i from 1 to N. Variable i क्रमिक रूप से 1 से N तक मान लेगा { cout << "वर्ग संख्या "<<i<<" है" <<मैं*मैं<<"\n"; // किसी संख्या के वर्ग को एक विशिष्ट प्रारूप में आउटपुट करना और एक नई पंक्ति में जाना } } लूप में प्रवेश करते समय, कथन i = 1 निष्पादित किया जाता है, और फिर चर i को प्रत्येक चरण के साथ एक से बढ़ाया जाता है (i ++ ). स्थिति i <= N के सत्य होने पर लूप निष्पादित किया जाता है। लूप की बॉडी में, केवल आउटपुट स्टेटमेंट ही संख्या और उसके वर्ग को निर्दिष्ट प्रारूप के अनुसार स्क्रीन पर प्रिंट करता है।
    वर्ग करने या अन्य निम्न घातांकों के लिए, गुणन का उपयोग करना बेहतर होता है।

    प्रोग्राम को रन करें और वेरिएबल N के विभिन्न मानों के साथ इसके कार्य का परिणाम देखें।

    Training problem

    फॉर लूप का हेडर - एन-बार दोहराना