{"id":40208,"date":"2020-02-01T06:04:35","date_gmt":"2020-02-01T03:04:35","guid":{"rendered":"https:\/\/prohoster.info\/blog\/blog_prohoster\/kak-nauchit-preodolevat-trudnosti-a-zaodno-i-pisat-czikly"},"modified":"2020-02-01T06:04:35","modified_gmt":"2020-02-01T03:04:35","slug":"kak-nauchit-preodolevat-trudnosti-a-zaodno-i-pisat-czikly","status":"publish","type":"post","link":"https:\/\/prohoster.info\/en\/blog\/kak-nauchit-preodolevat-trudnosti-a-zaodno-i-pisat-czikly","title":{"rendered":"How to Teach Overcoming Challenges and Writing Loops","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

Although this article discusses one of the fundamental topics, it is written for experienced professionals. The goal is to highlight the misconceptions that beginners in programming often have. For practicing developers, these issues have long been resolved, forgotten, or simply unnoticed. This article may be useful if you ever need to assist someone with this topic. Comparisons will be made with material from various programming books by authors such as Schildt, Stroustrup, and Okulov.<\/p>\n

The topic of loops was chosen because it tends to filter out many people when learning programming.<\/p>\n

This methodology is designed for weaker students. Strong students typically do not get stuck on this topic, and there is no need to invent special methods for them. A secondary goal of the article is to transform this methodology from a class that 'works for all students, but only with one instructor' to a class that 'works for all students and all instructors.' I do not claim absolute originality. If you already use a similar methodology for teaching this topic, please share how your approach differs. If you decide to implement it, let me know how it turned out. If a similar method is described in any book, please provide the title.<\/p>\n

<\/a><\/noindex>
\nI have refined this methodology over four years, working individually with students of varying skill levels. In total, I have taught around fifty students and spent two thousand hours in lessons. Initially, students would get permanently stuck on this topic and drop out. After each student, the methodology and materials were adjusted. In the last year, students no longer get stuck on this topic, so I decided to share my findings.<\/p>\n

Why so many words? Loops are elementary!<\/h4>\n

\nAs I mentioned earlier, for practicing developers and strong students, the complexity of the concept of loops may be underestimated. For example, one can deliver a lengthy lecture, see nodding heads and intelligent eyes. However, when attempting to solve a task, confusion and inexplicable problems arise. After the lecture, students surely only have a partial understanding. The situation is exacerbated by the fact that students cannot articulate what exactly their misconceptions are.
\nOnce, I realized that students perceive my examples as hieroglyphs. That is, as indivisible pieces of text where they need to add some 'magical' letter for it to work.
\nSometimes I noticed that students think that solving a specific problem requires some other<\/i> construct that I just haven't explained yet. However, solving it only required a slight modification of the example.<\/p>\n

This led me to the idea that the main focus should be on the concept of refactoring repetitive code using loops. Once students grasp this idea, any syntax can be mastered through small exercises.<\/p>\n

Who and why I teach<\/h4>\n

\nSince there are no entrance exams, classes can have both strong and very weak students. More details about my students can be found in the article Portrait of evening course attendees<\/a><\/noindex>
\nI aimed for programming to be accessible to everyone who wants to learn it.
\nMy classes are individual, and each student pays for their lessons. It seems that students would optimize costs and demand the minimum. However, people attend face-to-face classes with a live teacher not just for knowledge, but for confidence in what they have learned, for a sense of progress, and for approval from an expert (the teacher). If students do not feel progress in their learning, they will leave. In general, classes can be structured so that students feel progress in the increase of familiar constructions. That is, we first study while in detail, then learn for, then do while, and we have our course ready for a thousand and one nights, where for two months we study only loops, leading to a student who dictates the standard library. However, to solve practical problems, one needs not only knowledge of the material but also independence in applying it and searching for new information. Therefore, for face-to-face courses, I believe it is correct to teach the minimum and encourage independent study of nuances and related topics. In the topic of loops, I consider the minimum to be the while construct. Understanding this principle allows one to independently master both for and do-while.<\/p>\n

To ensure that weaker students grasp the material, it is not enough to just describe the syntax. It's important to provide plenty of simple yet diverse tasks and to outline examples in more detail. Ultimately, the speed of understanding is limited by the student's ability to transform expressions and identify patterns. For more perceptive students, most tasks will be tedious. When working with them, it is acceptable not to insist on solving 100% of the problems. You can view my material on my GitHub<\/a><\/noindex>. However, the repository is more like a grimoires of a wizard \u2014 no one but me will understand where everything is, and if you fail the review, it might drive you mad.<\/p>\n

The methodology is focused on practice.<\/h4>\n

\nThe theory is explained through solving problems. In introductory programming classes, where branching and loops are studied, it is simply not feasible to conduct a useful lecture on a single topic for an entire hour. 15-20 minutes is enough to explain the concept. The main difficulties arise during the practical assignments.
\nNew teachers might cover operators, branching, loops, and arrays in a single lecture. However, students will face challenges in absorbing this information.
\nIt is essential not only to present the material but also to ensure that the audience understands it.<\/p>\n

The understanding of the topic is determined by how well the student performs in independent work.
\nIf a student manages to solve a problem on the topic without the teacher's help, then the topic has been mastered. To facilitate self-checking, each problem is accompanied by a table with test scenarios. The tasks follow a clear sequence. It is not recommended to skip tasks. If the current problem is too complex, moving to the next will be pointless as it will be even harder. To help the student tackle the current challenging task, several techniques are explained using the first task as an example. Essentially, the entire content of the topic boils down to techniques for overcoming difficulties. Loops are more of a side effect.<\/p>\n

The first task is always an example. The second task is slightly different and is performed 'independently' right after the first one under the teacher's supervision. All subsequent tasks aim to draw attention to various nuances that may cause misconceptions.<\/p>\n

The explanation of the example consists of a dialogue where the student needs to invoke back propagation and cross-validation to ensure they've grasped the material presented.<\/p>\n

I will be clich\u00e9 and state that the first example on the topic is very important. When there is extensive material for independent work, missing the first example can be corrected. However, if there is nothing besides the example, the student is unlikely to grasp the topic.<\/p>\n

While or for?<\/h4>\n

\nOne of the contentious issues is the choice of construction for the example: while or for. Once, a practicing developer friend of mine, who had no teaching experience, tried to convince me for an hour that the for loop is the simplest to understand. His arguments boiled down to 'everything is clear and organized within it.' However, the root cause of the difficulties for true beginners lies in the very idea of loops, not in their syntax. If a person doesn't understand this idea, they will struggle with syntax. Once the idea is understood, problems with code formatting disappear on their own.<\/p>\n

In my materials, the topic of loops follows the topic of branching. The external similarity of if and while allows for a direct analogy: 'when the condition in the header is true, the body executes.' The only difference with loops is that the body executes multiple times.<\/p>\n

My second argument is that while requires less formatting than for. Less formatting means fewer silly mistakes with missing commas and parentheses. Newcomers do not yet possess the attention to detail needed to automatically avoid syntax errors.
\nThe third argument is that in many good books, while is explained first.<\/p>\n

If a student can easily transform expressions, then we can mention for in passing. The student can then choose what they prefer. However, if transformations are challenging, it's better not to distract them. Let them first resolve everything using while. Once the topic of loops is mastered, solutions can be rewritten to practice transforming while into for.
\nPost-condition loops are quite a rare beast. I don't spend any time on them at all. If a student has grasped the concepts of identifying patterns and transforming expressions, they can figure it out without my help.<\/p>\n

When demonstrating the first example to strong students, I emphasize that in the first example, it is important to document not only the solution but also the entire chain of actions that led to the result. Lazy students may neglect the writing and only transfer the final algorithm to themselves. They need to be convinced that one day they will encounter a complex task. To solve it, they will need to go step by step as in this example. That is why it is important to document all stages. In subsequent tasks, only the final solution can be provided.<\/p>\n

The main idea of automation is that we delegate routine tasks to the computer to perform instead of a human. One of the basic techniques is writing loops. It is used when the program has to perform several identical repetitive actions consecutively.<\/p>\n

Explicit is better than implicit.<\/h4>\n

\nIt may seem like a good idea in the first task about loops to output the same phrase several times. For example:<\/p>\n

Hooray, it works!
\nHooray, it works!
\nHooray, it works!
\nHooray, it works!
\nHooray, it works!
\nHooray, it works!
\nHooray, it works!
\nHooray, it works!\n<\/p><\/blockquote>\n

\nThis option is poor because the output does not show the value of the counter. This is a problem for beginners. This issue should not be underestimated. Initially, this task was the first, while the task of outputting a series of numbers in ascending order was the second. Additional terms like \"loop N times\" and \"loop from A to B\" had to be introduced, which essentially mean the same thing. To avoid creating unnecessary entities, I decided to show only the example of outputting a series of numbers. Not many can learn to keep a counter in mind and model the program's behavior in their head without preparation. Some students encounter the concept of mental modeling for the first time precisely in the topic on loops.
\nAfter some practice, I give the task of repeating the same text as an independent exercise. If a visible counter is provided first and then an invisible one, students encounter fewer issues. Sometimes just the hint \"don't print the counter to the screen\" is enough.<\/p>\n

How is it explained by others?<\/h4>\n

\nIn most online educational materials, the syntax for loops is presented within the context of a 'lecture.' For example, on developer.mozilla.org (currently), the while loop is accompanied by several other constructs. However, only the constructs themselves are given in the form of templates. The results of their execution are described in words, while illustrations are absent. In my opinion, this style of presenting the topic diminishes the usefulness of such materials to zero. A student can rewrite the code and run it themselves, but a benchmark for comparison is still needed. How can one understand if the example has been rewritten correctly if there is nothing to compare the result against?
\nWhen only a template is provided without an example, it becomes even more challenging for the student. How can one know if the code fragments are arranged correctly in the template? One might try to write something<\/i>, and then run it. But if there is no benchmark for comparing the result, then running it won't help either.<\/p>\n

In the C++ course, the syntax of the loop is buried on the third page of lecture 4 on the topic of \u201coperators.\u201d When explaining the syntax of loops, special emphasis is placed on the term \u201coperator.\u201d The term is presented as a set of facts like \u201csymbol; this is an operator,\u201d \u201c{} is a compound operator,\u201d and \u201cthe body of the loop must be an operator.\u201d I dislike this approach because it tends to obscure important relationships behind a single term. Breaking down the source code into terms at this level is necessary for compiler developers to implement the language specification, but it does not help students at an initial stage. Beginners in programming rarely have the diligence to pay such close attention to terminology. Few people remember and understand new words at the first attempt. Almost nobody can correctly apply a term just learned. As a result, students make a lot of mistakes like \u201cI wrote while(a<7);{, but the program doesn\u2019t work.\u201d
\nIn my opinion, it's better to present the syntax of the construct initially with the brackets. The version without brackets should only be explained if the student has a specific question: 'why is it working here without brackets?'<\/p>\n

In Okulov's book \"Fundamentals of Programming\" from 2012, the introduction to loops begins with the for template, followed by recommendations for its use, and then immediately moves into an experimental section of the lesson. As I understand it, the book was written for that small group of highly capable students who rarely attend my classes.<\/p>\n

Popular books always present the results of code snippets. For instance, in Schildt's \"Java 8: The Complete Reference\" from 2015. First, a template is given, then a sample program, and right after that\u2014the output result.<\/p>\n

As an example, let's consider a while loop that performs a countdown, starting from 10, and outputs exactly 10 lines of \"ticks\":
\nAfter launching, this program outputs ten \"ticks\" as follows: <\/p>\n

\/\/\u041f\u0440\u043e\u0434\u0435\u043c\u043e\u043d\u0441\u0442\u0440\u0438\u0440\u043e\u0432\u0430\u0442\u044c \u043f\u0440\u0438\u043c\u0435\u043d\u0435\u043d\u0438\u0435 \u043e\u043f\u0435\u0440\u0430\u0442\u043e\u0440\u0430 \u0446\u0438\u043a\u043b\u0430 while\nclass While {\n    public static void main(String args []) {\n        int n = 10;\n        while (n > 0) {\n            System.out.println("\u0442\u0430\u043a\u0442 " + n);\n            n--;\n        }\n    }\n}<\/code><\/pre>\n
\nThis approach of presenting a template, a sample program, and the results of that program is also used in the book \"JavaScript for Kids\" and in the JavaScript course on w3schools.com. The webpage format even allows this example to be interactive.
\nstep 10
\nstep 9
\nstep 8
\nstep 7
\nstep 6
\nstep 5
\nstep 4
\nstep 3
\nstep 2
\nstep 1<\/code><\/p><\/blockquote>\n
\nIn Bjarne Stroustrup's book \"Principles and Practice Using C++\" from 2016, the author goes even further. First, he explains what the expected result should be, and only after that\u2014shows the program text. Moreover, they take not just a random program as an example, but provide a historical overview. This helps to draw attention to it: \"Look, this is not just some useless text. You see something significant.\"<\/p>\n
As an example of iteration, let's consider the first program executed on a stored-program machine (EDSAC). It was written by David Wheeler in the Computer Laboratory of Cambridge University (Cambridge University, England) on May 6, 1949. This program calculates and prints a simple list of squares.<\/p>\n
Here, each line contains a number followed by a tab character (\u2018t\u2019) and the square of that number. The version of this program in C++ looks like this:
\n0 0
\n1 1
\n2 4
\n3 9
\n4 16
\n...
\n98 9604
\n99 9801<\/code>
\nHere, each line contains a number, followed by a tab character (\u2018t\u2019) and the square of that number. The version of this program in C++ looks like this:<\/p>\n
\/\/\u0412\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u043c \u0438 \u0440\u0430\u0441\u043f\u0435\u0447\u0430\u0442\u044b\u0432\u0430\u0435\u043c \u0442\u0430\u0431\u043b\u0438\u0446\u0443 \u043a\u0432\u0430\u0434\u0440\u0430\u0442\u043e\u0432 \u0447\u0438\u0441\u0435\u043b 0-99\nint main()\n{\n    int i = 0; \/\/ \u041d\u0430\u0447\u0438\u043d\u0430\u0435\u043c \u0441 \u043d\u0443\u043b\u044f\n    while(i < 100){\n        cout << i << 't' << square(i) << 'n';\n        ++i;\n    }\n}<\/code><\/pre>\n<\/blockquote>\n
\nAs I explain myselfTranslation<\/a><\/noindex>) emphasizes that it respects the intelligence of its students. The ability to identify a pattern from several examples is considered a manifestation of such intelligence.<\/p>\n
How I explain it myself<\/h4>\n
\nStroustrup's approach: describe the outcome, then solve the problem, and finally conduct an independent analysis by the student\u2014seems to be the most thoughtful. Therefore, I decided to base this on his method, but to discuss it using a less historical example\u2014the task of generating a 'table of contents'. It creates a recognizable anchor, so I can later say, 'remember the task about the table of contents,' and the students will recall it specifically. In my example, I have tried to address two of the most common misconceptions. I will elaborate on them further.<\/p>\n
In this task, we become familiar with techniques for solving complex problems. The initial solution should be primitive and straightforward. Then we can think about how to improve this solution.
\nIntroduction
\nChapter 1
\nChapter 2
\nChapter 3
\nChapter 4
\nChapter 5
\nChapter 6
\nChapter 7
\nConclusion<\/code><\/p><\/blockquote>\n
\nIn my observations, the approach of \u201ctemplate-example-result\u201d in various combinations still leads to students perceiving the loop as an hieroglyph. This was evident in their misunderstanding of why a condition should be written there, how to choose between i++ and i\u2014, and other seemingly obvious matters. To avoid such misconceptions, the discussion about loops should emphasize the meaning of repeating identical actions and only then \u2014 how to format them using the construction. Therefore, before presenting the syntax of the loop, the problem should be addressed \u201chead-on.\u201d A primitive solution to the table of contents problem looks like this:<\/p>\n
Console.WriteLine(\"Introduction\");\nConsole.WriteLine(\"Chapter 1\");\nConsole.WriteLine(\"Chapter 2\");\nConsole.WriteLine(\"Chapter 3\");\nConsole.WriteLine(\"Chapter 4\");\nConsole.WriteLine(\"Chapter 5\");\nConsole.WriteLine(\"Chapter 6\");\nConsole.WriteLine(\"Chapter 7\");\nConsole.WriteLine(\"Conclusion\");\n<\/code><\/pre>\n
\nHow can it be improved?
\nReplace repetitive actions with a loop.
\nWhat actions are repeated consecutively without changes?
\nThere are none in this fragment. However, the commands outputting the word 'Chapter' with a number are very similar to each other.
\nTherefore, the next step is to find the difference between the fragments. This task makes it obvious, but later, there will be not just single commands repeating, but blocks of code consisting of 5 lines or more. One will have to search not just in the list of commands, but in branching or loop constructions.
\nIn this example, the difference between the commands is in the number after the word 'Chapter.'
\nOnce the difference is found, one must understand the pattern of change. Is the differing fragment a number? Does it constantly increase or decrease? How does the value of the number change between two commands in close proximity?
\nIn this example, the number after the word \"Chapter\" increases by 1. The difference has been found, and a pattern has been identified. Now, we can replace the differing fragment with a variable.
\nYou need to declare such a variable before the first of the repeating fragments. This variable is usually called i or j, or something more descriptive. Its initial value should be equal to the first value displayed on the screen. In this example, the first value is 1. 
\nWhat initial value should be taken for outputting the series of numbers \"100, 101, 102, 103, 104, 105\"?
\nIn this series, the first number is 100.
\nAfter each output command, the variable's value should be increased by 1. This unit is the step of change.
\nWhat step will be in the series of numbers \"100, 102, 104, 106\"?
\nIn this series, the step is 2.
\nAfter replacing the differing fragment with a variable, the code will look like this:<\/p>\n
Console.WriteLine(\"Introduction\");\nint i;\ni = 0;\nConsole.WriteLine(\"Chapter \" + i);\ni = i + 1;\nConsole.WriteLine(\"Chapter \" + i);\ni = i + 1;\nConsole.WriteLine(\"Chapter \" + i);\ni = i + 1;\nConsole.WriteLine(\"Chapter \" + i);\ni = i + 1;\nConsole.WriteLine(\"Chapter \" + i);\ni = i + 1;\nConsole.WriteLine(\"Chapter \" + i);\ni = i + 1;\nConsole.WriteLine(\"Chapter \" + i);\ni = i + 1;\nConsole.WriteLine(\"Conclusion\");\n<\/code><\/pre>\n
\nAfter applying the technique of \"expressing the pattern as a variable\", the code results in several groups of identical actions that follow one another. Now, repeating actions can be replaced with a loop.<\/p>\n
The sequence for solving a problem where loops need to be used consists of the following stages:<\/p>\n
    \n
  1. Solve \"brute force\" with multiple individual commands<\/li>\n
  2. Find the pattern<\/li>\n
  3. Express the pattern as a variable<\/li>\n
  4. Format it as a loop<\/li>\n<\/ol>\n
    Next, new terms are introduced so that the student does not find themselves in a situation of \"I understand everything, but I can't say it\":
    \n \u2014 counter \u2014 always a variable that is needed to track the number of steps in the loop. Usually an integer that is compared to a limit.
    \n \u2014 counter step \u2014 a description of how the counter changes.
    \n \u2014 limit \u2014 a number or variable with which the counter is compared to ensure the algorithm is finite. The counter's value changes to approach the limit.
    \n \u2014 loop body \u2014 a set of commands that will be repeated. When it is said \"the command is written inside the loop\", it refers specifically to the body.
    \n \u2014 loop iteration \u2014 a single execution of the loop body.
    \n \u2014 loop condition \u2014 a logical expression that determines whether another iteration will be executed. (This might be confused with branching constructs)
    \nBe prepared for the fact that at first, students may use terms incorrectly. This applies to both strong and weak students. Establishing a common language is an art in itself. To put it briefly: set the task 'highlight the code fragment with <term>' and use these terms correctly in conversation yourself.
    \nAfter conversion with a loop, the fragment is:<\/p>\n
    Console.WriteLine("Introduction");\nint i = 0;\nwhile (i < 7) {\n    Console.WriteLine("Chapter " + i);\n    i = i + 1;\n}\nConsole.WriteLine("Conclusion");<\/code><\/pre>\n
    The main misconception<\/h4>\n
    \nOne popular misconception among students is that they place actions inside a loop construct that should only be executed once. For instance, like this:<\/p>\n
    ;\nint i = 0;\nwhile (i < 7) {\n    Console.WriteLine("Introduction");\n    Console.WriteLine("Chapter " + i);\n    i = i + 1;\n    Console.WriteLine("Conclusion");\n}\n<\/code><\/pre>\n
    \nStudents frequently encounter this problem, both at the beginning and in more complex tasks.
    \nThe key hint in this case is:<\/p>\n
    How many times should the command be repeated: once or many?\n<\/p><\/blockquote>\n
    \nThe output commands for the words 'Introduction' and 'Conclusion', as well as the declaration and initialization of the variable i, do not resemble other repetitive actions. They are executed only once, so they should be written outside the loop body.<\/p>\n
    All three stages of the solution should remain in the code to refer to them in case of difficulties. The first two options can be commented out so they don't interfere.
    \nThe student's attention should be drawn to the following facts:
    \n \u2014 In the loop condition, the counter is usually compared with a limit. The counter may change within the loop body, while the limit may not. To violate this rule requires sound reasoning.
    \n \u2014 The commands for outputting the words 'Introduction' and 'Conclusion' are outside the loop body. We need to execute them once. 'Introduction' \u2014 before repeating actions, 'Conclusion' \u2014 after.
    \nIn the process of reinforcing this topic, mastering the next ones, and dealing with difficulties, it is helpful even for strong students to ask the question: 'How many times should this action be performed? Once or many?'.<\/p>\n
    Development of additional skills<\/h4>\n
    \nWhile studying loops, students also practice the skill of diagnosing and solving problems. To perform diagnostics, a student needs to envision the desired outcome and compare it with the actual result. The actions to correct any differences depend on this comparison.
    \nSince students at this stage still have a poor understanding of the 'desired' outcome, they can rely on test data. Typically, no one at this stage understands what might go wrong and how to tackle it. Therefore, I provide a written description of typical problems and several solutions. Choosing the most appropriate one is the student's task.
    \nThe written record is needed to ask questions like 'Was the expected result achieved?', 'What situation occurred?', 'Did the applied solution help?'.<\/p>\n
      \n
    1. The number of actions is either one less or more than expected. Solutions include:
      \n \u2014 increasing the initial value of the counter by 1.
      \n \u2014 replacing the strict comparison operator (< or >) with a non-strict one (<= or >=).
      \n \u2014 changing the limit value by 1.<\/li>\n
    2. Actions within the loop are executed without stopping, infinitely. Solutions include:
      \n \u2014 adding a counter modification command if it is missing.
      \n \u2014 correcting the counter modification command so its value approaches the limit.
      \n \u2014 removing the limit modification command if it exists within the loop.<\/li>\n
    3. The number of actions in the loop is more than 1 less or more than expected. An action in the loop did not run at all. First, it's essential to determine the actual variable values right before entering the loop. Solutions include:
      \n \u2014 changing the initial limit value.
      \n \u2014 changing the initial value of the counter.<\/li>\n<\/ol>\n
      \nUsually, problem 3 is related to using the wrong variable or failing to reset the counter.<\/p>\n
      After this explanation, students may still have various misconceptions about how loops work.
      \nTo dispel the most common ones, I provide tasks:<\/p>\n
        \n
      1. Where the limit, initial counter value, or step of the counter is input by the user.<\/li>\n
      2. Where the counter value needs to be used in some arithmetic expression. Preferably with the counter in a sub-expression or in the denominator, so the difference is nonlinear.<\/li>\n
      3. In which the counter value is not displayed on the screen during the loop process. For example, outputting the required number of identical text fragments or drawing a figure using turtle graphics.<\/li>\n
      4. In which some repeating actions need to be performed first, and then others.<\/li>\n
      5. In which other actions need to be performed before and after the repetitions.<\/li>\n<\/ol>\n
        \nFor each task, you need to provide test data and the expected result.<\/p>\n
        To understand how quickly you can proceed, you need to read the conditions of these tasks and ask: \"How do they differ from the example?\", \"What needs to be changed in the example to solve them?\" If the student answers thoughtfully, then let them solve at least one in class, while the others can be done at home independently. If the solution is successful, then you can start explaining conditions within loops.
        \nIf there are difficulties with independent solution, then everything needs to be worked out in class. To ensure that the problem-solving does not resemble drawing an owl, I recommend starting by solving the problem non-generally. That is, in such a way that the solution passes the first test without using a loop structure. Then you can apply transformations to achieve generality in the solution.<\/p>\n
        Loops and branches<\/h4>\n
        \nIn my opinion, it is useful to give the topic \"loops within branches\" separately. This way, the difference between multiple condition checks and a single condition check will be clearer.
        \nTasks for consolidation will be about outputting numbers from A to B, which are entered by the user:
        \n \u2014 always in ascending order.
        \n \u2014 in ascending or descending order depending on the values of A and B.<\/p>\n
        The topic of \"branching within loops\" should only be introduced after the student has mastered the techniques of: \"replacing patterns with variables\" and \"substituting repeated actions with loops.\"
        \nThe main reason for using branches within loops is anomalies in the pattern. In the middle, it breaks depending on the initial data.
        \nFor students capable of finding solutions by combining simple techniques, it is enough to say, \"Branches can be written inside loops\" and give a task \"for example\" fully for independent solution.
        \nExample task:<\/p>\n
        The user inputs a number X. Print the numbers from 0 to 9 in a column and place the sign ‘+’ next to the number that is equal to X.<\/p><\/blockquote>\n
        \nIf 0 was entered<\/b>0+
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        If 6 was entered<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6+
        \n7
        \n8
        \n9<\/p>\n
        If 9 was entered<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9+<\/p>\n
        If 777 was entered<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        If a brief explanation is insufficient to write with a loop, then we need to achieve a universal solution to the same problem without a loop.
        \nOne of two options will result:
        \nDesired<\/b><\/p>\n
        string temp;\ntemp = Console.ReadLine();\nint x;\nx = int.Parse(temp);\nif (x==0) {\n    Console.WriteLine(0 + "+");\n} else {\n    Console.WriteLine(0);\n}\nif (x==1) {\n    Console.WriteLine(1 + "+");\n} else {\n    Console.WriteLine(1);\n}\nif (x==2) {\n    Console.WriteLine(2 + "+");\n} else {\n    Console.WriteLine(2);\n}\nif (x==3) {\n    Console.WriteLine(3 + "+");\n} else {\n    Console.WriteLine(3);\n}\nif (x==4) {\n    Console.WriteLine(4 + "+");\n} else {\n    Console.WriteLine(4);\n}\nif (x==5) {\n    Console.WriteLine(5 + "+");\n} else {\n    Console.WriteLine(5);\n}\nif (x==6) {\n    Console.WriteLine(6 + "+");\n} else {\n    Console.WriteLine(6);\n}\nif (x==7) {\n    Console.WriteLine(7 + "+");\n} else {\n    Console.WriteLine(7);\n}\nif (x==8) {\n    Console.WriteLine(8 + "+");\n} else {\n    Console.WriteLine(8);\n}\nif (x==9) {\n    Console.WriteLine(9 + "+");\n} else {\n    Console.WriteLine(9);\n}\n<\/code><\/pre>\n
        Possible<\/b><\/p>\n
        string temp;\ntemp = Console.ReadLine();\nint x;\nx = int.Parse(temp);\nif (x==0) {\n    Console.WriteLine("0+n1n2n3n4n5n6n7n8n9");\n}\nif (x==1) {\n    Console.WriteLine("0n1+n2n3n4n5n6n7n8n9");\n}\nif (x==2) {\n    Console.WriteLine("0n1n2+n3n4n5n6n7n8n9");\n}\nif (x==3) {\n    Console.WriteLine("0n1n2n3+n4n5n6n7n8n9");\n}\nif (x==4) {\n    Console.WriteLine("0n1n2n3n4+n5n6n7n8n9");\n}\nif (x==5) {\n    Console.WriteLine("0n1n2n3n4n5+n6n7n8n9");\n}\nif (x==6) {\n    Console.WriteLine("0n1n2n3n4n5n6+n7n8n9");\n}\nif (x==7) {\n    Console.WriteLine("0n1n2n3n4n5n6n7+n8n9");\n}\nif (x==8) {\n    Console.WriteLine("0n1n2n3n4n5n6n7n8+n9");\n}\nif (x==9) {\n    Console.WriteLine("0n1n2n3n4n5n6n7n8n9+");\n}\n<\/code><\/pre>\n
        I give a similar task in advance, during the study of branching.
        \nIf the student has arrived at a 'possible' option, then it's important to explain that there can be multiple solutions to the same problem. However, they differ in their resilience to changing requirements. Ask the question: 'How many places in the code will need to be fixed if we have to add one more number?' In the 'possible' option, an additional branch will need to be added and the new number written in 10 different places. In the 'desired' option, only one additional branch needs to be added.
        \nSet the task to reproduce the 'desired' option, then find the pattern in the code, perform the variable replacement, and write a loop.
        \nIf you have an idea on how to solve this task without a loop in some other way, please write it in the comments.<\/p>\n
        Loops within loops<\/h4>\n
        \nIn this topic, it's important to note that:
        \n \u2014 counters for the inner and outer loops must be different variables.
        \n \u2014 the counter for the inner loop needs to be reset multiple times (i.e., in the body of the outer loop).
        \n In tasks involving text output, you cannot start by printing one character in several lines and then the second. You need to output all the characters of the first line first, then all the characters of the second line, and so on.<\/p>\n
        It's best to start the explanation of the topic on loops within loops by explaining the importance of resetting the counter.
        \nExample task:<\/p>\n
        The user inputs two numbers: R and T. Output two lines of the character "#". The first line should have R characters. The second line should have T characters. If any number is negative, output an error message.<\/p><\/blockquote>\n
        \nR=5, T=11<\/b>#####
        \n###########<\/p>\n
        R=20, T=3<\/b>####################
        \n###<\/p>\n
        R=-1, T=6<\/b>The value of R must be non-negative.<\/p>\n
        R=6, T=-2<\/b>The value of T must be non-negative.<\/p>\n
        It is clear that this task also has at least two possible solutions.
        \nDesired<\/b><\/p>\n
        string temp;\nint R;\nint T;\ntemp = Console.ReadLine();\nR = int.Parse(temp);\ntemp = Console.ReadLine();\nT = int.Parse(temp);\nint i = 0;\nwhile (i < R)\n{\n    Console.Write("#");\n    i = i + 1;\n}\nConsole.WriteLine();\ni = 0;\nwhile (i < T)\n{\n    Console.Write("#");\n    i = i + 1;\n}\n<\/code><\/pre>\n
        Option #1<\/b><\/p>\n
        string temp;\nint R;\nint T;\ntemp = Console.ReadLine();\nR = int.Parse(temp);\ntemp = Console.ReadLine();\nT = int.Parse(temp);\nint i = 0;\nwhile (i < R)\n{\n    Console.Write("#");\n    i = i + 1;\n}\nConsole.WriteLine();\nint j = 0;\nj = 0;\nwhile (j < T)\n{\n    Console.Write("#");\n    j = j + 1;\n}\n<\/code><\/pre>\n
        The difference is that in the \"possible\" solution for outputting the second line, a second variable was used. It is necessary to insist on using the same variable for both loops. This restriction can be justified by the fact that a solution with one counter for two loops will illustrate the term \"resetting the counter.\" Understanding this term is essential when solving subsequent problems. As a compromise, both solutions to the task can be retained.<\/p>\n
        A typical problem with using one counter variable for two loops manifests itself like this:
        \nR=5, T=11<\/b>#####
        \n######<\/p>\n
        The number of characters in the second line does not correspond to the value of T. If help is needed with this problem, one should \"point out\" the notes on common problems with loops. This is symptom #3. It can be diagnosed by adding the output of the counter value right before the second loop. It is fixed by resetting. However, it is better not to reveal this immediately. The student should try to formulate at least one hypothesis.<\/p>\n
        Of course, there is another option for solving it. But I have never seen it from students. At the stage of learning loops, discussing it would distract attention. It can be returned to later when studying functions that work with strings.
        \nOption #2<\/b><\/p>\n
        string temp;\nint R;\nint T;\ntemp = Console.ReadLine();\nR = int.Parse(temp);\ntemp = Console.ReadLine();\nT = int.Parse(temp);\nConsole.WriteLine(new String('#', R));\nConsole.WriteLine(new String('#', T));\n<\/code><\/pre>\n
        \nThe next mandatory task:<\/p>\n
        Display the numbers from 0 to 9 on the screen. Each number should be on a new line. The number of digits per line (W) is input via the keyboard.<\/p><\/blockquote>\n
        \nW=1<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        W=10<\/b>0000000000
        \n1111111111
        \n2222222222
        \n3333333333
        \n4444444444
        \n5555555555
        \n6666666666
        \n7777777777
        \n8888888888
        \n9999999999<\/code><\/p>\n
        If the student has mastered the variable replacement technique, they will manage quite quickly. The possible issue again will be the variable reset. If they are struggling with the conversion, it means they rushed, and should work on simpler tasks.<\/p>\n
        Thank you for your attention. Please like and subscribe to the channel.<\/p>\n
        P.S. If you find typos or errors in the text, please let me know. You can do this by highlighting part of the text and pressing '\u2318 + Enter' on Mac or 'Ctrl \/ Enter' on classic keyboards, or through personal messages. If these options are unavailable, please report errors in the comments. Thank you!<\/p>\n
        Only registered users can participate in the survey. Please log in<\/a><\/noindex>, please.<\/p>\n
        Survey for readers without karma<\/h2>\n