როგორ ვასწავლოთ როგორ გადავლახოთ სირთულეები და ამავდროულად დავწეროთ ციკლები

მიუხედავად იმისა, რომ ჩვენ ვისაუბრებთ ერთ-ერთ ძირითად თემაზე, ეს სტატია დაწერილია გამოცდილი პროფესიონალებისთვის. მიზანია აჩვენოს რა მცდარი წარმოდგენები აქვთ დამწყებთათვის პროგრამირებაში. პრაქტიკოსი დეველოპერებისთვის ეს პრობლემები დიდი ხანია მოგვარებულია, დავიწყებული ან საერთოდ არ შენიშნა. სტატია შეიძლება გამოგადგეთ, თუ მოულოდნელად დაგჭირდებათ ვინმეს დახმარება ამ თემაზე. სტატიაში ავლებს პარალელებს შილდტის, სტროუსტრუპის, ოკულოვის პროგრამირების სხვადასხვა წიგნების მასალასთან.

ციკლების შესახებ თემა იმიტომ შეირჩა, რომ პროგრამირების დაუფლებისას საკმაოდ ბევრი ადამიანია გამორიცხული.

ეს ტექნიკა განკუთვნილია სუსტი სტუდენტებისთვის. როგორც წესი, ძლიერი ხალხი ამ თემაზე არ იჭედება და არ არის საჭირო მათთვის სპეციალური ტექნიკის გამომუშავება. სტატიის მეორადი მიზანია ამ ტექნიკის გადატანა კლასიდან „მუშაობს ყველა მოსწავლისთვის, მაგრამ მხოლოდ ერთი მასწავლებელი“ კლასში „მუშაობს ყველა მოსწავლისთვის, ყველა მასწავლებლისთვის“. აბსოლუტურ ორიგინალურობას არ ვამტკიცებ. თუ თქვენ უკვე იყენებთ მსგავს მეთოდოლოგიას ამ თემის სწავლებისთვის, გთხოვთ დაწეროთ, როგორ განსხვავდება თქვენი ვერსია. თუ გადაწყვეტთ მის გამოყენებას, გვითხარით როგორ წავიდა. თუ მსგავსი ტექნიკა აღწერილია წიგნში, გთხოვთ დაწეროთ სახელი.

ამ ტექნიკაზე 4 წელი ვიმუშავე, ინდივიდუალურად ვსწავლობდი სხვადასხვა დონის ტრენინგის სტუდენტებთან. სულ ორმოცდაათამდე სტუდენტი და ორი ათასი საათი გაკვეთილია. თავიდან სტუდენტები ყოველთვის ჩერდებოდნენ ამ თემაზე და ტოვებდნენ. თითოეული მოსწავლის შემდეგ ხდებოდა მეთოდოლოგია და მასალების კორექტირება. გასული წლის განმავლობაში, სტუდენტები აღარ ჩერდებოდნენ ამ თემაზე, ამიტომ გადავწყვიტე გამეზიარებინა ჩემი დასკვნები.

რატომ ამდენი ასო? ციკლები ისეთი ელემენტარულია!

როგორც ზემოთ დავწერე, პრაქტიკოსი დეველოპერებისთვის და ძლიერი სტუდენტებისთვის, მარყუჟების კონცეფციის სირთულე შეიძლება არ იყოს შეფასებული. მაგალითად, შეგიძლიათ წაიკითხოთ გრძელი ლექცია, ნახოთ თავები და გონიერი თვალები. მაგრამ როდესაც რაიმე პრობლემის გადაჭრას ცდილობს, სისულელე და აუხსნელი პრობლემები იწყება. ლექციის შემდეგ სტუდენტებს ალბათ მხოლოდ ნაწილობრივი გაგება ჰქონდათ. სიტუაციას ისიც ამძიმებს, რომ თავად სტუდენტები ვერ ახმოვანებენ კონკრეტულად რა არის მათი ბოდვა.
ერთ დღეს მივხვდი, რომ სტუდენტები ჩემს მაგალითებს იეროგლიფებად აღიქვამდნენ. ანუ, როგორც ტექსტის განუყოფელი ნაწილები, რომელშიც თქვენ უნდა დაამატოთ რაიმე „ჯადოსნური“ ასო და ის იმუშავებს.
ხანდახან ვამჩნევდი, რომ სტუდენტები ფიქრობენ, რომ კონკრეტული პრობლემის გადაჭრა გჭირდებათ კიდევ რაღაც დიზაინი, რომელიც ჯერ არ გამიკეთებია. მიუხედავად იმისა, რომ გამოსავალი მოითხოვდა მაგალითის მხოლოდ მცირე ცვლილებას.

ასე რომ, მე გამოვიტანე იდეა, რომ აქცენტი უნდა იყოს არა გამონათქვამების სინტაქსზე, არამედ მარყუჟების გამოყენებით განმეორებადი კოდის გადაკეთების იდეაზე. მას შემდეგ რაც სტუდენტები აითვისებენ ამ იდეას, ნებისმიერი სინტაქსი შეიძლება გაუმჯობესდეს მცირე პრაქტიკით.

ვინ და რატომ ვასწავლი?

იმის გამო, რომ არ არის მისაღები გამოცდები, კლასებში შეიძლება შევიდეს როგორც ძლიერი, ასევე ძალიან სუსტი სტუდენტები. ჩემი სტუდენტების შესახებ მეტი შეგიძლიათ წაიკითხოთ სტატიაში საღამოს კურსის სტუდენტების პორტრეტი
მე ვცდილობდი იმის უზრუნველყოფა, რომ ყველას, ვისაც პროგრამირების სწავლა სურს, შეეძლოს მისი სწავლა.
ჩემი მეცადინეობები ტარდება ინდივიდუალურად და სტუდენტი თითოეულში თავის ფულს იხდის. როგორც ჩანს, სტუდენტები გააუმჯობესებენ ხარჯებს და მოითხოვენ მინიმუმს. თუმცა, ადამიანები დადიან პირისპირ გაკვეთილებზე ცოცხალ მასწავლებელთან არა თავად ცოდნისთვის, არამედ ნასწავლის ნდობისთვის, პროგრესის განცდისა და ექსპერტის (მასწავლებლის) დამტკიცებისთვის. თუ მოსწავლეები ვერ გრძნობენ პროგრესს სწავლაში, ისინი დატოვებენ. ზოგადად, კლასები შეიძლება იყოს სტრუქტურირებული ისე, რომ სტუდენტებმა იგრძნონ პროგრესი ნაცნობი სტრუქტურების რაოდენობის გაზრდაში. ანუ ჯერ დეტალურად ვსწავლობთ, მერე ვსწავლობთ, მერე ვაკეთებთ და ახლა გვაქვს მზად ათასი და ერთი ღამის კურსი, რომელშიც მხოლოდ ციკლებს სწავლობენ ორი თვე და ბოლოს - სტუდენტი, რომელიც წერდა. სტანდარტული ბიბლიოთეკა კარნახით. ამასთან, პრაქტიკული პრობლემების გადასაჭრელად საჭიროა არა მხოლოდ მასალის ცოდნა, არამედ დამოუკიდებლობა მის გამოყენებაში და ახალი ინფორმაციის ძიებაში. ამიტომ, პირისპირ კურსებისთვის, ვფიქრობ, სწორი პრინციპია მინიმუმის სწავლება და ნიუანსებისა და მასთან დაკავშირებული თემების დამოუკიდებელი შესწავლის წახალისება. მარყუჟების თემაში მინიმალურად მიმაჩნია while კონსტრუქცია. მისგან შეგიძლიათ გაიგოთ პრინციპი. პრინციპის ცოდნით, შეგიძლიათ დაეუფლოთ როგორც საკუთარ თავს, ისე ამის გაკეთებას.

სუსტი მოსწავლეების მიერ მასალის ათვისების მისაღწევად სინტაქსის აღწერა საკმარისი არ არის. აუცილებელია უფრო მარტივი, მაგრამ მრავალფეროვანი ამოცანების მიცემა და მაგალითების უფრო დეტალურად აღწერა. საბოლოო ჯამში, განვითარების სიჩქარე შემოიფარგლება მოსწავლის უნარით გარდაქმნას გამონათქვამები და ეძებოს შაბლონები. ჭკვიანი სტუდენტებისთვის დავალებების უმეტესობა მოსაწყენი იქნება. მათთან სწავლისას არ უნდა მოითხოვოთ პრობლემების 100%-ით გადაჭრა. ჩემი მასალის ნახვა შეგიძლიათ აქ ჩემი გიტუბი. მართალია, საცავი მეორელის გრიმუარს უფრო ჰგავს - ჩემს გარდა ვერავინ გაიგებს, სად არის და თუ შემოწმებას ვერ შეძლებ, გაგიჟდები.

მეთოდოლოგია პრაქტიკაზეა ორიენტირებული

თეორია ახსნილია პრობლემის გადაჭრის მაგალითის გამოყენებით. პროგრამირების საფუძვლების კლასში, სადაც ისწავლება განშტოებები და მარყუჟები, უბრალოდ შეუძლებელია ერთ თემაზე სასარგებლო ლექციის წაკითხვა მთელი საათის განმავლობაში. კონცეფციის ასახსნელად საკმარისია 15-20 წუთი. ძირითადი სირთულეები წარმოიქმნება პრაქტიკული ამოცანების შესრულებისას.
დამწყებ მასწავლებელს შეუძლია ერთ ლექციაზე ატეხოს ოპერატორები, განშტოებები, მარყუჟები და მასივები. მაგრამ მათ მოსწავლეებს შეექმნებათ ამ ინფორმაციის ათვისების პრობლემა.
საჭიროა არა მხოლოდ მასალის მოყოლა, არამედ იმის უზრუნველყოფა, რომ მსმენელს ესმის.

თემის ათვისების ფაქტი განისაზღვრება იმით, თუ როგორ ართმევს თავს მოსწავლე დამოუკიდებელ სამუშაოს.
თუ მოსწავლემ მასწავლებლის დახმარების გარეშე მოახერხა პრობლემის გადაჭრა თემაზე, მაშინ ეს თემა აითვისა. თვითშემოწმების უზრუნველსაყოფად, თითოეული დავალება აღწერილია ცხრილში ტესტის სცენარებით. დავალებებს აქვს მკაფიო თანმიმდევრობა. არ არის რეკომენდებული დავალებების გამოტოვება. თუ მიმდინარე დავალება ძალიან რთულია, შემდეგზე გადასვლა უსარგებლოა. ეს კიდევ უფრო რთულია. იმისათვის, რომ მოსწავლემ შეძლოს მიმდინარე რთული ამოცანის ათვისება, მას უხსნის რამდენიმე ტექნიკას პირველი ამოცანის მაგალითის გამოყენებით. სინამდვილეში, თემის მთელი შინაარსი სირთულეების დაძლევის ტექნიკაზე მოდის. ციკლები უფრო გვერდითი ეფექტია.

პირველი ამოცანა ყოველთვის მაგალითია. მეორე ოდნავ განსხვავდება და შესრულებულია "დამოუკიდებლად" პირველის შემდეგ დაუყოვნებლივ მასწავლებლის მეთვალყურეობის ქვეშ. ყველა შემდგომი დავალება მიზნად ისახავს ყურადღების მიქცევას სხვადასხვა წვრილმანებზე, რამაც შეიძლება გამოიწვიოს მცდარი წარმოდგენები.

მაგალითის ახსნა არის დიალოგი, რომელშიც მოსწავლეს სჭირდება გამრავლება და ჯვარედინი დადასტურება, რათა დარწმუნდეს, რომ მან აითვისა მასალის ნაწილი.

ვიქნები ბანალური და ვიტყვი, რომ პირველი მაგალითი თემაზე ძალიან მნიშვნელოვანია. თუ თქვენ გაქვთ მასალა ვრცელი დამოუკიდებელი მუშაობისთვის, პირველი მაგალითის გამოტოვება შეიძლება გამოსწორდეს. თუ მაგალითის გარდა სხვა არაფერია, მაშინ სტუდენტი დიდი ალბათობით ვერ დაეუფლება თემას.

სანამ ან ამისთვის?

ერთ-ერთი საკამათო საკითხია კონსტრუქციის არჩევანი მაგალითად: ხოლო ან ამისთვის. ერთხელ ჩემმა პრაქტიკოსმა დეველოპერმა მეგობარმა, რომელსაც არ აქვს სწავლების გამოცდილება, ერთი საათი დამარწმუნა, რომ for loop ყველაზე მარტივი გასაგები იყო. არგუმენტები ჩამოყალიბდა იმით, რომ „მასში ყველაფერი ნათელია და თავის ადგილზეა ჩამოყალიბებული“. თუმცა, ნამდვილი დამწყებთათვის სირთულეების ძირითადი მიზეზი არის თავად ციკლის იდეა და არა მისი წერა. თუ ადამიანს ეს აზრი არ ესმის, მაშინ მას გაუჭირდება სინტაქსი. როგორც კი იდეა განხორციელდება, კოდის დიზაინის პრობლემები თავისთავად ქრება.

ჩემს მასალებში მარყუჟების თემა მიჰყვება განშტოების თემას. if და while-ის გარეგანი მსგავსება საშუალებას გვაძლევს დავხატოთ პირდაპირი ანალოგია: „როდესაც სათაურში არსებული მდგომარეობა მართალია, მაშინ სხეული სრულდება“. ციკლის ერთადერთი თავისებურება ის არის, რომ სხეული მრავალჯერ სრულდება.

ჩემი მეორე არგუმენტი არის ის, რომ ხოლო მოითხოვს ნაკლებ ფორმატირებას, ვიდრე for. ნაკლები ფორმატირება ნიშნავს ნაკლებ სულელურ შეცდომებს გამოტოვებული მძიმეებით და ფრჩხილებით. დამწყებთათვის ჯერ არ გამოუმუშავდათ საკმარისი ყურადღება და ზედმიწევნითობა, რათა ავტომატურად აიცილონ სინტაქსის შეცდომები.
მესამე არგუმენტი ახსნილია ბევრ კარგ წიგნში, როგორც პირველი არგუმენტი.

თუ მოსწავლეს შეუძლია მარტივად გარდაქმნას გამონათქვამები, მაშინ თქვენ შეგიძლიათ გაიგოთ ჩაბარებით. შემდეგ მოსწავლე აირჩევს იმას, რაც მას ყველაზე მეტად მოსწონს. თუ გარდაქმნები იწვევს სირთულეებს, მაშინ უმჯობესია არ გადაიტანოთ ყურადღება. მიეცით საშუალება მოსწავლეს ჯერ ამოხსნას ყველაფერი while გამოყენებით. მას შემდეგ რაც აითვისებთ მარყუჟების თემას, შეგიძლიათ გადაწეროთ გადაწყვეტილებები, რათა ივარჯიშოთ კონვერტაციისთვის, ხოლო for-ში.
პოსტკონდიციური მარყუჟები საკმაოდ იშვიათი მხეციაა. მე საერთოდ არ ვხარჯავ მასზე დროს. თუ მოსწავლემ აითვისა ნიმუშების იდენტიფიცირებისა და გამონათქვამების გარდაქმნის იდეები, მას შეუძლია ამის გარკვევა ჩემი დახმარების გარეშე.

ძლიერი სტუდენტებისთვის პირველი მაგალითის დემონსტრირებისას ყურადღებას ვაქცევ იმ ფაქტს, რომ პირველ მაგალითში მნიშვნელოვანია ჩაწეროთ არა მხოლოდ გამოსავალი, არამედ მოქმედებების მთელი ჯაჭვი, რამაც გამოიწვია შედეგი. ზარმაცი მოსწავლეებს შეუძლიათ უგულებელყვნენ ნაწერი და დააკოპირონ მხოლოდ საბოლოო ალგორითმი. მათ უნდა დარწმუნდნენ, რომ ერთ დღეს მათ წინაშე რთული ამოცანა დადგება. მის გადასაჭრელად, თქვენ უნდა შეასრულოთ ნაბიჯები, როგორც ამ მაგალითში. ამიტომ მნიშვნელოვანია ყველა ეტაპის ჩაწერა. შემდეგ პრობლემებში შესაძლებელი იქნება გადაწყვეტის მხოლოდ საბოლოო ვერსიის დატოვება.

ავტომატიზაციის მთავარი იდეა არის ის, რომ ჩვენ კომპიუტერს ვანდობთ ადამიანის რუტინული სამუშაოს შესრულებას. ერთ-ერთი ძირითადი ტექნიკაა მარყუჟების წერა. იგი გამოიყენება, როდესაც პროგრამაში ზედიზედ რამდენიმე იდენტური განმეორებითი მოქმედებაა ჩაწერილი.

აშკარა სჯობს იმპლიციტურს

შეიძლება კარგი იდეა ჩანდეს ერთი და იგივე ფრაზის მრავალჯერ ჩვენება პირველ მარყუჟის ამოცანაში. Მაგალითად:

ჩქარა, მუშაობს!
ჩქარა, მუშაობს!
ჩქარა, მუშაობს!
ჩქარა, მუშაობს!
ჩქარა, მუშაობს!
ჩქარა, მუშაობს!
ჩქარა, მუშაობს!
ჩქარა, მუშაობს!

ეს ვარიანტი ცუდია, რადგან მრიცხველის მნიშვნელობა არ ჩანს გამოსავალში. დამწყებთათვის ეს პრობლემაა. ნუ შეაფასებ მას. თავიდან ეს ამოცანა პირველი იყო, ხოლო რიცხვების სერიის აღმავალი წესით გამოყვანის ამოცანა მეორე იყო. საჭირო იყო დამატებითი ტერმინების „ციკლი N ჯერ“ და „ციკლი A-დან B-მდე“ შემოღება, რომლებიც არსებითად ერთი და იგივეა. იმისათვის, რომ არ შემექმნა ზედმეტი ერთეულები, მე გადავწყვიტე მეჩვენებინა მხოლოდ მაგალითი რიცხვების სერიის გამომავალით. ცოტა ადამიანი ახერხებს ისწავლოს როგორ დაიჭიროს თავში მრიცხველი და მოახდინოს პროგრამის ქცევის მოდელირება თავის თავში მომზადების გარეშე. ზოგიერთი სტუდენტი პირველად ხვდება მენტალურ მოდელირებას ციკლების თემაზე.
გარკვეული ვარჯიშის შემდეგ ვაძლევ დამოუკიდებლად ამოსახსნელად იმავე ტექსტის გამეორების დავალებას. თუ ჯერ ხილულ მრიცხველს აძლევთ და შემდეგ უხილავს, მოსწავლეებს ნაკლები პრობლემები ექნებათ. ზოგჯერ მინიშნება "არ დაწერო მრიცხველი ეკრანზე" საკმარისია.

სხვები როგორ ხსნიან?

ინტერნეტის საგანმანათლებლო მასალებში უმეტესობაში ციკლის სინტაქსი მოცემულია „ლექციის“ ფარგლებში. მაგალითად, developer.mozilla.org-ზე (ამჟამად), რამდენიმე სხვა კონსტრუქცია აღწერილია while ციკლთან ერთად. ამ შემთხვევაში, მხოლოდ თავად დიზაინები მოცემულია შაბლონების სახით. მათი გაშვების შედეგი სიტყვებით არის აღწერილი, მაგრამ ილუსტრაცია არ არსებობს. ჩემი აზრით, თემის ასეთი პრეზენტაცია ასეთი მასალების სარგებლიანობას ნულზე ამრავლებს. მოსწავლეს შეუძლია კოდი გადაწეროს და თვითონ გაუშვას, მაგრამ შედარებისთვის სტანდარტი მაინც სჭირდება. როგორ გესმით, რომ მაგალითი სწორად არის გადაწერილი, თუ შედეგის შედარება არაფერია?
როდესაც მხოლოდ შაბლონი მოცემულია, მაგალითის გარეშე, ეს კიდევ უფრო რთული ხდება სტუდენტისთვის. როგორ გავიგოთ, რომ კოდის ფრაგმენტები სწორად არის განთავსებული შაბლონში? შეგიძლიათ სცადოთ დაწერა როგორმედა შემდეგ გაიქეცი. მაგრამ თუ არ არსებობს სტანდარტი შედეგის შესადარებლად, მაშინ გაშვება არც დაეხმარება.

C++ კურსში ინტუიციურზე, მარყუჟის სინტაქსი ჩაფლულია მე-4 ლექციის მესამე გვერდზე თემაზე „ოპერატორები“. მარყუჟების სინტაქსის ახსნისას განსაკუთრებული აქცენტი კეთდება ტერმინ „ოპერატორზე“. ტერმინი წარმოდგენილია როგორც ფაქტების ერთობლიობა, როგორიცაა „სიმბოლო; ეს არის განცხადება", "{} არის რთული წინადადება", "ციკლის სხეული უნდა იყოს განცხადება". მე არ მომწონს ეს მიდგომა, რადგან თითქოს ის მალავს მნიშვნელოვან ურთიერთობებს ერთი ტერმინის მიღმა. პროგრამის საწყისი კოდის ტერმინებად დაყოფა ამ დონეზე საჭიროა შემდგენელი დეველოპერებისთვის ენის სპეციფიკაციის განსახორციელებლად, მაგრამ არა სტუდენტებისთვის, როგორც პირველი მიახლოებით. პროგრამირების ახალწვეულები იშვიათად არიან საკმარისად ზედმიწევნითი, რომ ასეთი დიდი ყურადღება მიაქციონ ტერმინებს. ეს იშვიათი ადამიანია, რომელსაც პირველად ახსოვს და ესმის ახალი სიტყვები. თითქმის ვერავინ შეძლებს სწორად გამოიყენოს ტერმინი, რომელიც ახლახან ისწავლა. ამიტომ, სტუდენტები იღებენ უამრავ შეცდომას, როგორიცაა "მე დავწერე while(a<7);{, მაგრამ პროგრამა არ მუშაობს."
ჩემი აზრით, თავიდან ჯობია კონსტრუქციის სინტაქსი მაშინვე მივცეთ ფრჩხილებით. ვარიანტი ფრჩხილების გარეშე უნდა იყოს ახსნილი მხოლოდ იმ შემთხვევაში, თუ სტუდენტს აქვს კონკრეტული შეკითხვა: „რატომ არ არის ფრჩხილები და მუშაობს“.

ოკულოვის 2012 წლის წიგნში "პროგრამირების საფუძვლები", მარყუჟების შესავალი იწყება for ნიმუშით, შემდეგ იძლევა რეკომენდაციებს მისი გამოყენების შესახებ და შემდეგ დაუყოვნებლივ გადადის გაკვეთილის ექსპერიმენტულ განყოფილებაში. მესმის, რომ წიგნი დაიწერა იმ უმცირესობისთვის, რომელიც ძალიან ნიჭიერი სტუდენტებისთვისაა, რომლებიც იშვიათად მოდიან ჩემს გაკვეთილებზე.

პოპულარულ წიგნებში ყოველთვის იწერება კოდის ფრაგმენტების შედეგი. მაგალითად, შილტის "ჯავა 8. სრული გზამკვლევი" 2015 წლის გამოცემა. ჯერ მოცემულია შაბლონი, შემდეგ პროგრამის მაგალითი და მაშინვე - შესრულების შედეგი.

მაგალითად, განიხილეთ while ციკლი, რომელიც საპირისპიროს აკეთებს
ათვლა იწყება 10-დან და ნაჩვენებია ზუსტად 10 სტრიქონი "ზომები":

//Продемонстрировать применение оператора цикла while
class While {
    public static void main(String args []) {
        int n = 10;
        while (n > 0) {
            System.out.println("такт " + n);
            n--;
        }
    }
}

გაშვების შემდეგ, ეს პროგრამა გამოსცემს ათ "ციკლს" შემდეგნაირად:
такт 10
такт 9
такт 8
такт 7
такт 6
такт 5
такт 4
такт 3
такт 2
такт 1

შაბლონის, მაგალითის პროგრამისა და პროგრამის შედეგის აღწერის მიდგომა ასევე გამოყენებულია წიგნში „Javascript ბავშვებისთვის“ და js კურსში w3schools.com-ზე. ვებ გვერდის ფორმატი კი საშუალებას აძლევს ამ მაგალითს იყოს ინტერაქტიული.

Stroustrup-ის 2016 წლის წიგნი პრინციპები და პრაქტიკა C++-ის გამოყენებით კიდევ უფრო შორს წავიდა. პირველი ნაბიჯი არის იმის ახსნა, თუ რა შედეგი უნდა მივიღოთ და ამის შემდეგ ნაჩვენებია პროგრამის ტექსტი. უფრო მეტიც, ისინი მაგალითს იღებენ არა მხოლოდ შემთხვევით პროგრამას, არამედ ატარებენ ექსკურსიას ისტორიაში. ეს ხელს უწყობს მასზე ყურადღების მიქცევას: „აჰა, ეს არ არის მხოლოდ რაღაც უსარგებლო ტექსტი. თქვენ ხედავთ რაღაც მნიშვნელოვანს."

როგორც გამეორების მაგალითი, განვიხილოთ პირველი პროგრამა, რომელიც შესრულებულია შენახულ პროგრამულ მანქანაზე (EDSAC). იგი დაიწერა დევიდ უილერმა კემბრიჯის უნივერსიტეტის კომპიუტერულ ლაბორატორიაში, ინგლისი 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;
    }
}

საინტერესოა, რომ სინტაქსის ნიმუში არ არის აღწერილი ამ წიგნში. 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("Заключение");

კოდში „ცვლადის ნიმუშის გამოხატვის“ ტექნიკის გამოყენების შემდეგ, თქვენ მიიღებთ იდენტური ქმედებების რამდენიმე ჯგუფს, რომლებიც მიდიან ზედიზედ. ახლა განმეორებითი მოქმედებები შეიძლება შეიცვალოს მარყუჟით.

პრობლემის გადაჭრის თანმიმდევრობა, სადაც საჭიროა მარყუჟების გამოყენება, შედგება შემდეგი ნაბიჯებისგან:

1. ამოხსენით „პირადი“ მრავალი ცალკეული ბრძანებით
2. იპოვნეთ ნიმუში
3. გამოხატეთ ცვლადის ნიმუში
4. დიზაინი, როგორც ციკლი

შემდეგი, შემოდის ახალი ტერმინები, რათა სტუდენტი არ აღმოჩნდეს სიტუაციაში: „ყველაფერი მესმის, მაგრამ არ შემიძლია ამის თქმა“:
— მრიცხველი ყოველთვის არის ცვლადი, რომელიც საჭიროა მარყუჟში ნაბიჯების რაოდენობის დასაკვირვებლად. როგორც წესი, მთელი რიცხვი, რომელიც შედარებულია შეზღუდვასთან.
— მრიცხველის ნაბიჯი — მრიცხველის ცვლილებების ნიმუშის აღწერა.
- შეზღუდვა - რიცხვი ან ცვლადი, რომელთანაც მრიცხველი შედარებულია ისე, რომ ალგორითმი საბოლოო იყოს. მრიცხველი იცვლება ლიმიტის მიახლოების მიზნით.
— loop body — ბრძანებების ნაკრები, რომელიც განმეორდება. როდესაც ისინი ამბობენ "ბრძანება იწერება მარყუჟის შიგნით", ისინი გულისხმობენ სხეულს.
— მარყუჟის გამეორება — მარყუჟის სხეულის ერთჯერადი შესრულება.
— მარყუჟის მდგომარეობა — ლოგიკური გამოხატულება, რომელიც განსაზღვრავს შესრულდება თუ არა სხვა გამეორება. (აქ შეიძლება იყოს დაბნეულობა განშტოების სტრუქტურებთან)
თქვენ უნდა მოემზადოთ იმისთვის, რომ თავდაპირველად სტუდენტები გამოიყენებენ ტერმინებს სხვა მიზნებისთვის. ეს ეხება როგორც ძლიერებს, ასევე სუსტებს. საერთო ენის ჩამოყალიბება ხელოვნებაა. ახლა მოკლედ დავწერ: თქვენ უნდა დააყენოთ დავალება „მონიშნეთ კოდის ფრაგმენტი <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-ზე.
2. მარყუჟში მოქმედებები შესრულებულია შეუჩერებლად, განუსაზღვრელი ვადით. გადაწყვეტილებები:
   - დაამატეთ მრიცხველის შეცვლის ბრძანება, თუ ის აკლია.
   — დააფიქსირეთ მრიცხველის შეცვლის ბრძანება ისე, რომ მისი მნიშვნელობა მიუახლოვდეს ზღვარს.
   — ამოიღეთ შეზღუდვის შეცვლის ბრძანება, თუ ის მარყუჟის სხეულშია.
3. ციკლში მოქმედებების რაოდენობა არის 1-ზე მეტი ან მეტი ვიდრე მოსალოდნელია. მარყუჟში მოქმედება ერთხელაც არ შესრულებულა. ჯერ უნდა გაარკვიოთ ცვლადების რეალური მნიშვნელობები მარყუჟის დაწყებამდე. გადაწყვეტილებები:
   — შეცვალეთ შეზღუდვის საწყისი მნიშვნელობა
   — შეცვალეთ მრიცხველის საწყისი მნიშვნელობა

პრობლემა 3, როგორც წესი, გულისხმობს არასწორი ცვლადის გამოყენებას ან მრიცხველის ნულზე გადატვირთვას.

ამ ახსნის შემდეგ, სტუდენტს შეიძლება კვლავ ჰქონდეს სხვადასხვა მცდარი წარმოდგენა იმის შესახებ, თუ როგორ მუშაობს მარყუჟები.
ყველაზე გავრცელებულის გასაქრობად, მე გაძლევთ შემდეგ დავალებებს:

1. რომელშიც ლიმიტი, საწყისი მრიცხველის მნიშვნელობა ან მრიცხველის ნაბიჯი შეიყვანება მომხმარებლის მიერ.
2. რომელშიც მრიცხველის მნიშვნელობა უნდა იყოს გამოყენებული რაიმე არითმეტიკული გამოსახულებით. მიზანშეწონილია მრიცხველის გამოყენება რადიკალურ გამოხატულებაში ან მნიშვნელში ისე, რომ განსხვავება იყოს არაწრფივი.
3. რომელშიც მრიცხველის მნიშვნელობა არ არის ნაჩვენები ეკრანზე, სანამ ციკლი მუშაობს. მაგალითად, იდენტური ტექსტის ფრაგმენტების საჭირო რაოდენობის ჩვენება ან ფიგურის დახატვა კუს გრაფიკით.
4. რომელშიც ჯერ უნდა შეასრულოთ რამდენიმე განმეორებადი მოქმედება, შემდეგ კი სხვები.
5. რომელშიც თქვენ უნდა შეასრულოთ სხვა მოქმედებები გამეორებამდე და გამეორების შემდეგ

თითოეული ამოცანისთვის თქვენ უნდა მიაწოდოთ ტესტის მონაცემები და მოსალოდნელი შედეგი.

იმის გასაგებად, თუ რამდენად სწრაფად შეგიძლიათ გადაადგილება, თქვენ უნდა წაიკითხოთ ამ პრობლემების პირობები და ჰკითხოთ: "რით განსხვავდებიან ისინი მაგალითისგან?", "რა უნდა შეიცვალოს მაგალითში მათი გადასაჭრელად?" თუ მოსწავლე აზრობრივად პასუხობს, მაშინ მიეცით, რომ კლასში ერთი მაინც გადაჭრას, დანარჩენი კი საკუთარ სახლში. თუ გამოსავალი წარმატებულია, მაშინ ჩვენ შეგვიძლია დავიწყოთ მარყუჟების შიგნით არსებული პირობების ახსნა.
თუ პრობლემები გაქვთ დამოუკიდებლად გადაჭრით, თქვენ უნდა იმუშაოთ კლასში. იმისათვის, რომ პრობლემის გადაჭრა არ მოგაგონებთ ბუს დახატვას, გირჩევთ პირველ რიგში პრობლემის გადაჭრა არა უნივერსალური გზით. ანუ ისე, რომ ხსნარმა გაიაროს პირველი ტესტი და არ გამოიყენოს მარყუჟის კონსტრუქცია. კარგად, მაშინ გამოიყენეთ ტრანსფორმაციები გადაწყვეტის უნივერსალურობის მისაღწევად.

მარყუჟები და ტოტები

ჩემი აზრით, სასარგებლოა თემის „ციკლები ფილიალებში“ ცალკე. ასე რომ, მოგვიანებით შეგიძლიათ ნახოთ განსხვავება მდგომარეობის მრავალჯერად შემოწმებასა და ერთხელ შემოწმებას შორის.
კონსოლიდაციის ამოცანები იქნება A-დან B-მდე რიცხვების გამოტანა, რომლებიც შეყვანილია მომხმარებლის მიერ:
- ყოველთვის აღმავალი თანმიმდევრობით.
- აღმავალი ან დაღმავალი A და B მნიშვნელობების მიხედვით.

თემა „მარყუჟებში განშტოება“ უნდა გადავიდეს მხოლოდ მას შემდეგ, რაც მოსწავლე დაეუფლება ტექნიკებს: „ნიმუშის შეცვლა ცვლადით“ და „განმეორებადი მოქმედებების შეცვლა ციკლით“.
მარყუჟების შიგნით ტოტების გამოყენების მთავარი მიზეზი არის ნიმუშის ანომალიები. შუაში იშლება საწყისი მონაცემების მიხედვით.
იმ სტუდენტებისთვის, რომლებსაც შეუძლიათ მარტივი ტექნიკის კომბინაციით გამოსავლის ძიება, საკმარისია თქვან „განშტოება შეიძლება ჩაიწეროს მარყუჟებში“ და მივცეთ პრობლემა „მაგალითად“ მთლიანად დამოუკიდებლად გადასაჭრელად.
დავალების მაგალითი:

მომხმარებელი შეიყვანს X რიცხვს. აჩვენეთ რიცხვები 0-დან 9-მდე სვეტში და დააყენეთ "+" ნიშანი იმ რიცხვის საპირისპიროდ, რომელიც უდრის X-ს.

თუ შეყვანილი იყო 00+
1
2
3
4
5
6
7
8
9

თუ შეყვანილი იყო 60
1
2
3
4
5
6+
7
8
9

თუ შეყვანილი იყო 90
1
2
3
4
5
6
7
8
9+

თუ შეყვანილი იყო 7770
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-ში

ამ თემაში ყურადღება უნდა მიაქციოთ შემდეგს:
- შიდა და გარე მარყუჟების მრიცხველები უნდა იყოს განსხვავებული ცვლადი.
— შიდა მარყუჟის მრიცხველი მრავალჯერ უნდა გადატვირთოს (ანუ გარე მარყუჟის სხეულში).
— ტექსტის გამომავალ ამოცანებში ჯერ ერთი ასოს რამდენიმე სტრიქონში დაწერა არ შეიძლება, შემდეგ კი მეორე. ჯერ უნდა დაბეჭდოთ პირველი ხაზის ყველა ასო, შემდეგ მეორის ყველა ასო და ა.შ.

უმჯობესია დაიწყოთ მარყუჟების თემის ახსნა მარყუჟების შიგნით მრიცხველის ნულზე გადატვირთვის მნიშვნელობის ახსნით.
დავალების მაგალითი:

მომხმარებელი შეაქვს ორ რიცხვს: 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

თუ მოსწავლემ აითვისა ცვლადის ჩანაცვლების ტექნიკა, მაშინ ის საკმაოდ სწრაფად გაუმკლავდება. შესაძლო პრობლემა კვლავ იქნება ცვლადის გადატვირთვა. თუ ტრანსფორმაციას ვერ უმკლავდებით, ეს ნიშნავს, რომ ჩქარობდით და გჭირდებათ უფრო მარტივი პრობლემების მოგვარება.

Გმადლობთ ყურადღებისთვის. მოიწონეთ და გამოიწერეთ არხი.

პ.ს ტექსტში თუ იპოვით შეცდომას ან შეცდომებს, გთხოვთ შემატყობინოთ. ეს შეიძლება გაკეთდეს ტექსტის ნაწილის არჩევით და დააჭირეთ ღილაკს "⌘ + Enter" Mac-ზე და "Ctrl / Enter" კლასიკურ კლავიატურებზე, ან პირადი შეტყობინებების საშუალებით. თუ ეს პარამეტრები მიუწვდომელია, დაწერეთ შეცდომების შესახებ კომენტარებში. Გმადლობთ!

გამოკითხვაში მონაწილეობა შეუძლიათ მხოლოდ დარეგისტრირებულ მომხმარებლებს. Შებრძანდითგთხოვთ

გამოკითხვა მკითხველებისთვის კარმის გარეშე

• 20,0%ვასწავლი პროფესიონალურად +12

• 10,0%ვასწავლი პროფესიულად, -11

• 70,0%მე არ ვასწავლი, +17

• 0,0%არ ვასწავლი, -10

• 0,0%სხვა 0

მისცა ხმა 10 მომხმარებელმა. 5-მა მომხმარებელმა თავი შეიკავა.

წყარო: www.habr.com