🥇मुश्किलों पर काबू पाना कैसे सिखाएं और साथ ही साइकिल कैसे लिखें

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

साइकिल के बारे में विषय इसलिए चुना गया क्योंकि प्रोग्रामिंग में महारत हासिल करते समय बहुत से लोगों को इससे बाहर रखा जाता है।

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

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

इतने सारे पत्र क्यों? साइकिलें बहुत प्राथमिक हैं!

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

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

मैं किसे और क्यों पढ़ाता हूँ?

चूंकि कोई प्रवेश परीक्षा नहीं होती, इसलिए कक्षाओं में मजबूत और बहुत कमजोर दोनों तरह के छात्र शामिल हो सकते हैं। आप लेख में मेरे छात्रों के बारे में अधिक पढ़ सकते हैं शाम के पाठ्यक्रम के छात्रों का चित्रण
मैंने यह सुनिश्चित करने का प्रयास किया कि जो कोई भी प्रोग्रामिंग सीखना चाहता है वह इसे सीख सके।
मेरी कक्षाएँ व्यक्तिगत रूप से आयोजित की जाती हैं और छात्र प्रत्येक के लिए अपना पैसा देता है। ऐसा प्रतीत होता है कि छात्र लागत का अनुकूलन करेंगे और न्यूनतम मांग करेंगे। हालाँकि, लोग ज्ञान के लिए नहीं, बल्कि जो उन्होंने सीखा है उस पर विश्वास करने, प्रगति की भावना और विशेषज्ञ (शिक्षक) से अनुमोदन के लिए एक जीवित शिक्षक के साथ आमने-सामने की कक्षाओं में जाते हैं। यदि छात्र अपने सीखने में प्रगति महसूस नहीं करते हैं, तो वे चले जाएंगे। सामान्य तौर पर, कक्षाओं को इस तरह से संरचित किया जा सकता है कि छात्र परिचित संरचनाओं की संख्या बढ़ाने में प्रगति महसूस करें। अर्थात् पहले हम विस्तार से अध्ययन करते हैं, फिर उसके लिए अध्ययन करते हैं, फिर उसके बाद करते हैं, और अब हमारे पास एक हजार एक रात का पाठ्यक्रम तैयार है, जिसमें दो महीने तक अकेले चक्र का अध्ययन किया जाता है, और अंत में - एक छात्र जिसने लिखा है श्रुतलेख के अंतर्गत एक मानक पुस्तकालय। हालाँकि, व्यावहारिक समस्याओं को हल करने के लिए, आपको न केवल सामग्री का ज्ञान होना चाहिए, बल्कि इसके अनुप्रयोग में स्वतंत्रता और नई जानकारी की खोज भी होनी चाहिए। इसलिए, आमने-सामने के पाठ्यक्रमों के लिए, मुझे लगता है कि सही सिद्धांत न्यूनतम पढ़ाना और बारीकियों और संबंधित विषयों के स्वतंत्र अध्ययन को प्रोत्साहित करना है। लूप्स के विषय में, मैं while निर्माण को न्यूनतम मानता हूँ। इससे आप सिद्धांत को समझ सकते हैं. सिद्धांत को जानकर, आप स्वयं के लिए और करते समय दोनों में महारत हासिल कर सकते हैं।

कमजोर छात्रों द्वारा सामग्री पर महारत हासिल करने के लिए वाक्यविन्यास का वर्णन करना पर्याप्त नहीं है। अधिक सरल लेकिन विविध कार्य देना और उदाहरणों का अधिक विस्तार से वर्णन करना आवश्यक है। अंततः, विकास की गति छात्र की अभिव्यक्ति को बदलने और पैटर्न की खोज करने की क्षमता से सीमित होती है। होशियार विद्यार्थियों के लिए अधिकांश कार्य उबाऊ होंगे। उनके साथ अध्ययन करते समय, आपको 100% समस्याओं को हल करने पर जोर देने की ज़रूरत नहीं है। मेरी सामग्री यहां देखी जा सकती है मेरा github. सच है, रिपॉजिटरी एक करामाती ग्रिमोयर की तरह है - मेरे अलावा कोई नहीं समझेगा कि क्या है, और यदि आप चेक में असफल हो जाते हैं, तो आप पागल हो सकते हैं

कार्यप्रणाली अभ्यास-उन्मुख है

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

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

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

उदाहरण की व्याख्या एक संवाद है जिसमें छात्र को यह सुनिश्चित करने के लिए प्रचार और क्रॉस-सत्यापन को वापस बुलाने की आवश्यकता है कि उसने सामग्री के एक हिस्से में महारत हासिल कर ली है।

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

जबकि या के लिए?

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

मेरी सामग्रियों में, लूप का विषय ब्रांचिंग के विषय का अनुसरण करता है। यदि और जबकि की बाहरी समानता हमें एक सीधा सादृश्य बनाने की अनुमति देती है: "जब हेडर में स्थिति सत्य होती है, तो बॉडी निष्पादित होती है।" चक्र की एकमात्र विशेषता यह है कि शरीर को कई बार क्रियान्वित किया जाता है।

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

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

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

स्वचालन का मुख्य विचार यह है कि हम किसी व्यक्ति के नियमित कार्य करने के लिए एक कंप्यूटर को सौंपते हैं। बुनियादी तकनीकों में से एक लूप लिखना है। इसका उपयोग तब किया जाता है जब किसी प्रोग्राम में कई समान दोहराई जाने वाली क्रियाएं एक पंक्ति में लिखी जाती हैं।

स्पष्ट, अंतर्निहित से बेहतर है

पहले लूपिंग कार्य में एक ही वाक्यांश को कई बार प्रदर्शित करना एक अच्छा विचार लग सकता है। उदाहरण के लिए:

हुर्रे, यह काम करता है!
हुर्रे, यह काम करता है!
हुर्रे, यह काम करता है!
हुर्रे, यह काम करता है!
हुर्रे, यह काम करता है!
हुर्रे, यह काम करता है!
हुर्रे, यह काम करता है!
हुर्रे, यह काम करता है!

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

दूसरे इसे कैसे समझाते हैं?

इंटरनेट पर अधिकांश शैक्षिक सामग्रियों में, चक्र का वाक्यविन्यास "व्याख्यान" के भाग के रूप में दिया गया है। उदाहरण के लिए,developer.mozilla.org (वर्तमान में) पर, while लूप के साथ कई अन्य निर्माणों का वर्णन किया गया है। इस मामले में, केवल डिज़ाइन ही टेम्पलेट के रूप में दिए गए हैं। उनके प्रक्षेपण के परिणाम को शब्दों में वर्णित किया गया है, लेकिन कोई चित्रण नहीं है। मेरी राय में, विषय की ऐसी प्रस्तुति ऐसी सामग्रियों की उपयोगिता को शून्य से कई गुना बढ़ा देती है। छात्र कोड को फिर से लिख सकता है और इसे स्वयं चला सकता है, लेकिन उसे तुलना के लिए अभी भी एक मानक की आवश्यकता है। आप यह कैसे समझ सकते हैं कि एक उदाहरण को सही ढंग से दोबारा लिखा गया है यदि परिणाम की तुलना करने के लिए कुछ भी नहीं है?
जब बिना किसी उदाहरण के केवल एक टेम्पलेट दिया जाता है, तो छात्र के लिए यह और भी कठिन हो जाता है। यह कैसे समझें कि कोड के टुकड़े टेम्पलेट में सही ढंग से रखे गए हैं? आप लिखने का प्रयास कर सकते हैं किसी न किसी तरह, और फिर चलाएँ। लेकिन अगर परिणाम की तुलना करने के लिए कोई मानक नहीं है, तो लॉन्च करने से भी मदद नहीं मिलेगी।

Intuitive पर C++ पाठ्यक्रम में, लूप सिंटैक्स "ऑपरेटर" विषय पर व्याख्यान 4 के तीसरे पृष्ठ में छिपा हुआ है। लूप के सिंटैक्स को समझाते समय, "ऑपरेटर" शब्द पर विशेष जोर दिया जाता है। यह शब्द "प्रतीक" जैसे तथ्यों के एक समूह के रूप में प्रस्तुत किया गया है; यह एक कथन है", "{} एक मिश्रित कथन है", "लूप का मुख्य भाग एक कथन होना चाहिए"। मुझे यह दृष्टिकोण पसंद नहीं है क्योंकि ऐसा लगता है कि यह महत्वपूर्ण रिश्तों को एक शब्द के पीछे छिपा देता है। इस स्तर पर प्रोग्राम के स्रोत कोड को शब्दों में पार्स करना कंपाइलर डेवलपर्स द्वारा भाषा विनिर्देश को लागू करने के लिए आवश्यक है, लेकिन छात्रों द्वारा पहले सन्निकटन के रूप में नहीं। प्रोग्रामिंग में नवागंतुक शायद ही कभी इतने सावधानीपूर्वक होते हैं कि शर्तों पर इतना ध्यान दे सकें। यह एक दुर्लभ व्यक्ति है जो पहली बार नए शब्दों को याद करता है और समझता है। लगभग कोई भी व्यक्ति अभी-अभी सीखे गए शब्द को सही ढंग से लागू नहीं कर सकता है। इसलिए, छात्रों को बहुत सारी त्रुटियां मिलती हैं जैसे "मैंने (a<7);{ लिखते समय लिखा था, लेकिन प्रोग्राम काम नहीं करता है।"
मेरी राय में, शुरुआत में निर्माण का वाक्य-विन्यास तुरंत कोष्ठक के साथ देना बेहतर है। कोष्ठक के बिना विकल्प को केवल तभी समझाया जाना चाहिए जब छात्र के पास कोई विशिष्ट प्रश्न हो: "कोई कोष्ठक क्यों नहीं है और यह काम करता है।"

ओकुलोव की 2012 की पुस्तक "फंडामेंटल्स ऑफ प्रोग्रामिंग" में, लूप्स का परिचय फॉर पैटर्न से शुरू होता है, फिर इसके उपयोग के लिए सिफारिशें देता है, और फिर तुरंत पाठ के प्रायोगिक खंड में जाता है। मैं समझता हूं कि यह पुस्तक बहुत ही सक्षम छात्रों के उस अल्पसंख्यक वर्ग के लिए लिखी गई थी जो शायद ही कभी मेरी कक्षाओं में आते हैं।

लोकप्रिय पुस्तकों में, कोड अंशों का परिणाम हमेशा लिखा जाता है। उदाहरण के लिए, शिल्ड्ट का "जावा 8. द कम्प्लीट गाइड" 2015 संस्करण। सबसे पहले, एक टेम्प्लेट दिया जाता है, फिर एक उदाहरण प्रोग्राम और उसके तुरंत बाद - निष्पादन का परिणाम।

उदाहरण के तौर पर, एक while लूप पर विचार करें जो विपरीत कार्य करता है
उलटी गिनती 10 से शुरू होती है, और "उपायों" की ठीक 10 पंक्तियाँ प्रदर्शित होती हैं:
//Продемонстрировать применение оператора цикла while
class While {
    public static void main(String args []) {
        int n = 10;
        while (n > 0) {
            System.out.println("такт " + n);
            n--;
        }
    }
}
एक बार चलाने के बाद, यह प्रोग्राम निम्नानुसार दस "चक्र" आउटपुट करता है:
такт 10 такт 9 такт 8 такт 7 такт 6 такт 5 такт 4 такт 3 такт 2 такт 1

एक टेम्प्लेट, एक उदाहरण प्रोग्राम और प्रोग्राम के परिणाम का वर्णन करने का दृष्टिकोण "बच्चों के लिए जावास्क्रिप्ट" पुस्तक और w3schools.com पर जेएस पाठ्यक्रम में भी उपयोग किया जाता है। वेब पेज प्रारूप इस उदाहरण को इंटरैक्टिव होने की भी अनुमति देता है।

स्ट्रॉस्ट्रुप की 2016 की पुस्तक प्रिंसिपल्स एंड प्रैक्टिस यूजिंग सी++ और भी आगे बढ़ गई। पहला कदम यह समझाना है कि क्या परिणाम प्राप्त किया जाना चाहिए, और उसके बाद कार्यक्रम का पाठ दिखाया गया है। इसके अलावा, वे न केवल एक यादृच्छिक कार्यक्रम को एक उदाहरण के रूप में लेते हैं, बल्कि इतिहास का भ्रमण भी कराते हैं। इससे इस ओर ध्यान आकर्षित करने में मदद मिलती है: “देखिए, यह कोई बेकार पाठ नहीं है। आप कुछ सार्थक देख रहे हैं।"

पुनरावृत्ति के उदाहरण के रूप में, संग्रहीत प्रोग्राम मशीन (ईडीएसएसी) पर निष्पादित पहले प्रोग्राम पर विचार करें। इसे डेविड व्हीलर ने 6 मई, 1949 को कैम्ब्रिज विश्वविद्यालय, इंग्लैंड की कंप्यूटर प्रयोगशाला में लिखा था। यह प्रोग्राम वर्गों की एक सरल सूची की गणना और प्रिंट करता है।
0 0 1 1 2 4 3 9 4 16 ... 98 9604 99 9801
यहां, प्रत्येक पंक्ति में एक संख्या होती है जिसके बाद एक टैब वर्ण ('टी') और उस संख्या का वर्ग होता है। इस प्रोग्राम का C++ संस्करण इस प्रकार दिखता है:
//Вычисляем и распечатываем таблицу квадратов чисел 0-99
int main()
{
    int i = 0; // Начинаем с нуля
    while(i < 100){
        cout << i << 't' << square(i) << 'n';
        ++i;
    }
}

दिलचस्प बात यह है कि इस पुस्तक में वाक्यविन्यास पैटर्न का वर्णन नहीं किया गया है। प्रशिक्षक के मैनुअल में स्ट्रॉस्ट्रुप (अनुवाद) इस बात पर जोर देता है कि वह अपने छात्रों की बुद्धिमत्ता का सम्मान करता है। शायद कई उदाहरणों में एक पैटर्न की पहचान करने की क्षमता को ऐसी बुद्धिमत्ता की अभिव्यक्ति माना जाता है।

जैसा कि मैं खुद को समझाता हूं

स्ट्रॉस्ट्रुप का दृष्टिकोण: परिणाम का वर्णन करना, फिर समस्या का समाधान करना, और फिर छात्र द्वारा एक स्वतंत्र विश्लेषण - सबसे विचारशील लगता है। इसलिए, मैंने इसे एक आधार के रूप में लेने का निर्णय लिया, लेकिन इसे कम ऐतिहासिक उदाहरण का उपयोग करके बताएं - "सामग्री की तालिका" प्राप्त करने का कार्य। यह एक पहचानने योग्य एंकर बनाता है ताकि आप फिर कह सकें "सामग्री की तालिका के बारे में कार्य याद रखें" और ताकि छात्रों को यह ठीक से याद रहे। अपने उदाहरण में, मैंने दो और सबसे आम गलतफहमियों को रोकने की कोशिश की। आगे मैं इनके बारे में और विस्तार से लिखूंगा.

इस कार्य में हमें जटिल समस्याओं को हल करने की तकनीकों से परिचित कराया जाता है। प्रारंभिक निर्णय को आदिम और सरल बनाने की आवश्यकता है। खैर, फिर आप सोच सकते हैं कि इस समाधान को कैसे बेहतर बनाया जाए।
Введение Глава 1 Глава 2 Глава 3 Глава 4 Глава 5 Глава 6 Глава 7 Заключение

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

Console.WriteLine("Введение");
Console.WriteLine("Глава 1");
Console.WriteLine("Глава 2");
Console.WriteLine("Глава 3");
Console.WriteLine("Глава 4");
Console.WriteLine("Глава 5");
Console.WriteLine("Глава 6");
Console.WriteLine("Глава 7");
Console.WriteLine("Заключение");

इसमें कैसे सुधार किया जा सकता है?
नीरस क्रियाओं को एक चक्र से बदलें।
कौन सी क्रियाएं बिना किसी परिवर्तन के एक पंक्ति में दोहराई जाती हैं?
इस टुकड़े में कोई भी नहीं है. हालाँकि, "अध्याय" शब्द को किसी संख्या के साथ प्रदर्शित करने के आदेश एक-दूसरे से बहुत मिलते-जुलते हैं।
इसलिए, अगला चरण टुकड़ों के बीच अंतर का पता लगाना है। यह केवल इस कार्य में है कि सब कुछ स्पष्ट है, फिर एकल कमांड दोहराए नहीं जाएंगे, लेकिन 5 लाइनों या अधिक के कोड के ब्लॉक। आपको न केवल कमांड की सूची में, बल्कि ब्रांचिंग या लूप कंस्ट्रक्शन में भी खोजना होगा।
उदाहरण में, कमांड के बीच का अंतर "अध्याय" शब्द के बाद की संख्या में है।
एक बार अंतर पता चलने के बाद, आपको बदलाव के पैटर्न को समझने की जरूरत है। भिन्न खंड संख्या है? क्या यह लगातार बढ़ रहा है या घट रहा है? दो टीमों के बीच किसी संख्या का मान साथ-साथ कैसे बदलता है?
उदाहरण में, "अध्याय" शब्द के बाद की संख्या 1 की वृद्धि में बढ़ती है। अंतर पाया जाता है, पैटर्न का पता चलता है। अब आप अलग-अलग टुकड़े को एक वेरिएबल से बदल सकते हैं।
आपको दोहराए जाने वाले टुकड़ों में से पहले से पहले इस तरह के एक चर को घोषित करने की आवश्यकता है। ऐसे चर को आमतौर पर I या j या कुछ और विस्तृत कहा जाता है। इसका प्रारंभिक मान स्क्रीन पर प्रदर्शित पहले मान के बराबर होना चाहिए। उदाहरण में, पहला मान 1 है।
संख्याओं की श्रृंखला "100, 101, 102, 103, 104, 105" को प्रदर्शित करने के लिए क्या प्रारंभिक मान लिया जाना चाहिए?
इस श्रृंखला में पहला अंक 100 है।
प्रत्येक आउटपुट कमांड के बाद, आपको इस वेरिएबल का मान 1 से बढ़ाना होगा। यह इकाई परिवर्तन चरण है।
संख्याओं “100, 102, 104, 106” की श्रृंखला में कौन सा चरण होगा?
इस पंक्ति में चरण 2.
अलग-अलग फ़्रैगमेंट को वेरिएबल से बदलने के बाद, कोड इस तरह दिखेगा:

Console.WriteLine("Введение");
int i;
i = 0;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");

कोड में "एक चर के पैटर्न को व्यक्त करें" तकनीक को लागू करने के बाद, आपको समान क्रियाओं के कई समूह मिलते हैं जो एक पंक्ति में चलते हैं। अब दोहराई जाने वाली क्रियाओं को लूप से बदला जा सकता है।

किसी समस्या को हल करने का क्रम जहां आपको लूप का उपयोग करने की आवश्यकता होती है, उसमें निम्नलिखित चरण होते हैं:

कई अलग-अलग आदेशों के साथ "हेड-ऑन" हल करें
एक पैटर्न खोजें
किसी चर के पैटर्न को व्यक्त करें
एक साइकिल के रूप में डिज़ाइन करें

इसके बाद, नए शब्द पेश किए गए हैं ताकि छात्र खुद को "मैं सब कुछ समझता हूं, लेकिन मैं यह नहीं कह सकता" जैसी स्थिति में न पाए:
- एक काउंटर हमेशा एक वैरिएबल होता है जो लूप में चरणों की संख्या को ट्रैक करने के लिए आवश्यक होता है। आमतौर पर एक पूर्णांक जिसकी तुलना बाधा से की जाती है।
— प्रति चरण — प्रति परिवर्तन के पैटर्न का विवरण।
- बाधा - एक संख्या या चर जिसके साथ काउंटर की तुलना की जाती है ताकि एल्गोरिदम अंतिम हो। सीमा के करीब पहुंचने के लिए काउंटर वैल्यू बदल जाती है।
- लूप बॉडी - आदेशों का एक सेट जिसे दोहराया जाएगा। जब वे कहते हैं "कमांड एक लूप के अंदर लिखा गया है," तो उनका मतलब शरीर से है।
- लूप पुनरावृत्ति - लूप बॉडी का एक बार निष्पादन।
- लूप स्थिति - एक तार्किक अभिव्यक्ति जो यह निर्धारित करती है कि कोई अन्य पुनरावृत्ति निष्पादित की जाएगी या नहीं। (यहां शाखा संरचनाओं को लेकर भ्रम हो सकता है)
आपको इस तथ्य के लिए तैयार रहना होगा कि सबसे पहले छात्र अन्य उद्देश्यों के लिए शब्दों का उपयोग करेंगे। यह बात ताकतवर और कमज़ोर दोनों पर लागू होती है। एक सामान्य भाषा स्थापित करना एक कला है। अब मैं संक्षेप में लिखूंगा: आपको "<term> के साथ कोड खंड को हाइलाइट करें" कार्य निर्धारित करना होगा और बातचीत में इन शब्दों का स्वयं सही ढंग से उपयोग करना होगा।
एक लूप के साथ परिवर्तन के बाद, टुकड़ा प्राप्त होता है:

Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
    Console.WriteLine("Глава " + i);
    i = i + 1;
}
Console.WriteLine("Заключение");

मुख्य ग़लतफ़हमी

छात्रों के बीच एक लोकप्रिय ग़लतफ़हमी यह है कि वे कार्यों को एक लूप के अंदर रखते हैं जिन्हें केवल एक बार करने की आवश्यकता होती है। उदाहरण के लिए इस प्रकार:

;
int i = 0;
while (i < 7) {
    Console.WriteLine("Введение")
    Console.WriteLine("Глава " + i);
    i = i + 1;
    Console.WriteLine("Заключение");
}

विद्यार्थी हर समय इस समस्या से जूझते हैं, शुरुआत में भी और अधिक जटिल समस्याओं में भी।
इस मामले में मुख्य संकेत:

आपको आदेश को कितनी बार दोहराना चाहिए: एक बार या कई बार?

"परिचय" और "निष्कर्ष" शब्दों को प्रिंट करने और वेरिएबल i को घोषित करने और आरंभ करने के आदेश अन्य दोहराए जाने वाले कार्यों की तरह नहीं हैं। उन्हें केवल एक बार निष्पादित किया जाता है, जिसका अर्थ है कि उन्हें लूप बॉडी के बाहर लिखा जाना चाहिए।

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

अतिरिक्त कौशल का विकास

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

कार्रवाइयों की संख्या अपेक्षा से 1 कम या अधिक है. समाधान:
- काउंटर का प्रारंभिक मान 1 बढ़ाएँ।
- सख्त तुलना ऑपरेटर (<या >) को गैर-सख्त तुलना ऑपरेटर (<= या >=) से बदलें।
- सीमा मान को 1 में बदलें।
लूप में क्रियाएं बिना रुके, अनिश्चित काल तक की जाती हैं। समाधान:
- यदि यह गायब है तो काउंटर चेंज कमांड जोड़ें।
- काउंटर चेंज कमांड को ठीक करें ताकि इसका मूल्य सीमा के करीब हो जाए।
- यदि लूप के मुख्य भाग में बाधा परिवर्तन कमांड है तो उसे हटा दें।
एक लूप में क्रियाओं की संख्या अपेक्षा से 1 कम या अधिक होती है। लूप में कार्रवाई एक बार भी निष्पादित नहीं की गई। सबसे पहले आपको लूप शुरू होने से ठीक पहले वेरिएबल्स के वास्तविक मूल्यों का पता लगाना होगा। समाधान:
- बाधा का प्रारंभिक मान बदलें
- काउंटर का प्रारंभिक मान बदलें

समस्या 3 में आमतौर पर गलत वेरिएबल का उपयोग करना या काउंटर को शून्य पर रीसेट न करना शामिल है।

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

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

प्रत्येक कार्य के लिए आपको परीक्षण डेटा और अपेक्षित परिणाम प्रदान करना होगा।

यह समझने के लिए कि आप कितनी तेजी से आगे बढ़ सकते हैं, आपको इन समस्याओं की शर्तों को पढ़ना होगा और पूछना होगा: "वे उदाहरण से कैसे भिन्न हैं?", "उन्हें हल करने के लिए उदाहरण में क्या बदलने की आवश्यकता है?" यदि छात्र सार्थक उत्तर देता है, तो उसे कम से कम एक कक्षा में और बाकी घर पर स्वयं हल करने दें। यदि समाधान सफल होता है, तो हम लूप के अंदर की स्थितियों को समझाना शुरू कर सकते हैं।
यदि आपको स्वयं समस्याओं को हल करने में समस्या आ रही है, तो आपको कक्षा में हर चीज़ पर काम करने की आवश्यकता है। समस्या के समाधान को उल्लू का चित्र बनाने जैसी याद दिलाने से बचने के लिए, मैं पहले समस्या को गैर-सार्वभौमिक तरीके से हल करने की सलाह देता हूँ। अर्थात्, ताकि समाधान पहला परीक्षण पास कर ले और लूप निर्माण का उपयोग न करे। खैर, फिर समाधान की सार्वभौमिकता प्राप्त करने के लिए परिवर्तन लागू करें।

लूप और शाखाएँ

मेरी राय में, "शाखाओं के भीतर चक्र" विषय को अलग से देना उपयोगी है। ताकि बाद में आप किसी शर्त को कई बार जांचने और एक बार जांचने के बीच का अंतर देख सकें।
समेकन के कार्य ए से बी तक संख्याओं को आउटपुट करने के बारे में होंगे, जो उपयोगकर्ता द्वारा दर्ज किए गए हैं:
- सदैव बढ़ते क्रम में.
- ए और बी के मूल्यों के आधार पर आरोही या अवरोही।

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

उपयोगकर्ता संख्या X दर्ज करता है। 0 से 9 तक की संख्याओं को एक कॉलम में प्रदर्शित करें और उस संख्या के सामने '+' चिह्न लगाएं जो X के बराबर है।

यदि 0 दर्ज किया गया था0+
1
2
3
4
5
6
7
8
9

यदि 6 दर्ज किया गया था0
1
2
3
4
5
6+
7
8
9

यदि 9 दर्ज किया गया था0
1
2
3
4
5
6
7
8
9+

यदि 777 दर्ज किया गया था0
1
2
3
4
5
6
7
8
9

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

string temp;
temp = Console.ReadLine();
int x;
x = int.Parse(temp);
if (x==0) {
    Console.WriteLine(0 + "+");
} else {
    Console.WriteLine(0);
}
if (x==1) {
    Console.WriteLine(1 + "+");
} else {
    Console.WriteLine(1);
}
if (x==2) {
    Console.WriteLine(2 + "+");
} else {
    Console.WriteLine(2);
}
if (x==3) {
    Console.WriteLine(3 + "+");
} else {
    Console.WriteLine(3);
}
if (x==4) {
    Console.WriteLine(4 + "+");
} else {
    Console.WriteLine(4);
}
if (x==5) {
    Console.WriteLine(5 + "+");
} else {
    Console.WriteLine(5);
}
if (x==6) {
    Console.WriteLine(6 + "+");
} else {
    Console.WriteLine(6);
}
if (x==7) {
    Console.WriteLine(7 + "+");
} else {
    Console.WriteLine(7);
}
if (x==8) {
    Console.WriteLine(8 + "+");
} else {
    Console.WriteLine(8);
}
if (x==9) {
    Console.WriteLine(9 + "+");
} else {
    Console.WriteLine(9);
}

संभावित

string temp;
temp = Console.ReadLine();
int x;
x = int.Parse(temp);
if (x==0) {
    Console.WriteLine("0+n1n2n3n4n5n6n7n8n9");
}
if (x==1) {
    Console.WriteLine("0n1+n2n3n4n5n6n7n8n9");
}
if (x==2) {
    Console.WriteLine("0n1n2+n3n4n5n6n7n8n9");
}
if (x==3) {
    Console.WriteLine("0n1n2n3+n4n5n6n7n8n9");
}
if (x==4) {
    Console.WriteLine("0n1n2n3n4+n5n6n7n8n9");
}
if (x==5) {
    Console.WriteLine("0n1n2n3n4n5+n6n7n8n9");
}
if (x==6) {
    Console.WriteLine("0n1n2n3n4n5n6+n7n8n9");
}
if (x==7) {
    Console.WriteLine("0n1n2n3n4n5n6n7+n8n9");
}
if (x==8) {
    Console.WriteLine("0n1n2n3n4n5n6n7n8+n9");
}
if (x==9) {
    Console.WriteLine("0n1n2n3n4n5n6n7n8n9+");
}

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

लूप्स के भीतर लूप्स

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

काउंटर को शून्य पर रीसेट करने के महत्व को समझाकर लूप के भीतर लूप के विषय को समझाना शुरू करना सबसे अच्छा है।
उदाहरण कार्य:

उपयोगकर्ता दो नंबर दर्ज करता है: आर और टी। "#" वर्णों की दो पंक्तियाँ प्रिंट करें। पहली पंक्ति में R अक्षर होना चाहिए. दूसरी पंक्ति में T टुकड़े हैं। यदि कोई संख्या ऋणात्मक है, तो एक त्रुटि संदेश प्रदर्शित करें।

आर=5, टी=11#####
###########

आर=20, टी=3###################
# # #

आर=-1, टी=6R मान गैर-नकारात्मक होना चाहिए

आर=6, टी=-2T मान गैर-ऋणात्मक होना चाहिए

जाहिर है, इस समस्या के भी कम से कम दो समाधान हैं.
इच्छित

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
int i = 0;
while (i < R)
{
    Console.Write("#");
    i = i + 1;
}
Console.WriteLine();
i = 0;
while (i < T)
{
    Console.Write("#");
    i = i + 1;
}

संभव #1

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
int i = 0;
while (i < R)
{
    Console.Write("#");
    i = i + 1;
}
Console.WriteLine();
int j = 0;
j = 0;
while (j < T)
{
    Console.Write("#");
    j = j + 1;
}

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

दो लूपों के लिए एक काउंटर वेरिएबल का उपयोग करने में एक सामान्य समस्या इस प्रकार दिखाई देती है:
आर=5, टी=11#####
######

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

निःसंदेह, एक और समाधान है। लेकिन मैंने इसे छात्रों के बीच कभी नहीं देखा। चक्रों के अध्ययन के चरण में, इसके बारे में कहानी ध्यान भटकाएगी। स्ट्रिंग फ़ंक्शंस के बारे में सीखते समय आप बाद में इस पर वापस आ सकते हैं।
संभव #2

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
Console.WriteLine(new String('#', R));
Console.WriteLine(new String('#', T));

अगला आवश्यक कार्य:

0 से 9 तक की संख्याएँ प्रदर्शित करें। प्रत्येक संख्या अपनी ही पंक्ति में होनी चाहिए। एक पंक्ति में अंकों की संख्या (W) कीबोर्ड से दर्ज की जाती है।

डब्ल्यू = ९0
1
2
3
4
5
6
7
8
9

डब्ल्यू = ९0000000000 1111111111 2222222222 3333333333 4444444444 5555555555 6666666666 7777777777 8888888888 9999999999

यदि किसी छात्र ने किसी चर को बदलने की तकनीक में महारत हासिल कर ली है, तो वह बहुत जल्दी इसका सामना कर लेगा। एक संभावित समस्या फिर से वेरिएबल को रीसेट करने में होगी। यदि आप परिवर्तन को संभाल नहीं सकते हैं, तो इसका मतलब है कि आप जल्दी में थे और आपको सरल समस्याओं को हल करने की आवश्यकता है।

आपके ध्यान देने के लिए धन्यवाद! चैनल को लाइक और सब्सक्राइब करें.

PS यदि आपको पाठ में टाइपो या त्रुटियां मिलती हैं, तो कृपया मुझे बताएं। यह टेक्स्ट का हिस्सा चुनकर और मैक पर "⌘ + Enter" दबाकर, और क्लासिक कीबोर्ड पर "Ctrl / Enter" दबाकर या निजी संदेशों के माध्यम से किया जा सकता है। यदि ये विकल्प उपलब्ध नहीं हैं, तो टिप्पणियों में त्रुटियों के बारे में लिखें। धन्यवाद!

केवल पंजीकृत उपयोगकर्ता ही सर्वेक्षण में भाग ले सकते हैं। साइन इन करेंकृपया।

कर्म रहित पाठकों के लिए मतदान

20,0% तक मैं पेशेवर रूप से पढ़ाता हूं, +12
10,0% तक मैं पेशेवर ढंग से पढ़ाता हूं, -11
70,0% तक मैं नहीं पढ़ाता, +17
0,0% तक मैं नहीं पढ़ाता, -10
0,0% तक अन्य0

10 उपयोगकर्ताओं ने मतदान किया। 5 उपयोगकर्ता अनुपस्थित रहे।

स्रोत: www.habr.com

कठिनाइयों को दूर करना कैसे सिखाएं और साथ ही चक्र कैसे लिखें