लूप के लिए कैसे बाहर निकलें। लूप के लिए और जबकि, ब्रेक और स्टेटमेंट जारी रखें, जादू शब्द और। जादू शब्द अन्य

प्रोग्रामिंग

टर्बो पास्कल में साइकिल का एक विशेष स्थान है। वे स्क्रीन पर इनपुट-आउटपुट जानकारी के कौशल पर काम करने के तुरंत बाद अध्ययन करना शुरू कर देते हैं। आखिरकार, अधिकांश कार्य इस तथ्य के लिए नीचे आते हैं कि एक पैरामीटर और अन्य निर्माण वाले चक्र एक निश्चित प्रोग्राम ब्लॉक के लेखन और संचालन को सुविधाजनक बनाने में मदद करते हैं।

चक्र की किस्में

कुल तीन किस्में हैं:

इस पाठ में हम सीखेंगे कि पीसना क्या है। पीसने से हमें चीजों को दोहराने की क्षमता मिलती है और यदि आवश्यक हो, तो उन्हें विशिष्ट परिस्थितियों में बांधें। तो कहने के लिए, यदि नियंत्रण संरचना दोहराव के साथ है, जब तक कि तुलना सत्य न हो। यह सूचकांक आमतौर पर एक शर्त को परिभाषित करने के लिए प्रयोग किया जाता है।

प्रत्येक पीस चक्र के बाद सूचकांक को ही बढ़ाया या घटाया जाना चाहिए। हम कीवर्ड को सीधे वैरिएबल डिक्लेरेशन और इनिशियलाइज़ेशन के बाद लिखते हैं। हम अपने इंडेक्स वेरिएबल को केवल "इंडेक्स" कहते हैं। हम स्थिति विवरण से अर्धविराम के साथ आरंभीकरण को अलग करते हैं और अपनी स्थिति लिखते हैं, जो यह सुनिश्चित करता है कि लूप तब तक जारी रहे जब तक कि तुलना सही न हो। फिर से हमें एक अर्धविराम बनाना है और उसके बाद हम अपना वेतन वृद्धि जोड़ेंगे।

पैरामीटर के साथ
एक पूर्व शर्त के साथ
एक पोस्टकंडीशन के साथ।

एक पैरामीटर के साथ लूप, अन्यथा के रूप में जाना जाता है ... से ... करो या के लिए ... नीचे ... के रूप में। करें, क्रियाओं के एक निश्चित क्रम को बार-बार दोहराएं। सिद्धांत रूप में, अन्य किस्मों का उपयोग उसी उद्देश्य के लिए किया जाता है, केवल फॉर-लूप में चरणों की संख्या पहले से ज्ञात होती है।

अन्य दो निर्माणों (जबकि और दोहराना) में, पुनरावृत्तियों की संख्या शुरू में अज्ञात है। इसलिए, कार्य का अध्ययन करते समय, यह समझना आवश्यक है कि किस चक्र का उपयोग किया जाएगा।

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

लूप टूटा हुआ है और निम्न कोड निष्पादित किया गया है। हमारे नियम के अनुसार वेतन वृद्धि बढ़ती है। आप यह भी कह सकते हैं कि हमारे पास एक पास नहीं है। यदि ऐसा है, तो वर्तमान रन को छोड़ दें। हमारे पास एक कीवर्ड है जिसके बाद एक वेरिएबल "नंबर" है जो केवल लूप में उपलब्ध है। इसके बाद एक कीवर्ड आता है जिसमें हम एक तथाकथित इटरेटर के साथ एक ऑब्जेक्ट पास करते हैं।

विषय पर बुनियादी परिभाषाएँ

मापदंडों के साथ लूप कई पुनरावृत्तियों हैं। काउंटर मुख्य संकेतक है जिसके साथ दिया गया निर्माण किया जाता है। अंतराल की सीमाएं उन सीमाओं को दर्शाती हैं जिनके भीतर कुछ पुनरावृत्तियों का प्रदर्शन किया जाएगा। वैसे, यह बिल्कुल आवश्यक नहीं है कि प्रारंभिक मान 1 के बराबर हो। उपयोगकर्ता स्वतंत्र रूप से अंतराल की दोनों सीमाओं को निर्धारित करता है। लूप बॉडी कमांड का एक सेट है जिसके लिए दोहराव की संख्या पहले ही निर्धारित की जा चुकी है।

इटरेटर किस प्रकार का होता है, हम बाद में जानेंगे। तो बोलने के लिए, संख्याओं का एक कंटेनर। पहली संख्या निर्धारित करती है कि संख्याओं की सीमा कहाँ से शुरू होती है। दूसरा नंबर नंबर माइनस वन है जहां यह समाप्त होता है। सच में, संख्या 5 के साथ समाप्त नहीं होती है, लेकिन शुरुआत अभी भी थोड़ी भ्रमित करने वाली है, लेकिन चाल जल्दी दौड़ती है!

ऑब्जेक्ट ओरिएंटेशन चैप्टर में हम सीखेंगे कि किस तरह के एरेज़ हैं। एक बार जब हम लूप को परिभाषित कर लेते हैं, तो अब हम प्रत्येक रन पर निष्पादित होने के लिए कोड का अपना ब्लॉक लिखेंगे। जैसे ही हमारे कंटेनर की नोक पहुँचती है यह समाप्त हो जाता है।

एक लेखन शैली भी है जिसमें दो बिंदुओं के बजाय तीन बिंदु और एक छोटा प्रतीक है। फिर चक्र छठे तत्व के साथ समाप्त होता है। एक शर्त के बाद एक कीवर्ड लिखें। इस लूप का लाभ यह है कि स्थिति की जाँच से पहले कम से कम एक बार कोड के ब्लॉक को निष्पादित किया जाता है।

"पैरामीटर के साथ लूप" की अवधारणा का अर्थ है कि इस निर्माण में एक शर्त की जांच की जाती है, जिसके बाद पुनरावृत्तियों का एक सेट किया जाता है। काउंटर वेतन वृद्धि (या कमी) और सब कुछ दोहराता है। लूप के शरीर को तब तक निष्पादित किया जाएगा जब तक कि स्थिति सही न हो।

के लिए ... से ... करना: कार्य एल्गोरिदम, वाक्यविन्यास

जैसा कि पहले ही उल्लेख किया गया है, एक पैरामीटर वाले चक्रों का उपयोग उन कार्यों में किया जाता है जिनमें एक "अंतराल" इंगित किया जाता है जिसमें काम करना है। तो, यह संख्याओं की एक सरणी, सप्ताह के दिन, एक कविता की पंक्तियाँ आदि हो सकती है।

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

टर्बो पास्कल: कैसे एक लूप से बाहर निकलने के लिए

हम अपने पहले अध्याय के अंत में आ गए हैं। अगले अध्याय में, हम उन ऑपरेटरों और खोजशब्दों पर करीब से नज़र डालेंगे, जिन्हें वस्तुओं को उन्मुख करने से पहले हमें जानना या जानना आवश्यक है। हमें श्रृंखला के पहले भाग पर आपकी प्रतिक्रिया सुनना अच्छा लगेगा! आपकी दृढ़ता के लिए धन्यवाद और स्विफ्ट सीखने का आनंद लेना जारी रखें!

डिज़ाइन 2 प्रकार के होते हैं: काउंटर को बढ़ाना और घटाना। पहली संरचना इस प्रकार लिखी जाएगी:

के लिये निवर्तमान चर := सीमा 1प्रति सीमा 2करना

लूप बॉडी;

यहां: संदर्भ। चरकिसी प्रोग्राम या ब्लॉक की शुरुआत में उपयोगकर्ता द्वारा घोषित; सीमा 1 और सीमा 2- अंतराल का प्रारंभिक और अंतिम मूल्य; में तन चक्रकार्यक्रम द्वारा किए जाने वाले कार्यों का एक सेट निर्दिष्ट करता है। यह याद रखना चाहिए कि यदि लूप के शरीर में केवल 1 कमांड है, तो ऑपरेटर ब्रैकेट शुरू होता है ... अंत छोड़ा जा सकता है। डिजाइन के इस संस्करण में, काउंटर, अर्थात्<исх.переменная>, 1 की वेतन वृद्धि में वृद्धि होगी।

एक विशिष्ट संरचना इस तरह दिखती है। पंक्ति 2 सभी शर्तों को सूचीबद्ध करती है। ब्रैकेट के अंदर अर्धविराम ";" द्वारा अलग किए गए 3 ब्लॉक हैं। यह सुनिश्चित करता है कि हमारा लूप 10 पास में पूरा होगा। . जब आप इस उदाहरण को चलाते हैं, तो आपको एक लंबवत अनुक्रम दिखाई देगा संख्या 0-9. काउंटर वैरिएबल लूप का दिल है, क्योंकि यह काउंटर का मान है जो लूप को बताता है कि इसे कब समाप्त होना चाहिए।

लूप लूप

इस खंड में, हमने नामों की एक सरणी बनाई है। कंटेनरों को मैन्युअल रूप से कॉल करने के बजाय, हम एक लूप का उपयोग करते हैं जो हमारे लिए सभी कंटेनरों को प्रदर्शित करता है। यदि लूप यह निर्धारित करता है कि इसके काउंट वेरिएबल का मान 5 है, तो यह अब निष्पादन क्षेत्र में प्रवेश नहीं करता है। निम्नलिखित उदाहरण को देखें। यह अभी भी एक सरल उदाहरण है, लेकिन कभी-कभी इसमें कीड़े रेंगते हैं जो खोजने में उतनी जल्दी नहीं होते हैं।

के लिये निवर्तमान चर:= सीमा 1नीचे तक सीमा 2करना

लूप बॉडी;

यहाँ रेफरी है। चर 1 की वृद्धि में घट जाएगा।

फॉर ... टू ... डू पैरामीटर के साथ लूप की योजना इस तरह दिखेगी:

अंतराल की ऊपरी सीमा का मान निर्धारित किया जाता है, अर्थात। सीमा 2.

स्रोत चरपैरामीटर मान असाइन किया गया है सीमा 1.

स्थिति की जाँच की जाती है: कच्चा चर सीमा 2.

परिणाम प्राप्त होने पर सत्य (सत्य) लूप बॉडी निष्पादित की जाती है।

काउंटर 1 से बढ़ा है।

प्रदर्शन अंक 3-5तब तक होता है जब तक कि स्थिति सत्य न हो: स्रोत चर > सीमा 2. जैसे ही ऐसा होता है, लूप बाहर निकल जाता है और इस निर्माण के बाद नियंत्रण को कमांड में स्थानांतरित कर दिया जाता है।

For ... downto ... do में, कार्य का एल्गोरिथ्म कुछ बिंदुओं के अपवाद के साथ उपरोक्त के समान है:

दूसरी ओर, आपको अनंत लूप जल्दी मिलते हैं, क्योंकि यदि आप अपनी स्क्रिप्ट का परीक्षण करते हैं और समाप्त नहीं करते हैं, तो यह आमतौर पर एक अनंत लूप होता है। संकल्पनात्मक लूप ऐसे आदेश हैं जिन्हें कुछ राज्य अनुमानों के अनुसार कई बार निष्पादित किया जाएगा। लूप को निष्पादित करने के लिए एक इनपुट स्थिति का उपयोग किया जाता है। प्रस्तावों में कुछ ऐसे भी होने चाहिए जो स्थिति को बदल दें। निर्देशों के अनुक्रम को दोहराने के लिए यह लूप सबसे अधिक उपयोग किया जाता है। लूप निर्देश पूरे कार्यक्रम या कार्यक्रम के एक विशिष्ट भाग को एक से अधिक बार दोहराने की समस्या को हल करते हैं। दौड़ना।

तीसरे पैराग्राफ में, स्थिति की जाँच की जाती है: स्रोत चर सीमा 2.

एल्गोरिथम की 5वीं पंक्ति में, काउंटर को 1 से घटाया जाता है।

छठे पैराग्राफ में टीमें 3-5शर्त पूरी होने तक निष्पादित किया जाएगा: निवर्तमान चर< граница 2.

बाकी सब कुछ दोनों कार्य एल्गोरिदम में समान है।

स्थिति सरल या जटिल हो सकती है। निर्देशों का एक विशिष्ट समूह एक निर्देश या निर्देशों का एक पूरा समूह हो सकता है। इस कारण से इसे समाप्ति चक्र के रूप में भी जाना जाता है। लूप्स किसी चीज़ को बार-बार करने का त्वरित और आसान तरीका प्रदान करते हैं।

कई अलग-अलग प्रकार के लूप हैं, लेकिन वे सभी एक ही काम करते हैं: एक क्रिया को कई बार दोहराना। विभिन्न चक्र भी प्रदान करते हैं विभिन्न तरीकेप्रारंभ और अंत बिंदुओं को परिभाषित करना। ऐसी कुछ स्थितियां हैं जिन्हें एक प्रकार के लूप से दूसरों की तुलना में संभालना आसान होता है।

फैसले के लिए। यह अभिव्यक्ति आमतौर पर एक या एक से अधिक लूप काउंटर को इनिशियलाइज़ करती है, लेकिन सिंटैक्स किसी भी डिग्री की जटिलता को व्यक्त करने की अनुमति देता है। यदि व्यंजक शर्त को छोड़ दिया जाता है, तो शर्त को सत्य माना जाता है। आवेदन पूरा हुआ। कई कथनों को निष्पादित करने के लिए, उन्हें एक साथ समूहित करने के लिए एक स्टेटमेंट ब्लॉक का उपयोग करें।

यह अभिव्यक्ति चर भी घोषित कर सकती है।
अभिव्यक्ति की स्थिति व्यक्त की जा रही है।
यदि शर्त मान सत्य है, तो लूप स्टेटमेंट निष्पादित किया जाता है।

मेनू में निहित विकल्पों को उन वस्तुओं द्वारा दर्शाया जाता है जिन्हें आइटम द्वारा समूहीकृत किया जा सकता है।

पैरामीटर के साथ लूप ब्लॉक आरेख

एक पैरामीटर के साथ साइकिल है अगला दृश्यब्लॉक आरेख (हालाँकि यह पहले ही ऊपर प्रस्तुत किया जा चुका है)। एक सरलीकृत डिजाइन संगठन भी यहां दिखाया गया है।

एक पैरामीटर के साथ चक्र के लिए बुनियादी आवश्यकताएं

पैरामीटर वाले लूप को कुछ खास तरह की शर्तों की ज़रूरत होती है।

स्थिति का मूल्यांकन करने से पहले कथन निष्पादित किया जाता है। यदि शर्त सत्य है, तो कथन को फिर से निष्पादित किया जाता है। प्रत्येक रन के अंत में, स्थिति की जाँच की जाती है। लूप में निहित कथन के निष्पादन से पहले स्थिति का मूल्यांकन किया जाता है। सुनिश्चित करें कि लूप में स्थिति अंततः झूठी हो जाती है; अन्यथा, लूप कभी खत्म नहीं होगा।

एक लेबल एक पहचानकर्ता के साथ एक बयान प्रदान करता है जो आपको इसे अपने कार्यक्रम में कहीं से भी संदर्भित करने की अनुमति देता है। लेबल ऑपरेटर सिंटैक्स। आप जिस ऑफ़र को लेबल से पहचानते हैं, वह कोई भी ऑफ़र हो सकता है। जब आप बिना लेबल वाले ब्रेक का उपयोग करते हैं, तो समय में संलग्न कोड को तुरंत समाप्त कर दें, हमेशा के लिए, या स्विच करें और अगले स्टेटमेंट पर नियंत्रण स्थानांतरित करें। वाक्यविन्यास का पहला रूप लूप या स्विच में लपेटा जा रहा है; लेबल स्टेटमेंट द्वारा निर्दिष्ट के रूप में दूसरा समाप्त होता है।

काउंटर और स्पैन की सीमा (यानी, स्रोत चर, बाउंड 1, और बाउंड 2) एक ही डेटा प्रकार का होना चाहिए। यदि अंतराल के प्रारंभ और अंत मूल्यों और मूल चर के बीच केवल संगतता है, तो प्रोग्राम गलत तरीके से व्यवहार कर सकता है, क्योंकि सीमाओं को मूल पैरामीटर के डेटा प्रकार के अनुसार परिवर्तित किया जाएगा।

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

लूप बॉडी में प्रारंभिक चर पैरामीटर के मान को बदलना अवांछनीय है। अन्यथा, उपयोगकर्ता दिखाई देने वाली संभावित त्रुटियों को शायद ही ट्रैक कर पाएगा।

अन्य प्रकार के लूपों के विपरीत, For … to… do या For … downto… do में चरण 1 के अलावा किसी अन्य पैरामीटर में नहीं बदल सकता है।

टर्बो पास्कल: कैसे एक लूप से बाहर निकलने के लिए

अक्सर ऐसी समस्याएं होती हैं जिनमें लूपिंग होती है, यानी जाँच की जा रही स्थिति हमेशा सत्य होती है। ब्रेक प्रक्रिया पूर्व शर्त, पोस्टकंडीशन, पैरामीटर के साथ लूप से बाहर निकलने में मदद करती है। यानी उनका काम तय समय से पहले ही खत्म कर दिया जाता है।

उदाहरण 2: लेबल उल्लंघन

निम्न उदाहरण एक सरणी के तत्वों के माध्यम से पुनरावृति करता है जब तक कि यह पता नहीं चलता कि उस तत्व का सूचकांक जिसका मूल्य मूल्य है। जब आप किसी टैग के साथ निरंतरता का उपयोग करते हैं, तो यह टैग के साथ पहचाने गए नेस्टेड स्टेटमेंट को संदर्भित करता है। यदि यह जारी रहता है, तो प्रोग्राम चेक के दौरान पुनरावृत्ति को समाप्त कर देगा और अगला पुनरावृत्ति प्रारंभ करेगा। निम्न फ़ंक्शन ऑब्जेक्ट और ऑब्जेक्ट का नाम तर्क के रूप में लेता है। यह तब वस्तु के सभी गुणों के माध्यम से पुनरावृति करता है और संपत्ति के नामों और उनके नामों को सूचीबद्ध करते हुए एक स्ट्रिंग देता है।

पास्कल पैरामीटर लूप (जिसकी प्रोग्रामिंग स्थिति की "शाश्वत" सच्चाई मानती है) को जारी रखें के साथ रोका जा सकता है। यहां, कार्य निम्नानुसार सेट किया गया है: वर्तमान पुनरावृत्ति अपने निष्पादन को समय से पहले पूरा करती है, नियंत्रण अगले आदेश में स्थानांतरित कर दिया जाता है, लेकिन लूप से बाहर निकले बिना।

प्रोग्राम कोड में किसी विशेष ब्लॉक के कार्य को पूरा करने के लिए निकास प्रक्रिया आवश्यक है। इसे एक प्रक्रिया (फ़ंक्शन) के अंदर कहा जाता है और साथ ही, इस "टुकड़े" का निष्पादन तुरंत बंद हो जाता है। यदि Exit प्रोग्राम के मेन ब्लॉक में है तो यह अपना काम खत्म कर देता है।

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

जादू शब्द अन्य

शब्द "लूप" एक नियंत्रण संरचना को संदर्भित करता है जो निर्देशों के समान अनुक्रम को एक या अधिक शर्तों के अनुसार एक निश्चित संख्या में निष्पादित करने में सक्षम है जिसे जांचना चाहिए। लूप से बाहर निकलने में सक्षम होने के लिए यह जांचना हमेशा आवश्यक होगा कि किसी निश्चित क्षण में स्थितियां झूठी हो जाती हैं।

हॉल्ट प्रक्रिया संचालन के सिद्धांत को निम्न तक कम कर देती है: कार्यक्रम पूरी तरह से समाप्त हो जाता है।

समाधान के साथ कार्यों के उदाहरण

"पास्कल में एक पैरामीटर के साथ लूप्स" विषय का अध्ययन करने के बाद, उपयोगकर्ता के लिए पहले उदाहरणों का अध्ययन करना, और फिर कोड को स्वयं लिखने के लिए प्रशिक्षित करना उपयोगी होगा। सरल कार्य भविष्य के प्रोग्रामर को सिद्धांत को व्यवहार में सीखने में मदद करते हैं, और फिर इसे सफलतापूर्वक लागू करते हैं। "पैरामीटर के साथ लूप्स" विषय पर, समाधान के साथ समस्याओं के उदाहरण आसान और जटिल दोनों मिल सकते हैं। यहां 3 कार्य हैं जिनमें कार्य के एल्गोरिदम का विश्लेषण किया जाता है और प्रत्येक समाधान के लिए स्पष्टीकरण और टिप्पणियां दी जाती हैं।

यह सबसे प्रसिद्ध लूप है क्योंकि यह अधिकांश प्रोग्रामिंग भाषाओं में मौजूद है। हमने स्प्रैडशीट ट्यूटोरियल में इसका उल्लेख पहले ही कर लिया है, लेकिन हम इस पाठ्यक्रम में बाद में वापस आएंगे। दूसरे शब्दों में, एक मान जो स्थिति को गलत बना देगा और लूप को रोक देगा। इसका सिंटैक्स सरल है और इसके लिए 3 आवश्यक मापदंडों की आवश्यकता होती है।

लूप जारी है या लूप को अनदेखा किया गया है या नहीं यह निर्धारित करने के लिए प्रत्येक पुनरावृत्ति पर इस स्थिति का पुनर्मूल्यांकन किया जाता है। अंत में, अंतिम पैरामीटर पुनरावृत्ति के अंत में निष्पादित किए जाने वाले व्यंजक को निर्दिष्ट करता है। आमतौर पर, लूप काउंटर को अपडेट करने के लिए यहां एक इंक्रीमेंट जोड़ा जाता है।

इनिशियलाइज़ेशन एक एक्सप्रेशन है जिसका उपयोग लूप को इनिशियलाइज़ करने के लिए किया जाता है।
लूप आमतौर पर एक मान से शुरू होते हैं।
दूसरा पैरामीटर लूप को रोकने की स्थिति से मेल खाता है।

निम्न उदाहरण अंक गुणन तालिका की पीढ़ी को दर्शाता है।

कार्य 1

यादृच्छिक रूप से चुने गए श्रेणी में प्राकृतिक संख्याओं के द्वि-आयामी सरणी को देखते हुए। उन सभी दो अंकों वाली संख्याओं की संख्या ज्ञात कीजिए जिनके अंकों का योग 2 का गुणज है।

क्रिया एल्गोरिथ्म:

एक द्वि-आयामी सरणी बनाएं।
शर्तों के अनुपालन के लिए प्रत्येक नंबर की जाँच करें:

ए) अगर 9< Х < 100, то разделить его нацело на 10 посредством div;

हमने एक चक्र स्थापित किया है। . जब यह गलत हो जाता है, तो प्रोग्राम लूप से बाहर निकल जाएगा। इसका सिंटैक्स इस प्रकार है। डेटाबेस से जानकारी निकालते समय यह विशेष रूप से उपयोगी होता है। इस दावे की ख़ासियत यह है कि कमांड ब्लॉक के पूर्ण निष्पादन के बाद ही स्थिति की जाँच की जाती है। यदि शर्त समाप्त होने से पहले झूठी हो जाती है, तो शेष निर्देशों को निष्पादित किया जाएगा।

के लिए ... से ... करना: कार्य एल्गोरिदम, वाक्यविन्यास

डिफ़ॉल्ट मान अपरिवर्तित रहता है, अर्थात्: फिर हम स्टॉप कंडीशन को परिभाषित करते हैं। फिर हम निष्पादित किए जाने वाले आदेशों की सूची को परिभाषित करते हैं, अर्थात गणना, उत्पाद प्रदर्शन और काउंटर जोड़।

आइए काउंटर को एक मान पर सेट करके शुरू करें।
हम लूप को छोड़ने या न छोड़ने की स्थिति के परीक्षण के साथ समाप्त करते हैं।

अधिकांश प्रोग्रामिंग भाषाओं में, लूप का उपयोग करके एक सरणी पथ लागू किया जाता है। यह एक विशेष लूप है जो प्रत्येक पुनरावृत्ति पर सरणी सूचक को आगे बढ़ाता है।

बी) मॉड के माध्यम से विभाजित करके संख्या का दूसरा अंक निकालें;

ग) हाइलाइट की गई संख्याओं को जोड़ें;

डी) मॉड द्वारा दी गई राशि को 2 से विभाजित करें;

ई) यदि परिणाम 0 है, तो काउंटर 1 से बढ़ जाता है।

टास्क 2

पूर्णांक तत्वों की एक-आयामी सरणी को देखते हुए। सकारात्मक संख्याओं की संख्या ज्ञात कीजिए।

क्रिया एल्गोरिथ्म:

यादृच्छिक द्वारा उत्पन्न पूर्णांक तत्वों की एक सरणी बनाएं।
IF को पैरामीटर के साथ लूप में संलग्न करें, जो इस शर्त के अनुपालन के लिए दिए गए तत्व की जांच करेगा: X>0।
यदि शर्त पूरी हो जाती है, तो काउंटर को 1 से बढ़ा दिया जाता है।
लूप के बाद, परिणामी काउंटर मान स्क्रीन पर प्रदर्शित होना चाहिए।

कोष्ठक () में डेटा टिप्पणियाँ हैं। पंक्ति 11 में, आप स्क्रीन पर सरणी को दो तरीकों से प्रदर्शित कर सकते हैं: संख्याओं के बीच एक स्थान छोड़ दें, या प्रत्येक तत्व के लिए एक निश्चित संख्या में कक्ष आवंटित करें (इस मामले में, उनमें से 5 हैं)।

पंक्ति 12 में, काउंटर चर को दो तरीकों से भी बढ़ाया जा सकता है: या तो पिछले मान में 1 जोड़ें, या मानक इंक फ़ंक्शन का उपयोग करें।

टास्क 3

एक वर्ग मैट्रिक्स दिया गया है। मुख्य विकर्ण पर धनात्मक तत्वों की संख्या ज्ञात कीजिए।

स्पष्टीकरण:

संख्याओं की एक सरणी में, मुख्य विकर्ण ऊपरी बाएँ कोने से नीचे दाईं ओर फैला होता है। इसकी ख़ासियत यह है कि पंक्ति और स्तंभ सूचकांक समान हैं। इसलिए, शेष तत्वों पर पुनरावृति किए बिना लाइनों के माध्यम से जाने के लिए 1 चक्र को व्यवस्थित करना पर्याप्त है।

क्रिया एल्गोरिथ्म:

एक वर्ग मैट्रिक्स बनाएँ।
सकारात्मक तत्वों की गणना के लिए जिम्मेदार चर को "0" पर सेट करें।
एक वर्ग मैट्रिक्स बनाने के लिए एक चक्र बनाएं।
स्थिति की जांच के लिए एक लूप व्यवस्थित करें: यदि मुख्य विकर्ण पर संख्या> 0 है, तो काउंटर 1 से बढ़ जाता है।
लूप के अंत के बाद, वेरिएबल का मान प्रदर्शित करें जो स्क्रीन पर सकारात्मक तत्वों की संख्या को संग्रहीत करता है।

दो प्रोग्रामिंग भाषाओं का टकराव: सी और टर्बो पास्कल

एक नियम के रूप में, एक स्वाभिमानी प्रोग्रामर कई भाषाओं को जानता है। उदाहरण के लिए, यह C++, Turbo Pascal, Delphi, Java, आदि हो सकता है। उन दोनों का विरोध स्पष्ट रूप से 80 के दशक में वापस व्यक्त किया गया था। (सी और टर्बो पास्कल)। 20वीं सदी के अंत में C++ और Java के बीच भी यही संघर्ष देखने को मिला।

वर्चुअल स्पेस में, तीन दर्जन प्रोग्रामिंग भाषाओं में, तीन सबसे चमकीले जोड़े को प्रतिष्ठित किया जा सकता है, जिसके विरोध ने साइबर स्पेस के महानतम दिमागों को चकित कर दिया: अल्गोल -60 और फोरट्रान, पास्कल और सी, जावा और सी ++। बेशक, ये भावनाएँ व्यक्तिपरक हैं, लेकिन एक समय या किसी अन्य जोड़ी में से एक नेता था। यह उद्योग की आवश्यकताओं और एक या दूसरे की आवश्यकता के कारण था सॉफ्टवेयर उत्पाद. 70 के दशक में। फोरट्रान ने "दुनिया पर राज किया", 80 के दशक में - टर्बो पास्कल, 90 के दशक में - सी ++। बेशक, उनमें से कोई भी "मर गया" नहीं। बल्कि, वे बेहतर सॉफ्टवेयर उत्पादों में विकसित हुए हैं।

प्रोग्रामिंग भाषाओं का अध्ययन करते समय, आप देखेंगे कि कुछ विषयों में वाक्य रचना समान है। तो, सी में पैरामीटर वाले लूप पास्कल में समान निर्माण के समान होते हैं, कुछ बिंदुओं के अपवाद के साथ।

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

लूप्स का उपयोग कोड के टुकड़ों को कई बार दोहराने के लिए किया जाता है। कुछ कोड अंशों को दोहराने की क्षमता मुख्य और एक ही समय में से एक है महत्वपूर्ण कार्यजिसे प्रोग्रामर को तय करना होता है। अधिकांश प्रोग्राम या साइटें लूप का उपयोग करती हैं, उदाहरण के लिए, समाचार जानकारी या घोषणाएं प्रदर्शित करने के लिए। यही है, ऐसे कार्यों में लगातार पढ़ना और लिखना आवश्यक है, और समान कोड की नकल न करने के लिए, चक्र बचाव के लिए आते हैं। कोड में घोषित करने के लिए लूप काफी सरल हैं, लेकिन वे जटिल कार्यों को केवल सरल दोहराव के साथ करते हैं।

लूप के साथ आरंभ करने के लिए, सुनिश्चित करें कि आपको सी प्रोग्रामिंग भाषा में अवधारणा की अच्छी समझ है। क्योंकि यह चक्रों के उपयोग में महत्वपूर्ण होगा, क्योंकि चक्रों में और साथ ही साथ सशर्त अभिव्यक्तियाँ होती हैं। सी में तीन प्रकार के लूप हैं: के लिए, जबकि, करते समय। उनमें से प्रत्येक के अपने विशिष्ट उपयोग हैं। उन सभी का वर्णन नीचे किया गया है।

सबसे अधिक इस्तेमाल किया जाने वाला लूप फॉर लूप है, इसकी संरचना नीचे दिखाई गई है:

के लिए (/* वेरिएबल इनिशियलाइज़ेशन; कंडीशन; एक वेरिएबल का मान बदलना */) (// लूप बॉडी (यहां वह कोड है जिसे दोहराया जाएगा))

वेरिएबल इनिशियलाइज़ेशन आपको या तो एक वेरिएबल घोषित करने और इसके लिए एक वैल्यू असाइन करने की अनुमति देता है, या पहले से मौजूद वेरिएबल के लिए एक वैल्यू असाइन करता है। दूसरा, इस वेरिएबल का मान प्रोग्राम को बताता है कि लूप कंडीशन सही है या गलत। और जब तक लूप की स्थिति सही है, लूप को दोहराना जारी रखना चाहिए। नियंत्रण चर को किसी भी तरह बदला जाना चाहिए, अन्यथा लूप अंतहीन होगा, उदाहरण के लिए, आप इसे इस तरह अपडेट कर सकते हैं: i++ , i = i + 2 या यहां तक कि i = random(5) । ध्यान दें कि लूप हेडर में प्रत्येक अनुभाग अर्धविराम से अलग होता है, जो बहुत महत्वपूर्ण है। यह भी ध्यान दें कि प्रत्येक अनुभाग खाली हो सकता है, हालांकि अर्धविराम अभी भी वहां होना चाहिए। यदि स्थिति खाली नहीं है, तो यह सत्य का मूल्यांकन करता है और लूप तब तक जारी रहेगा जब तक कि कुछ लूप की स्थिति को गलत न बना दे। आइए लूप के लिए उपयोग करने का एक सरल उदाहरण देखें।

#शामिल int main() ( int i; /* लूप i . तक चलेगा)< 10, при этом после каждой итерации переменная i будет инкрементироваться(увеличиваться на 1)*/ for (i = 0; i < 10; i++) { /* Имейте ввиду что условие проверяется перед каждым повторением, то есть работа цикла остановится когда переменная i будет равна 10*/ printf("%d\n", i); } getchar(); }

दरअसल, कार्यक्रम का परिणाम:

0 1 2 3 4 5 6 7 8 9

यह प्रोग्राम लूप का उपयोग करने का एक बहुत ही सरल उदाहरण है। वेरिएबल i को शून्य असाइन किया गया है, और जबकि i 10 से कम है, वेरिएबल i का मान स्क्रीन पर प्रिंट किया जाता है, फिर एक को वेरिएबल i में जोड़ा जाता है और सब कुछ फिर से दोहराया जाता है जब तक कि कंडीशन गलत न हो जाए। ध्यान रखें कि लूप के शरीर में कोड के निष्पादन के बाद पहली बार चलने वाले चर i का मान बढ़ जाता है।

जबकि लूप एक बहुत ही सरल लूप है, यहाँ इसकी संरचना है:

जबकि (/*condition*/) (// लूप का शरीर - यहाँ वह कोड है जिसे दोहराने की आवश्यकता है)

लूप की स्थिति सही होने पर लूप बॉडी निष्पादित करना शुरू कर देती है। शर्त एक बूलियन एक्सप्रेशन है, जैसे x == 1 या x! = 7 (x 7 के बराबर नहीं है)। यही है, शर्त बिल्कुल कुछ भी हो सकती है - तार्किक अभिव्यक्तियों का कोई भी संयोजन। यहाँ एक यौगिक स्थिति का उदाहरण दिया गया है - x == 3 || x > 10 , यह स्थिति सही होगी यदि x 3 के बराबर है या x 10 से अधिक है। ध्यान दें कि जबकि एक आरंभीकरण खंड या एक नियंत्रित चर परिवर्तन अनुभाग है, इसलिए इस लूप का उपयोग करने से पहले, आपको पहले एक चर घोषित करने की आवश्यकता है हालत लूप में परीक्षण किया जाएगा और लूप के शरीर में इस चर के मान को बदल देगा। असल में, आइए थोड़ी देर के लूप का उपयोग करके एक साधारण उदाहरण देखें:

#शामिल int main() ( int var = 0; /* पहले वेरिएबल घोषित करना सुनिश्चित करें */ जबकि (var< 10) { /* пока значение переменной var меньше 10 */ printf("%d\n", var); var++; /* обновляем значение в переменной var(если этого не делать, то условие цикла всегда будет истинным, тогда цикл будет - бесконечным) */ } getchar(); }

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

एक अन्य प्रकार का लूप है - करते समय। यह लूप तब उपयोगी होता है जब आपको कोड को कम से कम 1 बार निष्पादित करने की आवश्यकता होती है। इसकी संरचना पर विचार करें:

Do (// लूप बॉडी) जबकि (/*condition*/);

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

#शामिल int main() ( int i = 0; do (/* एक संदेश प्रिंट करें और बाहर निकलें */ printf ("हाय! मैं जबकि \ n" कर रहा हूं); ) जबकि (i! = 0); getchar (); )

लूप के अंत में अर्धविराम नोट करें, आपको हमेशा इस अर्धविराम का उपयोग करना चाहिए जैसा कि ऊपर दिए गए उदाहरण में है। बहुत बार इस अर्धविराम को छोड़ दिया जाता है, जिसके परिणामस्वरूप संकलन त्रुटि होती है। केवल यह चक्र अर्धविराम के साथ समाप्त होता है, अंत में शेष चक्र, समापन कोष्ठक को छोड़कर, कुछ भी नहीं डालते हैं। ध्यान दें कि ऊपर के उदाहरण में, यह लूप एक बार चलेगा क्योंकि संदेश पहले प्रिंट होता है और फिर लूप की स्थिति की जाँच की जाती है।