for लूप का अध्ययन करते समय, हमने कहा कि यदि किसी क्रिया के दोहराव की संख्या ज्ञात है, तो आप for लूप ऑपरेटर का उपयोग करके प्रोग्राम को छोटा कर सकते हैं। लेकिन क्या होगा अगर दोहराव की संख्या ज्ञात नहीं है? और ऐसा अक्सर होता है।
उदाहरण के लिए, आइए दशमलव संख्या प्रणाली से किसी अन्य संख्या में किसी संख्या के रूपांतरण को याद रखें: हमें संख्या प्रणाली के आधार द्वारा संख्या (और फिर विभाजन का परिणाम) को तब तक विभाजित करने की आवश्यकता है जब तक कि हमें उत्तर में शून्य न मिल जाए। हम कितनी बार साझा करेंगे अज्ञात है। और ऐसे कई प्रोग्राम हैं जो इस तरह के एल्गोरिद्म को लागू करते हैं।
इसे कैसे लागू किया जाता है?
प्रोग्रामिंग में ऐसे मामलों के लिए, एक शर्त के साथ एक लूप ऑपरेटर होता है।
पास्कल प्रोग्रामिंग लैंग्वेज में, एक कंडीशनल लूप स्टेटमेंट शब्द के साथ शुरू होता है और इसकी निम्नलिखित संरचना होती है।
<पूर्व>
जबकि <स्थिति> शुरू करो
लूप बॉडी
अंत
जैसा कि हम पहले से ही जानते हैं:
- शर्त एक व्यंजक है, जिसका परिणाम या तो सत्य या असत्य हो सकता है (जैसा कि सशर्त कथन में होता है)
- लूप बॉडी वह कमांड है जिसे दोहराने की जरूरत होती है
- प्रारंभ और अंत को छोड़ा जा सकता है यदि लूप बॉडी में केवल एक ऑपरेटर हो
ऑपरेटर कैसे काम करता है:
1. सबसे पहले, कार्यक्रम शब्द के बाद की स्थिति का मूल्यांकन करता है। यदि शर्त पूरी होती है (सत्य), तो प्रोग्राम लूप बॉडी में निहित बयानों को निष्पादित करता है।
2. जैसा कि लूप के लिए होता है, यदि लूप बॉडी में केवल एक स्टेटमेंट होता है, तो लूप बॉडी को हाइलाइट करने वाले शब्दों को छोड़ा जा सकता है।
3. लूप बॉडी का निष्पादन पूरा होने के बाद, प्रोग्राम स्थिति की जांच करने के लिए वापस आता है और इसे फिर से जांचता है।
4. ये क्रियाएं (स्थिति की जांच - लूप बॉडी को निष्पादित करना) तब तक दोहराई जाती हैं जब तक कि स्थिति झूठी नहीं हो जाती।
5. यदि इस ऑपरेटर के पहले निष्पादन पर, स्थिति तुरंत संतुष्ट नहीं होती है (गलत), तो प्रोग्राम लूप बॉडी को कभी भी निष्पादित नहीं करेगा।
इस ऑपरेटर के काम का विश्लेषण करते हुए, यह स्पष्ट हो जाना चाहिए कि लूप बॉडी में एक ऑपरेटर होना चाहिए जो स्थिति को प्रभावित करता हो।
उदाहरण के लिए, एक लूप किसी स्थिति में उपयोग किए जाने वाले वेरिएबल के मान को बढ़ा सकता है।
प्रोग्राम का एक उदाहरण जिसे हम "साइलेंट काउंट"
कहेंगे
आइए, हमारी बजाय प्रोग्राम की गिनती करें, उदाहरण के लिए, 10 तक।
कार्यक्रम को "प्रारंभ" वाक्यांश को आउटपुट करना चाहिए और "समाप्त", और इन क्रियाओं के बीच उन संख्याओं को प्रदर्शित करते हैं जिनकी गणना की जा रही है।
इस तरह,
शुरू
1 2 3 4 5 6 7 8 9 10
समाप्त
थोड़ी देर के लूप का उपयोग करने वाला प्रोग्राम इस तरह दिखेगा।
<पूर्व>
var i: पूर्णांक;
शुरू
राइटलन (' प्रारंभ करें & #39;);
मैं := 1;
जबकि i <= 10 शुरू करते हैं
लिखें (मैं, ' ');
मैं + = 1; // ऑपरेटर जो स्थिति में चर के परिवर्तन को प्रभावित करता है
अंत;
राइटलन ();
राइटलन ('समाप्त करें');
अंत।
इस प्रोग्राम में, हम वेरिएबल i := 1 - मूल
को एक मान प्रदान करते हैं
इसके अलावा, जब तक हमारे पास वेरिएबल i का मान हमारे लिए आवश्यक मान से अधिक नहीं है (अर्थात, इससे कम या इसके बराबर), हम
1 - वेरिएबल i
का मान प्रदर्शित करता है
2 - वेरिएबल i के मान को 1 से बढ़ाएँ - यह ऑपरेटर कोष्ठक में स्थिति के मान को प्रभावित करता है। वेरिएबल i बढ़ा हुआ है, यानी किसी बिंदु पर स्थिति i<=10 झूठी हो जाएगी। यह तब होगा जब i 11 के बराबर हो जाएगा। इस मामले में, लूप बॉडी को निष्पादित नहीं किया जाएगा, और प्रोग्राम लूप के बाद अगला स्टेटमेंट निष्पादित करेगा, अर्थात। लेखन ();
राइटलन('फिनिश');