एक ऐसी स्थिति की कल्पना करें जहां हमें एक ही शब्द को स्क्रीन पर प्रदर्शित करने की आवश्यकता है, आइए "HELLO" शब्द को 10 बार कहें। हमें क्या करना चाहिए?
आप कमांड को 10 बार ले और लिख सकते हैं writeln('HELLO');
लेकिन क्या होगा अगर आपको 10 बार नहीं, बल्कि 20, 30, 40 बार और अगर 200 बार चाहिए? ऐसे में नकल में काफी समय लगेगा। और अगर यह आवश्यक है कि उपयोगकर्ता स्क्रीन पर जानकारी प्रदर्शित करने के लिए कितनी बार चुन सकता है?
इस कार्य से निपटने के लिए, हम LOOP
नामक एक विशेष निर्माण का उपयोग कर सकते हैं
लूप एक एल्गोरिथम निर्माण है जिसमें कमांड का एक निश्चित क्रम कई बार दोहराया जाता है।
पास्कल प्रोग्रामिंग भाषा में, दो प्रकार के लूप होते हैं: एक लूप एक चर के साथ (के लिए) और एक लूप एक शर्त के साथ (जबकि)
चलिए पहले प्रकार से साइकिल से परिचित होना शुरू करते हैं।
एक चर के साथ लूप या चरणों की ज्ञात संख्या के साथ (FOR)
अक्सर ऐसा होता है कि हम कुछ क्रियाओं की पुनरावृत्ति की संख्या जानते हैं, या हम ज्ञात डेटा का उपयोग करके दोहराव की संख्या की गणना कर सकते हैं। कुछ प्रोग्रामिंग भाषाओं में एक कमांड होता है जो रूसी में REPEAT (कई बार की संख्या) जैसा लगता है - यानी, हम दोहराव की सटीक संख्या निर्दिष्ट कर सकते हैं।
यह देखना दिलचस्प है कि यह चक्र मशीन स्तर पर कैसे काम करता है:
1. एक निश्चित मेमोरी सेल को मेमोरी में आवंटित किया जाता है और उसमें दोहराव की संख्या लिखी जाती है,
2. जब प्रोग्राम लूप बॉडी को एक बार निष्पादित करता है, तो इस सेल (काउंटर) की सामग्री एक से कम हो जाती है।
3. इस सेल के शून्य होने पर लूप निष्पादन समाप्त हो जाता है।
प्रोग्रामिंग भाषा पास्कल में, ऐसा कोई निर्माण नहीं है, लेकिन निर्माण के लिए है।
for लूप स्टेटमेंट का सामान्य रूप इस प्रकार है:
<पूर्व>
for *start value* to *end value* करते हैं
शुरू
/*एक स्टेटमेंट या स्टेटमेंट का ब्लॉक - लूप बॉडी*/;
अंत;
इस निर्माण के लिए आवश्यक है कि हम
1. स्पष्ट रूप से एक मेमोरी सेल आवंटित करें, जो एक काउंटर होगा, और इसका प्रारंभिक मान सेट करें
2. निर्दिष्ट करें कि इस सेल में मान कैसे बदलेगा।
3. एक कंडीशन लिखी थी जिसके तहत लूप बॉडी को एक्जीक्यूट किया जाएगा
व्यावहारिक भाग में, हम हैलो शब्द को 10 बार प्रदर्शित करने का प्रयास करेंगे। निम्नलिखित कार्यों में, हम इस निर्माण का अधिक विस्तार से विश्लेषण करेंगे।
|
फॉर लूप बार-बार की जाने वाली क्रियाओं के माध्यम से आगे बढ़ने का माध्यम है। आइए करीब से देखें कि यह कैसे काम करता है।
आमतौर पर, लूप के लिए के भाग निम्न चरणों का पालन करते हैं:
1. आरंभिक मान सेट करें।
2. वह चरण सेट करना जिससे लूप चर बदलेगा
3. अंतिम मान सेट करना।
3. लूप क्रियाएँ निष्पादित करें।
4. परीक्षण में उपयोग किए गए मान अपडेट करें।
और फिर शर्त पूरी होने तक चरण 2-4 दोहराए जाते हैं। जैसे ही कंडीशन झूठी हो जाती है, लूप समाप्त हो जाता है और लूप स्टेटमेंट के बाद का स्टेटमेंट निष्पादित हो जाता है।
आइए हम लूप स्टेटमेंट के सामान्य रूप पर लौटते हैं और सभी भागों का अधिक विस्तार से विश्लेषण करते हैं
<पूर्व>
for *सेट इनिशियल वैल्यू टू वेरिएबल* टू/डाउनटू *एंड वैल्यू* शुरू करें
/*एक स्टेटमेंट या स्टेटमेंट का ब्लॉक - लूप बॉडी*/;
अंत;
वेरिएबल को शुरुआती वैल्यू पर सेट करना
चक्र चर (काउंटर) के प्रारंभिक मान को सेट करने के लिए ज़िम्मेदार है, कोष्ठक या कुछ और के साथ हाइलाइट नहीं किया गया है
उदाहरण के लिए :
<पूर्व>
मैं: = 0; // चक्र चर i को शून्य के बराबर प्रारंभिक मान दिया गया है। इस तरह के रिकॉर्ड के साथ,
// चर i को लूप से पहले घोषित किया जाना चाहिए
से/नीचे
<पूर्व>
यह वह चरण है जिस पर लूप में प्रयुक्त वेरिएबल बदल जाएगा। यदि हम लिखते हैं, तो प्रत्येक पुनरावृत्ति चर के मान में 1 की वृद्धि होगी, यदि नीचे - 1 से घट जाती है
<पूर्व>
अंतिम मूल्य
वह अंतिम मान है जिस पर लूप की बॉडी अभी भी निष्पादित की जाएगी। उदाहरण के लिए, यदि हम अंतिम मान को 100 पर सेट करते हैं, तो 100 पर हमारा लूप अभी भी निष्पादित होगा, और 101 पर यह नहीं होगा।
आइए लूप के लिए शीर्षक लिखने का अभ्यास करें
|
पास्कल में for लूप के शीर्ष में कई भाग होते हैं:
1) शब्द के लिए
2) हम किस चर और किस मूल्य को निर्दिष्ट कर रहे हैं। इस प्रोग्राम में, यह b := 1 है, यानी हम b को 1 मान देते हैं।
3) शब्द to या downto, जो उस चरण को इंगित करता है जिसके साथ लूप निष्पादित किया गया है। यदि हम लिखते हैं, तो चर प्रत्येक पुनरावृत्ति में 1 से बढ़ जाएगा, यदि कम हो जाता है, तो 1 से घट जाएगा।
4) वेरिएबल का अंतिम मान
5) शब्द करें
6) शब्द शुरू (लूप बॉडी में केवल एक पंक्ति होने पर इसे छोड़ा जा सकता है, अन्यथा इसे लिखा जाना चाहिए। यदि आप प्रारंभ नहीं लिखते हैं, तो केवल पहली पंक्ति होगी लूप के पूरे शरीर से निष्पादित किया जाएगा)। चलो लूप बॉडी के बाद मत भूलना, अगर हमने शब्द शुरू लिखा है, तो अंत; शब्द लिखें !
|
for लूप वाले सभी प्रोग्राम जिन्हें हमने अभी तक लिखा है उन्हें यूनिवर्सल नहीं कहा जा सकता है। क्योंकि हम लूप बॉडी के दोहराव की संख्या स्वयं निर्धारित करते हैं।
लेकिन क्या होगा अगर दोहराव की संख्या किसी अन्य मूल्य पर निर्भर करती है? उदाहरण के लिए, उपयोगकर्ता स्वयं चक्र के दोहराव की संख्या निर्धारित करना चाहता है।
ऐसे में क्या करें?
सब कुछ बहुत आसान है। संख्यात्मक प्रारंभ और समाप्ति मानों के बजाय, हम ऐसे किसी भी चर का उपयोग कर सकते हैं जिसकी गणना या उपयोगकर्ता द्वारा सेट की जा सकती है।
उदाहरण के लिए, हमें 1 से n तक की संख्याओं के वर्गों को प्रदर्शित करने की आवश्यकता है, जहां उपयोगकर्ता द्वारा कीबोर्ड से वेरिएबल n का मान दर्ज किया जाता है।
कार्यक्रम कुछ इस तरह दिखेगा:
<पूर्व>
वर मैं, एन: पूर्णांक; // बुंदाबांदी में; पाश चर, n - अधिकतम संख्या जिसके लिए हम वर्ग की गणना करते हैं
शुरू
पढ़ें (एन); // इनपुट n कीबोर्ड से
for i := 1 to n do // लूप: सभी i से 1 से n - वेरिएबल के लिए मैं क्रमिक रूप से 1 से n तक मान लूंगा
राइटलन ('कवद्रत चिस्ला', आई, 'रेवेन', आई * आई); // किसी संख्या के वर्ग को एक विशिष्ट प्रारूप में आउटपुट करना और एक नई पंक्ति में जाना
अंत।
लूप में प्रवेश करते समय, कथन i := 1 निष्पादित किया जाता है, और फिर चर i को प्रत्येक चरण के साथ एक (to) से बढ़ाया जाता है। लूप निष्पादित किया जाता है जबकि स्थिति i <= n सत्य है। लूप की बॉडी में, केवल आउटपुट स्टेटमेंट ही संख्या और उसके वर्ग को निर्दिष्ट प्रारूप के अनुसार स्क्रीन पर प्रिंट करता है।
वर्ग करने या अन्य निम्न घातांकों के लिए, गुणन का उपयोग करना बेहतर होता है।
प्रोग्राम को चलाएं और चर n के विभिन्न मूल्यों के साथ इसके काम का परिणाम देखें।
|