Sa kabila ng katotohanan na pag-uusapan natin ang tungkol sa isa sa mga pangunahing paksa, ang artikulong ito ay isinulat para sa mga nakaranasang propesyonal. Ang layunin ay ipakita kung ano ang mga maling akala ng mga nagsisimula sa programming. Para sa mga nagsasanay na mga developer, ang mga problemang ito ay matagal nang nalutas, nakalimutan o hindi napansin. Maaaring maging kapaki-pakinabang ang artikulo kung biglang kailangan mong tulungan ang isang tao sa paksang ito. Ang artikulo ay gumuhit ng mga parallel sa materyal mula sa iba't ibang mga libro sa programming ni Schildt, Stroustrup, Okulov.
Napili ang paksa tungkol sa mga cycle dahil napakaraming tao ang hindi kasama dito kapag pinagkadalubhasaan ang programming.
Ang pamamaraan na ito ay dinisenyo para sa mga mahihinang mag-aaral. Bilang isang patakaran, ang mga malalakas na tao ay hindi natigil sa paksang ito at hindi na kailangang magkaroon ng mga espesyal na diskarte para sa kanila. Ang pangalawang layunin ng artikulo ay ilipat ang diskarteng ito mula sa klase na "gumagana para sa lahat ng mag-aaral, ngunit isang guro lamang" patungo sa klase na "gumagana para sa lahat ng mag-aaral, lahat ng guro". Hindi ko inaangkin ang ganap na pagka-orihinal. Kung gumagamit ka na ng katulad na pamamaraan upang ituro ang paksang ito, mangyaring isulat kung paano naiiba ang iyong bersyon. Kung magpasya kang gamitin ito, sabihin sa amin kung paano ito napunta. Kung ang isang katulad na pamamaraan ay inilarawan sa isang libro, mangyaring isulat ang pangalan.
Nagtrabaho ako sa diskarteng ito sa loob ng 4 na taon, nag-aaral nang paisa-isa sa mga mag-aaral ng iba't ibang antas ng pagsasanay. Sa kabuuan ay may humigit-kumulang limampung mag-aaral at dalawang libong oras ng mga klase. Sa una, ang mga mag-aaral ay palaging natigil sa paksang ito at umalis. Pagkatapos ng bawat mag-aaral, ang pamamaraan at mga materyales ay inayos. Sa nakalipas na taon, ang mga mag-aaral ay hindi na natigil sa paksang ito, kaya nagpasya akong ibahagi ang aking mga natuklasan.
Bakit ang daming letra? Napaka elementarya ng mga cycle!
Tulad ng isinulat ko sa itaas, para sa pagsasanay sa mga developer at para sa malalakas na estudyante, ang pagiging kumplikado ng konsepto ng mga loop ay maaaring maliitin. Halimbawa, maaari kang magbigay ng mahabang panayam, tingnan ang mga tumatango-tango at matatalinong mata. Ngunit kapag sinusubukang lutasin ang anumang problema, magsisimula ang pagkahilo at hindi maipaliwanag na mga problema. Pagkatapos ng lektura, marahil ay bahagyang naunawaan lamang ng mga mag-aaral. Ang sitwasyon ay pinalala ng katotohanan na ang mga mag-aaral mismo ay hindi makapagsalita kung ano talaga ang kanilang maling akala.
Isang araw napagtanto ko na ang mga estudyante ay naunawaan ang aking mga halimbawa bilang mga hieroglyph. Iyon ay, tulad ng hindi mahahati na mga piraso ng teksto kung saan kailangan mong magdagdag ng ilang "magic" na titik at gagana ito.
Minsan napansin ko na iniisip ng mga estudyante na para malutas ang isang partikular na problema ay kailangan mo iba pa isang disenyo na hindi ko pa lang nasasakop. Kahit na ang solusyon ay nangangailangan lamang ng isang bahagyang pagbabago ng halimbawa.
Kaya nakaisip ako na ang focus ay hindi dapat sa syntax ng mga expression, ngunit sa ideya ng refactoring ng paulit-ulit na code gamit ang mga loop. Kapag napag-aralan na ng mga mag-aaral ang ideyang ito, maaaring mapabuti ang anumang syntax sa kaunting pagsasanay.
Sino at bakit ako nagtuturo?
Dahil walang entrance exams, maaaring kabilang sa mga klase ang mga malalakas at mahihinang estudyante. Maaari mong basahin ang higit pa tungkol sa aking mga mag-aaral sa artikulo
Sinikap kong matiyak na lahat ng gustong matuto ng programming ay matututo nito.
Ang aking mga klase ay ginaganap nang paisa-isa at ang mag-aaral ay nagbabayad ng kanyang sariling pera para sa bawat isa. Mukhang i-optimize ng mga mag-aaral ang mga gastos at hihingin ang pinakamababa. Gayunpaman, ang mga tao ay pumupunta sa harapang mga klase kasama ang isang live na guro hindi para sa kaalaman mismo, ngunit para sa pagtitiwala sa kanilang natutunan, para sa isang pakiramdam ng pag-unlad at para sa pag-apruba mula sa eksperto (guro). Kung ang mga mag-aaral ay hindi nakakaramdam ng pag-unlad sa kanilang pag-aaral, sila ay aalis. Sa pangkalahatan, maaaring isaayos ang mga klase upang maramdaman ng mga mag-aaral ang pag-unlad sa pagtaas ng bilang ng mga pamilyar na istruktura. Ibig sabihin, una kaming nag-aaral habang detalyado, pagkatapos ay nag-aaral kami para sa, pagkatapos ay gumawa ng habang, at ngayon mayroon kaming isang libo at isang gabi na kurso na handa, kung saan ang mga cycle lamang ay pinag-aaralan sa loob ng dalawang buwan, at sa dulo - isang mag-aaral na sumulat isang karaniwang aklatan sa ilalim ng pagdidikta. Gayunpaman, upang malutas ang mga praktikal na problema, kailangan mo hindi lamang kaalaman sa materyal, kundi pati na rin ang pagsasarili sa aplikasyon nito at sa paghahanap ng bagong impormasyon. Samakatuwid, para sa harapang mga kurso, sa tingin ko ang tamang prinsipyo ay magturo ng pinakamababa at hikayatin ang malayang pag-aaral ng mga nuances at mga kaugnay na paksa. Sa paksa ng mga loop, isinasaalang-alang ko ang while construct na pinakamababa. Maiintindihan mo ang prinsipyo mula dito. Alam ang prinsipyo, maaari mong master ang parehong para sa at gawin-habang ang iyong sarili.
Upang makamit ang mastery ng materyal ng mahihinang mga mag-aaral, ang paglalarawan ng syntax ay hindi sapat. Kinakailangang magbigay ng mas simple ngunit sari-saring mga gawain at ilarawan ang mga halimbawa nang mas detalyado. Sa huli, ang bilis ng pag-unlad ay nalilimitahan ng kakayahan ng mag-aaral na baguhin ang mga expression at maghanap ng mga pattern. Para sa matatalinong estudyante, karamihan sa mga takdang-aralin ay magiging boring. Kapag nag-aaral sa kanila, hindi mo kailangang ipilit ang paglutas ng 100% ng mga problema. Ang aking materyal ay maaaring matingnan sa . Totoo, ang repositoryo ay mas katulad ng isang warlock's grimoire - walang sinuman maliban sa akin ang makakaintindi kung saan, at kung nabigo ka sa tseke, maaari kang mabaliw
Ang pamamaraan ay nakatuon sa kasanayan
Ang teorya ay ipinaliwanag gamit ang halimbawa ng paglutas ng problema. Sa isang batayan ng klase ng programming kung saan itinuturo ang mga sangay at loop, simpleng hindi posible na magbigay ng kapaki-pakinabang na panayam sa isang paksa sa loob ng isang buong oras. Ang 15-20 minuto ay sapat na upang ipaliwanag ang konsepto. Ang mga pangunahing paghihirap ay lumitaw kapag nagsasagawa ng mga praktikal na gawain.
Ang mga nagsisimulang guro ay maaaring mag-rattle ng mga operator, branch, loop, at array sa isang lecture. Ngunit haharapin ng kanilang mga estudyante ang problema sa pag-asimilasyon ng impormasyong ito.
Ito ay kinakailangan hindi lamang upang sabihin ang materyal, ngunit din upang matiyak na ang mga tagapakinig ay nauunawaan ito.
Ang katotohanan ng pag-master ng isang paksa ay natutukoy sa pamamagitan ng kung paano nakayanan ng mag-aaral ang malayang gawain.
Kung ang isang mag-aaral ay nagawang malutas ang isang problema sa isang paksa nang walang tulong ng isang guro, kung gayon ang paksa ay pinagkadalubhasaan. Upang matiyak ang pagsusuri sa sarili, ang bawat gawain ay inilarawan sa isang talahanayan na may mga sitwasyon ng pagsubok. Ang mga gawain ay may malinaw na pagkakasunud-sunod. Ang paglaktaw sa mga gawain ay hindi inirerekomenda. Kung ang kasalukuyang gawain ay masyadong mahirap, kung gayon ang paglipat sa susunod ay walang silbi. Ito ay mas kumplikado. Upang makabisado ng mag-aaral ang kasalukuyang kumplikadong gawain, maraming mga diskarte ang ipinaliwanag sa kanya gamit ang halimbawa ng unang problema. Sa totoo lang, ang buong nilalaman ng paksa ay nagmumula sa mga pamamaraan para sa pagtagumpayan ng mga paghihirap. Ang mga cycle ay higit na isang side effect.
Ang unang gawain ay palaging isang halimbawa. Ang pangalawa ay bahagyang naiiba at isinasagawa nang "independiyente" kaagad pagkatapos ng una sa ilalim ng pangangasiwa ng isang guro. Ang lahat ng kasunod na gawain ay naglalayong bigyang pansin ang iba't ibang maliliit na bagay na maaaring magdulot ng maling akala.
Ang paliwanag ng halimbawa ay isang diyalogo kung saan ang mag-aaral ay kailangang tumawag pabalik sa pagpapalaganap at cross-validation upang matiyak na siya ay nakabisado ang isang bahagi ng materyal.
Ako ay magiging banal at sasabihin na ang unang halimbawa sa paksa ay napakahalaga. Kung mayroon kang materyal para sa malawak na independiyenteng gawain, maaaring itama ang mga pagkukulang sa unang halimbawa. Kung walang iba maliban sa halimbawa, malamang na hindi makabisado ng mag-aaral ang paksa.
Habang o para?
Isa sa mga kontrobersyal na isyu ay ang pagpili ng konstruksiyon para sa halimbawa: habang o para sa. Minsan, gumugol ng isang oras ang isang nagsasanay kong kaibigang developer na walang karanasan sa pagtuturo sa pagkumbinsi sa akin na ang for loop ang pinakamadaling maunawaan. Ang mga argumento ay bumagsak sa "lahat ng nasa loob nito ay malinaw at inilatag sa lugar nito." Gayunpaman, ang pangunahing sanhi ng mga paghihirap para sa mga tunay na nagsisimula ay ang ideya ng cycle mismo, at hindi ang pagsulat nito. Kung hindi naiintindihan ng isang tao ang ideyang ito, mahihirapan siya sa syntax. Sa sandaling natanto ang ideya, ang mga problema sa disenyo ng code ay nawawala sa kanilang sarili.
Sa aking mga materyales, ang tema ng mga loop ay sumusunod sa tema ng sumasanga. Ang panlabas na pagkakapareho ng if at while ay nagbibigay-daan sa amin na gumuhit ng direktang pagkakatulad: "kapag ang kundisyon sa header ay totoo, kung gayon ang katawan ay isasagawa." Ang tanging kakaiba ng cycle ay ang katawan ay naisakatuparan ng maraming beses.
Ang aking pangalawang argumento ay habang nangangailangan ng mas kaunting pag-format kaysa para sa. Ang mas kaunting pag-format ay nangangahulugan ng mas kaunting mga hangal na pagkakamali na may nawawalang mga kuwit at panaklong. Ang mga nagsisimula ay hindi pa nakakabuo ng sapat na pagkaasikaso at pagiging maselan upang awtomatikong maiwasan ang mga error sa syntax.
Ang ikatlong argumento ay ipinaliwanag sa maraming magagandang libro bilang unang argumento.
Kung ang mag-aaral ay madaling ibahin ang anyo ng mga ekspresyon, maaari mong pag-usapan ang tungkol sa pagpasa. Pagkatapos ay pipiliin ng mag-aaral kung ano ang pinakagusto niya. Kung ang mga pagbabagong-anyo ay nagdudulot ng mga paghihirap, mas mahusay na huwag makagambala sa iyong pansin. Hayaang lutasin muna ng mag-aaral ang lahat gamit ang while. Kapag napag-aralan mo na ang paksa ng mga loop, maaari mong muling isulat ang mga solusyon upang magsanay sa pag-convert habang sa para sa.
Ang mga postcondition loop ay isang medyo bihirang hayop. Hindi ako gumugugol ng anumang oras dito. Kung pinagkadalubhasaan ng isang mag-aaral ang mga ideya ng pagtukoy ng mga pattern at pagbabago ng mga expression, maaari niyang malaman ito nang walang tulong ko.
Kapag ipinakita ang unang halimbawa sa malalakas na mag-aaral, binibigyang pansin ko ang katotohanan na sa unang halimbawa ay mahalaga na itala hindi lamang ang solusyon, kundi pati na rin ang buong hanay ng mga aksyon na humantong sa resulta. Ang mga tamad na estudyante ay maaaring magpabaya sa pagsulat at kopyahin lamang ang huling algorithm. Kailangan nilang kumbinsihin na isang araw ay darating sa kanila ang isang mahirap na gawain. Upang malutas ito, kakailanganin mong sundin ang mga hakbang tulad ng sa halimbawang ito. Iyon ang dahilan kung bakit mahalagang itala ang lahat ng mga yugto. Sa mga sumusunod na problema, posibleng iwanan lamang ang huling bersyon ng solusyon.
Ang pangunahing ideya ng automation ay ipinagkatiwala namin ang isang computer na gawin ang karaniwang gawain para sa isang tao. Ang isa sa mga pangunahing pamamaraan ay ang pagsulat ng mga loop. Ginagamit ito kapag maraming magkakaparehong paulit-ulit na pagkilos ang nakasulat sa isang programa nang sunud-sunod.
Ang tahasan ay mas mabuti kaysa implicit
Maaaring mukhang isang magandang ideya na ipakita ang parehong parirala nang maraming beses sa unang gawain sa pag-loop. Halimbawa:
Hurray, ito ay gumagana!
Hurray, ito ay gumagana!
Hurray, ito ay gumagana!
Hurray, ito ay gumagana!
Hurray, ito ay gumagana!
Hurray, ito ay gumagana!
Hurray, ito ay gumagana!
Hurray, ito ay gumagana!
Ang opsyon na ito ay masama dahil ang counter value ay hindi nakikita sa output. Ito ay isang problema para sa mga nagsisimula. Huwag mo siyang maliitin. Sa una, ang gawaing ito ang una, at ang gawain ng pagkuha ng isang serye ng mga numero sa pataas na pagkakasunud-sunod ay ang pangalawa. Kinailangan na ipakilala ang mga karagdagang terminong "cycle N beses" at "cycle mula A hanggang B", na mahalagang parehong bagay. Upang hindi lumikha ng mga hindi kinakailangang entity, nagpasya akong magpakita lamang ng isang halimbawa na may output ng isang serye ng mga numero. Ilang tao ang nakakatuto kung paano humawak ng counter sa kanilang ulo at imodelo ang gawi ng isang programa sa kanilang ulo nang walang paghahanda. Ang ilang mga mag-aaral ay unang nakatagpo ng mental modeling sa paksa ng mga cycle.
Pagkatapos ng ilang pagsasanay, binibigyan ko ang gawain ng pag-uulit ng parehong teksto upang malutas nang nakapag-iisa. Kung magbibigay ka muna ng isang nakikitang counter at pagkatapos ay isang hindi nakikita, ang mga mag-aaral ay magkakaroon ng mas kaunting mga problema. Minsan sapat na ang pahiwatig na "huwag isulat ang counter sa screen".
Paano ito ipinapaliwanag ng iba?
Sa karamihan ng mga materyal na pang-edukasyon sa Internet, ang syntax ng cycle ay ibinibigay bilang bahagi ng isang "lektura". Halimbawa, sa developer.mozilla.org (kasalukuyan), maraming iba pang mga construct ang inilalarawan kasama ng while loop. Sa kasong ito, ang mga disenyo lamang mismo ang ibinibigay sa anyo ng mga template. Ang resulta ng kanilang paglunsad ay inilarawan sa mga salita, ngunit walang paglalarawan. Sa palagay ko, ang gayong pagtatanghal ng paksa ay nagpaparami ng pagiging kapaki-pakinabang ng mga naturang materyales sa pamamagitan ng zero. Maaaring muling isulat ng mag-aaral ang code at patakbuhin ito mismo, ngunit kailangan pa rin niya ng pamantayan para sa paghahambing. Paano mo mauunawaan na ang isang halimbawa ay muling naisulat nang tama kung walang maihahambing ang resulta?
Kapag template lang ang ibinigay, walang halimbawa, lalo itong nagiging mahirap para sa estudyante. Paano maiintindihan na ang mga fragment ng code ay inilagay nang tama sa template? Maaari mong subukang magsulat kahit papaano, at pagkatapos ay tumakbo. Ngunit kung walang pamantayan upang ihambing ang resulta, kung gayon ang paglulunsad ay hindi rin makakatulong.
Sa kursong C++ sa Intuitive, ang loop syntax ay nakabaon sa ikatlong pahina ng Lecture 4 sa paksang "mga operator". Kapag ipinapaliwanag ang syntax ng mga loop, ang espesyal na diin ay inilalagay sa terminong "operator". Ang termino ay ipinakita bilang isang hanay ng mga katotohanan tulad ng "simbolo; ito ay isang pahayag", "{} ay isang tambalang pahayag", "ang katawan ng loop ay dapat na isang pahayag". Hindi ko gusto ang diskarteng ito dahil tila nagtatago ito ng mahahalagang relasyon sa likod ng isang termino. Ang pag-parse ng source code ng isang program sa mga termino sa antas na ito ay kailangan ng mga developer ng compiler upang ipatupad ang detalye ng wika, ngunit hindi ng mga mag-aaral bilang unang pagtatantya. Ang mga bagong dating sa programming ay bihirang sapat na metikuloso upang bigyang-pansin ang mga termino. Ito ay isang bihirang tao na nakakaalala at nakakaintindi ng mga bagong salita sa unang pagkakataon. Halos walang makapag-apply nang tama ng terminong natutunan lang nila. Samakatuwid, ang mga mag-aaral ay nakakakuha ng maraming error tulad ng "Isinulat ko habang(a<7);{, ngunit hindi gumagana ang program."
Sa palagay ko, sa simula ay mas mahusay na ibigay kaagad ang syntax ng konstruksiyon na may mga panaklong. Ang opsyon na walang panaklong ay dapat lamang ipaliwanag kung ang mag-aaral ay may partikular na tanong: "bakit walang panaklong at ito ay gumagana."
Sa 2012 na aklat ni Okulov na "Mga Pundamental ng Programming," isang panimula sa mga loop ay nagsisimula sa para sa pattern, pagkatapos ay nagbibigay ng mga rekomendasyon para sa paggamit nito, at pagkatapos ay agad na pumunta sa eksperimental na seksyon ng aralin. Naiintindihan ko na ang aklat ay isinulat para sa minoryang iyon ng mga napakahusay na estudyante na bihirang pumasok sa aking mga klase.
Sa mga sikat na libro, palaging nakasulat ang resulta ng mga fragment ng code. Halimbawa, ang "Java 8. The Complete Guide" ni Shildt 2015 na edisyon. Una, ang isang template ay ibinigay, pagkatapos ay isang halimbawa ng programa at kaagad pagkatapos nito - ang resulta ng pagpapatupad.
Bilang halimbawa, isaalang-alang ang isang while loop na gumagawa ng reverse
countdown simula sa 10, at eksaktong 10 linya ng "mga panukala" ay ipinapakita://Продемонстрировать применение оператора цикла while class While { public static void main(String args []) { int n = 10; while (n > 0) { System.out.println("такт " + n); n--; } } }Sa sandaling tumakbo, ang program na ito ay naglalabas ng sampung "cycle" tulad ng sumusunod:
такт 10
такт 9
такт 8
такт 7
такт 6
такт 5
такт 4
такт 3
такт 2
такт 1
Ang diskarte sa paglalarawan ng isang template, isang halimbawang programa at ang resulta ng programa ay ginagamit din sa aklat na "Javascript for Kids" at sa js course sa w3schools.com. Ang format ng web page ay nagbibigay-daan sa halimbawang ito na maging interactive.
Ang aklat ni Stroustrup noong 2016 na Mga Prinsipyo at Pagsasanay sa Paggamit ng C++ ay mas lumayo pa. Ang unang hakbang ay ipaliwanag kung anong resulta ang dapat makuha, at pagkatapos ay ipapakita ang teksto ng programa. Bukod dito, hindi lamang sila kinukuha ng isang random na programa bilang isang halimbawa, ngunit nagbibigay ng isang iskursiyon sa kasaysayan. Ito ay nakakatulong upang maakit ang pansin dito: “Narito, ito ay hindi lamang ilang walang silbing teksto. May nakikita kang makabuluhan."
Bilang halimbawa ng pag-ulit, isaalang-alang ang unang program na naisakatuparan sa isang stored program machine (EDSAC). Ito ay isinulat ni David Wheeler sa Computer Laboratory ng Cambridge University, England noong Mayo 6, 1949. Kinakalkula at ini-print ng program na ito ang isang simpleng listahan ng mga parisukat.
0 0
1 1
2 4
3 9
4 16
...
98 9604
99 9801
Dito, ang bawat linya ay naglalaman ng isang numero na sinusundan ng isang tab na character ('t') at ang parisukat ng numerong iyon. Ang C++ na bersyon ng program na ito ay ganito ang hitsura://Вычисляем и распечатываем таблицу квадратов чисел 0-99 int main() { int i = 0; // Начинаем с нуля while(i < 100){ cout << i << 't' << square(i) << 'n'; ++i; } }
Kapansin-pansin, ang pattern ng syntax ay hindi inilarawan sa aklat na ito. Stroustrup sa manwal ng magtuturo () ay binibigyang-diin na iginagalang nito ang katalinuhan ng mga mag-aaral nito. Marahil ang kakayahang makilala ang isang pattern sa ilang mga halimbawa ay itinuturing na isang pagpapakita ng naturang katalinuhan.
Habang pinapaliwanag ko ang sarili ko
Ang diskarte ni Stroustrup: inilalarawan ang resulta, pagkatapos ay lutasin ang problema, at pagkatapos ay isang independiyenteng pagsusuri ng mag-aaral - tila ang pinaka-maalalahanin. Samakatuwid, nagpasya akong kunin ito bilang batayan, ngunit sabihin ito gamit ang isang hindi gaanong makasaysayang halimbawa - ang gawain ng pagkuha ng isang "talahanayan ng mga nilalaman". Bumubuo ito ng isang makikilalang anchor upang masabi mo ang "tandaan ang gawain tungkol sa talaan ng mga nilalaman" at para matandaan ito ng mga estudyante nang eksakto. Sa aking halimbawa, sinubukan kong pigilan ang dalawa pa sa mga pinakakaraniwang maling kuru-kuro. Susunod na isusulat ko ang tungkol sa mga ito nang mas detalyado.
Sa gawaing ito ay ipinakilala tayo sa mga pamamaraan para sa paglutas ng mga kumplikadong problema. Ang paunang desisyon ay kailangang gawin primitive at simple. Kaya, maaari mong isipin kung paano pagbutihin ang solusyon na ito.
Введение
Глава 1
Глава 2
Глава 3
Глава 4
Глава 5
Глава 6
Глава 7
Заключение
Ayon sa aking mga obserbasyon, ang "template-example-result" na diskarte sa iba't ibang mga kumbinasyon ay humahantong pa rin sa katotohanan na ang mga estudyante ay nakikita ang cycle bilang isang hieroglyph. Nagpakita ito sa katotohanan na hindi nila naiintindihan kung bakit may kondisyon na magsulat doon, kung paano pumili sa pagitan ng i++ at i— at iba pang mga bagay na tila halata. Upang maiwasan ang mga maling kuru-kuro na ito, ang diskarte sa pakikipag-usap tungkol sa mga cycle ay dapat na bigyang-diin ang kahulugan ng paulit-ulit na magkatulad na mga aksyon at pagkatapos ay gawing pormal ang mga ito gamit ang isang istraktura. Samakatuwid, bago ibigay ang loop syntax, kailangan mong lutasin ang problema nang direkta. Ang isang primitive na solusyon sa problema sa talahanayan ng mga nilalaman ay ganito ang hitsura:
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("Заключение");
Paano ito mapapabuti?
Palitan ang mga monotonous na aksyon ng isang cycle.
Anong mga aksyon ang paulit-ulit sa isang hilera nang walang mga pagbabago?
Wala sa fragment na ito. Gayunpaman, ang mga utos para sa pagpapakita ng salitang "Kabanata" na may isang numero ay halos magkapareho sa bawat isa.
Samakatuwid, ang susunod na yugto ay upang mahanap ang pagkakaiba sa pagitan ng mga fragment. Sa gawaing ito lamang ang lahat ay halata, pagkatapos ay hindi iisang utos ang mauulit, ngunit ang mga bloke ng code ng 5 linya o higit pa. Kakailanganin mong maghanap hindi lamang sa listahan ng mga command, ngunit sa mga branching o loop constructions.
Sa halimbawa, ang pagkakaiba sa pagitan ng mga utos ay nasa numero pagkatapos ng salitang "Kabanata".
Kapag natagpuan ang pagkakaiba, kailangan mong maunawaan ang pattern ng pagbabago. Ang iba't ibang fragment ay ang numero? Ito ba ay patuloy na tumataas o bumababa? Paano nagbabago ang halaga ng isang numero sa pagitan ng dalawang koponan na magkatabi?
Sa halimbawa, ang bilang pagkatapos ng salitang "Kabanata" ay tumataas sa mga pagtaas ng 1. Ang pagkakaiba ay natagpuan, ang pattern ay ipinahayag. Ngayon ay maaari mong palitan ang magkakaibang fragment ng isang variable.
Kailangan mong ideklara ang naturang variable bago ang una sa mga umuulit na fragment. Ang ganitong variable ay karaniwang tinatawag na I o j o isang bagay na mas detalyado. Ang paunang halaga nito ay dapat na katumbas ng unang halaga na ipinapakita sa screen. Sa halimbawa, ang unang halaga ay 1.
Anong paunang halaga ang dapat kunin upang maipakita ang serye ng mga numerong “100, 101, 102, 103, 104, 105”?
Ang unang numero sa seryeng ito ay 100.
Pagkatapos ng bawat output command, kailangan mong taasan ang halaga ng variable na ito ng 1. Ang yunit na ito ay ang hakbang ng pagbabago.
Ano ang magiging hakbang sa serye ng mga numero na "100, 102, 104, 106"?
Hakbang 2 sa hilera na ito.
Pagkatapos palitan ang magkakaibang fragment ng variable, magiging ganito ang code:
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("Заключение");
Pagkatapos ilapat ang diskarteng "ipahayag ang pattern ng isang variable" sa code, makakakuha ka ng ilang grupo ng magkakaparehong pagkilos na magkakasunod. Ngayon ang mga paulit-ulit na aksyon ay maaaring mapalitan ng isang loop.
Ang pagkakasunud-sunod ng paglutas ng isang problema kung saan kailangan mong gumamit ng mga loop ay binubuo ng mga sumusunod na hakbang:
- Lutasin ang "head-on" na may maraming magkakahiwalay na utos
- Maghanap ng pattern
- Ipahayag ang pattern ng isang variable
- Disenyo bilang isang cycle
Susunod, ang mga bagong termino ay ipinakilala upang ang mag-aaral ay hindi mahanap ang kanyang sarili sa sitwasyon ng "Naiintindihan ko ang lahat, ngunit hindi ko masabi ito":
— Ang isang counter ay palaging isang variable na kinakailangan upang subaybayan ang bilang ng mga hakbang sa isang loop. Karaniwang isang integer na inihahambing sa pagpilit.
— counter step — paglalarawan ng pattern ng mga counter na pagbabago.
- hadlang - isang numero o variable kung saan inihahambing ang counter upang ang algorithm ay pinal. Nagbabago ang counter value upang lapitan ang limitasyon.
— loop body — isang set ng mga utos na uulitin. Kapag sinabi nilang "ang utos ay nakasulat sa loob ng isang loop," ang ibig nilang sabihin ay ang katawan.
— loop iteration — isang beses na pagpapatupad ng loop body.
— loop condition — isang lohikal na expression na tumutukoy kung isa pang pag-ulit ang isasagawa. (Maaaring may pagkalito sa mga sumasanga na istruktura dito)
Kailangan mong maging handa para sa katotohanan na sa unang mga mag-aaral ay gagamit ng mga termino para sa iba pang mga layunin. Nalalapat ito sa parehong malakas at mahina. Ang pagtatatag ng isang karaniwang wika ay isang sining. Ngayon ay magsusulat ako nang maikli: kailangan mong itakda ang gawain na "i-highlight ang fragment ng code na may <term>" at gamitin ang mga terminong ito nang tama sa pag-uusap.
Pagkatapos ng pagbabagong-anyo na may isang loop, ang fragment ay nakuha:
Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
Console.WriteLine("Глава " + i);
i = i + 1;
}
Console.WriteLine("Заключение");Ang pangunahing maling kuru-kuro
Ang isang popular na maling kuru-kuro sa mga mag-aaral ay ang paglalagay nila ng mga aksyon sa loob ng isang loop na kailangang gawin nang isang beses lang. Halimbawa tulad nito:
;
int i = 0;
while (i < 7) {
Console.WriteLine("Введение")
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");
}
Ang mga mag-aaral ay nakakaranas ng problemang ito sa lahat ng oras, kapwa sa simula at sa mas kumplikadong mga problema.
Pangunahing pahiwatig sa kasong ito:
Ilang beses mo dapat ulitin ang utos: isang beses o maraming beses?
Ang mga utos para sa pag-print ng mga salitang "Introduction" at "Conclusion" at pagdedeklara at pagsisimula ng variable na i ay hindi katulad ng iba pang mga paulit-ulit na aksyon. Isinasagawa ang mga ito nang isang beses lamang, na nangangahulugang kailangan nilang isulat sa labas ng katawan ng loop.
Ang lahat ng tatlong yugto ng solusyon ay dapat manatili sa code upang maaari kang sumangguni sa mga ito sa ibang pagkakataon kung sakaling magkaroon ng mga kahirapan. Sapat na magkomento sa unang dalawang opsyon upang hindi sila makagambala.
Ang atensyon ng mag-aaral ay dapat maakit sa mga sumusunod na katotohanan:
— Sa isang kondisyon ng loop, karaniwang inihahambing ang isang counter at isang limitasyon. Ang counter ay maaaring magbago sa katawan ng loop, ngunit ang limitasyon ay hindi. Upang masira ang panuntunang ito, kailangan mong magbalangkas ng mga nakakahimok na dahilan.
— Ang mga utos para sa pagpapakita ng mga salitang "Introduction" at "Conclusion" ay matatagpuan sa labas ng katawan ng loop. Kailangan nating gawin ang mga ito ng 1 beses. "Panimula" - bago ulitin ang mga aksyon, "Konklusyon" - pagkatapos.
Sa proseso ng pagsasama-sama ng paksang ito, pag-master ng mga susunod, pati na rin ang pagharap sa mga paghihirap, kapaki-pakinabang para sa kahit na malalakas na mag-aaral na tanungin ang tanong: "Ilang beses kailangang isagawa ang pagkilos na ito? Isa o marami?
Pag-unlad ng karagdagang mga kasanayan
Sa proseso ng pag-aaral ng mga siklo, ang mga mag-aaral ay nagkakaroon din ng kasanayan sa pag-diagnose at paglutas ng mga problema. Upang maisagawa ang mga diagnostic, kailangang ipakita ng mag-aaral ang nais na resulta at ihambing ito sa aktwal na resulta. Ang mga pagwawasto ay nakasalalay sa pagkakaiba sa pagitan ng mga ito.
Dahil ang mga mag-aaral sa yugtong ito ay may kaunting ideya pa rin sa "nais na" resulta, maaari silang tumuon sa data ng pagsubok. Bilang isang tuntunin, wala pang sinuman sa yugtong ito ang nakakaunawa kung ano ang maaaring magkamali at kung paano haharapin ito. Samakatuwid, nagsusulat ako sa isang kuwaderno ng isang paglalarawan ng mga tipikal na problema at ilang mga paraan upang malutas ang mga ito. Ang pagpili ng pinakaangkop ay ang gawain ng mag-aaral mismo.
Ang isang talaan ay kailangan upang itanong "naganap ba ang inaasahan?", "Alin sa mga sitwasyong ito ang nangyari ngayon?", "Nakatulong ba ang inilapat na solusyon?"
- Ang bilang ng mga pagkilos ay 1 mas mababa o higit pa kaysa sa inaasahan. Mga solusyon:
— dagdagan ang paunang halaga ng counter ng 1.
— palitan ang mahigpit na operator ng paghahambing (< o >) ng hindi mahigpit na operator (<= o >=).
— baguhin ang halaga ng limitasyon sa 1. - Ang mga aksyon sa isang loop ay isinasagawa nang walang tigil, nang walang katiyakan. Mga solusyon:
— magdagdag ng utos ng counter change kung ito ay nawawala.
— ayusin ang utos ng counter change upang ang halaga nito ay maging mas malapit sa limitasyon.
— tanggalin ang constraint change command kung ito ay nasa katawan ng loop. - Ang bilang ng mga aksyon sa isang loop ay higit sa 1 mas mababa o higit pa kaysa sa inaasahan. Ang aksyon sa loop ay hindi naisakatuparan kahit isang beses. Una kailangan mong malaman ang aktwal na mga halaga ng mga variable bago magsimula ang loop. Mga solusyon:
— baguhin ang paunang halaga ng pagpilit
— baguhin ang paunang halaga ng counter
Ang problema 3 ay kadalasang kinabibilangan ng paggamit ng maling variable o hindi pag-reset ng counter sa zero.
Pagkatapos ng paliwanag na ito, ang mag-aaral ay maaaring magkaroon pa rin ng iba't ibang mga maling kuru-kuro tungkol sa kung paano gumagana ang mga loop.
Upang iwaksi ang pinakakaraniwan, binibigyan kita ng mga sumusunod na gawain:
- Kung saan ang limitasyon, paunang counter value, o counter step ay ipinasok ng user.
- Kung saan dapat gamitin ang counter value sa ilang expression ng aritmetika. Maipapayo na gumamit ng counter sa radical expression o sa denominator upang ang pagkakaiba ay hindi linear.
- Kung saan ang counter value ay hindi ipinapakita sa screen habang tumatakbo ang loop. Halimbawa, ang pagpapakita ng kinakailangang bilang ng magkaparehong mga fragment ng teksto o pagguhit ng figure na may mga turtle graphics.
- Kung saan kailangan mong magsagawa muna ng ilang mga paulit-ulit na aksyon, at pagkatapos ay iba pa.
- Kung saan kailangan mong magsagawa ng iba pang mga aksyon bago at pagkatapos ng pag-uulit
Para sa bawat gawain kailangan mong magbigay ng data ng pagsubok at ang inaasahang resulta.
Upang maunawaan kung gaano kabilis ka makakagalaw, kailangan mong basahin ang mga tuntunin ng mga problemang ito at itanong: "paano sila naiiba sa halimbawa?", "Ano ang kailangang baguhin sa halimbawa upang malutas ang mga ito?" Kung makahulugan ang sagot ng estudyante, hayaan siyang mag-solve kahit isa man lang sa klase, at ang iba ay sa bahay nang mag-isa. Kung ang solusyon ay matagumpay, pagkatapos ay maaari naming simulan ang pagpapaliwanag ng mga kondisyon sa loob ng mga loop.
Kung mayroon kang mga problema sa paglutas ng mga problema sa iyong sarili, kailangan mong pagsikapan ang lahat sa klase. Upang maiwasan ang paglutas ng problema na nakapagpapaalaala sa pagguhit ng isang kuwago, inirerekumenda ko munang lutasin ang problema sa isang hindi unibersal na paraan. Iyon ay, upang ang solusyon ay pumasa sa unang pagsubok at hindi ginagamit ang pagbuo ng loop. Well, pagkatapos ay ilapat ang mga pagbabagong-anyo upang makamit ang pagiging pangkalahatan ng solusyon.
Mga loop at sanga
Sa palagay ko, kapaki-pakinabang na bigyan ang paksang "mga siklo sa loob ng mga sangay" nang hiwalay. Upang sa paglaon ay makikita mo ang pagkakaiba sa pagitan ng pagsuri ng kondisyon nang maraming beses at pagsuri nito nang isang beses.
Ang mga gawain para sa pagsasama-sama ay tungkol sa pag-output ng mga numero mula A hanggang B, na ipinasok ng user:
- palaging nasa pataas na pagkakasunud-sunod.
- pataas o pababang depende sa mga halaga ng A at B.
Ang paksa ng "pagsasanga sa loob ng mga loop" ay dapat na ilipat sa pagkatapos lamang ang mag-aaral ay makabisado ang mga diskarte: "pagpapalit ng isang pattern ng isang variable" at "pagpapalit ng mga paulit-ulit na aksyon na may isang cycle."
Ang pangunahing dahilan para sa paggamit ng mga sanga sa loob ng mga loop ay mga anomalya sa pattern. Sa gitna ito masira depende sa paunang data.
Para sa mga mag-aaral na makakahanap ng solusyon sa pamamagitan ng pagsasama-sama ng mga simpleng pamamaraan, sapat na ang sabihing "maaring isulat ang sanga sa loob ng mga loop" at bigyan ng ganap na "halimbawa" ang problema upang malutas nang nakapag-iisa.
Halimbawang gawain:
Ilalagay ng user ang numerong X. Ipakita ang mga numero mula 0 hanggang 9 sa isang column at maglagay ng '+' sign sa tapat ng numero na katumbas ng X.
Kung 0 ang ipinasok0+
1
2
3
4
5
6
7
8
9
Kung 6 ang ipinasok0
1
2
3
4
5
6+
7
8
9
Kung 9 ang ipinasok0
1
2
3
4
5
6
7
8
9+
Kung 777 ang ipinasok0
1
2
3
4
5
6
7
8
9
Kung ang isang maikling paliwanag ay hindi sapat upang magsulat gamit ang isang loop, pagkatapos ay kailangan mong makamit ang isang unibersal na solusyon sa parehong problema nang walang loop.
Makakakuha ka ng isa sa dalawang opsyon:
Ninanais
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);
}
Maaari
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+");
}
Nagbibigay ako ng katulad na gawain nang maaga, habang pinag-aaralan ang paksa ng pagsasanga.
Kung ang mag-aaral ay makaisip ng isang "posible" na opsyon, kailangan mong sabihin sa kanila na maaaring maraming solusyon sa parehong problema. Gayunpaman, naiiba sila sa kanilang pagtutol sa mga pagbabago sa mga kinakailangan. Itanong ang tanong: "Ilang lugar sa code ang kailangang itama kung kailangan kong magdagdag ng isa pang numero?" Sa "posible" na bersyon, kakailanganin mong magdagdag ng isa pang branch at magdagdag ng bagong numero sa 10 iba pang lugar. Sa "nais" ito ay sapat na upang magdagdag lamang ng isang sangay.
Itakda ang gawain upang kopyahin ang opsyon na "nais", pagkatapos ay maghanap ng isang pattern sa code, magsagawa ng isang variable na kapalit at magsulat ng isang loop.
Kung mayroon kang ideya kung paano lutasin ang problemang ito nang walang loop sa ibang paraan, mangyaring sumulat sa mga komento.
Mga Loop sa loob ng Loops
Sa paksang ito kailangan mong bigyang pansin ang mga sumusunod:
— ang mga counter para sa panloob at panlabas na mga loop ay dapat na magkaibang mga variable.
— ang counter para sa panloob na loop ay dapat na i-reset nang maraming beses (iyon ay, sa katawan ng panlabas na loop).
— sa mga gawain ng text output, hindi ka muna makakasulat ng isang titik sa ilang linya, at pagkatapos ay ang pangalawa. Kailangan mo munang i-print ang lahat ng mga titik ng unang linya, pagkatapos ang lahat ng mga titik ng pangalawa, at iba pa.
Pinakamainam na simulan ang pagpapaliwanag sa paksa ng mga loop sa loob ng mga loop sa pamamagitan ng pagpapaliwanag sa kahalagahan ng pag-reset ng counter sa zero.
Halimbawang gawain:
Ang gumagamit ay nagpasok ng dalawang numero: R at T. Mag-print ng dalawang linya ng "#" na mga character. Ang unang linya ay dapat maglaman ng R character. Ang pangalawang linya ay naglalaman ng mga piraso ng T. Kung negatibo ang anumang numero, magpakita ng mensahe ng error.
R=5, T=11#####
####
R=20, T=3########################
# # #
R=-1, T=6Ang halaga ng R ay dapat na hindi negatibo
R=6, T=-2Dapat na hindi negatibo ang halaga ng T
Malinaw, ang problemang ito ay mayroon ding hindi bababa sa dalawang solusyon.
Ninanais
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;
}
Posible #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;
}
Ang pagkakaiba ay na sa "posible" na solusyon, isang pangalawang variable ang ginamit upang i-output ang pangalawang linya. Dapat mong igiit ang paggamit ng parehong variable para sa parehong mga loop. Ang limitasyong ito ay maaaring bigyang-katwiran sa pamamagitan ng katotohanan na ang isang solusyon na may isang counter para sa dalawang cycle ay magiging isang paglalarawan ng terminong "counter reset". Ang pag-unawa sa terminong ito ay kinakailangan kapag nilutas ang mga sumusunod na problema. Bilang isang kompromiso, maaari mong i-save ang parehong mga solusyon sa problema.
Ang isang karaniwang problema sa paggamit ng isang counter variable para sa dalawang loop ay lilitaw tulad nito:
R=5, T=11#####
######
Ang bilang ng mga character sa pangalawang linya ay hindi tumutugma sa halaga ng T. Kung kailangan mo ng tulong sa problemang ito, kailangan mong tingnan ang mga tala tungkol sa mga tipikal na problema sa mga loop. Ito ang sintomas #3. Ito ay nasuri kung nagdagdag ka ng isang counter value na output kaagad bago ang ikalawang cycle. Naitama sa pamamagitan ng pag-reset. Ngunit mas mabuting huwag sabihin ito kaagad. Dapat subukan ng mag-aaral na bumalangkas ng hindi bababa sa isang hypothesis.
Mayroong, siyempre, isa pang solusyon. Ngunit hindi ko ito nakita sa mga estudyante. Sa yugto ng pag-aaral ng mga siklo, ang kuwento tungkol dito ay makaabala sa atensyon. Maaari mong balikan ito sa ibang pagkakataon kapag natutunan ang tungkol sa mga function ng string.
Posible #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));
Susunod na kinakailangang gawain:
Ipakita ang mga numero mula 0 hanggang 9. Ang bawat numero ay dapat nasa sarili nitong linya. Ang bilang ng mga digit sa isang linya (W) ay ipinasok mula sa keyboard.
W = 10
1
2
3
4
5
6
7
8
9
W = 100000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999
Kung ang isang mag-aaral ay pinagkadalubhasaan ang pamamaraan ng pagpapalit ng isang variable, pagkatapos ay makaya niya nang mabilis. Ang isang posibleng problema ay muli sa pag-reset ng variable. Kung hindi mo mahawakan ang pagbabago, nangangahulugan ito na nagmamadali ka at kailangan mong lutasin ang mga mas simpleng problema.
Salamat sa iyong atensyon. Mag-like at mag-subscribe sa channel.
PS Kung makakita ka ng mga typo o error sa text, mangyaring ipaalam sa akin. Magagawa ito sa pamamagitan ng pagpili ng bahagi ng text at pagpindot sa “⌘ + Enter” sa Mac, at “Ctrl / Enter” sa mga classic na keyboard, o sa pamamagitan ng mga pribadong mensahe. Kung hindi available ang mga opsyong ito, isulat ang tungkol sa mga error sa mga komento. Salamat!
Ang mga rehistradong user lamang ang maaaring lumahok sa survey. , pakiusap
Poll para sa mga mambabasa na walang karma
-
20,0%Nagtuturo ako nang propesyonal, +12
-
10,0%Nagtuturo ako nang propesyonal, -11
-
70,0%Hindi ako nagtuturo, +17
-
0,0%Hindi ako nagtuturo, -10
-
0,0%Iba pa0
10 user ang bumoto. 5 na user ang umiwas.
Pinagmulan: www.habr.com