🈯️ 🤛🏾 🔈 कठिनाइयों को दूर करने के लिए कैसे सिखाना है, और एक ही समय में साइकिल लिखना है 📑 🦀 👩‍👩‍👧‍👦

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

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

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

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

इतने पत्र क्यों? चक्र प्राथमिक हैं!

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

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

किसको और क्यों पढ़ाऊं

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

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

अभ्यास उन्मुख अभ्यास

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

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

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

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

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

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

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

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

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

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

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

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

निहितार्थ की तुलना में स्पष्ट है

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

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

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

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

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

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

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

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

एक उदाहरण के रूप में, थोड़ी देर के लूप पर विचार करें जिसमें रिवर्स
उलटी गिनती, 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 पर js पाठ्यक्रम में भी किया जाता है। वेब पेज प्रारूप भी आपको इस उदाहरण को इंटरैक्टिव बनाने की अनुमति देता है।

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

पुनरावृत्ति के एक उदाहरण के रूप में, संग्रहीत प्रोग्राम (ईडीएसएसी) के साथ मशीन पर निष्पादित पहले कार्यक्रम पर विचार करें। यह 6 मई, 1949 को इंग्लैंड के कैम्ब्रिज विश्वविद्यालय में कंप्यूटर लैब में डेविड व्हीलर द्वारा लिखा गया था। यह कार्यक्रम वर्गों की एक सरल सूची की गणना करता है और प्रिंट करता है।
0 0 1 1 2 4 3 9 4 16 ... 98 9604 99 9801
यहां, प्रत्येक पंक्ति में एक टैब ('\ t') और उस संख्या के वर्ग के बाद एक संख्या होती है। इस प्रोग्राम का 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-- और अन्य प्रतीत होता है स्पष्ट चीजों के बीच चयन करना चाहिए। इन गलत धारणाओं से बचने के लिए, चक्र के बारे में कहानी के दृष्टिकोण को समान कार्यों की पुनरावृत्ति के अर्थ पर जोर देना चाहिए और उसके बाद ही - डिजाइन का उपयोग करके उन्हें डिजाइन करना चाहिए। इसलिए, लूप का सिंटैक्स देने से पहले, आपको "माथे" समस्या को हल करने की आवश्यकता है। सामग्री समस्या की तालिका का एक आदिम समाधान इस तरह दिखता है:

 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("");

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

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

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

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

 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 में बदलें।
लूप में क्रियाओं को बिना रुके, अंतहीन रूप से किया जाता है। हल करने के तरीके:
- अनुपस्थित होने पर काउंटर परिवर्तन कमांड जोड़ें।
- काउंटर परिवर्तन कमांड को ठीक करें ताकि इसका मान सीमा के करीब हो जाए।
- यदि चक्र के शरीर में है, तो बाधा को बदलने के लिए कमांड को हटा दें।
लूप में क्रियाओं की संख्या अपेक्षा से 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+\n1\n2\n3\n4\n5\n6\n7\n8\n9"); } if (x==1) { Console.WriteLine("0\n1+\n2\n3\n4\n5\n6\n7\n8\n9"); } if (x==2) { Console.WriteLine("0\n1\n2+\n3\n4\n5\n6\n7\n8\n9"); } if (x==3) { Console.WriteLine("0\n1\n2\n3+\n4\n5\n6\n7\n8\n9"); } if (x==4) { Console.WriteLine("0\n1\n2\n3\n4+\n5\n6\n7\n8\n9"); } if (x==5) { Console.WriteLine("0\n1\n2\n3\n4\n5+\n6\n7\n8\n9"); } if (x==6) { Console.WriteLine("0\n1\n2\n3\n4\n5\n6+\n7\n8\n9"); } if (x==7) { Console.WriteLine("0\n1\n2\n3\n4\n5\n6\n7+\n8\n9"); } if (x==8) { Console.WriteLine("0\n1\n2\n3\n4\n5\n6\n7\n8+\n9"); } if (x==9) { Console.WriteLine("0\n1\n2\n3\n4\n5\n6\n7\n8\n9+"); }

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

लूप्स के अंदर लूप्स

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

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

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

आर = 5, टी = 11

#####
###########

आर = 20, टी = 3

####################
###

आर = -1, टी = 6

R का मान गैर-ऋणात्मक होना चाहिए

आर = 6, टी = -2

T का मान गैर-ऋणात्मक होना चाहिए

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

वांछित

 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; }

संभव संख्या १

 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 है। यदि आप दूसरे चक्र से तुरंत पहले काउंटर वैल्यू का आउटपुट जोड़ते हैं तो इसका निदान किया जाता है। शून्य करके ठीक किया गया। लेकिन यह अभी नहीं बताना बेहतर है। छात्र को कम से कम एक परिकल्पना तैयार करने का प्रयास करना चाहिए।

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

संभव संख्या २

 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) अंकों की संख्या दर्ज की जाती है।

W = 1