🥇 कसरी सिकाउने कसरी कठिनाइहरू पार गर्ने, र एकै समयमा चक्र लेख्नुहोस्

यस तथ्यको बावजुद हामी आधारभूत विषयहरू मध्ये एकको बारेमा कुरा गर्नेछौं, यो लेख अनुभवी पेशेवरहरूको लागि लेखिएको हो। लक्ष्य भनेको प्रोग्रामिङमा शुरुआतीहरूले के गलत धारणाहरू छन् भनेर देखाउनु हो। अभ्यास गर्ने विकासकर्ताहरूको लागि, यी समस्याहरू लामो समयदेखि हल भएका छन्, बिर्सिएका छन् वा ध्यान दिएका छैनन्। यदि तपाईंलाई अचानक यस विषयमा कसैलाई मद्दत गर्न आवश्यक छ भने लेख उपयोगी हुन सक्छ। लेख Schildt, Stroustrup, Okulov द्वारा प्रोग्रामिंग मा विभिन्न पुस्तकहरु को सामग्री संग समानता को आकर्षित गर्दछ।

साइकलको बारेमा विषय छनोट गरिएको थियो किनभने प्रोग्रामिङमा महारत हासिल गर्दा धेरै मानिसहरू यसबाट बहिष्कृत हुन्छन्।

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

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

किन यति धेरै पत्र? साइकलहरू धेरै प्राथमिक छन्!

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

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

कसलाई र किन पढाउने?

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

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

पद्धति अभ्यास उन्मुख छ

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

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

पहिलो कार्य सधैं एक उदाहरण हो। दोस्रो थोरै फरक छ र शिक्षकको पर्यवेक्षण अन्तर्गत पहिलो पछि तुरुन्तै "स्वतन्त्र" प्रदर्शन गरिन्छ। सबै पछिल्ला कार्यहरू विभिन्न साना कुराहरूमा ध्यान दिने उद्देश्यले गलत धारणाहरू निम्त्याउन सक्छ।

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

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

जबकि वा लागि?

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

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

मेरो दोस्रो तर्क यो हो कि जब को लागी कम ढाँचा आवश्यक छ। कम ढाँचा भनेको अल्पविराम र कोष्ठकहरू नभएका कम मूर्ख गल्तीहरू हुन्। शुरुआतीहरूले स्वचालित रूपमा वाक्य रचना त्रुटिहरूबाट बच्न पर्याप्त ध्यान र सावधानी विकास गरेका छैनन्।
तेस्रो तर्कलाई धेरै राम्रा पुस्तकहरूमा पहिलो तर्कको रूपमा व्याख्या गरिएको छ।

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

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

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

निहित भन्दा स्पष्ट राम्रो छ

पहिलो लुपिङ कार्यमा एउटै वाक्यांश धेरै पटक प्रदर्शन गर्न राम्रो विचार जस्तो लाग्न सक्छ। उदाहरणका लागि:

हुर्रे, यो काम गर्दछ!
हुर्रे, यो काम गर्दछ!
हुर्रे, यो काम गर्दछ!
हुर्रे, यो काम गर्दछ!
हुर्रे, यो काम गर्दछ!
हुर्रे, यो काम गर्दछ!
हुर्रे, यो काम गर्दछ!
हुर्रे, यो काम गर्दछ!

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

अरूले कसरी व्याख्या गर्छन्?

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

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

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

लोकप्रिय पुस्तकहरूमा, कोड टुक्राहरूको परिणाम सधैं लेखिएको छ। उदाहरण को लागी, Shildt को "Java 8. The Complete Guide" 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

टेम्प्लेट, उदाहरण कार्यक्रम र कार्यक्रमको नतिजाको वर्णन गर्ने दृष्टिकोण पनि "बालकहरूको लागि Javascript" पुस्तकमा र w3schools.com मा js पाठ्यक्रममा प्रयोग गरिन्छ। वेब पृष्ठ ढाँचाले पनि यो उदाहरण अन्तरक्रियात्मक हुन अनुमति दिन्छ।

Stroustrup को 2016 को पुस्तक सिद्धान्त र अभ्यास 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;
    }
}

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

जसरी म आफैंलाई बुझाउँछु

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

यस कार्यमा हामी जटिल समस्याहरू समाधान गर्नका लागि प्रविधिहरूमा परिचय गराइन्छौं। प्रारम्भिक निर्णय आदिम र सरल बनाउन आवश्यक छ। ठीक छ, त्यसोभए तपाईले यो समाधान कसरी सुधार गर्ने बारे सोच्न सक्नुहुन्छ।
Введение Глава 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 मा सीमा मान परिवर्तन गर्नुहोस्।
लूपमा भएका कार्यहरू रोक बिना, अनिश्चित कालका लागि गरिन्छ। समाधानहरू:
- यदि हराइरहेको छ भने काउन्टर परिवर्तन आदेश थप्नुहोस्।
- काउन्टर परिवर्तन आदेश ठीक गर्नुहोस् ताकि यसको मान सीमाको नजिक हुन्छ।
- यदि यो लूपको मुख्य भागमा छ भने अवरोध परिवर्तन आदेश हटाउनुहोस्।
लुपमा हुने कार्यहरूको संख्या १ भन्दा कम वा अपेक्षित भन्दा बढी छ। लुपमा भएको कार्य एक पटक पनि कार्यान्वयन भएन। पहिले तपाईंले लूप सुरु हुनु अघि चरहरूको वास्तविक मानहरू पत्ता लगाउन आवश्यक छ। समाधानहरू:
- बाधा को प्रारम्भिक मान परिवर्तन
- काउन्टरको प्रारम्भिक मान परिवर्तन गर्नुहोस्

समस्या 3 मा सामान्यतया गलत चर प्रयोग गर्ने वा काउन्टरलाई शून्यमा रिसेट नगर्ने समावेश हुन्छ।

यस स्पष्टीकरण पछि, विद्यार्थीले कसरी लूपले काम गर्छ भन्ने बारे विभिन्न गलत धारणाहरू हुन सक्छ।
सबैभन्दा सामान्यहरूलाई हटाउन, म तपाईंलाई निम्न कार्यहरू दिन्छु:

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

प्रत्येक कार्यको लागि तपाईंले परीक्षण डेटा र अपेक्षित परिणाम प्रदान गर्न आवश्यक छ।

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

लूप र शाखाहरू

मेरो विचारमा, "शाखा भित्रको चक्र" छुट्टै विषय दिनु उपयुक्त हुन्छ। ताकि पछि तपाईले एक सर्त धेरै पटक जाँच गर्नु र एक पटक जाँच गर्नु बीचको भिन्नता देख्न सक्नुहुन्छ।
समेकनका लागि कार्यहरू A देखि B सम्मको संख्याहरू आउटपुट गर्ने बारे हुनेछ, जुन प्रयोगकर्ताद्वारा प्रविष्ट गरिएको छ:
- सधैं आरोही क्रममा।
- A र B को मानहरूमा निर्भर गर्दै आरोही वा घट्दो।

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

प्रयोगकर्ताले X नम्बर प्रविष्ट गर्दछ। स्तम्भमा 0 देखि 9 सम्मको संख्याहरू प्रदर्शन गर्नुहोस् र X बराबरको संख्याको विपरीत '+' चिन्ह राख्नुहोस्।

यदि ० प्रविष्ट गरिएको थियो0+
1
2
3
4
5
6
7
8
9

यदि ० प्रविष्ट गरिएको थियो0
1
2
3
4
5
6+
7
8
9

यदि ० प्रविष्ट गरिएको थियो0
1
2
3
4
5
6
7
8
9+

यदि ० प्रविष्ट गरिएको थियो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+");
}

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

लुप्स भित्र लूपहरू

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

काउन्टरलाई शून्यमा रिसेट गर्ने महत्त्वको व्याख्या गरेर लूप भित्र लूपहरूको विषयलाई व्याख्या गर्न सुरु गर्नु उत्तम हुन्छ।
उदाहरण कार्य:

प्रयोगकर्ताले दुई नम्बरहरू प्रविष्ट गर्दछ: R र T। "#" अक्षरहरूको दुई रेखाहरू छाप्नुहोस्। पहिलो पङ्क्तिमा R वर्णहरू हुनुपर्छ। दोस्रो लाइनमा T टुक्राहरू छन्। यदि कुनै संख्या ऋणात्मक छ भने, त्रुटि सन्देश देखाउनुहोस्।

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

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

R=-1, T=6R मान गैर-ऋणात्मक हुनुपर्छ

R=6, T=-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;
}

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

दुई लूपहरूको लागि एक काउन्टर चर प्रयोग गर्ने सामान्य समस्या यस्तो देखिन्छ:
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 यदि तपाईंले पाठमा typos वा त्रुटिहरू फेला पार्नुभयो भने, कृपया मलाई थाहा दिनुहोस्। यो पाठको अंश चयन गरेर र Mac मा "⌘ + Enter" र क्लासिक किबोर्डहरूमा "Ctrl / Enter" थिचेर वा निजी सन्देशहरू मार्फत गर्न सकिन्छ। यदि यी विकल्पहरू उपलब्ध छैनन् भने, टिप्पणीहरूमा त्रुटिहरूको बारेमा लेख्नुहोस्। धन्यवाद!

दर्ता भएका प्रयोगकर्ताहरूले मात्र सर्वेक्षणमा भाग लिन सक्छन्। साइन इन गर्नुहोस्कृपया

कर्म बिना पाठकहरूको लागि पोल

20,0%म व्यावसायिक रूपमा पढाउँछु, +12
10,0%म व्यावसायिक रूपमा पढाउँछु, -11
70,0%म सिकाउँदैन, +17
0,0%म सिकाउँदैन, -10
0,0%अन्य ०

10 प्रयोगकर्ताहरूले मतदान गरे। 5 प्रयोगकर्ताहरू रोकिए।

स्रोत: www.habr.com

कसरी सिकाउने कसरी कठिनाइहरू पार गर्ने, र एकै समयमा चक्र लेख्नुहोस्