Trotz der Tatsaach, datt mir iwwer ee vun de Basis Themen schwätzen, ass dësen Artikel fir erfuerene Fachleit geschriwwen. D'Zil ass ze weisen wat Mëssverständnis Ufänger am Programméiere hunn. Fir praktizéierend Entwéckler sinn dës Probleemer laang geléist, vergiess oder guer net gemierkt. Den Artikel ka praktesch kommen wann Dir op eemol een mat dësem Thema hëllefe musst. Den Artikel zitt Parallelen mat Material aus verschiddene Bicher iwwer Programméierung vum Schildt, Stroustrup, Okulov.
D'Thema iwwer d'Zyklen gouf gewielt, well zimlech vill Leit dovun ausgeschloss sinn wann se d'Programméiere beherrschen.
Dës Technik ass fir schwaach Studenten entworf. In der Regel, staark Leit stinn net op dësem Thema an et ass net néideg mat speziellen Techniken fir si ze kommen. Déi sekundär Zil vum Artikel ass dës Technik aus der Klass "Wierkt fir all Studenten, awer nëmmen een Enseignant" an d'Klass "Wierkt fir all Studenten, all Enseignanten". Ech behaapten keng absolut Originalitéit. Wann Dir schonn eng ähnlech Methodik benotzt fir dëst Thema ze léieren, schreift w.e.g. wéi Är Versioun ënnerscheet. Wann Dir decidéiert et ze benotzen, sot eis wéi et gaang ass. Wann eng ähnlech Technik an engem Buch beschriwwe gëtt, schreift w.e.g. den Numm.
Ech hunn op dëser Technik fir 4 Joer geschafft, individuell mat Studenten vu verschiddenen Trainingsniveauen studéiert. Am Ganzen sinn et ongeféier fofzeg Studenten an zwee dausend Stonne Coursen. Fir d'éischt hunn d'Studenten ëmmer bei dësem Thema festgehalen a sinn fortgaang. No all Schüler goufen d'Methodologie a Materialien ugepasst. Am leschte Joer hunn d'Studenten net méi un dësem Thema festgehal, also hunn ech beschloss meng Erkenntnisser ze deelen.
Firwat sou vill Bréiwer? Cyclen sinn sou elementar!
Wéi ech uewen geschriwwen hunn, fir praktizéierend Entwéckler a fir staark Studenten, kann d'Komplexitéit vum Konzept vu Loops ënnerschat ginn. Zum Beispill, Dir kënnt e laange Virtrag ginn, gesinn noding Käpp an intelligent Aen. Awer wann Dir probéiert e Problem ze léisen, fänken d'Stëmmung an onerklärbar Probleemer un. Nom Virtrag haten d'Schüler wuel nëmmen en deelweis Verständnis. D'Situatioun gëtt verschäerft duerch d'Tatsaach, datt d'Studenten selwer net kënne soen, wat hir Wahn ass.
Enges Daags hunn ech gemierkt datt d'Schüler meng Beispiller als Hieroglyphe gesinn hunn. Dat ass, wéi ondeelbar Textstécker, an deenen Dir e puer "Magie" Bréif derbäi musst an et funktionnéiert.
Heiansdo hunn ech gemierkt datt d'Studenten mengen datt Dir e spezifesche Problem braucht fir ze léisen eppes anescht en Design deen ech just nach net ofgedeckt hunn. Obwuel d'Léisung nëmmen eng liicht Ännerung vum Beispill erfuerdert.
Also sinn ech op d'Iddi komm datt de Fokus net op d'Syntax vun Ausdréck sollt sinn, mee op d'Iddi fir repetitive Code mat Loops ze refactoréieren. Wann d'Schüler dës Iddi beherrscht hunn, kann all Syntax mat wéineg Praxis verbessert ginn.
Wien a firwat léieren ech?
Well et keng Entrée Examen, Klassen kënnen souwuel staark a ganz schwaach Schüler enthalen. Dir kënnt méi iwwer meng Studenten am Artikel liesen
Ech hu beméit fir sécherzestellen datt jidderee dee Programméiere wëll léiere kann et léieren.
Meng Klassen sinn individuell ofgehalen an de Schüler bezuelt seng eege Suen fir all. Et schéngt, datt d'Studenten d'Käschte optimiséieren an de Minimum verlaangen. Wéi och ëmmer, d'Leit ginn an d'Gesiicht-zu-Gesiicht Klasse mat engem Live Enseignant net fir d'Wëssen selwer, mee fir d'Vertrauen vun deem wat se geléiert hunn, fir e Gefill vu Fortschrëtt a fir d'Zustimmung vum Expert (Léierpersonal). Wann d'Schüler kee Fortschrëtt an hirem Léieren fillen, gi se fort. Am Allgemengen kënnen d'Klasse strukturéiert ginn, sou datt d'Schüler Fortschrëtter fillen fir d'Zuel vu vertraute Strukturen ze erhéijen. Dat ass, fir d'éischt studéiere mir während am Detail, da studéiere mir fir, da maache mir während, an elo hu mir dausend an eng Nuecht Cours prett, an deem Zyklen eleng fir zwee Méint studéiert ginn, an um Enn - e Student deen geschriwwen huet eng Standardbibliothéik ënner Diktat. Allerdéngs, fir praktesch Problemer ze léisen, brauch Dir net nëmmen Wëssen iwwer d'Material, awer och Onofhängegkeet an hirer Uwendung an der Sich no neien Informatioun. Dofir, fir Gesiicht-ze-Gesiicht Coursen, mengen ech de richtege Prinzip ass de Minimum ze léieren an onofhängeg Etude vun Nuancen a verbonne Themen encouragéieren. Am Thema Loops betruechten ech de Wärend Konstruktioun als Minimum. Dir kënnt de Prinzip dovunner verstoen. Wann Dir de Prinzip kennt, kënnt Dir souwuel fir an do-wann Dir selwer beherrschen.
Fir d'Meeschterung vum Material vu schwaache Studenten z'erreechen, ass d'Syntax ze beschreiwen net genuch. Et ass néideg fir méi einfach, awer variéiert Aufgaben ze ginn a Beispiller méi detailléiert ze beschreiwen. Schlussendlech ass d'Geschwindegkeet vun der Entwécklung limitéiert duerch d'Fäegkeet vum Student fir Ausdréck ze transforméieren an no Musteren ze sichen. Fir intelligent Studenten wäerten déi meescht Aufgaben langweileg sinn. Wann Dir mat hinnen studéiert, musst Dir net insistéieren op 100% vun de Problemer ze léisen. Meng Material kann gekuckt ginn op . Richteg, de Repository ass méi wéi e Warlock's Grimoire - keen ausser ech wäert verstoen wat wou ass, a wann Dir de Scheck feelt, kënnt Dir verréckt ginn
D'Methodologie ass praktesch orientéiert
D'Theorie gëtt erkläert mam Beispill fir e Problem ze léisen. An enger Fundamental vun der Programméierungsklass, wou Branchen a Schleifen geléiert ginn, ass et einfach net méiglech eng nëtzlech Virliesung iwwer een Thema fir eng ganz Stonn ze maachen. 15-20 Minutten ass genuch fir d'Konzept z'erklären. D'Haaptschwieregkeeten entstinn wann Dir praktesch Aufgaben ausféiert.
Ufänger Léierpersonal kënnen d'Betreiber, Filialen, Schleifen, an Arrays an engem Virtrag rattelen. Awer hir Schüler wäerten de Problem stellen dës Informatioun ze assimiléieren.
No all, Dir musst net nëmmen d'Material soen, mä och sécherstellen, datt d'Nolauschterer et verstoen.
D'Tatsaach, en Thema ze beherrschen, gëtt festgeluegt wéi de Student mat onofhängeger Aarbecht këmmert.
Wann e Student et fäerdeg bruecht huet e Problem iwwer en Thema ze léisen ouni d'Hëllef vun engem Enseignant, dann ass d'Thema beherrscht. Fir Selbsttestung ze garantéieren, gëtt all Aufgab an enger Tabell mat Testszenarien beschriwwen. D'Aufgaben hunn eng kloer Uerdnung. Aufgaben iwwersprangen ass net recommandéiert. Wann déi aktuell Aufgab ze schwéier ass, dann ass weider op déi nächst nëtzlos. Et ass nach méi komplizéiert. Fir datt de Schüler déi aktuell komplex Aufgab beherrscht, ginn him e puer Techniken erkläert mat dem Beispill vum éischte Problem. Eigentlech kënnt de ganzen Inhalt vum Thema op Techniken fir Schwieregkeeten ze iwwerwannen. Zyklen si méi eng Nebenwirkung.
Déi éischt Aufgab ass ëmmer e Beispill. Déi zweet ënnerscheet sech liicht a gëtt "onofhängeg" direkt no der éischter ënner der Opsiicht vun engem Enseignant duerchgefouert. All spéider Aufgaben zielen op Opmierksamkeet op verschidde kleng Saachen ze bezuelen, déi Mëssverständnisser verursaache kënnen.
D'Erklärung vum Beispill ass en Dialog an deem de Schüler d'Verbreedung an d'Kräizvalidatioun muss zréckruffen fir sécherzestellen datt hien en Deel vum Material beherrscht.
Ech wäert banal sinn a soen datt dat éischt Beispill zum Thema ganz wichteg ass. Wann Dir d'Material fir extensiv onofhängeg Aarbecht hutt, kënnen d'Omissiounen vum éischte Beispill korrigéiert ginn. Wann et näischt anescht wéi d'Beispill ass, da wäert de Schüler héchstwahrscheinlech d'Thema net beherrschen.
Während oder fir?
Ee vun de kontroversen Themen ass d'Wiel vum Bau fir d'Beispill: während oder fir. Eemol huet e praktizéierenden Entwéckler Frënd vu mir ouni Léiererfahrung eng Stonn verbruecht fir mech ze iwwerzeegen datt d'For Loop am einfachsten ze verstoen war. D'Argumenter sinn op "Alles dran ass kloer an op senger Plaz geluecht." Wéi och ëmmer, d'Ursaach vu Schwieregkeeten fir richteg Ufänger ass d'Iddi vum Zyklus selwer, an net säi Schreiwen. Wann eng Persoun dës Iddi net versteet, da wäert hien Schwieregkeeten mat der Syntax hunn. Soubal d'Iddi realiséiert gëtt, verschwannen d'Problemer vum Code Design eleng.
A menge Materialien ass d'Thema vu Schleifen dem Thema vun der Verzweigung. Déi extern Ähnlechkeet vu wann a wärend erlaabt eis eng direkt Analogie ze zéien: "wann d'Konditioun am Header richteg ass, da gëtt de Kierper ausgefouert." Déi eenzeg Besonderheet vum Zyklus ass datt de Kierper vill Mol ausgefouert gëtt.
Meng zweet Argument ass, datt iwwerdeems manner Formatéierung brauch wéi fir. Manner Formatéierung bedeit manner domm Feeler mat fehlende Kommaen a Klammern. Ufänger hunn nach net genuch Opmierksamkeet a Virsiichtegkeet entwéckelt fir automatesch Syntaxfehler ze vermeiden.
Dat drëtt Argument gëtt a ville gudde Bicher als éischt Argument erkläert.
Wann de Schüler d'Ausdréck einfach transforméiere kann, da kënnt Dir am Viraus schwätzen. De Schüler wielt dann dat wat him am beschte gefält. Wann Transformatiounen Schwieregkeeten verursaachen, ass et besser net Är Opmierksamkeet ze distractéieren. Loosst de Schüler fir d'éischt alles léisen mat der Zäit. Wann Dir d'Thema vun de Loops beherrscht hutt, kënnt Dir d'Léisungen iwwerschreiwe fir d'Konvertéierung ze üben wärend fir.
Postbedingungsschleifen sinn e relativ seelen Béischt. Ech verbréngen guer keng Zäit drop. Wann e Student d'Iddie beherrscht huet fir Musteren z'identifizéieren an Ausdréck ze transforméieren, kann hien et ouni meng Hëllef erausfannen.
Wann ech dat éischt Beispill fir staark Studenten demonstréieren, zéien ech op d'Tatsaach datt et am éischte Beispill wichteg ass net nëmmen d'Léisung opzehuelen, awer och d'ganz Kette vun Aktiounen, déi zum Resultat gefouert hunn. Lazy Studenten kënnen d'Schreiwen vernoléissegen an nëmmen de finalen Algorithmus kopéieren. Si mussen iwwerzeegt sinn, datt enges Daags eng schwiereg Aufgab op hire Wee kënnt. Fir et ze léisen, musst Dir d'Schrëtt verfollegen wéi an dësem Beispill. Dofir ass et wichteg all Etappen opzehuelen. An de folgende Problemer ass et méiglech nëmmen déi lescht Versioun vun der Léisung ze verloossen.
D'Haaptidee vun der Automatioun ass datt mir e Computer uvertraut fir Routineaarbecht fir eng Persoun ze maachen. Ee vun de Basis Techniken ass Schreifweis Schleifen. Et gëtt benotzt wann e puer identesch Widderhuelungsaktiounen an engem Programm an enger Zeil geschriwwe ginn.
Explizit ass besser wéi implizit
Et kéint wéi eng gutt Iddi schéngen déi selwecht Ausdrock e puer Mol an der éischter Looping Aufgab ze weisen. Zum Beispill:
Hurra, et funktionnéiert!
Hurra, et funktionnéiert!
Hurra, et funktionnéiert!
Hurra, et funktionnéiert!
Hurra, et funktionnéiert!
Hurra, et funktionnéiert!
Hurra, et funktionnéiert!
Hurra, et funktionnéiert!
Dës Optioun ass schlecht well de Konterwäert net am Ausgang sichtbar ass. Dëst ass e Problem fir Ufänger. Ënnerschätzt hatt net. Fir d'éischt war dës Aufgab déi éischt, an d'Aufgab fir eng Serie vun Zuelen an opsteigend Uerdnung z'erreechen war déi zweet. Et war néideg zousätzlech Begrëffer "Zyklus N Mol" an "Zyklus vun A op B" aféieren, déi am Fong d'selwecht sinn. Fir net onnéideg Entitéiten ze kreéieren, hunn ech beschloss nëmmen e Beispill mat der Ausgang vun enger Serie vun Zuelen ze weisen. Puer Leit geléngen ze léieren, wéi engem Konter am Kapp ze halen an d'Behuele vun engem Programm am Kapp ouni Virbereedung modelléieren. E puer Studenten begéinen als éischt mental Modeller iwwer d'Thema Zyklen.
No e bësse Praxis ginn ech d'Aufgab fir dee selwechten Text ze widderhuelen fir onofhängeg ze léisen. Wann Dir fir d'éischt e sichtbare Konter gitt an dann en onsichtbaren, hunn d'Schüler manner Problemer. Heiansdo ass den Hiweis "Schreift de Konter net um Écran" genuch.
Wéi erklären anerer et?
Am meeschte Bildungsmaterial um Internet gëtt d'Syntax vum Zyklus am Kader vun engem "Virtrag" gegeben. Zum Beispill, op developer.mozilla.org (aktuell), ginn e puer aner Konstrukter zesumme mat der While Loop beschriwwen. An dësem Fall sinn nëmmen d'Designs selwer a Form vu Schabloune ginn. D'Resultat vun hirem Start gëtt a Wierder beschriwwen, awer et gëtt keng Illustratioun. Menger Meenung no, sou eng Presentatioun vum Thema multiplizéiert d'Nëtzlechkeet vun esou Materialien mat Null. De Schüler kann de Code iwwerschreiwe a selwer lafen, awer hien brauch nach ëmmer e Standard fir de Verglach. Wéi kënnt Dir verstoen datt e Beispill richteg ëmgeschriwwe gouf wann et näischt ass fir d'Resultat ze vergläichen?
Wann nëmmen eng Schabloun gëtt, ouni e Beispill, gëtt et nach méi schwéier fir de Schüler. Wéi ze verstoen datt d'Codefragmenter richteg an der Schabloun plazéiert sinn? Dir kënnt probéieren ze schreiwen iergendwéi, an dann lafen. Awer wann et kee Standard gëtt fir d'Resultat ze vergläichen, da wäert de Start och net hëllefen.
Am C ++ Cours iwwer Intuitiv gëtt d'Loop Syntax op der drëtter Säit vum Virtrag 4 iwwer d'Thema "Operateuren" begruewen. Wann Dir d'Syntax vu Loop erkläert, gëtt spezielle Wäert op de Begrëff "Bedreiwer" geluecht. De Begrëff gëtt als Set vu Fakten presentéiert wéi "Symbol; dëst ass eng Ausso", "{} ass eng zesummegesate Ausso", "de Kierper vun der Loop muss eng Ausso sinn". Ech hunn dës Approche net gär well et schéngt wichteg Bezéiungen hannert engem Begrëff ze verstoppen. Parsing de Quellcode vun engem Programm a Begrëffer op dësem Niveau ass vun Compiler Entwéckler gebraucht fir d'Sprooch Spezifikatioun ëmzesetzen, awer net vun de Studenten als éischt Approximatioun. Newcomer zu programméiere si selten virsiichteg genuch fir esou no Opmierksamkeet op Begrëffer ze bezuelen. Et ass eng selten Persoun déi erënnert a versteet nei Wierder déi éischte Kéier. Bal kee kann e Begrëff richteg applizéieren deen se just geléiert hunn. Dofir kréien d'Schüler vill Feeler wéi "Ech hunn geschriwwen wärend (a<7);{, awer de Programm funktionnéiert net."
Menger Meenung no, am Ufank ass et besser d'Syntax vun der Konstruktioun direkt mat Klammern ze ginn. D'Optioun ouni Klammern soll nëmmen erkläert ginn wann de Schüler eng spezifesch Fro huet: "Firwat gëtt et keng Klammern an et funktionnéiert."
Am Okulov sengem 2012 Buch "Fundamentals of Programming", fänkt eng Aféierung an d'Schleifen mat dem For Muster un, gitt dann Empfehlungen fir seng Benotzung, a geet dann direkt an d'experimentell Sektioun vun der Lektioun. Ech verstinn datt d'Buch fir déi Minoritéit vu ganz kapabele Studenten geschriwwe gouf, déi seelen an meng Klassen kommen.
A populäre Bicher gëtt d'Resultat vu Codefragmenter ëmmer geschriwwen. Zum Beispill, dem Shildt seng "Java 8. The Complete Guide" 2015 Editioun. Als éischt gëtt eng Schabloun uginn, dann e Beispillprogramm an direkt duerno - d'Resultat vun der Ausféierung.
Als Beispill, betruecht eng Wäitschleife déi de Géigendeel mécht
Countdown ab 10, a genee 10 Zeilen vun "Mesuren" ginn ugewisen://Продемонстрировать применение оператора цикла while class While { public static void main(String args []) { int n = 10; while (n > 0) { System.out.println("такт " + n); n--; } } }Eemol lafen, gëtt dëse Programm zéng "Zyklen" wéi follegt:
такт 10
такт 9
такт 8
такт 7
такт 6
такт 5
такт 4
такт 3
такт 2
такт 1
D'Approche fir eng Schabloun ze beschreiwen, e Beispillprogramm an d'Resultat vum Programm gëtt och am Buch "Javascript for Kids" an am js-Cours op w3schools.com benotzt. D'Websäitformat erlaabt dëst Beispill souguer interaktiv ze sinn.
Dem Stroustrup säi 2016 Buch Prinzipien a Praxis mat C++ ass nach méi wäit gaangen. Den éischte Schrëtt ass ze erklären wat Resultat soll kritt ginn, an dann ass den Text vum Programm gewisen. Ausserdeem huelen se net nëmmen en zoufälleg Programm als Beispill, awer ginn en Ausfluch an d'Geschicht. Dëst hëlleft der Opmierksamkeet op et ze zéien: "Kuckt, dëst ass net nëmmen en onnëtzen Text. Dir gesitt eppes sënnvoll."
Als Beispill vun Iteratioun, betruecht den éischte Programm op enger gespäichert Programmmaschinn (EDSAC) ausgefouert. Et gouf vum David Wheeler am Computer Laboratory vun der Cambridge University, England de 6. Mee 1949 geschriwwen. Dëse Programm berechent a dréckt eng einfach Lëscht vu Quadraten.
0 0
1 1
2 4
3 9
4 16
...
98 9604
99 9801
Hei enthält all Zeil eng Nummer gefollegt vun engem Tab Charakter ('t') an de Quadrat vun där Nummer. D'C++ Versioun vun dësem Programm gesäit esou aus://Вычисляем и распечатываем таблицу квадратов чисел 0-99 int main() { int i = 0; // Начинаем с нуля while(i < 100){ cout << i << 't' << square(i) << 'n'; ++i; } }
Interessanterweis ass d'Syntaxmuster net an dësem Buch beschriwwen. Stroustrup im Instruktorhandbuch () ënnersträicht datt et d'Intelligenz vu senge Studenten respektéiert. Vläicht ass d'Fäegkeet fir e Muster an e puer Beispiller z'identifizéieren als Manifestatioun vun esou Intelligenz.
Wéi ech erkläre mech
D'Approche vum Stroustrup: d'Resultat ze beschreiwen, dann de Problem ze léisen, an dann eng onofhängeg Analyse vum Student - schéngt am meeschte nodenklech. Dofir hunn ech décidéiert et als Basis ze huelen, awer soen et mat engem manner historesche Beispill - d'Aufgab fir en "Inhaltsverzeechnes" ze kréien. Et formt en erkennbaren Anker, fir datt Dir dann "erënnert un d'Aufgab iwwer den Inhaltsverzeechnes" kënnt soen a fir datt d'Schüler sech genee dat erënneren. A mengem Beispill hunn ech probéiert zwee méi vun den heefegste Mëssverständnisser ze vermeiden. Als nächst wäert ech iwwer si méi detailléiert schreiwen.
An dëser Aufgab gi mir Techniken agefouert fir komplex Problemer ze léisen. Déi éischt Entscheedung muss primitiv an einfach gemaach ginn. Gutt, da kënnt Dir iwwerdenken wéi Dir dës Léisung verbessert.
Введение
Глава 1
Глава 2
Глава 3
Глава 4
Глава 5
Глава 6
Глава 7
Заключение
No menger Observatioune féiert d'Approche "Schabloun-Beispill-Resultat" a verschiddene Kombinatiounen nach ëmmer zu der Tatsaach, datt d'Schüler den Zyklus als Hieroglyph gesinn. Dat huet sech an der Tatsaach manifestéiert, datt si net verstanen hunn, firwat et eng Bedingung gëtt fir do ze schreiwen, wéi een tëscht i++ an i— an aner anscheinend offensichtlech Saachen auswielen. Fir dës Mëssverständnisser ze vermeiden, sollt d'Approche fir iwwer Zyklen ze schwätzen, d'Bedeitung vun der Widderhuelung vun identesche Aktiounen ënnersträichen an nëmmen duerno mat enger Struktur formaliséieren. Dofir, ier Dir de Loop Syntax gitt, musst Dir de Problem direkt léisen. Eng primitiv Léisung fir den Inhaltsverzeechnesproblem gesäit esou aus:
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("Заключение");
Wéi kann et verbessert ginn?
Ersetzen monoton Aktiounen mat engem Zyklus.
Wéi eng Aktiounen ginn an enger Rei widderholl ouni Ännerungen?
Et gi keng an dësem Fragment. Wéi och ëmmer, d'Befehle fir d'Wuert "Kapitel" mat enger Zuel ze weisen si ganz ähnlech mateneen.
Dofir ass déi nächst Etapp den Ënnerscheed tëscht de Fragmenter ze fannen. Et ass nëmmen an dëser Aufgab datt alles offensichtlech ass, da ginn net eenzel Befehle widderholl, awer Codeblocks vu 5 Linnen oder méi. Dir musst net nëmmen an der Lëscht vun de Kommandoen sichen, mee a Verzweigungs- oder Loopkonstruktiounen.
Am Beispill ass den Ënnerscheed tëscht de Kommandoen an der Zuel nom Wuert "Kapitel".
Wann den Ënnerscheed fonnt gëtt, musst Dir d'Muster vun der Ännerung verstoen. Déi aner Fragment ass d'Zuel? Gëtt et stänneg erop oder erof? Wéi ännert sech de Wäert vun enger Zuel tëscht zwou Équipen niewenteneen?
Am Beispill erhéicht d'Zuel nom Wuert "Kapitel" an Inkremente vun 1. Den Ënnerscheed gëtt fonnt, d'Muster gëtt opgedeckt. Elo kënnt Dir dat ënnerschiddlecht Fragment mat enger Variabel ersetzen.
Dir musst esou eng Variabel virun der éischter vun de widderhuelende Fragmenter deklaréieren. Esou eng Variabel gëtt normalerweis I oder j genannt oder eppes méi detailléiert. Säin initialen Wäert muss gläich sinn dem éischte Wäert deen um Bildschierm ugewise gëtt. Am Beispill ass den éischte Wäert 1.
Wéi eng initial Wäert soll geholl ginn fir d'Serie vun den Zuelen "100, 101, 102, 103, 104, 105" ze weisen?
Déi éischt Nummer an dëser Serie ass 100.
No all Ausgabbefehl musst Dir de Wäert vun dëser Variabel ëm 1 erhéijen. Dës Eenheet ass de Changement Schrëtt.
Wat Schrëtt wäert an der Serie vun Zuelen ginn "100, 102, 104, 106"?
Schrëtt 2 an dëser Zeil.
Nodeems Dir dat ënnerschiddlecht Fragment mat enger Variabel ersetzt, gesäit de Code esou aus:
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("Заключение");
Nodeems Dir d'Technik "Ausdréck vum Muster vun enger Variabel" am Code applizéiert hutt, kritt Dir e puer Gruppe vun identesche Aktiounen, déi an enger Zeil goen. Elo kënnen widderhuelend Aktiounen duerch en Zyklus ersat ginn.
D'Sequenz fir e Problem ze léisen wou Dir Loops benotze musst besteet aus de folgende Schrëtt:
- Solve "head-on" mat villen separaten Kommandoen
- Fannt e Muster
- Express d'Muster vun enger Variabel
- Design als Zyklus
Als nächst ginn nei Begrëffer agefouert fir datt de Schüler sech net an der Situatioun fënnt "Ech verstinn alles, awer ech kann et net soen":
- e Konter ass ëmmer eng Variabel déi gebraucht gëtt fir d'Zuel vun de Schrëtt an enger Loop ze verfolgen. Typesch eng ganz Zuel déi mat der Aschränkung verglach gëtt.
- Konter Schrëtt - Beschreiwung vun der Muster vun Konter Ännerungen.
- Constraint - eng Zuel oder Variabel mat där de Konter verglach gëtt, sou datt den Algorithmus endgülteg ass. De Konterwäert ännert sech fir un d'Limite ze kommen.
- Loop Kierper - eng Rei vu Kommandoen déi widderholl ginn. Wa se soen "de Kommando ass an enger Loop geschriwwen", mengen se de Kierper.
- Loop Iteration - eng Kéier Ausféierung vum Loop Kierper.
- Loop Conditioun - e logeschen Ausdrock deen bestëmmt ob eng aner Iteratioun ausgefouert gëtt. (Et kann Duercherneen mat Verzweigungsstrukturen hei sinn)
Dir musst op d'Tatsaach virbereet sinn datt d'Studente fir d'éischt Begrëffer fir aner Zwecker benotzen. Dëst gëllt souwuel fir déi staark wéi déi schwaach. Eng gemeinsam Sprooch opzebauen ass eng Konscht. Elo schreiwen ech kuerz: Dir musst d'Aufgab setzen "Highlight the Code Fragment with <term>" a benotzt dës Begrëffer selwer richteg am Gespréich.
No der Transformatioun mat enger Loop gëtt de Fragment kritt:
Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
Console.WriteLine("Глава " + i);
i = i + 1;
}
Console.WriteLine("Заключение");D'Haaptrei Mëssverständnis
Ee populäre Mëssverständnis ënner Studenten ass datt se Handlungen an enger Loop setzen déi nëmmen eemol gemaach musse ginn. Zum Beispill esou:
;
int i = 0;
while (i < 7) {
Console.WriteLine("Введение")
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");
}
D'Schüler stinn ëmmer an dësem Problem, souwuel am Ufank wéi a méi komplexe Problemer.
Schlëssel Tipp an dësem Fall:
Wéi oft sollt Dir de Kommando widderhuelen: eemol oder vill Mol?
D'Befehle fir d'Wierder "Aféierung" an "Conclusioun" ze drécken an d'Variabel i z'erklären an ze initialiséieren sinn net wéi aner repetitive Aktiounen. Si ginn nëmmen eemol ausgefouert, dat heescht datt se ausserhalb vum Loopkierper geschriwwe musse ginn.
All dräi Etappe vun der Léisung sollten am Code bleiwen, fir datt Dir se spéider am Fall vu Schwieregkeete verweisen kënnt. Et ass genuch fir déi éischt zwou Optiounen ze kommentéieren fir datt se net stéieren.
D'Opmierksamkeet vum Schüler soll op déi folgend Fakten ugezunn ginn:
- An engem Loopbedingung ginn normalerweis e Konter an eng Limit verglach. De Konter kann am Kierper vun der Loop änneren, awer d'Limite kann net. Fir dës Regel ze briechen, musst Dir zwéngend Grënn formuléieren.
- Kommandoen fir d'Wierder "Aféierung" a "Conclusioun" ze weisen sinn ausserhalb vum Kierper vun der Loop. Mir mussen se 1 Kéier ausféieren. "Aféierung" - ier d'Aktiounen widderhuelen, "Conclusioun" - no.
Am Prozess vun der Konsolidéierung vun dësem Thema, Meeschter um nächsten, wéi och mat Schwieregkeeten ze këmmeren, ass et nëtzlech fir och staark Studenten d'Fro ze stellen: "Wéi oft muss dës Aktioun gemaach ginn? Een oder vill?
Entwécklung vun zousätzlech Kompetenzen
Am Prozess vun der Studie vun Zyklen entwéckelen d'Schüler och d'Fäegkeet fir d'Diagnos an d'Léisung vu Probleemer. Fir Diagnostik auszeféieren, muss de Schüler dat gewënschte Resultat presentéieren an et mam aktuellen Resultat vergläichen. Korrekturaktiounen hänkt vum Ënnerscheed tëscht hinnen of.
Zënter Studenten op dëser Etapp nach ëmmer wéineg Ahnung vum "gewënschte" Resultat hunn, kënne se sech op Testdaten konzentréieren. An der Regel, op dëser Etapp nach kee versteet, wat kann schief goen a wéi et ëmzegoen. Dofir schreiwen ech an engem Notizbuch eng Beschreiwung vun typesche Probleemer a verschidde Weeër fir se ze léisen. Wielt déi gëeegent ass d'Aufgab vum Schüler selwer.
E Rekord ass néideg fir ze froen "Huet dat wat erwaart gouf geschitt?", "Wéi vun dëse Situatiounen ass elo geschitt?", "Huet déi applizéiert Léisung gehollef?"
- D'Zuel vun den Aktiounen ass 1 manner oder méi wéi erwaart. Léisungen:
- erhéicht den initialen Wäert vum Comptoir ëm 1.
- ersetzt de strenge Vergläichsbedreiwer (< oder >) mat engem net-strengen (<= oder >=).
- ännert de Grenzwäert op 1. - Aktiounen an enger Loop ginn ouni Stopp gemaach, onbestëmmt. Léisungen:
- füügt e Konterännerungskommando un wann et fehlt.
- fixéiert de Konterännerungskommando sou datt säi Wäert méi no un der Limit gëtt.
- läscht de Beschränkungsännerungskommando wann et am Kierper vun der Loop ass. - D'Zuel vun den Aktiounen an enger Loop ass méi wéi 1 manner oder méi wéi erwaart. D'Aktioun an der Loop gouf net mol eng Kéier ausgefouert. Als éischt musst Dir déi aktuell Wäerter vun de Variabelen erausfannen just ier d'Loop ufänkt. Léisungen:
- den initialen Wäert vun der Aschränkung änneren
- den initialen Wäert vum Comptoir änneren
Problem 3 ëmfaasst normalerweis déi falsch Variabel ze benotzen oder de Konter net op Null zrécksetzen.
No dëser Erklärung kann de Student nach ëmmer verschidde Mëssverständnisser hunn iwwer wéi d'Loops funktionnéieren.
Fir déi heefegst ze verdreiwen, ginn ech Iech déi folgend Aufgaben:
- An deem d'Limite, den initialen Konterwäert oder de Konterschrëtt vum Benotzer aginn ass.
- An deem de Konterwäert muss an e puer arithmeteschen Ausdrock benotzt ginn. Et ass ubruecht e Konter am radikalen Ausdrock oder am Nenner ze benotzen, sou datt den Ënnerscheed netlinear ass.
- An deem de Konterwäert net um Bildschierm ugewise gëtt während d'Loop leeft. Zum Beispill, déi erfuerderlech Unzuel vun identesche Textfragmenter ze weisen oder eng Figur mat Schildkröt Grafiken ze zéien.
- An deem Dir musst éischt e puer repetitive Aktiounen Leeschtunge, an dann anerer.
- An deem Dir musst aner Aktiounen virun an no Widderhuelung ausféieren
Fir all Aufgab musst Dir Testdaten an dat erwaart Resultat ubidden.
Fir ze verstoen wéi séier Dir kënnt bewegen, musst Dir d'Konditioune vun dëse Probleemer liesen a froen: "wéi ënnerscheede se sech vum Beispill?", "Wat muss am Beispill geännert ginn fir se ze léisen?" Wann de Schüler sënnvoll äntwert, da loosst hien op d'mannst een an der Klass léisen, an de Rescht doheem eleng. Wann d'Léisung erfollegräich ass, da kënne mir ufänken d'Konditioune bannent de Schleifen z'erklären.
Wann Dir Probleemer hutt mat Iech selwer ze léisen, musst Dir alles an der Klass duerchschaffen. Fir ze vermeiden datt d'Problem ze léisen erënnert un d'Zeechnung vun enger Eule, ech recommandéieren d'éischt de Problem op eng net-universal Manéier ze léisen. Dat ass, sou datt d'Léisung den éischten Test passéiert an d'Loopkonstruktioun net benotzt. Gutt, da gëlle Transformatiounen fir d'Universalitéit vun der Léisung z'erreechen.
Loops a Branchen
Menger Meenung no ass et nëtzlech fir d'Thema "Zyklen bannent Branchen" getrennt ze ginn. Also datt Dir méi spéit den Ënnerscheed gesitt tëscht engem Conditioun méimol ze kontrolléieren an et eemol ze kontrolléieren.
D'Aufgabe fir d'Konsolidéierung wäerten d'Zuelen vun A op B ausginn, déi vum Benotzer agefouert ginn:
- ëmmer an opsteigend Uerdnung.
- opsteigend oder erofgaang ofhängeg vun de Wäerter vun A a B.
D'Thema "Verzweigung bannent Schleifen" soll eréischt geplënnert ginn nodeems de Student d'Technike beherrscht huet: "e Muster mat enger Variabel ersetzen" an "repetitive Aktiounen mat engem Zyklus ersetzen."
Den Haaptgrond fir d'Branchen an de Schleifen ze benotzen ass Anomalien am Muster. An der Mëtt brécht se ofhängeg vun den initialen Donnéeën.
Fir déi Studenten, déi fäeg sinn eng Léisung ze sichen andeems se einfach Techniken kombinéieren, ass et genuch ze soen "Verzweigung kann a Schleifen geschriwwe ginn" an de Problem "zum Beispill" komplett onofhängeg ze léisen.
Beispill Aufgab:
De Benotzer setzt d'Zuel X an. Weist d'Zuelen vun 0 bis 9 an enger Kolonn a setzt en '+' Zeeche vis-à-vis vun der Zuel déi dem X gläich ass.
Wann 0 agefouert gouf0+
1
2
3
4
5
6
7
8
9
Wann 6 agefouert gouf0
1
2
3
4
5
6+
7
8
9
Wann 9 agefouert gouf0
1
2
3
4
5
6
7
8
9+
Wann 777 agefouert gouf0
1
2
3
4
5
6
7
8
9
Wann eng kuerz Erklärung net genuch ass fir mat enger Loop ze schreiwen, da musst Dir eng universell Léisung fir dee selwechte Problem ouni Loop erreechen.
Dir kritt eng vun zwou Méiglechkeeten:
Wonsch
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);
}
Méiglech
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+");
}
Ech ginn eng ähnlech Aufgab am Viraus, wärend ech d'Thema vun der Verzweigung studéieren.
Wann de Schüler mat enger "méiglecher" Optioun kënnt, da musst Dir hinnen soen datt et vill Léisunge fir dee selwechte Problem ka ginn. Wéi och ëmmer, si ënnerscheede sech an hirer Resistenz géint Ännerungen an Ufuerderungen. Stellt d'Fro: "Wéi vill Plazen am Code musse korrigéiert ginn wann ech eng aner Nummer derbäisetzen?" An der "méiglecher" Versioun musst Dir nach eng Branche derbäisetzen an eng nei Nummer op 10 anere Plazen derbäi. Am "gewënschte" ass et genuch fir nëmmen eng Branche ze addéieren.
Setzt d'Aufgab fir déi "gewënscht" Optioun ze reproduzéieren, da fannt Dir e Muster am Code, maacht e variabelen Ersatz a schreift eng Loop.
Wann Dir eng Iddi hutt wéi Dir dëse Problem ouni Loop op eng aner Manéier léist, da schreift w.e.g. an de Kommentarer.
Loops bannent Loops
An dësem Thema musst Dir op déi folgend oppassen:
- Zähler fir déi bannenzeg an äusser Schleifen mussen ënnerschiddlech Variabelen sinn.
- de Konter fir déi bannescht Loop muss vill Mol zréckgesat ginn (dat heescht am Kierper vun der äusseren Loop).
- an Textausgabe Aufgaben, kënnt Dir net als éischt ee Bréif a verschiddene Zeilen schreiwen, an dann deen zweeten. Dir musst éischt all Buschtawen vun der éischter Linn Drécken, dann all Buschtawen vun der zweeter, an sou op.
Et ass am beschten d'Thema vu Schleifen bannent Schleifen z'erklären andeems Dir d'Wichtegkeet erklärt fir de Konter op Null zréckzesetzen.
Beispill Aufgab:
De Benotzer gitt zwou Zuelen: R an T. Drécken zwou Zeile vun "#" Zeechen. Déi éischt Zeil soll R Zeechen enthalen. Déi zweet Linn enthält T Stécker. Wann eng Zuel negativ ass, weist eng Fehlermeldung.
R=5, T=11#####
############
R=20, T=3#####################
###
R=-1, T=6De R Wäert muss net negativ sinn
R=6, T=-2T Wäert muss net negativ sinn
Natierlech huet dëse Problem och op d'mannst zwou Léisungen.
Wonsch
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;
}
Méiglech #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;
}
Den Ënnerscheed ass datt an der "méiglecher" Léisung eng zweet Variabel benotzt gouf fir déi zweet Zeil erauszekréien. Dir sollt insistéieren op déi selwecht Variabel fir béid Loops ze benotzen. Dës Begrenzung kann gerechtfäerdegt ginn duerch d'Tatsaach datt eng Léisung mat engem Konter fir zwee Zyklen eng Illustratioun vum Begrëff "Konter zrécksetzen". Dëse Begrëff ze verstoen ass néideg wann Dir déi folgend Probleemer léist. Als Kompromiss kënnt Dir béid Léisunge fir de Problem späicheren.
En typesche Problem mat der Benotzung vun enger Kontervariabel fir zwou Schleifen erschéngt esou:
R=5, T=11#####
######
D'Zuel vun den Zeechen an der zweeter Zeil entsprécht net dem Wäert vum T. Wann Dir Hëllef braucht mat dësem Problem, da musst Dir an d'Noten iwwer typesch Probleemer mat Loop kucken. Dëst ass Symptom #3. Et gëtt diagnostizéiert wann Dir e Konterwäertausgang direkt virum zweeten Zyklus bäidréit. Korrigéiert duerch Reset. Awer et ass besser dëst net direkt ze soen. De Student muss probéieren op d'mannst eng Hypothese ze formuléieren.
Et gëtt natierlech eng aner Léisung. Mee ech hunn et ni ënnert Studenten gesinn. Op der Bühn vum Zyklen ze studéieren, wäert d'Geschicht doriwwer d'Opmierksamkeet oflenken. Dir kënnt spéider drop zréckkommen wann Dir iwwer Stringfunktiounen léiert.
Méiglech #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));
Nächst erfuerderlech Aufgab:
Weist d'Zuelen vun 0 bis 9. All Zuel soll op seng eege Linn sinn. D'Zuel vun den Zifferen an enger Zeil (W) gëtt vun der Tastatur aginn.
W = 10
1
2
3
4
5
6
7
8
9
W = 100000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999
Wann e Schüler d'Technik beherrscht huet fir eng Variabel z'ersetzen, da wäert hien zimlech séier ëmgoen. E méigleche Problem wäert erëm d'Verännerlech zrécksetzen. Wann Dir d'Transformatioun net handhaben kënnt, heescht et datt Dir presséiert sidd an Dir musst méi einfach Problemer léisen.
Merci fir är Opmierksamkeet. Like an abonnéiert de Kanal.
PS Wann Dir Tippfeeler oder Feeler am Text fannt, soot mir w.e.g. Bescheed. Dëst kann gemaach ginn andeems Dir en Deel vum Text auswielt an "⌘ + Enter" op Mac dréckt, an "Ctrl / Enter" op klassesch Tastaturen, oder duerch privat Messagen. Wann dës Optiounen net verfügbar sinn, schreift iwwer Feeler an de Kommentaren. Merci!
Nëmme registréiert Benotzer kënnen un der Ëmfro deelhuelen. , wann ech glift.
Ëmfro fir Lieser ouni Karma
-
20,0%Ech léieren professionell, +12
-
10,0%Ech léieren professionell, -11
-
70,0%Ech léieren net, +17
-
0,0%Ech léieren net, -10
-
0,0%Aner 0
10 Benotzer hunn gestëmmt. 5 Benotzer hu sech enthalen.
Source: will.com