🥇अडचणींवर मात कशी करायची हे शिकवायचे आणि त्याच बरोबर आवर्तन कसे लिहायचे

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

सायकलचा विषय निवडला आहे कारण प्रोग्रामिंगमध्ये प्रभुत्व मिळवताना बरेच लोक त्यातून वगळले जातात.

हे तंत्र दुर्बल विद्यार्थ्यांसाठी तयार करण्यात आले आहे. नियमानुसार, सशक्त लोक या विषयावर अडकत नाहीत आणि त्यांच्यासाठी विशेष तंत्रांसह येण्याची आवश्यकता नाही. लेखाचे दुय्यम उद्दिष्ट हे तंत्र "सर्व विद्यार्थ्यांसाठी कार्य करते, परंतु केवळ एक शिक्षक" वर्गापासून "सर्व विद्यार्थ्यांसाठी, सर्व शिक्षकांसाठी कार्य करते" वर्गात हलवणे आहे. मी परिपूर्ण मौलिकतेचा दावा करत नाही. हा विषय शिकवण्यासाठी तुम्ही आधीपासून समान पद्धती वापरत असल्यास, कृपया तुमची आवृत्ती कशी वेगळी आहे ते लिहा. तुम्ही ते वापरायचे ठरवले तर ते कसे गेले ते आम्हाला सांगा. पुस्तकात तत्सम तंत्राचे वर्णन असल्यास कृपया नाव लिहा.

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

इतकी पत्रे का? सायकल खूप प्राथमिक आहेत!

मी वर लिहिल्याप्रमाणे, सराव करणार्‍या विकसकांसाठी आणि सशक्त विद्यार्थ्यांसाठी, लूपच्या संकल्पनेची जटिलता कमी लेखली जाऊ शकते. उदाहरणार्थ, आपण एक लांब व्याख्यान देऊ शकता, डोके हलवणारे आणि बुद्धिमान डोळे पाहू शकता. परंतु कोणतीही समस्या सोडवण्याचा प्रयत्न करताना, मूर्खपणा आणि न समजण्याजोग्या समस्या सुरू होतात. व्याख्यानानंतर, विद्यार्थ्यांना कदाचित फक्त अर्धवट समजले असेल. त्यांचा भ्रम नेमका काय आहे, हे विद्यार्थी स्वत:च सांगू शकत नसल्यामुळे परिस्थिती बिकट झाली आहे.
एके दिवशी माझ्या लक्षात आले की विद्यार्थ्यांनी माझी उदाहरणे चित्रलिपी म्हणून समजली. म्हणजेच, मजकुराच्या अविभाज्य तुकड्यांप्रमाणे ज्यामध्ये तुम्हाला काही "जादू" अक्षर जोडण्याची आवश्यकता आहे आणि ते कार्य करेल.
काहीवेळा माझ्या लक्षात आले की, विद्यार्थ्यांना वाटते की तुम्हाला एखादी विशिष्ट समस्या सोडवायची आहे काहीतरी एक डिझाइन जे मी अद्याप कव्हर केलेले नाही. जरी सोल्यूशनसाठी उदाहरणामध्ये थोडासा बदल करणे आवश्यक आहे.

म्हणून मला कल्पना सुचली की अभिव्यक्तींच्या वाक्यरचनेवर लक्ष केंद्रित करू नये, परंतु लूप वापरून पुनरावृत्ती कोड रिफॅक्टर करण्याच्या कल्पनेवर लक्ष केंद्रित केले पाहिजे. विद्यार्थ्यांनी या कल्पनेवर प्रभुत्व मिळवल्यानंतर, कोणत्याही वाक्यरचना थोड्या सरावाने सुधारली जाऊ शकते.

मी कोण आणि का शिकवू?

कोणत्याही प्रवेश परीक्षा नसल्यामुळे, वर्गांमध्ये सशक्त आणि अत्यंत कमकुवत अशा दोन्ही विद्यार्थ्यांचा समावेश असू शकतो. आपण लेखात माझ्या विद्यार्थ्यांबद्दल अधिक वाचू शकता संध्याकाळच्या अभ्यासक्रमाच्या विद्यार्थ्यांचे पोर्ट्रेट
प्रोग्रामिंग शिकू इच्छिणाऱ्या प्रत्येकाला ते शिकता यावे यासाठी मी प्रयत्न केले.
माझे वर्ग वैयक्तिकरित्या आयोजित केले जातात आणि विद्यार्थी प्रत्येकासाठी स्वतःचे पैसे देतात. असे दिसते की विद्यार्थी खर्च अनुकूल करतील आणि किमान मागणी करतील. तथापि, लोक थेट शिक्षकासोबत समोरासमोर वर्गात जातात ज्ञानासाठी नव्हे, तर त्यांनी जे शिकले त्याचा आत्मविश्वास, प्रगतीची भावना आणि तज्ञ (शिक्षक) कडून मान्यता मिळवण्यासाठी. विद्यार्थ्यांना त्यांच्या अभ्यासात प्रगती वाटत नसेल तर ते सोडून जातील. सर्वसाधारणपणे, वर्गांची रचना केली जाऊ शकते जेणेकरून विद्यार्थ्यांना परिचित रचनांची संख्या वाढवण्यात प्रगती वाटेल. म्हणजेच, प्रथम आपण तपशीलवार अभ्यास करतो, नंतर आपण अभ्यास करतो, नंतर करतो आणि आता आमच्याकडे एक हजार आणि एक रात्रीचा कोर्स तयार आहे, ज्यामध्ये दोन महिने एकटेच अभ्यास केला जातो आणि शेवटी - एक विद्यार्थी ज्याने लिहिले डिक्टेशन अंतर्गत एक मानक लायब्ररी. तथापि, व्यावहारिक समस्यांचे निराकरण करण्यासाठी, आपल्याला केवळ सामग्रीचे ज्ञान नाही तर त्याच्या अनुप्रयोगात आणि नवीन माहिती शोधण्यात स्वातंत्र्य देखील आवश्यक आहे. त्यामुळे, समोरासमोर अभ्यासक्रमांसाठी, मला वाटते की किमान शिकवणे आणि बारकावे आणि संबंधित विषयांच्या स्वतंत्र अभ्यासाला प्रोत्साहन देणे हे योग्य तत्त्व आहे. लूपच्या विषयामध्ये, मी व्हील कन्स्ट्रक्टला किमान मानतो. त्यावरून तत्त्व समजून घेता येईल. तत्त्व जाणून घेतल्यास, तुम्ही स्वतःसाठी आणि करताना दोन्हीमध्ये प्रभुत्व मिळवू शकता.

कमकुवत विद्यार्थ्यांचे साहित्यावर प्रभुत्व मिळविण्यासाठी, वाक्यरचनेचे वर्णन करणे पुरेसे नाही. अधिक सोपी परंतु विविध कार्ये देणे आणि उदाहरणांचे अधिक तपशीलवार वर्णन करणे आवश्यक आहे. शेवटी, विकासाचा वेग हा विद्यार्थ्याच्या अभिव्यक्ती बदलण्याच्या आणि नमुने शोधण्याच्या क्षमतेमुळे मर्यादित असतो. हुशार विद्यार्थ्यांसाठी, बहुतेक असाइनमेंट कंटाळवाणे असतील. त्यांच्यासोबत अभ्यास करताना, तुम्हाला 100% समस्या सोडवण्याचा आग्रह धरण्याची गरज नाही. माझे साहित्य येथे पाहिले जाऊ शकते माझे गिथब. खरे आहे, भांडार हे वॉरलॉकच्या ग्रिमॉयरसारखे आहे - कुठे आहे ते माझ्याशिवाय कोणीही समजणार नाही आणि जर तुम्ही चेक अयशस्वी झाला तर तुम्ही वेडे होऊ शकता.

कार्यपद्धती अभ्यासाभिमुख आहे

समस्येचे निराकरण करण्याचे उदाहरण वापरून सिद्धांत स्पष्ट केला आहे. प्रोग्रामिंग क्लासच्या मूलभूत गोष्टींमध्ये जेथे शाखा आणि लूप शिकवले जातात, एका विषयावर संपूर्ण तासभर उपयुक्त व्याख्यान देणे शक्य नसते. संकल्पना स्पष्ट करण्यासाठी 15-20 मिनिटे पुरेसे आहेत. व्यावहारिक कार्ये करताना मुख्य अडचणी उद्भवतात.
सुरुवातीचे शिक्षक एका व्याख्यानात ऑपरेटर्स, शाखा, लूप आणि अॅरे यांना गोंधळात टाकू शकतात. परंतु त्यांच्या विद्यार्थ्यांना ही माहिती आत्मसात करण्यात अडचणी येतील.
केवळ सामग्री सांगणे आवश्यक नाही, तर श्रोत्यांना ते समजले आहे याची खात्री करणे देखील आवश्यक आहे.

एखाद्या विषयावर प्रभुत्व मिळवण्याची वस्तुस्थिती विद्यार्थ्याने स्वतंत्र कामाचा सामना कसा केला यावर अवलंबून असते.
जर एखाद्या विद्यार्थ्याने शिक्षकांच्या मदतीशिवाय एखाद्या विषयावरील समस्या सोडविण्यास व्यवस्थापित केले असेल तर विषयावर प्रभुत्व मिळवले आहे. स्वयं-चाचणी सुनिश्चित करण्यासाठी, प्रत्येक कार्य चाचणी परिस्थितींसह सारणीमध्ये वर्णन केले आहे. कार्यांना स्पष्ट क्रम आहे. कार्ये वगळण्याची शिफारस केलेली नाही. जर सध्याचे कार्य खूप कठीण असेल तर पुढील कार्यावर जाणे निरुपयोगी आहे. हे आणखी क्लिष्ट आहे. विद्यार्थ्याला सध्याच्या गुंतागुंतीच्या कामात प्रभुत्व मिळावे म्हणून, पहिल्या समस्येचे उदाहरण वापरून त्याला अनेक तंत्रे समजावून सांगितली जातात. वास्तविक, विषयाची संपूर्ण सामग्री अडचणींवर मात करण्याच्या तंत्रांवर येते. सायकलचे दुष्परिणाम अधिक आहेत.

पहिले कार्य नेहमीच एक उदाहरण असते. दुसरा थोडा वेगळा आहे आणि शिक्षकांच्या देखरेखीखाली पहिल्या नंतर लगेच "स्वतंत्रपणे" केला जातो. त्यानंतरची सर्व कार्ये विविध लहान गोष्टींकडे लक्ष देण्याच्या उद्देशाने आहेत ज्यामुळे गैरसमज होऊ शकतात.

उदाहरणाचे स्पष्टीकरण हा एक संवाद आहे ज्यामध्ये विद्यार्थ्याने सामग्रीच्या एका भागावर प्रभुत्व मिळवले आहे याची खात्री करण्यासाठी त्याला परत प्रसार आणि क्रॉस-व्हॅलिडेशन कॉल करणे आवश्यक आहे.

मी सामान्य आहे आणि म्हणेन की या विषयावरील पहिले उदाहरण खूप महत्वाचे आहे. तुमच्याकडे विस्तृत स्वतंत्र कामासाठी साहित्य असल्यास, पहिल्या उदाहरणातील वगळणे दुरुस्त केले जाऊ शकते. उदाहरणाशिवाय दुसरे काहीही नसल्यास, विद्यार्थी बहुधा विषयावर प्रभुत्व मिळवू शकणार नाही.

तेव्हा किंवा साठी?

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

माझ्या सामग्रीमध्ये, लूपची थीम ब्रँचिंगच्या थीमचे अनुसरण करते. if आणि while ची बाह्य समानता आपल्याला थेट समानता काढण्याची परवानगी देते: "जेव्हा शीर्षलेखातील स्थिती सत्य असते, तेव्हा शरीर अंमलात आणले जाते." सायकलचे एकमेव वैशिष्ठ्य म्हणजे शरीराला अनेक वेळा अंमलात आणले जाते.

माझा दुसरा युक्तिवाद असा आहे की for पेक्षा कमी स्वरूपन आवश्यक असताना. कमी स्वरूपन म्हणजे स्वल्पविराम आणि कंस नसलेल्या कमी मूर्ख चुका. वाक्यरचना त्रुटी स्वयंचलितपणे टाळण्यासाठी नवशिक्यांनी अद्याप पुरेशी चौकसता आणि सूक्ष्मता विकसित केलेली नाही.
तिसरा युक्तिवाद अनेक चांगल्या पुस्तकांमध्ये पहिला युक्तिवाद म्हणून स्पष्ट केला आहे.

जर विद्यार्थी सहजपणे अभिव्यक्ती बदलू शकत असेल, तर तुम्ही उत्तीर्ण होण्याबद्दल बोलू शकता. त्यानंतर विद्यार्थी त्याला सर्वात जास्त आवडेल ते निवडेल. जर परिवर्तनांमुळे अडचणी येत असतील तर तुमचे लक्ष विचलित न करणे चांगले. विद्यार्थ्याला प्रथम सर्व काही सोडवू द्या. एकदा तुम्ही लूपच्या विषयावर प्रभुत्व मिळवले की, तुम्ही सोल्यूशन्स पुन्हा लिहू शकता जेणेकरून ते बदलण्याचा सराव करा.
पोस्ट कंडिशन लूप हे एक दुर्मिळ प्राणी आहेत. मी यात अजिबात वेळ घालवत नाही. जर एखाद्या विद्यार्थ्याने नमुने ओळखणे आणि अभिव्यक्ती बदलण्याच्या कल्पनांवर प्रभुत्व मिळवले असेल, तर तो माझ्या मदतीशिवाय ते शोधू शकतो.

सशक्त विद्यार्थ्यांना पहिले उदाहरण दाखवून देताना, मी या वस्तुस्थितीकडे लक्ष वेधतो की पहिल्या उदाहरणात केवळ उपायच नव्हे तर परिणामाची संपूर्ण शृंखला देखील नोंदवणे महत्त्वाचे आहे. आळशी विद्यार्थी लेखनाकडे दुर्लक्ष करू शकतात आणि केवळ अंतिम अल्गोरिदम कॉपी करू शकतात. एक दिवस कठीण काम त्यांच्या वाट्याला येईल याची त्यांना खात्री पटली पाहिजे. त्याचे निराकरण करण्यासाठी, आपल्याला या उदाहरणाप्रमाणे चरणांचे अनुसरण करणे आवश्यक आहे. म्हणूनच सर्व टप्प्यांची नोंद करणे महत्त्वाचे आहे. खालील समस्यांमध्ये समाधानाची केवळ अंतिम आवृत्ती सोडणे शक्य होईल.

ऑटोमेशनची मुख्य कल्पना अशी आहे की आम्ही एखाद्या व्यक्तीसाठी नियमित काम करण्यासाठी संगणकावर सोपवतो. मूलभूत तंत्रांपैकी एक म्हणजे लूप लिहिणे. जेव्हा प्रोग्राममध्ये एका ओळीत अनेक समान पुनरावृत्ती क्रिया लिहिल्या जातात तेव्हा ते वापरले जाते.

निहित पेक्षा स्पष्ट चांगले आहे

पहिल्या लूपिंग टास्कमध्ये समान वाक्यांश अनेक वेळा प्रदर्शित करणे ही चांगली कल्पना आहे असे वाटू शकते. उदाहरणार्थ:

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

हा पर्याय खराब आहे कारण काउंटर मूल्य आउटपुटमध्ये दिसत नाही. नवशिक्यांसाठी ही समस्या आहे. तिला कमी लेखू नका. प्रथम, हे कार्य पहिले होते, आणि चढत्या क्रमाने संख्यांची मालिका काढण्याचे कार्य दुसरे होते. "सायकल N वेळा" आणि "A पासून B पर्यंत सायकल" या अतिरिक्त संज्ञा सादर करणे आवश्यक होते, जे मूलत: समान आहेत. अनावश्यक घटक तयार न करण्यासाठी, मी संख्यांच्या मालिकेच्या आउटपुटसह फक्त एक उदाहरण दर्शविण्याचा निर्णय घेतला. काही लोक त्यांच्या डोक्यात काउंटर कसे ठेवायचे आणि तयारीशिवाय त्यांच्या डोक्यात प्रोग्रामचे वर्तन कसे तयार करायचे हे शिकू शकतात. काही विद्यार्थ्यांना सायकल या विषयावर प्रथम मानसिक मॉडेलिंगचा सामना करावा लागतो.
काही सरावानंतर, मी स्वतंत्रपणे सोडवण्यासाठी समान मजकूर पुनरावृत्ती करण्याचे कार्य देतो. आपण प्रथम दृश्यमान काउंटर आणि नंतर अदृश्य काउंटर दिल्यास, विद्यार्थ्यांना कमी समस्या येतील. कधीकधी "स्क्रीनवर काउंटर लिहू नका" हा इशारा पुरेसा असतो.

इतरांनी ते कसे स्पष्ट करावे?

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

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

ओकुलोव्हच्या 2012 च्या "प्रोग्रामिंगची मूलभूत तत्त्वे" या पुस्तकात, लूपची ओळख फॉर पॅटर्नपासून सुरू होते, नंतर त्याच्या वापरासाठी शिफारसी देते आणि त्यानंतर लगेच धड्याच्या प्रायोगिक विभागात जाते. मला समजते की हे पुस्तक माझ्या वर्गात क्वचितच येणाऱ्या अत्यंत सक्षम विद्यार्थ्यांसाठी लिहिले गेले आहे.

लोकप्रिय पुस्तकांमध्ये, कोडच्या तुकड्यांचा परिणाम नेहमी लिहिला जातो. उदाहरणार्थ, Shildt ची “Java 8. The Complete Guide” 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

टेम्प्लेट, उदाहरण कार्यक्रम आणि कार्यक्रमाचा परिणाम यांचे वर्णन करण्याचा दृष्टीकोन देखील “मुलांसाठी Javascript” या पुस्तकात आणि w3schools.com वरील js कोर्समध्ये वापरला जातो. वेब पृष्ठ स्वरूप या उदाहरणास परस्परसंवादी होण्यास अनुमती देते.

Stroustrup चे 2016 चे पुस्तक Principles and Practice Using C++ आणखी पुढे गेले. पहिली पायरी म्हणजे कोणता परिणाम मिळावा हे स्पष्ट करणे आणि त्यानंतर प्रोग्रामचा मजकूर दर्शविला जातो. शिवाय, ते केवळ एक यादृच्छिक कार्यक्रम उदाहरण म्हणून घेत नाहीत, तर इतिहासात भ्रमण करतात. हे त्याकडे लक्ष वेधण्यास मदत करते: “पाहा, हा काही निरुपयोगी मजकूर नाही. तुला काहीतरी अर्थपूर्ण दिसत आहे."

पुनरावृत्तीचे उदाहरण म्हणून, संग्रहित प्रोग्राम मशीन (EDSAC) वर अंमलात आणलेल्या पहिल्या प्रोग्रामचा विचार करा. डेव्हिड व्हीलर यांनी ६ मे १९४९ रोजी केंब्रिज विद्यापीठाच्या संगणक प्रयोगशाळेत लिहिले होते. हा प्रोग्राम स्क्वेअरची एक सोपी सूची मोजतो आणि मुद्रित करतो.
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++ आणि 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 वर बदला.
लूपमधील क्रिया न थांबता, अनिश्चित काळासाठी केल्या जातात. उपाय:
- काउंटर चेंज कमांड गहाळ असल्यास जोडा.
— काउंटर चेंज कमांड फिक्स करा जेणेकरून त्याचे मूल्य मर्यादेच्या जवळ येईल.
कंस्ट्रेंट चेंज कमांड लूपच्या बॉडीमध्ये असल्यास काढून टाका.
लूपमधील क्रियांची संख्या 1 पेक्षा कमी किंवा अपेक्षेपेक्षा जास्त आहे. लूपमधील कारवाई एकदाही पार पडली नाही. प्रथम तुम्हाला लूप सुरू होण्यापूर्वी व्हेरिएबल्सची वास्तविक मूल्ये शोधण्याची आवश्यकता आहे. उपाय:
- प्रतिबंधाचे प्रारंभिक मूल्य बदला
- काउंटरचे प्रारंभिक मूल्य बदला

समस्या 3 मध्ये सहसा चुकीचे व्हेरिएबल वापरणे किंवा काउंटर शून्यावर रीसेट न करणे समाविष्ट असते.

या स्पष्टीकरणानंतर, विद्यार्थ्यामध्ये लूप कसे कार्य करतात याबद्दल अजूनही विविध गैरसमज असू शकतात.
सर्वात सामान्य गोष्टी दूर करण्यासाठी, मी तुम्हाला खालील कार्ये देतो:

ज्यामध्ये वापरकर्त्याद्वारे मर्यादा, प्रारंभिक काउंटर मूल्य किंवा काउंटर स्टेप प्रविष्ट केली जाते.
ज्यामध्ये काउंटर व्हॅल्यू काही अंकगणित अभिव्यक्तीमध्ये वापरणे आवश्यक आहे. मूलगामी अभिव्यक्तीमध्ये किंवा भाजकामध्ये काउंटर वापरण्याचा सल्ला दिला जातो जेणेकरून फरक नॉनलाइनर असेल.
ज्यामध्ये लूप चालू असताना काउंटर व्हॅल्यू स्क्रीनवर प्रदर्शित होत नाही. उदाहरणार्थ, समान मजकूर तुकड्यांची आवश्यक संख्या प्रदर्शित करणे किंवा कासव ग्राफिक्ससह आकृती काढणे.
ज्यामध्ये तुम्हाला प्रथम काही पुनरावृत्ती क्रिया करणे आवश्यक आहे आणि नंतर इतर.
ज्यामध्ये तुम्हाला पुनरावृत्ती करण्यापूर्वी आणि नंतर इतर क्रिया करणे आवश्यक आहे

प्रत्येक कार्यासाठी तुम्हाला चाचणी डेटा आणि अपेक्षित परिणाम प्रदान करणे आवश्यक आहे.

आपण किती लवकर हलवू शकता हे समजून घेण्यासाठी, आपल्याला या समस्यांच्या अटी वाचण्याची आणि विचारण्याची आवश्यकता आहे: "ते उदाहरणापेक्षा वेगळे कसे आहेत?", "त्या सोडवण्यासाठी उदाहरणामध्ये काय बदलण्याची आवश्यकता आहे?" जर विद्यार्थ्याने अर्थपूर्ण उत्तरे दिली तर त्याला किमान एक वर्गात सोडवा आणि बाकीचे स्वतः घरी सोडवा. जर उपाय यशस्वी झाला, तर आपण लूपमधील परिस्थिती समजावून सांगू शकतो.
जर तुम्हाला स्वतःच समस्या सोडवताना समस्या येत असतील, तर तुम्हाला वर्गातील प्रत्येक गोष्टीत काम करणे आवश्यक आहे. घुबड रेखांकनाची आठवण करून देणारी समस्या सोडवण्यापासून टाळण्यासाठी, मी प्रथम एक गैर-सार्वभौमिक मार्गाने समस्येचे निराकरण करण्याची शिफारस करतो. म्हणजे, जेणेकरून सोल्यूशन प्रथम चाचणी उत्तीर्ण करेल आणि लूप बांधकाम वापरत नाही. बरं, मग सोल्यूशनची सार्वत्रिकता प्राप्त करण्यासाठी परिवर्तन लागू करा.

लूप आणि शाखा

माझ्या मते, “शाखांमध्ये चक्र” हा विषय स्वतंत्रपणे देणे उपयुक्त आहे. जेणेकरून नंतर तुम्ही एखादी अट अनेक वेळा तपासणे आणि एकदा तपासणे यातील फरक पाहू शकता.
एकत्रीकरणाची कार्ये A ते B पर्यंत संख्या आउटपुट करण्याबद्दल असतील, जी वापरकर्त्याद्वारे प्रविष्ट केली जातात:
- नेहमी चढत्या क्रमाने.
- A आणि B च्या मूल्यांवर अवलंबून चढत्या किंवा उतरत्या.

विद्यार्थ्याने तंत्रात प्रभुत्व मिळवल्यानंतरच “लूपमध्ये शाखा” हा विषय पुढे जावा: “पॅटर्नला व्हेरिएबलसह बदलणे” आणि “पुनरावृत्तीच्या कृती सायकलने बदलणे.”
लूपमध्ये शाखा वापरण्याचे मुख्य कारण म्हणजे पॅटर्नमधील विसंगती. मध्यभागी ते प्रारंभिक डेटावर अवलंबून खंडित होते.
जे विद्यार्थी सोप्या तंत्रांचा वापर करून उपाय शोधण्यास सक्षम आहेत, त्यांच्यासाठी "ब्रँचिंग लूपमध्ये लिहिले जाऊ शकते" असे म्हणणे पुरेसे आहे आणि "उदाहरणार्थ" समस्या स्वतंत्रपणे सोडवण्यासाठी पूर्णपणे द्या.
उदाहरण कार्य:

वापरकर्ता 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 ठिकाणी नवीन क्रमांक जोडावा लागेल. "इच्छित" मध्ये फक्त एक शाखा जोडणे पुरेसे आहे.
"इच्छित" पर्यायाचे पुनरुत्पादन करण्यासाठी कार्य सेट करा, नंतर कोडमध्ये नमुना शोधा, व्हेरिएबल बदला आणि लूप लिहा.
या समस्येचे निराकरण इतर मार्गाने कसे करावे याबद्दल आपल्याला कल्पना असल्यास, कृपया टिप्पण्यांमध्ये लिहा.

Loops मध्ये loops

या विषयात तुम्हाला खालील गोष्टींकडे लक्ष देणे आवश्यक आहे.
- आतील आणि बाह्य लूपसाठी काउंटर भिन्न व्हेरिएबल्स असणे आवश्यक आहे.
- आतील लूपसाठी काउंटर अनेक वेळा रीसेट करणे आवश्यक आहे (म्हणजे, बाह्य लूपच्या मुख्य भागामध्ये).
— मजकूर आउटपुट कार्यांमध्ये, आपण प्रथम अनेक ओळींमध्ये एक अक्षर लिहू शकत नाही आणि नंतर दुसरे. तुम्ही प्रथम पहिल्या ओळीतील सर्व अक्षरे, नंतर दुसऱ्या ओळीची सर्व अक्षरे, इत्यादी मुद्रित करणे आवश्यक आहे.

काउंटरला शून्यावर रीसेट करण्याचे महत्त्व समजावून सांगून लूपमधील लूपचा विषय समजावून सांगणे चांगले.
उदाहरण कार्य:

वापरकर्ता दोन अंक प्रविष्ट करतो: R आणि T. "#" वर्णांच्या दोन ओळी मुद्रित करा. पहिल्या ओळीत R वर्ण असावेत. दुसऱ्या ओळीत टी तुकडे आहेत. कोणतीही संख्या ऋणात्मक असल्यास, त्रुटी संदेश प्रदर्शित करा.

R=5, T=11######
#############

R=20, T=3##################
###

R=-1, T=6R मूल्य नॉन-ऋणात्मक असणे आवश्यक आहे

R=6, T=-2टी मूल्य नॉन-ऋणात्मक असणे आवश्यक आहे

साहजिकच, या समस्येला किमान दोन उपाय आहेत.
इच्छित

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

फरक असा आहे की "शक्य" सोल्यूशनमध्ये, दुसरी व्हेरिएबल दुसरी ओळ आउटपुट करण्यासाठी वापरली गेली. तुम्ही दोन्ही लूपसाठी समान व्हेरिएबल वापरण्याचा आग्रह धरला पाहिजे. ही मर्यादा या वस्तुस्थितीद्वारे न्याय्य ठरविली जाऊ शकते की दोन चक्रांसाठी एक काउंटर असलेले समाधान "काउंटर रीसेट" या शब्दाचे उदाहरण असेल. खालील समस्या सोडवताना ही संज्ञा समजून घेणे आवश्यक आहे. तडजोड म्हणून, आपण समस्येचे दोन्ही उपाय जतन करू शकता.

दोन लूपसाठी एक काउंटर व्हेरिएबल वापरण्याची सामान्य समस्या याप्रमाणे दिसते:
R=5, T=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) कीबोर्डवरून प्रविष्ट केली जाते.

W=10
1
2
3
4
5
6
7
8
9

W=100000000000 1111111111 2222222222 3333333333 4444444444 5555555555 6666666666 7777777777 8888888888 9999999999

जर एखाद्या विद्यार्थ्याने व्हेरिएबल बदलण्याच्या तंत्रात प्रभुत्व मिळवले असेल तर तो त्वरीत सामना करेल. व्हेरिएबल रीसेट करताना संभाव्य समस्या पुन्हा येईल. तुम्ही परिवर्तन हाताळू शकत नसल्यास, याचा अर्थ तुम्ही घाईत आहात आणि तुम्हाला सोप्या समस्या सोडवण्याची गरज आहे.

आपण लक्ष दिल्याबद्दल धन्यवाद. चॅनल ला लाईक आणि सबस्क्राईब करा.

PS तुम्हाला मजकूरात टायपिंग किंवा चुका आढळल्यास, कृपया मला कळवा. हे मजकूराचा काही भाग निवडून आणि Mac वर “⌘ + Enter” दाबून आणि क्लासिक कीबोर्डवर “Ctrl/Enter” दाबून किंवा खाजगी संदेशांद्वारे केले जाऊ शकते. हे पर्याय उपलब्ध नसल्यास, टिप्पण्यांमध्ये त्रुटींबद्दल लिहा. धन्यवाद!

केवळ नोंदणीकृत वापरकर्तेच सर्वेक्षणात भाग घेऊ शकतात. साइन इन करा, आपले स्वागत आहे.

कर्माशिवाय वाचकांसाठी मतदान

20,0%मी व्यावसायिकपणे शिकवतो, +12
10,0%मी व्यावसायिक शिकवतो, -11
70,0%मी शिकवत नाही, +17
0,0%मी शिकवत नाही, -10
0,0%इतर0

10 वापरकर्त्यांनी मतदान केले. 5 वापरकर्ते दूर राहिले.

स्त्रोत: www.habr.com

अडचणींवर मात कशी करायची हे शिकवायचे आणि त्याच वेळी चक्र कसे लिहायचे